v1.2.9

added things to avoid

.gitignore

@@ -11,8 +11,6 @@ build/
 classes/
 *.class
 
-/out
-
 # IntelliJ Files
 .idea/
 *.iml

.travis.yml

@@ -10,7 +10,7 @@ install:
 
 script:
 - docker run --rm cabaletta/baritone ./gradlew javadoc
-- docker run --name baritone cabaletta/baritone /bin/sh -c "/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; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runAutoTest; cat /code/autotest/success"
+- 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; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runClient"
 - docker cp baritone:/code/dist dist
 - ls dist
 - cat dist/checksums.txt

README.md

@@ -19,8 +19,9 @@
 ![Lines of Code](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
 [![GitHub contributors](https://img.shields.io/github/contributors/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/graphs/contributors/)
 [![GitHub commits](https://img.shields.io/github/commits-since/cabaletta/baritone/v1.0.0.svg)](https://github.com/cabaletta/baritone/commit/)
-[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.6%20/%20v1.3.2-brightgreen.svg)](https://impactdevelopment.github.io/)
+[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.8%20/%20v1.3.4%20/%20v1.4.1-brightgreen.svg)](https://impactdevelopment.github.io/)
 [![ForgeHax integration](https://img.shields.io/badge/ForgeHax%20%22integration%22-scuffed-yellow.svg)](https://github.com/fr1kin/ForgeHax/)
+[![Aristois add-on integration](https://img.shields.io/badge/Aristois%20add--on%20integration-v1.3.4%20/%20v1.4.1-green.svg)](https://gitlab.com/emc-mods-indrit/baritone_api)
 [![WWE integration](https://img.shields.io/badge/WWE%20%22integration%22-master%3F-green.svg)](https://wweclient.com/)
 [![Future integration](https://img.shields.io/badge/Future%20integration-Soon™%3F%3F%3F-red.svg)](https://futureclient.net/)
 [![forthebadge](https://forthebadge.com/images/badges/built-with-swag.svg)](http://forthebadge.com/)
@@ -30,14 +31,14 @@ A Minecraft pathfinder bot.
 
 Baritone is the pathfinding system used in [Impact](https://impactdevelopment.github.io/) since 4.4. There's a [showcase video](https://www.youtube.com/watch?v=yI8hgW_m6dQ) made by @Adovin#3153 on Baritone's integration into Impact. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a video I made showing off what it can do.
 
-The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the forge jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* forge api jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
 
-For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1).
+For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1). Or [with optifine](https://github.com/cabaletta/baritone/issues/797).
 
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8.9, rebuilt for 1.12.2 and 1.13.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
 
-Have committed at least once a day for the last 11 months =D 🦀
+Have committed at least once a day from Aug 1 2018 to Aug 1 2019.
 
 1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2
 

SETUP.md

@@ -11,6 +11,8 @@ These releases are not always completely up to date with latest features, and ar
 
 Link to the releases page: [Releases](https://github.com/cabaletta/baritone/releases)
 
+v1.2.* is for 1.12.2, v1.3.* is for 1.13.2
+
 Any official release will be GPG signed by leijurv (44A3EA646EADAC6A) and ZeroMemes (73A788379A197567). Please verify that the hash of the file you download is in `checksums.txt` and that `checksums_signed.asc` is a valid signature by those two public keys of `checksums.txt`. 
 
 The build is fully deterministic and reproducible, and you can verify Travis did it properly by running `docker build --no-cache -t cabaletta/baritone .` yourself and comparing the shasum. This works identically on Travis, Mac, and Linux (if you have docker on Windows, I'd be grateful if you could let me know if it works there too).

USAGE.md

@@ -24,7 +24,7 @@ Some common examples:
 - `goal clear` to clear the goal
 - `cancel` or `stop` to stop everything
 - `goto portal` or `goto ender_chest` or `goto block_type` to go to a block. (in Impact, `.goto` is an alias for `.b goto` for the most part)
-- `mine diamond_ore` to mine diamond ore (turn on the setting `legitMine` to only mine ores that it can actually see. It will explore randomly around y=11 until it finds them.)
+- `mine diamond_ore` to mine diamond ore (turn on the setting `legitMine` to only mine ores that it can actually see. It will explore randomly around y=11 until it finds them.) An amount of blocks can also be specified, for example, `mine diamond_ore 64`.
 - `click` to click your destination on the screen. Right click path to on top of the block, left click to path into it (either at foot level or eye level), and left click and drag to clear all blocks from an area.
 - `follow playerName` to follow a player. `followplayers` to follow any players in range (combine with Kill Aura for a fun time). `followentities` to follow any entities. `followentity pig` to follow entities of a specific type.
 - `save waypointName` to save a waypoint. `goto waypointName` to go to it.

build.gradle

@@ -16,33 +16,33 @@
  */
 
 group 'baritone'
-version '1.3.4'
+version '1.2.9'
 
 buildscript {
     repositories {
-        jcenter()
         maven {
             name = 'forge'
             url = 'http://files.minecraftforge.net/maven'
         }
         maven {
-            name = 'impactdevelopment-repo'
+            name = 'SpongePowered'
-            url = 'https://impactdevelopment.github.io/maven/'
+            url = 'http://repo.spongepowered.org/maven'
         }
+        jcenter()
     }
 
     dependencies {
-        classpath group: 'com.github.ImpactDevelopment', name: 'ForgeGradle', version: '3.0.115'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
-        classpath group: 'com.github.ImpactDevelopment', name: 'MixinGradle', version: '0.6.2'
+        classpath 'org.spongepowered:mixingradle:0.6-SNAPSHOT'
     }
 }
 
+
 import baritone.gradle.task.CreateDistTask
 import baritone.gradle.task.ProguardTask
-import org.apache.tools.ant.taskdefs.condition.Os
 
 apply plugin: 'java'
-apply plugin: 'net.minecraftforge.gradle'
+apply plugin: 'net.minecraftforge.gradle.tweaker-client'
 apply plugin: 'org.spongepowered.mixin'
 
 sourceCompatibility = targetCompatibility = '1.8'
@@ -52,19 +52,8 @@ compileJava {
 }
 
 sourceSets {
-    api {
-        compileClasspath += main.compileClasspath
-    }
-    main {
-        compileClasspath += api.output
-    }
-    test {
-        compileClasspath += main.compileClasspath + main.runtimeClasspath + main.output
-        runtimeClasspath += main.compileClasspath + main.runtimeClasspath + main.output
-    }
     launch {
         compileClasspath += main.compileClasspath + main.runtimeClasspath + main.output
-        runtimeClasspath += main.compileClasspath + main.runtimeClasspath + main.output
     }
 
     schematica_api {
@@ -76,51 +65,14 @@ sourceSets {
     }
 }
 
-task sourceJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
-    from sourceSets.api.allSource
-}
-
 minecraft {
-    mappings channel: 'snapshot', version: '20190307-1.13.1'
+    version = '1.12.2'
-    reobfMappings 'notch'
+    mappings = 'stable_39'
+    tweakClass = 'baritone.launch.BaritoneTweaker'
+    runDir = 'run'
 
-    runs {
+    // The sources jar should use SRG names not MCP to ensure compatibility with all mappings
-        client {
+    makeObfSourceJar = true
-            workingDirectory project.file('run')
-            source sourceSets.launch
-
-            main 'baritone.launch.LaunchTesting'
-
-            environment 'assetIndex', '{asset_index}'
-            environment 'assetDirectory', downloadAssets.output
-            environment 'nativesDirectory', extractNatives.output
-
-            environment 'tweakClass', 'baritone.launch.BaritoneTweaker'
-
-            if (Os.isFamily(Os.FAMILY_MAC)) {
-                jvmArgs "-XstartOnFirstThread"
-            }
-        }
-
-        autoTest {
-            workingDirectory project.file('autotest')
-            source sourceSets.launch
-
-            main 'baritone.launch.LaunchTesting'
-
-            environment 'assetIndex', '{asset_index}'
-            environment 'assetDirectory', downloadAssets.output
-            environment 'nativesDirectory', extractNatives.output
-
-            environment 'tweakClass', 'baritone.launch.BaritoneTweaker'
-            environment 'BARITONE_AUTO_TEST', 'true'
-
-            if (Os.isFamily(Os.FAMILY_MAC)) {
-                jvmArgs "-XstartOnFirstThread"
-            }
-        }
-    }
 }
 
 repositories {
@@ -138,12 +90,6 @@ repositories {
 }
 
 dependencies {
-    minecraft 'com.github.ImpactDevelopment:Vanilla:1.13.2'
-
-    runtime launchCompile('net.minecraft:launchwrapper:1.12') {
-        exclude module: 'lwjgl'
-    }
-    runtime launchCompile('org.ow2.asm:asm-debug-all:5.2')
     runtime launchCompile('com.github.ImpactDevelopment:SimpleTweaker:1.2')
     runtime launchCompile('org.spongepowered:mixin:0.7.11-SNAPSHOT') {
         // Mixin includes a lot of dependencies that are too up-to-date
@@ -153,7 +99,6 @@ dependencies {
         exclude module: 'commons-io'
         exclude module: 'log4j-core'
     }
-
     testImplementation 'junit:junit:4.12'
 }
 

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

@@ -40,13 +40,17 @@ class BaritoneGradleTask extends DefaultTask {
             PROGUARD_STANDALONE_CONFIG      = "standalone.pro",
             PROGUARD_EXPORT_PATH            = "proguard_out.jar",
 
+            TEMP_LIBRARY_DIR = "tempLibraries/",
+
             ARTIFACT_STANDARD         = "%s-%s.jar",
             ARTIFACT_UNOPTIMIZED      = "%s-unoptimized-%s.jar",
             ARTIFACT_API              = "%s-api-%s.jar",
-            ARTIFACT_STANDALONE       = "%s-standalone-%s.jar";
+            ARTIFACT_STANDALONE       = "%s-standalone-%s.jar",
+            ARTIFACT_FORGE_API        = "%s-api-forge-%s.jar",
+            ARTIFACT_FORGE_STANDALONE = "%s-standalone-forge-%s.jar";
 
     protected String artifactName, artifactVersion;
-    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, proguardOut;
+    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, artifactForgeApiPath, artifactForgeStandalonePath, proguardOut;
 
     protected void verifyArtifacts() throws IllegalStateException {
         this.artifactName = getProject().getName();
@@ -56,6 +60,8 @@ class BaritoneGradleTask extends DefaultTask {
         this.artifactUnoptimizedPath     = this.getBuildFile(formatVersion(ARTIFACT_UNOPTIMIZED));
         this.artifactApiPath             = this.getBuildFile(formatVersion(ARTIFACT_API));
         this.artifactStandalonePath      = this.getBuildFile(formatVersion(ARTIFACT_STANDALONE));
+        this.artifactForgeApiPath        = this.getBuildFile(formatVersion(ARTIFACT_FORGE_API));
+        this.artifactForgeStandalonePath = this.getBuildFile(formatVersion(ARTIFACT_FORGE_STANDALONE));
 
         this.proguardOut = this.getTemporaryFile(PROGUARD_EXPORT_PATH);
 

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

@@ -45,6 +45,8 @@ public class CreateDistTask extends BaritoneGradleTask {
         Path api             = getRelativeFile("dist/" + formatVersion(ARTIFACT_API));
         Path standalone      = getRelativeFile("dist/" + formatVersion(ARTIFACT_STANDALONE));
         Path unoptimized     = getRelativeFile("dist/" + formatVersion(ARTIFACT_UNOPTIMIZED));
+        Path forgeApi        = getRelativeFile("dist/" + formatVersion(ARTIFACT_FORGE_API));
+        Path forgeStandalone = getRelativeFile("dist/" + formatVersion(ARTIFACT_FORGE_STANDALONE));
 
         // NIO will not automatically create directories
         Path dir = getRelativeFile("dist/");
@@ -56,9 +58,11 @@ public class CreateDistTask extends BaritoneGradleTask {
         Files.copy(this.artifactApiPath,             api,             REPLACE_EXISTING);
         Files.copy(this.artifactStandalonePath,      standalone,      REPLACE_EXISTING);
         Files.copy(this.artifactUnoptimizedPath,     unoptimized,     REPLACE_EXISTING);
+        Files.copy(this.artifactForgeApiPath,        forgeApi,        REPLACE_EXISTING);
+        Files.copy(this.artifactForgeStandalonePath, forgeStandalone, REPLACE_EXISTING);
 
         // Calculate all checksums and format them like "shasum"
-        List<String> shasum = Stream.of(api, standalone, unoptimized)
+        List<String> shasum = Stream.of(api, forgeApi, standalone, forgeStandalone, unoptimized)
                 .map(path -> sha1(path) + "  " + path.getFileName().toString())
                 .collect(Collectors.toList());
 

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

@@ -18,18 +18,26 @@
 package baritone.gradle.task;
 
 import baritone.gradle.util.Determinizer;
+import baritone.gradle.util.MappingType;
+import baritone.gradle.util.ReobfWrapper;
 import org.apache.commons.io.IOUtils;
-import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.NamedDomainObjectContainer;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.internal.plugins.DefaultConvention;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.internal.Pair;
 
 import java.io.*;
+import java.lang.reflect.Field;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
+import java.util.regex.Matcher;
-import java.util.stream.Stream;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -41,12 +49,18 @@ import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
  */
 public class ProguardTask extends BaritoneGradleTask {
 
+    private static final Pattern TEMP_LIBRARY_PATTERN = Pattern.compile("-libraryjars 'tempLibraries\\/([a-zA-Z0-9/_\\-\\.]+)\\.jar'");
+
     @Input
     private String url;
 
     @Input
     private String extract;
 
+    private List<String> requiredLibraries;
+
+    private File mixin;
+
     @TaskAction
     protected void exec() throws Exception {
         super.verifyArtifacts();
@@ -56,6 +70,7 @@ public class ProguardTask extends BaritoneGradleTask {
         downloadProguard();
         extractProguard();
         generateConfigs();
+        acquireDependencies();
         proguardApi();
         proguardStandalone();
         cleanup();
@@ -66,7 +81,7 @@ public class ProguardTask extends BaritoneGradleTask {
             Files.delete(this.artifactUnoptimizedPath);
         }
 
-        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString());
+        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString(), Optional.empty());
     }
 
     private void downloadProguard() throws Exception {
@@ -99,19 +114,6 @@ public class ProguardTask extends BaritoneGradleTask {
         String out = IOUtils.toString(p.getInputStream(), "UTF-8").split("\n")[0].split("Opened ")[1].replace("]", "");
         template.add(2, "-libraryjars '" + out + "'");
 
-        // Discover all of the libraries that we will need to acquire from gradle
-        acquireDependencies().forEach(f -> {
-            if (f.toString().endsWith("-recomp.jar")) {
-                // remove MCP mapped jar
-                return;
-            }
-            if (f.toString().endsWith("client-extra.jar")) {
-                // go from the extra to the original downloaded client
-                f = new File(f.getParentFile(), "client.jar");
-            }
-            template.add(2, "-libraryjars '" + f + "'");
-        });
-
         // API config doesn't require any changes from the changes that we made to the template
         Files.write(getTemporaryFile(PROGUARD_API_CONFIG), template);
 
@@ -119,20 +121,165 @@ public class ProguardTask extends BaritoneGradleTask {
         List<String> standalone = new ArrayList<>(template);
         standalone.removeIf(s -> s.contains("# this is the keep api"));
         Files.write(getTemporaryFile(PROGUARD_STANDALONE_CONFIG), standalone);
+
+        // Discover all of the libraries that we will need to acquire from gradle
+        this.requiredLibraries = new ArrayList<>();
+        template.forEach(line -> {
+            if (!line.startsWith("#")) {
+                Matcher m = TEMP_LIBRARY_PATTERN.matcher(line);
+                if (m.find()) {
+                    this.requiredLibraries.add(m.group(1));
+                }
+            }
+        });
     }
 
-    private Stream<File> acquireDependencies() {
+    private void acquireDependencies() throws Exception {
-        return getProject().getConvention().getPlugin(JavaPluginConvention.class).getSourceSets().findByName("launch").getRuntimeClasspath().getFiles().stream().filter(File::isFile);
+
+        // Create a map of all of the dependencies that we are able to access in this project
+        // Likely a better way to do this, I just pair the dependency with the first valid configuration
+        Map<String, Pair<Configuration, Dependency>> dependencyLookupMap = new HashMap<>();
+        getProject().getConfigurations().stream().filter(Configuration::isCanBeResolved).forEach(config ->
+                config.getAllDependencies().forEach(dependency ->
+                        dependencyLookupMap.putIfAbsent(dependency.getName() + "-" + dependency.getVersion(), Pair.of(config, dependency))));
+
+        // Create the directory if it doesn't already exist
+        Path tempLibraries = getTemporaryFile(TEMP_LIBRARY_DIR);
+        if (!Files.exists(tempLibraries)) {
+            Files.createDirectory(tempLibraries);
+        }
+
+        // Iterate the required libraries to copy them to tempLibraries
+        for (String lib : this.requiredLibraries) {
+            // copy from the forgegradle cache
+            if (lib.equals("minecraft")) {
+                Path cachedJar = getMinecraftJar();
+                Path inTempDir = getTemporaryFile("tempLibraries/minecraft.jar");
+                // TODO: maybe try not to copy every time
+                Files.copy(cachedJar, inTempDir, REPLACE_EXISTING);
+
+                continue;
+            }
+
+            // Find a configuration/dependency pair that matches the desired library
+            Pair<Configuration, Dependency> pair = null;
+            for (Map.Entry<String, Pair<Configuration, Dependency>> entry : dependencyLookupMap.entrySet()) {
+                if (entry.getKey().startsWith(lib)) {
+                    pair = entry.getValue();
+                }
+            }
+
+            // The pair must be non-null
+            Objects.requireNonNull(pair);
+
+            // Find the library jar file, and copy it to tempLibraries
+            for (File file : pair.getLeft().files(pair.getRight())) {
+                if (file.getName().startsWith(lib)) {
+                    if (lib.contains("mixin")) {
+                        mixin = file;
+                    }
+                    Files.copy(file.toPath(), getTemporaryFile("tempLibraries/" + lib + ".jar"), REPLACE_EXISTING);
+                }
+            }
+        }
+        if (mixin == null) {
+            throw new IllegalStateException("Unable to find mixin jar");
+        }
+    }
+
+    // a bunch of epic stuff to get the path to the cached jar
+    private Path getMinecraftJar() throws Exception {
+        MappingType mappingType;
+        try {
+            mappingType = getMappingType();
+        } catch (Exception e) {
+            System.err.println("Failed to get mapping type, assuming NOTCH.");
+            mappingType = MappingType.NOTCH;
+        }
+
+        String suffix;
+        switch (mappingType) {
+            case NOTCH:
+                suffix = "";
+                break;
+            case SEARGE:
+                suffix = "-srgBin";
+                break;
+            case CUSTOM:
+                throw new IllegalStateException("Custom mappings not supported!");
+            default:
+                throw new IllegalStateException("Unknown mapping type: " + mappingType);
+        }
+
+        DefaultConvention convention = (DefaultConvention) this.getProject().getConvention();
+        Object extension = convention.getAsMap().get("minecraft");
+        Objects.requireNonNull(extension);
+
+        // for some reason cant use Class.forName
+        Class<?> class_baseExtension = extension.getClass().getSuperclass().getSuperclass().getSuperclass(); // <-- cursed
+        Field f_replacer = class_baseExtension.getDeclaredField("replacer");
+        f_replacer.setAccessible(true);
+        Object replacer = f_replacer.get(extension);
+        Class<?> class_replacementProvider = replacer.getClass();
+        Field replacement_replaceMap = class_replacementProvider.getDeclaredField("replaceMap");
+        replacement_replaceMap.setAccessible(true);
+
+        Map<String, Object> replacements = (Map) replacement_replaceMap.get(replacer);
+        String cacheDir = replacements.get("CACHE_DIR").toString() + "/net/minecraft";
+        String mcVersion = replacements.get("MC_VERSION").toString();
+        String mcpInsert = replacements.get("MAPPING_CHANNEL").toString() + "/" + replacements.get("MAPPING_VERSION").toString();
+        String fullJarName = "minecraft-" + mcVersion + suffix + ".jar";
+
+        String baseDir = String.format("%s/minecraft/%s/", cacheDir, mcVersion);
+
+        String jarPath;
+        if (mappingType == MappingType.SEARGE) {
+            jarPath = String.format("%s/%s/%s", baseDir, mcpInsert, fullJarName);
+        } else {
+            jarPath = baseDir + fullJarName;
+        }
+        jarPath = jarPath
+                .replace("/", File.separator)
+                .replace("\\", File.separator); // hecking regex
+
+        return new File(jarPath).toPath();
+    }
+
+    // throws IllegalStateException if mapping type is ambiguous or it fails to find it
+    private MappingType getMappingType() {
+        // if it fails to find this then its probably a forgegradle version problem
+        Set<Object> reobf = (NamedDomainObjectContainer<Object>) this.getProject().getExtensions().getByName("reobf");
+
+        List<MappingType> mappingTypes = getUsedMappingTypes(reobf);
+        long mappingTypesUsed = mappingTypes.size();
+        if (mappingTypesUsed == 0) {
+            throw new IllegalStateException("Failed to find mapping type (no jar task?)");
+        }
+        if (mappingTypesUsed > 1) {
+            throw new IllegalStateException("Ambiguous mapping type (multiple jars with different mapping types?)");
+        }
+
+        return mappingTypes.get(0);
+    }
+
+    private List<MappingType> getUsedMappingTypes(Set<Object> reobf) {
+        return reobf.stream()
+                .map(ReobfWrapper::new)
+                .map(ReobfWrapper::getMappingType)
+                .distinct()
+                .collect(Collectors.toList());
     }
 
     private void proguardApi() throws Exception {
         runProguard(getTemporaryFile(PROGUARD_API_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString(), Optional.empty());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeApiPath.toString(), Optional.of(mixin));
     }
 
     private void proguardStandalone() throws Exception {
         runProguard(getTemporaryFile(PROGUARD_STANDALONE_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString(), Optional.empty());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeStandalonePath.toString(), Optional.of(mixin));
     }
 
     private void cleanup() {

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

@@ -22,10 +22,7 @@ import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 
 import java.io.*;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
@@ -39,7 +36,7 @@ import java.util.stream.Collectors;
  */
 public class Determinizer {
 
-    public static void determinize(String inputPath, String outputPath) throws IOException {
+    public static void determinize(String inputPath, String outputPath, Optional<File> toInclude) throws IOException {
         System.out.println("Running Determinizer");
         System.out.println(" Input path: " + inputPath);
         System.out.println(" Output path: " + outputPath);
@@ -66,10 +63,30 @@ public class Determinizer {
                 if (entry.getName().endsWith(".refmap.json")) {
                     JsonObject object = new JsonParser().parse(new InputStreamReader(jarFile.getInputStream(entry))).getAsJsonObject();
                     jos.write(writeSorted(object).getBytes());
+                } else if (entry.getName().equals("META-INF/MANIFEST.MF") && toInclude.isPresent()) { // only replace for forge jar
+                    ByteArrayOutputStream cancer = new ByteArrayOutputStream();
+                    copy(jarFile.getInputStream(entry), cancer);
+                    String manifest = new String(cancer.toByteArray());
+                    if (!manifest.contains("baritone.launch.BaritoneTweaker")) {
+                        throw new IllegalStateException("unable to replace");
+                    }
+                    manifest = manifest.replace("baritone.launch.BaritoneTweaker", "org.spongepowered.asm.launch.MixinTweaker");
+                    jos.write(manifest.getBytes());
                 } else {
                     copy(jarFile.getInputStream(entry), jos);
                 }
             }
+            if (toInclude.isPresent()) {
+                try (JarFile mixin = new JarFile(toInclude.get())) {
+                    for (JarEntry entry : mixin.stream().sorted(Comparator.comparing(JarEntry::getName)).collect(Collectors.toList())) {
+                        if (entry.getName().startsWith("META-INF") && !entry.getName().startsWith("META-INF/services")) {
+                            continue;
+                        }
+                        jos.putNextEntry(entry);
+                        copy(mixin.getInputStream(entry), jos);
+                    }
+                }
+            }
             jos.finish();
         }
     }

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

@@ -0,0 +1,29 @@
+/*
+ * 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.gradle.util;
+
+/**
+ * All credits go to AsmLibGradle and its contributors.
+ *
+ * @see <a href="https://github.com/pozzed/AsmLibGradle/blob/8f917dbc3939eab7a3d9daf54d9d285fdf34f4b2/src/main/java/net/futureclient/asmlib/forgegradle/MappingType.java">Original Source</a>
+ */
+public enum MappingType {
+    SEARGE,
+    NOTCH,
+    CUSTOM // forgegradle
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.gradle.util;
+
+import java.lang.reflect.Field;
+import java.util.Objects;
+
+/**
+ * All credits go to AsmLibGradle and its contributors.
+ *
+ * @see <a href="https://github.com/pozzed/AsmLibGradle/blob/8f917dbc3939eab7a3d9daf54d9d285fdf34f4b2/src/main/java/net/futureclient/asmlib/forgegradle/ReobfWrapper.java">Original Source</a>
+ */
+public class ReobfWrapper {
+
+    private final Object instance;
+    private final Class<?> type;
+
+    public ReobfWrapper(Object instance) {
+        this.instance = instance;
+        Objects.requireNonNull(instance);
+        this.type = instance.getClass();
+    }
+
+    public String getName() {
+        try {
+            Field nameField = type.getDeclaredField("name");
+            nameField.setAccessible(true);
+            return (String) nameField.get(this.instance);
+        } catch (ReflectiveOperationException ex) {
+            throw new IllegalStateException(ex);
+        }
+    }
+
+    public MappingType getMappingType() {
+        try {
+            Field enumField = type.getDeclaredField("mappingType");
+            enumField.setAccessible(true);
+            Enum<?> aEnum = (Enum<?>) enumField.get(this.instance);
+            MappingType mappingType = MappingType.values()[aEnum.ordinal()];
+            if (!aEnum.name().equals(mappingType.name())) {
+                throw new IllegalStateException("ForgeGradle ReobfMappingType is not equivalent to MappingType (version error?)");
+            }
+            return mappingType;
+        } catch (ReflectiveOperationException ex) {
+            throw new IllegalStateException(ex);
+        }
+    }
+}

scripts/proguard.pro

@@ -14,8 +14,6 @@
 
 # lwjgl is weird
 -dontwarn org.lwjgl.**
-# also lwjgl lol
--dontwarn module-info
 
 -keep class baritone.api.** { *; } # this is the keep api
 
@@ -38,6 +36,55 @@
 #proguard doesnt like it when it cant find our fake schematica classes
 -dontwarn baritone.utils.schematic.schematica.**
 
+# copy all necessary libraries into tempLibraries to build
+
+# The correct jar will be copied from the forgegradle cache based on the mapping type being compiled with
+-libraryjars 'tempLibraries/minecraft.jar'
+
+-libraryjars 'tempLibraries/SimpleTweaker-1.2.jar'
+
+-libraryjars 'tempLibraries/authlib-1.5.25.jar'
+-libraryjars 'tempLibraries/codecjorbis-20101023.jar'
+-libraryjars 'tempLibraries/codecwav-20101023.jar'
+-libraryjars 'tempLibraries/commons-codec-1.10.jar'
+-libraryjars 'tempLibraries/commons-compress-1.8.1.jar'
+-libraryjars 'tempLibraries/commons-io-2.5.jar'
+-libraryjars 'tempLibraries/commons-lang3-3.5.jar'
+-libraryjars 'tempLibraries/commons-logging-1.1.3.jar'
+-libraryjars 'tempLibraries/fastutil-7.1.0.jar'
+-libraryjars 'tempLibraries/gson-2.8.0.jar'
+-libraryjars 'tempLibraries/guava-21.0.jar'
+-libraryjars 'tempLibraries/httpclient-4.3.3.jar'
+-libraryjars 'tempLibraries/httpcore-4.3.2.jar'
+-libraryjars 'tempLibraries/icu4j-core-mojang-51.2.jar'
+-libraryjars 'tempLibraries/jinput-2.0.5.jar'
+-libraryjars 'tempLibraries/jna-4.4.0.jar'
+-libraryjars 'tempLibraries/jopt-simple-5.0.3.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'
+
+# startsWith is used to check the library, and mac/linux differ in which version they use
+# this is FINE
+-libraryjars 'tempLibraries/lwjgl-.jar'
+-libraryjars 'tempLibraries/lwjgl_util-.jar'
+
+-libraryjars 'tempLibraries/netty-all-4.1.9.Final.jar'
+-libraryjars 'tempLibraries/oshi-core-1.1.jar'
+-libraryjars 'tempLibraries/patchy-1.1.jar'
+-libraryjars 'tempLibraries/platform-3.4.0.jar'
+-libraryjars 'tempLibraries/realms-1.10.22.jar'
+-libraryjars 'tempLibraries/soundsystem-20120107.jar'
+-libraryjars 'tempLibraries/text2speech-1.10.3.jar'
+
+-libraryjars 'tempLibraries/mixin-0.7.11-SNAPSHOT.jar'
+-libraryjars 'tempLibraries/launchwrapper-1.11.jar' # TODO why does only 1.11.jar exist?
+
+
+
 
 # Keep - Applications. Keep all application classes, along with their 'main'
 # methods.

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

@@ -124,6 +124,13 @@ public final class Settings {
      */
     public final Setting<Boolean> allowJumpAt256 = new Setting<>(false);
 
+    /**
+     * This should be monetized it's so good
+     * <p>
+     * Defaults to true, but only actually takes effect if allowParkour is also true
+     */
+    public final Setting<Boolean> allowParkourAscend = new Setting<>(true);
+
     /**
      * Allow descending diagonally
      * <p>
@@ -144,10 +151,10 @@ public final class Settings {
      * Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)
      */
     public final Setting<List<Item>> acceptableThrowawayItems = new Setting<>(new ArrayList<>(Arrays.asList(
-            Blocks.DIRT.asItem(),
+            Item.getItemFromBlock(Blocks.DIRT),
-            Blocks.COBBLESTONE.asItem(),
+            Item.getItemFromBlock(Blocks.COBBLESTONE),
-            Blocks.NETHERRACK.asItem(),
+            Item.getItemFromBlock(Blocks.NETHERRACK),
-            Blocks.STONE.asItem()
+            Item.getItemFromBlock(Blocks.STONE)
     )));
 
     /**
@@ -163,8 +170,11 @@ public final class Settings {
     public final Setting<List<Block>> blocksToAvoidBreaking = new Setting<>(new ArrayList<>(Arrays.asList( // TODO can this be a HashSet or ImmutableSet?
             Blocks.CRAFTING_TABLE,
             Blocks.FURNACE,
+            Blocks.LIT_FURNACE,
             Blocks.CHEST,
-            Blocks.TRAPPED_CHEST
+            Blocks.TRAPPED_CHEST,
+            Blocks.STANDING_SIGN,
+            Blocks.WALL_SIGN
     )));
 
     /**
@@ -178,7 +188,7 @@ public final class Settings {
      * Enables some more advanced vine features. They're honestly just gimmicks and won't ever be needed in real
      * pathing scenarios. And they can cause Baritone to get trapped indefinitely in a strange scenario.
      * <p>
-     * Never turn this on lol
+     * Almost never turn this on lol
      */
     public final Setting<Boolean> allowVines = new Setting<>(false);
 
@@ -231,11 +241,6 @@ public final class Settings {
      */
     public final Setting<Integer> rightClickSpeed = new Setting<>(4);
 
-    /**
-     * How many degrees to randomize the yaw every tick. Set to 0 to disable
-     */
-    public final Setting<Double> randomLooking = new Setting<>(2d);
-
     /**
      * This is the big A* setting.
      * As long as your cost heuristic is an *underestimate*, it's guaranteed to find you the best path.
@@ -694,11 +699,36 @@ public final class Settings {
      */
     public final Setting<Boolean> goalBreakFromAbove = new Setting<>(false);
 
+    /**
+     * Build in map art mode, which makes baritone only care about the top block in each column
+     */
+    public final Setting<Boolean> mapArtMode = new Setting<>(false);
+
+    /**
+     * Override builder's behavior to not attempt to correct blocks that are currently water
+     */
+    public final Setting<Boolean> okIfWater = new Setting<>(false);
+
+    /**
+     * The set of incorrect blocks can never grow beyond this size
+     */
+    public final Setting<Integer> incorrectSize = new Setting<>(100);
+
+    /**
+     * Multiply the cost of breaking a block that's correct in the builder's schematic by this coefficient
+     */
+    public final Setting<Double> breakCorrectBlockPenaltyMultiplier = new Setting<>(10d);
+
     /**
      * While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
      */
     public final Setting<Boolean> mineScanDroppedItems = new Setting<>(true);
 
+    /**
+     * Trim incorrect positions too far away, helps performance but hurts reliability in very large schematics
+     */
+    public final Setting<Boolean> distanceTrim = new Setting<>(true);
+
     /**
      * Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
      * <p>
@@ -812,7 +842,7 @@ public final class Settings {
      * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
      * {@link Setting#value};
      */
-    public final Setting<Consumer<ITextComponent>> logger = new Setting<>(Minecraft.getInstance().ingameGUI.getChatGUI()::printChatMessage);
+    public final Setting<Consumer<ITextComponent>> logger = new Setting<>(Minecraft.getMinecraft().ingameGUI.getChatGUI()::printChatMessage);
 
     /**
      * The size of the box that is rendered when the current goal is a GoalYLevel

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

@@ -18,11 +18,12 @@
 package baritone.api.event.listener;
 
 import baritone.api.event.events.*;
+import io.netty.util.concurrent.GenericFutureListener;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.gui.GuiGameOver;
-import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.settings.GameSettings;
 import net.minecraft.entity.Entity;
 import net.minecraft.network.Packet;
 
@@ -44,7 +45,7 @@ public interface IGameEventListener {
      * Run once per game tick from before and after the player rotation is sent to the server.
      *
      * @param event The event
-     * @see EntityPlayerSP#tick()
+     * @see EntityPlayerSP#onUpdate()
      */
     void onPlayerUpdate(PlayerUpdateEvent event);
 
@@ -60,11 +61,14 @@ public interface IGameEventListener {
      * Runs before and after whenever a chunk is either loaded, unloaded, or populated.
      *
      * @param event The event
+     * @see WorldClient#doPreChunk(int, int, boolean)
      */
     void onChunkEvent(ChunkEvent event);
 
     /**
-     * Runs once per world render pass.
+     * Runs once per world render pass. Two passes are made when {@link GameSettings#anaglyph} is on.
+     * <p>
+     * <b>Note:</b> {@link GameSettings#anaglyph} has been removed in Minecraft 1.13
      *
      * @param event The event
      */
@@ -74,7 +78,7 @@ public interface IGameEventListener {
      * Runs before and after whenever a new world is loaded
      *
      * @param event The event
-     * @see Minecraft#loadWorld(WorldClient, GuiScreen)
+     * @see Minecraft#loadWorld(WorldClient, String)
      */
     void onWorldEvent(WorldEvent event);
 
@@ -83,6 +87,7 @@ public interface IGameEventListener {
      *
      * @param event The event
      * @see Packet
+     * @see GenericFutureListener
      */
     void onSendPacket(PacketEvent event);
 
@@ -91,6 +96,7 @@ public interface IGameEventListener {
      *
      * @param event The event
      * @see Packet
+     * @see GenericFutureListener
      */
     void onReceivePacket(PacketEvent event);
 
@@ -104,10 +110,10 @@ public interface IGameEventListener {
     void onPlayerRotationMove(RotationMoveEvent event);
 
     /**
-     * Called whenever the sprint keybind state is checked in {@link EntityPlayerSP#livingTick}
+     * Called whenever the sprint keybind state is checked in {@link EntityPlayerSP#onLivingUpdate}
      *
      * @param event The event
-     * @see EntityPlayerSP#livingTick()
+     * @see EntityPlayerSP#onLivingUpdate()
      */
     void onPlayerSprintState(SprintStateEvent event);
 

src/api/java/baritone/api/process/IBuilderProcess.java

@@ -50,7 +50,7 @@ public interface IBuilderProcess extends IBaritoneProcess {
     boolean build(String name, File schematic, Vec3i origin);
 
     default boolean build(String schematicFile, BlockPos origin) {
-        File file = new File(new File(Minecraft.getInstance().gameDir, "schematics"), schematicFile);
+        File file = new File(new File(Minecraft.getMinecraft().gameDir, "schematics"), schematicFile);
         return build(schematicFile, file, origin);
     }
 

src/api/java/baritone/api/utils/BlockUtils.java

@@ -19,7 +19,6 @@ package baritone.api.utils;
 
 import net.minecraft.block.Block;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.registry.IRegistry;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -29,7 +28,7 @@ public class BlockUtils {
     private static transient Map<String, Block> resourceCache = new HashMap<>();
 
     public static String blockToString(Block block) {
-        ResourceLocation loc = IRegistry.BLOCK.getKey(block);
+        ResourceLocation loc = Block.REGISTRY.getNameForObject(block);
         String name = loc.getPath(); // normally, only write the part after the minecraft:
         if (!loc.getNamespace().equals("minecraft")) {
             // Baritone is running on top of forge with mods installed, perhaps?
@@ -53,7 +52,7 @@ public class BlockUtils {
         if (resourceCache.containsKey(name)) {
             return null; // cached as null
         }
-        block = IRegistry.BLOCK.get(ResourceLocation.tryCreate(name.contains(":") ? name : "minecraft:" + name));
+        block = Block.getBlockFromName(name.contains(":") ? name : "minecraft:" + name);
         Map<String, Block> copy = new HashMap<>(resourceCache); // read only copy is safe, wont throw concurrentmodification
         copy.put(name, block);
         resourceCache = copy;

src/api/java/baritone/api/utils/ExampleBaritoneControl.java

@@ -38,16 +38,20 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.ReportedException;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraft.util.text.event.ClickEvent;
+import net.minecraft.world.DimensionType;
 import net.minecraft.world.chunk.Chunk;
 
 import java.nio.file.Path;
 import java.util.*;
 
+import static org.apache.commons.lang3.math.NumberUtils.isCreatable;
+
 public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
     private static final String COMMAND_PREFIX = "#";
 
@@ -119,7 +123,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return true;
         }
         if (msg.equals("") || msg.equals("help") || msg.equals("?")) {
-            ITextComponent component = MESSAGE_PREFIX.shallowCopy();
+            ITextComponent component = MESSAGE_PREFIX.createCopy();
             component.getStyle().setColor(TextFormatting.GRAY);
             TextComponentString helpLink = new TextComponentString(" Click here for instructions on how to use Baritone (https://github.com/cabaletta/baritone/blob/master/USAGE.md)");
             helpLink.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, "https://github.com/cabaletta/baritone/blob/master/USAGE.md"));
@@ -177,6 +181,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             StringBuilder meme = new StringBuilder();
             CrashReport rep = new CrashReport("Manually triggered debug crash", new Throwable());
             mc.addGraphicsAndWorldToCrashReport(rep);
+            new ReportedException(rep).printStackTrace();
             rep.getSectionsInStringBuilder(meme);
             System.out.println(meme);
             logDirect(meme.toString());
@@ -236,20 +241,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return true;
         }
         if (msg.equals("repack") || msg.equals("rescan")) {
-            ChunkProviderClient cli = (ChunkProviderClient) ctx.world().getChunkProvider();
+            logDirect("Queued " + repack() + " chunks for repacking");
-            int playerChunkX = ctx.playerFeet().getX() >> 4;
-            int playerChunkZ = ctx.playerFeet().getZ() >> 4;
-            int count = 0;
-            for (int x = playerChunkX - 40; x <= playerChunkX + 40; x++) {
-                for (int z = playerChunkZ - 40; z <= playerChunkZ + 40; z++) {
-                    Chunk chunk = cli.getChunk(x, z, false, false);
-                    if (chunk != null) {
-                        count++;
-                        baritone.getWorldProvider().getCurrentWorld().getCachedWorld().queueForPacking(chunk);
-                    }
-                }
-            }
-            logDirect("Queued " + count + " chunks for repacking");
             return true;
         }
         if (msg.startsWith("build")) {
@@ -258,7 +250,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             try {
                 String[] coords = msg.substring("build".length()).trim().split(" ");
                 file = coords[0] + ".schematic";
-                origin = new BlockPos(parseOrDefault(coords[1], ctx.playerFeet().x), parseOrDefault(coords[2], ctx.playerFeet().y), parseOrDefault(coords[3], ctx.playerFeet().z));
+                origin = new BlockPos(parseOrDefault(coords[1], ctx.playerFeet().x, 1), parseOrDefault(coords[2], ctx.playerFeet().y, 1), parseOrDefault(coords[3], ctx.playerFeet().z, 1));
             } catch (Exception ex) {
                 file = msg.substring(5).trim() + ".schematic";
                 origin = ctx.playerFeet();
@@ -368,7 +360,8 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
         }
         if (msg.equals("render")) {
             BetterBlockPos pf = ctx.playerFeet();
-            Minecraft.getInstance().worldRenderer.markBlockRangeForRenderUpdate(pf.x - 500, pf.y - 500, pf.z - 500, pf.x + 500, pf.y + 500, pf.z + 500);
+            int dist = (Minecraft.getMinecraft().gameSettings.renderDistanceChunks + 1) * 16;
+            Minecraft.getMinecraft().renderGlobal.markBlockRangeForRenderUpdate(pf.x - dist, pf.y - 256, pf.z - dist, pf.x + dist, pf.y + 256, pf.z + dist);
             logDirect("okay");
             return true;
         }
@@ -398,7 +391,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             String name = msg.substring(12).trim();
             Optional<Entity> toFollow = Optional.empty();
             for (Entity entity : ctx.world().loadedEntityList) {
-                String entityName = entity.getName().getFormattedText().trim().toLowerCase();
+                String entityName = entity.getName().trim().toLowerCase();
                 if ((entityName.contains(name) || name.contains(entityName)) && !(entity instanceof EntityItem || entity instanceof EntityPlayer)) { // We dont want it following players while `#follow` exists.
                     toFollow = Optional.of(entity);
                 }
@@ -419,8 +412,8 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
                 toFollow = ctx.getSelectedEntity();
             } else {
                 for (EntityPlayer pl : ctx.world().playerEntities) {
-                    String theirName = pl.getName().getString().trim().toLowerCase();
+                    String theirName = pl.getName().trim().toLowerCase();
-                    if (!theirName.equals(ctx.player().getName().getString().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
+                    if (!theirName.equals(ctx.player().getName().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
                         toFollow = Optional.of(pl);
                     }
                 }
@@ -441,7 +434,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             // means that entries in blah.json are NOT already explored
             String path = msg.substring("explorefilter".length()).trim();
             String[] parts = path.split(" ");
-            Path path1 = Minecraft.getInstance().gameDir.toPath().resolve(parts[0]);
+            Path path1 = Minecraft.getMinecraft().gameDir.toPath().resolve(parts[0]);
             boolean invert = parts.length > 1;
             try {
                 baritone.getExploreProcess().applyJsonFilter(path1, invert);
@@ -496,6 +489,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return true;
         }
         if (msg.startsWith("find")) {
+            repack();
             String blockType = msg.substring(4).trim();
             ArrayList<BlockPos> locs = baritone.getWorldProvider().getCurrentWorld().getCachedWorld().getLocationsOf(blockType, 1, ctx.playerFeet().getX(), ctx.playerFeet().getZ(), 4);
             logDirect("Have " + locs.size() + " locations");
@@ -508,6 +502,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return true;
         }
         if (msg.startsWith("mine")) {
+            repack();
             String[] blockTypes = msg.substring(4).trim().split(" ");
             try {
                 int quantity = Integer.parseInt(blockTypes[1]);
@@ -597,6 +592,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return true;
         }
         if (msg.startsWith("goto")) {
+            repack();
             String waypointType = msg.substring(4).trim();
             if (waypointType.endsWith("s") && IWaypoint.Tag.fromString(waypointType.substring(0, waypointType.length() - 1)) != null) {
                 // for example, "show deaths"
@@ -670,14 +666,31 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
         return false;
     }
 
-    private int parseOrDefault(String str, int i) {
+    private int repack() {
-        return str.equals("~") ? i : str.startsWith("~") ? Integer.parseInt(str.substring(1)) + i : Integer.parseInt(str);
+        ChunkProviderClient cli = (ChunkProviderClient) ctx.world().getChunkProvider();
+        int playerChunkX = ctx.playerFeet().getX() >> 4;
+        int playerChunkZ = ctx.playerFeet().getZ() >> 4;
+        int count = 0;
+        for (int x = playerChunkX - 40; x <= playerChunkX + 40; x++) {
+            for (int z = playerChunkZ - 40; z <= playerChunkZ + 40; z++) {
+                Chunk chunk = cli.getLoadedChunk(x, z);
+                if (chunk != null && !chunk.isEmpty()) {
+                    count++;
+                    baritone.getWorldProvider().getCurrentWorld().getCachedWorld().queueForPacking(chunk);
+                }
+            }
+        }
+        return count;
+    }
+
+    private int parseOrDefault(String str, int i, double dimensionFactor) {
+        return str.equals("~") ? i : str.startsWith("~") ? (int) (Integer.parseInt(str.substring(1)) * dimensionFactor) + i : (int) (Integer.parseInt(str) * dimensionFactor);
     }
 
     private void log(List<ItemStack> stacks) {
         for (ItemStack stack : stacks) {
             if (!stack.isEmpty()) {
-                logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getDamage());
+                logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getItemDamage());
             }
         }
     }
@@ -686,18 +699,23 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
         Goal goal;
         try {
             BetterBlockPos playerFeet = ctx.playerFeet();
-            switch (params.length) {
+
+            int length = params.length - 1; // length has to be smaller when a dimension parameter is added
+            if (params.length < 1 || (isCreatable(params[params.length - 1]) || params[params.length - 1].startsWith("~"))) {
+                length = params.length;
+            }
+            switch (length) {
                 case 0:
                     goal = new GoalBlock(playerFeet);
                     break;
                 case 1:
-                    goal = new GoalYLevel(parseOrDefault(params[0], playerFeet.y));
+                    goal = new GoalYLevel(parseOrDefault(params[0], playerFeet.y, 1));
                     break;
                 case 2:
-                    goal = new GoalXZ(parseOrDefault(params[0], playerFeet.x), parseOrDefault(params[1], playerFeet.z));
+                    goal = new GoalXZ(parseOrDefault(params[0], playerFeet.x, calculateDimensionFactor(params[params.length - 1])), parseOrDefault(params[1], playerFeet.z, calculateDimensionFactor(params[params.length - 1])));
                     break;
                 case 3:
-                    goal = new GoalBlock(new BlockPos(parseOrDefault(params[0], playerFeet.x), parseOrDefault(params[1], playerFeet.y), parseOrDefault(params[2], playerFeet.z)));
+                    goal = new GoalBlock(new BlockPos(parseOrDefault(params[0], playerFeet.x, calculateDimensionFactor(params[params.length - 1])), parseOrDefault(params[1], playerFeet.y, 1), parseOrDefault(params[2], playerFeet.z, calculateDimensionFactor(params[params.length - 1]))));
                     break;
                 default:
                     logDirect("unable to understand lol");
@@ -709,4 +727,23 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
         }
         return goal;
     }
+
+
+    private double calculateDimensionFactor(String to) {
+        return Math.pow(8, ctx.world().provider.getDimensionType().getId() - getDimensionByName(to.toLowerCase()).getId());
+    }
+
+    private DimensionType getDimensionByName(String name) {
+        if ("the_end".contains(name)) {
+            return DimensionType.THE_END;
+        }
+        if ("the_overworld".contains(name) || "surface".contains(name)) {
+            return DimensionType.OVERWORLD;
+        }
+        if ("the_nether".contains(name) || "hell".contains(name)) {
+            return DimensionType.NETHER;
+        }
+        return ctx.world().provider.getDimensionType();
+    }
+
 }

src/api/java/baritone/api/utils/Helper.java

@@ -42,7 +42,7 @@ public interface Helper {
             TextFormatting.GRAY
     ));
 
-    Minecraft mc = Minecraft.getInstance();
+    Minecraft mc = Minecraft.getMinecraft();
 
     /**
      * Send a message to chat only if chatDebug is on
@@ -64,9 +64,9 @@ public interface Helper {
      * @param message The message to display in chat
      */
     default void logDirect(String message) {
-        ITextComponent component = MESSAGE_PREFIX.shallowCopy();
+        ITextComponent component = MESSAGE_PREFIX.createCopy();
         component.getStyle().setColor(TextFormatting.GRAY);
         component.appendSibling(new TextComponentString(" " + message));
-        Minecraft.getInstance().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+        Minecraft.getMinecraft().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
     }
 }

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

@@ -72,7 +72,7 @@ public interface IPlayerContext {
      */
     default Optional<BlockPos> getSelectedBlock() {
         RayTraceResult result = objectMouseOver();
-        if (result != null && result.type == RayTraceResult.Type.BLOCK) {
+        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
             return Optional.of(result.getBlockPos());
         }
         return Optional.empty();
@@ -89,8 +89,8 @@ public interface IPlayerContext {
      */
     default Optional<Entity> getSelectedEntity() {
         RayTraceResult result = objectMouseOver();
-        if (result != null && result.type == RayTraceResult.Type.ENTITY) {
+        if (result != null && result.typeOfHit == RayTraceResult.Type.ENTITY) {
-            return Optional.of(result.entity);
+            return Optional.of(result.entityHit);
         }
         return Optional.empty();
     }

src/api/java/baritone/api/utils/MyChunkPos.java

@@ -27,7 +27,7 @@ public class MyChunkPos {
     @SerializedName("x")
     public int x;
 
-    @SerializedName("y")
+    @SerializedName("z")
     public int z;
 
     @Override

src/api/java/baritone/api/utils/RayTraceUtils.java

@@ -18,7 +18,6 @@
 package baritone.api.utils;
 
 import net.minecraft.entity.Entity;
-import net.minecraft.util.math.RayTraceFluidMode;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
 
@@ -41,13 +40,13 @@ public final class RayTraceUtils {
      * @return The calculated raytrace result
      */
     public static RayTraceResult rayTraceTowards(Entity entity, Rotation rotation, double blockReachDistance) {
-        Vec3d start = entity.getEyePosition(1.0F);
+        Vec3d start = entity.getPositionEyes(1.0F);
         Vec3d direction = RotationUtils.calcVec3dFromRotation(rotation);
         Vec3d end = start.add(
                 direction.x * blockReachDistance,
                 direction.y * blockReachDistance,
                 direction.z * blockReachDistance
         );
-        return entity.world.rayTraceBlocks(start, end, RayTraceFluidMode.NEVER, false, true);
+        return entity.world.rayTraceBlocks(start, end, false, false, true);
     }
 }

src/api/java/baritone/api/utils/Rotation.java

@@ -36,9 +36,6 @@ public class Rotation {
     public Rotation(float yaw, float pitch) {
         this.yaw = yaw;
         this.pitch = pitch;
-        if (Float.isInfinite(yaw) || Float.isNaN(yaw) || Float.isInfinite(pitch) || Float.isNaN(pitch)) {
-            throw new IllegalStateException(yaw + " " + pitch);
-        }
     }
 
     /**

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

@@ -23,13 +23,7 @@ import net.minecraft.block.BlockFire;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.*;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
-import net.minecraft.util.math.shapes.VoxelShape;
-import net.minecraft.util.math.shapes.VoxelShapes;
 
 import java.util.Optional;
 
@@ -180,14 +174,11 @@ public final class RotationUtils {
         }
 
         IBlockState state = entity.world.getBlockState(pos);
-        VoxelShape shape = state.getShape(entity.world, pos);
+        AxisAlignedBB aabb = state.getBoundingBox(entity.world, pos);
-        if (shape.isEmpty()) {
-            shape = VoxelShapes.fullCube();
-        }
         for (Vec3d sideOffset : BLOCK_SIDE_MULTIPLIERS) {
-            double xDiff = shape.getStart(EnumFacing.Axis.X) * sideOffset.x + shape.getEnd(EnumFacing.Axis.X) * (1 - sideOffset.x);
+            double xDiff = aabb.minX * sideOffset.x + aabb.maxX * (1 - sideOffset.x);
-            double yDiff = shape.getStart(EnumFacing.Axis.Y) * sideOffset.y + shape.getEnd(EnumFacing.Axis.Y) * (1 - sideOffset.y);
+            double yDiff = aabb.minY * sideOffset.y + aabb.maxY * (1 - sideOffset.y);
-            double zDiff = shape.getStart(EnumFacing.Axis.Z) * sideOffset.z + shape.getEnd(EnumFacing.Axis.Z) * (1 - sideOffset.z);
+            double zDiff = aabb.minZ * sideOffset.z + aabb.maxZ * (1 - sideOffset.z);
             possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance);
             if (possibleRotation.isPresent()) {
                 return possibleRotation;
@@ -208,10 +199,10 @@ public final class RotationUtils {
      * @return The optional rotation
      */
     public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance) {
-        Rotation rotation = calcRotationFromVec3d(entity.getEyePosition(1.0F), offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
+        Rotation rotation = calcRotationFromVec3d(entity.getPositionEyes(1.0F), offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
         RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance);
         //System.out.println(result);
-        if (result != null && result.type == RayTraceResult.Type.BLOCK) {
+        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
             if (result.getBlockPos().equals(pos)) {
                 return Optional.of(rotation);
             }

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

@@ -19,11 +19,8 @@ package baritone.api.utils;
 
 import baritone.api.Settings;
 import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
 import net.minecraft.item.Item;
 import net.minecraft.util.EnumFacing;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.registry.IRegistry;
 import net.minecraft.util.math.Vec3i;
 
 import java.awt.*;
@@ -45,11 +42,12 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import static net.minecraft.client.Minecraft.getMinecraft;
 
 public class SettingsUtil {
-    private static final Path SETTINGS_PATH = Minecraft.getInstance().gameDir.toPath().resolve("baritone").resolve("settings.txt");
-    private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>.+)"); // key and value split by the first space
 
+    private static final Path SETTINGS_PATH = getMinecraft().gameDir.toPath().resolve("baritone").resolve("settings.txt");
+    private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>.+)"); // key and value split by the first space
 
     private static boolean isComment(String line) {
         return line.startsWith("#") || line.startsWith("//");
@@ -194,14 +192,15 @@ public class SettingsUtil {
         ),
         ITEM(
                 Item.class,
-                str -> IRegistry.ITEM.get(new ResourceLocation(str.trim())),
+                str -> Item.getByNameOrId(str.trim()),
-                item -> IRegistry.ITEM.getKey(item).toString()
+                item -> Item.REGISTRY.getNameForObject(item).toString()
         ),
         LIST() {
             @Override
             public Object parse(ParserContext context, String raw) {
                 Type type = ((ParameterizedType) context.getSetting().getType()).getActualTypeArguments()[0];
                 Parser parser = Parser.getParser(type);
+
                 return Arrays.stream(raw.split(","))
                         .map(s -> parser.parse(context, s))
                         .collect(Collectors.toList());

src/api/java/baritone/api/utils/VecUtils.java

@@ -20,10 +20,9 @@ package baritone.api.utils;
 import net.minecraft.block.BlockFire;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
-import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.world.World;
 
 /**
@@ -44,16 +43,10 @@ public final class VecUtils {
      */
     public static Vec3d calculateBlockCenter(World world, BlockPos pos) {
         IBlockState b = world.getBlockState(pos);
-        VoxelShape shape = b.getCollisionShape(world, pos);
+        AxisAlignedBB bbox = b.getBoundingBox(world, pos);
-        if (shape.isEmpty()) {
+        double xDiff = (bbox.minX + bbox.maxX) / 2;
-            return getBlockPosCenter(pos);
+        double yDiff = (bbox.minY + bbox.maxY) / 2;
-        }
+        double zDiff = (bbox.minZ + bbox.maxZ) / 2;
-        double xDiff = (shape.getStart(EnumFacing.Axis.X) + shape.getEnd(EnumFacing.Axis.X)) / 2;
-        double yDiff = (shape.getStart(EnumFacing.Axis.Y) + shape.getEnd(EnumFacing.Axis.Y)) / 2;
-        double zDiff = (shape.getStart(EnumFacing.Axis.Z) + shape.getEnd(EnumFacing.Axis.Z)) / 2;
-        if (Double.isNaN(xDiff) || Double.isNaN(yDiff) || Double.isNaN(zDiff)) {
-            throw new IllegalStateException(b + " " + pos + " " + shape);
-        }
         if (b.getBlock() instanceof BlockFire) {//look at bottom of fire when putting it out
             yDiff = 0;
         }

src/launch/java/baritone/launch/LaunchTesting.java

@@ -1,105 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.launch;
-
-import com.google.common.base.Strings;
-import com.google.gson.GsonBuilder;
-import com.mojang.authlib.Agent;
-import com.mojang.authlib.exceptions.AuthenticationException;
-import com.mojang.authlib.properties.PropertyMap;
-import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-import com.mojang.authlib.yggdrasil.YggdrasilUserAuthentication;
-import net.minecraft.launchwrapper.Launch;
-
-import java.io.File;
-import java.lang.reflect.Field;
-import java.net.Proxy;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Based on GradleStart from ForgeGradle 2.3
- *
- * @author Brady
- * @since 3/11/2019
- */
-public class LaunchTesting {
-
-    public static void main(String[] args) {
-        Map<String, String> arguments = new HashMap<>();
-
-        hackNatives();
-        arguments.put("version", "BaritownedDeveloperEnvironment");
-        arguments.put("assetIndex", System.getenv("assetIndex"));
-        arguments.put("assetsDir", System.getenv().getOrDefault("assetDirectory", "assets"));
-        arguments.put("accessToken", "FML");
-        arguments.put("userProperties", "{}");
-        arguments.put("tweakClass", System.getenv("tweakClass"));
-        String password = System.getenv("password");
-        if (password != null && !password.isEmpty()) {
-            attemptLogin(arguments, System.getenv("username"), System.getenv("password"));
-        }
-
-        List<String> argsArray = new ArrayList<>();
-        arguments.forEach((k, v) -> {
-            argsArray.add("--" + k);
-            argsArray.add(v);
-        });
-
-        Launch.main(argsArray.toArray(new String[0]));
-    }
-
-    private static void hackNatives() {
-        String paths = System.getProperty("java.library.path");
-        String nativesDir = System.getenv().get("nativesDirectory");
-
-        if (Strings.isNullOrEmpty(paths))
-            paths = nativesDir;
-        else
-            paths += File.pathSeparator + nativesDir;
-
-        System.setProperty("java.library.path", paths);
-
-        // hack the classloader now.
-        try {
-            final Field sysPathsField = ClassLoader.class.getDeclaredField("sys_paths");
-            sysPathsField.setAccessible(true);
-            sysPathsField.set(null, null);
-        } catch (Throwable ignored) {}
-    }
-
-    private static void attemptLogin(Map<String, String> argMap, String username, String password) {
-        YggdrasilUserAuthentication auth = (YggdrasilUserAuthentication) (new YggdrasilAuthenticationService(Proxy.NO_PROXY, "1")).createUserAuthentication(Agent.MINECRAFT);
-        auth.setUsername(username);
-        auth.setPassword(password);
-
-        try {
-            auth.logIn();
-        } catch (AuthenticationException var4) {
-            throw new RuntimeException(var4);
-        }
-
-        argMap.put("accessToken", auth.getAuthenticatedToken());
-        argMap.put("uuid", auth.getSelectedProfile().getId().toString().replace("-", ""));
-        argMap.put("username", auth.getSelectedProfile().getName());
-        argMap.put("userType", auth.getUserType().getName());
-        argMap.put("userProperties", (new GsonBuilder()).registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer()).create().toJson(auth.getUserProperties()));
-    }
-}

src/launch/java/baritone/launch/mixins/MixinChunkRenderContainer.java

@@ -28,10 +28,7 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
 
-import static org.lwjgl.opengl.GL11.GL_ONE;
+import static org.lwjgl.opengl.GL11.*;
-import static org.lwjgl.opengl.GL11.GL_ZERO;
-import static org.lwjgl.opengl.GL14.GL_CONSTANT_ALPHA;
-import static org.lwjgl.opengl.GL14.GL_ONE_MINUS_CONSTANT_ALPHA;
 
 @Mixin(ChunkRenderContainer.class)
 public class MixinChunkRenderContainer {
@@ -44,11 +41,11 @@ public class MixinChunkRenderContainer {
             )
     )
     private BlockPos getPosition(RenderChunk renderChunkIn) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getInstance().isSingleplayer() && Minecraft.getInstance().world.getChunk(renderChunkIn.getPosition()).isEmpty()) {
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer() && Minecraft.getMinecraft().world.getChunk(renderChunkIn.getPosition()).isEmpty()) {
-            GlStateManager.enableAlphaTest();
+            GlStateManager.enableAlpha();
             GlStateManager.enableBlend();
             GL14.glBlendColor(0, 0, 0, Baritone.settings().cachedChunksOpacity.value);
-            GlStateManager.blendFuncSeparate(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.tryBlendFuncSeparate(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_ONE, GL_ZERO);
         }
         return renderChunkIn.getPosition();
     }

src/launch/java/baritone/launch/mixins/MixinChunkRenderWorker.java

@@ -43,7 +43,7 @@ public abstract class MixinChunkRenderWorker {
             )
     )
     private boolean isChunkExisting(ChunkRenderWorker worker, BlockPos pos, World world) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getInstance().isSingleplayer()) {
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
             Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
             IPlayerContext ctx = baritone.getPlayerContext();
             if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {

src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java

@@ -23,7 +23,6 @@ import baritone.api.event.events.RotationMoveEvent;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.EntityType;
 import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -45,8 +44,9 @@ public abstract class MixinEntityLivingBase extends Entity {
      */
     private RotationMoveEvent jumpRotationEvent;
 
-    public MixinEntityLivingBase(EntityType<?> entityTypeIn, World worldIn) {
+    public MixinEntityLivingBase(World worldIn, RotationMoveEvent jumpRotationEvent) {
-        super(entityTypeIn, worldIn);
+        super(worldIn);
+        this.jumpRotationEvent = jumpRotationEvent;
     }
 
     @Inject(

src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java

@@ -58,10 +58,10 @@ public class MixinEntityPlayerSP {
     }
 
     @Inject(
-            method = "tick",
+            method = "onUpdate",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/client/entity/EntityPlayerSP.isPassenger()Z",
+                    target = "net/minecraft/client/entity/EntityPlayerSP.isRiding()Z",
                     shift = At.Shift.BY,
                     by = -3
             )
@@ -74,7 +74,7 @@ public class MixinEntityPlayerSP {
     }
 
     @Inject(
-            method = "tick",
+            method = "onUpdate",
             at = @At(
                     value = "INVOKE",
                     target = "net/minecraft/client/entity/EntityPlayerSP.onUpdateWalkingPlayer()V",
@@ -90,7 +90,7 @@ public class MixinEntityPlayerSP {
     }
 
     @Redirect(
-            method = "livingTick",
+            method = "onLivingUpdate",
             at = @At(
                     value = "FIELD",
                     target = "net/minecraft/entity/player/PlayerCapabilities.allowFlying:Z"
@@ -105,7 +105,7 @@ public class MixinEntityPlayerSP {
     }
 
     @Redirect(
-            method = "livingTick",
+            method = "onLivingUpdate",
             at = @At(
                     value = "INVOKE",
                     target = "net/minecraft/client/settings/KeyBinding.isKeyDown()Z"

src/launch/java/baritone/launch/mixins/MixinEntityRenderer.java

@@ -20,24 +20,24 @@ package baritone.launch.mixins;
 import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.event.events.RenderEvent;
-import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.EntityRenderer;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(GameRenderer.class)
+@Mixin(EntityRenderer.class)
-public class MixinGameRenderer {
+public class MixinEntityRenderer {
 
     @Inject(
-            method = "updateCameraAndRender(FJ)V",
+            method = "renderWorldPass",
             at = @At(
                     value = "INVOKE_STRING",
                     target = "Lnet/minecraft/profiler/Profiler;endStartSection(Ljava/lang/String;)V",
                     args = {"ldc=hand"}
             )
     )
-    private void renderWorldPass(float partialTicks, long finishTimeNano, CallbackInfo ci) {
+    private void renderWorldPass(int pass, float partialTicks, long finishTimeNano, CallbackInfo ci) {
         for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
             ibaritone.getGameEventHandler().onRenderPass(new RenderEvent(partialTicks));
         }

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

@@ -97,10 +97,10 @@ public class MixinMinecraft {
     }
 
     @Inject(
-            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Lnet/minecraft/client/gui/GuiScreen;)V",
+            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Ljava/lang/String;)V",
             at = @At("HEAD")
     )
-    private void preLoadWorld(WorldClient world, GuiScreen loadingScreen, CallbackInfo ci) {
+    private void preLoadWorld(WorldClient world, String loadingMessage, CallbackInfo ci) {
         // If we're unloading the world but one doesn't exist, ignore it
         if (this.world == null && world == null) {
             return;
@@ -117,10 +117,10 @@ public class MixinMinecraft {
     }
 
     @Inject(
-            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Lnet/minecraft/client/gui/GuiScreen;)V",
+            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Ljava/lang/String;)V",
             at = @At("RETURN")
     )
-    private void postLoadWorld(WorldClient world, GuiScreen loadingScreen, CallbackInfo ci) {
+    private void postLoadWorld(WorldClient world, String loadingMessage, CallbackInfo ci) {
         // still fire event for both null, as that means we've just finished exiting a world
 
         // mc.world changing is only the primary baritone

src/launch/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java

@@ -24,7 +24,6 @@ import baritone.api.event.events.type.EventState;
 import net.minecraft.client.network.NetHandlerPlayClient;
 import net.minecraft.network.play.server.SPacketChunkData;
 import net.minecraft.network.play.server.SPacketCombatEvent;
-import net.minecraft.network.play.server.SPacketUnloadChunk;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -41,7 +40,7 @@ public class MixinNetHandlerPlayClient {
             method = "handleChunkData",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/client/multiplayer/ChunkProviderClient.func_212474_a(IILnet/minecraft/network/PacketBuffer;IZ)Lnet/minecraft/world/chunk/Chunk;"
+                    target = "net/minecraft/world/chunk/Chunk.read(Lnet/minecraft/network/PacketBuffer;IZ)V"
             )
     )
     private void preRead(SPacketChunkData packetIn, CallbackInfo ci) {
@@ -78,34 +77,6 @@ public class MixinNetHandlerPlayClient {
         }
     }
 
-    @Inject(
-            method = "processChunkUnload",
-            at = @At("HEAD")
-    )
-    private void preChunkUnload(SPacketUnloadChunk packet, CallbackInfo ci) {
-        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
-            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
-                ibaritone.getGameEventHandler().onChunkEvent(
-                        new ChunkEvent(EventState.PRE, ChunkEvent.Type.UNLOAD, packet.getX(), packet.getZ())
-                );
-            }
-        }
-    }
-
-    @Inject(
-            method = "processChunkUnload",
-            at = @At("RETURN")
-    )
-    private void postChunkUnload(SPacketUnloadChunk packet, CallbackInfo ci) {
-        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
-            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
-                ibaritone.getGameEventHandler().onChunkEvent(
-                        new ChunkEvent(EventState.POST, ChunkEvent.Type.UNLOAD, packet.getX(), packet.getZ())
-                );
-            }
-        }
-    }
-
     @Inject(
             method = "handleCombatEvent",
             at = @At(

src/launch/java/baritone/launch/mixins/MixinNetworkManager.java

@@ -53,7 +53,7 @@ public class MixinNetworkManager {
             method = "dispatchPacket",
             at = @At("HEAD")
     )
-    private void preDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>> futureListeners, CallbackInfo ci) {
+    private void preDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>>[] futureListeners, CallbackInfo ci) {
         if (this.direction != EnumPacketDirection.CLIENTBOUND) {
             return;
         }
@@ -69,7 +69,7 @@ public class MixinNetworkManager {
             method = "dispatchPacket",
             at = @At("RETURN")
     )
-    private void postDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>> futureListeners, CallbackInfo ci) {
+    private void postDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>>[] futureListeners, CallbackInfo ci) {
         if (this.direction != EnumPacketDirection.CLIENTBOUND) {
             return;
         }
@@ -85,7 +85,7 @@ public class MixinNetworkManager {
             method = "channelRead0",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/network/NetworkManager.processPacket(Lnet/minecraft/network/Packet;Lnet/minecraft/network/INetHandler;)V"
+                    target = "net/minecraft/network/Packet.processPacket(Lnet/minecraft/network/INetHandler;)V"
             )
     )
     private void preProcessPacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {

src/launch/java/baritone/launch/mixins/MixinRenderChunk.java

@@ -23,8 +23,8 @@ import baritone.api.utils.IPlayerContext;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.chunk.RenderChunk;
-import net.minecraft.client.renderer.chunk.RenderChunkCache;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.ChunkCache;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
@@ -40,11 +40,43 @@ public class MixinRenderChunk {
             method = "rebuildChunk",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/client/renderer/chunk/RenderChunkCache.getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/state/IBlockState;"
+                    target = "net/minecraft/world/ChunkCache.isEmpty()Z"
             )
     )
-    private IBlockState getBlockState(RenderChunkCache chunkCache, BlockPos pos) {
+    private boolean isEmpty(ChunkCache chunkCache) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getInstance().isSingleplayer()) {
+        if (!chunkCache.isEmpty()) {
+            return false;
+        }
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
+            Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
+            IPlayerContext ctx = baritone.getPlayerContext();
+            if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {
+                BlockPos position = ((RenderChunk) (Object) this).getPosition();
+                // RenderChunk extends from -1,-1,-1 to +16,+16,+16
+                // then the constructor of ChunkCache extends it one more (presumably to get things like the connected status of fences? idk)
+                // so if ANY of the adjacent chunks are loaded, we are unempty
+                for (int dx = -1; dx <= 1; dx++) {
+                    for (int dz = -1; dz <= 1; dz++) {
+                        if (baritone.bsi.isLoaded(16 * dx + position.getX(), 16 * dz + position.getZ())) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Redirect(
+            method = "rebuildChunk",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/world/ChunkCache.getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/state/IBlockState;"
+            )
+    )
+    private IBlockState getBlockState(ChunkCache chunkCache, BlockPos pos) {
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
             Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
             IPlayerContext ctx = baritone.getPlayerContext();
             if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {

src/launch/java/baritone/launch/mixins/MixinRenderChunkCache.java

@@ -1,47 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.launch.mixins;
-
-import baritone.Baritone;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.chunk.RenderChunkCache;
-import net.minecraft.world.chunk.Chunk;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(RenderChunkCache.class)
-public class MixinRenderChunkCache {
-
-    @Redirect(
-            method = "generateCache",
-            at = @At(
-                    value = "INVOKE",
-                    target = "net/minecraft/world/chunk/Chunk.isEmptyBetween(II)Z"
-            )
-    )
-    private static boolean isEmpty(Chunk chunk, int yStart, int yEnd) {
-        if (!chunk.isEmptyBetween(yStart, yEnd)) {
-            return false;
-        }
-        if (chunk.isEmpty() && Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null) {
-            return false;
-        }
-        return true;
-    }
-}

src/launch/java/baritone/launch/mixins/MixinRenderList.java

@@ -38,9 +38,9 @@ public class MixinRenderList {
             )
     )
     private void popMatrix() {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getInstance().isSingleplayer()) {
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
             // reset the blend func to normal (not dependent on constant alpha)
-            GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
         }
         GlStateManager.popMatrix();
     }

src/launch/java/baritone/launch/mixins/MixinVboRenderList.java

@@ -38,9 +38,9 @@ public class MixinVboRenderList {
             )
     )
     private void popMatrix() {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getInstance().isSingleplayer()) {
+        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
             // reset the blend func to normal (not dependent on constant alpha)
-            GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
         }
         GlStateManager.popMatrix();
     }

src/launch/java/baritone/launch/mixins/MixinWorldClient.java

@@ -0,0 +1,75 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
+import baritone.api.event.events.ChunkEvent;
+import baritone.api.event.events.type.EventState;
+import net.minecraft.client.multiplayer.WorldClient;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * @author Brady
+ * @since 8/2/2018
+ */
+@Mixin(WorldClient.class)
+public class MixinWorldClient {
+
+    @Inject(
+            method = "doPreChunk",
+            at = @At("HEAD")
+    )
+    private void preDoPreChunk(int chunkX, int chunkZ, boolean loadChunk, CallbackInfo ci) {
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().world() == (WorldClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.PRE,
+                                loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
+                                chunkX,
+                                chunkZ
+                        )
+                );
+            }
+        }
+
+    }
+
+    @Inject(
+            method = "doPreChunk",
+            at = @At("RETURN")
+    )
+    private void postDoPreChunk(int chunkX, int chunkZ, boolean loadChunk, CallbackInfo ci) {
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().world() == (WorldClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.POST,
+                                loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
+                                chunkX,
+                                chunkZ
+                        )
+                );
+            }
+        }
+    }
+}

src/launch/resources/mixins.baritone.json

@@ -16,13 +16,13 @@
     "MixinChunkRenderWorker",
     "MixinEntityLivingBase",
     "MixinEntityPlayerSP",
-    "MixinGameRenderer",
+    "MixinEntityRenderer",
     "MixinMinecraft",
     "MixinNetHandlerPlayClient",
     "MixinNetworkManager",
     "MixinRenderChunk",
-    "MixinRenderChunkCache",
     "MixinRenderList",
-    "MixinVboRenderList"
+    "MixinVboRenderList",
+    "MixinWorldClient"
   ]
 }

src/main/java/baritone/Baritone.java

@@ -52,7 +52,7 @@ public class Baritone implements IBaritone {
     static {
         threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
 
-        dir = new File(Minecraft.getInstance().gameDir, "baritone");
+        dir = new File(Minecraft.getMinecraft().gameDir, "baritone");
         if (!Files.exists(dir.toPath())) {
             try {
                 Files.createDirectories(dir.toPath());
@@ -148,12 +148,12 @@ public class Baritone implements IBaritone {
     }
 
     @Override
-    public CustomGoalProcess getCustomGoalProcess() { // Iffy
+    public CustomGoalProcess getCustomGoalProcess() {
         return this.customGoalProcess;
     }
 
     @Override
-    public GetToBlockProcess getGetToBlockProcess() {  // Iffy
+    public GetToBlockProcess getGetToBlockProcess() {
         return this.getToBlockProcess;
     }
 

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

@@ -26,6 +26,7 @@ import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.init.Blocks;
 import net.minecraft.inventory.ClickType;
 import net.minecraft.item.*;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.NonNullList;
 
 import java.util.ArrayList;
@@ -132,9 +133,12 @@ public final class InventoryBehavior extends Behavior {
 
     public boolean selectThrowawayForLocation(boolean select, int x, int y, int z) {
         IBlockState maybe = baritone.getBuilderProcess().placeAt(x, y, z);
-        if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof ItemBlock && ((ItemBlock) stack.getItem()).getBlock().equals(maybe.getBlock()))) {
+        if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof ItemBlock && maybe.equals(((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(ctx.world(), ctx.playerFeet(), EnumFacing.UP, (float) ctx.player().posX, (float) ctx.player().posY, (float) ctx.player().posZ, stack.getItem().getMetadata(stack.getMetadata()), ctx.player())))) {
             return true; // gotem
         }
+        if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof ItemBlock && ((ItemBlock) stack.getItem()).getBlock().equals(maybe.getBlock()))) {
+            return true;
+        }
         for (Item item : Baritone.settings().acceptableThrowawayItems.value) {
             if (throwaway(select, stack -> item.equals(stack.getItem()))) {
                 return true;

src/main/java/baritone/behavior/LookBehavior.java

@@ -28,6 +28,9 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
 
     /**
      * Target's values are as follows:
+     * <p>
+     * getFirst() -> yaw
+     * getSecond() -> pitch
      */
     private Rotation target;
 
@@ -50,13 +53,6 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
     @Override
     public void updateTarget(Rotation target, boolean force) {
         this.target = target;
-        if (!force) {
-            double rand = Math.random() - 0.5;
-            if (Math.abs(rand) < 0.1) {
-                rand *= 4;
-            }
-            this.target = new Rotation(this.target.getYaw() + (float) (rand * Baritone.settings().randomLooking.value), this.target.getPitch());
-        }
         this.force = force || !Baritone.settings().freeLook.value;
     }
 

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

@@ -135,7 +135,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                     ) {
                         // when it was *just* started, currentBest will be empty so we need to also check calcFrom since that's always present
                         inProgress.cancel(); // cancellation doesn't dispatch any events
-                        inProgress = null; // this is safe since we hold both locks
                     }
                 }
             }
@@ -339,7 +338,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
     }
 
     // just cancel the current path
-    public void secretInternalSegmentCancel() {
+    private void secretInternalSegmentCancel() {
         queuePathEvent(PathEvent.CANCELED);
         synchronized (pathPlanLock) {
             getInProgress().ifPresent(AbstractNodeCostSearch::cancel);
@@ -361,12 +360,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         }
     }
 
-    /*public void secretCursedFunctionDoNotCall(IPath path) {
-        synchronized (pathPlanLock) {
-            current = new PathExecutor(this, path);
-        }
-    }*/
-
     public CalculationContext secretInternalGetCalculationContext() {
         return context;
     }
@@ -495,7 +488,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                     }
                 }
                 if (talkAboutIt && current != null && current.getPath() != null) {
-                    if (goal == null || goal.isInGoal(current.getPath().getDest())) {
+                    if (goal.isInGoal(current.getPath().getDest())) {
                         logDebug("Finished finding a path from " + start + " to " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
                     } else {
                         logDebug("Found path segment from " + start + " towards " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
@@ -508,7 +501,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         });
     }
 
-    public static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
+    private static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
         Goal transformed = goal;
         if (Baritone.settings().simplifyUnloadedYCoord.value && goal instanceof IGoalRenderPos) {
             BlockPos pos = ((IGoalRenderPos) goal).getGoalPos();

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

@@ -38,13 +38,23 @@ import java.util.Map;
 public final class CachedChunk {
 
     public static final ImmutableSet<Block> BLOCKS_TO_KEEP_TRACK_OF = ImmutableSet.of(
+            Blocks.DIAMOND_BLOCK,
+            //Blocks.COAL_ORE,
+            Blocks.COAL_BLOCK,
+            //Blocks.IRON_ORE,
+            Blocks.IRON_BLOCK,
+            //Blocks.GOLD_ORE,
+            Blocks.GOLD_BLOCK,
+            Blocks.EMERALD_ORE,
+            Blocks.EMERALD_BLOCK,
+
             Blocks.ENDER_CHEST,
             Blocks.FURNACE,
             Blocks.CHEST,
             Blocks.TRAPPED_CHEST,
             Blocks.END_PORTAL,
             Blocks.END_PORTAL_FRAME,
-            Blocks.SPAWNER,
+            Blocks.MOB_SPAWNER,
             Blocks.BARRIER,
             Blocks.OBSERVER,
             Blocks.WHITE_SHULKER_BOX,
@@ -55,7 +65,7 @@ public final class CachedChunk {
             Blocks.LIME_SHULKER_BOX,
             Blocks.PINK_SHULKER_BOX,
             Blocks.GRAY_SHULKER_BOX,
-            Blocks.LIGHT_GRAY_SHULKER_BOX,
+            Blocks.SILVER_SHULKER_BOX,
             Blocks.CYAN_SHULKER_BOX,
             Blocks.PURPLE_SHULKER_BOX,
             Blocks.BLUE_SHULKER_BOX,
@@ -63,52 +73,25 @@ public final class CachedChunk {
             Blocks.GREEN_SHULKER_BOX,
             Blocks.RED_SHULKER_BOX,
             Blocks.BLACK_SHULKER_BOX,
-            Blocks.NETHER_PORTAL,
+            Blocks.PORTAL,
             Blocks.HOPPER,
             Blocks.BEACON,
             Blocks.BREWING_STAND,
-
+            Blocks.SKULL,
-// TODO: Maybe add a predicate for blocks to keep track of?
-// This should really not need to happen
-            Blocks.CREEPER_HEAD,
-            Blocks.CREEPER_WALL_HEAD,
-            Blocks.DRAGON_HEAD,
-            Blocks.DRAGON_WALL_HEAD,
-            Blocks.PLAYER_HEAD,
-            Blocks.PLAYER_WALL_HEAD,
-            Blocks.ZOMBIE_HEAD,
-            Blocks.ZOMBIE_WALL_HEAD,
-            Blocks.SKELETON_SKULL,
-            Blocks.SKELETON_WALL_SKULL,
-            Blocks.WITHER_SKELETON_SKULL,
-            Blocks.WITHER_SKELETON_WALL_SKULL,
             Blocks.ENCHANTING_TABLE,
             Blocks.ANVIL,
-            Blocks.WHITE_BED,
+            Blocks.LIT_FURNACE,
-            Blocks.ORANGE_BED,
+            Blocks.BED,
-            Blocks.MAGENTA_BED,
-            Blocks.LIGHT_BLUE_BED,
-            Blocks.YELLOW_BED,
-            Blocks.LIME_BED,
-            Blocks.PINK_BED,
-            Blocks.GRAY_BED,
-            Blocks.LIGHT_GRAY_BED,
-            Blocks.CYAN_BED,
-            Blocks.PURPLE_BED,
-            Blocks.BLUE_BED,
-            Blocks.BROWN_BED,
-            Blocks.GREEN_BED,
-            Blocks.RED_BED,
-            Blocks.BLACK_BED,
             Blocks.DRAGON_EGG,
             Blocks.JUKEBOX,
             Blocks.END_GATEWAY,
-            Blocks.COBWEB,
+            Blocks.WEB,
             Blocks.NETHER_WART,
             Blocks.LADDER,
             Blocks.VINE
     );
 
+
     /**
      * The size of the chunk data in bits. Equal to 16 KiB.
      * <p>
@@ -187,8 +170,8 @@ public final class CachedChunk {
 
             // we have this exact block, it's a surface block
             /*System.out.println("Saying that " + x + "," + y + "," + z + " is " + state);
-            if (!Minecraft.getInstance().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock().equals(state.getBlock())) {
+            if (!Minecraft.getMinecraft().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock().equals(state.getBlock())) {
-                throw new IllegalStateException("failed " + Minecraft.getInstance().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock() + " " + state.getBlock() + " " + (x + this.x * 16) + " " + y + " " + (z + this.z * 16));
+                throw new IllegalStateException("failed " + Minecraft.getMinecraft().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock() + " " + state.getBlock() + " " + (x + this.x * 16) + " " + y + " " + (z + this.z * 16));
             }*/
             return overview[internalPos];
         }
@@ -199,8 +182,17 @@ public final class CachedChunk {
             }
         }
 
-        if (type == PathingBlockType.SOLID && y == 127 && dimension == -1) {
+        if (type == PathingBlockType.SOLID) {
-            return Blocks.BEDROCK.getDefaultState();
+            if (y == 127 && dimension == -1) {
+                // nether roof is always unbreakable
+                return Blocks.BEDROCK.getDefaultState();
+            }
+            if (y < 5 && dimension == 0) {
+                // solid blocks below 5 are commonly bedrock
+                // however, returning bedrock always would be a little yikes
+                // discourage paths that include breaking blocks below 5 a little more heavily just so that it takes paths breaking what's known to be stone (at 5 or above) instead of what could maybe be bedrock (below 5)
+                return Blocks.OBSIDIAN.getDefaultState();
+            }
         }
         return ChunkPacker.pathingTypeToBlock(type, dimension);
     }

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

@@ -24,10 +24,9 @@ import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.ChunkSection;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import java.util.*;
 
@@ -45,9 +44,9 @@ public final class ChunkPacker {
         Map<String, List<BlockPos>> specialBlocks = new HashMap<>();
         BitSet bitSet = new BitSet(CachedChunk.SIZE);
         try {
-            ChunkSection[] chunkInternalStorageArray = chunk.getSections();
+            ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
             for (int y0 = 0; y0 < 16; y0++) {
-                ChunkSection extendedblockstorage = chunkInternalStorageArray[y0];
+                ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
                 if (extendedblockstorage == null) {
                     // any 16x16x16 area that's all air will have null storage
                     // for example, in an ocean biome, with air from y=64 to y=256
@@ -59,7 +58,7 @@ public final class ChunkPacker {
                     // since a bitset is initialized to all zero, and air is saved as zeros
                     continue;
                 }
-                BlockStateContainer<IBlockState> bsc = extendedblockstorage.getData();
+                BlockStateContainer bsc = extendedblockstorage.getData();
                 int yReal = y0 << 4;
                 // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x;
                 // for better cache locality, iterate in that order
@@ -104,9 +103,10 @@ public final class ChunkPacker {
         return new CachedChunk(chunk.x, chunk.z, bitSet, blocks, specialBlocks, System.currentTimeMillis());
     }
 
+
     private static PathingBlockType getPathingBlockType(IBlockState state, Chunk chunk, int x, int y, int z) {
         Block block = state.getBlock();
-        if (MovementHelper.isWater(state)) {
+        if (block == Blocks.WATER || block == Blocks.FLOWING_WATER) {
             // only water source blocks are plausibly usable, flowing water should be avoid
             // FLOWING_WATER is a waterfall, it doesn't really matter and caching it as AVOID just makes it look wrong
             if (MovementHelper.possiblyFlowing(state)) {
@@ -121,8 +121,7 @@ public final class ChunkPacker {
                 return PathingBlockType.AVOID;
             }
             if (x == 0 || x == 15 || z == 0 || z == 15) {
-                Vec3d flow = state.getFluidState().getFlow(chunk.getWorld(), new BlockPos(x + chunk.x << 4, y, z + chunk.z << 4));
+                if (BlockLiquid.getSlopeAngle(chunk.getWorld(), new BlockPos(x + chunk.x << 4, y, z + chunk.z << 4), state.getMaterial(), state) == -1000.0F) {
-                if (flow.x != 0.0 || flow.z != 0.0) {
                     return PathingBlockType.WATER;
                 }
                 return PathingBlockType.AVOID;
@@ -130,14 +129,14 @@ public final class ChunkPacker {
             return PathingBlockType.WATER;
         }
 
-        if (MovementHelper.avoidWalkingInto(state) || MovementHelper.isBottomSlab(state)) {
+        if (MovementHelper.avoidWalkingInto(block) || MovementHelper.isBottomSlab(state)) {
             return PathingBlockType.AVOID;
         }
         // We used to do an AABB check here
         // however, this failed in the nether when you were near a nether fortress
         // because fences check their adjacent blocks in the world for their fence connection status to determine AABB shape
         // this caused a nullpointerexception when we saved chunks on unload, because they were unable to check their neighbors
-        if (block instanceof BlockAir || block instanceof BlockTallGrass || block instanceof BlockDoublePlant || block instanceof BlockFlower) {
+        if (block == Blocks.AIR || block instanceof BlockTallGrass || block instanceof BlockDoublePlant || block instanceof BlockFlower) {
             return PathingBlockType.AIR;
         }
 

src/main/java/baritone/cache/WorldProvider.java

@@ -24,7 +24,6 @@ import baritone.utils.accessor.IAnvilChunkLoader;
 import baritone.utils.accessor.IChunkProviderServer;
 import net.minecraft.server.integrated.IntegratedServer;
 import net.minecraft.world.WorldServer;
-import net.minecraft.world.dimension.DimensionType;
 import org.apache.commons.lang3.SystemUtils;
 
 import java.io.File;
@@ -56,7 +55,7 @@ public class WorldProvider implements IWorldProvider, Helper {
      *
      * @param dimension The ID of the world's dimension
      */
-    public final void initWorld(DimensionType dimension) {
+    public final void initWorld(int dimension) {
         File directory;
         File readme;
 
@@ -93,7 +92,7 @@ public class WorldProvider implements IWorldProvider, Helper {
         } catch (IOException ignored) {}
 
         // We will actually store the world data in a subfolder: "DIM<id>"
-        Path dir = new File(directory, "DIM" + dimension.getId()).toPath();
+        Path dir = new File(directory, "DIM" + dimension).toPath();
         if (!Files.exists(dir)) {
             try {
                 Files.createDirectories(dir);
@@ -102,7 +101,7 @@ public class WorldProvider implements IWorldProvider, Helper {
 
         System.out.println("Baritone world data dir: " + dir);
         synchronized (worldCache) {
-            this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, dimension.getId()));
+            this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, dimension));
         }
     }
 

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

@@ -26,7 +26,7 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.ChunkSection;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import java.util.*;
 import java.util.stream.IntStream;
@@ -70,7 +70,7 @@ public enum WorldScanner implements IWorldScanner {
                     foundChunks = true;
                     int chunkX = xoff + playerChunkX;
                     int chunkZ = zoff + playerChunkZ;
-                    Chunk chunk = chunkProvider.getChunk(chunkX, chunkZ, false, false);
+                    Chunk chunk = chunkProvider.getLoadedChunk(chunkX, chunkZ);
                     if (chunk == null) {
                         continue;
                     }
@@ -97,7 +97,7 @@ public enum WorldScanner implements IWorldScanner {
         }
 
         ChunkProviderClient chunkProvider = (ChunkProviderClient) ctx.world().getChunkProvider();
-        Chunk chunk = chunkProvider.getChunk(pos.x, pos.z, false, false);
+        Chunk chunk = chunkProvider.getLoadedChunk(pos.x, pos.z);
         int playerY = ctx.playerFeet().getY();
 
         if (chunk == null || chunk.isEmpty()) {
@@ -110,16 +110,16 @@ public enum WorldScanner implements IWorldScanner {
     }
 
     private boolean scanChunkInto(int chunkX, int chunkZ, Chunk chunk, List<Block> search, Collection<BlockPos> result, int max, int yLevelThreshold, int playerY, int[] coordinateIterationOrder) {
-        ChunkSection[] chunkInternalStorageArray = chunk.getSections();
+        ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
         boolean foundWithinY = false;
         for (int yIndex = 0; yIndex < 16; yIndex++) {
             int y0 = coordinateIterationOrder[yIndex];
-            ChunkSection extendedblockstorage = chunkInternalStorageArray[y0];
+            ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
             if (extendedblockstorage == null) {
                 continue;
             }
             int yReal = y0 << 4;
-            BlockStateContainer<IBlockState> bsc = extendedblockstorage.getData();
+            BlockStateContainer bsc = extendedblockstorage.getData();
             // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x;
             // for better cache locality, iterate in that order
             for (int y = 0; y < 16; y++) {

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

@@ -84,7 +84,7 @@ public final class GameEventHandler implements IEventBus, Helper {
         // to make sure the chunk being unloaded is already loaded.
         boolean isPreUnload = state == EventState.PRE
                 && type == ChunkEvent.Type.UNLOAD
-                && world.getChunkProvider().getChunk(event.getX(), event.getZ(), false, false) != null;
+                && world.getChunkProvider().isChunkGeneratedAt(event.getX(), event.getZ());
 
         if (isPostPopulate || isPreUnload) {
             baritone.getWorldProvider().ifWorldLoaded(worldData -> {
@@ -109,7 +109,7 @@ public final class GameEventHandler implements IEventBus, Helper {
         if (event.getState() == EventState.POST) {
             cache.closeWorld();
             if (event.getWorld() != null) {
-                cache.initWorld(event.getWorld().getDimension().getType());
+                cache.initWorld(event.getWorld().provider.getDimensionType().getId());
             }
         }
 

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

@@ -76,6 +76,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
         int timeCheckInterval = 1 << 6;
         int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.value; // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior
         double minimumImprovement = Baritone.settings().minimumImprovementRepropagation.value ? MIN_IMPROVEMENT : 0;
+        Moves[] allMoves = Moves.values();
         while (!openSet.isEmpty() && numEmptyChunk < pathingMaxChunkBorderFetch && !cancelRequested) {
             if ((numNodes & (timeCheckInterval - 1)) == 0) { // only call this once every 64 nodes (about half a millisecond)
                 long now = System.currentTimeMillis(); // since nanoTime is slow on windows (takes many microseconds)
@@ -95,7 +96,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
                 logDebug("Took " + (System.currentTimeMillis() - startTime) + "ms, " + numMovementsConsidered + " movements considered");
                 return Optional.of(new Path(startNode, currentNode, numNodes, goal, calcContext));
             }
-            for (Moves moves : Moves.values()) {
+            for (Moves moves : allMoves) {
                 int newX = currentNode.x + moves.xOffset;
                 int newZ = currentNode.z + moves.zOffset;
                 if ((newX >> 4 != currentNode.x >> 4 || newZ >> 4 != currentNode.z >> 4) && !calcContext.isLoaded(newX, newZ)) {

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

@@ -127,7 +127,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder, Helper {
                 return new PathCalculationResult(PathCalculationResult.Type.SUCCESS_SEGMENT, path);
             }
         } catch (Exception e) {
-            Helper.HELPER.logDebug("Pathing exception: " + e);
+            Helper.HELPER.logDirect("Pathing exception: " + e);
             e.printStackTrace();
             return new PathCalculationResult(PathCalculationResult.Type.EXCEPTION);
         } finally {

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

@@ -72,28 +72,9 @@ class Path extends PathBase {
         this.start = new BetterBlockPos(start.x, start.y, start.z);
         this.end = new BetterBlockPos(end.x, end.y, end.z);
         this.numNodes = numNodes;
-        this.path = new ArrayList<>();
         this.movements = new ArrayList<>();
-        this.nodes = new ArrayList<>();
         this.goal = goal;
         this.context = context;
-        assemblePath(end);
-    }
-
-    @Override
-    public Goal getGoal() {
-        return goal;
-    }
-
-    /**
-     * Assembles this path given the end node.
-     *
-     * @param end The end node
-     */
-    private void assemblePath(PathNode end) {
-        if (!path.isEmpty() || !movements.isEmpty()) {
-            throw new IllegalStateException();
-        }
         PathNode current = end;
         LinkedList<BetterBlockPos> tempPath = new LinkedList<>();
         LinkedList<PathNode> tempNodes = new LinkedList<>();
@@ -107,8 +88,13 @@ class Path extends PathBase {
         // Can't directly convert from the PathNode pseudo linked list to an array because we don't know how long it is
         // 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);
+        this.path = new ArrayList<>(tempPath);
-        nodes.addAll(tempNodes);
+        this.nodes = new ArrayList<>(tempNodes);
+    }
+
+    @Override
+    public Goal getGoal() {
+        return goal;
     }
 
     private boolean assembleMovements() {

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

@@ -58,6 +58,7 @@ public class CalculationContext {
     public final boolean allowParkour;
     public final boolean allowParkourPlace;
     public final boolean allowJumpAt256;
+    public final boolean allowParkourAscend;
     public final boolean assumeWalkOnWater;
     public final boolean allowDiagonalDescend;
     public final boolean allowDownward;
@@ -83,13 +84,14 @@ public class CalculationContext {
         this.bsi = new BlockStateInterface(world, worldData, forUseOnAnotherThread);
         this.toolSet = new ToolSet(player);
         this.hasThrowaway = Baritone.settings().allowPlace.value && ((Baritone) baritone).getInventoryBehavior().hasGenericThrowaway();
-        this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.value && InventoryPlayer.isHotbar(player.inventory.getSlotFor(STACK_BUCKET_WATER)) && !world.getDimension().isNether();
+        this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.value && InventoryPlayer.isHotbar(player.inventory.getSlotFor(STACK_BUCKET_WATER)) && !world.provider.isNether();
         this.canSprint = Baritone.settings().allowSprint.value && player.getFoodStats().getFoodLevel() > 6;
         this.placeBlockCost = Baritone.settings().blockPlacementPenalty.value;
         this.allowBreak = Baritone.settings().allowBreak.value;
         this.allowParkour = Baritone.settings().allowParkour.value;
         this.allowParkourPlace = Baritone.settings().allowParkourPlace.value;
         this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
+        this.allowParkourAscend = Baritone.settings().allowParkourAscend.value;
         this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;
         this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.value;
         this.allowDownward = Baritone.settings().allowDownward.value;

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

@@ -25,6 +25,7 @@ import baritone.api.utils.*;
 import baritone.api.utils.input.Input;
 import baritone.behavior.PathingBehavior;
 import baritone.utils.BlockStateInterface;
+import net.minecraft.block.BlockLiquid;
 import net.minecraft.entity.item.EntityFallingBlock;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.AxisAlignedBB;
@@ -122,7 +123,7 @@ public abstract class Movement implements IMovement, MovementHelper {
      */
     @Override
     public MovementStatus update() {
-        ctx.player().abilities.isFlying = false;
+        ctx.player().capabilities.isFlying = false;
         currentState = updateState(currentState);
         if (MovementHelper.isLiquid(ctx, ctx.playerFeet())) {
             currentState.setInput(Input.JUMP, true);
@@ -160,7 +161,7 @@ public abstract class Movement implements IMovement, MovementHelper {
             if (!ctx.world().getEntitiesWithinAABB(EntityFallingBlock.class, new AxisAlignedBB(0, 0, 0, 1, 1.1, 1).offset(blockPos)).isEmpty() && Baritone.settings().pauseMiningForFallingBlocks.value) {
                 return false;
             }
-            if (!MovementHelper.canWalkThrough(ctx, blockPos)) { // can't break air, so don't try
+            if (!MovementHelper.canWalkThrough(ctx, blockPos) && !(BlockStateInterface.getBlock(ctx, blockPos) instanceof BlockLiquid)) { // can't break liquid, so don't try
                 somethingInTheWay = true;
                 MovementHelper.switchToBestToolFor(ctx, BlockStateInterface.get(ctx, blockPos));
                 Optional<Rotation> reachable = RotationUtils.reachable(ctx.player(), blockPos, ctx.playerController().getBlockReachDistance());
@@ -176,7 +177,7 @@ public abstract class Movement implements IMovement, MovementHelper {
                 //i'm doing it anyway
                 //i dont care if theres snow in the way!!!!!!!
                 //you dont own me!!!!
-                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getEyePosition(1.0F),
+                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getPositionEyes(1.0F),
                         VecUtils.getBlockPosCenter(blockPos), ctx.playerRotations()), true)
                 );
                 // don't check selectedblock on this one, this is a fallback when we can't see any face directly, it's intended to be breaking the "incorrect" block

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

@@ -27,16 +27,9 @@ import baritone.pathing.movement.MovementState.MovementTarget;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.ToolSet;
 import net.minecraft.block.*;
+import net.minecraft.block.properties.PropertyBool;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.fluid.FlowingFluid;
-import net.minecraft.fluid.Fluid;
-import net.minecraft.fluid.IFluidState;
-import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
-import net.minecraft.init.Fluids;
-import net.minecraft.pathfinding.PathType;
-import net.minecraft.state.BooleanProperty;
-import net.minecraft.state.properties.SlabType;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
@@ -78,7 +71,7 @@ public interface MovementHelper extends ActionCosts, Helper {
                 && BlockFalling.canFallThrough(bsi.get0(x, y - 1, z))) { // and if it would fall (i.e. it's unsupported)
             return true; // dont break a block that is adjacent to unsupported gravel because it can cause really weird stuff
         }
-        return !state.getFluidState().isEmpty();
+        return block instanceof BlockLiquid;
     }
 
     static boolean canWalkThrough(IPlayerContext ctx, BetterBlockPos pos) {
@@ -91,10 +84,10 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static boolean canWalkThrough(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
         Block block = state.getBlock();
-        if (block instanceof BlockAir) { // early return for most common case
+        if (block == Blocks.AIR) { // early return for most common case
             return true;
         }
-        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.COBWEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockAbstractSkull || block == Blocks.BUBBLE_COLUMN || block instanceof BlockShulkerBox || block instanceof BlockSlab || block instanceof BlockTrapDoor) {
+        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.WEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block instanceof BlockTrapDoor) {
             return false;
         }
         if (Baritone.settings().blocksToAvoid.value.contains(block)) {
@@ -106,10 +99,10 @@ public interface MovementHelper extends ActionCosts, Helper {
             // be opened by just interacting.
             return block != Blocks.IRON_DOOR;
         }
-        if (block instanceof BlockCarpet) {
+        if (block == Blocks.CARPET) {
             return canWalkOn(bsi, x, y - 1, z);
         }
-        if (block instanceof BlockSnowLayer) {
+        if (block instanceof BlockSnow) {
             // we've already checked doors and fence gates
             // so the only remaining dynamic isPassables are snow and trapdoor
             // if they're cached as a top block, we don't know their metadata
@@ -119,7 +112,7 @@ public interface MovementHelper extends ActionCosts, Helper {
             }
             // the check in BlockSnow.isPassable is layers < 5
             // while actually, we want < 3 because 3 or greater makes it impassable in a 2 high ceiling
-            if (state.get(BlockSnowLayer.LAYERS) >= 3) {
+            if (state.getValue(BlockSnow.LAYERS) >= 3) {
                 return false;
             }
             // ok, it's low enough we could walk through it, but is it supported?
@@ -128,21 +121,20 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (isFlowing(x, y, z, state, bsi)) {
             return false; // Don't walk through flowing liquids
         }
-        IFluidState fluidState = state.getFluidState();
+        if (block instanceof BlockLiquid) {
-        if (fluidState.getFluid() instanceof WaterFluid) {
             if (Baritone.settings().assumeWalkOnWater.value) {
                 return false;
             }
             IBlockState up = bsi.get0(x, y + 1, z);
-            if (!up.getFluidState().isEmpty() || up.getBlock() instanceof BlockLilyPad) {
+            if (up.getBlock() instanceof BlockLiquid || up.getBlock() instanceof BlockLilyPad) {
                 return false;
             }
-            return true;
+            return block == Blocks.WATER || block == Blocks.FLOWING_WATER;
         }
         // every block that overrides isPassable with anything more complicated than a "return true;" or "return false;"
         // has already been accounted for above
         // therefore it's safe to not construct a blockpos from our x, y, z ints and instead just pass null
-        return state.allowsMovement(null, BlockPos.ORIGIN, PathType.LAND); // workaround for future compatibility =P
+        return block.isPassable(null, BlockPos.ORIGIN);
     }
 
     /**
@@ -161,28 +153,27 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static boolean fullyPassable(IBlockState state) {
         Block block = state.getBlock();
-        if (block instanceof BlockAir) { // early return for most common case
+        if (block == Blocks.AIR) { // early return for most common case
             return true;
         }
         // exceptions - blocks that are isPassable true, but we can't actually jump through
         if (block == Blocks.FIRE
                 || block == Blocks.TRIPWIRE
-                || block == Blocks.COBWEB
+                || block == Blocks.WEB
                 || block == Blocks.VINE
                 || block == Blocks.LADDER
                 || block == Blocks.COCOA
                 || block instanceof BlockDoor
                 || block instanceof BlockFenceGate
                 || block instanceof BlockSnow
-                || !state.getFluidState().isEmpty()
+                || block instanceof BlockLiquid
                 || block instanceof BlockTrapDoor
                 || block instanceof BlockEndPortal
-                || block instanceof BlockSkull
+                || block instanceof BlockSkull) {
-                || block instanceof BlockShulkerBox) {
             return false;
         }
         // door, fence gate, liquid, trapdoor have been accounted for, nothing else uses the world or pos parameters
-        return state.allowsMovement(null, null, PathType.LAND);
+        return block.isPassable(null, null);
     }
 
     static boolean isReplacable(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
@@ -197,19 +188,20 @@ public interface MovementHelper extends ActionCosts, Helper {
          *     }
          */
         Block block = state.getBlock();
-        if (block instanceof BlockAir) {
+        if (block == Blocks.AIR || isWater(block)) {
             // early return for common cases hehe
             return true;
         }
-        if (block instanceof BlockSnowLayer) {
+        if (block instanceof BlockSnow) {
             // as before, default to true (mostly because it would otherwise make long distance pathing through snowy biomes impossible)
             if (!bsi.worldContainsLoadedChunk(x, z)) {
                 return true;
             }
-            return state.get(BlockSnowLayer.LAYERS) == 1;
+            return state.getValue(BlockSnow.LAYERS) == 1;
         }
-        if (block == Blocks.LARGE_FERN || block == Blocks.TALL_GRASS) {
+        if (block instanceof BlockDoublePlant) {
-            return true;
+            BlockDoublePlant.EnumPlantType kek = state.getValue(BlockDoublePlant.VARIANT);
+            return kek == BlockDoublePlant.EnumPlantType.FERN || kek == BlockDoublePlant.EnumPlantType.GRASS;
         }
         return state.getMaterial().isReplaceable();
     }
@@ -237,16 +229,16 @@ public interface MovementHelper extends ActionCosts, Helper {
             return true;
         }
 
-        return state.get(BlockFenceGate.OPEN);
+        return state.getValue(BlockFenceGate.OPEN);
     }
 
-    static boolean isHorizontalBlockPassable(BlockPos blockPos, IBlockState blockState, BlockPos playerPos, BooleanProperty propertyOpen) {
+    static boolean isHorizontalBlockPassable(BlockPos blockPos, IBlockState blockState, BlockPos playerPos, PropertyBool propertyOpen) {
         if (playerPos.equals(blockPos)) {
             return false;
         }
 
-        EnumFacing.Axis facing = blockState.get(BlockHorizontal.HORIZONTAL_FACING).getAxis();
+        EnumFacing.Axis facing = blockState.getValue(BlockHorizontal.FACING).getAxis();
-        boolean open = blockState.get(propertyOpen);
+        boolean open = blockState.getValue(propertyOpen);
 
         EnumFacing.Axis playerFacing;
         if (playerPos.north().equals(blockPos) || playerPos.south().equals(blockPos)) {
@@ -260,15 +252,13 @@ public interface MovementHelper extends ActionCosts, Helper {
         return (facing == playerFacing) == open;
     }
 
-    static boolean avoidWalkingInto(IBlockState state) {
+    static boolean avoidWalkingInto(Block block) {
-        Block block = state.getBlock();
+        return block instanceof BlockLiquid
-        return !state.getFluidState().isEmpty()
+                || block == Blocks.MAGMA
-                || block == Blocks.MAGMA_BLOCK
                 || block == Blocks.CACTUS
                 || block == Blocks.FIRE
                 || block == Blocks.END_PORTAL
-                || block == Blocks.COBWEB
+                || block == Blocks.WEB;
-                || block == Blocks.BUBBLE_COLUMN;
     }
 
     /**
@@ -285,7 +275,7 @@ public interface MovementHelper extends ActionCosts, Helper {
      */
     static boolean canWalkOn(BlockStateInterface bsi, int x, int y, int z, IBlockState state) {
         Block block = state.getBlock();
-        if (block instanceof BlockAir || block == Blocks.MAGMA_BLOCK || block == Blocks.BUBBLE_COLUMN) {
+        if (block == Blocks.AIR || block == Blocks.MAGMA) {
             // early return for most common case (air)
             // plus magma, which is a normal cube but it hurts you
             return false;
@@ -302,31 +292,33 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST) {
             return true;
         }
-        if (isWater(state)) {
+        if (isWater(block)) {
             // since this is called literally millions of times per second, the benefit of not allocating millions of useless "pos.up()"
             // BlockPos s that we'd just garbage collect immediately is actually noticeable. I don't even think its a decrease in readability
-            IBlockState upState = bsi.get0(x, y + 1, z);
+            Block up = bsi.get0(x, y + 1, z).getBlock();
-            Block up = upState.getBlock();
+            if (up == Blocks.WATERLILY || up == Blocks.CARPET) {
-            if (up == Blocks.LILY_PAD || up instanceof BlockCarpet) {
                 return true;
             }
-            if (isFlowing(x, y, z, state, bsi) || upState.getFluidState().getFluid() == Fluids.FLOWING_WATER) {
+            if (isFlowing(x, y, z, state, bsi) || block == Blocks.FLOWING_WATER) {
                 // the only scenario in which we can walk on flowing water is if it's under still water with jesus off
-                return isWater(upState) && !Baritone.settings().assumeWalkOnWater.value;
+                return isWater(up) && !Baritone.settings().assumeWalkOnWater.value;
             }
             // if assumeWalkOnWater is on, we can only walk on water if there isn't water above it
             // if assumeWalkOnWater is off, we can only walk on water if there is water above it
-            return isWater(upState) ^ Baritone.settings().assumeWalkOnWater.value;
+            return isWater(up) ^ Baritone.settings().assumeWalkOnWater.value;
         }
-        if (Baritone.settings().assumeWalkOnLava.value && isLava(state) && !isFlowing(x, y, z, state, bsi)) {
+        if (Baritone.settings().assumeWalkOnLava.value && isLava(block) && !isFlowing(x, y, z, state, bsi)) {
             return true;
         }
-        if (block == Blocks.GLASS || block instanceof BlockStainedGlass) {
+        if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
             return true;
         }
         if (block instanceof BlockSlab) {
             if (!Baritone.settings().allowWalkOnBottomSlab.value) {
-                return state.isTopSolid();
+                if (((BlockSlab) block).isDouble()) {
+                    return true;
+                }
+                return state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM;
             }
             return true;
         }
@@ -365,7 +357,7 @@ public interface MovementHelper extends ActionCosts, Helper {
         // can we look at the center of a side face of this block and likely be able to place?
         // (thats how this check is used)
         // therefore dont include weird things that we technically could place against (like carpet) but practically can't
-        return state.isBlockNormalCube() || state.isFullCube() || state.getBlock() == Blocks.GLASS || state.getBlock() instanceof BlockStainedGlass;
+        return state.isBlockNormalCube() || state.isFullBlock() || state.getBlock() == Blocks.GLASS || state.getBlock() == Blocks.STAINED_GLASS;
     }
 
     static double getMiningDurationTicks(CalculationContext context, int x, int y, int z, boolean includeFalling) {
@@ -375,7 +367,7 @@ public interface MovementHelper extends ActionCosts, Helper {
     static double getMiningDurationTicks(CalculationContext context, int x, int y, int z, IBlockState state, boolean includeFalling) {
         Block block = state.getBlock();
         if (!canWalkThrough(context.bsi, x, y, z, state)) {
-            if (!state.getFluidState().isEmpty()) {
+            if (block instanceof BlockLiquid) {
                 return COST_INF;
             }
             double mult = context.breakCostMultiplierAt(x, y, z);
@@ -405,7 +397,8 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static boolean isBottomSlab(IBlockState state) {
         return state.getBlock() instanceof BlockSlab
-                && state.get(BlockSlab.TYPE) == SlabType.BOTTOM;
+                && !((BlockSlab) state.getBlock()).isDouble()
+                && state.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM;
     }
 
     /**
@@ -442,12 +435,11 @@ public interface MovementHelper extends ActionCosts, Helper {
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.
      *
-     * @param state The block state
+     * @param b The block
      * @return Whether or not the block is water
      */
-    static boolean isWater(IBlockState state) {
+    static boolean isWater(Block b) {
-        Fluid f = state.getFluidState().getFluid();
+        return b == Blocks.FLOWING_WATER || b == Blocks.WATER;
-        return f == Fluids.WATER || f == Fluids.FLOWING_WATER;
     }
 
     /**
@@ -459,12 +451,11 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @return Whether or not the block is water
      */
     static boolean isWater(IPlayerContext ctx, BlockPos bp) {
-        return isWater(BlockStateInterface.get(ctx, bp));
+        return isWater(BlockStateInterface.getBlock(ctx, bp));
     }
 
-    static boolean isLava(IBlockState state) {
+    static boolean isLava(Block b) {
-        Fluid f = state.getFluidState().getFluid();
+        return b == Blocks.FLOWING_LAVA || b == Blocks.LAVA;
-        return f == Fluids.LAVA || f == Fluids.FLOWING_LAVA;
     }
 
     /**
@@ -475,25 +466,20 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @return Whether or not the block is a liquid
      */
     static boolean isLiquid(IPlayerContext ctx, BlockPos p) {
-        return isLiquid(BlockStateInterface.get(ctx, p));
+        return BlockStateInterface.getBlock(ctx, p) instanceof BlockLiquid;
-    }
-
-    static boolean isLiquid(IBlockState blockState) {
-        return !blockState.getFluidState().isEmpty();
     }
 
     static boolean possiblyFlowing(IBlockState state) {
-        IFluidState fluidState = state.getFluidState();
+        // Will be IFluidState in 1.13
-        return fluidState.getFluid() instanceof FlowingFluid
+        return state.getBlock() instanceof BlockLiquid
-                && fluidState.getFluid().getLevel(fluidState) != 8;
+                && state.getValue(BlockLiquid.LEVEL) != 0;
     }
 
     static boolean isFlowing(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
-        IFluidState fluidState = state.getFluidState();
+        if (!(state.getBlock() instanceof BlockLiquid)) {
-        if (!(fluidState.getFluid() instanceof FlowingFluid)) {
             return false;
         }
-        if (fluidState.getFluid().getLevel(fluidState) != 8) {
+        if (state.getValue(BlockLiquid.LEVEL) != 0) {
             return true;
         }
         return possiblyFlowing(bsi.get0(x + 1, y, z))
@@ -520,11 +506,11 @@ public interface MovementHelper extends ActionCosts, Helper {
                     return PlaceResult.NO_OPTION;
                 }
                 double faceX = (placeAt.getX() + against1.getX() + 1.0D) * 0.5D;
-                double faceY = (placeAt.getY() + against1.getY() + 1.0D) * 0.5D;
+                double faceY = (placeAt.getY() + against1.getY() + 0.5D) * 0.5D;
                 double faceZ = (placeAt.getZ() + against1.getZ() + 1.0D) * 0.5D;
                 Rotation place = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), new Vec3d(faceX, faceY, faceZ), ctx.playerRotations());
                 RayTraceResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance());
-                if (res != null && res.type == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(placeAt)) {
+                if (res != null && res.typeOfHit == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(placeAt)) {
                     state.setTarget(new MovementState.MovementTarget(place, true));
                     found = true;
 

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

@@ -276,7 +276,7 @@ public enum Moves {
         }
     },
 
-    PARKOUR_NORTH(0, 0, -4, true, false) {
+    PARKOUR_NORTH(0, 0, -4, true, true) {
         @Override
         public Movement apply0(CalculationContext context, BetterBlockPos src) {
             return MovementParkour.cost(context, src, EnumFacing.NORTH);
@@ -288,7 +288,7 @@ public enum Moves {
         }
     },
 
-    PARKOUR_SOUTH(0, 0, +4, true, false) {
+    PARKOUR_SOUTH(0, 0, +4, true, true) {
         @Override
         public Movement apply0(CalculationContext context, BetterBlockPos src) {
             return MovementParkour.cost(context, src, EnumFacing.SOUTH);
@@ -300,7 +300,7 @@ public enum Moves {
         }
     },
 
-    PARKOUR_EAST(+4, 0, 0, true, false) {
+    PARKOUR_EAST(+4, 0, 0, true, true) {
         @Override
         public Movement apply0(CalculationContext context, BetterBlockPos src) {
             return MovementParkour.cost(context, src, EnumFacing.EAST);
@@ -312,7 +312,7 @@ public enum Moves {
         }
     },
 
-    PARKOUR_WEST(-4, 0, 0, true, false) {
+    PARKOUR_WEST(-4, 0, 0, true, true) {
         @Override
         public Movement apply0(CalculationContext context, BetterBlockPos src) {
             return MovementParkour.cost(context, src, EnumFacing.WEST);

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

@@ -145,7 +145,7 @@ public class MovementDescend extends Movement {
             IBlockState ontoBlock = context.get(destX, newY, destZ);
             int unprotectedFallHeight = fallHeight - (y - effectiveStartHeight); // equal to fallHeight - y + effectiveFallHeight, which is equal to -newY + effectiveFallHeight, which is equal to effectiveFallHeight - newY
             double tentativeCost = WALK_OFF_BLOCK_COST + FALL_N_BLOCKS_COST[unprotectedFallHeight] + frontBreak + costSoFar;
-            if (MovementHelper.isWater(ontoBlock)) {
+            if (MovementHelper.isWater(ontoBlock.getBlock())) {
                 if (!MovementHelper.canWalkThrough(context.bsi, destX, newY, destZ, ontoBlock)) {
                     return false;
                 }
@@ -224,7 +224,7 @@ public class MovementDescend extends Movement {
             double destZ = (src.getZ() + 0.5) * 0.17 + (dest.getZ() + 0.5) * 0.83;
             EntityPlayerSP player = ctx.player();
             state.setTarget(new MovementState.MovementTarget(
-                    new Rotation(RotationUtils.calcRotationFromVec3d(player.getEyePosition(1.0F),
+                    new Rotation(RotationUtils.calcRotationFromVec3d(player.getPositionEyes(1.0F),
                             new Vec3d(destX, dest.getY(), destZ),
                             new Rotation(player.rotationYaw, player.rotationPitch)).getYaw(), player.rotationPitch),
                     false
@@ -256,7 +256,7 @@ public class MovementDescend extends Movement {
             return true;
         }
         for (int y = 0; y <= 2; y++) { // we could hit any of the three blocks
-            if (MovementHelper.avoidWalkingInto(BlockStateInterface.get(ctx, into.up(y)))) {
+            if (MovementHelper.avoidWalkingInto(BlockStateInterface.getBlock(ctx, into.up(y)))) {
                 return true;
             }
         }

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

@@ -103,12 +103,12 @@ public class MovementDiagonal extends Movement {
         if (fromDown == Blocks.SOUL_SAND) {
             multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
         }
-        IBlockState cuttingOver1 = context.get(x, y - 1, destZ);
+        Block cuttingOver1 = context.get(x, y - 1, destZ).getBlock();
-        if (cuttingOver1.getBlock() == Blocks.MAGMA_BLOCK || MovementHelper.isLava(cuttingOver1)) {
+        if (cuttingOver1 == Blocks.MAGMA || MovementHelper.isLava(cuttingOver1)) {
             return;
         }
-        IBlockState cuttingOver2 = context.get(destX, y - 1, z);
+        Block cuttingOver2 = context.get(destX, y - 1, z).getBlock();
-        if (cuttingOver2.getBlock() == Blocks.MAGMA_BLOCK || MovementHelper.isLava(cuttingOver2)) {
+        if (cuttingOver2 == Blocks.MAGMA || MovementHelper.isLava(cuttingOver2)) {
             return;
         }
         IBlockState pb0 = context.get(x, y, destZ);
@@ -127,7 +127,7 @@ public class MovementDiagonal extends Movement {
             return;
         }
         IBlockState pb3 = context.get(destX, y + 1, z);
-        if (optionA == 0 && ((MovementHelper.avoidWalkingInto(pb2) && pb2.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb3))) {
+        if (optionA == 0 && ((MovementHelper.avoidWalkingInto(pb2.getBlock()) && pb2.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb3.getBlock()))) {
             // at this point we're done calculating optionA, so we can check if it's actually possible to edge around in that direction
             return;
         }
@@ -136,14 +136,13 @@ public class MovementDiagonal extends Movement {
             // and finally, if the cost is nonzero for both ways to approach this diagonal, it's not possible
             return;
         }
-        if (optionB == 0 && ((MovementHelper.avoidWalkingInto(pb0) && pb0.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb1))) {
+        if (optionB == 0 && ((MovementHelper.avoidWalkingInto(pb0.getBlock()) && pb0.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb1.getBlock()))) {
             // and now that option B is fully calculated, see if we can edge around that way
             return;
         }
         boolean water = false;
-        IBlockState startState = context.get(x, y, z);
+        Block startIn = context.getBlock(x, y, z);
-        Block startIn = startState.getBlock();
+        if (MovementHelper.isWater(startIn) || MovementHelper.isWater(destInto.getBlock())) {
-        if (MovementHelper.isWater(startState) || MovementHelper.isWater(destInto)) {
             // 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

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

@@ -34,7 +34,6 @@ import net.minecraft.block.Block;
 import net.minecraft.block.BlockLadder;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
@@ -92,11 +91,10 @@ public class MovementFall extends Movement {
         BlockPos playerFeet = ctx.playerFeet();
         Rotation toDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations());
         Rotation targetRotation = null;
-        IBlockState destState = ctx.world().getBlockState(dest);
+        Block destBlock = ctx.world().getBlockState(dest).getBlock();
-        Block destBlock = destState.getBlock();
+        boolean isWater = destBlock == Blocks.WATER || destBlock == Blocks.FLOWING_WATER;
-        boolean isWater = destState.getFluidState().getFluid() instanceof WaterFluid;
         if (!isWater && willPlaceBucket() && !playerFeet.equals(dest)) {
-            if (!InventoryPlayer.isHotbar(ctx.player().inventory.getSlotFor(STACK_BUCKET_WATER)) || ctx.world().getDimension().isNether()) {
+            if (!InventoryPlayer.isHotbar(ctx.player().inventory.getSlotFor(STACK_BUCKET_WATER)) || ctx.world().provider.isNether()) {
                 return state.setStatus(MovementStatus.UNREACHABLE);
             }
 
@@ -162,7 +160,7 @@ public class MovementFall extends Movement {
         for (int i = 0; i < 15; i++) {
             IBlockState state = ctx.world().getBlockState(ctx.playerFeet().down(i));
             if (state.getBlock() == Blocks.LADDER) {
-                return state.get(BlockLadder.FACING);
+                return state.getValue(BlockLadder.FACING);
             }
         }
         return null;

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

@@ -28,11 +28,10 @@ import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.pathing.MutableMoveResult;
 import net.minecraft.block.Block;
+import net.minecraft.block.BlockLiquid;
 import net.minecraft.block.BlockStairs;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
-import net.minecraft.init.Fluids;
 import net.minecraft.util.EnumFacing;
 
 import java.util.HashSet;
@@ -44,18 +43,20 @@ public class MovementParkour extends Movement {
 
     private final EnumFacing direction;
     private final int dist;
+    private final boolean ascend;
 
-    private MovementParkour(IBaritone baritone, BetterBlockPos src, int dist, EnumFacing dir) {
+    private MovementParkour(IBaritone baritone, BetterBlockPos src, int dist, EnumFacing dir, boolean ascend) {
-        super(baritone, src, src.offset(dir, dist), EMPTY, src.offset(dir, dist).down());
+        super(baritone, src, src.offset(dir, dist).up(ascend ? 1 : 0), EMPTY, src.offset(dir, dist).down(ascend ? 0 : 1));
         this.direction = dir;
         this.dist = dist;
+        this.ascend = ascend;
     }
 
     public static MovementParkour cost(CalculationContext context, BetterBlockPos src, EnumFacing direction) {
         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(context.getBaritone(), src, dist, direction);
+        return new MovementParkour(context.getBaritone(), src, dist, direction, res.y > src.y);
     }
 
     public static void cost(CalculationContext context, int x, int y, int z, EnumFacing dir, MutableMoveResult res) {
@@ -77,7 +78,7 @@ public class MovementParkour extends Movement {
             // second most common case -- we could just traverse not parkour
             return;
         }
-        if (MovementHelper.avoidWalkingInto(adj) && !(adj.getFluidState().getFluid() instanceof WaterFluid)) { // magma sucks
+        if (MovementHelper.avoidWalkingInto(adj.getBlock()) && adj.getBlock() != Blocks.WATER && adj.getBlock() != Blocks.FLOWING_WATER) { // magma sucks
             return;
         }
         if (!MovementHelper.fullyPassable(context, x + xDiff, y + 1, z + zDiff)) {
@@ -90,7 +91,7 @@ public class MovementParkour extends Movement {
             return;
         }
         IBlockState standingOn = context.get(x, y - 1, z);
-        if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn) || standingOn.getFluidState().getFluid() != Fluids.EMPTY) {
+        if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn) || standingOn.getBlock() instanceof BlockLiquid) {
             return;
         }
         int maxJump;
@@ -104,19 +105,36 @@ public class MovementParkour extends Movement {
             }
         }
         for (int i = 2; i <= maxJump; i++) {
-            // TODO perhaps dest.up(3) doesn't need to be fullyPassable, just canWalkThrough, possibly?
+            int destX = x + xDiff * i;
-            for (int y2 = 0; y2 < 4; y2++) {
+            int destZ = z + zDiff * i;
-                if (!MovementHelper.fullyPassable(context, x + xDiff * i, y + y2, z + zDiff * i)) {
+            if (!MovementHelper.fullyPassable(context, destX, y + 1, destZ)) {
-                    return;
+                return;
-                }
             }
-            IBlockState landingOn = context.bsi.get0(x + xDiff * i, y - 1, z + zDiff * i);
+            if (!MovementHelper.fullyPassable(context, destX, y + 2, destZ)) {
+                return;
+            }
+            IBlockState destInto = context.bsi.get0(destX, y, destZ);
+            if (!MovementHelper.fullyPassable(destInto)) {
+                if (i <= 3 && context.allowParkourAscend && context.canSprint && MovementHelper.canWalkOn(context.bsi, destX, y, destZ, destInto) && checkOvershootSafety(context.bsi, destX + xDiff, y + 1, destZ + zDiff)) {
+                    res.x = destX;
+                    res.y = y + 1;
+                    res.z = destZ;
+                    res.cost = i * SPRINT_ONE_BLOCK_COST + context.jumpPenalty;
+                }
+                return;
+            }
+            IBlockState landingOn = context.bsi.get0(destX, y - 1, destZ);
             // farmland needs to be canwalkon otherwise farm can never work at all, but we want to specifically disallow ending a jumy on farmland haha
-            if (landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, x + xDiff * i, y - 1, z + zDiff * i, landingOn)) {
+            if (landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, landingOn)) {
-                res.x = x + xDiff * i;
+                if (checkOvershootSafety(context.bsi, destX + xDiff, y, destZ + zDiff)) {
-                res.y = y;
+                    res.x = destX;
-                res.z = z + zDiff * i;
+                    res.y = y;
-                res.cost = costFromJumpDistance(i) + context.jumpPenalty;
+                    res.z = destZ;
+                    res.cost = costFromJumpDistance(i) + context.jumpPenalty;
+                }
+                return;
+            }
+            if (!MovementHelper.fullyPassable(context, destX, y + 3, destZ)) {
                 return;
             }
         }
@@ -137,6 +155,9 @@ public class MovementParkour extends Movement {
         if (!MovementHelper.isReplacable(destX, y - 1, destZ, toReplace, context.bsi)) {
             return;
         }
+        if (!checkOvershootSafety(context.bsi, destX + xDiff, y, destZ + zDiff)) {
+            return;
+        }
         for (int i = 0; i < 5; i++) {
             int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
             int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
@@ -154,6 +175,11 @@ public class MovementParkour extends Movement {
         }
     }
 
+    private static boolean checkOvershootSafety(BlockStateInterface bsi, int x, int y, int z) {
+        // we're going to walk into these two blocks after the landing of the parkour anyway, so make sure they aren't avoidWalkingInto
+        return !MovementHelper.avoidWalkingInto(bsi.get0(x, y, z).getBlock()) && !MovementHelper.avoidWalkingInto(bsi.get0(x, y + 1, z).getBlock());
+    }
+
     private static double costFromJumpDistance(int dist) {
         switch (dist) {
             case 2:
@@ -172,7 +198,7 @@ public class MovementParkour extends Movement {
     public double calculateCost(CalculationContext context) {
         MutableMoveResult res = new MutableMoveResult();
         cost(context, src.x, src.y, src.z, direction, res);
-        if (res.x != dest.x || res.z != dest.z) {
+        if (res.x != dest.x || res.y != dest.y || res.z != dest.z) {
             return COST_INF;
         }
         return res.cost;
@@ -203,16 +229,12 @@ public class MovementParkour extends Movement {
         if (state.getStatus() != MovementStatus.RUNNING) {
             return state;
         }
-        if (ctx.player().isHandActive()) {
-            logDebug("Pausing parkour since hand is active");
-            return state;
-        }
         if (ctx.playerFeet().y < src.y) {
             // we have fallen
             logDebug("sorry");
             return state.setStatus(MovementStatus.UNREACHABLE);
         }
-        if (dist >= 4) {
+        if (dist >= 4 || ascend) {
             state.setInput(Input.SPRINT, true);
         }
         MovementHelper.moveTowards(ctx, state, dest);
@@ -232,7 +254,8 @@ public class MovementParkour extends Movement {
                     // go in the opposite order to check DOWN before all horizontals -- down is preferable because you don't have to look to the side while in midair, which could mess up the trajectory
                     state.setInput(Input.CLICK_RIGHT, true);
                 }
-                if (dist == 3) { // this is a 2 block gap, dest = src + direction * 3
+                // prevent jumping too late by checking for ascend
+                if (dist == 3 && !ascend) { // this is a 2 block gap, dest = src + direction * 3
                     double xDiff = (src.x + 0.5) - ctx.player().posX;
                     double zDiff = (src.z + 0.5) - ctx.player().posZ;
                     double distFromStart = Math.max(Math.abs(xDiff), Math.abs(zDiff));

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

@@ -57,15 +57,14 @@ public class MovementPillar extends Movement {
     }
 
     public static double cost(CalculationContext context, int x, int y, int z) {
-        IBlockState fromState = context.get(x, y, z);
+        Block from = context.get(x, y, z).getBlock();
-        Block from = fromState.getBlock();
         boolean ladder = from == Blocks.LADDER || from == Blocks.VINE;
         IBlockState fromDown = context.get(x, y - 1, z);
         if (!ladder) {
             if (fromDown.getBlock() == Blocks.LADDER || fromDown.getBlock() == Blocks.VINE) {
                 return COST_INF; // can't pillar from a ladder or vine onto something that isn't also climbable
             }
-            if (fromDown.getBlock() instanceof BlockSlab && !fromDown.isTopSolid()) {
+            if (fromDown.getBlock() instanceof BlockSlab && !((BlockSlab) fromDown.getBlock()).isDouble() && fromDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) {
                 return COST_INF; // can't pillar up from a bottom slab onto a non ladder
             }
         }
@@ -77,9 +76,9 @@ public class MovementPillar extends Movement {
         if (toBreakBlock instanceof BlockFenceGate) { // see issue #172
             return COST_INF;
         }
-        IBlockState srcUp = null;
+        Block srcUp = null;
-        if (MovementHelper.isWater(toBreak) && MovementHelper.isWater(fromState)) { // TODO should this also be allowed if toBreakBlock is air?
+        if (MovementHelper.isWater(toBreakBlock) && MovementHelper.isWater(from)) { // TODO should this also be allowed if toBreakBlock is air?
-            srcUp = context.get(x, y + 1, z);
+            srcUp = context.get(x, y + 1, z).getBlock();
             if (MovementHelper.isWater(srcUp)) {
                 return LADDER_UP_ONE_COST; // allow ascending pillars of water, but only if we're already in one
             }
@@ -91,11 +90,11 @@ public class MovementPillar extends Movement {
             if (placeCost >= COST_INF) {
                 return COST_INF;
             }
-            if (fromDown.getBlock() instanceof BlockAir) {
+            if (fromDown.getBlock() == Blocks.AIR) {
                 placeCost += 0.1; // slightly (1/200th of a second) penalize pillaring on what's currently air
             }
         }
-        if ((MovementHelper.isLiquid(fromState) && !MovementHelper.canPlaceAgainst(context.bsi, x, y - 1, z, fromDown)) || (MovementHelper.isLiquid(fromDown) && context.assumeWalkOnWater)) {
+        if (from instanceof BlockLiquid || (fromDown.getBlock() instanceof BlockLiquid && context.assumeWalkOnWater)) {
             // otherwise, if we're standing in water, we cannot pillar
             // if we're standing on water and assumeWalkOnWater is true, we cannot pillar
             // if we're standing on water and assumeWalkOnWater is false, we must have ascended to here, or sneak backplaced, so it is possible to pillar again
@@ -113,9 +112,9 @@ public class MovementPillar extends Movement {
                 if (check.getBlock() instanceof BlockFalling) {
                     // see MovementAscend's identical check for breaking a falling block above our head
                     if (srcUp == null) {
-                        srcUp = context.get(x, y + 1, z);
+                        srcUp = context.get(x, y + 1, z).getBlock();
                     }
-                    if (!(toBreakBlock instanceof BlockFalling) || !(srcUp.getBlock() instanceof BlockFalling)) {
+                    if (!(toBreakBlock instanceof BlockFalling) || !(srcUp instanceof BlockFalling)) {
                         return COST_INF;
                     }
                 }
@@ -170,7 +169,7 @@ public class MovementPillar extends Movement {
         }
 
         IBlockState fromDown = BlockStateInterface.get(ctx, src);
-        if (MovementHelper.isWater(fromDown) && MovementHelper.isWater(ctx, dest)) {
+        if (MovementHelper.isWater(fromDown.getBlock()) && MovementHelper.isWater(ctx, dest)) {
             // stay centered while swimming up a water column
             state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations()), false));
             Vec3d destCenter = VecUtils.getBlockPosCenter(dest);
@@ -184,7 +183,7 @@ public class MovementPillar extends Movement {
         }
         boolean ladder = fromDown.getBlock() == Blocks.LADDER || fromDown.getBlock() == Blocks.VINE;
         boolean vine = fromDown.getBlock() == Blocks.VINE;
-        Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.player().getEyePosition(1.0F),
+        Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.player().getPositionEyes(1.0F),
                 VecUtils.getBlockPosCenter(positionToPlace),
                 new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));
         if (!ladder) {
@@ -193,7 +192,7 @@ public class MovementPillar extends Movement {
 
         boolean blockIsThere = MovementHelper.canWalkOn(ctx, src) || ladder;
         if (ladder) {
-            BlockPos against = vine ? getAgainst(new CalculationContext(baritone), src) : src.offset(fromDown.get(BlockLadder.FACING).getOpposite());
+            BlockPos against = vine ? getAgainst(new CalculationContext(baritone), src) : src.offset(fromDown.getValue(BlockLadder.FACING).getOpposite());
             if (against == null) {
                 logDebug("Unable to climb vines");
                 return state.setStatus(MovementStatus.UNREACHABLE);

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

@@ -33,9 +33,7 @@ import baritone.utils.BlockStateInterface;
 import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
-import net.minecraft.state.properties.SlabType;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 
@@ -73,12 +71,11 @@ public class MovementTraverse extends Movement {
         IBlockState pb0 = context.get(destX, y + 1, destZ);
         IBlockState pb1 = context.get(destX, y, destZ);
         IBlockState destOn = context.get(destX, y - 1, destZ);
-        IBlockState down = context.get(x, y - 1, z);
+        Block srcDown = context.getBlock(x, y - 1, z);
-        Block srcDown = down.getBlock();
         if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn)) {//this is a walk, not a bridge
             double WC = WALK_ONE_BLOCK_COST;
             boolean water = false;
-            if (MovementHelper.isWater(pb0) || MovementHelper.isWater(pb1)) {
+            if (MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
                 WC = context.waterWalkSpeed;
                 water = true;
             } else {
@@ -115,8 +112,8 @@ public class MovementTraverse extends Movement {
                 return COST_INF;
             }
             if (MovementHelper.isReplacable(destX, y - 1, destZ, destOn, context.bsi)) {
-                boolean throughWater = MovementHelper.isWater(pb0) || MovementHelper.isWater(pb1);
+                boolean throughWater = MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock());
-                if (MovementHelper.isWater(destOn) && throughWater) {
+                if (MovementHelper.isWater(destOn.getBlock()) && throughWater) {
                     // this happens when assume walk on water is true and this is a traverse in water, which isn't allowed
                     return COST_INF;
                 }
@@ -142,10 +139,10 @@ public class MovementTraverse extends Movement {
                     }
                 }
                 // now that we've checked all possible directions to side place, we actually need to backplace
-                if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && down.get(BlockSlab.TYPE) != SlabType.DOUBLE)) {
+                if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && !((BlockSlab) srcDown).isDouble())) {
                     return COST_INF; // can't sneak and backplace against soul sand or half slabs (regardless of whether it's top half or bottom half) =/
                 }
-                if (down.getFluidState() instanceof WaterFluid) {
+                if (srcDown == Blocks.FLOWING_WATER || srcDown == Blocks.WATER) {
                     return COST_INF; // this is obviously impossible
                 }
                 WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
@@ -170,10 +167,10 @@ public class MovementTraverse extends Movement {
                 return state;
             }
             // and if it's fine to walk into the blocks in front
-            if (MovementHelper.avoidWalkingInto(pb0)) {
+            if (MovementHelper.avoidWalkingInto(pb0.getBlock())) {
                 return state;
             }
-            if (MovementHelper.avoidWalkingInto(pb1)) {
+            if (MovementHelper.avoidWalkingInto(pb1.getBlock())) {
                 return state;
             }
             // and we aren't already pressed up against the block
@@ -254,8 +251,8 @@ public class MovementTraverse extends Movement {
                 return state;
             }
             BlockPos into = dest.subtract(src).add(dest);
-            IBlockState intoBelow = BlockStateInterface.get(ctx, into);
+            Block intoBelow = BlockStateInterface.get(ctx, into).getBlock();
-            IBlockState intoAbove = BlockStateInterface.get(ctx, into.up());
+            Block intoAbove = BlockStateInterface.get(ctx, into.up()).getBlock();
             if (wasTheBridgeBlockAlwaysThere && (!MovementHelper.isLiquid(ctx, feet) || Baritone.settings().sprintInWater.value) && (!MovementHelper.avoidWalkingInto(intoBelow) || MovementHelper.isWater(intoBelow)) && !MovementHelper.avoidWalkingInto(intoAbove)) {
                 state.setInput(Input.SPRINT, true);
             }
@@ -263,7 +260,7 @@ public class MovementTraverse extends Movement {
             IBlockState destDown = BlockStateInterface.get(ctx, dest.down());
             BlockPos against = positionsToBreak[0];
             if (feet.getY() != dest.getY() && ladder && (destDown.getBlock() == Blocks.VINE || destDown.getBlock() == Blocks.LADDER)) {
-                against = destDown.getBlock() == Blocks.VINE ? MovementPillar.getAgainst(new CalculationContext(baritone), dest.down()) : dest.offset(destDown.get(BlockLadder.FACING).getOpposite());
+                against = destDown.getBlock() == Blocks.VINE ? MovementPillar.getAgainst(new CalculationContext(baritone), dest.down()) : dest.offset(destDown.getValue(BlockLadder.FACING).getOpposite());
             }
             MovementHelper.moveTowards(ctx, state, against);
             return state;

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

@@ -32,6 +32,7 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.movements.*;
 import baritone.utils.BlockStateInterface;
+import net.minecraft.block.BlockLiquid;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
@@ -42,8 +43,7 @@ import java.util.*;
 import static baritone.api.pathing.movement.MovementStatus.*;
 
 /**
- * Behavior to execute a precomputed path. Does not (yet) deal with path segmentation or stitching
+ * Behavior to execute a precomputed path
- * or cutting (jumping onto the next path if it starts with a backtrack of this path's ending)
  *
  * @author leijurv
  */
@@ -130,7 +130,7 @@ public class PathExecutor implements IPathExecutor, Helper {
         Tuple<Double, BlockPos> status = closestPathPos(path);
         if (possiblyOffPath(status, MAX_DIST_FROM_PATH)) {
             ticksAway++;
-            System.out.println("FAR AWAY FROM PATH FOR " + ticksAway + " TICKS. Current distance: " + status.getA() + ". Threshold: " + MAX_DIST_FROM_PATH);
+            System.out.println("FAR AWAY FROM PATH FOR " + ticksAway + " TICKS. Current distance: " + status.getFirst() + ". Threshold: " + MAX_DIST_FROM_PATH);
             if (ticksAway > MAX_TICKS_AWAY) {
                 logDebug("Too far away from path for too long, cancelling path");
                 cancel();
@@ -303,7 +303,7 @@ public class PathExecutor implements IPathExecutor, Helper {
     }
 
     private boolean possiblyOffPath(Tuple<Double, BlockPos> status, double leniency) {
-        double distanceFromPath = status.getA();
+        double distanceFromPath = status.getFirst();
         if (distanceFromPath > leniency) {
             // when we're midair in the middle of a fall, we're very far from both the beginning and the end, but we aren't actually off path
             if (path.movements().get(pathPosition) instanceof MovementFall) {
@@ -323,7 +323,7 @@ public class PathExecutor implements IPathExecutor, Helper {
      * @return Whether or not it was possible to snap to the current player feet
      */
     public boolean snipsnapifpossible() {
-        if (!ctx.player().onGround && ctx.world().getFluidState(ctx.playerFeet()).isEmpty()) {
+        if (!ctx.player().onGround && !(ctx.world().getBlockState(ctx.playerFeet()).getBlock() instanceof BlockLiquid)) {
             // if we're falling in the air, and not in water, don't splice
             return false;
         } else {
@@ -426,7 +426,7 @@ public class PathExecutor implements IPathExecutor, Helper {
         if (current instanceof MovementFall) {
             Tuple<Vec3d, BlockPos> data = overrideFall((MovementFall) current);
             if (data != null) {
-                BetterBlockPos fallDest = new BetterBlockPos(data.getB());
+                BetterBlockPos fallDest = new BetterBlockPos(data.getSecond());
                 if (!path.positions().contains(fallDest)) {
                     throw new IllegalStateException();
                 }
@@ -437,7 +437,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                     return true;
                 }
                 clearKeys();
-                behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getA(), ctx.playerRotations()), false);
+                behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getFirst(), ctx.playerRotations()), false);
                 behavior.baritone.getInputOverrideHandler().setInputForceState(Input.MOVE_FORWARD, true);
                 return true;
             }
@@ -529,10 +529,10 @@ public class PathExecutor implements IPathExecutor, Helper {
                 }
             }
         }
-        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(current.getSrc().up(3)))) {
+        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(current.getSrc().up(3)).getBlock())) {
             return false;
         }
-        return !MovementHelper.avoidWalkingInto(ctx.world().getBlockState(next.getDest().up(2))); // codacy smh my head
+        return !MovementHelper.avoidWalkingInto(ctx.world().getBlockState(next.getDest().up(2)).getBlock()); // codacy smh my head
     }
 
     private static boolean canSprintFromDescendInto(IPlayerContext ctx, IMovement current, IMovement next) {

src/main/java/baritone/process/BackfillProcess.java

@@ -28,6 +28,7 @@ import baritone.pathing.path.PathExecutor;
 import baritone.utils.BaritoneProcessHelper;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.EmptyChunk;
 
@@ -103,7 +104,7 @@ public final class BackfillProcess extends BaritoneProcessHelper {
                 .keySet()
                 .stream()
                 .filter(pos -> ctx.world().getBlockState(pos).getBlock() == Blocks.AIR)
-                .filter(pos -> baritone.getBuilderProcess().placementPlausible(pos, Blocks.DIRT.getDefaultState()))
+                .filter(pos -> ctx.world().mayPlace(Blocks.DIRT, pos, false, EnumFacing.UP, null))
                 .filter(pos -> !partOfCurrentMovement(pos))
                 .sorted(Comparator.<BlockPos>comparingDouble(ctx.player()::getDistanceSq).reversed())
                 .collect(Collectors.toList());

src/main/java/baritone/process/BuilderProcess.java

@@ -34,23 +34,21 @@ import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.PathingCommandContext;
 import baritone.utils.schematic.AirSchematic;
+import baritone.utils.schematic.MapArtSchematic;
 import baritone.utils.schematic.Schematic;
 import baritone.utils.schematic.schematica.SchematicaHelper;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import net.minecraft.block.BlockAir;
-import net.minecraft.block.BlockFlowingFluid;
+import net.minecraft.block.BlockLiquid;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
-import net.minecraft.item.BlockItemUseContext;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
-import net.minecraft.item.ItemUseContext;
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.*;
-import net.minecraft.util.math.shapes.VoxelShape;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -115,7 +113,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         if (SchematicaHelper.isSchematicaPresent()) {
             Optional<Tuple<ISchematic, BlockPos>> schematic = SchematicaHelper.getOpenSchematic();
             if (schematic.isPresent()) {
-                this.build(schematic.get().getA().toString(), schematic.get().getA(), schematic.get().getB());
+                this.build(schematic.get().getFirst().toString(), schematic.get().getFirst(), schematic.get().getSecond());
             } else {
                 logDirect("No schematic currently open");
             }
@@ -133,7 +131,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
     }
 
     private static ISchematic parse(NBTTagCompound schematic) {
-        return new Schematic(schematic);
+        return Baritone.settings().mapArtMode.value ? new MapArtSchematic(schematic) : new Schematic(schematic);
     }
 
     @Override
@@ -149,7 +147,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             return null;
         }
         IBlockState state = schematic.desiredState(x - origin.getX(), y - origin.getY(), z - origin.getZ());
-        if (state.getBlock() instanceof BlockAir) {
+        if (state.getBlock() == Blocks.AIR) {
             return null;
         }
         return state;
@@ -172,7 +170,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                         continue; // irrelevant
                     }
                     IBlockState curr = bcc.bsi.get0(x, y, z);
-                    if (!(curr.getBlock() instanceof BlockAir) && !(curr.getBlock() == Blocks.WATER || curr.getBlock() == Blocks.LAVA) && !valid(curr, desired)) {
+                    if (curr.getBlock() != Blocks.AIR && !(curr.getBlock() instanceof BlockLiquid) && !valid(curr, desired)) {
                         BetterBlockPos pos = new BetterBlockPos(x, y, z);
                         Optional<Rotation> rot = RotationUtils.reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
                         if (rot.isPresent()) {
@@ -213,7 +211,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                     }
                     IBlockState curr = bcc.bsi.get0(x, y, z);
                     if (MovementHelper.isReplacable(x, y, z, curr, bcc.bsi) && !valid(curr, desired)) {
-                        if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() instanceof BlockAir) {
+                        if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() == Blocks.AIR) {
                             continue;
                         }
                         desirableOnHotbar.add(desired);
@@ -228,11 +226,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         return Optional.empty();
     }
 
-    public boolean placementPlausible(BlockPos pos, IBlockState state) {
-        VoxelShape voxelshape = state.getCollisionShape(ctx.world(), pos);
-        return voxelshape.isEmpty() || ctx.world().checkNoEntityCollision(null, voxelshape.withOffset(pos.getX(), pos.getY(), pos.getZ()));
-    }
-
     private Optional<Placement> possibleToPlace(IBlockState toPlace, int x, int y, int z, BlockStateInterface bsi) {
         for (EnumFacing against : EnumFacing.values()) {
             BetterBlockPos placeAgainstPos = new BetterBlockPos(x, y, z).offset(against);
@@ -240,20 +233,17 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             if (MovementHelper.isReplacable(placeAgainstPos.x, placeAgainstPos.y, placeAgainstPos.z, placeAgainstState, bsi)) {
                 continue;
             }
-            if (!toPlace.isValidPosition(ctx.world(), new BetterBlockPos(x, y, z))) {
+            if (!ctx.world().mayPlace(toPlace.getBlock(), new BetterBlockPos(x, y, z), false, against, null)) {
                 continue;
             }
-            if (!placementPlausible(new BetterBlockPos(x, y, z), toPlace)) {
+            AxisAlignedBB aabb = placeAgainstState.getBoundingBox(ctx.world(), placeAgainstPos);
-                continue;
-            }
-            AxisAlignedBB aabb = placeAgainstState.getShape(ctx.world(), placeAgainstPos).getBoundingBox();
             for (Vec3d placementMultiplier : aabbSideMultipliers(against)) {
                 double placeX = placeAgainstPos.x + aabb.minX * placementMultiplier.x + aabb.maxX * (1 - placementMultiplier.x);
                 double placeY = placeAgainstPos.y + aabb.minY * placementMultiplier.y + aabb.maxY * (1 - placementMultiplier.y);
                 double placeZ = placeAgainstPos.z + aabb.minZ * placementMultiplier.z + aabb.maxZ * (1 - placementMultiplier.z);
                 Rotation rot = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), new Vec3d(placeX, placeY, placeZ), ctx.playerRotations());
                 RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot, ctx.playerController().getBlockReachDistance());
-                if (result != null && result.type == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(placeAgainstPos) && result.sideHit == against.getOpposite()) {
+                if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(placeAgainstPos) && result.sideHit == against.getOpposite()) {
                     OptionalInt hotbar = hasAnyItemThatWouldPlace(toPlace, result, rot);
                     if (hotbar.isPresent()) {
                         return Optional.of(new Placement(hotbar.getAsInt(), placeAgainstPos, against.getOpposite(), rot));
@@ -275,24 +265,18 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             // the state depends on the facing of the player sometimes
             ctx.player().rotationYaw = rot.getYaw();
             ctx.player().rotationPitch = rot.getPitch();
-            BlockItemUseContext meme = new BlockItemUseContext(new ItemUseContext(
+            IBlockState wouldBePlaced = ((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(
-                    ctx.player(),
+                    ctx.world(),
-                    stack,
                     result.getBlockPos().offset(result.sideHit),
                     result.sideHit,
-                    (float) result.hitVec.x - result.getBlockPos().getX(),
+                    (float) result.hitVec.x - result.getBlockPos().getX(), // as in PlayerControllerMP
                     (float) result.hitVec.y - result.getBlockPos().getY(),
-                    (float) result.hitVec.z - result.getBlockPos().getZ()
+                    (float) result.hitVec.z - result.getBlockPos().getZ(),
-            ));
+                    stack.getItem().getMetadata(stack.getMetadata()),
-            IBlockState wouldBePlaced = ((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(meme);
+                    ctx.player()
+            );
             ctx.player().rotationYaw = originalYaw;
             ctx.player().rotationPitch = originalPitch;
-            if (wouldBePlaced == null) {
-                continue;
-            }
-            if (!meme.canPlace()) {
-                continue;
-            }
             if (valid(wouldBePlaced, desired)) {
                 return OptionalInt.of(i);
             }
@@ -391,14 +375,16 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             logDirect("Repeating build in vector " + repeat + ", new origin is " + origin);
             return onTick(calcFailed, isSafeToCancel);
         }
-        trim();
+        if (Baritone.settings().distanceTrim.value) {
+            trim();
+        }
 
         Optional<Tuple<BetterBlockPos, Rotation>> toBreak = toBreakNearPlayer(bcc);
         if (toBreak.isPresent() && isSafeToCancel && ctx.player().onGround) {
             // we'd like to pause to break this block
             // only change look direction if it's safe (don't want to fuck up an in progress parkour for example
-            Rotation rot = toBreak.get().getB();
+            Rotation rot = toBreak.get().getSecond();
-            BetterBlockPos pos = toBreak.get().getA();
+            BetterBlockPos pos = toBreak.get().getFirst();
             baritone.getLookBehavior().updateTarget(rot, true);
             MovementHelper.switchToBestToolFor(ctx, bcc.get(pos));
             if (ctx.player().isSneaking()) {
@@ -451,7 +437,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             }
         }
 
-
         Goal goal = assemble(bcc, approxPlacable.subList(0, 9));
         if (goal == null) {
             goal = assemble(bcc, approxPlacable); // we're far away, so assume that we have our whole inventory to recalculate placable properly
@@ -530,6 +515,9 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                         } else {
                             incorrectPositions.add(new BetterBlockPos(blockX, blockY, blockZ));
                             observedCompleted.remove(BetterBlockPos.longHash(blockX, blockY, blockZ));
+                            if (incorrectPositions.size() > Baritone.settings().incorrectSize.value) {
+                                return;
+                            }
                         }
                         continue;
                     }
@@ -538,6 +526,9 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                         // and we've never seen this position be correct
                         // therefore mark as incorrect
                         incorrectPositions.add(new BetterBlockPos(blockX, blockY, blockZ));
+                        if (incorrectPositions.size() > Baritone.settings().incorrectSize.value) {
+                            return;
+                        }
                     }
                 }
             }
@@ -555,7 +546,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                     placable.add(pos);
                 }
             } else {
-                if (state.getBlock() instanceof BlockFlowingFluid) {
+                if (state.getBlock() instanceof BlockLiquid) {
                     // if the block itself is JUST a liquid (i.e. not just a waterlogged block), we CANNOT break it
                     // TODO for 1.13 make sure that this only matches pure water, not waterlogged blocks
                     if (!MovementHelper.possiblyFlowing(state)) {
@@ -630,13 +621,13 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
     }
 
     private Goal placementGoal(BlockPos pos, BuilderCalculationContext bcc) {
-        if (!(ctx.world().getBlockState(pos).getBlock() instanceof BlockAir)) {  // TODO can this even happen?
+        if (ctx.world().getBlockState(pos).getBlock() != Blocks.AIR) { // TODO can this even happen?
             return new GoalPlace(pos);
         }
-        boolean allowSameLevel = !(ctx.world().getBlockState(pos.up()).getBlock() instanceof BlockAir);
+        boolean allowSameLevel = ctx.world().getBlockState(pos.up()).getBlock() != Blocks.AIR;
         for (EnumFacing facing : Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP) {
-            if (MovementHelper.canPlaceAgainst(ctx, pos.offset(facing)) && placementPlausible(pos, bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()))) {
+            if (MovementHelper.canPlaceAgainst(ctx, pos.offset(facing)) && ctx.world().mayPlace(bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()).getBlock(), pos, false, facing, null)) {
-                return new GoalAdjacent(pos, allowSameLevel);
+                return new GoalAdjacent(pos, pos.offset(facing), allowSameLevel);
             }
         }
         return new GoalPlace(pos);
@@ -659,9 +650,11 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
 
     public static class GoalAdjacent extends GoalGetToBlock {
         private boolean allowSameLevel;
+        private BlockPos no;
 
-        public GoalAdjacent(BlockPos pos, boolean allowSameLevel) {
+        public GoalAdjacent(BlockPos pos, BlockPos no, boolean allowSameLevel) {
             super(pos);
+            this.no = no;
             this.allowSameLevel = allowSameLevel;
         }
 
@@ -669,6 +662,9 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             if (x == this.x && y == this.y && z == this.z) {
                 return false;
             }
+            if (x == no.getX() && y == no.getY() && z == no.getZ()) {
+                return false;
+            }
             if (!allowSameLevel && y == this.y - 1) {
                 return false;
             }
@@ -720,21 +716,18 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                 continue;
             }
             // <toxic cloud>
-            result.add(((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(new BlockItemUseContext(new ItemUseContext(ctx.player(), stack, ctx.playerFeet(), EnumFacing.UP, (float) ctx.player().posX, (float) ctx.player().posY, (float) ctx.player().posZ))));
+            result.add(((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(ctx.world(), ctx.playerFeet(), EnumFacing.UP, (float) ctx.player().posX, (float) ctx.player().posY, (float) ctx.player().posZ, stack.getItem().getMetadata(stack.getMetadata()), ctx.player()));
             // </toxic cloud>
         }
         return result;
     }
 
     private boolean valid(IBlockState current, IBlockState desired) {
-        if (desired == null) {
-            return true;
-        }
-        if (current.getBlock() instanceof BlockAir && desired.getBlock() instanceof BlockAir) {
-            return true;
-        }
         // TODO more complicated comparison logic I guess
-        return current.equals(desired);
+        if (current.getBlock() instanceof BlockLiquid && Baritone.settings().okIfWater.value) {
+            return true;
+        }
+        return desired == null || current.equals(desired);
     }
 
     public class BuilderCalculationContext extends CalculationContext {
@@ -772,7 +765,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             IBlockState sch = getSchematic(x, y, z);
             if (sch != null) {
                 // TODO this can return true even when allowPlace is off.... is that an issue?
-                if (sch.getBlock() instanceof BlockAir) {
+                if (sch.getBlock() == Blocks.AIR) {
                     // we want this to be air, but they're asking if they can place here
                     // this won't be a schematic block, this will be a throwaway
                     return placeBlockCost * 2; // we're going to have to break it eventually
@@ -805,7 +798,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             }
             IBlockState sch = getSchematic(x, y, z);
             if (sch != null) {
-                if (sch.getBlock() instanceof BlockAir) {
+                if (sch.getBlock() == Blocks.AIR) {
                     // it should be air
                     // regardless of current contents, we can break it
                     return 1;
@@ -813,7 +806,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                 // it should be a real block
                 // is it already that block?
                 if (valid(bsi.get0(x, y, z), sch)) {
-                    return 3;
+                    return Baritone.settings().breakCorrectBlockPenaltyMultiplier.value;
                 } else {
                     // can break if it's wrong
                     // would be great to return less than 1 here, but that would actually make the cost calculation messed up

src/main/java/baritone/process/ExploreProcess.java

@@ -140,6 +140,9 @@ public final class ExploreProcess extends BaritoneProcessHelper implements IExpl
                     centers.add(new BlockPos(centerX, 0, centerZ));
                 }
             }
+            if (dist % 10 == 0) {
+                count = Math.min(filter.countRemain(), Baritone.settings().exploreChunkSetMinimumSize.value);
+            }
             if (centers.size() >= count) {
                 return centers.stream().map(pos -> createGoal(pos.getX(), pos.getZ())).toArray(Goal[]::new);
             }

src/main/java/baritone/process/FarmProcess.java

@@ -37,7 +37,9 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
+import net.minecraft.item.EnumDyeColor;
 import net.minecraft.item.Item;
+import net.minecraft.item.ItemDye;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
@@ -71,17 +73,17 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
             Items.BEETROOT_SEEDS,
             Items.BEETROOT,
             Items.MELON_SEEDS,
-            Items.MELON_SLICE,
+            Items.MELON,
-            Blocks.MELON.asItem(),
+            Item.getItemFromBlock(Blocks.MELON_BLOCK),
             Items.WHEAT_SEEDS,
             Items.WHEAT,
             Items.PUMPKIN_SEEDS,
-            Blocks.PUMPKIN.asItem(),
+            Item.getItemFromBlock(Blocks.PUMPKIN),
             Items.POTATO,
             Items.CARROT,
             Items.NETHER_WART,
-            Blocks.SUGAR_CANE.asItem(),
+            Items.REEDS,
-            Blocks.CACTUS.asItem()
+            Item.getItemFromBlock(Blocks.CACTUS)
     );
 
     public FarmProcess(Baritone baritone) {
@@ -105,9 +107,9 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
         POTATOES((BlockCrops) Blocks.POTATOES),
         BEETROOT((BlockCrops) Blocks.BEETROOTS),
         PUMPKIN(Blocks.PUMPKIN, state -> true),
-        MELON(Blocks.MELON, state -> true),
+        MELON(Blocks.MELON_BLOCK, state -> true),
-        NETHERWART(Blocks.NETHER_WART, state -> state.get(BlockNetherWart.AGE) >= 3),
+        NETHERWART(Blocks.NETHER_WART, state -> state.getValue(BlockNetherWart.AGE) >= 3),
-        SUGARCANE(Blocks.SUGAR_CANE, null) {
+        SUGARCANE(Blocks.REEDS, null) {
             @Override
             public boolean readyToHarvest(World world, BlockPos pos, IBlockState state) {
                 return world.getBlockState(pos.down()).getBlock() instanceof BlockReed;
@@ -151,7 +153,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
     }
 
     private boolean isBoneMeal(ItemStack stack) {
-        return !stack.isEmpty() && stack.getItem().equals(Items.BONE_MEAL);
+        return !stack.isEmpty() && stack.getItem() instanceof ItemDye && EnumDyeColor.byDyeDamage(stack.getMetadata()) == EnumDyeColor.WHITE;
     }
 
     private boolean isNetherWart(ItemStack stack) {
@@ -224,7 +226,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
             Optional<Rotation> rot = RotationUtils.reachableOffset(ctx.player(), pos, new Vec3d(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5), ctx.playerController().getBlockReachDistance());
             if (rot.isPresent() && isSafeToCancel && baritone.getInventoryBehavior().throwaway(true, soulsand ? this::isNetherWart : this::isPlantable)) {
                 RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot.get(), ctx.playerController().getBlockReachDistance());
-                if (result.type == RayTraceResult.Type.BLOCK && result.sideHit == EnumFacing.UP) {
+                if (result.typeOfHit == RayTraceResult.Type.BLOCK && result.sideHit == EnumFacing.UP) {
                     baritone.getLookBehavior().updateTarget(rot.get(), true);
                     if (ctx.isLookingAt(pos)) {
                         baritone.getInputOverrideHandler().setInputForceState(Input.CLICK_RIGHT, true);

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

@@ -72,7 +72,7 @@ public final class FollowProcess extends BaritoneProcessHelper implements IFollo
         if (entity == null) {
             return false;
         }
-        if (!entity.isAlive()) {
+        if (entity.isDead) {
             return false;
         }
         if (entity.equals(ctx.player())) {

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

@@ -213,7 +213,7 @@ public final class GetToBlockProcess extends BaritoneProcessHelper implements IG
         if (!Baritone.settings().enterPortal.value) {
             return false;
         }
-        return block == Blocks.NETHER_PORTAL;
+        return block == Blocks.PORTAL;
     }
 
     private boolean rightClickOnArrival(Block block) {

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

@@ -79,11 +79,11 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
     @Override
     public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
         if (desiredQuantity > 0) {
-            Item item = mining.get(0).getItemDropped(mining.get(0).getDefaultState(), ctx.world(), null, 0).asItem();
+            Item item = mining.get(0).getItemDropped(mining.get(0).getDefaultState(), new Random(), 0);
             int curr = ctx.player().inventory.mainInventory.stream().filter(stack -> item.equals(stack.getItem())).mapToInt(ItemStack::getCount).sum();
             System.out.println("Currently have " + curr + " " + item);
             if (curr >= desiredQuantity) {
-                logDirect("Have " + curr + " " + item.getDisplayName(new ItemStack(item, 1)));
+                logDirect("Have " + curr + " " + item.getItemStackDisplayName(new ItemStack(item, 1)));
                 cancel();
                 return null;
             }
@@ -290,8 +290,8 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         }
         Set<Item> searchingFor = new HashSet<>();
         for (Block block : mining) {
-            Item drop = block.getItemDropped(block.getDefaultState(), world, null, 0).asItem();
+            Item drop = block.getItemDropped(block.getDefaultState(), new Random(), 0);
-            Item ore = block.asItem();
+            Item ore = Item.getItemFromBlock(block);
             searchingFor.add(drop);
             searchingFor.add(ore);
         }

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

@@ -24,21 +24,14 @@ import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalBlock;
 import baritone.api.utils.Helper;
 import baritone.api.utils.IPlayerContext;
-import net.minecraft.client.GameSettings;
 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.server.integrated.IntegratedServer;
-import net.minecraft.util.HttpUtil;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.GameType;
 import net.minecraft.world.WorldSettings;
 import net.minecraft.world.WorldType;
-import net.minecraft.world.dimension.DimensionType;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
 
 /**
  * Responsible for automatically testing Baritone's pathing algorithm by automatically creating a world with a specific
@@ -96,13 +89,11 @@ public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
             mc.launchIntegratedServer("BaritoneAutoTest", "BaritoneAutoTest", worldsettings);
         }
 
-        IntegratedServer server = mc.getIntegratedServer();
-
         // If the integrated server is launched and the world has initialized, set the spawn point
         // to our defined starting position
-        if (server != null && server.getWorld(DimensionType.OVERWORLD) != null) {
+        if (mc.getIntegratedServer() != null && mc.getIntegratedServer().worlds[0] != null) {
-            server.getWorld(DimensionType.OVERWORLD).setSpawnPoint(STARTING_POSITION);
+            mc.getIntegratedServer().worlds[0].setSpawnPoint(STARTING_POSITION);
-            server.getWorld(DimensionType.OVERWORLD).getGameRules().setOrCreateGameRule("spawnRadius", "0", server);
+            mc.getIntegratedServer().worlds[0].getGameRules().setOrCreateGameRule("spawnRadius", "0");
         }
 
         if (event.getType() == TickEvent.Type.IN) { // If we're in-game
@@ -110,7 +101,7 @@ public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
             // 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, HttpUtil.getSuitableLanPort());
+                mc.getIntegratedServer().shareToLAN(GameType.getByName("survival"), false);
             }
 
             // For the first 200 ticks, wait for the world to generate
@@ -132,16 +123,7 @@ public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
             // If we have reached our goal, print a message and safely close the game
             if (GOAL.isInGoal(ctx.playerFeet())) {
                 System.out.println("Successfully pathed to " + ctx.playerFeet() + " in " + event.getCount() + " ticks");
-                try {
-                    File file = new File("success");
-                    System.out.println("Writing success to " + file.getAbsolutePath());
-                    Files.write(file.getAbsoluteFile().toPath(), "Success!".getBytes());
-                } catch (IOException e) {
-                    e.printStackTrace();
-                }
                 mc.shutdown();
-                mc.shutdownMinecraftApplet();
-                System.exit(0);
             }
 
             // If we have exceeded the expected number of ticks to complete the pathing

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

@@ -54,7 +54,7 @@ public final class BlockBreakHelper implements Helper {
 
     public void tick(boolean isLeftClick) {
         RayTraceResult trace = playerContext.objectMouseOver();
-        boolean isBlockTrace = trace != null && trace.type == RayTraceResult.Type.BLOCK;
+        boolean isBlockTrace = trace != null && trace.typeOfHit == RayTraceResult.Type.BLOCK;
 
         if (isLeftClick && isBlockTrace) {
             tryBreakBlock(trace.getBlockPos(), trace.sideHit);

src/main/java/baritone/utils/BlockPlaceHelper.java

@@ -38,7 +38,7 @@ public class BlockPlaceHelper implements Helper {
             return;
         }
         RayTraceResult mouseOver = ctx.objectMouseOver();
-        if (!rightClickRequested || ctx.player().isRowingBoat() || mouseOver == null || mouseOver.getBlockPos() == null || mouseOver.type != RayTraceResult.Type.BLOCK) {
+        if (!rightClickRequested || ctx.player().isRowingBoat() || mouseOver == null || mouseOver.getBlockPos() == null || mouseOver.typeOfHit != RayTraceResult.Type.BLOCK) {
             return;
         }
         rightClickTimer = Baritone.settings().rightClickSpeed.value;

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

@@ -67,7 +67,7 @@ public class BlockStateInterface {
             this.loadedChunks = worldLoaded; // this will only be used on the main thread
         }
         this.useTheRealWorld = !Baritone.settings().pathThroughCachedOnly.value;
-        if (!Minecraft.getInstance().isCallingFromMinecraftThread()) {
+        if (!Minecraft.getMinecraft().isCallingFromMinecraftThread()) {
             throw new IllegalStateException();
         }
     }

src/main/java/baritone/utils/GuiClick.java

@@ -25,9 +25,13 @@ import baritone.api.utils.BetterBlockPos;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.math.*;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
 import org.lwjgl.BufferUtils;
-import org.lwjgl.opengl.GL11;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.util.glu.GLU;
 
 import java.awt.*;
 import java.nio.FloatBuffer;
@@ -53,25 +57,22 @@ public class GuiClick extends GuiScreen {
     }
 
     @Override
-    public void render(int mouseX, int mouseY, float partialTicks) {
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
-        double mx = mc.mouseHelper.getMouseX();
+        int mx = Mouse.getX();
-        double my = mc.mouseHelper.getMouseY();
+        int my = Mouse.getY();
-        my = mc.mainWindow.getHeight() - my;
-        my *= mc.mainWindow.getFramebufferHeight() / (double) mc.mainWindow.getHeight();
-        mx *= mc.mainWindow.getFramebufferWidth() / (double) mc.mainWindow.getWidth();
         Vec3d near = toWorld(mx, my, 0);
         Vec3d far = toWorld(mx, my, 1); // "Use 0.945 that's what stack overflow says" - leijurv
         if (near != null && far != null) {
             Vec3d viewerPos = new Vec3d(mc.getRenderManager().viewerPosX, mc.getRenderManager().viewerPosY, mc.getRenderManager().viewerPosZ);
-            RayTraceResult result = mc.world.rayTraceBlocks(near.add(viewerPos), far.add(viewerPos), RayTraceFluidMode.NEVER, false, true);
+            RayTraceResult result = mc.world.rayTraceBlocks(near.add(viewerPos), far.add(viewerPos), false, false, true);
-            if (result != null && result.type == RayTraceResult.Type.BLOCK) {
+            if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
                 currentMouseOver = result.getBlockPos();
             }
         }
     }
 
     @Override
-    public boolean mouseReleased(double mouseX, double mouseY, int mouseButton) {
+    protected void mouseReleased(int mouseX, int mouseY, int mouseButton) {
         if (mouseButton == 0) {
             if (clickStart != null && !clickStart.equals(currentMouseOver)) {
                 ((Baritone) BaritoneAPI.getProvider().getPrimaryBaritone()).getBuilderProcess().clearArea(clickStart, currentMouseOver);
@@ -83,19 +84,17 @@ public class GuiClick extends GuiScreen {
             BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAndPath(new GoalBlock(currentMouseOver.up()));
         }
         clickStart = null;
-        return super.mouseReleased(mouseX, mouseY, mouseButton);
     }
 
     @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) {
         clickStart = currentMouseOver;
-        return super.mouseClicked(mouseX, mouseY, mouseButton);
     }
 
     public void onRender() {
-        GlStateManager.getFloatv(GL_MODELVIEW_MATRIX, (FloatBuffer) MODELVIEW.clear());
+        GlStateManager.getFloat(GL_MODELVIEW_MATRIX, (FloatBuffer) MODELVIEW.clear());
-        GlStateManager.getFloatv(GL_PROJECTION_MATRIX, (FloatBuffer) PROJECTION.clear());
+        GlStateManager.getFloat(GL_PROJECTION_MATRIX, (FloatBuffer) PROJECTION.clear());
-        GL11.glGetIntegerv(GL_VIEWPORT, (IntBuffer) VIEWPORT.clear());
+        GlStateManager.glGetInteger(GL_VIEWPORT, (IntBuffer) VIEWPORT.clear());
 
         if (currentMouseOver != null) {
             Entity e = mc.getRenderViewEntity();
@@ -103,16 +102,16 @@ public class GuiClick extends GuiScreen {
             PathRenderer.drawManySelectionBoxes(e, Collections.singletonList(currentMouseOver), Color.CYAN);
             if (clickStart != null && !clickStart.equals(currentMouseOver)) {
                 GlStateManager.enableBlend();
-                GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+                GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-                GlStateManager.color4f(Color.RED.getColorComponents(null)[0], Color.RED.getColorComponents(null)[1], Color.RED.getColorComponents(null)[2], 0.4F);
+                GlStateManager.color(Color.RED.getColorComponents(null)[0], Color.RED.getColorComponents(null)[1], Color.RED.getColorComponents(null)[2], 0.4F);
-                GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+                GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
                 GlStateManager.disableTexture2D();
                 GlStateManager.depthMask(false);
-                GlStateManager.disableDepthTest();
+                GlStateManager.disableDepth();
                 BetterBlockPos a = new BetterBlockPos(currentMouseOver);
                 BetterBlockPos b = new BetterBlockPos(clickStart);
                 PathRenderer.drawAABB(new AxisAlignedBB(Math.min(a.x, b.x), Math.min(a.y, b.y), Math.min(a.z, b.z), Math.max(a.x, b.x) + 1, Math.max(a.y, b.y) + 1, Math.max(a.z, b.z) + 1));
-                GlStateManager.enableDepthTest();
+                GlStateManager.enableDepth();
 
                 GlStateManager.depthMask(true);
                 GlStateManager.enableTexture2D();
@@ -122,194 +121,10 @@ public class GuiClick extends GuiScreen {
     }
 
     private Vec3d toWorld(double x, double y, double z) {
-        boolean result = gluUnProject((float) x, (float) y, (float) z, MODELVIEW, PROJECTION, VIEWPORT, (FloatBuffer) TO_WORLD_BUFFER.clear());
+        boolean result = GLU.gluUnProject((float) x, (float) y, (float) z, MODELVIEW, PROJECTION, VIEWPORT, (FloatBuffer) TO_WORLD_BUFFER.clear());
         if (result) {
             return new Vec3d(TO_WORLD_BUFFER.get(0), TO_WORLD_BUFFER.get(1), TO_WORLD_BUFFER.get(2));
         }
         return null;
     }
-
-    // skidded from lwjgl2 :ok_hand:
-    // its uhhhhh mit license so its ok
-    // here is the uhh license
-    /*
-     * Copyright (c) 2002-2007 Lightweight Java Game Library Project
-     * All rights reserved.
-     *
-     * Redistribution and use in source and binary forms, with or without
-     * modification, are permitted provided that the following conditions are
-     * met:
-     *
-     * * Redistributions of source code must retain the above copyright
-     *   notice, this list of conditions and the following disclaimer.
-     *
-     * * Redistributions in binary form must reproduce the above copyright
-     *   notice, this list of conditions and the following disclaimer in the
-     *   documentation and/or other materials provided with the distribution.
-     *
-     * * Neither the name of 'Light Weight Java Game Library' nor the names of
-     *   its contributors may be used to endorse or promote products derived
-     *   from this software without specific prior written permission.
-     *
-     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-     * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-     * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-     * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-     * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-     * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-     * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-     * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-     * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-     */
-
-    public static boolean gluUnProject(
-            float winx,
-            float winy,
-            float winz,
-            FloatBuffer modelMatrix,
-            FloatBuffer projMatrix,
-            IntBuffer viewport,
-            FloatBuffer obj_pos) {
-        FloatBuffer finalMatrix = BufferUtils.createFloatBuffer(16);
-        float[] in = new float[4];
-        float[] out = new float[4];
-
-        __gluMultMatricesf(modelMatrix, projMatrix, finalMatrix);
-
-        if (!__gluInvertMatrixf(finalMatrix, finalMatrix))
-            return false;
-
-        in[0] = winx;
-        in[1] = winy;
-        in[2] = winz;
-        in[3] = 1.0f;
-
-        // Map x and y from window coordinates
-        in[0] = (in[0] - viewport.get(viewport.position() + 0)) / viewport.get(viewport.position() + 2);
-        in[1] = (in[1] - viewport.get(viewport.position() + 1)) / viewport.get(viewport.position() + 3);
-
-        // Map to range -1 to 1
-        in[0] = in[0] * 2 - 1;
-        in[1] = in[1] * 2 - 1;
-        in[2] = in[2] * 2 - 1;
-
-        __gluMultMatrixVecf(finalMatrix, in, out);
-
-        if (out[3] == 0.0)
-            return false;
-
-        out[3] = 1.0f / out[3];
-
-        obj_pos.put(obj_pos.position() + 0, out[0] * out[3]);
-        obj_pos.put(obj_pos.position() + 1, out[1] * out[3]);
-        obj_pos.put(obj_pos.position() + 2, out[2] * out[3]);
-
-        return true;
-    }
-
-    private static void __gluMultMatrixVecf(FloatBuffer m, float[] in, float[] out) {
-        for (int i = 0; i < 4; i++) {
-            out[i] =
-                    in[0] * m.get(m.position() + 0 * 4 + i)
-                            + in[1] * m.get(m.position() + 1 * 4 + i)
-                            + in[2] * m.get(m.position() + 2 * 4 + i)
-                            + in[3] * m.get(m.position() + 3 * 4 + i);
-
-        }
-    }
-
-    private static void __gluMultMatricesf(FloatBuffer a, FloatBuffer b, FloatBuffer r) {
-        for (int i = 0; i < 4; i++) {
-            for (int j = 0; j < 4; j++) {
-                r.put(r.position() + i * 4 + j,
-                        a.get(a.position() + i * 4 + 0) * b.get(b.position() + 0 * 4 + j) + a.get(a.position() + i * 4 + 1) * b.get(b.position() + 1 * 4 + j) + a.get(a.position() + i * 4 + 2) * b.get(b.position() + 2 * 4 + j) + a.get(a.position() + i * 4 + 3) * b.get(b.position() + 3 * 4 + j));
-            }
-        }
-    }
-
-    private static boolean __gluInvertMatrixf(FloatBuffer src, FloatBuffer inverse) {
-        int i, j, k, swap;
-        float t;
-        FloatBuffer temp = BufferUtils.createFloatBuffer(16);
-
-
-        for (i = 0; i < 16; i++) {
-            temp.put(i, src.get(i + src.position()));
-        }
-        __gluMakeIdentityf(inverse);
-
-        for (i = 0; i < 4; i++) {
-            /*
-             * * Look for largest element in column
-             */
-            swap = i;
-            for (j = i + 1; j < 4; j++) {
-                /*
-                 * if (fabs(temp[j][i]) > fabs(temp[i][i])) { swap = j;
-                 */
-                if (Math.abs(temp.get(j * 4 + i)) > Math.abs(temp.get(i * 4 + i))) {
-                    swap = j;
-                }
-            }
-
-            if (swap != i) {
-                /*
-                 * * Swap rows.
-                 */
-                for (k = 0; k < 4; k++) {
-                    t = temp.get(i * 4 + k);
-                    temp.put(i * 4 + k, temp.get(swap * 4 + k));
-                    temp.put(swap * 4 + k, t);
-
-                    t = inverse.get(i * 4 + k);
-                    inverse.put(i * 4 + k, inverse.get(swap * 4 + k));
-                    //inverse.put((i << 2) + k, inverse.get((swap << 2) + k));
-                    inverse.put(swap * 4 + k, t);
-                    //inverse.put((swap << 2) + k, t);
-                }
-            }
-
-            if (temp.get(i * 4 + i) == 0) {
-                /*
-                 * * No non-zero pivot. The matrix is singular, which shouldn't *
-                 * happen. This means the user gave us a bad matrix.
-                 */
-                return false;
-            }
-
-            t = temp.get(i * 4 + i);
-            for (k = 0; k < 4; k++) {
-                temp.put(i * 4 + k, temp.get(i * 4 + k) / t);
-                inverse.put(i * 4 + k, inverse.get(i * 4 + k) / t);
-            }
-            for (j = 0; j < 4; j++) {
-                if (j != i) {
-                    t = temp.get(j * 4 + i);
-                    for (k = 0; k < 4; k++) {
-                        temp.put(j * 4 + k, temp.get(j * 4 + k) - temp.get(i * 4 + k) * t);
-                        inverse.put(j * 4 + k, inverse.get(j * 4 + k) - inverse.get(i * 4 + k) * t);
-						/*inverse.put(
-							(j << 2) + k,
-							inverse.get((j << 2) + k) - inverse.get((i << 2) + k) * t);*/
-                    }
-                }
-            }
-        }
-        return true;
-    }
-
-    private static final float[] IDENTITY_MATRIX =
-            new float[]{
-                    1.0f, 0.0f, 0.0f, 0.0f,
-                    0.0f, 1.0f, 0.0f, 0.0f,
-                    0.0f, 0.0f, 1.0f, 0.0f,
-                    0.0f, 0.0f, 0.0f, 1.0f};
-
-    private static void __gluMakeIdentityf(FloatBuffer m) {
-        int oldPos = m.position();
-        m.put(IDENTITY_MATRIX);
-        m.position(oldPos);
-    }
 }

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

@@ -100,7 +100,7 @@ public final class InputOverrideHandler extends Behavior implements IInputOverri
             }
         } else {
             if (ctx.player().movementInput.getClass() == PlayerMovementInput.class) { // allow other movement inputs that aren't this one, e.g. for a freecam
-                ctx.player().movementInput = new MovementInputFromOptions(Minecraft.getInstance().gameSettings);
+                ctx.player().movementInput = new MovementInputFromOptions(Minecraft.getMinecraft().gameSettings);
             }
         }
         // only set it if it was previously incorrect

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

@@ -34,12 +34,10 @@ import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.tileentity.TileEntityBeaconRenderer;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.ResourceLocation;
+import net.minecraft.init.Blocks;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.shapes.VoxelShape;
-import net.minecraft.util.math.shapes.VoxelShapes;
 
 import java.awt.*;
 import java.util.Collection;
@@ -54,7 +52,6 @@ import static org.lwjgl.opengl.GL11.*;
  */
 public final class PathRenderer implements Helper {
 
-    private static final ResourceLocation TEXTURE_BEACON_BEAM = new ResourceLocation("textures/entity/beacon_beam.png");
     private static final Tessellator TESSELLATOR = Tessellator.getInstance();
     private static final BufferBuilder BUFFER = TESSELLATOR.getBuffer();
 
@@ -67,8 +64,8 @@ public final class PathRenderer implements Helper {
             ((GuiClick) mc.currentScreen).onRender();
         }
 
-        int thisPlayerDimension = behavior.baritone.getPlayerContext().world().getDimension().getType().getId();
+        int thisPlayerDimension = behavior.baritone.getPlayerContext().world().provider.getDimensionType().getId();
-        int currentRenderViewDimension = BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext().world().getDimension().getType().getId();
+        int currentRenderViewDimension = BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext().world().provider.getDimensionType().getId();
 
         if (thisPlayerDimension != currentRenderViewDimension) {
             // this is a path for a bot in a different dimension, don't render it
@@ -125,13 +122,14 @@ public final class PathRenderer implements Helper {
 
     public static void drawPath(IPath path, int startIndex, Entity player, float partialTicks, Color color, boolean fadeOut, int fadeStart0, int fadeEnd0) {
         GlStateManager.enableBlend();
-        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.disableLighting();
-        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
+        GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-        GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
+        GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
         if (Baritone.settings().renderPathIgnoreDepth.value) {
-            GlStateManager.disableDepthTest();
+            GlStateManager.disableDepth();
         }
         List<BetterBlockPos> positions = path.positions();
         int next;
@@ -168,17 +166,18 @@ public final class PathRenderer implements Helper {
                     }
                     alpha = 0.4F * (1.0F - (float) (i - fadeStart) / (float) (fadeEnd - fadeStart));
                 }
-                GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], alpha);
+                GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], alpha);
             }
             drawLine(x1, y1, z1, x2, y2, z2);
             tessellator.draw();
         }
         if (Baritone.settings().renderPathIgnoreDepth.value) {
-            GlStateManager.enableDepthTest();
+            GlStateManager.enableDepth();
         }
         //GlStateManager.color(0.0f, 0.0f, 0.0f, 0.4f);
         GlStateManager.depthMask(true);
         GlStateManager.enableTexture2D();
+        GlStateManager.enableLighting();
         GlStateManager.disableBlend();
     }
 
@@ -196,14 +195,14 @@ public final class PathRenderer implements Helper {
 
     public static void drawManySelectionBoxes(Entity player, Collection<BlockPos> positions, Color color) {
         GlStateManager.enableBlend();
-        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
-        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
+        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
-        GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+        GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
 
         if (Baritone.settings().renderSelectionBoxesIgnoreDepth.value) {
-            GlStateManager.disableDepthTest();
+            GlStateManager.disableDepth();
         }
 
 
@@ -211,14 +210,17 @@ public final class PathRenderer implements Helper {
         BlockStateInterface bsi = new BlockStateInterface(BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext()); // TODO this assumes same dimension between primary baritone and render view? is this safe?
         positions.forEach(pos -> {
             IBlockState state = bsi.get0(pos);
-            VoxelShape shape = state.getShape(player.world, pos);
+            AxisAlignedBB toDraw;
-            AxisAlignedBB toDraw = shape.isEmpty() ? VoxelShapes.fullCube().getBoundingBox() : shape.getBoundingBox();
+            if (state.getBlock().equals(Blocks.AIR)) {
-            toDraw = toDraw.offset(pos);
+                toDraw = Blocks.DIRT.getDefaultState().getSelectedBoundingBox(player.world, pos);
+            } else {
+                toDraw = state.getSelectedBoundingBox(player.world, pos);
+            }
             drawAABB(toDraw);
         });
 
         if (Baritone.settings().renderSelectionBoxesIgnoreDepth.value) {
-            GlStateManager.enableDepthTest();
+            GlStateManager.enableDepth();
         }
 
         GlStateManager.depthMask(true);
@@ -292,10 +294,10 @@ public final class PathRenderer implements Helper {
             if (Baritone.settings().renderGoalXZBeacon.value) {
                 glPushAttrib(GL_LIGHTING_BIT);
 
-                mc.getTextureManager().bindTexture(TEXTURE_BEACON_BEAM);
+                mc.getTextureManager().bindTexture(TileEntityBeaconRenderer.TEXTURE_BEACON_BEAM);
 
                 if (Baritone.settings().renderGoalIgnoreDepth.value) {
-                    GlStateManager.disableDepthTest();
+                    GlStateManager.disableDepth();
                 }
 
                 TileEntityBeaconRenderer.renderBeamSegment(
@@ -304,18 +306,14 @@ public final class PathRenderer implements Helper {
                         goalPos.getZ() - renderPosZ,
                         partialTicks,
                         1.0,
-                        player.world.getGameTime(),
+                        player.world.getTotalWorldTime(),
                         0,
                         256,
-                        color.getColorComponents(null),
+                        color.getColorComponents(null)
-
-                        // Arguments filled by the private method lol
-                        0.2D,
-                        0.25D
                 );
 
                 if (Baritone.settings().renderGoalIgnoreDepth.value) {
-                    GlStateManager.enableDepthTest();
+                    GlStateManager.enableDepth();
                 }
 
                 glPopAttrib();
@@ -351,13 +349,13 @@ public final class PathRenderer implements Helper {
         }
 
         GlStateManager.enableBlend();
-        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
-        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.6F);
+        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.6F);
-        GlStateManager.lineWidth(Baritone.settings().goalRenderLineWidthPixels.value);
+        GlStateManager.glLineWidth(Baritone.settings().goalRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
         if (Baritone.settings().renderGoalIgnoreDepth.value) {
-            GlStateManager.disableDepthTest();
+            GlStateManager.disableDepth();
         }
 
         renderHorizontalQuad(minX, maxX, minZ, maxZ, y1);
@@ -375,7 +373,7 @@ public final class PathRenderer implements Helper {
         TESSELLATOR.draw();
 
         if (Baritone.settings().renderGoalIgnoreDepth.value) {
-            GlStateManager.enableDepthTest();
+            GlStateManager.enableDepth();
         }
         GlStateManager.depthMask(true);
         GlStateManager.enableTexture2D();

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

@@ -24,6 +24,7 @@ import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.enchantment.EnchantmentHelper;
 import net.minecraft.init.Enchantments;
 import net.minecraft.init.MobEffects;
+import net.minecraft.item.Item.ToolMaterial;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemTool;
 
@@ -74,13 +75,19 @@ public class ToolSet {
     }
 
     /**
-     * Evaluate the material cost of a possible tool. Will return 1 for tools, -1 for other
+     * Evaluate the material cost of a possible tool. The priority matches the
+     * listed order in the Item.ToolMaterial enum.
      *
      * @param itemStack a possibly empty ItemStack
-     * @return Either 1 or -1
+     * @return values range from -1 to 4
      */
     private int getMaterialCost(ItemStack itemStack) {
-        return itemStack.getItem() instanceof ItemTool ? 1 : -1;
+        if (itemStack.getItem() instanceof ItemTool) {
+            ItemTool tool = (ItemTool) itemStack.getItem();
+            return ToolMaterial.valueOf(tool.getToolMaterialName()).ordinal();
+        } else {
+            return -1;
+        }
     }
 
     /**

src/main/java/baritone/utils/accessor/IChunkProviderServer.java

@@ -17,10 +17,12 @@
 
 package baritone.utils.accessor;
 
+import net.minecraft.world.WorldProvider;
 import net.minecraft.world.chunk.storage.IChunkLoader;
 
 /**
  * @author Brady
+ * @see WorldProvider
  * @since 8/4/2018
  */
 public interface IChunkProviderServer {

src/main/java/baritone/utils/schematic/MapArtSchematic.java

@@ -36,7 +36,7 @@ public class MapArtSchematic extends Schematic {
             for (int z = 0; z < lengthZ; z++) {
                 IBlockState[] column = states[x][z];
 
-                OptionalInt lowestBlockY = lastIndexMatching(column, block -> !(block instanceof BlockAir));
+                OptionalInt lowestBlockY = lastIndexMatching(column, state -> !(state.getBlock() instanceof BlockAir));
                 if (lowestBlockY.isPresent()) {
                     heightMap[x][z] = lowestBlockY.getAsInt();
                 } else {

src/main/java/baritone/utils/schematic/Schematic.java

@@ -18,6 +18,7 @@
 package baritone.utils.schematic;
 
 import baritone.api.utils.ISchematic;
+import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.nbt.NBTTagCompound;
 
@@ -28,7 +29,7 @@ public class Schematic implements ISchematic {
     protected final IBlockState[][][] states;
 
     public Schematic(NBTTagCompound schematic) {
-        /*String type = schematic.getString("Materials");
+        String type = schematic.getString("Materials");
         if (!type.equals("Alpha")) {
             throw new IllegalStateException("bad schematic " + type);
         }
@@ -63,8 +64,7 @@ public class Schematic implements ISchematic {
                     states[x][z][y] = block.getStateFromMeta(meta);
                 }
             }
-        }*/
+        }
-        throw new UnsupportedOperationException("1.13 be like: numeric IDs btfo");
     }
 
     @Override