v0.0.7

They're not good they're shit I lied to you

.gitignore

@@ -2,6 +2,7 @@
 **/*.swp
 
 run/
+autotest/
 
 # Gradle
 build/

.travis.yml

@@ -6,9 +6,7 @@ services:
 - docker
 
 install:
-- sudo apt-get update
-- sudo apt-get install jshon
-- docker build -t cabaletta/baritone .
+- travis_retry docker build -t cabaletta/baritone .
 
 script:
 - docker run --name baritone cabaletta/baritone /bin/sh -c "set -e; /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -screen 0 128x128x24 -ac +extension GLX +render; sh scripts/build.sh; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runClient"

Dockerfile

@@ -15,10 +15,10 @@ RUN apt install -qq --force-yes mesa-utils libgl1-mesa-glx libxcursor1 libxrandr
 
 RUN apt install -qq --force-yes unzip wget
 
-ADD . /code
-
-RUN echo "\nrunClient {\nargs \"--width\",\"128\",\"--height\",\"128\"\n}" >> /code/build.gradle
+COPY . /code
 
+# this .deb is specially patched to support lwjgl
+# source: https://github.com/tectonicus/tectonicus/issues/60#issuecomment-154239173
 RUN dpkg -i /code/scripts/xvfb_1.16.4-1_amd64.deb
 
 WORKDIR /code

FEATURES.md

@@ -10,16 +10,19 @@
 - **Falling blocks** Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore).
 - **Avoiding dangerous blocks** Obviously, it knows not to walk through fire or on magma, not to corner over lava (that deals some damage), not to break any blocks touching a liquid (it might drown), etc.
 - **Parkour** Sprint jumping over 1, 2, or 3 block gaps
+- **Parkour place** Sprint jumping over a 3 block gap and placing the block to land on while executing the jump. It's really cool.
 
 # Pathing method
-Baritone uses a modified version of A*. 
+Baritone uses A*, with some modifications: 
 
-- **Incremental cost backoff** Since most of the time Baritone only knows the terrain up to the render distance, it can't calculate a full path to the goal. Therefore it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a <a href="https://docs.google.com/document/d/1WVHHXKXFdCR1Oz__KtK8sFqyvSwJN_H4lftkHFgmzlc/edit">write-up</a> that still applies. In essence, it keeps track of the best node by various increasing coefficients, then picks the node with the least coefficient that goes at least 5 blocks from the starting position.
+- **Segmented calculation** Traditional A* calculates until the most promising node is in the goal, however in the environment of Minecraft with a limited render distance, we don't know the environment all the way to our goal. Baritone has three possible ways for path calculation to end: finding a path all the way to the goal, running out of time, or getting to the render distance. In the latter two scenarios, the selection of which segment to actually execute falls to the next item (incremental cost backoff). Whenever the path calculation thread finds that the best / most promising node is at the edge of loaded chunks, it increments a counter. If this happens more than 50 times (configurable), path calculation exits early. This happens with very low render distances. Otherwise, calculation continues until the timeout is hit (also configurable) or we find a path all the way to the goal.
+- **Incremental cost backoff** When path calculation exits early without getting all the way to the goal, Baritone it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a <a href="https://docs.google.com/document/d/1WVHHXKXFdCR1Oz__KtK8sFqyvSwJN_H4lftkHFgmzlc/edit">write-up</a> that still applies. In essence, it keeps track of the best node by various increasing coefficients, then picks the node with the least coefficient that goes at least 5 blocks from the starting position.
 - **Minimum improvement repropagation** The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get.
-- **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. 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 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/main/java/baritone/Settings.java">here</a>.
+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.
 
 # Goals
@@ -30,6 +33,7 @@ The pathing goal can be set to any of these options:
 - **GoalTwoBlocks** a block position that the player should stand in, either at foot or eye level
 - **GoalGetToBlock** a block position that the player should stand adjacent to, below, or on top of
 - **GoalNear** a block position that the player should get within a certain radius of, used for following entities
+- **GoalAxis** a block position on an axis or diagonal axis (so x=0, z=0, or x=z), and y=120 (configurable)
 
 And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a `GoalComposite` of `GoalTwoBlocks`s for every diamond ore location it knows of.
 
@@ -38,7 +42,6 @@ And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one o
 Things it doesn't have yet
 - Trapdoors
 - Sprint jumping in a 1x2 corridor
-- Parkour (jumping over gaps of any length) [IN PROGRESS]
 
 See <a href="https://github.com/cabaletta/baritone/issues">issues</a> for more.
 

IMPACT.md

@@ -11,9 +11,14 @@ There are some basic steps to getting Baritone setup with Impact.
 ## Acquiring a build of Baritone
 There are 3 methods of acquiring a build of Baritone (While it is still in development)
 
-### Official Build (Not always up to date)
-Download the "official" jar (as of commit <a href="https://github.com/cabaletta/baritone/commit/61cf103df451a5aafa6bfbe5ed089043212f0b42">61cf103</a>,
-built on September 24) from <a href="https://www.dropbox.com/s/imc6xwwpwsh3i0y/baritone-1.0.0.jar?dl=0">here</a>.
+### 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`.
+
+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 for `baritone-unoptimized-X.Y.Z.jar` is deterministic, and you can verify Travis did it properly by running `scripts/build.sh` yourself and comparing the shasum. The proguarded files (api and standalone) aren't yet reproducible, because proguard annoyingly includes the current timestamp into the final jar.
 
 ### Building Baritone yourself
 There are a few steps to this

README.md

@@ -3,12 +3,7 @@
 [![License](https://img.shields.io/github/license/cabaletta/baritone.svg)](LICENSE)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/7150d8ccf6094057b1782aa7a8f92d7d)](https://www.codacy.com/app/leijurv/baritone?utm_source=github.com&utm_medium=referral&utm_content=cabaletta/baritone&utm_campaign=Badge_Grade)
 
-<!---
-Plutie's jenkins is dead right now, so here's the old badge that was used:
-[![Build Status](https://plutiejenkins.leijurv.com/job/baritone/badge/icon)](https://plutiejenkins.leijurv.com/job/baritone/lastSuccessfulBuild/)
---->
-
-Unofficial Jenkins: [![Jenkins Status](https://img.shields.io/badge/jenkins-offline-red.svg)]()
+Unofficial Jenkins: [![Build Status](https://plutiejenkins.leijurv.com/job/baritone/badge/icon)](https://plutiejenkins.leijurv.com/job/baritone/lastSuccessfulBuild/)
 
 A Minecraft pathfinder bot. This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. Baritone focuses on reliability and particularly performance (it's over [29x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
@@ -73,4 +68,4 @@ Magic. (Hours of [Leijurv](https://github.com/leijurv) enduring excruciating pai
 
 ## Why is it called Baritone?
 
-It's named for FitMC's deep sultry voice. 
+It's named for FitMC's deep sultry voice. 

build.gradle

@@ -1,3 +1,7 @@
+import java.util.jar.JarEntry
+import java.util.jar.JarFile
+import java.util.jar.JarOutputStream
+
 /*
  * This file is part of Baritone.
  *
@@ -16,7 +20,7 @@
  */
 
 group 'baritone'
-version '0.0.3'
+version '0.0.7'
 
 buildscript {
     repositories {
@@ -88,4 +92,36 @@ mixin {
 
 jar {
     from sourceSets.launch.output, sourceSets.api.output
+    preserveFileTimestamps = false
+    reproducibleFileOrder = true
+}
+
+build {
+    // while "jar" supports preserveFileTimestamps false
+    // reobfJar doesn't, it just sets all the last modified times to that instant where it runs the reobfuscator
+    // so we have to set all those last modified times back to zero
+    doLast {
+        File jarFile = new File("build/libs/baritone-" + version + ".jar")
+        JarFile jf = new JarFile(jarFile)
+        JarOutputStream jos = new JarOutputStream(new FileOutputStream(new File("temp.jar")))
+        jf.entries().unique { it.name }.sort { it.name }.each {
+            if (it.name != "META-INF/fml_cache_annotation.json" && it.name != "META-INF/fml_cache_class_versions.json") {
+                JarEntry clone = new JarEntry(it)
+                clone.time = 0
+                jos.putNextEntry(clone)
+                copy(jf.getInputStream(it), jos)
+            }
+        }
+        jos.finish()
+        jf.close()
+        file("temp.jar").renameTo(jarFile)
+    }
+}
+
+void copy(InputStream is, OutputStream os) {
+    byte[] buffer = new byte[1024]
+    int len = 0
+    while ((len = is.read(buffer)) != -1) {
+        os.write(buffer, 0, len)
+    }
 }

scripts/build.sh

@@ -10,9 +10,11 @@ cat ../../scripts/proguard.pro | grep -v "this is the rt jar" | grep -v "\-injar
 echo "-libraryjars '$(java -verbose 2>/dev/null | sed -ne '1 s/\[Opened \(.*\)\]/\1/p')'" >> api.pro # insert correct rt.jar location
 tail api.pro # debug, print out what the previous two commands generated
 cat api.pro | grep -v "\-keep class baritone.api" > standalone.pro # standalone doesn't keep baritone api
-wget -nv https://www.dropbox.com/s/zmc2l3jnwdvzvak/tempLibraries.zip?dl=1 # i'm sorry
-mv tempLibraries.zip?dl=1 tempLibraries.zip
-unzip tempLibraries.zip
+
+#instead of downloading these jars from my dropbox in a zip, just assume gradle's already got them for us
+mkdir -p tempLibraries
+cat ../../scripts/proguard.pro | grep tempLibraries | grep .jar | cut -d "/" -f 2- | cut -d "'" -f -1 | xargs -n1 -I{} bash -c "find ~/.gradle -name {}" | tee /dev/stderr | xargs -n1 -I{} cp {} tempLibraries
+
 mkdir ../../dist
 java -jar ../../proguard6.0.3/lib/proguard.jar @api.pro
 mv Obfuscated/baritone-$VERSION.jar ../../dist/baritone-api-$VERSION.jar

scripts/proguard.pro

@@ -1,4 +1,4 @@
--injars baritone-0.0.2.jar
+-injars baritone-0.0.7.jar
 -outjars Obfuscated
 
 
@@ -12,14 +12,12 @@
 -overloadaggressively
 -dontusemixedcaseclassnames
 
-# instead of obfing to a, b, c, obf to baritone.a, baritone.b, baritone.c so as to not conflict with minecraft's obfd classes
+# instead of renaming to a, b, c, rename to baritone.a, baritone.b, baritone.c so as to not conflict with minecraft's obfd classes
 -flattenpackagehierarchy
 -repackageclasses 'baritone'
 
-#-keep class baritone.behavior.** { *; }
 -keep class baritone.api.** { *; }
-#-keep class baritone.* { *; }
-#-keep class baritone.pathing.goals.** { *; }
+-keep class baritone.BaritoneProvider
 
 # setting names are reflected from field names, so keep field names
 -keepclassmembers class baritone.api.Settings {
@@ -32,7 +30,7 @@
 # copy all necessary libraries into tempLibraries to build
 -libraryjars '/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/rt.jar' # this is the rt jar
 
--libraryjars 'tempLibraries/1.12.2.jar'
+-libraryjars 'tempLibraries/minecraft-1.12.2.jar'
 
 -libraryjars 'tempLibraries/authlib-1.5.25.jar'
 -libraryjars 'tempLibraries/codecjorbis-20101023.jar'
@@ -48,22 +46,25 @@
 -libraryjars 'tempLibraries/httpclient-4.3.3.jar'
 -libraryjars 'tempLibraries/httpcore-4.3.2.jar'
 -libraryjars 'tempLibraries/icu4j-core-mojang-51.2.jar'
--libraryjars 'tempLibraries/java-objc-bridge-1.0.0-natives-osx.jar'
 -libraryjars 'tempLibraries/java-objc-bridge-1.0.0.jar'
 -libraryjars 'tempLibraries/jinput-2.0.5.jar'
--libraryjars 'tempLibraries/jinput-platform-2.0.5-natives-osx.jar'
 -libraryjars 'tempLibraries/jna-4.4.0.jar'
 -libraryjars 'tempLibraries/jopt-simple-5.0.3.jar'
--libraryjars 'tempLibraries/jsr305-3.0.1-sources.jar'
 -libraryjars 'tempLibraries/jsr305-3.0.1.jar'
 -libraryjars 'tempLibraries/jutils-1.0.0.jar'
 -libraryjars 'tempLibraries/libraryjavasound-20101123.jar'
 -libraryjars 'tempLibraries/librarylwjglopenal-20100824.jar'
 -libraryjars 'tempLibraries/log4j-api-2.8.1.jar'
 -libraryjars 'tempLibraries/log4j-core-2.8.1.jar'
--libraryjars 'tempLibraries/lwjgl-2.9.2-nightly-20140822.jar'
--libraryjars 'tempLibraries/lwjgl-platform-2.9.2-nightly-20140822-natives-osx.jar'
--libraryjars 'tempLibraries/lwjgl_util-2.9.2-nightly-20140822.jar'
+
+# linux / travis
+-libraryjars 'tempLibraries/lwjgl-2.9.4-nightly-20150209.jar'
+-libraryjars 'tempLibraries/lwjgl_util-2.9.4-nightly-20150209.jar'
+
+# mac
+#-libraryjars 'tempLibraries/lwjgl_util-2.9.2-nightly-20140822.jar'
+#-libraryjars 'tempLibraries/lwjgl-2.9.2-nightly-20140822.jar'
+
 -libraryjars 'tempLibraries/netty-all-4.1.9.Final.jar'
 -libraryjars 'tempLibraries/oshi-core-1.1.jar'
 -libraryjars 'tempLibraries/patchy-1.1.jar'
@@ -72,8 +73,8 @@
 -libraryjars 'tempLibraries/soundsystem-20120107.jar'
 -libraryjars 'tempLibraries/text2speech-1.10.3.jar'
 
--libraryjars 'tempLibraries/mixin-0.7.8-SNAPSHOT.jar'
--libraryjars 'tempLibraries/launchwrapper-1.12.jar'
+-libraryjars 'tempLibraries/mixin-0.7.11-SNAPSHOT.jar'
+-libraryjars 'tempLibraries/launchwrapper-1.11.jar' # TODO why does only 1.11.jar exist?
 
 
 

src/api/java/baritone/api/BaritoneAPI.java

@@ -19,6 +19,12 @@ package baritone.api;
 
 import baritone.api.behavior.*;
 import baritone.api.cache.IWorldProvider;
+import baritone.api.cache.IWorldScanner;
+import baritone.api.event.listener.IGameEventListener;
+import baritone.api.utils.SettingsUtil;
+
+import java.util.Iterator;
+import java.util.ServiceLoader;
 
 /**
  * API exposure for various things implemented in Baritone.
@@ -28,37 +34,38 @@ import baritone.api.cache.IWorldProvider;
  * @author Brady
  * @since 9/23/2018
  */
-public class BaritoneAPI {
+public final class BaritoneAPI {
 
-    // General
-    private static final Settings settings = new Settings();
-    private static IWorldProvider worldProvider;
+    private final static IBaritoneProvider baritone;
+    private final static Settings settings;
 
-    // Behaviors
-    private static IFollowBehavior followBehavior;
-    private static ILookBehavior lookBehavior;
-    private static IMemoryBehavior memoryBehavior;
-    private static IMineBehavior mineBehavior;
-    private static IPathingBehavior pathingBehavior;
+    static {
+        ServiceLoader<IBaritoneProvider> baritoneLoader = ServiceLoader.load(IBaritoneProvider.class);
+        Iterator<IBaritoneProvider> instances = baritoneLoader.iterator();
+        baritone = instances.next();
+
+        settings = new Settings();
+        SettingsUtil.readAndApply(settings);
+    }
 
     public static IFollowBehavior getFollowBehavior() {
-        return followBehavior;
+        return baritone.getFollowBehavior();
     }
 
     public static ILookBehavior getLookBehavior() {
-        return lookBehavior;
+        return baritone.getLookBehavior();
     }
 
     public static IMemoryBehavior getMemoryBehavior() {
-        return memoryBehavior;
+        return baritone.getMemoryBehavior();
     }
 
     public static IMineBehavior getMineBehavior() {
-        return mineBehavior;
+        return baritone.getMineBehavior();
     }
 
     public static IPathingBehavior getPathingBehavior() {
-        return pathingBehavior;
+        return baritone.getPathingBehavior();
     }
 
     public static Settings getSettings() {
@@ -66,34 +73,14 @@ public class BaritoneAPI {
     }
 
     public static IWorldProvider getWorldProvider() {
-        return worldProvider;
+        return baritone.getWorldProvider();
     }
 
-    /**
-     * FOR INTERNAL USE ONLY
-     */
-    public static void registerProviders(
-            IWorldProvider worldProvider
-    ) {
-        BaritoneAPI.worldProvider = worldProvider;
+    public static IWorldScanner getWorldScanner() {
+        return baritone.getWorldScanner();
     }
 
-    /**
-     * FOR INTERNAL USE ONLY
-     */
-    // @formatter:off
-    public static void registerDefaultBehaviors(
-            IFollowBehavior  followBehavior,
-            ILookBehavior    lookBehavior,
-            IMemoryBehavior  memoryBehavior,
-            IMineBehavior    mineBehavior,
-            IPathingBehavior pathingBehavior
-    ) {
-        BaritoneAPI.followBehavior  = followBehavior;
-        BaritoneAPI.lookBehavior    = lookBehavior;
-        BaritoneAPI.memoryBehavior  = memoryBehavior;
-        BaritoneAPI.mineBehavior    = mineBehavior;
-        BaritoneAPI.pathingBehavior = pathingBehavior;
+    public static void registerEventListener(IGameEventListener listener) {
+        baritone.registerEventListener(listener);
     }
-    // @formatter:on
 }

src/api/java/baritone/api/IBaritoneProvider.java

@@ -0,0 +1,86 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api;
+
+import baritone.api.behavior.*;
+import baritone.api.cache.IWorldProvider;
+import baritone.api.cache.IWorldScanner;
+import baritone.api.event.listener.IGameEventListener;
+
+/**
+ * @author Brady
+ * @since 9/29/2018
+ */
+public interface IBaritoneProvider {
+
+    /**
+     * @see IFollowBehavior
+     *
+     * @return The {@link IFollowBehavior} instance
+     */
+    IFollowBehavior getFollowBehavior();
+
+    /**
+     * @see ILookBehavior
+     *
+     * @return The {@link ILookBehavior} instance
+     */
+    ILookBehavior getLookBehavior();
+
+    /**
+     * @see IMemoryBehavior
+     *
+     * @return The {@link IMemoryBehavior} instance
+     */
+    IMemoryBehavior getMemoryBehavior();
+
+    /**
+     * @see IMineBehavior
+     *
+     * @return The {@link IMineBehavior} instance
+     */
+    IMineBehavior getMineBehavior();
+
+    /**
+     * @see IPathingBehavior
+     *
+     * @return The {@link IPathingBehavior} instance
+     */
+    IPathingBehavior getPathingBehavior();
+
+    /**
+     * @see IWorldProvider
+     *
+     * @return The {@link IWorldProvider} instance
+     */
+    IWorldProvider getWorldProvider();
+
+    /**
+     * @see IWorldScanner
+     *
+     * @return The {@link IWorldScanner} instance
+     */
+    IWorldScanner getWorldScanner();
+
+    /**
+     * Registers a {@link IGameEventListener} with Baritone's "event bus".
+     *
+     * @param listener The listener
+     */
+    void registerEventListener(IGameEventListener listener);
+}

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

@@ -56,6 +56,13 @@ public class Settings {
      */
     public Setting<Double> blockPlacementPenalty = new Setting<>(20D);
 
+    /**
+     * This is just a tiebreaker to make it less likely to break blocks if it can avoid it.
+     * For example, fire has a break cost of 0, this makes it nonzero, so all else being equal
+     * it will take an otherwise equivalent route that doesn't require it to put out fire.
+     */
+    public Setting<Double> blockBreakAdditionalPenalty = new Setting<>(2D);
+
     /**
      * Allow Baritone to fall arbitrary distances and place a water bucket beneath it.
      * Reliability: questionable.
@@ -149,7 +156,7 @@ public class Settings {
      *
      * @see <a href="https://github.com/cabaletta/baritone/issues/18">Issue #18</a>
      */
-    public Setting<Double> backtrackCostFavoringCoefficient = new Setting<>(0.9);
+    public Setting<Double> backtrackCostFavoringCoefficient = new Setting<>(0.1);
 
     /**
      * Don't repropagate cost improvements below 0.01 ticks. They're all just floating point inaccuracies,
@@ -191,7 +198,19 @@ public class Settings {
     /**
      * Start planning the next path once the remaining movements tick estimates sum up to less than this value
      */
-    public Setting<Integer> planningTickLookAhead = new Setting<>(100);
+    public Setting<Integer> planningTickLookAhead = new Setting<>(150);
+
+    /**
+     * Default size of the Long2ObjectOpenHashMap used in pathing
+     */
+    public Setting<Integer> pathingMapDefaultSize = new Setting<>(1024);
+
+    /**
+     * Load factor coefficient for the Long2ObjectOpenHashMap used in pathing
+     * <p>
+     * Decrease for faster map operations, but higher memory usage
+     */
+    public Setting<Float> pathingMapLoadFactor = new Setting<>(0.75f);
 
     /**
      * How far are you allowed to fall onto solid ground (without a water bucket)?
@@ -283,6 +302,11 @@ public class Settings {
      */
     public Setting<Boolean> renderGoal = new Setting<>(true);
 
+    /**
+     * Ignore depth when rendering the goal
+     */
+    public Setting<Boolean> renderGoalIgnoreDepth = new Setting<>(false);
+
     /**
      * Line width of the path when rendered, in pixels
      */
@@ -392,6 +416,28 @@ public class Settings {
      */
     public Setting<Integer> followRadius = new Setting<>(3);
 
+    /**
+     * Cached chunks (regardless of if they're in RAM or saved to disk) expire and are deleted after this number of seconds
+     * -1 to disable
+     * <p>
+     * I would highly suggest leaving this setting disabled (-1).
+     * <p>
+     * The only valid reason I can think of enable this setting is if you are extremely low on disk space and you play on multiplayer,
+     * and can't take (average) 300kb saved for every 512x512 area. (note that more complicated terrain is less compressible and will take more space)
+     * <p>
+     * However, simply discarding old chunks because they are old is inadvisable. Baritone is extremely good at correcting
+     * itself and its paths as it learns new information, as new chunks load. There is no scenario in which having an
+     * incorrect cache can cause Baritone to get stuck, take damage, or perform any action it wouldn't otherwise, everything
+     * is rechecked once the real chunk is in range.
+     * <p>
+     * Having a robust cache greatly improves long distance pathfinding, as it's able to go around large scale obstacles
+     * before they're in render distance. In fact, when the chunkCaching setting is disabled and Baritone starts anew
+     * every time, or when you enter a completely new and very complicated area, it backtracks far more often because it
+     * has to build up that cache from scratch. But after it's gone through an area just once, the next time will have zero
+     * backtracking, since the entire area is now known and cached.
+     */
+    public Setting<Long> cachedChunksExpirySeconds = new Setting<>(-1L);
+
     /**
      * The function that is called when Baritone will log to chat. This function can be added to
      * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
@@ -439,11 +485,19 @@ public class Settings {
      */
     public Setting<Color> colorGoalBox = new Setting<>(Color.GREEN);
 
+    /**
+     * A map of lowercase setting field names to their respective setting
+     */
     public final Map<String, Setting<?>> byLowerName;
+
+    /**
+     * A list of all settings
+     */
     public final List<Setting<?>> allSettings;
 
     public class Setting<T> {
         public T value;
+        public final T defaultValue;
         private String name;
         private final Class<T> klass;
 
@@ -453,6 +507,7 @@ public class Settings {
                 throw new IllegalArgumentException("Cannot determine value type class from null");
             }
             this.value = value;
+            this.defaultValue = value;
             this.klass = (Class<T>) value.getClass();
         }
 

src/api/java/baritone/api/behavior/IMemoryBehavior.java

@@ -20,6 +20,8 @@ package baritone.api.behavior;
 import baritone.api.behavior.memory.IRememberedInventory;
 import net.minecraft.util.math.BlockPos;
 
+import java.util.Map;
+
 /**
  * @author Brady
  * @since 9/23/2018
@@ -33,4 +35,11 @@ public interface IMemoryBehavior extends IBehavior {
      * @return The remembered inventory
      */
     IRememberedInventory getInventoryByPos(BlockPos pos);
+
+    /**
+     * Gets the map of all block positions to their remembered inventories.
+     *
+     * @return Map of block positions to their respective remembered inventories
+     */
+    Map<BlockPos, IRememberedInventory> getRememberedInventories();
 }

src/api/java/baritone/api/cache/IWorldScanner.java

@@ -0,0 +1,42 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.cache;
+
+import net.minecraft.block.Block;
+import net.minecraft.util.math.BlockPos;
+
+import java.util.List;
+
+/**
+ * @author Brady
+ * @since 10/6/2018
+ */
+public interface IWorldScanner {
+
+    /**
+     * Scans the world, up to the specified max chunk radius, for the specified blocks.
+     *
+     * @param blocks          The blocks to scan for
+     * @param max             The maximum number of blocks to scan before cutoff
+     * @param yLevelThreshold If a block is found within this Y level, the current result will be
+     *                        returned, if the value is negative, then this condition doesn't apply.
+     * @param maxSearchRadius The maximum chunk search radius
+     * @return The matching block positions
+     */
+    List<BlockPos> scanLoadedChunks(List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius);
+}

src/api/java/baritone/api/pathing/movement/ActionCosts.java

@@ -23,21 +23,21 @@ public interface ActionCosts {
      * These costs are measured roughly in ticks btw
      */
     double WALK_ONE_BLOCK_COST = 20 / 4.317; // 4.633
-    double WALK_ONE_IN_WATER_COST = 20 / 2.2;
+    double WALK_ONE_IN_WATER_COST = 20 / 2.2; // 9.091
     double WALK_ONE_OVER_SOUL_SAND_COST = WALK_ONE_BLOCK_COST * 2; // 0.4 in BlockSoulSand but effectively about half
-    double SPRINT_ONE_OVER_SOUL_SAND_COST = WALK_ONE_OVER_SOUL_SAND_COST * 0.75;
-    double LADDER_UP_ONE_COST = 20 / 2.35;
-    double LADDER_DOWN_ONE_COST = 20 / 3.0;
-    double SNEAK_ONE_BLOCK_COST = 20 / 1.3;
+    double LADDER_UP_ONE_COST = 20 / 2.35; // 8.511
+    double LADDER_DOWN_ONE_COST = 20 / 3.0; // 6.667
+    double SNEAK_ONE_BLOCK_COST = 20 / 1.3; // 15.385
     double SPRINT_ONE_BLOCK_COST = 20 / 5.612; // 3.564
+    double SPRINT_MULTIPLIER = SPRINT_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST; // 0.769
     /**
      * To walk off an edge you need to walk 0.5 to the edge then 0.3 to start falling off
      */
-    double WALK_OFF_BLOCK_COST = WALK_ONE_BLOCK_COST * 0.8;
+    double WALK_OFF_BLOCK_COST = WALK_ONE_BLOCK_COST * 0.8; // 3.706
     /**
      * To walk the rest of the way to be centered on the new block
      */
-    double CENTER_AFTER_FALL_COST = WALK_ONE_BLOCK_COST - WALK_OFF_BLOCK_COST;
+    double CENTER_AFTER_FALL_COST = WALK_ONE_BLOCK_COST - WALK_OFF_BLOCK_COST; // 0.927
 
     /**
      * don't make this Double.MAX_VALUE because it's added to other things, maybe other COST_INFs,

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

@@ -0,0 +1,140 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.utils;
+
+import baritone.api.Settings;
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.Item;
+import net.minecraft.util.ResourceLocation;
+
+import java.awt.*;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class SettingsUtil {
+    private static final File settingsFile = new File(new File(Minecraft.getMinecraft().gameDir, "baritone"), "settings.txt");
+
+    private static final Map<Class<?>, SettingsIO> map;
+
+    public static void readAndApply(Settings settings) {
+        try (Scanner scan = new Scanner(settingsFile)) {
+            while (scan.hasNextLine()) {
+                String line = scan.nextLine();
+                if (line.isEmpty()) {
+                    continue;
+                }
+                if (line.startsWith("#") || line.startsWith("//")) {
+                    continue;
+                }
+                int space = line.indexOf(" ");
+                if (space == -1) {
+                    System.out.println("Skipping invalid line with no space: " + line);
+                    continue;
+                }
+                String settingName = line.substring(0, space).trim().toLowerCase();
+                String settingValue = line.substring(space).trim();
+                try {
+                    parseAndApply(settings, settingName, settingValue);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                    System.out.println("Unable to parse line " + line);
+                }
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            System.out.println("Exception while reading Baritone settings, some settings may be reset to default values!");
+        }
+    }
+
+    public static synchronized void save(Settings settings) {
+        try (FileOutputStream out = new FileOutputStream(settingsFile)) {
+            for (Settings.Setting setting : settings.allSettings) {
+                if (setting.get() == null) {
+                    System.out.println("NULL SETTING?" + setting.getName());
+                    continue;
+                }
+                if (setting.getName().equals("logger")) {
+                    continue; // NO
+                }
+                if (setting.value == setting.defaultValue) {
+                    continue;
+                }
+                SettingsIO io = map.get(setting.getValueClass());
+                if (io == null) {
+                    throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting + " " + setting.getName());
+                }
+                out.write((setting.getName() + " " + io.toString.apply(setting.get()) + "\n").getBytes());
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            System.out.println("Exception while saving Baritone settings!");
+        }
+    }
+
+    private static void parseAndApply(Settings settings, String settingName, String settingValue) throws IllegalStateException, NumberFormatException {
+        Settings.Setting setting = settings.byLowerName.get(settingName);
+        if (setting == null) {
+            throw new IllegalStateException("No setting by that name");
+        }
+        Class intendedType = setting.getValueClass();
+        SettingsIO ioMethod = map.get(intendedType);
+        Object parsed = ioMethod.parser.apply(settingValue);
+        if (!intendedType.isInstance(parsed)) {
+            throw new IllegalStateException(ioMethod + " parser returned incorrect type, expected " + intendedType + " got " + parsed + " which is " + parsed.getClass());
+        }
+        setting.value = parsed;
+    }
+
+    private enum SettingsIO {
+        DOUBLE(Double.class, Double::parseDouble),
+        BOOLEAN(Boolean.class, Boolean::parseBoolean),
+        INTEGER(Integer.class, Integer::parseInt),
+        FLOAT(Float.class, Float::parseFloat),
+        LONG(Long.class, Long::parseLong),
+
+        ITEM_LIST(ArrayList.class, str -> Stream.of(str.split(",")).map(Item::getByNameOrId).collect(Collectors.toCollection(ArrayList::new)), list -> ((ArrayList<Item>) list).stream().map(Item.REGISTRY::getNameForObject).map(ResourceLocation::toString).collect(Collectors.joining(","))),
+        COLOR(Color.class, str -> new Color(Integer.parseInt(str.split(",")[0]), Integer.parseInt(str.split(",")[1]), Integer.parseInt(str.split(",")[2])), color -> color.getRed() + "," + color.getGreen() + "," + color.getBlue());
+
+
+        Class<?> klass;
+        Function<String, Object> parser;
+        Function<Object, String> toString;
+
+        <T> SettingsIO(Class<T> klass, Function<String, T> parser) {
+            this(klass, parser, Object::toString);
+        }
+
+        <T> SettingsIO(Class<T> klass, Function<String, T> parser, Function<T, String> toString) {
+            this.klass = klass;
+            this.parser = parser::apply;
+            this.toString = x -> toString.apply((T) x);
+        }
+    }
+
+    static {
+        HashMap<Class<?>, SettingsIO> tempMap = new HashMap<>();
+        for (SettingsIO type : SettingsIO.values()) {
+            tempMap.put(type.klass, type);
+        }
+        map = Collections.unmodifiableMap(tempMap);
+    }
+}

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

@@ -23,6 +23,7 @@ import baritone.api.event.events.TickEvent;
 import baritone.api.event.events.WorldEvent;
 import baritone.api.event.events.type.EventState;
 import baritone.behavior.PathingBehavior;
+import baritone.utils.BaritoneAutoTest;
 import baritone.utils.ExampleBaritoneControl;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
@@ -39,6 +40,7 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 /**
@@ -59,11 +61,22 @@ public class MixinMinecraft {
             method = "init",
             at = @At("RETURN")
     )
-    private void init(CallbackInfo ci) {
+    private void postInit(CallbackInfo ci) {
         Baritone.INSTANCE.init();
         ExampleBaritoneControl.INSTANCE.initAndRegister();
     }
 
+    @Inject(
+            method = "init",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/Minecraft.startTimerHackThread()V"
+            )
+    )
+    private void preInit(CallbackInfo ci) {
+        BaritoneAutoTest.INSTANCE.onPreInit();
+    }
+
     @Inject(
             method = "runTick",
             at = @At(

src/main/java/baritone/Baritone.java

@@ -21,7 +21,6 @@ import baritone.api.BaritoneAPI;
 import baritone.api.Settings;
 import baritone.api.event.listener.IGameEventListener;
 import baritone.behavior.*;
-import baritone.cache.WorldProvider;
 import baritone.event.GameEventHandler;
 import baritone.utils.BaritoneAutoTest;
 import baritone.utils.InputOverrideHandler;
@@ -36,7 +35,6 @@ import java.util.concurrent.Executor;
 import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
 
 /**
  * @author Brady
@@ -61,19 +59,13 @@ public enum Baritone {
     private File dir;
     private ThreadPoolExecutor threadPool;
 
-
-    /**
-     * List of consumers to be called after Baritone has initialized
-     */
-    private List<Consumer<Baritone>> onInitConsumers;
-
     /**
      * Whether or not Baritone is active
      */
     private boolean active;
 
     Baritone() {
-        this.onInitConsumers = new ArrayList<>();
+        this.gameEventHandler = new GameEventHandler();
     }
 
     public synchronized void init() {
@@ -81,15 +73,12 @@ public enum Baritone {
             return;
         }
         this.threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
-        this.gameEventHandler = new GameEventHandler();
         this.inputOverrideHandler = new InputOverrideHandler();
 
         // Acquire the "singleton" instance of the settings directly from the API
         // We might want to change this...
         this.settings = BaritoneAPI.getSettings();
 
-        BaritoneAPI.registerProviders(WorldProvider.INSTANCE);
-
         this.behaviors = new ArrayList<>();
         {
             registerBehavior(PathingBehavior.INSTANCE);
@@ -98,19 +87,9 @@ public enum Baritone {
             registerBehavior(LocationTrackingBehavior.INSTANCE);
             registerBehavior(FollowBehavior.INSTANCE);
             registerBehavior(MineBehavior.INSTANCE);
-
-            // TODO: Clean this up
-            // Maybe combine this call in someway with the registerBehavior calls?
-            BaritoneAPI.registerDefaultBehaviors(
-                    FollowBehavior.INSTANCE,
-                    LookBehavior.INSTANCE,
-                    MemoryBehavior.INSTANCE,
-                    MineBehavior.INSTANCE,
-                    PathingBehavior.INSTANCE
-            );
         }
-        if (BaritoneAutoTest.ENABLE_AUTO_TEST && "true".equals(System.getenv("BARITONE_AUTO_TEST"))) {
-            registerEventListener(new BaritoneAutoTest());
+        if (BaritoneAutoTest.ENABLE_AUTO_TEST) {
+            registerEventListener(BaritoneAutoTest.INSTANCE);
         }
         this.dir = new File(Minecraft.getMinecraft().gameDir, "baritone");
         if (!Files.exists(dir.toPath())) {
@@ -121,8 +100,6 @@ public enum Baritone {
 
         this.active = true;
         this.initialized = true;
-
-        this.onInitConsumers.forEach(consumer -> consumer.accept(this));
     }
 
     public boolean isInitialized() {
@@ -169,8 +146,4 @@ public enum Baritone {
     public File getDir() {
         return this.dir;
     }
-
-    public void registerInitListener(Consumer<Baritone> runnable) {
-        this.onInitConsumers.add(runnable);
-    }
 }

src/main/java/baritone/BaritoneProvider.java

@@ -0,0 +1,74 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone;
+
+import baritone.api.IBaritoneProvider;
+import baritone.api.behavior.*;
+import baritone.api.cache.IWorldProvider;
+import baritone.api.cache.IWorldScanner;
+import baritone.api.event.listener.IGameEventListener;
+import baritone.behavior.*;
+import baritone.cache.WorldProvider;
+import baritone.cache.WorldScanner;
+
+/**
+ * @author Brady
+ * @since 9/29/2018
+ */
+public final class BaritoneProvider implements IBaritoneProvider {
+
+    @Override
+    public IFollowBehavior getFollowBehavior() {
+        return FollowBehavior.INSTANCE;
+    }
+
+    @Override
+    public ILookBehavior getLookBehavior() {
+        return LookBehavior.INSTANCE;
+    }
+
+    @Override
+    public IMemoryBehavior getMemoryBehavior() {
+        return MemoryBehavior.INSTANCE;
+    }
+
+    @Override
+    public IMineBehavior getMineBehavior() {
+        return MineBehavior.INSTANCE;
+    }
+
+    @Override
+    public IPathingBehavior getPathingBehavior() {
+        return PathingBehavior.INSTANCE;
+    }
+
+    @Override
+    public IWorldProvider getWorldProvider() {
+        return WorldProvider.INSTANCE;
+    }
+
+    @Override
+    public IWorldScanner getWorldScanner() {
+        return WorldScanner.INSTANCE;
+    }
+
+    @Override
+    public void registerEventListener(IGameEventListener listener) {
+        Baritone.INSTANCE.registerEventListener(listener);
+    }
+}

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

@@ -19,9 +19,11 @@ package baritone.behavior;
 
 import baritone.api.behavior.IMemoryBehavior;
 import baritone.api.behavior.memory.IRememberedInventory;
+import baritone.api.cache.IWorldData;
 import baritone.api.event.events.PacketEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.type.EventState;
+import baritone.cache.WorldProvider;
 import baritone.utils.Helper;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
@@ -43,27 +45,19 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
 
     public static MemoryBehavior INSTANCE = new MemoryBehavior();
 
-    /**
-     * Possible future inventories that we will be able to remember
-     */
-    private final List<FutureInventory> futureInventories = new ArrayList<>();
-
-    /**
-     * The current remembered inventories
-     */
-    private final Map<BlockPos, RememberedInventory> rememberedInventories = new HashMap<>();
+    private final Map<IWorldData, WorldDataContainer> worldDataContainers = new HashMap<>();
 
     private MemoryBehavior() {}
 
     @Override
-    public void onPlayerUpdate(PlayerUpdateEvent event) {
+    public synchronized void onPlayerUpdate(PlayerUpdateEvent event) {
         if (event.getState() == EventState.PRE) {
             updateInventory();
         }
     }
 
     @Override
-    public void onSendPacket(PacketEvent event) {
+    public synchronized void onSendPacket(PacketEvent event) {
         Packet p = event.getPacket();
 
         if (event.getState() == EventState.PRE) {
@@ -78,7 +72,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
                     TileEntityLockable lockable = (TileEntityLockable) tileEntity;
                     int size = lockable.getSizeInventory();
 
-                    this.futureInventories.add(new FutureInventory(System.nanoTime() / 1000000L, size, lockable.getGuiID(), tileEntity.getPos()));
+                    this.getCurrentContainer().futureInventories.add(new FutureInventory(System.nanoTime() / 1000000L, size, lockable.getGuiID(), tileEntity.getPos()));
                 }
             }
 
@@ -89,24 +83,26 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
     }
 
     @Override
-    public void onReceivePacket(PacketEvent event) {
+    public synchronized void onReceivePacket(PacketEvent event) {
         Packet p = event.getPacket();
 
         if (event.getState() == EventState.PRE) {
             if (p instanceof SPacketOpenWindow) {
                 SPacketOpenWindow packet = event.cast();
 
-                // Remove any entries that were created over a second ago, this should make up for INSANE latency
-                this.futureInventories.removeIf(i -> System.nanoTime() / 1000000L - i.time > 1000);
+                WorldDataContainer container = this.getCurrentContainer();
 
-                this.futureInventories.stream()
+                // Remove any entries that were created over a second ago, this should make up for INSANE latency
+                container.futureInventories.removeIf(i -> System.nanoTime() / 1000000L - i.time > 1000);
+
+                container.futureInventories.stream()
                         .filter(i -> i.type.equals(packet.getGuiId()) && i.slots == packet.getSlotCount())
                         .findFirst().ifPresent(matched -> {
                     // Remove the future inventory
-                    this.futureInventories.remove(matched);
+                    container.futureInventories.remove(matched);
 
                     // Setup the remembered inventory
-                    RememberedInventory inventory = this.rememberedInventories.computeIfAbsent(matched.pos, pos -> new RememberedInventory());
+                    RememberedInventory inventory = container.rememberedInventories.computeIfAbsent(matched.pos, pos -> new RememberedInventory());
                     inventory.windowId = packet.getWindowId();
                     inventory.size = packet.getSlotCount();
                 });
@@ -119,7 +115,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
     }
 
     private Optional<RememberedInventory> getInventoryFromWindow(int windowId) {
-        return this.rememberedInventories.values().stream().filter(i -> i.windowId == windowId).findFirst();
+        return this.getCurrentContainer().rememberedInventories.values().stream().filter(i -> i.windowId == windowId).findFirst();
     }
 
     private void updateInventory() {
@@ -129,9 +125,32 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
         });
     }
 
+    private WorldDataContainer getCurrentContainer() {
+        return this.worldDataContainers.computeIfAbsent(WorldProvider.INSTANCE.getCurrentWorld(), data -> new WorldDataContainer());
+    }
+
     @Override
-    public final RememberedInventory getInventoryByPos(BlockPos pos) {
-        return this.rememberedInventories.get(pos);
+    public final synchronized RememberedInventory getInventoryByPos(BlockPos pos) {
+        return this.getCurrentContainer().rememberedInventories.get(pos);
+    }
+
+    @Override
+    public final synchronized Map<BlockPos, IRememberedInventory> getRememberedInventories() {
+        // make a copy since this map is modified from the packet thread
+        return new HashMap<>(this.getCurrentContainer().rememberedInventories);
+    }
+
+    private static final class WorldDataContainer {
+
+        /**
+         * Possible future inventories that we will be able to remember
+         */
+        private final List<FutureInventory> futureInventories = new ArrayList<>();
+
+        /**
+         * The current remembered inventories
+         */
+        private final Map<BlockPos, RememberedInventory> rememberedInventories = new HashMap<>();
     }
 
     /**
@@ -170,7 +189,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
     /**
      * An inventory that we are aware of.
      * <p>
-     * Associated with a {@link BlockPos} in {@link MemoryBehavior#rememberedInventories}.
+     * Associated with a {@link BlockPos} in {@link WorldDataContainer#rememberedInventories}.
      */
     public static class RememberedInventory implements IRememberedInventory {
 
@@ -195,7 +214,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
 
         @Override
         public final List<ItemStack> getContents() {
-            return this.items;
+            return Collections.unmodifiableList(this.items);
         }
 
         @Override

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

@@ -24,10 +24,11 @@ import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.RenderEvent;
 import baritone.api.event.events.TickEvent;
 import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.utils.interfaces.IGoalRenderPos;
 import baritone.pathing.calc.AStarPathFinder;
 import baritone.pathing.calc.AbstractNodeCostSearch;
 import baritone.pathing.calc.IPathFinder;
-import baritone.api.pathing.goals.GoalXZ;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.path.IPath;
 import baritone.pathing.path.PathExecutor;
@@ -35,14 +36,12 @@ import baritone.utils.BlockBreakHelper;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
 import baritone.utils.PathRenderer;
-import baritone.api.utils.interfaces.IGoalRenderPos;
 import baritone.utils.pathing.BetterBlockPos;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.EmptyChunk;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -341,7 +340,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                 pos = ((IGoalRenderPos) goal).getGoalPos();
             }
 
-            // TODO simplify each individual goal in a GoalComposite
             if (pos != null && world().getChunk(pos) instanceof EmptyChunk) {
                 logDebug("Simplifying " + goal.getClass() + " to GoalXZ due to distance");
                 goal = new GoalXZ(pos.getX(), pos.getZ());
@@ -353,9 +351,14 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         } else {
             timeout = Baritone.settings().planAheadTimeoutMS.<Long>get();
         }
-        Optional<HashSet<Long>> favoredPositions = previous.map(IPath::positions).map(Collection::stream).map(x -> x.map(y -> y.hashCode)).map(x -> x.collect(Collectors.toList())).map(HashSet::new); // <-- okay this is EPIC
+        Optional<HashSet<Long>> favoredPositions;
+        if (Baritone.settings().backtrackCostFavoringCoefficient.get() == 1D) {
+            favoredPositions = Optional.empty();
+        } else {
+            favoredPositions = previous.map(IPath::positions).map(Collection::stream).map(x -> x.map(BetterBlockPos::longHash)).map(x -> x.collect(Collectors.toList())).map(HashSet::new); // <-- okay this is EPIC
+        }
         try {
-            IPathFinder pf = new AStarPathFinder(start, goal, favoredPositions);
+            IPathFinder pf = new AStarPathFinder(start.getX(), start.getY(), start.getZ(), goal, favoredPositions);
             return pf.calculate(timeout);
         } catch (Exception e) {
             logDebug("Pathing exception: " + e);
@@ -368,70 +371,23 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         if (!Baritone.settings().cancelOnGoalInvalidation.get()) {
             return;
         }
-        if (current == null || goal == null) {
-            return;
-        }
-        Goal intended = current.getPath().getGoal();
-        BlockPos end = current.getPath().getDest();
-        if (intended.isInGoal(end) && !goal.isInGoal(end)) {
-            // this path used to end in the goal
-            // but the goal has changed, so there's no reason to continue...
-            cancel();
+        synchronized (pathPlanLock) {
+            if (current == null || goal == null) {
+                return;
+            }
+            Goal intended = current.getPath().getGoal();
+            BlockPos end = current.getPath().getDest();
+            if (intended.isInGoal(end) && !goal.isInGoal(end)) {
+                // this path used to end in the goal
+                // but the goal has changed, so there's no reason to continue...
+                cancel();
+            }
         }
     }
 
     @Override
     public void onRenderPass(RenderEvent event) {
-        // System.out.println("Render passing");
-        // System.out.println(event.getPartialTicks());
-        float partialTicks = event.getPartialTicks();
-        if (goal != null && Baritone.settings().renderGoal.value) {
-            PathRenderer.drawLitDankGoalBox(player(), goal, partialTicks, Baritone.settings().colorGoalBox.get());
-        }
-        if (!Baritone.settings().renderPath.get()) {
-            return;
-        }
-
-        //long start = System.nanoTime();
-
-
-        PathExecutor current = this.current; // this should prevent most race conditions?
-        PathExecutor next = this.next; // like, now it's not possible for current!=null to be true, then suddenly false because of another thread
-        // TODO is this enough, or do we need to acquire a lock here?
-        // TODO benchmark synchronized in render loop
-
-        // Render the current path, if there is one
-        if (current != null && current.getPath() != null) {
-            int renderBegin = Math.max(current.getPosition() - 3, 0);
-            PathRenderer.drawPath(current.getPath(), renderBegin, player(), partialTicks, Baritone.settings().colorCurrentPath.get(), Baritone.settings().fadePath.get(), 10, 20);
-        }
-        if (next != null && next.getPath() != null) {
-            PathRenderer.drawPath(next.getPath(), 0, player(), partialTicks, Baritone.settings().colorNextPath.get(), Baritone.settings().fadePath.get(), 10, 20);
-        }
-
-        //long split = System.nanoTime();
-        if (current != null) {
-            PathRenderer.drawManySelectionBoxes(player(), current.toBreak(), partialTicks, Baritone.settings().colorBlocksToBreak.get());
-            PathRenderer.drawManySelectionBoxes(player(), current.toPlace(), partialTicks, Baritone.settings().colorBlocksToPlace.get());
-            PathRenderer.drawManySelectionBoxes(player(), current.toWalkInto(), partialTicks, Baritone.settings().colorBlocksToWalkInto.get());
-        }
-
-        // If there is a path calculation currently running, render the path calculation process
-        AbstractNodeCostSearch.getCurrentlyRunning().ifPresent(currentlyRunning -> {
-            currentlyRunning.bestPathSoFar().ifPresent(p -> {
-                PathRenderer.drawPath(p, 0, player(), partialTicks, Baritone.settings().colorBestPathSoFar.get(), Baritone.settings().fadePath.get(), 10, 20);
-                currentlyRunning.pathToMostRecentNodeConsidered().ifPresent(mr -> {
-
-                    PathRenderer.drawPath(mr, 0, player(), partialTicks, Baritone.settings().colorMostRecentConsidered.get(), Baritone.settings().fadePath.get(), 10, 20);
-                    PathRenderer.drawManySelectionBoxes(player(), Collections.singletonList(mr.getDest()), partialTicks, Baritone.settings().colorMostRecentConsidered.get());
-                });
-            });
-        });
-        //long end = System.nanoTime();
-        //System.out.println((end - split) + " " + (split - start));
-        // if (end - start > 0) {
-        //   System.out.println("Frame took " + (split - start) + " " + (end - split));
-        //}
+        PathRenderer.render(event, this);
     }
 
     @Override

src/main/java/baritone/cache/CachedChunk.java

@@ -106,7 +106,9 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
 
     private final Map<String, List<BlockPos>> specialBlockLocations;
 
-    CachedChunk(int x, int z, BitSet data, IBlockState[] overview, Map<String, List<BlockPos>> specialBlockLocations) {
+    public final long cacheTimestamp;
+
+    CachedChunk(int x, int z, BitSet data, IBlockState[] overview, Map<String, List<BlockPos>> specialBlockLocations, long cacheTimestamp) {
         validateSize(data);
 
         this.x = x;
@@ -115,6 +117,7 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
         this.overview = overview;
         this.heightMap = new int[256];
         this.specialBlockLocations = specialBlockLocations;
+        this.cacheTimestamp = cacheTimestamp;
         calculateHeightMap();
     }
 

src/main/java/baritone/cache/CachedRegion.java

@@ -17,6 +17,7 @@
 
 package baritone.cache;
 
+import baritone.Baritone;
 import baritone.api.cache.ICachedRegion;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
@@ -112,6 +113,7 @@ public final class CachedRegion implements ICachedRegion {
         if (!hasUnsavedChanges) {
             return;
         }
+        removeExpired();
         try {
             Path path = Paths.get(directory);
             if (!Files.exists(path)) {
@@ -129,8 +131,8 @@ public final class CachedRegion implements ICachedRegion {
                     DataOutputStream out = new DataOutputStream(gzipOut)
             ) {
                 out.writeInt(CACHED_REGION_MAGIC);
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
                         CachedChunk chunk = this.chunks[x][z];
                         if (chunk == null) {
                             out.write(CHUNK_NOT_PRESENT);
@@ -143,8 +145,8 @@ public final class CachedRegion implements ICachedRegion {
                         }
                     }
                 }
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
                         if (chunks[x][z] != null) {
                             for (int i = 0; i < 256; i++) {
                                 out.writeUTF(ChunkPacker.blockToString(chunks[x][z].getOverview()[i].getBlock()));
@@ -152,8 +154,8 @@ public final class CachedRegion implements ICachedRegion {
                         }
                     }
                 }
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
                         if (chunks[x][z] != null) {
                             Map<String, List<BlockPos>> locs = chunks[x][z].getRelativeBlocks();
                             out.writeShort(locs.entrySet().size());
@@ -168,10 +170,17 @@ public final class CachedRegion implements ICachedRegion {
                         }
                     }
                 }
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
+                        if (chunks[x][z] != null) {
+                            out.writeLong(chunks[x][z].cacheTimestamp);
+                        }
+                    }
+                }
             }
             hasUnsavedChanges = false;
             System.out.println("Saved region successfully");
-        } catch (IOException ex) {
+        } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
@@ -203,42 +212,42 @@ public final class CachedRegion implements ICachedRegion {
                     // by switching on the magic value, and either loading it normally, or loading through a converter.
                     throw new IOException("Bad magic value " + magic);
                 }
-                CachedChunk[][] tmpCached = new CachedChunk[32][32];
+                boolean[][] present = new boolean[32][32];
+                BitSet[][] bitSets = new BitSet[32][32];
                 Map<String, List<BlockPos>>[][] location = new Map[32][32];
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
+                IBlockState[][][] overview = new IBlockState[32][32][];
+                long[][] cacheTimestamp = new long[32][32];
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
                         int isChunkPresent = in.read();
                         switch (isChunkPresent) {
                             case CHUNK_PRESENT:
                                 byte[] bytes = new byte[CachedChunk.SIZE_IN_BYTES];
                                 in.readFully(bytes);
+                                bitSets[x][z] = BitSet.valueOf(bytes);
                                 location[x][z] = new HashMap<>();
-                                int regionX = this.x;
-                                int regionZ = this.z;
-                                int chunkX = x + 32 * regionX;
-                                int chunkZ = z + 32 * regionZ;
-                                tmpCached[x][z] = new CachedChunk(chunkX, chunkZ, BitSet.valueOf(bytes), new IBlockState[256], location[x][z]);
+                                overview[x][z] = new IBlockState[256];
+                                present[x][z] = true;
                                 break;
                             case CHUNK_NOT_PRESENT:
-                                tmpCached[x][z] = null;
                                 break;
                             default:
                                 throw new IOException("Malformed stream");
                         }
                     }
                 }
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
-                        if (tmpCached[x][z] != null) {
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
+                        if (present[x][z]) {
                             for (int i = 0; i < 256; i++) {
-                                tmpCached[x][z].getOverview()[i] = ChunkPacker.stringToBlock(in.readUTF()).getDefaultState();
+                                overview[x][z][i] = ChunkPacker.stringToBlock(in.readUTF()).getDefaultState();
                             }
                         }
                     }
                 }
-                for (int z = 0; z < 32; z++) {
-                    for (int x = 0; x < 32; x++) {
-                        if (tmpCached[x][z] != null) {
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
+                        if (present[x][z]) {
                             // 16 * 16 * 256 = 65536 so a short is enough
                             // ^ haha jokes on leijurv, java doesn't have unsigned types so that isn't correct
                             //   also why would you have more than 32767 special blocks in a chunk
@@ -264,21 +273,52 @@ public final class CachedRegion implements ICachedRegion {
                         }
                     }
                 }
+                for (int x = 0; x < 32; x++) {
+                    for (int z = 0; z < 32; z++) {
+                        if (present[x][z]) {
+                            cacheTimestamp[x][z] = in.readLong();
+                        }
+                    }
+                }
                 // only if the entire file was uncorrupted do we actually set the chunks
                 for (int x = 0; x < 32; x++) {
                     for (int z = 0; z < 32; z++) {
-                        this.chunks[x][z] = tmpCached[x][z];
+                        if (present[x][z]) {
+                            int regionX = this.x;
+                            int regionZ = this.z;
+                            int chunkX = x + 32 * regionX;
+                            int chunkZ = z + 32 * regionZ;
+                            this.chunks[x][z] = new CachedChunk(chunkX, chunkZ, bitSets[x][z], overview[x][z], location[x][z], cacheTimestamp[x][z]);
+                        }
                     }
                 }
             }
+            removeExpired();
             hasUnsavedChanges = false;
             long end = System.nanoTime() / 1000000L;
             System.out.println("Loaded region successfully in " + (end - start) + "ms");
-        } catch (IOException ex) {
+        } catch (Exception ex) { // corrupted files can cause NullPointerExceptions as well as IOExceptions
             ex.printStackTrace();
         }
     }
 
+    public synchronized final void removeExpired() {
+        long expiry = Baritone.settings().cachedChunksExpirySeconds.get();
+        if (expiry < 0) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        long oldestAcceptableAge = now - expiry * 1000L;
+        for (int x = 0; x < 32; x++) {
+            for (int z = 0; z < 32; z++) {
+                if (this.chunks[x][z] != null && this.chunks[x][z].cacheTimestamp < oldestAcceptableAge) {
+                    System.out.println("Removing chunk " + (x + 32 * this.x) + "," + (z + 32 * this.z) + " because it was cached " + (now - this.chunks[x][z].cacheTimestamp) / 1000L + " seconds ago, and max age is " + expiry);
+                    this.chunks[x][z] = null;
+                }
+            }
+        }
+    }
+
     /**
      * @return The region x coordinate
      */

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

@@ -142,6 +142,11 @@ public final class CachedWorld implements ICachedWorld, Helper {
     public final void save() {
         if (!Baritone.settings().chunkCaching.get()) {
             System.out.println("Not saving to disk; chunk caching is disabled.");
+            allRegions().forEach(region -> {
+                if (region != null) {
+                    region.removeExpired();
+                }
+            }); // even if we aren't saving to disk, still delete expired old chunks from RAM
             return;
         }
         long start = System.nanoTime() / 1000000L;

src/main/java/baritone/cache/ChunkPacker.java

@@ -106,7 +106,7 @@ public final class ChunkPacker implements Helper {
                 blocks[z << 4 | x] = Blocks.AIR.getDefaultState();
             }
         }
-        return new CachedChunk(chunk.x, chunk.z, bitSet, blocks, specialBlocks);
+        return new CachedChunk(chunk.x, chunk.z, bitSet, blocks, specialBlocks, System.currentTimeMillis());
     }
 
     public static String blockToString(Block block) {

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

@@ -17,6 +17,7 @@
 
 package baritone.cache;
 
+import baritone.api.cache.IWorldScanner;
 import baritone.utils.Helper;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
@@ -29,19 +30,11 @@ import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 import java.util.LinkedList;
 import java.util.List;
 
-public enum WorldScanner implements Helper {
+public enum WorldScanner implements IWorldScanner, Helper {
+
     INSTANCE;
 
-    /**
-     * Scans the world, up to your render distance, for the specified blocks.
-     *
-     * @param blocks          The blocks to scan for
-     * @param max             The maximum number of blocks to scan before cutoff
-     * @param yLevelThreshold If a block is found within this Y level, the current result will be
-     *                        returned, if the value is negative, then this condition doesn't apply.
-     * @param maxSearchRadius The maximum chunk search radius
-     * @return The matching block positions
-     */
+    @Override
     public List<BlockPos> scanLoadedChunks(List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius) {
         if (blocks.contains(null)) {
             throw new IllegalStateException("Invalid block name should have been caught earlier: " + blocks.toString());

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

@@ -26,8 +26,7 @@ import baritone.pathing.movement.Moves;
 import baritone.pathing.path.IPath;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
-import baritone.utils.pathing.MoveResult;
-import net.minecraft.util.math.BlockPos;
+import baritone.utils.pathing.MutableMoveResult;
 
 import java.util.HashSet;
 import java.util.Optional;
@@ -41,14 +40,14 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
 
     private final Optional<HashSet<Long>> favoredPositions;
 
-    public AStarPathFinder(BlockPos start, Goal goal, Optional<HashSet<Long>> favoredPositions) {
-        super(start, goal);
+    public AStarPathFinder(int startX, int startY, int startZ, Goal goal, Optional<HashSet<Long>> favoredPositions) {
+        super(startX, startY, startZ, goal);
         this.favoredPositions = favoredPositions;
     }
 
     @Override
     protected Optional<IPath> calculate0(long timeout) {
-        startNode = getNodeAtPosition(start.x, start.y, start.z);
+        startNode = getNodeAtPosition(startX, startY, startZ, posHash(startX, startY, startZ));
         startNode.cost = 0;
         startNode.combinedCost = startNode.estimatedCostToGoal;
         BinaryHeapOpenSet openSet = new BinaryHeapOpenSet();
@@ -61,6 +60,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
             bestSoFar[i] = startNode;
         }
         CalculationContext calcContext = new CalculationContext();
+        MutableMoveResult res = new MutableMoveResult();
         HashSet<Long> favored = favoredPositions.orElse(null);
         BlockStateInterface.clearCachedChunk();
         long startTime = System.nanoTime() / 1000000L;
@@ -105,24 +105,29 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                         continue;
                     }
                 }
-                MoveResult res = moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z);
+                res.reset();
+                moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z, res);
                 numMovementsConsidered++;
                 double actionCost = res.cost;
                 if (actionCost >= ActionCosts.COST_INF) {
                     continue;
                 }
                 // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
-                if (!moves.dynamicXZ && (res.destX != newX || res.destZ != newZ)) {
-                    throw new IllegalStateException(moves + " " + res.destX + " " + newX + " " + res.destZ + " " + newZ);
+                if (!moves.dynamicXZ && (res.x != newX || res.z != newZ)) {
+                    throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
+                }
+                if (!moves.dynamicY && res.y != currentNode.y + moves.yOffset) {
+                    throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
                 }
                 if (actionCost <= 0) {
                     throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
                 }
-                if (favoring && favored.contains(posHash(res.destX, res.destY, res.destZ))) {
+                long hashCode = posHash(res.x, res.y, res.z);
+                if (favoring && favored.contains(hashCode)) {
                     // see issue #18
                     actionCost *= favorCoeff;
                 }
-                PathNode neighbor = getNodeAtPosition(res.destX, res.destY, res.destZ);
+                PathNode neighbor = getNodeAtPosition(res.x, res.y, res.z, hashCode);
                 double tentativeCost = currentNode.cost + actionCost;
                 if (tentativeCost < neighbor.cost) {
                     if (tentativeCost < 0) {

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

@@ -17,11 +17,10 @@
 
 package baritone.pathing.calc;
 
+import baritone.Baritone;
 import baritone.api.pathing.goals.Goal;
 import baritone.pathing.path.IPath;
-import baritone.utils.pathing.BetterBlockPos;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
-import net.minecraft.util.math.BlockPos;
 
 import java.util.Optional;
 
@@ -37,7 +36,9 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      */
     private static AbstractNodeCostSearch currentlyRunning = null;
 
-    protected final BetterBlockPos start;
+    protected final int startX;
+    protected final int startY;
+    protected final int startZ;
 
     protected final Goal goal;
 
@@ -68,10 +69,12 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      */
     protected final static double MIN_DIST_PATH = 5;
 
-    AbstractNodeCostSearch(BlockPos start, Goal goal) {
-        this.start = new BetterBlockPos(start.getX(), start.getY(), start.getZ());
+    AbstractNodeCostSearch(int startX, int startY, int startZ, Goal goal) {
+        this.startX = startX;
+        this.startY = startY;
+        this.startZ = startZ;
         this.goal = goal;
-        this.map = new Long2ObjectOpenHashMap<>();
+        this.map = new Long2ObjectOpenHashMap<>(Baritone.settings().pathingMapDefaultSize.value, Baritone.settings().pathingMapLoadFactor.get());
     }
 
     public void cancel() {
@@ -114,22 +117,21 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      * @return The distance, squared
      */
     protected double getDistFromStartSq(PathNode n) {
-        int xDiff = n.x - start.x;
-        int yDiff = n.y - start.y;
-        int zDiff = n.z - start.z;
+        int xDiff = n.x - startX;
+        int yDiff = n.y - startY;
+        int zDiff = n.z - startZ;
         return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
     }
 
     /**
-     * Attempts to search the {@link BlockPos} to {@link PathNode} map
+     * Attempts to search the block position hashCode long to {@link PathNode} map
      * for the node mapped to the specified pos. If no node is found,
      * a new node is created.
      *
      * @return The associated node
      * @see <a href="https://github.com/cabaletta/baritone/issues/107">Issue #107</a>
      */
-    protected PathNode getNodeAtPosition(int x, int y, int z) {
-        long hashCode = posHash(x, y, z);
+    protected PathNode getNodeAtPosition(int x, int y, int z, long hashCode) {
         PathNode node = map.get(hashCode);
         if (node == null) {
             node = new PathNode(x, y, z, goal);
@@ -140,7 +142,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
 
     public static long posHash(int x, int y, int z) {
         /*
-         *   This is the hashcode implementation of Vec3i, the superclass of BlockPos
+         *   This is the hashcode implementation of Vec3i (the superclass of the class which I shall not name)
          *
          *   public int hashCode() {
          *       return (this.getY() + this.getZ() * 31) * 31 + this.getX();
@@ -220,11 +222,6 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
         return goal;
     }
 
-    @Override
-    public final BlockPos getStart() {
-        return start;
-    }
-
     public static Optional<AbstractNodeCostSearch> getCurrentlyRunning() {
         return Optional.ofNullable(currentlyRunning);
     }

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

@@ -19,7 +19,6 @@ package baritone.pathing.calc;
 
 import baritone.api.pathing.goals.Goal;
 import baritone.pathing.path.IPath;
-import net.minecraft.util.math.BlockPos;
 
 import java.util.Optional;
 
@@ -30,8 +29,6 @@ import java.util.Optional;
  */
 public interface IPathFinder {
 
-    BlockPos getStart();
-
     Goal getGoal();
 
     /**

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

@@ -86,11 +86,11 @@ class Path implements IPath {
             throw new IllegalStateException();
         }
         PathNode current = end;
-        LinkedList<BetterBlockPos> tempPath = new LinkedList<>(); // Repeatedly inserting to the beginning of an arraylist is O(n^2)
-        LinkedList<Movement> tempMovements = new LinkedList<>(); // Instead, do it into a linked list, then convert at the end
+        LinkedList<BetterBlockPos> tempPath = new LinkedList<>();
+        // Repeatedly inserting to the beginning of an arraylist is O(n^2)
+        // Instead, do it into a linked list, then convert at the end
         while (!current.equals(start)) {
             tempPath.addFirst(new BetterBlockPos(current.x, current.y, current.z));
-            tempMovements.addFirst(runBackwards(current.previous, current));
             current = current.previous;
         }
         tempPath.addFirst(this.start);
@@ -98,20 +98,6 @@ class Path implements IPath {
         // inserting into a LinkedList<E> keeps track of length, then when we addall (which calls .toArray) it's able
         // to performantly do that conversion since it knows the length.
         path.addAll(tempPath);
-        movements.addAll(tempMovements);
-    }
-
-    private static Movement runBackwards(PathNode src0, PathNode dest0) { // TODO this is horrifying
-        BetterBlockPos src = new BetterBlockPos(src0.x, src0.y, src0.z);
-        BetterBlockPos dest = new BetterBlockPos(dest0.x, dest0.y, dest0.z);
-        for (Moves moves : Moves.values()) {
-            Movement move = moves.apply0(src);
-            if (move.getDest().equals(dest)) {
-                return move;
-            }
-        }
-        // leave this as IllegalStateException; it's caught in AbstractNodeCostSearch
-        throw new IllegalStateException("Movement became impossible during calculation " + src + " " + dest + " " + dest.subtract(src));
     }
 
     /**
@@ -140,12 +126,35 @@ class Path implements IPath {
         }
     }
 
+    private void assembleMovements() {
+        if (path.isEmpty() || !movements.isEmpty()) {
+            throw new IllegalStateException();
+        }
+        for (int i = 0; i < path.size() - 1; i++) {
+            movements.add(runBackwards(path.get(i), path.get(i + 1)));
+        }
+    }
+
+    private static Movement runBackwards(BetterBlockPos src, BetterBlockPos dest) { // TODO this is horrifying
+        for (Moves moves : Moves.values()) {
+            Movement move = moves.apply0(src);
+            if (move.getDest().equals(dest)) {
+                // TODO instead of recalculating here, could we take pathNode.cost - pathNode.prevNode.cost to get the cost as-calculated?
+                move.recalculateCost(); // have to calculate the cost at calculation time so we can accurately judge whether a cost increase happened between cached calculation and real execution
+                return move;
+            }
+        }
+        // this is no longer called from bestPathSoFar, now it's in postprocessing
+        throw new IllegalStateException("Movement became impossible during calculation " + src + " " + dest + " " + dest.subtract(src));
+    }
+
     @Override
     public void postprocess() {
         if (verified) {
             throw new IllegalStateException();
         }
         verified = true;
+        assembleMovements();
         // more post processing here
         movements.forEach(Movement::checkLoadedChunk);
         sanityCheck();

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

@@ -18,8 +18,10 @@
 package baritone.pathing.movement;
 
 import baritone.Baritone;
+import baritone.api.pathing.movement.ActionCosts;
 import baritone.utils.Helper;
 import baritone.utils.ToolSet;
+import net.minecraft.enchantment.EnchantmentHelper;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
@@ -40,6 +42,8 @@ public class CalculationContext implements Helper {
     private final boolean allowBreak;
     private final int maxFallHeightNoWater;
     private final int maxFallHeightBucket;
+    private final double waterWalkSpeed;
+    private final double breakBlockAdditionalCost;
 
     public CalculationContext() {
         this(new ToolSet());
@@ -54,13 +58,20 @@ public class CalculationContext implements Helper {
         this.allowBreak = Baritone.settings().allowBreak.get();
         this.maxFallHeightNoWater = Baritone.settings().maxFallHeightNoWater.get();
         this.maxFallHeightBucket = Baritone.settings().maxFallHeightBucket.get();
+        int depth = EnchantmentHelper.getDepthStriderModifier(player());
+        if (depth > 3) {
+            depth = 3;
+        }
+        float mult = depth / 3.0F;
+        this.waterWalkSpeed = ActionCosts.WALK_ONE_IN_WATER_COST * (1 - mult) + ActionCosts.WALK_ONE_BLOCK_COST * mult;
+        this.breakBlockAdditionalCost = Baritone.settings().blockBreakAdditionalPenalty.get();
         // why cache these things here, why not let the movements just get directly from settings?
         // because if some movements are calculated one way and others are calculated another way,
         // then you get a wildly inconsistent path that isn't optimal for either scenario.
     }
 
     public ToolSet getToolSet() {
-        return this.toolSet;
+        return toolSet;
     }
 
     public boolean hasWaterBucket() {
@@ -91,4 +102,11 @@ public class CalculationContext implements Helper {
         return maxFallHeightBucket;
     }
 
+    public double waterWalkSpeed() {
+        return waterWalkSpeed;
+    }
+
+    public double breakBlockAdditionalCost() {
+        return breakBlockAdditionalCost;
+    }
 }

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

@@ -187,6 +187,14 @@ public abstract class Movement implements Helper, MovementHelper {
         return true;
     }
 
+    public boolean safeToCancel() {
+        return safeToCancel(currentState);
+    }
+
+    protected boolean safeToCancel(MovementState currentState) {
+        return true;
+    }
+
     public boolean isFinished() {
         return (currentState.getStatus() != MovementStatus.RUNNING
                 && currentState.getStatus() != MovementStatus.PREPPING

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

@@ -374,6 +374,7 @@ public interface MovementHelper extends ActionCosts, Helper {
             }
 
             double result = m / strVsBlock;
+            result += context.breakBlockAdditionalCost();
             if (includeFalling) {
                 IBlockState above = BlockStateInterface.get(x, y + 1, z);
                 if (above.getBlock() instanceof BlockFalling) {

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

@@ -19,7 +19,7 @@ package baritone.pathing.movement;
 
 import baritone.pathing.movement.movements.*;
 import baritone.utils.pathing.BetterBlockPos;
-import baritone.utils.pathing.MoveResult;
+import baritone.utils.pathing.MutableMoveResult;
 import net.minecraft.util.EnumFacing;
 
 /**
@@ -28,306 +28,326 @@ import net.minecraft.util.EnumFacing;
  * @author leijurv
  */
 public enum Moves {
-    DOWNWARD(0, 0) {
+    DOWNWARD(0, -1, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementDownward(src, src.down());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y - 1, z, MovementDownward.cost(context, x, y, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementDownward.cost(context, x, y, z);
         }
     },
 
-    PILLAR(0, 0) {
+    PILLAR(0, +1, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementPillar(src, src.up());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y + 1, z, MovementPillar.cost(context, x, y, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementPillar.cost(context, x, y, z);
         }
     },
 
-    TRAVERSE_NORTH(0, -1) {
+    TRAVERSE_NORTH(0, 0, -1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementTraverse(src, src.north());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y, z - 1, MovementTraverse.cost(context, x, y, z, x, z - 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementTraverse.cost(context, x, y, z, x, z - 1);
         }
     },
 
-    TRAVERSE_SOUTH(0, +1) {
+    TRAVERSE_SOUTH(0, 0, +1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementTraverse(src, src.south());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y, z + 1, MovementTraverse.cost(context, x, y, z, x, z + 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementTraverse.cost(context, x, y, z, x, z + 1);
         }
     },
 
-    TRAVERSE_EAST(+1, 0) {
+    TRAVERSE_EAST(+1, 0, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementTraverse(src, src.east());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x + 1, y, z, MovementTraverse.cost(context, x, y, z, x + 1, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementTraverse.cost(context, x, y, z, x + 1, z);
         }
     },
 
-    TRAVERSE_WEST(-1, 0) {
+    TRAVERSE_WEST(-1, 0, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementTraverse(src, src.west());
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x - 1, y, z, MovementTraverse.cost(context, x, y, z, x - 1, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementTraverse.cost(context, x, y, z, x - 1, z);
         }
     },
 
-    ASCEND_NORTH(0, -1) {
+    ASCEND_NORTH(0, +1, -1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementAscend(src, new BetterBlockPos(src.x, src.y + 1, src.z - 1));
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y + 1, z - 1, MovementAscend.cost(context, x, y, z, x, z - 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementAscend.cost(context, x, y, z, x, z - 1);
         }
     },
 
-    ASCEND_SOUTH(0, +1) {
+    ASCEND_SOUTH(0, +1, +1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementAscend(src, new BetterBlockPos(src.x, src.y + 1, src.z + 1));
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x, y + 1, z + 1, MovementAscend.cost(context, x, y, z, x, z + 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementAscend.cost(context, x, y, z, x, z + 1);
         }
     },
 
-    ASCEND_EAST(+1, 0) {
+    ASCEND_EAST(+1, +1, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementAscend(src, new BetterBlockPos(src.x + 1, src.y + 1, src.z));
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x + 1, y + 1, z, MovementAscend.cost(context, x, y, z, x + 1, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementAscend.cost(context, x, y, z, x + 1, z);
         }
     },
 
-    ASCEND_WEST(-1, 0) {
+    ASCEND_WEST(-1, +1, 0) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementAscend(src, new BetterBlockPos(src.x - 1, src.y + 1, src.z));
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x - 1, y + 1, z, MovementAscend.cost(context, x, y, z, x - 1, z));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementAscend.cost(context, x, y, z, x - 1, z);
         }
     },
 
-    DESCEND_EAST(+1, 0) {
+    DESCEND_EAST(+1, 0, 0, false, true) {
         @Override
         public Movement apply0(BetterBlockPos src) {
-            MoveResult res = apply(new CalculationContext(), src.x, src.y, src.z);
-            if (res.destY == src.y - 1) {
-                return new MovementDescend(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+            MutableMoveResult res = new MutableMoveResult();
+            apply(new CalculationContext(), src.x, src.y, src.z, res);
+            if (res.y == src.y - 1) {
+                return new MovementDescend(src, new BetterBlockPos(res.x, res.y, res.z));
             } else {
-                return new MovementFall(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+                return new MovementFall(src, new BetterBlockPos(res.x, res.y, res.z));
             }
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementDescend.cost(context, x, y, z, x + 1, z);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementDescend.cost(context, x, y, z, x + 1, z, result);
         }
     },
 
-    DESCEND_WEST(-1, 0) {
+    DESCEND_WEST(-1, 0, 0, false, true) {
         @Override
         public Movement apply0(BetterBlockPos src) {
-            MoveResult res = apply(new CalculationContext(), src.x, src.y, src.z);
-            if (res.destY == src.y - 1) {
-                return new MovementDescend(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+            MutableMoveResult res = new MutableMoveResult();
+            apply(new CalculationContext(), src.x, src.y, src.z, res);
+            if (res.y == src.y - 1) {
+                return new MovementDescend(src, new BetterBlockPos(res.x, res.y, res.z));
             } else {
-                return new MovementFall(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+                return new MovementFall(src, new BetterBlockPos(res.x, res.y, res.z));
             }
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementDescend.cost(context, x, y, z, x - 1, z);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementDescend.cost(context, x, y, z, x - 1, z, result);
         }
     },
 
-    DESCEND_NORTH(0, -1) {
+    DESCEND_NORTH(0, 0, -1, false, true) {
         @Override
         public Movement apply0(BetterBlockPos src) {
-            MoveResult res = apply(new CalculationContext(), src.x, src.y, src.z);
-            if (res.destY == src.y - 1) {
-                return new MovementDescend(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+            MutableMoveResult res = new MutableMoveResult();
+            apply(new CalculationContext(), src.x, src.y, src.z, res);
+            if (res.y == src.y - 1) {
+                return new MovementDescend(src, new BetterBlockPos(res.x, res.y, res.z));
             } else {
-                return new MovementFall(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+                return new MovementFall(src, new BetterBlockPos(res.x, res.y, res.z));
             }
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementDescend.cost(context, x, y, z, x, z - 1);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementDescend.cost(context, x, y, z, x, z - 1, result);
         }
     },
 
-    DESCEND_SOUTH(0, +1) {
+    DESCEND_SOUTH(0, 0, +1, false, true) {
         @Override
         public Movement apply0(BetterBlockPos src) {
-            MoveResult res = apply(new CalculationContext(), src.x, src.y, src.z);
-            if (res.destY == src.y - 1) {
-                return new MovementDescend(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+            MutableMoveResult res = new MutableMoveResult();
+            apply(new CalculationContext(), src.x, src.y, src.z, res);
+            if (res.y == src.y - 1) {
+                return new MovementDescend(src, new BetterBlockPos(res.x, res.y, res.z));
             } else {
-                return new MovementFall(src, new BetterBlockPos(res.destX, res.destY, res.destZ));
+                return new MovementFall(src, new BetterBlockPos(res.x, res.y, res.z));
             }
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementDescend.cost(context, x, y, z, x, z + 1);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementDescend.cost(context, x, y, z, x, z + 1, result);
         }
     },
 
-    DIAGONAL_NORTHEAST(+1, -1) {
+    DIAGONAL_NORTHEAST(+1, 0, -1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementDiagonal(src, EnumFacing.NORTH, EnumFacing.EAST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x + 1, y, z - 1, MovementDiagonal.cost(context, x, y, z, x + 1, z - 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementDiagonal.cost(context, x, y, z, x + 1, z - 1);
         }
     },
 
-    DIAGONAL_NORTHWEST(-1, -1) {
+    DIAGONAL_NORTHWEST(-1, 0, -1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementDiagonal(src, EnumFacing.NORTH, EnumFacing.WEST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x - 1, y, z - 1, MovementDiagonal.cost(context, x, y, z, x - 1, z - 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementDiagonal.cost(context, x, y, z, x - 1, z - 1);
         }
     },
 
-    DIAGONAL_SOUTHEAST(+1, +1) {
+    DIAGONAL_SOUTHEAST(+1, 0, +1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementDiagonal(src, EnumFacing.SOUTH, EnumFacing.EAST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x + 1, y, z + 1, MovementDiagonal.cost(context, x, y, z, x + 1, z + 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementDiagonal.cost(context, x, y, z, x + 1, z + 1);
         }
     },
 
-    DIAGONAL_SOUTHWEST(-1, +1) {
+    DIAGONAL_SOUTHWEST(-1, 0, +1) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return new MovementDiagonal(src, EnumFacing.SOUTH, EnumFacing.WEST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return new MoveResult(x - 1, y, z + 1, MovementDiagonal.cost(context, x, y, z, x - 1, z + 1));
+        public double cost(CalculationContext context, int x, int y, int z) {
+            return MovementDiagonal.cost(context, x, y, z, x - 1, z + 1);
         }
     },
 
-    PARKOUR_NORTH(0, -4, true) {
+    PARKOUR_NORTH(0, 0, -4, true, false) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return MovementParkour.cost(new CalculationContext(), src, EnumFacing.NORTH);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementParkour.cost(context, x, y, z, EnumFacing.NORTH);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementParkour.cost(context, x, y, z, EnumFacing.NORTH, result);
         }
     },
 
-    PARKOUR_SOUTH(0, +4, true) {
+    PARKOUR_SOUTH(0, 0, +4, true, false) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return MovementParkour.cost(new CalculationContext(), src, EnumFacing.SOUTH);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementParkour.cost(context, x, y, z, EnumFacing.SOUTH);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementParkour.cost(context, x, y, z, EnumFacing.SOUTH, result);
         }
     },
 
-    PARKOUR_EAST(+4, 0, true) {
+    PARKOUR_EAST(+4, 0, 0, true, false) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return MovementParkour.cost(new CalculationContext(), src, EnumFacing.EAST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementParkour.cost(context, x, y, z, EnumFacing.EAST);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementParkour.cost(context, x, y, z, EnumFacing.EAST, result);
         }
     },
 
-    PARKOUR_WEST(-4, 0, true) {
+    PARKOUR_WEST(-4, 0, 0, true, false) {
         @Override
         public Movement apply0(BetterBlockPos src) {
             return MovementParkour.cost(new CalculationContext(), src, EnumFacing.WEST);
         }
 
         @Override
-        public MoveResult apply(CalculationContext context, int x, int y, int z) {
-            return MovementParkour.cost(context, x, y, z, EnumFacing.WEST);
+        public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+            MovementParkour.cost(context, x, y, z, EnumFacing.WEST, result);
         }
     };
 
     public final boolean dynamicXZ;
+    public final boolean dynamicY;
 
     public final int xOffset;
+    public final int yOffset;
     public final int zOffset;
 
-    Moves(int x, int z, boolean dynamicXZ) {
+    Moves(int x, int y, int z, boolean dynamicXZ, boolean dynamicY) {
         this.xOffset = x;
+        this.yOffset = y;
         this.zOffset = z;
         this.dynamicXZ = dynamicXZ;
+        this.dynamicY = dynamicY;
     }
 
-    Moves(int x, int z) {
-        this(x, z, false);
+    Moves(int x, int y, int z) {
+        this(x, y, z, false, false);
     }
 
     public abstract Movement apply0(BetterBlockPos src);
 
-    public abstract MoveResult apply(CalculationContext context, int x, int y, int z);
+    public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
+        if (dynamicXZ || dynamicY) {
+            throw new UnsupportedOperationException();
+        }
+        result.x = x + xOffset;
+        result.y = y + yOffset;
+        result.z = z + zOffset;
+        result.cost = cost(context, x, y, z);
+    }
+
+    public double cost(CalculationContext context, int x, int y, int z) {
+        throw new UnsupportedOperationException();
+    }
 }

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

@@ -71,7 +71,7 @@ public class MovementAscend extends Movement {
             return COST_INF;// the only thing we can ascend onto from a bottom slab is another bottom slab
         }
         boolean hasToPlace = false;
-        if (!MovementHelper.canWalkOn(destX, y, z, toPlace)) {
+        if (!MovementHelper.canWalkOn(destX, y, destZ, toPlace)) {
             if (!context.hasThrowaway()) {
                 return COST_INF;
             }
@@ -101,14 +101,15 @@ public class MovementAscend extends Movement {
             // HOWEVER, we assume that we're standing in the start position
             // that means that src and src.up(1) are both air
             // maybe they aren't now, but they will be by the time this starts
-            if (!(BlockStateInterface.getBlock(x, y + 1, z) instanceof BlockFalling) || !((srcUp2 = BlockStateInterface.get(x, y + 2, z)).getBlock() instanceof BlockFalling)) {
-                // if both of those are BlockFalling, that means that by standing on src
+            if (MovementHelper.canWalkThrough(x, y + 1, z) || !((srcUp2 = BlockStateInterface.get(x, y + 2, z)).getBlock() instanceof BlockFalling)) {
+                // if the lower one is can't walk through and the upper one is falling, that means that by standing on src
                 // (the presupposition of this Movement)
                 // we have necessarily already cleared the entire BlockFalling stack
                 // on top of our head
 
-                // but if either of them aren't BlockFalling, that means we're still in suffocation danger
-                // so don't do it
+                // as in, if we have a block, then two BlockFallings on top of it
+                // and that block is x, y+1, z, and we'd have to clear it to even start this movement
+                // we don't need to worry about those BlockFallings because we've already cleared them
                 return COST_INF;
             }
             // you may think we only need to check srcUp2, not srcUp

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

@@ -26,15 +26,13 @@ import baritone.pathing.movement.MovementState.MovementStatus;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.InputOverrideHandler;
 import baritone.utils.pathing.BetterBlockPos;
-import baritone.utils.pathing.MoveResult;
+import baritone.utils.pathing.MutableMoveResult;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockFalling;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
 
-import static baritone.utils.pathing.MoveResult.IMPOSSIBLE;
-
 public class MovementDescend extends Movement {
 
     private int numTicks = 0;
@@ -51,31 +49,33 @@ public class MovementDescend extends Movement {
 
     @Override
     protected double calculateCost(CalculationContext context) {
-        MoveResult result = cost(context, src.x, src.y, src.z, dest.x, dest.z);
-        if (result.destY != dest.y) {
+        MutableMoveResult result = new MutableMoveResult();
+        cost(context, src.x, src.y, src.z, dest.x, dest.z, result);
+        if (result.y != dest.y) {
             return COST_INF; // doesn't apply to us, this position is a fall not a descend
         }
         return result.cost;
     }
 
-    public static MoveResult cost(CalculationContext context, int x, int y, int z, int destX, int destZ) {
+    public static void cost(CalculationContext context, int x, int y, int z, int destX, int destZ, MutableMoveResult res) {
         Block fromDown = BlockStateInterface.get(x, y - 1, z).getBlock();
         if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) {
-            return IMPOSSIBLE;
+            return;
         }
 
         double totalCost = 0;
-        totalCost += MovementHelper.getMiningDurationTicks(context, destX, y - 1, destZ, false);
+        IBlockState destDown = BlockStateInterface.get(destX, y - 1, destZ);
+        totalCost += MovementHelper.getMiningDurationTicks(context, destX, y - 1, destZ, destDown, false);
         if (totalCost >= COST_INF) {
-            return IMPOSSIBLE;
+            return;
         }
         totalCost += MovementHelper.getMiningDurationTicks(context, destX, y, destZ, false);
         if (totalCost >= COST_INF) {
-            return IMPOSSIBLE;
+            return;
         }
         totalCost += MovementHelper.getMiningDurationTicks(context, destX, y + 1, destZ, true); // only the top block in the 3 we need to mine needs to consider the falling blocks above
         if (totalCost >= COST_INF) {
-            return IMPOSSIBLE;
+            return;
         }
 
         // A
@@ -90,12 +90,12 @@ public class MovementDescend extends Movement {
 
         IBlockState below = BlockStateInterface.get(destX, y - 2, destZ);
         if (!MovementHelper.canWalkOn(destX, y - 2, destZ, below)) {
-            return dynamicFallCost(context, x, y, z, destX, destZ, totalCost, below);
+            dynamicFallCost(context, x, y, z, destX, destZ, totalCost, below, res);
+            return;
         }
 
-        Block tmp1 = BlockStateInterface.get(destX, y - 1, destZ).getBlock();
-        if (tmp1 == Blocks.LADDER || tmp1 == Blocks.VINE) {
-            return IMPOSSIBLE;
+        if (destDown.getBlock() == Blocks.LADDER || destDown.getBlock() == Blocks.VINE) {
+            return;
         }
 
         // we walk half the block plus 0.3 to get to the edge, then we walk the other 0.2 while simultaneously falling (math.max because of how it's in parallel)
@@ -105,55 +105,72 @@ public class MovementDescend extends Movement {
             walk = WALK_ONE_OVER_SOUL_SAND_COST;
         }
         totalCost += walk + Math.max(FALL_N_BLOCKS_COST[1], CENTER_AFTER_FALL_COST);
-        return new MoveResult(destX, y - 1, destZ, totalCost);
+        res.x = destX;
+        res.y = y - 1;
+        res.z = destZ;
+        res.cost = totalCost;
     }
 
-    public static MoveResult dynamicFallCost(CalculationContext context, int x, int y, int z, int destX, int destZ, double frontBreak, IBlockState below) {
+    public static void dynamicFallCost(CalculationContext context, int x, int y, int z, int destX, int destZ, double frontBreak, IBlockState below, MutableMoveResult res) {
         if (frontBreak != 0 && BlockStateInterface.get(destX, y + 2, destZ).getBlock() instanceof BlockFalling) {
             // if frontBreak is 0 we can actually get through this without updating the falling block and making it actually fall
             // but if frontBreak is nonzero, we're breaking blocks in front, so don't let anything fall through this column,
             // and potentially replace the water we're going to fall into
-            return IMPOSSIBLE;
+            return;
         }
         if (!MovementHelper.canWalkThrough(destX, y - 2, destZ, below) && below.getBlock() != Blocks.WATER) {
-            return IMPOSSIBLE;
+            return;
         }
         for (int fallHeight = 3; true; fallHeight++) {
             int newY = y - fallHeight;
             if (newY < 0) {
                 // when pathing in the end, where you could plausibly fall into the void
                 // this check prevents it from getting the block at y=-1 and crashing
-                return IMPOSSIBLE;
+                return;
             }
             IBlockState ontoBlock = BlockStateInterface.get(destX, newY, destZ);
             double tentativeCost = WALK_OFF_BLOCK_COST + FALL_N_BLOCKS_COST[fallHeight] + frontBreak;
-            if (ontoBlock.getBlock() == Blocks.WATER && !BlockStateInterface.isFlowing(ontoBlock)) { // TODO flowing check required here?
+            if (ontoBlock.getBlock() == Blocks.WATER && !BlockStateInterface.isFlowing(ontoBlock) && BlockStateInterface.getBlock(destX, newY + 1, destZ) != Blocks.WATERLILY) { // TODO flowing check required here?
+                // lilypads are canWalkThrough, but we can't end a fall that should be broken by water if it's covered by a lilypad
+                // however, don't return impossible in the lilypad scenario, because we could still jump right on it (water that's below a lilypad is canWalkOn so it works)
                 if (Baritone.settings().assumeWalkOnWater.get()) {
-                    return IMPOSSIBLE; // TODO fix
+                    return; // TODO fix
                 }
                 // found a fall into water
-                return new MoveResult(destX, newY, destZ, tentativeCost); // TODO incorporate water swim up cost?
+                res.x = destX;
+                res.y = newY;
+                res.z = destZ;
+                res.cost = tentativeCost;// TODO incorporate water swim up cost?
+                return;
             }
             if (ontoBlock.getBlock() == Blocks.FLOWING_WATER) {
-                return IMPOSSIBLE;
+                return;
             }
             if (MovementHelper.canWalkThrough(destX, newY, destZ, ontoBlock)) {
                 continue;
             }
             if (!MovementHelper.canWalkOn(destX, newY, destZ, ontoBlock)) {
-                return IMPOSSIBLE;
+                return;
             }
             if (MovementHelper.isBottomSlab(ontoBlock)) {
-                return IMPOSSIBLE; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect
+                return; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect
             }
             if (context.hasWaterBucket() && fallHeight <= context.maxFallHeightBucket() + 1) {
-                return new MoveResult(destX, newY + 1, destZ, tentativeCost + context.placeBlockCost()); // this is the block we're falling onto, so dest is +1
+                res.x = destX;
+                res.y = newY + 1;// this is the block we're falling onto, so dest is +1
+                res.z = destZ;
+                res.cost = tentativeCost + context.placeBlockCost();
+                return;
             }
             if (fallHeight <= context.maxFallHeightNoWater() + 1) {
                 // fallHeight = 4 means onto.up() is 3 blocks down, which is the max
-                return new MoveResult(destX, newY + 1, destZ, tentativeCost);
+                res.x = destX;
+                res.y = newY + 1;
+                res.z = destZ;
+                res.cost = tentativeCost;
+                return;
             } else {
-                return IMPOSSIBLE;
+                return;
             }
         }
     }

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

@@ -85,37 +85,54 @@ public class MovementDiagonal extends Movement {
             return COST_INF;
         }
         IBlockState pb0 = BlockStateInterface.get(x, y, destZ);
-        IBlockState pb1 = BlockStateInterface.get(x, y + 1, destZ);
         IBlockState pb2 = BlockStateInterface.get(destX, y, z);
-        IBlockState pb3 = BlockStateInterface.get(destX, y + 1, z);
-        double optionA = MovementHelper.getMiningDurationTicks(context, x, y, destZ, pb0, false) + MovementHelper.getMiningDurationTicks(context, x, y + 1, destZ, pb1, true);
-        double optionB = MovementHelper.getMiningDurationTicks(context, destX, y, z, pb2, false) + MovementHelper.getMiningDurationTicks(context, destX, y + 1, z, pb3, true);
+        double optionA = MovementHelper.getMiningDurationTicks(context, x, y, destZ, pb0, false);
+        double optionB = MovementHelper.getMiningDurationTicks(context, destX, y, z, pb2, false);
         if (optionA != 0 && optionB != 0) {
+            // check these one at a time -- if pb0 and pb2 were nonzero, we already know that (optionA != 0 && optionB != 0)
+            // so no need to check pb1 as well, might as well return early here
             return COST_INF;
         }
+        IBlockState pb1 = BlockStateInterface.get(x, y + 1, destZ);
+        optionA += MovementHelper.getMiningDurationTicks(context, x, y + 1, destZ, pb1, true);
+        if (optionA != 0 && optionB != 0) {
+            // same deal, if pb1 makes optionA nonzero and option B already was nonzero, pb3 can't affect the result
+            return COST_INF;
+        }
+        IBlockState pb3 = BlockStateInterface.get(destX, y + 1, z);
         if (optionA == 0) {
-            if (MovementHelper.avoidWalkingInto(pb2.getBlock()) || MovementHelper.avoidWalkingInto(pb3.getBlock())) {
+            // at this point we're done calculating optionA, so we can check if it's actually possible to edge around in that direction
+            if ((MovementHelper.avoidWalkingInto(pb2.getBlock()) && pb2.getBlock() != Blocks.WATER) || (MovementHelper.avoidWalkingInto(pb3.getBlock()) && pb3.getBlock() != Blocks.WATER)) {
                 return COST_INF;
             }
         }
+        optionB += MovementHelper.getMiningDurationTicks(context, destX, y + 1, z, pb3, true);
+        if (optionA != 0 && optionB != 0) {
+            // and finally, if the cost is nonzero for both ways to approach this diagonal, it's not possible
+            return COST_INF;
+        }
         if (optionB == 0) {
-            if (MovementHelper.avoidWalkingInto(pb0.getBlock()) || MovementHelper.avoidWalkingInto(pb1.getBlock())) {
+            // and now that option B is fully calculated, see if we can edge around that way
+            if ((MovementHelper.avoidWalkingInto(pb0.getBlock()) && pb0.getBlock() != Blocks.WATER) || (MovementHelper.avoidWalkingInto(pb1.getBlock()) && pb1.getBlock() != Blocks.WATER)) {
                 return COST_INF;
             }
         }
+        boolean water = false;
         if (BlockStateInterface.isWater(BlockStateInterface.getBlock(x, y, z)) || BlockStateInterface.isWater(destInto.getBlock())) {
             // Ignore previous multiplier
             // Whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water
             // Not even touching the blocks below
-            multiplier = WALK_ONE_IN_WATER_COST;
+            multiplier = context.waterWalkSpeed();
+            water = true;
         }
         if (optionA != 0 || optionB != 0) {
             multiplier *= SQRT_2 - 0.001; // TODO tune
         }
-        if (multiplier == WALK_ONE_BLOCK_COST && context.canSprint()) {
-            // If we aren't edging around anything, and we aren't in water or soul sand
+        if (context.canSprint() && !water) {
+            // If we aren't edging around anything, and we aren't in water
             // We can sprint =D
-            multiplier = SPRINT_ONE_BLOCK_COST;
+            // Don't check for soul sand, since we can sprint on that too
+            multiplier *= SPRINT_MULTIPLIER;
         }
         return multiplier * SQRT_2;
     }

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

@@ -30,7 +30,7 @@ import baritone.utils.InputOverrideHandler;
 import baritone.utils.RayTraceUtils;
 import baritone.utils.Utils;
 import baritone.utils.pathing.BetterBlockPos;
-import baritone.utils.pathing.MoveResult;
+import baritone.utils.pathing.MutableMoveResult;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
@@ -49,8 +49,9 @@ public class MovementFall extends Movement {
 
     @Override
     protected double calculateCost(CalculationContext context) {
-        MoveResult result = MovementDescend.cost(context, src.x, src.y, src.z, dest.x, dest.z);
-        if (result.destY != dest.y) {
+        MutableMoveResult result = new MutableMoveResult();
+        MovementDescend.cost(context, src.x, src.y, src.z, dest.x, dest.z, result);
+        if (result.y != dest.y) {
             return COST_INF; // doesn't apply to us, this position is a descend not a fall
         }
         return result.cost;
@@ -111,6 +112,13 @@ public class MovementFall extends Movement {
         return state;
     }
 
+    @Override
+    public boolean safeToCancel(MovementState state) {
+        // if we haven't started walking off the edge yet, or if we're in the process of breaking blocks before doing the fall
+        // then it's safe to cancel this
+        return playerFeet().equals(src) || state.getStatus() != MovementStatus.RUNNING;
+    }
+
     private static BetterBlockPos[] buildPositionsToBreak(BetterBlockPos src, BetterBlockPos dest) {
         BetterBlockPos[] toBreak;
         int diffX = src.getX() - dest.getX();

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

@@ -18,27 +18,26 @@
 package baritone.pathing.movement.movements;
 
 import baritone.Baritone;
+import baritone.api.utils.Rotation;
 import baritone.behavior.LookBehaviorUtils;
 import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.InputOverrideHandler;
-import baritone.utils.Utils;
+import baritone.utils.*;
 import baritone.utils.pathing.BetterBlockPos;
-import baritone.utils.pathing.MoveResult;
+import baritone.utils.pathing.MutableMoveResult;
+import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
 
 import java.util.Objects;
 
-import static baritone.utils.pathing.MoveResult.IMPOSSIBLE;
-
 public class MovementParkour extends Movement {
 
     private static final EnumFacing[] HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST, EnumFacing.DOWN};
@@ -48,72 +47,81 @@ public class MovementParkour extends Movement {
     private final int dist;
 
     private MovementParkour(BetterBlockPos src, int dist, EnumFacing dir) {
-        super(src, src.offset(dir, dist), EMPTY);
+        super(src, src.offset(dir, dist), EMPTY, src.offset(dir, dist).down());
         this.direction = dir;
         this.dist = dist;
     }
 
     public static MovementParkour cost(CalculationContext context, BetterBlockPos src, EnumFacing direction) {
-        MoveResult res = cost(context, src.x, src.y, src.z, direction);
-        int dist = Math.abs(res.destX - src.x) + Math.abs(res.destZ - src.z);
+        MutableMoveResult res = new MutableMoveResult();
+        cost(context, src.x, src.y, src.z, direction, res);
+        int dist = Math.abs(res.x - src.x) + Math.abs(res.z - src.z);
         return new MovementParkour(src, dist, direction);
     }
 
-    public static MoveResult cost(CalculationContext context, int x, int y, int z, EnumFacing dir) {
+    public static void cost(CalculationContext context, int x, int y, int z, EnumFacing dir, MutableMoveResult res) {
         if (!Baritone.settings().allowParkour.get()) {
-            return IMPOSSIBLE;
+            return;
         }
         IBlockState standingOn = BlockStateInterface.get(x, y - 1, z);
         if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || MovementHelper.isBottomSlab(standingOn)) {
-            return IMPOSSIBLE;
+            return;
         }
         int xDiff = dir.getXOffset();
         int zDiff = dir.getZOffset();
         IBlockState adj = BlockStateInterface.get(x + xDiff, y - 1, z + zDiff);
         if (MovementHelper.avoidWalkingInto(adj.getBlock()) && adj.getBlock() != Blocks.WATER && adj.getBlock() != Blocks.FLOWING_WATER) { // magma sucks
-            return IMPOSSIBLE;
+            return;
         }
         if (MovementHelper.canWalkOn(x + xDiff, y - 1, z + zDiff, adj)) { // don't parkour if we could just traverse (for now)
-            return IMPOSSIBLE;
+            return;
         }
 
         if (!MovementHelper.fullyPassable(x + xDiff, y, z + zDiff)) {
-            return IMPOSSIBLE;
+            return;
         }
         if (!MovementHelper.fullyPassable(x + xDiff, y + 1, z + zDiff)) {
-            return IMPOSSIBLE;
+            return;
         }
         if (!MovementHelper.fullyPassable(x + xDiff, y + 2, z + zDiff)) {
-            return IMPOSSIBLE;
+            return;
         }
         if (!MovementHelper.fullyPassable(x, y + 2, z)) {
-            return IMPOSSIBLE;
+            return;
         }
         for (int i = 2; i <= (context.canSprint() ? 4 : 3); i++) {
             // TODO perhaps dest.up(3) doesn't need to be fullyPassable, just canWalkThrough, possibly?
             for (int y2 = 0; y2 < 4; y2++) {
                 if (!MovementHelper.fullyPassable(x + xDiff * i, y + y2, z + zDiff * i)) {
-                    return IMPOSSIBLE;
+                    return;
                 }
             }
             if (MovementHelper.canWalkOn(x + xDiff * i, y - 1, z + zDiff * i)) {
-                return new MoveResult(x + xDiff * i, y, z + zDiff * i, costFromJumpDistance(i));
+                res.x = x + xDiff * i;
+                res.y = y;
+                res.z = z + zDiff * i;
+                res.cost = costFromJumpDistance(i);
+                return;
             }
         }
         if (!context.canSprint()) {
-            return IMPOSSIBLE;
+            return;
         }
         if (!Baritone.settings().allowParkourPlace.get()) {
-            return IMPOSSIBLE;
+            return;
+        }
+        if (!Baritone.settings().allowPlace.get()) {
+            Helper.HELPER.logDirect("allowParkourPlace enabled but allowPlace disabled?");
+            return;
         }
         int destX = x + 4 * xDiff;
         int destZ = z + 4 * zDiff;
         IBlockState toPlace = BlockStateInterface.get(destX, y - 1, destZ);
         if (!context.hasThrowaway()) {
-            return IMPOSSIBLE;
+            return;
         }
         if (toPlace.getBlock() != Blocks.AIR && !BlockStateInterface.isWater(toPlace.getBlock()) && !MovementHelper.isReplacable(destX, y - 1, destZ, toPlace)) {
-            return IMPOSSIBLE;
+            return;
         }
         for (int i = 0; i < 5; i++) {
             int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
@@ -122,10 +130,13 @@ public class MovementParkour extends Movement {
                 continue;
             }
             if (MovementHelper.canPlaceAgainst(againstX, y - 1, againstZ)) {
-                return new MoveResult(destX, y, destZ, costFromJumpDistance(i) + context.placeBlockCost());
+                res.x = destX;
+                res.y = y;
+                res.z = destZ;
+                res.cost = costFromJumpDistance(4) + context.placeBlockCost();
+                return;
             }
         }
-        return IMPOSSIBLE;
     }
 
     private static double costFromJumpDistance(int dist) {
@@ -137,20 +148,29 @@ public class MovementParkour extends Movement {
             case 4:
                 return SPRINT_ONE_BLOCK_COST * 4;
             default:
-                throw new IllegalStateException("LOL");
+                throw new IllegalStateException("LOL " + dist);
         }
     }
 
 
     @Override
     protected double calculateCost(CalculationContext context) {
-        MoveResult res = cost(context, src.x, src.y, src.z, direction);
-        if (res.destX != dest.x || res.destZ != dest.z) {
+        MutableMoveResult res = new MutableMoveResult();
+        cost(context, src.x, src.y, src.z, direction, res);
+        if (res.x != dest.x || res.z != dest.z) {
             return COST_INF;
         }
         return res.cost;
     }
 
+    @Override
+    public boolean safeToCancel(MovementState state) {
+        // once this movement is instantiated, the state is default to PREPPING
+        // but once it's ticked for the first time it changes to RUNNING
+        // since we don't really know anything about momentum, it suffices to say Parkour can only be canceled on the 0th tick
+        return state.getStatus() != MovementState.MovementStatus.RUNNING;
+    }
+
     @Override
     public MovementState updateState(MovementState state) {
         super.updateState(state);
@@ -162,7 +182,13 @@ public class MovementParkour extends Movement {
         }
         MovementHelper.moveTowards(state, dest);
         if (playerFeet().equals(dest)) {
-            if (player().posY - playerFeet().getY() < 0.01) {
+            Block d = BlockStateInterface.getBlock(dest);
+            if (d == Blocks.VINE || d == Blocks.LADDER) {
+                // it physically hurt me to add support for parkour jumping onto a vine
+                // but i did it anyway
+                return state.setStatus(MovementState.MovementStatus.SUCCESS);
+            }
+            if (player().posY - playerFeet().getY() < 0.094) { // lilypads
                 state.setStatus(MovementState.MovementStatus.SUCCESS);
             }
         } else if (!playerFeet().equals(src)) {
@@ -182,10 +208,13 @@ public class MovementParkour extends Movement {
                             double faceX = (dest.getX() + against1.getX() + 1.0D) * 0.5D;
                             double faceY = (dest.getY() + against1.getY()) * 0.5D;
                             double faceZ = (dest.getZ() + against1.getZ() + 1.0D) * 0.5D;
-                            state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations()), true));
-                            EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit;
-
+                            Rotation place = Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations());
+                            RayTraceResult res = RayTraceUtils.rayTraceTowards(place);
+                            if (res != null && res.typeOfHit == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(dest.down())) {
+                                state.setTarget(new MovementState.MovementTarget(place, true));
+                            }
                             LookBehaviorUtils.getSelectedBlock().ifPresent(selectedBlock -> {
+                                EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit;
                                 if (Objects.equals(selectedBlock, against1) && selectedBlock.offset(side).equals(dest.down())) {
                                     state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
                                 }
@@ -195,7 +224,7 @@ public class MovementParkour extends Movement {
                 }
 
                 state.setInput(InputOverrideHandler.Input.JUMP, true);
-            } else {
+            } else if(!playerFeet().equals(dest.offset(direction, -1))) {
                 state.setInput(InputOverrideHandler.Input.SPRINT, false);
                 if (playerFeet().equals(src.offset(direction, -1))) {
                     MovementHelper.moveTowards(state, src);

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

@@ -67,8 +67,10 @@ public class MovementTraverse extends Movement {
         Block srcDown = BlockStateInterface.getBlock(x, y - 1, z);
         if (MovementHelper.canWalkOn(destX, y - 1, destZ, destOn)) {//this is a walk, not a bridge
             double WC = WALK_ONE_BLOCK_COST;
+            boolean water = false;
             if (BlockStateInterface.isWater(pb0.getBlock()) || BlockStateInterface.isWater(pb1.getBlock())) {
-                WC = WALK_ONE_IN_WATER_COST;
+                WC = context.waterWalkSpeed();
+                water = true;
             } else {
                 if (destOn.getBlock() == Blocks.SOUL_SAND) {
                     WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
@@ -83,10 +85,11 @@ public class MovementTraverse extends Movement {
             }
             double hardness2 = MovementHelper.getMiningDurationTicks(context, destX, y, destZ, pb1, false);
             if (hardness1 == 0 && hardness2 == 0) {
-                if (WC == WALK_ONE_BLOCK_COST && context.canSprint()) {
-                    // If there's nothing in the way, and this isn't water or soul sand, and we aren't sneak placing
+                if (!water && context.canSprint()) {
+                    // If there's nothing in the way, and this isn't water, and we aren't sneak placing
                     // We can sprint =D
-                    WC = SPRINT_ONE_BLOCK_COST;
+                    // Don't check for soul sand, since we can sprint on that too
+                    WC *= SPRINT_MULTIPLIER;
                 }
                 return WC;
             }
@@ -113,7 +116,7 @@ public class MovementTraverse extends Movement {
                 }
                 double hardness2 = MovementHelper.getMiningDurationTicks(context, destX, y + 1, destZ, pb1, true);
 
-                double WC = throughWater ? WALK_ONE_IN_WATER_COST : WALK_ONE_BLOCK_COST;
+                double WC = throughWater ? context.waterWalkSpeed() : WALK_ONE_BLOCK_COST;
                 for (int i = 0; i < 4; i++) {
                     int againstX = destX + HORIZONTALS[i].getXOffset();
                     int againstZ = destZ + HORIZONTALS[i].getZOffset();
@@ -266,7 +269,7 @@ public class MovementTraverse extends Movement {
                     state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations()), true));
 
                     EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit;
-                    if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), against1) && Minecraft.getMinecraft().player.isSneaking()) {
+                    if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), against1) && (Minecraft.getMinecraft().player.isSneaking() || Baritone.settings().assumeSafeWalk.get())) {
                         if (LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionToPlace)) {
                             return state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
                         }
@@ -291,9 +294,17 @@ public class MovementTraverse extends Movement {
                 double faceZ = (dest.getZ() + src.getZ() + 1.0D) * 0.5D;
                 // faceX, faceY, faceZ is the middle of the face between from and to
                 BlockPos goalLook = src.down(); // this is the block we were just standing on, and the one we want to place against
-                state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations()), true));
 
-                state.setInput(InputOverrideHandler.Input.MOVE_BACK, true);
+                Rotation backToFace = Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations());
+                float pitch = backToFace.getPitch();
+                double dist = Math.max(Math.abs(player().posX - faceX), Math.abs(player().posZ - faceZ));
+                if (dist < 0.29) {
+                    float yaw = Utils.calcRotationFromVec3d(Utils.getBlockPosCenter(dest), playerHead(), playerRotations()).getYaw();
+                    state.setTarget(new MovementState.MovementTarget(new Rotation(yaw, pitch), true));
+                    state.setInput(InputOverrideHandler.Input.MOVE_BACK, true);
+                } else {
+                    state.setTarget(new MovementState.MovementTarget(backToFace, true));
+                }
                 state.setInput(InputOverrideHandler.Input.SNEAK, true);
                 if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), goalLook)) {
                     return state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); // wait to right click until we are able to place
@@ -308,6 +319,14 @@ public class MovementTraverse extends Movement {
         }
     }
 
+    @Override
+    public boolean safeToCancel(MovementState state) {
+        // if we're in the process of breaking blocks before walking forwards
+        // or if this isn't a sneak place (the block is already there)
+        // then it's safe to cancel this
+        return state.getStatus() != MovementState.MovementStatus.RUNNING || MovementHelper.canWalkOn(dest.down());
+    }
+
     @Override
     protected boolean prepared(MovementState state) {
         if (playerFeet().equals(src) || playerFeet().equals(src.down())) {

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

@@ -20,19 +20,19 @@ package baritone.pathing.path;
 import baritone.Baritone;
 import baritone.api.event.events.TickEvent;
 import baritone.api.pathing.movement.ActionCosts;
-import baritone.pathing.movement.*;
+import baritone.pathing.calc.AbstractNodeCostSearch;
+import baritone.pathing.movement.CalculationContext;
+import baritone.pathing.movement.Movement;
+import baritone.pathing.movement.MovementHelper;
+import baritone.pathing.movement.MovementState;
 import baritone.pathing.movement.movements.*;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
-import baritone.utils.Utils;
+import baritone.utils.*;
 import baritone.utils.pathing.BetterBlockPos;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.BlockPos;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 import static baritone.pathing.movement.MovementState.MovementStatus.*;
 
@@ -110,18 +110,19 @@ public class PathExecutor implements Helper {
                         for (int j = pathPosition; j <= previousPos; j++) {
                             path.movements().get(j).reset();
                         }
-                        clearKeys();
+                        onChangeInPathPosition();
                         return false;
                     }
                 }
-                for (int i = pathPosition + 2; i < path.length(); i++) { //dont check pathPosition+1. the movement tells us when it's done (e.g. sneak placing)
+                for (int i = pathPosition + 3; i < path.length(); i++) { //dont check pathPosition+1. the movement tells us when it's done (e.g. sneak placing)
+                    // also don't check pathPosition+2 because reasons
                     if (whereAmI.equals(path.positions().get(i))) {
                         if (i - pathPosition > 2) {
                             logDebug("Skipping forward " + (i - pathPosition) + " steps, to " + i);
                         }
                         System.out.println("Double skip sundae");
                         pathPosition = i - 1;
-                        clearKeys();
+                        onChangeInPathPosition();
                         return false;
                     }
                 }
@@ -176,7 +177,7 @@ public class PathExecutor implements Helper {
                 }
             }
         }*/
-        long start = System.nanoTime() / 1000000L;
+        //long start = System.nanoTime() / 1000000L;
         for (int i = pathPosition - 10; i < pathPosition + 10; i++) {
             if (i < 0 || i >= path.movements().size()) {
                 continue;
@@ -212,17 +213,18 @@ public class PathExecutor implements Helper {
             toWalkInto = newWalkInto;
             recalcBP = false;
         }
-        long end = System.nanoTime() / 1000000L;
+        /*long end = System.nanoTime() / 1000000L;
         if (end - start > 0) {
             System.out.println("Recalculating break and place took " + (end - start) + "ms");
-        }
+        }*/
         Movement movement = path.movements().get(pathPosition);
+        boolean canCancel = movement.safeToCancel();
         if (costEstimateIndex == null || costEstimateIndex != pathPosition) {
             costEstimateIndex = pathPosition;
             // do this only once, when the movement starts, and deliberately get the cost as cached when this path was calculated, not the cost as it is right now
             currentMovementOriginalCostEstimate = movement.getCost(null);
             for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) {
-                if (path.movements().get(pathPosition + i).calculateCostWithoutCaching() >= ActionCosts.COST_INF) {
+                if (path.movements().get(pathPosition + i).calculateCostWithoutCaching() >= ActionCosts.COST_INF && canCancel) {
                     logDebug("Something has changed in the world and a future movement has become impossible. Cancelling.");
                     cancel();
                     return true;
@@ -230,16 +232,20 @@ public class PathExecutor implements Helper {
             }
         }
         double currentCost = movement.recalculateCost();
-        if (currentCost >= ActionCosts.COST_INF) {
+        if (currentCost >= ActionCosts.COST_INF && canCancel) {
             logDebug("Something has changed in the world and this movement has become impossible. Cancelling.");
             cancel();
             return true;
         }
-        if (!movement.calculatedWhileLoaded() && currentCost - currentMovementOriginalCostEstimate > Baritone.settings().maxCostIncrease.get()) {
+        if (!movement.calculatedWhileLoaded() && currentCost - currentMovementOriginalCostEstimate > Baritone.settings().maxCostIncrease.get() && canCancel) {
             logDebug("Original cost " + currentMovementOriginalCostEstimate + " current cost " + currentCost + ". Cancelling.");
             cancel();
             return true;
         }
+        if (shouldPause()) {
+            logDebug("Pausing since current best path is a backtrack");
+            return true;
+        }
         MovementState.MovementStatus movementStatus = movement.update();
         if (movementStatus == UNREACHABLE || movementStatus == FAILED) {
             logDebug("Movement returns status " + movementStatus);
@@ -249,8 +255,7 @@ public class PathExecutor implements Helper {
         if (movementStatus == SUCCESS) {
             //System.out.println("Movement done, next path");
             pathPosition++;
-            ticksOnCurrent = 0;
-            clearKeys();
+            onChangeInPathPosition();
             onTick(event);
             return true;
         } else {
@@ -269,6 +274,39 @@ public class PathExecutor implements Helper {
         return false; // movement is in progress
     }
 
+    private boolean shouldPause() {
+        Optional<AbstractNodeCostSearch> current = AbstractNodeCostSearch.getCurrentlyRunning();
+        if (!current.isPresent()) {
+            return false;
+        }
+        if (!player().onGround) {
+            return false;
+        }
+        if (!MovementHelper.canWalkOn(playerFeet().down())) {
+            // we're in some kind of sketchy situation, maybe parkouring
+            return false;
+        }
+        if (!MovementHelper.canWalkThrough(playerFeet()) || !MovementHelper.canWalkThrough(playerFeet().up())) {
+            // suffocating?
+            return false;
+        }
+        if (!path.movements().get(pathPosition).safeToCancel()) {
+            return false;
+        }
+        Optional<IPath> currentBest = current.get().bestPathSoFar();
+        if (!currentBest.isPresent()) {
+            return false;
+        }
+        List<BetterBlockPos> positions = currentBest.get().positions();
+        if (positions.size() < 3) {
+            return false; // not long enough yet to justify pausing, its far from certain we'll actually take this route
+        }
+        // the first block of the next path will always overlap
+        // no need to pause our very last movement when it would have otherwise cleanly exited with MovementStatus SUCCESS
+        positions = positions.subList(1, positions.size());
+        return positions.contains(playerFeet());
+    }
+
     private boolean possiblyOffPath(Tuple<Double, BlockPos> status, double leniency) {
         double distanceFromPath = status.getFirst();
         if (distanceFromPath > leniency) {
@@ -291,6 +329,7 @@ public class PathExecutor implements Helper {
 
         // first and foremost, if allowSprint is off, or if we don't have enough hunger, don't try and sprint
         if (!new CalculationContext().canSprint()) {
+            Baritone.INSTANCE.getInputOverrideHandler().setInputForceState(InputOverrideHandler.Input.SPRINT,false);
             player().setSprinting(false);
             return;
         }
@@ -303,6 +342,9 @@ public class PathExecutor implements Helper {
             return;
         }
 
+        // we'll take it from here, no need for minecraft to see we're holding down control and sprint for us
+        Baritone.INSTANCE.getInputOverrideHandler().setInputForceState(InputOverrideHandler.Input.SPRINT,false);
+
         // however, descend doesn't request sprinting, beceause it doesn't know the context of what movement comes after it
         Movement current = path.movements().get(pathPosition);
         if (current instanceof MovementDescend && pathPosition < path.length() - 2) {
@@ -320,10 +362,20 @@ public class PathExecutor implements Helper {
             }
 
             Movement next = path.movements().get(pathPosition + 1);
+            if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
+                // a descend then an ascend in the same direction
+                if (!player().isSprinting()) {
+                    player().setSprinting(true);
+                }
+                pathPosition++;
+                // 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;
+            }
             if (canSprintInto(current, next)) {
                 if (playerFeet().equals(current.getDest())) {
                     pathPosition++;
-                    clearKeys();
+                    onChangeInPathPosition();
                 }
                 if (!player().isSprinting()) {
                     player().setSprinting(true);
@@ -332,6 +384,19 @@ public class PathExecutor implements Helper {
             }
             //logDebug("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection()));
         }
+        if (current instanceof MovementAscend && pathPosition != 0) {
+            Movement prev = path.movements().get(pathPosition - 1);
+            if (prev instanceof MovementDescend && prev.getDirection().up().equals(current.getDirection().down())) {
+                BlockPos center = current.getSrc().up();
+                if (player().posY >= center.getY()) { // playerFeet adds 0.1251 to account for soul sand
+                    Baritone.INSTANCE.getInputOverrideHandler().setInputForceState(InputOverrideHandler.Input.JUMP, false);
+                    if (!player().isSprinting()) {
+                        player().setSprinting(true);
+                    }
+                    return;
+                }
+            }
+        }
         player().setSprinting(false);
     }
 
@@ -352,6 +417,11 @@ public class PathExecutor implements Helper {
         return false;
     }
 
+    private void onChangeInPathPosition() {
+        clearKeys();
+        ticksOnCurrent = 0;
+    }
+
     private static void clearKeys() {
         // i'm just sick and tired of this snippet being everywhere lol
         Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys();
@@ -359,6 +429,7 @@ public class PathExecutor implements Helper {
 
     private void cancel() {
         clearKeys();
+        BlockBreakHelper.stopBreakingBlock();
         pathPosition = path.length() + 3;
         failed = true;
     }

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

@@ -22,48 +22,102 @@ import baritone.api.event.listener.AbstractGameEventListener;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalBlock;
 import baritone.behavior.PathingBehavior;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiMainMenu;
+import net.minecraft.client.settings.GameSettings;
+import net.minecraft.client.tutorial.TutorialSteps;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.GameType;
 import net.minecraft.world.WorldSettings;
 import net.minecraft.world.WorldType;
 
 public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
-    public static final boolean ENABLE_AUTO_TEST = true;
+
+    public static final BaritoneAutoTest INSTANCE = new BaritoneAutoTest();
+
+    private BaritoneAutoTest() {}
+
+    public static final boolean ENABLE_AUTO_TEST = "true".equals(System.getenv("BARITONE_AUTO_TEST"));
     private static final long TEST_SEED = -928872506371745L;
-    private static final BlockPos STARTING_POSITION = new BlockPos(50, 65, 50);
+    private static final BlockPos STARTING_POSITION = new BlockPos(0, 65, 0);
     private static final Goal GOAL = new GoalBlock(69, 121, 420);
-    private static final int MAX_TICKS = 3200;
+    private static final int MAX_TICKS = 3500;
+
+    /**
+     * Called right after the {@link GameSettings} object is created in the {@link Minecraft} instance.
+     */
+    public void onPreInit() {
+        if (!BaritoneAutoTest.ENABLE_AUTO_TEST) {
+            return;
+        }
+        System.out.println("Optimizing Game Settings");
+
+        GameSettings s = mc.gameSettings;
+        s.limitFramerate = 20;
+        s.mipmapLevels = 0;
+        s.particleSetting = 2;
+        s.overrideWidth = 128;
+        s.overrideHeight = 128;
+        s.heldItemTooltips = false;
+        s.entityShadows = false;
+        s.chatScale = 0.0F;
+        s.ambientOcclusion = 0;
+        s.clouds = 0;
+        s.fancyGraphics = false;
+        s.tutorialStep = TutorialSteps.NONE;
+        s.hideGUI = true;
+        s.fovSetting = 30.0F;
+    }
 
     @Override
     public void onTick(TickEvent event) {
-        if (mc.currentScreen != null && mc.currentScreen instanceof GuiMainMenu) {
+
+        // If we're on the main menu then create the test world and launch the integrated server
+        if (mc.currentScreen instanceof GuiMainMenu) {
             System.out.println("Beginning Baritone automatic test routine");
             mc.displayGuiScreen(null);
             WorldSettings worldsettings = new WorldSettings(TEST_SEED, GameType.getByName("survival"), true, false, WorldType.DEFAULT);
-            worldsettings.setGeneratorOptions("");
             mc.launchIntegratedServer("BaritoneAutoTest", "BaritoneAutoTest", worldsettings);
         }
+
+        // If the integrated server is launched and the world has initialized, set the spawn point
+        // to our defined starting position
         if (mc.getIntegratedServer() != null && mc.getIntegratedServer().worlds[0] != null) {
             mc.getIntegratedServer().worlds[0].setSpawnPoint(STARTING_POSITION);
+            mc.getIntegratedServer().worlds[0].getGameRules().setOrCreateGameRule("spawnRadius", "0");
         }
-        if (event.getType() == TickEvent.Type.IN) {
+
+        if (event.getType() == TickEvent.Type.IN) { // If we're in-game
+
+            // Force the integrated server to share the world to LAN so that
+            // the ingame pause menu gui doesn't actually pause our game
             if (mc.isSingleplayer() && !mc.getIntegratedServer().getPublic()) {
                 mc.getIntegratedServer().shareToLAN(GameType.getByName("survival"), false);
             }
-            if (event.getCount() < 100) {
+
+            // For the first 200 ticks, wait for the world to generate
+            if (event.getCount() < 200) {
                 System.out.println("Waiting for world to generate... " + event.getCount());
                 return;
             }
-            if (event.getCount() % 100 == 0) { // print only once every 5 seconds
+
+            // Print out an update of our position every 5 seconds
+            if (event.getCount() % 100 == 0) {
                 System.out.println(playerFeet() + " " + event.getCount());
             }
+
+            // Setup Baritone's pathing goal and (if needed) begin pathing
             PathingBehavior.INSTANCE.setGoal(GOAL);
             PathingBehavior.INSTANCE.path();
+
+            // If we have reached our goal, print a message and safely close the game
             if (GOAL.isInGoal(playerFeet())) {
                 System.out.println("Successfully pathed to " + playerFeet() + " in " + event.getCount() + " ticks");
                 mc.shutdown();
             }
+
+            // If we have exceeded the expected number of ticks to complete the pathing
+            // task, then throw an IllegalStateException to cause the build to fail
             if (event.getCount() > MAX_TICKS) {
                 throw new IllegalStateException("took too long");
             }

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

@@ -23,6 +23,7 @@ import baritone.api.cache.IWaypoint;
 import baritone.api.event.events.ChatEvent;
 import baritone.api.pathing.goals.*;
 import baritone.api.pathing.movement.ActionCosts;
+import baritone.api.utils.SettingsUtil;
 import baritone.behavior.Behavior;
 import baritone.behavior.FollowBehavior;
 import baritone.behavior.MineBehavior;
@@ -31,7 +32,10 @@ import baritone.cache.ChunkPacker;
 import baritone.cache.Waypoint;
 import baritone.cache.WorldProvider;
 import baritone.pathing.calc.AbstractNodeCostSearch;
-import baritone.pathing.movement.*;
+import baritone.pathing.movement.CalculationContext;
+import baritone.pathing.movement.Movement;
+import baritone.pathing.movement.MovementHelper;
+import baritone.pathing.movement.Moves;
 import net.minecraft.block.Block;
 import net.minecraft.client.multiplayer.ChunkProviderClient;
 import net.minecraft.entity.Entity;
@@ -76,6 +80,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
                 setting.value ^= true;
                 event.cancel();
                 logDirect("Toggled " + setting.getName() + " to " + setting.value);
+                SettingsUtil.save(Baritone.settings());
                 return;
             }
         }
@@ -109,6 +114,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
                         event.cancel();
                         return;
                     }
+                    SettingsUtil.save(Baritone.settings());
                     logDirect(setting.toString());
                     event.cancel();
                     return;
@@ -198,7 +204,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             event.cancel();
             return;
         }
-        if (msg.equals("cancel")) {
+        if (msg.equals("cancel") || msg.equals("stop")) {
             MineBehavior.INSTANCE.cancel();
             FollowBehavior.INSTANCE.cancel();
             PathingBehavior.INSTANCE.cancel();
@@ -477,5 +483,15 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             event.cancel();
             return;
         }
+        if (msg.equals("pause")) {
+            boolean enabled = PathingBehavior.INSTANCE.toggle();
+            logDirect("Pathing Behavior has " + (enabled ? "resumed" : "paused") + ".");
+            event.cancel();
+            return;
+        }
+        if (msg.equals("damn")) {
+            logDirect("daniel");
+            return;
+        }
     }
 }

src/main/java/baritone/utils/PathRenderer.java

@@ -18,12 +18,16 @@
 package baritone.utils;
 
 import baritone.Baritone;
+import baritone.api.event.events.RenderEvent;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalComposite;
 import baritone.api.pathing.goals.GoalTwoBlocks;
 import baritone.api.pathing.goals.GoalXZ;
-import baritone.pathing.path.IPath;
 import baritone.api.utils.interfaces.IGoalRenderPos;
+import baritone.behavior.PathingBehavior;
+import baritone.pathing.calc.AbstractNodeCostSearch;
+import baritone.pathing.path.IPath;
+import baritone.pathing.path.PathExecutor;
 import baritone.utils.pathing.BetterBlockPos;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
@@ -40,6 +44,7 @@ import net.minecraft.util.math.MathHelper;
 
 import java.awt.*;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import static org.lwjgl.opengl.GL11.*;
@@ -49,12 +54,67 @@ import static org.lwjgl.opengl.GL11.*;
  * @since 8/9/2018 4:39 PM
  */
 public final class PathRenderer implements Helper {
-    
+
     private static final Tessellator TESSELLATOR = Tessellator.getInstance();
     private static final BufferBuilder BUFFER = TESSELLATOR.getBuffer();
 
     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();
+        EntityPlayerSP player = mc.player;
+        if (goal != null && Baritone.settings().renderGoal.value) {
+            PathRenderer.drawLitDankGoalBox(player, goal, partialTicks, Baritone.settings().colorGoalBox.get());
+        }
+        if (!Baritone.settings().renderPath.get()) {
+            return;
+        }
+
+        //long start = System.nanoTime();
+
+
+        PathExecutor current = behavior.getCurrent(); // this should prevent most race conditions?
+        PathExecutor next = behavior.getNext(); // like, now it's not possible for current!=null to be true, then suddenly false because of another thread
+        // TODO is this enough, or do we need to acquire a lock here?
+        // TODO benchmark synchronized in render loop
+
+        // Render the current path, if there is one
+        if (current != null && current.getPath() != null) {
+            int renderBegin = Math.max(current.getPosition() - 3, 0);
+            PathRenderer.drawPath(current.getPath(), renderBegin, player, partialTicks, Baritone.settings().colorCurrentPath.get(), Baritone.settings().fadePath.get(), 10, 20);
+        }
+        if (next != null && next.getPath() != null) {
+            PathRenderer.drawPath(next.getPath(), 0, player, partialTicks, Baritone.settings().colorNextPath.get(), Baritone.settings().fadePath.get(), 10, 20);
+        }
+
+        //long split = System.nanoTime();
+        if (current != null) {
+            PathRenderer.drawManySelectionBoxes(player, current.toBreak(), partialTicks, Baritone.settings().colorBlocksToBreak.get());
+            PathRenderer.drawManySelectionBoxes(player, current.toPlace(), partialTicks, Baritone.settings().colorBlocksToPlace.get());
+            PathRenderer.drawManySelectionBoxes(player, current.toWalkInto(), partialTicks, Baritone.settings().colorBlocksToWalkInto.get());
+        }
+
+        // If there is a path calculation currently running, render the path calculation process
+        AbstractNodeCostSearch.getCurrentlyRunning().ifPresent(currentlyRunning -> {
+            currentlyRunning.bestPathSoFar().ifPresent(p -> {
+                PathRenderer.drawPath(p, 0, player, partialTicks, Baritone.settings().colorBestPathSoFar.get(), Baritone.settings().fadePath.get(), 10, 20);
+            });
+            currentlyRunning.pathToMostRecentNodeConsidered().ifPresent(mr -> {
+
+                PathRenderer.drawPath(mr, 0, player, partialTicks, Baritone.settings().colorMostRecentConsidered.get(), Baritone.settings().fadePath.get(), 10, 20);
+                PathRenderer.drawManySelectionBoxes(player, Collections.singletonList(mr.getDest()), partialTicks, Baritone.settings().colorMostRecentConsidered.get());
+            });
+        });
+        //long end = System.nanoTime();
+        //System.out.println((end - split) + " " + (split - start));
+        // if (end - start > 0) {
+        //   System.out.println("Frame took " + (split - start) + " " + (end - split));
+        //}
+    }
+
     public static void drawPath(IPath path, int startIndex, EntityPlayerSP player, float partialTicks, Color color, boolean fadeOut, int fadeStart0, int fadeEnd0) {
         GlStateManager.enableBlend();
         GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
@@ -68,22 +128,24 @@ public final class PathRenderer implements Helper {
         int fadeStart = fadeStart0 + startIndex;
         int fadeEnd = fadeEnd0 + startIndex;
         for (int i = startIndex; i < positions.size() - 1; i = next) {
-            BlockPos start = positions.get(i);
+            BetterBlockPos start = positions.get(i);
 
             next = i + 1;
-            BlockPos end = positions.get(next);
+            BetterBlockPos end = positions.get(next);
 
-            BlockPos direction = Utils.diff(start, end);
-            while (next + 1 < positions.size() && (!fadeOut || next + 1 < fadeStart) && direction.equals(Utils.diff(end, positions.get(next + 1)))) {
+            int dirX = end.x - start.x;
+            int dirY = end.y - start.y;
+            int dirZ = end.z - start.z;
+            while (next + 1 < positions.size() && (!fadeOut || next + 1 < fadeStart) && (dirX == positions.get(next + 1).x - end.x && dirY == positions.get(next + 1).y - end.y && dirZ == positions.get(next + 1).z - end.z)) {
                 next++;
                 end = positions.get(next);
             }
-            double x1 = start.getX();
-            double y1 = start.getY();
-            double z1 = start.getZ();
-            double x2 = end.getX();
-            double y2 = end.getY();
-            double z2 = end.getZ();
+            double x1 = start.x;
+            double y1 = start.y;
+            double z1 = start.z;
+            double x2 = end.x;
+            double y2 = end.y;
+            double z2 = end.z;
             if (fadeOut) {
 
                 float alpha;
@@ -230,26 +292,12 @@ public final class PathRenderer implements Helper {
         GlStateManager.glLineWidth(Baritone.settings().goalRenderLineWidthPixels.get());
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
-
-        if (y1 != 0) {
-            BUFFER.begin(GL_LINE_STRIP, DefaultVertexFormats.POSITION);
-            BUFFER.pos(minX, y1, minZ).endVertex();
-            BUFFER.pos(maxX, y1, minZ).endVertex();
-            BUFFER.pos(maxX, y1, maxZ).endVertex();
-            BUFFER.pos(minX, y1, maxZ).endVertex();
-            BUFFER.pos(minX, y1, minZ).endVertex();
-            TESSELLATOR.draw();
+        if (Baritone.settings().renderGoalIgnoreDepth.get()) {
+            GlStateManager.disableDepth();
         }
 
-        if (y2 != 0) {
-            BUFFER.begin(GL_LINE_STRIP, DefaultVertexFormats.POSITION);
-            BUFFER.pos(minX, y2, minZ).endVertex();
-            BUFFER.pos(maxX, y2, minZ).endVertex();
-            BUFFER.pos(maxX, y2, maxZ).endVertex();
-            BUFFER.pos(minX, y2, maxZ).endVertex();
-            BUFFER.pos(minX, y2, minZ).endVertex();
-            TESSELLATOR.draw();
-        }
+        renderHorizontalQuad(minX, maxX, minZ, maxZ, y1);
+        renderHorizontalQuad(minX, maxX, minZ, maxZ, y2);
 
         BUFFER.begin(GL_LINES, DefaultVertexFormats.POSITION);
         BUFFER.pos(minX, minY, minZ).endVertex();
@@ -262,9 +310,22 @@ public final class PathRenderer implements Helper {
         BUFFER.pos(minX, maxY, maxZ).endVertex();
         TESSELLATOR.draw();
 
-
+        if (Baritone.settings().renderGoalIgnoreDepth.get()) {
+            GlStateManager.enableDepth();
+        }
         GlStateManager.depthMask(true);
         GlStateManager.enableTexture2D();
         GlStateManager.disableBlend();
     }
+
+    private static void renderHorizontalQuad(double minX, double maxX, double minZ, double maxZ, double y) {
+        if (y != 0) {
+            BUFFER.begin(GL_LINE_LOOP, DefaultVertexFormats.POSITION);
+            BUFFER.pos(minX, y, minZ).endVertex();
+            BUFFER.pos(maxX, y, minZ).endVertex();
+            BUFFER.pos(maxX, y, maxZ).endVertex();
+            BUFFER.pos(minX, y, maxZ).endVertex();
+            TESSELLATOR.draw();
+        }
+    }
 }

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

@@ -67,7 +67,14 @@ public class ToolSet implements Helper {
      * @return how long it would take in ticks
      */
     public double getStrVsBlock(IBlockState state) {
-        return this.breakStrengthCache.computeIfAbsent(state.getBlock(), b -> calculateStrVsBlock(getBestSlot(state), state));
+        Double strength = this.breakStrengthCache.get(state.getBlock());
+        if (strength != null) {
+            // the function will take this path >99% of the time
+            return strength;
+        }
+        double str = calculateStrVsBlock(getBestSlot(state), state);
+        this.breakStrengthCache.put(state.getBlock(), str);
+        return str;
     }
 
     /**

src/main/java/baritone/utils/Utils.java

@@ -130,8 +130,4 @@ public final class Utils {
     public static double radToDeg(double rad) {
         return rad * RAD_TO_DEG;
     }
-
-    public static BlockPos diff(BlockPos a, BlockPos b) {
-        return new BlockPos(a.getX() - b.getX(), a.getY() - b.getY(), a.getZ() - b.getZ());
-    }
 }

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

@@ -36,14 +36,12 @@ public final class BetterBlockPos extends BlockPos {
     public final int x;
     public final int y;
     public final int z;
-    public final long hashCode;
 
     public BetterBlockPos(int x, int y, int z) {
         super(x, y, z);
         this.x = x;
         this.y = y;
         this.z = z;
-        this.hashCode = AbstractNodeCostSearch.posHash(x, y, z);
     }
 
     public BetterBlockPos(double x, double y, double z) {
@@ -56,7 +54,11 @@ public final class BetterBlockPos extends BlockPos {
 
     @Override
     public int hashCode() {
-        return (int) hashCode;
+        return (int) AbstractNodeCostSearch.posHash(x, y, z);
+    }
+
+    public static long longHash(BetterBlockPos pos) {
+        return AbstractNodeCostSearch.posHash(pos.x, pos.y, pos.z);
     }
 
     @Override
@@ -66,9 +68,6 @@ public final class BetterBlockPos extends BlockPos {
         }
         if (o instanceof BetterBlockPos) {
             BetterBlockPos oth = (BetterBlockPos) o;
-            if (oth.hashCode != hashCode) {
-                return false;
-            }
             return oth.x == x && oth.y == y && oth.z == z;
         }
         // during path execution, like "if (whereShouldIBe.equals(whereAmI)) {"

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

@@ -17,24 +17,27 @@
 
 package baritone.utils.pathing;
 
-import static baritone.api.pathing.movement.ActionCosts.COST_INF;
+import baritone.api.pathing.movement.ActionCosts;
 
 /**
  * The result of a calculated movement, with destination x, y, z, and the cost of performing the movement
  *
  * @author leijurv
  */
-public final class MoveResult {
-    public static final MoveResult IMPOSSIBLE = new MoveResult(0, 0, 0, COST_INF);
-    public final int destX;
-    public final int destY;
-    public final int destZ;
-    public final double cost;
+public final class MutableMoveResult {
+    public int x;
+    public int y;
+    public int z;
+    public double cost;
 
-    public MoveResult(int x, int y, int z, double cost) {
-        this.destX = x;
-        this.destY = y;
-        this.destZ = z;
-        this.cost = cost;
+    public MutableMoveResult() {
+        reset();
+    }
+
+    public final void reset() {
+        x = 0;
+        y = 0;
+        z = 0;
+        cost = ActionCosts.COST_INF;
     }
 }

src/main/resources/META-INF/services/baritone.api.IBaritoneProvider

@@ -0,0 +1 @@
+baritone.BaritoneProvider