v1.3.1

use runAutoTest

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1 @@
+<!-- No UwU's or OwO's allowed -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1 @@
+<!-- No UwU's or OwO's allowed -->

.gitignore

@@ -11,6 +11,8 @@ build/
 classes/
 *.class
 
+/out
+
 # IntelliJ Files
 .idea/
 *.iml
@@ -18,4 +20,4 @@ classes/
 
 # Copyright Files
 !/.idea/copyright/Baritone.xml
-!/.idea/copyright/profiles_settings.xml
+!/.idea/copyright/profiles_settings.xml

.travis.yml

@@ -10,7 +10,7 @@ install:
 
 script:
 - docker run --rm cabaletta/baritone ./gradlew javadoc
-- 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 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 cp baritone:/code/dist dist
 - ls dist
 - cat dist/checksums.txt

CODE_OF_CONDUCT.md

@@ -45,6 +45,11 @@ that are not aligned to this Code of Conduct, or to ban temporarily or
 permanently any contributor for other behaviors that they deem inappropriate,
 threatening, offensive, or harmful.
 
+Project maintainers have the right and responsibility to immediately remove
+without any sort of dispute any issues or pull requests that do not align
+with their corresponding templates. Absolutely no leniancy shall be accepted
+with these terms.
+
 ## Scope
 
 This Code of Conduct applies both within project spaces and in public spaces

Dockerfile

@@ -1,17 +1,16 @@
-FROM debian:jessie
+FROM debian:stretch
 
-RUN echo 'deb http://deb.debian.org/debian jessie-backports main' > /etc/apt/sources.list.d/jessie-backports.list
+RUN echo 'deb http://deb.debian.org/debian stretch-backports main' > /etc/apt/sources.list.d/stretch-backports.list
 
 ENV DEBIAN_FRONTEND noninteractive
 
 RUN apt update -y
 
-RUN apt install --target-release jessie-backports \
+RUN apt install \
           openjdk-8-jdk \
-          ca-certificates-java \
           --assume-yes
 
-RUN apt install -qq --force-yes mesa-utils libgl1-mesa-glx libxcursor1 libxrandr2 libxxf86vm1 x11-xserver-utils xfonts-base xserver-common
+RUN apt install -qq --assume-yes mesa-utils libgl1-mesa-glx libxcursor1 libxrandr2 libxxf86vm1 x11-xserver-utils xfonts-base xserver-common
 
 COPY . /code
 
@@ -21,4 +20,4 @@ WORKDIR /code
 # source: https://github.com/tectonicus/tectonicus/issues/60#issuecomment-154239173
 RUN dpkg -i scripts/xvfb_1.16.4-1_amd64.deb
 
-RUN ./gradlew build
+RUN ./gradlew build

README.md

@@ -13,15 +13,16 @@
 ![Code size](https://img.shields.io/github/languages/code-size/cabaletta/baritone.svg)
 ![GitHub repo size](https://img.shields.io/github/repo-size/cabaletta/baritone.svg)
 ![](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
-![](https://tokei.rs/b1/github/cabaletta/baritone?category=files)
-[![Minecraft](https://img.shields.io/badge/MC-1.12.2-green.svg)](https://minecraft.gamepedia.com/1.12.2)
+[![Minecraft](https://img.shields.io/badge/MC-1.13.2-brightgreen.svg)](https://minecraft.gamepedia.com/1.13.2)
 [![GitHub contributors](https://img.shields.io/github/contributors/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/graphs/contributors/)
 [![GitHub commits](https://img.shields.io/github/commits-since/cabaletta/baritone/v1.0.0.svg)](https://github.com/cabaletta/baritone/commit/)
-[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.3-brightgreen.svg)](https://impactdevelopment.github.io/)
+[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.5%20/%20v1.3.0-brightgreen.svg)](https://impactdevelopment.github.io/)
 [![WWE integration](https://img.shields.io/badge/WWE%20%22integration%22-master%3F-green.svg)](https://wweclient.com/)
 [![KAMI integration](https://img.shields.io/badge/KAMI%20integration-v1.0.0-red.svg)](https://github.com/zeroeightysix/KAMI/)
 [![Future integration](https://img.shields.io/badge/Future%20integration-Soon™%3F%3F%3F-red.svg)](https://futureclient.net/)
 [![ForgeHax integration](https://img.shields.io/badge/ForgeHax%20integration-Soon™-red.svg)](https://github.com/fr1kin/ForgeHax)
+[![forthebadge](https://forthebadge.com/images/badges/built-with-swag.svg)](http://forthebadge.com)
+[![forthebadge](https://forthebadge.com/images/badges/mom-made-pizza-rolls.svg)](http://forthebadge.com)
 
 A Minecraft pathfinder bot. 
 
@@ -30,7 +31,7 @@ Baritone is the pathfinding system used in [Impact](https://impactdevelopment.gi
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8.9, rebuilt for 1.12.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
 
-Have committed at least once a day for the last 7 months =D 🦀
+Have committed at least once a day for the last 8 months =D 🦀
 
 1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2
 

SETUP.md

@@ -1,7 +1,7 @@
 # Installation
 
 ## Prebuilt official releases
-These releases are not always completely up to date with latest features, and are only released from `master`. (so if you want `builder` branch for example, you'll have to build it yourself)
+These releases are not always completely up to date with latest features, and are only released from `master`. (so if you want `backfill-2` branch for example, you'll have to build it yourself)
 
 Link to the releases page: [Releases](https://github.com/cabaletta/baritone/releases)
 

USAGE.md

@@ -34,7 +34,7 @@ Some common examples:
 - `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.)
-- `click` to click your destination on the screen. left click to path into it, right click to path on top of it.
+- `click` to click your destination on the screen. left click to path into it, right click to path on top of it. left click and drag to clear an area.
 - `follow playerName` to follow a player. `follow` to follow the entity you're looking at (only works if it hitting range). `followplayers` to follow any players in range (combine with Kill Aura for a fun time).
 - `save waypointName` to save a waypoint. `goto waypointName` to go to it.
 - `axis` to go to an axis or diagonal axis at y=120 (`axisHeight` is a configurable setting, defaults to 120).
@@ -42,6 +42,7 @@ Some common examples:
 - `render` to rerender the world in case `renderCachedChunks` is being glitchy
 - `version` to get the version of Baritone you're running
 - `damn` daniel
+- `build` to build a schematic. `build blah` will load `schematics/blah.schematic` and build it with the origin being your player feet. `build blah x y z` to set the origin. Any of those can be relative to your player (`~ 69 ~-420` would build at x=player x, y=69, z=player z-420).
 
 For the rest of the commands, you can take a look at the code [here](https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java).
 

build.gradle

@@ -16,33 +16,33 @@
  */
 
 group 'baritone'
-version '1.2.5'
+version '1.3.1'
 
 buildscript {
     repositories {
+        jcenter()
         maven {
             name = 'forge'
             url = 'http://files.minecraftforge.net/maven'
         }
         maven {
-            name = 'SpongePowered'
-            url = 'http://repo.spongepowered.org/maven'
+            name = 'impactdevelopment-repo'
+            url = 'https://impactdevelopment.github.io/maven/'
         }
-        jcenter()
     }
 
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
-        classpath 'org.spongepowered:mixingradle:0.6-SNAPSHOT'
+        classpath group: 'com.github.ImpactDevelopment', name: 'ForgeGradle', version: '3.0.115'
+        classpath group: 'com.github.ImpactDevelopment', name: 'MixinGradle', version: '0.6.2'
     }
 }
 
-
 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.tweaker-client'
+apply plugin: 'net.minecraftforge.gradle'
 apply plugin: 'org.spongepowered.mixin'
 
 sourceCompatibility = targetCompatibility = '1.8'
@@ -52,19 +52,67 @@ 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
     }
 }
 
-minecraft {
-    version = '1.12.2'
-    mappings = 'stable_39'
-    tweakClass = 'baritone.launch.BaritoneTweaker'
-    runDir = 'run'
+task sourceJar(type: Jar, dependsOn: classes) {
+    classifier = 'sources'
+    from sourceSets.api.allSource
+}
 
-    // The sources jar should use SRG names not MCP to ensure compatibility with all mappings
-    makeObfSourceJar = true
+minecraft {
+    mappings channel: 'snapshot', version: '20190307-1.13.1'
+    reobfMappings 'notch'
+
+    runs {
+        client {
+            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 {
@@ -82,6 +130,12 @@ 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
@@ -91,6 +145,7 @@ dependencies {
         exclude module: 'commons-io'
         exclude module: 'log4j-core'
     }
+
     testImplementation 'junit:junit:4.12'
 }
 

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

@@ -40,17 +40,13 @@ 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_FORGE_API        = "%s-api-forge-%s.jar",
-            ARTIFACT_FORGE_STANDALONE = "%s-standalone-forge-%s.jar";
+            ARTIFACT_STANDALONE       = "%s-standalone-%s.jar";
 
     protected String artifactName, artifactVersion;
-    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, artifactForgeApiPath, artifactForgeStandalonePath, proguardOut;
+    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, proguardOut;
 
     protected void verifyArtifacts() throws IllegalStateException {
         this.artifactName = getProject().getName();
@@ -60,8 +56,6 @@ 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,8 +45,6 @@ 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/");
@@ -58,11 +56,9 @@ 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, forgeApi, standalone, forgeStandalone, unoptimized)
+        List<String> shasum = Stream.of(api, standalone, unoptimized)
                 .map(path -> sha1(path) + "  " + path.getFileName().toString())
                 .collect(Collectors.toList());
 

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

@@ -18,26 +18,18 @@
 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.NamedDomainObjectContainer;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.internal.plugins.DefaultConvention;
+import org.gradle.api.plugins.JavaPluginConvention;
 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.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -49,18 +41,12 @@ 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();
@@ -70,7 +56,6 @@ public class ProguardTask extends BaritoneGradleTask {
         downloadProguard();
         extractProguard();
         generateConfigs();
-        acquireDependencies();
         proguardApi();
         proguardStandalone();
         cleanup();
@@ -81,7 +66,7 @@ public class ProguardTask extends BaritoneGradleTask {
             Files.delete(this.artifactUnoptimizedPath);
         }
 
-        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString(), Optional.empty());
+        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString());
     }
 
     private void downloadProguard() throws Exception {
@@ -114,6 +99,19 @@ 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);
 
@@ -121,165 +119,20 @@ 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 void acquireDependencies() throws Exception {
-
-        // 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 Stream<File> acquireDependencies() {
+        return getProject().getConvention().getPlugin(JavaPluginConvention.class).getSourceSets().findByName("launch").getRuntimeClasspath().getFiles().stream().filter(File::isFile);
     }
 
     private void proguardApi() throws Exception {
         runProguard(getTemporaryFile(PROGUARD_API_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString(), Optional.empty());
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeApiPath.toString(), Optional.of(mixin));
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString());
     }
 
     private void proguardStandalone() throws Exception {
         runProguard(getTemporaryFile(PROGUARD_STANDALONE_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString(), Optional.empty());
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeStandalonePath.toString(), Optional.of(mixin));
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString());
     }
 
     private void cleanup() {

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

@@ -22,7 +22,10 @@ import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 
 import java.io.*;
-import java.util.*;
+import java.util.ArrayList;
+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;
@@ -36,7 +39,7 @@ import java.util.stream.Collectors;
  */
 public class Determinizer {
 
-    public static void determinize(String inputPath, String outputPath, Optional<File> toInclude) throws IOException {
+    public static void determinize(String inputPath, String outputPath) throws IOException {
         System.out.println("Running Determinizer");
         System.out.println(" Input path: " + inputPath);
         System.out.println(" Output path: " + outputPath);
@@ -63,30 +66,10 @@ 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

@@ -1,29 +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.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

@@ -1,63 +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.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,6 +14,8 @@
 
 # lwjgl is weird
 -dontwarn org.lwjgl.**
+# also lwjgl lol
+-dontwarn module-info
 
 -keep class baritone.api.** { *; } # this is the keep api
 
@@ -29,56 +31,6 @@
 # need to keep mixin names
 -keep class baritone.launch.** { *; }
 
-# 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.
 -keepclasseswithmembers public class * {

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

@@ -21,6 +21,7 @@ import baritone.api.utils.SettingsUtil;
 import net.minecraft.client.Minecraft;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.text.ITextComponent;
 
 import java.awt.*;
@@ -58,7 +59,9 @@ public final class Settings {
 
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
-     * because we want to generally conserve blocks which might be limited
+     * because we want to generally conserve blocks which might be limited.
+     * <p>
+     * Decrease to make Baritone more often consider paths that would require placing blocks
      */
     public final Setting<Double> blockPlacementPenalty = new Setting<>(20D);
 
@@ -91,6 +94,11 @@ public final class Settings {
      */
     public final Setting<Boolean> assumeWalkOnWater = new Setting<>(false);
 
+    /**
+     * If you have Fire Resistance and Jesus then I guess you could turn this on lol
+     */
+    public final Setting<Boolean> assumeWalkOnLava = new Setting<>(false);
+
     /**
      * Assume step functionality; don't jump on an Ascend.
      */
@@ -108,7 +116,7 @@ public final class Settings {
     /**
      * If true, parkour is allowed to make jumps when standing on blocks at the maximum height, so player feet is y=256
      * <p>
-     * Defaults to false because this fails on constantiam
+     * Defaults to false because this fails on constantiam. Please let me know if this is ever disabled. Please.
      */
     public final Setting<Boolean> allowJumpAt256 = new Setting<>(false);
 
@@ -121,13 +129,20 @@ public final class Settings {
      */
     public final Setting<Boolean> allowDiagonalDescend = new Setting<>(false);
 
+    /**
+     * Allow mining the block directly beneath its feet
+     * <p>
+     * Turn this off to force it to make more staircases and less shafts
+     */
+    public final Setting<Boolean> allowDownward = new Setting<>(true);
+
     /**
      * 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(
-            Item.getItemFromBlock(Blocks.DIRT),
-            Item.getItemFromBlock(Blocks.COBBLESTONE),
-            Item.getItemFromBlock(Blocks.NETHERRACK)
+            Blocks.DIRT.asItem(),
+            Blocks.COBBLESTONE.asItem(),
+            Blocks.NETHERRACK.asItem()
     )));
 
     /**
@@ -424,6 +439,11 @@ public final class Settings {
      */
     public final Setting<Boolean> renderGoal = new Setting<>(true);
 
+    /**
+     * Render selection boxes
+     */
+    public final Setting<Boolean> renderSelectionBoxes = new Setting<>(true);
+
     /**
      * Ignore depth when rendering the goal
      */
@@ -547,6 +567,21 @@ public final class Settings {
      */
     public final Setting<Boolean> exploreForBlocks = new Setting<>(true);
 
+    /**
+     * Don't consider the next layer in builder until the current one is done
+     */
+    public final Setting<Boolean> buildInLayers = new Setting<>(false);
+
+    /**
+     * How far to move before repeating the build. -1 for the size of the build in that axis. 0 to disable
+     */
+    public final Setting<Integer> buildRepeatDistance=new Setting<>(0);
+
+    /**
+     * What direction te repeat the build in
+     */
+    public final Setting<EnumFacing> buildRepeatDirection = new Setting<>(EnumFacing.NORTH);
+
     /**
      * While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
      */
@@ -666,7 +701,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.getMinecraft().ingameGUI.getChatGUI()::printChatMessage);
+    public final Setting<Consumer<ITextComponent>> logger = new Setting<>(Minecraft.getInstance().ingameGUI.getChatGUI()::printChatMessage);
 
     /**
      * The color of the current path

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

@@ -18,12 +18,11 @@
 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;
 
@@ -45,7 +44,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#onUpdate()
+     * @see EntityPlayerSP#tick()
      */
     void onPlayerUpdate(PlayerUpdateEvent event);
 
@@ -61,14 +60,11 @@ 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. Two passes are made when {@link GameSettings#anaglyph} is on.
-     * <p>
-     * <b>Note:</b> {@link GameSettings#anaglyph} has been removed in Minecraft 1.13
+     * Runs once per world render pass.
      *
      * @param event The event
      */
@@ -78,7 +74,7 @@ public interface IGameEventListener {
      * Runs before and after whenever a new world is loaded
      *
      * @param event The event
-     * @see Minecraft#loadWorld(WorldClient, String)
+     * @see Minecraft#loadWorld(WorldClient, GuiScreen)
      */
     void onWorldEvent(WorldEvent event);
 
@@ -87,7 +83,6 @@ public interface IGameEventListener {
      *
      * @param event The event
      * @see Packet
-     * @see GenericFutureListener
      */
     void onSendPacket(PacketEvent event);
 
@@ -96,7 +91,6 @@ public interface IGameEventListener {
      *
      * @param event The event
      * @see Packet
-     * @see GenericFutureListener
      */
     void onReceivePacket(PacketEvent event);
 
@@ -110,10 +104,10 @@ public interface IGameEventListener {
     void onPlayerRotationMove(RotationMoveEvent event);
 
     /**
-     * Called whenever the sprint keybind state is checked in {@link EntityPlayerSP#onLivingUpdate}
+     * Called whenever the sprint keybind state is checked in {@link EntityPlayerSP#livingTick}
      *
      * @param event The event
-     * @see EntityPlayerSP#onLivingUpdate()
+     * @see EntityPlayerSP#livingTick()
      */
     void onPlayerSprintState(SprintStateEvent event);
 

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

@@ -61,6 +61,6 @@ public class GoalNear implements Goal, IGoalRenderPos {
                 ", y=" + y +
                 ", z=" + z +
                 ", rangeSq=" + rangeSq +
-                '}';
+                "}";
     }
 }

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

@@ -0,0 +1,76 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.pathing.goals;
+
+import baritone.api.BaritoneAPI;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * Dig a tunnel in a certain direction, but if you have to deviate from the path, go back to where you started
+ */
+public class GoalStrictDirection implements Goal {
+    public final int x;
+    public final int y;
+    public final int z;
+    public final int dx;
+    public final int dz;
+
+    public GoalStrictDirection(BlockPos origin, EnumFacing direction) {
+        x = origin.getX();
+        y = origin.getY();
+        z = origin.getZ();
+        dx = direction.getXOffset();
+        dz = direction.getZOffset();
+        if (dx == 0 && dz == 0) {
+            throw new IllegalArgumentException(direction + "");
+        }
+    }
+
+    @Override
+    public boolean isInGoal(int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public double heuristic(int x, int y, int z) {
+        int distanceFromStartInDesiredDirection = (x - this.x) * dx + (z - this.z) * dz;
+
+        int distanceFromStartInIncorrectDirection = Math.abs((x - this.x) * dz) + Math.abs((z - this.z) * dx);
+
+        int verticalDistanceFromStart = Math.abs(y - this.y);
+
+        // we want heuristic to decrease as desiredDirection increases
+        double heuristic = -distanceFromStartInDesiredDirection * 100;
+
+        heuristic += distanceFromStartInIncorrectDirection * 1000;
+        heuristic += verticalDistanceFromStart * 1000;
+        return heuristic;
+    }
+
+    @Override
+    public String toString() {
+        return "GoalStrictDirection{" +
+                "x=" + x +
+                ", y=" + y +
+                ", z=" + z +
+                ", dx=" + dx +
+                ", dz=" + dz +
+                "}";
+    }
+}

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

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

src/api/java/baritone/api/utils/ISchematic.java

@@ -18,6 +18,7 @@
 package baritone.api.utils;
 
 import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.EnumFacing;
 
 /**
  * Basic representation of a schematic. Provides the dimensions and
@@ -44,6 +45,19 @@ public interface ISchematic {
         return x >= 0 && x < widthX() && y >= 0 && y < heightY() && z >= 0 && z < lengthZ();
     }
 
+    default int size(EnumFacing.Axis axis) {
+        switch (axis) {
+            case X:
+                return widthX();
+            case Y:
+                return heightY();
+            case Z:
+                return lengthZ();
+            default:
+                throw new UnsupportedOperationException(axis + "");
+        }
+    }
+
     /**
      * Returns the desired block state at a given (X, Y, Z) position relative to the origin (0, 0, 0).
      *

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

@@ -18,6 +18,7 @@
 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;
 
@@ -40,13 +41,13 @@ public final class RayTraceUtils {
      * @return The calculated raytrace result
      */
     public static RayTraceResult rayTraceTowards(Entity entity, Rotation rotation, double blockReachDistance) {
-        Vec3d start = entity.getPositionEyes(1.0F);
+        Vec3d start = entity.getEyePosition(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, false, false, true);
+        return entity.world.rayTraceBlocks(start, end, RayTraceFluidMode.NEVER, false, true);
     }
 }

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

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

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

@@ -18,8 +18,11 @@
 package baritone.api.utils;
 
 import baritone.api.Settings;
+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 java.awt.*;
 import java.io.BufferedReader;
@@ -36,11 +39,9 @@ import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static net.minecraft.client.Minecraft.getMinecraft;
-
 public class SettingsUtil {
 
-    private static final Path SETTINGS_PATH = getMinecraft().gameDir.toPath().resolve("baritone").resolve("settings.txt");
+    private static final Path SETTINGS_PATH = Minecraft.getInstance().gameDir.toPath().resolve("baritone").resolve("settings.txt");
     private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>[^ ]+)"); // 2 words separated by spaces
 
     private static final Map<Class<?>, SettingsIO> map;
@@ -146,8 +147,9 @@ public class SettingsUtil {
         FLOAT(Float.class, Float::parseFloat),
         LONG(Long.class, Long::parseLong),
 
-        ITEM_LIST(ArrayList.class, str -> Stream.of(str.split(",")).map(Item::getByNameOrId).collect(Collectors.toCollection(ArrayList::new)), list -> ((ArrayList<Item>) list).stream().map(Item.REGISTRY::getNameForObject).map(ResourceLocation::toString).collect(Collectors.joining(","))),
-        COLOR(Color.class, str -> new Color(Integer.parseInt(str.split(",")[0]), Integer.parseInt(str.split(",")[1]), Integer.parseInt(str.split(",")[2])), color -> color.getRed() + "," + color.getGreen() + "," + color.getBlue());
+        ITEM_LIST(ArrayList.class, str -> Stream.of(str.split(",")).map(ResourceLocation::new).map(IRegistry.ITEM::get).collect(Collectors.toCollection(ArrayList::new)), list -> ((ArrayList<Item>) list).stream().map(IRegistry.ITEM::getKey).map(ResourceLocation::toString).collect(Collectors.joining(","))),
+        COLOR(Color.class, str -> new Color(Integer.parseInt(str.split(",")[0]), Integer.parseInt(str.split(",")[1]), Integer.parseInt(str.split(",")[2])), color -> color.getRed() + "," + color.getGreen() + "," + color.getBlue()),
+        ENUMFACING(EnumFacing.class, EnumFacing::byName);
 
 
         Class<?> klass;

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

@@ -20,9 +20,10 @@ package baritone.api.utils;
 import net.minecraft.block.BlockFire;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
-import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.shapes.VoxelShape;
 import net.minecraft.world.World;
 
 /**
@@ -43,10 +44,16 @@ public final class VecUtils {
      */
     public static Vec3d calculateBlockCenter(World world, BlockPos pos) {
         IBlockState b = world.getBlockState(pos);
-        AxisAlignedBB bbox = b.getBoundingBox(world, pos);
-        double xDiff = (bbox.minX + bbox.maxX) / 2;
-        double yDiff = (bbox.minY + bbox.maxY) / 2;
-        double zDiff = (bbox.minZ + bbox.maxZ) / 2;
+        VoxelShape shape = b.getCollisionShape(world, pos);
+        if (shape.isEmpty()) {
+            return getBlockPosCenter(pos);
+        }
+        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

@@ -0,0 +1,105 @@
+/*
+ * 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

@@ -29,6 +29,7 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
 
 import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL14.*;
 
 @Mixin(ChunkRenderContainer.class)
 public class MixinChunkRenderContainer {
@@ -41,11 +42,11 @@ public class MixinChunkRenderContainer {
             )
     )
     private BlockPos getPosition(RenderChunk renderChunkIn) {
-        if (Baritone.settings().renderCachedChunks.value && Minecraft.getMinecraft().getIntegratedServer() == null && Minecraft.getMinecraft().world.getChunk(renderChunkIn.getPosition()).isEmpty()) {
-            GlStateManager.enableAlpha();
+        if (Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null && Minecraft.getInstance().world.getChunk(renderChunkIn.getPosition()).isEmpty()) {
+            GlStateManager.enableAlphaTest();
             GlStateManager.enableBlend();
             GL14.glBlendColor(0, 0, 0, Baritone.settings().cachedChunksOpacity.value);
-            GlStateManager.tryBlendFuncSeparate(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.blendFuncSeparate(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.getMinecraft().getIntegratedServer() == null) {
+        if (Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null) {
             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,6 +23,7 @@ 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;
@@ -44,9 +45,8 @@ public abstract class MixinEntityLivingBase extends Entity {
      */
     private RotationMoveEvent jumpRotationEvent;
 
-    public MixinEntityLivingBase(World worldIn, RotationMoveEvent jumpRotationEvent) {
-        super(worldIn);
-        this.jumpRotationEvent = jumpRotationEvent;
+    public MixinEntityLivingBase(EntityType<?> entityTypeIn, World worldIn) {
+        super(entityTypeIn, worldIn);
     }
 
     @Inject(

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

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

src/launch/java/baritone/launch/mixins/MixinGameRenderer.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.EntityRenderer;
+import net.minecraft.client.renderer.GameRenderer;
 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(EntityRenderer.class)
-public class MixinEntityRenderer {
+@Mixin(GameRenderer.class)
+public class MixinGameRenderer {
 
     @Inject(
-            method = "renderWorldPass",
+            method = "updateCameraAndRender(FJ)V",
             at = @At(
                     value = "INVOKE_STRING",
                     target = "Lnet/minecraft/profiler/Profiler;endStartSection(Ljava/lang/String;)V",
                     args = {"ldc=hand"}
             )
     )
-    private void renderWorldPass(int pass, float partialTicks, long finishTimeNano, CallbackInfo ci) {
+    private void renderWorldPass(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;Ljava/lang/String;)V",
+            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Lnet/minecraft/client/gui/GuiScreen;)V",
             at = @At("HEAD")
     )
-    private void preLoadWorld(WorldClient world, String loadingMessage, CallbackInfo ci) {
+    private void preLoadWorld(WorldClient world, GuiScreen loadingScreen, 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;Ljava/lang/String;)V",
+            method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Lnet/minecraft/client/gui/GuiScreen;)V",
             at = @At("RETURN")
     )
-    private void postLoadWorld(WorldClient world, String loadingMessage, CallbackInfo ci) {
+    private void postLoadWorld(WorldClient world, GuiScreen loadingScreen, 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,6 +24,7 @@ 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;
@@ -40,7 +41,7 @@ public class MixinNetHandlerPlayClient {
             method = "handleChunkData",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/world/chunk/Chunk.read(Lnet/minecraft/network/PacketBuffer;IZ)V"
+                    target = "net/minecraft/client/multiplayer/ChunkProviderClient.func_212474_a(IILnet/minecraft/network/PacketBuffer;IZ)Lnet/minecraft/world/chunk/Chunk;"
             )
     )
     private void preRead(SPacketChunkData packetIn, CallbackInfo ci) {
@@ -77,6 +78,34 @@ 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/Packet.processPacket(Lnet/minecraft/network/INetHandler;)V"
+                    target = "net/minecraft/network/NetworkManager.processPacket(Lnet/minecraft/network/Packet;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,43 +40,11 @@ public class MixinRenderChunk {
             method = "rebuildChunk",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/world/ChunkCache.isEmpty()Z"
+                    target = "net/minecraft/client/renderer/chunk/RenderChunkCache.getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/state/IBlockState;"
             )
     )
-    private boolean isEmpty(ChunkCache chunkCache) {
-        if (!chunkCache.isEmpty()) {
-            return false;
-        }
-        if (Baritone.settings().renderCachedChunks.value && Minecraft.getMinecraft().getIntegratedServer() == null) {
-            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().getIntegratedServer() == null) {
+    private IBlockState getBlockState(RenderChunkCache chunkCache, BlockPos pos) {
+        if (Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null) {
             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

@@ -0,0 +1,47 @@
+/*
+ * 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.getMinecraft().getIntegratedServer() == null) {
+        if (Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null) {
             // reset the blend func to normal (not dependent on constant alpha)
-            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.blendFuncSeparate(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.getMinecraft().getIntegratedServer() == null) {
+        if (Baritone.settings().renderCachedChunks.value && Minecraft.getInstance().getIntegratedServer() == null) {
             // reset the blend func to normal (not dependent on constant alpha)
-            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+            GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
         }
         GlStateManager.popMatrix();
     }

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

@@ -1,75 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.launch.mixins;
-
-import baritone.api.BaritoneAPI;
-import baritone.api.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",
-    "MixinEntityRenderer",
+    "MixinGameRenderer",
     "MixinMinecraft",
     "MixinNetHandlerPlayClient",
     "MixinNetworkManager",
     "MixinRenderChunk",
+    "MixinRenderChunkCache",
     "MixinRenderList",
-    "MixinVboRenderList",
-    "MixinWorldClient"
+    "MixinVboRenderList"
   ]
 }

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.getMinecraft().gameDir, "baritone");
+        dir = new File(Minecraft.getInstance().gameDir, "baritone");
         if (!Files.exists(dir.toPath())) {
             try {
                 Files.createDirectories(dir.toPath());

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

@@ -28,9 +28,6 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
 
     /**
      * Target's values are as follows:
-     * <p>
-     * getFirst() -> yaw
-     * getSecond() -> pitch
      */
     private Rotation target;
 
@@ -72,8 +69,8 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
                     float oldPitch = ctx.player().rotationPitch;
                     float desiredPitch = this.target.getPitch();
                     ctx.player().rotationPitch = desiredPitch;
-                    if (desiredPitch == oldPitch) {
-                        //nudgeToLevel();
+                    if (desiredPitch == oldPitch && !Baritone.settings().freeLook.value) {
+                        nudgeToLevel();
                     }
                     this.target = null;
                 }

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

@@ -53,9 +53,10 @@ public final class CachedChunk {
         temp.add(Blocks.TRAPPED_CHEST);
         temp.add(Blocks.END_PORTAL);
         temp.add(Blocks.END_PORTAL_FRAME);
-        temp.add(Blocks.MOB_SPAWNER);
+        temp.add(Blocks.SPAWNER);
         temp.add(Blocks.BARRIER);
         temp.add(Blocks.OBSERVER);
+
         temp.add(Blocks.WHITE_SHULKER_BOX);
         temp.add(Blocks.ORANGE_SHULKER_BOX);
         temp.add(Blocks.MAGENTA_SHULKER_BOX);
@@ -64,7 +65,7 @@ public final class CachedChunk {
         temp.add(Blocks.LIME_SHULKER_BOX);
         temp.add(Blocks.PINK_SHULKER_BOX);
         temp.add(Blocks.GRAY_SHULKER_BOX);
-        temp.add(Blocks.SILVER_SHULKER_BOX);
+        temp.add(Blocks.LIGHT_GRAY_SHULKER_BOX);
         temp.add(Blocks.CYAN_SHULKER_BOX);
         temp.add(Blocks.PURPLE_SHULKER_BOX);
         temp.add(Blocks.BLUE_SHULKER_BOX);
@@ -72,23 +73,57 @@ public final class CachedChunk {
         temp.add(Blocks.GREEN_SHULKER_BOX);
         temp.add(Blocks.RED_SHULKER_BOX);
         temp.add(Blocks.BLACK_SHULKER_BOX);
-        temp.add(Blocks.PORTAL);
+
+        temp.add(Blocks.NETHER_PORTAL);
         temp.add(Blocks.HOPPER);
         temp.add(Blocks.BEACON);
         temp.add(Blocks.BREWING_STAND);
-        temp.add(Blocks.SKULL);
+
+        // TODO: Maybe add a predicate for blocks to keep track of?
+        // This should really not need to happen
+        temp.add(Blocks.CREEPER_HEAD);
+        temp.add(Blocks.CREEPER_WALL_HEAD);
+        temp.add(Blocks.DRAGON_HEAD);
+        temp.add(Blocks.DRAGON_WALL_HEAD);
+        temp.add(Blocks.PLAYER_HEAD);
+        temp.add(Blocks.PLAYER_WALL_HEAD);
+        temp.add(Blocks.ZOMBIE_HEAD);
+        temp.add(Blocks.ZOMBIE_WALL_HEAD);
+        temp.add(Blocks.SKELETON_SKULL);
+        temp.add(Blocks.SKELETON_WALL_SKULL);
+        temp.add(Blocks.WITHER_SKELETON_SKULL);
+        temp.add(Blocks.WITHER_SKELETON_WALL_SKULL);
+
         temp.add(Blocks.ENCHANTING_TABLE);
         temp.add(Blocks.ANVIL);
-        temp.add(Blocks.LIT_FURNACE);
-        temp.add(Blocks.BED);
+
+        temp.add(Blocks.WHITE_BED);
+        temp.add(Blocks.ORANGE_BED);
+        temp.add(Blocks.MAGENTA_BED);
+        temp.add(Blocks.LIGHT_BLUE_BED);
+        temp.add(Blocks.YELLOW_BED);
+        temp.add(Blocks.LIME_BED);
+        temp.add(Blocks.PINK_BED);
+        temp.add(Blocks.GRAY_BED);
+        temp.add(Blocks.LIGHT_GRAY_BED);
+        temp.add(Blocks.CYAN_BED);
+        temp.add(Blocks.PURPLE_BED);
+        temp.add(Blocks.BLUE_BED);
+        temp.add(Blocks.BROWN_BED);
+        temp.add(Blocks.GREEN_BED);
+        temp.add(Blocks.RED_BED);
+        temp.add(Blocks.BLACK_BED);
+        
         temp.add(Blocks.DRAGON_EGG);
         temp.add(Blocks.JUKEBOX);
         temp.add(Blocks.END_GATEWAY);
-        temp.add(Blocks.WEB);
+        temp.add(Blocks.COBWEB);
         temp.add(Blocks.NETHER_WART);
         temp.add(Blocks.LADDER);
         temp.add(Blocks.VINE);
         BLOCKS_TO_KEEP_TRACK_OF = Collections.unmodifiableSet(temp);
+
+        // TODO: Lit Furnaces
     }
 
     /**
@@ -169,8 +204,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.getMinecraft().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock().equals(state.getBlock())) {
-                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));
+            if (!Minecraft.getInstance().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));
             }*/
             return overview[internalPos];
         }

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

@@ -24,9 +24,11 @@ import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.registry.IRegistry;
 import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraft.world.chunk.ChunkSection;
 
 import java.util.*;
 
@@ -46,9 +48,9 @@ public final class ChunkPacker {
         Map<String, List<BlockPos>> specialBlocks = new HashMap<>();
         BitSet bitSet = new BitSet(CachedChunk.SIZE);
         try {
-            ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
+            ChunkSection[] chunkInternalStorageArray = chunk.getSections();
             for (int y0 = 0; y0 < 16; y0++) {
-                ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
+                ChunkSection 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
@@ -60,7 +62,7 @@ public final class ChunkPacker {
                     // since a bitset is initialized to all zero, and air is saved as zeros
                     continue;
                 }
-                BlockStateContainer bsc = extendedblockstorage.getData();
+                BlockStateContainer<IBlockState> 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
@@ -90,7 +92,8 @@ public final class ChunkPacker {
         IBlockState[] blocks = new IBlockState[256];
 
         for (int z = 0; z < 16; z++) {
-            https://www.ibm.com/developerworks/library/j-perry-writing-good-java-code/index.html
+            https:
+//www.ibm.com/developerworks/library/j-perry-writing-good-java-code/index.html
             for (int x = 0; x < 16; x++) {
                 for (int y = 255; y >= 0; y--) {
                     int index = CachedChunk.getPositionIndex(x, y, z);
@@ -106,7 +109,7 @@ public final class ChunkPacker {
     }
 
     public static String blockToString(Block block) {
-        ResourceLocation loc = Block.REGISTRY.getNameForObject(block);
+        ResourceLocation loc = IRegistry.BLOCK.getKey(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?
@@ -116,25 +119,29 @@ public final class ChunkPacker {
     }
 
     public static Block stringToBlockRequired(String name) {
+        if (name.equals("lit_redstone_ore")) {
+            return stringToBlockRequired("redstone_ore");
+        }
         Block block = stringToBlockNullable(name);
         Objects.requireNonNull(block);
         return block;
     }
 
     public static Block stringToBlockNullable(String name) {
-        return resourceCache.computeIfAbsent(name, n -> Block.getBlockFromName(n.contains(":") ? n : "minecraft:" + n));
+        return resourceCache.computeIfAbsent(name, n -> IRegistry.BLOCK.get(new ResourceLocation(n.contains(":") ? n : "minecraft:" + n)));
     }
 
     private static PathingBlockType getPathingBlockType(IBlockState state, Chunk chunk, int x, int y, int z) {
         Block block = state.getBlock();
-        if (block == Blocks.WATER || block == Blocks.FLOWING_WATER) {
+        if (MovementHelper.isWater(state)) {
             // only water source blocks are plausibly usable, flowing water should be avoid
             // FLOWING_WATER is a waterfall, it doesn't really matter and caching it as AVOID just makes it look wrong
             if (MovementHelper.possiblyFlowing(state)) {
                 return PathingBlockType.AVOID;
             }
             if (x == 0 || x == 15 || z == 0 || z == 15) {
-                if (BlockLiquid.getSlopeAngle(chunk.getWorld(), new BlockPos(x + chunk.x << 4, y, z + chunk.z << 4), state.getMaterial(), state) == -1000.0F) {
+                Vec3d flow = state.getFluidState().getFlow(chunk.getWorld(), new BlockPos(x + chunk.x << 4, y, z + chunk.z << 4));
+                if (flow.x != 0.0 || flow.z != 0.0) {
                     return PathingBlockType.WATER;
                 }
                 return PathingBlockType.AVOID;
@@ -145,14 +152,14 @@ public final class ChunkPacker {
             return PathingBlockType.WATER;
         }
 
-        if (MovementHelper.avoidWalkingInto(block) || MovementHelper.isBottomSlab(state)) {
+        if (MovementHelper.avoidWalkingInto(state) || 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 == Blocks.AIR || block instanceof BlockTallGrass || block instanceof BlockDoublePlant || block instanceof BlockFlower) {
+        if (block instanceof BlockAir || block instanceof BlockTallGrass || block instanceof BlockDoublePlant || block instanceof BlockFlower) {
             return PathingBlockType.AIR;
         }
 

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

@@ -24,6 +24,7 @@ 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;
@@ -55,7 +56,7 @@ public class WorldProvider implements IWorldProvider, Helper {
      *
      * @param dimension The ID of the world's dimension
      */
-    public final void initWorld(int dimension) {
+    public final void initWorld(DimensionType dimension) {
         File directory;
         File readme;
 
@@ -92,7 +93,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).toPath();
+        Path dir = new File(directory, "DIM" + dimension.getId()).toPath();
         if (!Files.exists(dir)) {
             try {
                 Files.createDirectories(dir);
@@ -101,7 +102,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));
+            this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, dimension.getId()));
         }
     }
 

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

@@ -26,17 +26,17 @@ 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.storage.ExtendedBlockStorage;
+import net.minecraft.world.chunk.ChunkSection;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
+import java.util.stream.IntStream;
 
 public enum WorldScanner implements IWorldScanner {
 
     INSTANCE;
 
+    private static final int[] DEFAULT_COORDINATE_ITERATION_ORDER = IntStream.range(0, 16).toArray();
+
     @Override
     public List<BlockPos> scanChunkRadius(IPlayerContext ctx, List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius) {
         if (blocks.contains(null)) {
@@ -53,6 +53,9 @@ public enum WorldScanner implements IWorldScanner {
         int playerChunkZ = ctx.playerFeet().getZ() >> 4;
         int playerY = ctx.playerFeet().getY();
 
+        int playerYBlockStateContainerIndex = playerY >> 4;
+        int[] coordinateIterationOrder = IntStream.range(0, 16).boxed().sorted(Comparator.comparingInt(y -> Math.abs(y - playerYBlockStateContainerIndex))).mapToInt(x -> x).toArray();
+
         int searchRadiusSq = 0;
         boolean foundWithinY = false;
         while (true) {
@@ -67,12 +70,14 @@ public enum WorldScanner implements IWorldScanner {
                     foundChunks = true;
                     int chunkX = xoff + playerChunkX;
                     int chunkZ = zoff + playerChunkZ;
-                    Chunk chunk = chunkProvider.getLoadedChunk(chunkX, chunkZ);
+                    Chunk chunk = chunkProvider.getChunk(chunkX, chunkZ, false, false);
                     if (chunk == null) {
                         continue;
                     }
                     allUnloaded = false;
-                    scanChunkInto(chunkX << 4, chunkZ << 4, chunk, blocks, res, max, yLevelThreshold, playerY);
+                    if (scanChunkInto(chunkX << 4, chunkZ << 4, chunk, blocks, res, max, yLevelThreshold, playerY, coordinateIterationOrder)) {
+                        foundWithinY = true;
+                    }
                 }
             }
             if ((allUnloaded && foundChunks)
@@ -92,7 +97,7 @@ public enum WorldScanner implements IWorldScanner {
         }
 
         ChunkProviderClient chunkProvider = (ChunkProviderClient) ctx.world().getChunkProvider();
-        Chunk chunk = chunkProvider.getLoadedChunk(pos.x, pos.z);
+        Chunk chunk = chunkProvider.getChunk(pos.x, pos.z, false, false);
         int playerY = ctx.playerFeet().getY();
 
         if (chunk == null || chunk.isEmpty()) {
@@ -100,19 +105,21 @@ public enum WorldScanner implements IWorldScanner {
         }
 
         ArrayList<BlockPos> res = new ArrayList<>();
-        scanChunkInto(pos.x << 4, pos.z << 4, chunk, blocks, res, max, yLevelThreshold, playerY);
+        scanChunkInto(pos.x << 4, pos.z << 4, chunk, blocks, res, max, yLevelThreshold, playerY, DEFAULT_COORDINATE_ITERATION_ORDER);
         return res;
     }
 
-    public void scanChunkInto(int chunkX, int chunkZ, Chunk chunk, List<Block> search, Collection<BlockPos> result, int max, int yLevelThreshold, int playerY) {
-        ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
-        for (int y0 = 0; y0 < 16; y0++) {
-            ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
+    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();
+        boolean foundWithinY = false;
+        for (int yIndex = 0; yIndex < 16; yIndex++) {
+            int y0 = coordinateIterationOrder[yIndex];
+            ChunkSection extendedblockstorage = chunkInternalStorageArray[y0];
             if (extendedblockstorage == null) {
                 continue;
             }
             int yReal = y0 << 4;
-            BlockStateContainer bsc = extendedblockstorage.getData();
+            BlockStateContainer<IBlockState> 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++) {
@@ -121,14 +128,23 @@ public enum WorldScanner implements IWorldScanner {
                         IBlockState state = bsc.get(x, y, z);
                         if (search.contains(state.getBlock())) {
                             int yy = yReal | y;
-                            result.add(new BlockPos(chunkX | x, yy, chunkZ | z));
-                            if (result.size() >= max && Math.abs(yy - playerY) < yLevelThreshold) {
-                                return;
+                            if (result.size() >= max) {
+                                if (Math.abs(yy - playerY) < yLevelThreshold) {
+                                    foundWithinY = true;
+                                } else {
+                                    if (foundWithinY) {
+                                        // have found within Y in this chunk, so don't need to consider outside Y
+                                        // TODO continue iteration to one more sorted Y coordinate block
+                                        return true;
+                                    }
+                                }
                             }
+                            result.add(new BlockPos(chunkX | x, yy, chunkZ | z));
                         }
                     }
                 }
             }
         }
+        return foundWithinY;
     }
 }

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().isChunkGeneratedAt(event.getX(), event.getZ());
+                && world.getChunkProvider().getChunk(event.getX(), event.getZ(), false, false) != null;
 
         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().provider.getDimensionType().getId());
+                cache.initWorld(event.getWorld().getDimension().getType());
             }
         }
 

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

@@ -60,6 +60,7 @@ public class CalculationContext {
     public final boolean allowJumpAt256;
     public final boolean assumeWalkOnWater;
     public final boolean allowDiagonalDescend;
+    public final boolean allowDownward;
     public final int maxFallHeightNoWater;
     public final int maxFallHeightBucket;
     public final double waterWalkSpeed;
@@ -82,7 +83,7 @@ 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.provider.isNether();
+        this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.value && InventoryPlayer.isHotbar(player.inventory.getSlotFor(STACK_BUCKET_WATER)) && !world.getDimension().isNether();
         this.canSprint = Baritone.settings().allowSprint.value && player.getFoodStats().getFoodLevel() > 6;
         this.placeBlockCost = Baritone.settings().blockPlacementPenalty.value;
         this.allowBreak = Baritone.settings().allowBreak.value;
@@ -91,6 +92,7 @@ public class CalculationContext {
         this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
         this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;
         this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.value;
+        this.allowDownward = Baritone.settings().allowDownward.value;
         this.maxFallHeightNoWater = Baritone.settings().maxFallHeightNoWater.value;
         this.maxFallHeightBucket = Baritone.settings().maxFallHeightBucket.value;
         int depth = EnchantmentHelper.getDepthStriderModifier(player);

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

@@ -23,7 +23,6 @@ import baritone.api.pathing.movement.MovementStatus;
 import baritone.api.utils.*;
 import baritone.api.utils.input.Input;
 import baritone.utils.BlockStateInterface;
-import net.minecraft.block.BlockLiquid;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 
@@ -106,7 +105,7 @@ public abstract class Movement implements IMovement, MovementHelper {
      */
     @Override
     public MovementStatus update() {
-        ctx.player().capabilities.isFlying = false;
+        ctx.player().abilities.isFlying = false;
         currentState = updateState(currentState);
         if (MovementHelper.isLiquid(ctx, ctx.playerFeet())) {
             currentState.setInput(Input.JUMP, true);
@@ -140,7 +139,7 @@ public abstract class Movement implements IMovement, MovementHelper {
         }
         boolean somethingInTheWay = false;
         for (BetterBlockPos blockPos : positionsToBreak) {
-            if (!MovementHelper.canWalkThrough(ctx, blockPos) && !(BlockStateInterface.getBlock(ctx, blockPos) instanceof BlockLiquid)) { // can't break liquid, so don't try
+            if (!MovementHelper.canWalkThrough(ctx, blockPos)) { // can't break air, so don't try
                 somethingInTheWay = true;
                 Optional<Rotation> reachable = RotationUtils.reachable(ctx.player(), blockPos, ctx.playerController().getBlockReachDistance());
                 if (reachable.isPresent()) {
@@ -156,7 +155,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().getPositionEyes(1.0F),
+                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getEyePosition(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

@@ -28,9 +28,16 @@ import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
 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;
@@ -52,11 +59,11 @@ public interface MovementHelper extends ActionCosts, Helper {
         return b == Blocks.ICE // ice becomes water, and water can mess up the path
                 || b instanceof BlockSilverfish // obvious reasons
                 // call context.get directly with x,y,z. no need to make 5 new BlockPos for no reason
-                || bsi.get0(x, y + 1, z).getBlock() instanceof BlockLiquid//don't break anything touching liquid on any side
-                || bsi.get0(x + 1, y, z).getBlock() instanceof BlockLiquid
-                || bsi.get0(x - 1, y, z).getBlock() instanceof BlockLiquid
-                || bsi.get0(x, y, z + 1).getBlock() instanceof BlockLiquid
-                || bsi.get0(x, y, z - 1).getBlock() instanceof BlockLiquid;
+                || !bsi.get0(x, y + 1, z).getFluidState().isEmpty()//don't break anything touching liquid on any side
+                || !bsi.get0(x + 1, y, z).getFluidState().isEmpty()
+                || !bsi.get0(x - 1, y, z).getFluidState().isEmpty()
+                || !bsi.get0(x, y, z + 1).getFluidState().isEmpty()
+                || !bsi.get0(x, y, z - 1).getFluidState().isEmpty();
     }
 
     static boolean canWalkThrough(IPlayerContext ctx, BetterBlockPos pos) {
@@ -69,10 +76,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 == Blocks.AIR) { // early return for most common case
+        if (block instanceof BlockAir) { // early return for most common case
             return true;
         }
-        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.WEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block instanceof BlockTrapDoor) {
+        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.COBWEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block == Blocks.BUBBLE_COLUMN || block instanceof BlockShulkerBox || block instanceof BlockSlab || block instanceof BlockTrapDoor) {
             return false;
         }
         if (block instanceof BlockDoor || block instanceof BlockFenceGate) {
@@ -81,10 +88,10 @@ public interface MovementHelper extends ActionCosts, Helper {
             // be opened by just interacting.
             return block != Blocks.IRON_DOOR;
         }
-        if (block == Blocks.CARPET) {
+        if (block instanceof BlockCarpet) {
             return canWalkOn(bsi, x, y - 1, z);
         }
-        if (block instanceof BlockSnow) {
+        if (block instanceof BlockSnowLayer) {
             // 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
@@ -94,7 +101,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.getValue(BlockSnow.LAYERS) >= 3) {
+            if (state.get(BlockSnowLayer.LAYERS) >= 3) {
                 return false;
             }
             // ok, it's low enough we could walk through it, but is it supported?
@@ -103,20 +110,21 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (isFlowing(x, y, z, state, bsi)) {
             return false; // Don't walk through flowing liquids
         }
-        if (block instanceof BlockLiquid) {
+        IFluidState fluidState = state.getFluidState();
+        if (fluidState.getFluid() instanceof WaterFluid) {
             if (Baritone.settings().assumeWalkOnWater.value) {
                 return false;
             }
             IBlockState up = bsi.get0(x, y + 1, z);
-            if (up.getBlock() instanceof BlockLiquid || up.getBlock() instanceof BlockLilyPad) {
+            if (!up.getFluidState().isEmpty() || up.getBlock() instanceof BlockLilyPad) {
                 return false;
             }
-            return block == Blocks.WATER || block == Blocks.FLOWING_WATER;
+            return true;
         }
         // 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 block.isPassable(null, null);
+        return state.allowsMovement(null, null, PathType.LAND);
     }
 
     /**
@@ -135,27 +143,28 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static boolean fullyPassable(IBlockState state) {
         Block block = state.getBlock();
-        if (block == Blocks.AIR) { // early return for most common case
+        if (block instanceof BlockAir) { // 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.WEB
+                || block == Blocks.COBWEB
                 || block == Blocks.VINE
                 || block == Blocks.LADDER
                 || block == Blocks.COCOA
                 || block instanceof BlockDoor
                 || block instanceof BlockFenceGate
                 || block instanceof BlockSnow
-                || block instanceof BlockLiquid
+                || !state.getFluidState().isEmpty()
                 || 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 block.isPassable(null, null);
+        return state.allowsMovement(null, null, PathType.LAND);
     }
 
     static boolean isReplacable(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
@@ -170,20 +179,19 @@ public interface MovementHelper extends ActionCosts, Helper {
          *     }
          */
         Block block = state.getBlock();
-        if (block == Blocks.AIR || isWater(block)) {
+        if (block instanceof BlockAir) {
             // early return for common cases hehe
             return true;
         }
-        if (block instanceof BlockSnow) {
+        if (block instanceof BlockSnowLayer) {
             // 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.getValue(BlockSnow.LAYERS) == 1;
+            return state.get(BlockSnowLayer.LAYERS) == 1;
         }
-        if (block instanceof BlockDoublePlant) {
-            BlockDoublePlant.EnumPlantType kek = state.getValue(BlockDoublePlant.VARIANT);
-            return kek == BlockDoublePlant.EnumPlantType.FERN || kek == BlockDoublePlant.EnumPlantType.GRASS;
+        if (block == Blocks.LARGE_FERN || block == Blocks.TALL_GRASS) {
+            return true;
         }
         return state.getMaterial().isReplaceable();
     }
@@ -211,16 +219,16 @@ public interface MovementHelper extends ActionCosts, Helper {
             return true;
         }
 
-        return state.getValue(BlockFenceGate.OPEN);
+        return state.get(BlockFenceGate.OPEN);
     }
 
-    static boolean isHorizontalBlockPassable(BlockPos blockPos, IBlockState blockState, BlockPos playerPos, PropertyBool propertyOpen) {
+    static boolean isHorizontalBlockPassable(BlockPos blockPos, IBlockState blockState, BlockPos playerPos, BooleanProperty propertyOpen) {
         if (playerPos.equals(blockPos)) {
             return false;
         }
 
-        EnumFacing.Axis facing = blockState.getValue(BlockHorizontal.FACING).getAxis();
-        boolean open = blockState.getValue(propertyOpen);
+        EnumFacing.Axis facing = blockState.get(BlockHorizontal.HORIZONTAL_FACING).getAxis();
+        boolean open = blockState.get(propertyOpen);
 
         EnumFacing.Axis playerFacing;
         if (playerPos.north().equals(blockPos) || playerPos.south().equals(blockPos)) {
@@ -234,14 +242,15 @@ public interface MovementHelper extends ActionCosts, Helper {
         return (facing == playerFacing) == open;
     }
 
-    static boolean avoidWalkingInto(Block block) {
-        return block instanceof BlockLiquid
-                || block instanceof BlockDynamicLiquid
-                || block == Blocks.MAGMA
+    static boolean avoidWalkingInto(IBlockState state) {
+        Block block = state.getBlock();
+        return !state.getFluidState().isEmpty()
+                || block == Blocks.MAGMA_BLOCK
                 || block == Blocks.CACTUS
                 || block == Blocks.FIRE
                 || block == Blocks.END_PORTAL
-                || block == Blocks.WEB;
+                || block == Blocks.COBWEB
+                || block == Blocks.BUBBLE_COLUMN;
     }
 
     /**
@@ -258,7 +267,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 == Blocks.AIR || block == Blocks.MAGMA) {
+        if (block instanceof BlockAir || block == Blocks.MAGMA_BLOCK || block == Blocks.BUBBLE_COLUMN) {
             // early return for most common case (air)
             // plus magma, which is a normal cube but it hurts you
             return false;
@@ -275,30 +284,31 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST) {
             return true;
         }
-        if (isWater(block)) {
+        if (isWater(state)) {
             // 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
-            Block up = bsi.get0(x, y + 1, z).getBlock();
-            if (up == Blocks.WATERLILY || up == Blocks.CARPET) {
+            IBlockState upState = bsi.get0(x, y + 1, z);
+            Block up = upState.getBlock();
+            if (up == Blocks.LILY_PAD || up instanceof BlockCarpet) {
                 return true;
             }
-            if (isFlowing(x, y, z, state, bsi) || block == Blocks.FLOWING_WATER) {
+            if (isFlowing(x, y, z, state, bsi) || upState.getFluidState().getFluid() == Fluids.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(up) && !Baritone.settings().assumeWalkOnWater.value;
+                return isWater(upState) && !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(up) ^ Baritone.settings().assumeWalkOnWater.value;
+            return isWater(upState) ^ Baritone.settings().assumeWalkOnWater.value;
         }
-        if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
+        if (Baritone.settings().assumeWalkOnLava.value && isLava(state) && !isFlowing(x, y, z, state, bsi)) {
+            return true;
+        }
+        if (block == Blocks.GLASS || block instanceof BlockStainedGlass) {
             return true;
         }
         if (block instanceof BlockSlab) {
             if (!Baritone.settings().allowWalkOnBottomSlab.value) {
-                if (((BlockSlab) block).isDouble()) {
-                    return true;
-                }
-                return state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM;
+                return state.isTopSolid();
             }
             return true;
         }
@@ -333,7 +343,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.isFullBlock() || state.getBlock() == Blocks.GLASS || state.getBlock() == Blocks.STAINED_GLASS;
+        return state.isBlockNormalCube() || state.isFullCube() || state.getBlock() == Blocks.GLASS || state.getBlock() instanceof BlockStainedGlass;
     }
 
     static double getMiningDurationTicks(CalculationContext context, int x, int y, int z, boolean includeFalling) {
@@ -350,7 +360,7 @@ public interface MovementHelper extends ActionCosts, Helper {
             if (avoidBreaking(context.bsi, x, y, z, state)) {
                 return COST_INF;
             }
-            if (block instanceof BlockLiquid) {
+            if (!state.getFluidState().isEmpty()) {
                 return COST_INF;
             }
             double m = Blocks.CRAFTING_TABLE.equals(block) ? 10 : 1; // TODO see if this is still necessary. it's from MineBot when we wanted to penalize breaking its crafting table
@@ -375,8 +385,7 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static boolean isBottomSlab(IBlockState state) {
         return state.getBlock() instanceof BlockSlab
-                && !((BlockSlab) state.getBlock()).isDouble()
-                && state.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM;
+                && state.get(BlockSlab.TYPE) == SlabType.BOTTOM;
     }
 
     /**
@@ -413,11 +422,12 @@ public interface MovementHelper extends ActionCosts, Helper {
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.
      *
-     * @param b The block
+     * @param state The block state
      * @return Whether or not the block is water
      */
-    static boolean isWater(Block b) {
-        return b == Blocks.FLOWING_WATER || b == Blocks.WATER;
+    static boolean isWater(IBlockState state) {
+        Fluid f = state.getFluidState().getFluid();
+        return f == Fluids.WATER || f == Fluids.FLOWING_WATER;
     }
 
     /**
@@ -429,11 +439,12 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @return Whether or not the block is water
      */
     static boolean isWater(IPlayerContext ctx, BlockPos bp) {
-        return isWater(BlockStateInterface.getBlock(ctx, bp));
+        return isWater(BlockStateInterface.get(ctx, bp));
     }
 
-    static boolean isLava(Block b) {
-        return b == Blocks.FLOWING_LAVA || b == Blocks.LAVA;
+    static boolean isLava(IBlockState state) {
+        Fluid f = state.getFluidState().getFluid();
+        return f == Fluids.LAVA || f == Fluids.FLOWING_LAVA;
     }
 
     /**
@@ -444,20 +455,25 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @return Whether or not the block is a liquid
      */
     static boolean isLiquid(IPlayerContext ctx, BlockPos p) {
-        return BlockStateInterface.getBlock(ctx, p) instanceof BlockLiquid;
+        return isLiquid(BlockStateInterface.get(ctx, p));
+    }
+
+    static boolean isLiquid(IBlockState blockState) {
+        return !blockState.getFluidState().isEmpty();
     }
 
     static boolean possiblyFlowing(IBlockState state) {
-        // Will be IFluidState in 1.13
-        return state.getBlock() instanceof BlockLiquid
-                && state.getValue(BlockLiquid.LEVEL) != 0;
+        IFluidState fluidState = state.getFluidState();
+        return fluidState.getFluid() instanceof FlowingFluid
+                && fluidState.getFluid().getLevel(fluidState) != 8;
     }
 
     static boolean isFlowing(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
-        if (!(state.getBlock() instanceof BlockLiquid)) {
+        IFluidState fluidState = state.getFluidState();
+        if (!(fluidState.getFluid() instanceof FlowingFluid)) {
             return false;
         }
-        if (state.getValue(BlockLiquid.LEVEL) != 0) {
+        if (fluidState.getFluid().getLevel(fluidState) != 8) {
             return true;
         }
         return possiblyFlowing(bsi.get0(x + 1, y, z))
@@ -488,7 +504,7 @@ public interface MovementHelper extends ActionCosts, Helper {
                 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.typeOfHit == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(placeAt)) {
+                if (res != null && res.type == 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/movements/MovementAscend.java

@@ -197,9 +197,7 @@ public class MovementAscend extends Movement {
         if (headBonkClear()) {
             return state.setInput(Input.JUMP, true);
         }
-
-
-        // System.out.println(flatDistToNext + " " + sideDist);
+        
         if (flatDistToNext > 1.2 || sideDist > 0.2) {
             return state;
         }

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

@@ -137,7 +137,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.getBlock())) {
+            if (MovementHelper.isWater(ontoBlock)) {
                 if (!MovementHelper.canWalkThrough(context.bsi, destX, newY, destZ, ontoBlock)) {
                     return false;
                 }
@@ -216,7 +216,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.getPositionEyes(1.0F),
+                    new Rotation(RotationUtils.calcRotationFromVec3d(player.getEyePosition(1.0F),
                             new Vec3d(destX, dest.getY(), destZ),
                             new Rotation(player.rotationYaw, player.rotationPitch)).getYaw(), player.rotationPitch),
                     false
@@ -248,7 +248,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.getBlock(ctx, into.up(y)))) {
+            if (MovementHelper.avoidWalkingInto(BlockStateInterface.get(ctx, into.up(y)))) {
                 return true;
             }
         }

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

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

@@ -48,6 +48,9 @@ public class MovementDownward extends Movement {
     }
 
     public static double cost(CalculationContext context, int x, int y, int z) {
+        if (!context.allowDownward) {
+            return COST_INF;
+        }
         if (!MovementHelper.canWalkOn(context.bsi, x, y - 2, z)) {
             return COST_INF;
         }

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

@@ -34,6 +34,7 @@ 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;
@@ -80,10 +81,11 @@ public class MovementFall extends Movement {
         BlockPos playerFeet = ctx.playerFeet();
         Rotation toDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations());
         Rotation targetRotation = null;
-        Block destBlock = ctx.world().getBlockState(dest).getBlock();
-        boolean isWater = destBlock == Blocks.WATER || destBlock == Blocks.FLOWING_WATER;
+        IBlockState destState = ctx.world().getBlockState(dest);
+        Block destBlock = destState.getBlock();
+        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().provider.isNether()) {
+            if (!InventoryPlayer.isHotbar(ctx.player().inventory.getSlotFor(STACK_BUCKET_WATER)) || ctx.world().getDimension().isNether()) {
                 return state.setStatus(MovementStatus.UNREACHABLE);
             }
 
@@ -93,7 +95,7 @@ public class MovementFall extends Movement {
                 targetRotation = new Rotation(toDest.getYaw(), 90.0F);
 
                 RayTraceResult trace = ctx.objectMouseOver();
-                if (trace != null && trace.typeOfHit == RayTraceResult.Type.BLOCK && (trace.getBlockPos().equals(dest) || trace.getBlockPos().equals(dest.down()))) {
+                if (trace != null && trace.type == RayTraceResult.Type.BLOCK && (trace.getBlockPos().equals(dest) || trace.getBlockPos().equals(dest.down()))) {
                     state.setInput(Input.CLICK_RIGHT, true);
                 }
             }
@@ -150,7 +152,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.getValue(BlockLadder.FACING);
+                return state.get(BlockLadder.FACING);
             }
         }
         return null;

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

@@ -28,10 +28,11 @@ 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;
 
 public class MovementParkour extends Movement {
@@ -73,7 +74,7 @@ public class MovementParkour extends Movement {
             // second most common case -- we could just traverse not parkour
             return;
         }
-        if (MovementHelper.avoidWalkingInto(adj.getBlock()) && adj.getBlock() != Blocks.WATER && adj.getBlock() != Blocks.FLOWING_WATER) { // magma sucks
+        if (MovementHelper.avoidWalkingInto(adj) && !(adj.getFluidState().getFluid() instanceof WaterFluid)) { // magma sucks
             return;
         }
         if (!MovementHelper.fullyPassable(context, x + xDiff, y + 1, z + zDiff)) {
@@ -86,7 +87,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.getBlock() instanceof BlockLiquid) {
+        if (standingOn.getBlock() == Blocks.VINE || standingOn.getBlock() == Blocks.LADDER || standingOn.getBlock() instanceof BlockStairs || MovementHelper.isBottomSlab(standingOn) || standingOn.getFluidState().getFluid() != Fluids.EMPTY) {
             return;
         }
         int maxJump;

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

@@ -51,14 +51,15 @@ public class MovementPillar extends Movement {
     }
 
     public static double cost(CalculationContext context, int x, int y, int z) {
-        Block from = context.get(x, y, z).getBlock();
+        IBlockState fromState = context.get(x, y, z);
+        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 && !((BlockSlab) fromDown.getBlock()).isDouble() && fromDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) {
+            if (fromDown.getBlock() instanceof BlockSlab && !fromDown.isTopSolid()) {
                 return COST_INF; // can't pillar up from a bottom slab onto a non ladder
             }
         }
@@ -70,9 +71,9 @@ public class MovementPillar extends Movement {
         if (toBreakBlock instanceof BlockFenceGate) { // see issue #172
             return COST_INF;
         }
-        Block srcUp = null;
-        if (MovementHelper.isWater(toBreakBlock) && MovementHelper.isWater(from)) { // TODO should this also be allowed if toBreakBlock is air?
-            srcUp = context.get(x, y + 1, z).getBlock();
+        IBlockState srcUp = null;
+        if (MovementHelper.isWater(toBreak) && MovementHelper.isWater(fromState)) { // TODO should this also be allowed if toBreakBlock is air?
+            srcUp = context.get(x, y + 1, z);
             if (MovementHelper.isWater(srcUp)) {
                 return LADDER_UP_ONE_COST; // allow ascending pillars of water, but only if we're already in one
             }
@@ -84,11 +85,11 @@ public class MovementPillar extends Movement {
             if (placeCost >= COST_INF) {
                 return COST_INF;
             }
-            if (fromDown.getBlock() == Blocks.AIR) {
+            if (fromDown.getBlock() instanceof BlockAir) {
                 placeCost += 0.1; // slightly (1/200th of a second) penalize pillaring on what's currently air
             }
         }
-        if (from instanceof BlockLiquid || (fromDown.getBlock() instanceof BlockLiquid && context.assumeWalkOnWater)) {
+        if ((MovementHelper.isLiquid(fromState) && !MovementHelper.canPlaceAgainst(context.bsi, x, y - 1, z, fromDown)) || (MovementHelper.isLiquid(fromDown) && 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
@@ -106,9 +107,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).getBlock();
+                        srcUp = context.get(x, y + 1, z);
                     }
-                    if (!(toBreakBlock instanceof BlockFalling) || !(srcUp instanceof BlockFalling)) {
+                    if (!(toBreakBlock instanceof BlockFalling) || !(srcUp.getBlock() instanceof BlockFalling)) {
                         return COST_INF;
                     }
                 }
@@ -163,7 +164,7 @@ public class MovementPillar extends Movement {
         }
 
         IBlockState fromDown = BlockStateInterface.get(ctx, src);
-        if (MovementHelper.isWater(fromDown.getBlock()) && MovementHelper.isWater(ctx, dest)) {
+        if (MovementHelper.isWater(fromDown) && 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);
@@ -177,7 +178,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().getPositionEyes(1.0F),
+        Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.player().getEyePosition(1.0F),
                 VecUtils.getBlockPosCenter(positionToPlace),
                 new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));
         if (!ladder) {
@@ -186,7 +187,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.getValue(BlockLadder.FACING).getOpposite());
+            BlockPos against = vine ? getAgainst(new CalculationContext(baritone), src) : src.offset(fromDown.get(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

@@ -30,12 +30,11 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockDoor;
-import net.minecraft.block.BlockFenceGate;
-import net.minecraft.block.BlockSlab;
+import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
+import net.minecraft.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;
 
@@ -67,11 +66,12 @@ 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);
-        Block srcDown = context.getBlock(x, y - 1, z);
+        IBlockState down = context.get(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.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
+            if (MovementHelper.isWater(pb0) || MovementHelper.isWater(pb1)) {
                 WC = context.waterWalkSpeed;
                 water = true;
             } else {
@@ -108,8 +108,8 @@ public class MovementTraverse extends Movement {
                 return COST_INF;
             }
             if (MovementHelper.isReplacable(destX, y - 1, destZ, destOn, context.bsi)) {
-                boolean throughWater = MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock());
-                if (MovementHelper.isWater(destOn.getBlock()) && throughWater) {
+                boolean throughWater = MovementHelper.isWater(pb0) || MovementHelper.isWater(pb1);
+                if (MovementHelper.isWater(destOn) && throughWater) {
                     // this happens when assume walk on water is true and this is a traverse in water, which isn't allowed
                     return COST_INF;
                 }
@@ -135,10 +135,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 && !((BlockSlab) srcDown).isDouble())) {
+                if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && down.get(BlockSlab.TYPE) != SlabType.DOUBLE)) {
                     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 (srcDown == Blocks.FLOWING_WATER || srcDown == Blocks.WATER) {
+                if (down.getFluidState() instanceof WaterFluid) {
                     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
@@ -151,6 +151,8 @@ public class MovementTraverse extends Movement {
     @Override
     public MovementState updateState(MovementState state) {
         super.updateState(state);
+        IBlockState pb0 = BlockStateInterface.get(ctx, positionsToBreak[0]);
+        IBlockState pb1 = BlockStateInterface.get(ctx, positionsToBreak[1]);
         if (state.getStatus() != MovementStatus.RUNNING) {
             // if the setting is enabled
             if (!Baritone.settings().walkWhileBreaking.value) {
@@ -161,10 +163,10 @@ public class MovementTraverse extends Movement {
                 return state;
             }
             // and if it's fine to walk into the blocks in front
-            if (MovementHelper.avoidWalkingInto(BlockStateInterface.get(ctx, positionsToBreak[0]).getBlock())) {
+            if (MovementHelper.avoidWalkingInto(pb0)) {
                 return state;
             }
-            if (MovementHelper.avoidWalkingInto(BlockStateInterface.get(ctx, positionsToBreak[1]).getBlock())) {
+            if (MovementHelper.avoidWalkingInto(pb1)) {
                 return state;
             }
             // and we aren't already pressed up against the block
@@ -177,6 +179,10 @@ public class MovementTraverse extends Movement {
             // it's safe to do this since the two blocks we break (in a traverse) are right on top of each other and so will have the same yaw
             float yawToDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), dest), ctx.playerRotations()).getYaw();
             float pitchToBreak = state.getTarget().getRotation().get().getPitch();
+            if ((pb0.isFullCube() || pb0.getBlock() instanceof BlockAir && (pb1.isFullCube() || pb1.getBlock() instanceof BlockAir))) {
+                // in the meantime, before we're right up against the block, we can break efficiently at this angle
+                pitchToBreak = 26;
+            }
 
             state.setTarget(new MovementState.MovementTarget(new Rotation(yawToDest, pitchToBreak), true));
             return state.setInput(Input.MOVE_FORWARD, true).setInput(Input.SPRINT, true);
@@ -187,8 +193,6 @@ public class MovementTraverse extends Movement {
 
         Block fd = BlockStateInterface.get(ctx, src.down()).getBlock();
         boolean ladder = fd == Blocks.LADDER || fd == Blocks.VINE;
-        IBlockState pb0 = BlockStateInterface.get(ctx, positionsToBreak[0]);
-        IBlockState pb1 = BlockStateInterface.get(ctx, positionsToBreak[1]);
 
         boolean door = pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor;
         if (door) {
@@ -240,8 +244,8 @@ public class MovementTraverse extends Movement {
                 return state;
             }
             BlockPos into = dest.subtract(src).add(dest);
-            Block intoBelow = BlockStateInterface.get(ctx, into).getBlock();
-            Block intoAbove = BlockStateInterface.get(ctx, into.up()).getBlock();
+            IBlockState intoBelow = BlockStateInterface.get(ctx, into);
+            IBlockState intoAbove = BlockStateInterface.get(ctx, into.up());
             if (wasTheBridgeBlockAlwaysThere && (!MovementHelper.isLiquid(ctx, ctx.playerFeet()) || Baritone.settings().sprintInWater.value) && (!MovementHelper.avoidWalkingInto(intoBelow) || MovementHelper.isWater(intoBelow)) && !MovementHelper.avoidWalkingInto(intoAbove)) {
                 state.setInput(Input.SPRINT, true);
             }

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

@@ -36,8 +36,8 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.movements.*;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
-import net.minecraft.block.BlockLiquid;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Fluids;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
@@ -137,7 +137,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.getFirst() + ". Threshold: " + MAX_DIST_FROM_PATH);
+            System.out.println("FAR AWAY FROM PATH FOR " + ticksAway + " TICKS. Current distance: " + status.getA() + ". Threshold: " + MAX_DIST_FROM_PATH);
             if (ticksAway > MAX_TICKS_AWAY) {
                 logDebug("Too far away from path for too long, cancelling path");
                 cancel();
@@ -333,7 +333,7 @@ public class PathExecutor implements IPathExecutor, Helper {
     }
 
     private boolean possiblyOffPath(Tuple<Double, BlockPos> status, double leniency) {
-        double distanceFromPath = status.getFirst();
+        double distanceFromPath = status.getA();
         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) {
@@ -353,7 +353,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().getBlockState(ctx.playerFeet()).getBlock() instanceof BlockLiquid)) {
+        if (!ctx.player().onGround && ctx.world().getFluidState(ctx.playerFeet()).isEmpty()) {
             // if we're falling in the air, and not in water, don't splice
             return false;
         } else {
@@ -453,7 +453,7 @@ public class PathExecutor implements IPathExecutor, Helper {
         if (current instanceof MovementFall) {
             Tuple<Vec3d, BlockPos> data = overrideFall((MovementFall) current);
             if (data != null) {
-                BlockPos fallDest = data.getSecond();
+                BlockPos fallDest = data.getB();
                 if (!path.positions().contains(fallDest)) {
                     throw new IllegalStateException();
                 }
@@ -464,7 +464,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                     return true;
                 }
                 clearKeys();
-                behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getFirst(), ctx.playerRotations()), false);
+                behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getA(), ctx.playerRotations()), false);
                 behavior.baritone.getInputOverrideHandler().setInputForceState(Input.MOVE_FORWARD, true);
                 return true;
             }
@@ -556,10 +556,10 @@ public class PathExecutor implements IPathExecutor, Helper {
                 }
             }
         }
-        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(current.getSrc().up(3)).getBlock())) {
+        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(current.getSrc().up(3)))) {
             return false;
         }
-        return !MovementHelper.avoidWalkingInto(ctx.world().getBlockState(next.getDest().up(2)).getBlock()); // codacy smh my head
+        return !MovementHelper.avoidWalkingInto(ctx.world().getBlockState(next.getDest().up(2))); // codacy smh my head
     }
 
     private static boolean canSprintFromDescendInto(IPlayerContext ctx, IMovement current, IMovement next) {

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

@@ -35,16 +35,20 @@ import baritone.utils.BlockStateInterface;
 import baritone.utils.PathingCommandContext;
 import baritone.utils.schematic.AirSchematic;
 import baritone.utils.schematic.Schematic;
+import net.minecraft.block.BlockAir;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 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;
@@ -56,18 +60,21 @@ import static baritone.api.pathing.movement.ActionCosts.COST_INF;
 
 public class BuilderProcess extends BaritoneProcessHelper implements IBuilderProcess {
 
+    private HashSet<BetterBlockPos> incorrectPositions;
+    private String name;
+    private ISchematic realSchematic;
+    private ISchematic schematic;
+    private Vec3i origin;
+    private int ticks;
+    private boolean paused;
+    private int layer;
+
     public BuilderProcess(Baritone baritone) {
         super(baritone);
     }
 
-    private HashSet<BetterBlockPos> incorrectPositions;
-    private String name;
-    private ISchematic schematic;
-    private Vec3i origin;
-    private int ticks;
-
     public boolean build(String schematicFile, BlockPos origin) {
-        File file = new File(new File(Minecraft.getMinecraft().gameDir, "schematics"), schematicFile);
+        File file = new File(new File(Minecraft.getInstance().gameDir, "schematics"), schematicFile);
         System.out.println(file + " " + file.exists());
         return build(schematicFile, file, origin);
     }
@@ -76,7 +83,14 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
     public void build(String name, ISchematic schematic, Vec3i origin) {
         this.name = name;
         this.schematic = schematic;
+        this.realSchematic = null;
         this.origin = origin;
+        this.paused = false;
+        this.layer = 0;
+    }
+
+    public void resume() {
+        paused = false;
     }
 
     @Override
@@ -120,7 +134,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
             return null;
         }
         IBlockState state = schematic.desiredState(x - origin.getX(), y - origin.getY(), z - origin.getZ());
-        if (state.getBlock() == Blocks.AIR) {
+        if (state.getBlock() instanceof BlockAir) {
             return null;
         }
         return state;
@@ -140,7 +154,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
                         continue; // irrelevant
                     }
                     IBlockState curr = bcc.bsi.get0(x, y, z);
-                    if (curr.getBlock() != Blocks.AIR && !valid(curr, desired)) {
+                    if (!(curr.getBlock() instanceof BlockAir) && !valid(curr, desired)) {
                         BetterBlockPos pos = new BetterBlockPos(x, y, z);
                         Optional<Rotation> rot = RotationUtils.reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
                         if (rot.isPresent()) {
@@ -154,10 +168,10 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
     }
 
     public class Placement {
-        final int hotbarSelection;
-        final BlockPos placeAgainst;
-        final EnumFacing side;
-        final Rotation rot;
+        private final int hotbarSelection;
+        private final BlockPos placeAgainst;
+        private final EnumFacing side;
+        private final Rotation rot;
 
         public Placement(int hotbarSelection, BlockPos placeAgainst, EnumFacing side, Rotation rot) {
             this.hotbarSelection = hotbarSelection;
@@ -181,7 +195,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
                     }
                     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() == Blocks.AIR) {
+                        if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() instanceof BlockAir) {
                             continue;
                         }
                         desirableOnHotbar.add(desired);
@@ -196,6 +210,11 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
         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()));
+    }
+
     public 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);
@@ -203,17 +222,20 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
             if (MovementHelper.isReplacable(placeAgainstPos.x, placeAgainstPos.y, placeAgainstPos.z, placeAgainstState, bsi)) {
                 continue;
             }
-            if (!ctx.world().mayPlace(toPlace.getBlock(), new BetterBlockPos(x, y, z), false, against, null)) {
+            if (!toPlace.isValidPosition(ctx.world(), new BetterBlockPos(x, y, z))) {
                 continue;
             }
-            AxisAlignedBB aabb = placeAgainstState.getBoundingBox(ctx.world(), placeAgainstPos);
+            if (!placementPlausible(new BetterBlockPos(x, y, z), toPlace)) {
+                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.typeOfHit == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(placeAgainstPos) && result.sideHit == against.getOpposite()) {
+                if (result != null && result.type == 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));
@@ -236,18 +258,24 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
             // the state depends on the facing of the player sometimes
             ctx.player().rotationYaw = rot.getYaw();
             ctx.player().rotationPitch = rot.getPitch();
-            IBlockState wouldBePlaced = ((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(
-                    ctx.world(),
+            BlockItemUseContext meme = new BlockItemUseContext(new ItemUseContext(
+                    ctx.player(),
+                    stack,
                     result.getBlockPos().offset(result.sideHit),
                     result.sideHit,
-                    (float) result.hitVec.x - result.getBlockPos().getX(), // as in PlayerControllerMP
+                    (float) result.hitVec.x - result.getBlockPos().getX(),
                     (float) result.hitVec.y - result.getBlockPos().getY(),
-                    (float) result.hitVec.z - result.getBlockPos().getZ(),
-                    stack.getItem().getMetadata(stack.getMetadata()),
-                    ctx.player()
-            );
+                    (float) result.hitVec.z - result.getBlockPos().getZ()
+            ));
+            IBlockState wouldBePlaced = ((ItemBlock) stack.getItem()).getBlock().getStateForPlacement(meme);
             ctx.player().rotationYaw = originalYaw;
             ctx.player().rotationPitch = originalPitch;
+            if (wouldBePlaced == null) {
+                continue;
+            }
+            if (!meme.canPlace()) {
+                continue;
+            }
             if (valid(wouldBePlaced, desired)) {
                 return OptionalInt.of(i);
             }
@@ -269,39 +297,77 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
                 double z = side.getZOffset() == 0 ? 0.5 : (1 + side.getZOffset()) / 2D;
                 return new Vec3d[]{new Vec3d(x, 0.25, z), new Vec3d(x, 0.75, z)};
             default: // null
-                throw new NullPointerException();
+                throw new IllegalStateException();
         }
     }
 
     @Override
     public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
-        // TODO somehow tell inventorybehavior what we'd like to have on the hotbar
-        // perhaps take the 16 closest positions in incorrectPositions to ctx.playerFeet that aren't desired to be air, and then snag the top 4 most common block states, then request those on the hotbar
-
-
-        // this will work as is, but it'll be trashy
-        // need to iterate over incorrectPositions and see which ones we can "correct" from our current standing position
-
-        baritone.getInputOverrideHandler().clearAllKeys();
-        BuilderCalculationContext bcc = new BuilderCalculationContext();
-        if (!recalc(bcc)) {
-            logDirect("Done building");
-            onLostControl();
-            return null;
-        }
-        trim(bcc);
         if (baritone.getInputOverrideHandler().isInputForcedDown(Input.CLICK_LEFT)) {
             ticks = 5;
         } else {
             ticks--;
         }
-        Optional<Tuple<BetterBlockPos, Rotation>> toBreak = toBreakNearPlayer(bcc);
         baritone.getInputOverrideHandler().clearAllKeys();
+        if (paused) {
+            return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
+        }
+        if (Baritone.settings().buildInLayers.value) {
+            if (realSchematic == null) {
+                realSchematic = schematic;
+            }
+            schematic = new ISchematic() {
+                @Override
+                public IBlockState desiredState(int x, int y, int z) {
+                    return realSchematic.desiredState(x, y, z);
+                }
+
+                @Override
+                public int widthX() {
+                    return realSchematic.widthX();
+                }
+
+                @Override
+                public int heightY() {
+                    return layer;
+                }
+
+                @Override
+                public int lengthZ() {
+                    return realSchematic.lengthZ();
+                }
+            };
+        }
+        BuilderCalculationContext bcc = new BuilderCalculationContext();
+        if (!recalc(bcc)) {
+            if (Baritone.settings().buildInLayers.value && layer < realSchematic.heightY()) {
+                logDirect("Starting layer " + layer);
+                layer++;
+                return onTick(calcFailed, isSafeToCancel);
+            }
+            int distance = Baritone.settings().buildRepeatDistance.value;
+            EnumFacing direction = Baritone.settings().buildRepeatDirection.value;
+            if (distance == 0) {
+                logDirect("Done building");
+                onLostControl();
+                return null;
+            }
+            // build repeat time
+            if (distance == -1) {
+                distance = schematic.size(direction.getAxis());
+            }
+            layer = 0;
+            origin = new BlockPos(origin).offset(direction, distance);
+            logDirect("Repeating build " + distance + " blocks to the " + direction + ", new origin is " + origin);
+        }
+        trim(bcc);
+
+        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().getSecond();
-            BetterBlockPos pos = toBreak.get().getFirst();
+            Rotation rot = toBreak.get().getB();
+            BetterBlockPos pos = toBreak.get().getA();
             baritone.getLookBehavior().updateTarget(rot, true);
             MovementHelper.switchToBestToolFor(ctx, bcc.get(pos));
             if (ctx.player().isSneaking()) {
@@ -359,9 +425,9 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
         if (goal == null) {
             goal = assemble(bcc, approxPlacable); // we're far away, so assume that we have our whole inventory to recalculate placable properly
             if (goal == null) {
-                logDirect("Unable to do it =(");
-                onLostControl();
-                return null;
+                logDirect("Unable to do it. Pausing. resume to resume, cancel to cancel");
+                paused = true;
+                return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
             }
         }
         return new PathingCommandContext(goal, PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH, bcc);
@@ -417,10 +483,8 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
         for (int y = 0; y < schematic.heightY(); y++) {
             for (int z = 0; z < schematic.lengthZ(); z++) {
                 for (int x = 0; x < schematic.widthX(); x++) {
-                    if (schematic.inSchematic(x, y, z)) {
-                        if (!valid(bcc.bsi.get0(x + origin.getX(), y + origin.getY(), z + origin.getZ()), schematic.desiredState(x, y, z))) {
-                            incorrectPositions.add(new BetterBlockPos(x + origin.getX(), y + origin.getY(), z + origin.getZ()));
-                        }
+                    if (schematic.inSchematic(x, y, z) && !valid(bcc.bsi.get0(x + origin.getX(), y + origin.getY(), z + origin.getZ()), schematic.desiredState(x, y, z))) {
+                        incorrectPositions.add(new BetterBlockPos(x + origin.getX(), y + origin.getY(), z + origin.getZ()));
                     }
                 }
             }
@@ -428,8 +492,8 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
     }
 
     private Goal assemble(BuilderCalculationContext bcc, List<IBlockState> approxPlacable) {
-        List<BetterBlockPos> placable = incorrectPositions.stream().filter(pos -> bcc.bsi.get0(pos).getBlock() == Blocks.AIR && approxPlacable.contains(bcc.getSchematic(pos.x, pos.y, pos.z))).collect(Collectors.toList());
-        Goal[] toBreak = incorrectPositions.stream().filter(pos -> bcc.bsi.get0(pos).getBlock() != Blocks.AIR).map(GoalBreak::new).toArray(Goal[]::new);
+        List<BetterBlockPos> placable = incorrectPositions.stream().filter(pos -> bcc.bsi.get0(pos).getBlock() instanceof BlockAir && approxPlacable.contains(bcc.getSchematic(pos.x, pos.y, pos.z))).collect(Collectors.toList());
+        Goal[] toBreak = incorrectPositions.stream().filter(pos -> !(bcc.bsi.get0(pos).getBlock() instanceof BlockAir)).map(GoalBreak::new).toArray(Goal[]::new);
         Goal[] toPlace = placable.stream().filter(pos -> !placable.contains(pos.down()) && !placable.contains(pos.down(2))).map(pos -> placementgoal(pos, bcc)).toArray(Goal[]::new);
 
         if (toPlace.length != 0) {
@@ -485,12 +549,12 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
     }
 
     public Goal placementgoal(BlockPos pos, BuilderCalculationContext bcc) {
-        if (ctx.world().getBlockState(pos).getBlock() != Blocks.AIR) {
+        if (!(ctx.world().getBlockState(pos).getBlock() instanceof BlockAir)) {
             return new GoalPlace(pos);
         }
-        boolean allowSameLevel = ctx.world().getBlockState(pos.up()).getBlock() != Blocks.AIR;
+        boolean allowSameLevel = !(ctx.world().getBlockState(pos.up()).getBlock() instanceof BlockAir);
         for (EnumFacing facing : Movement.HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP) {
-            if (MovementHelper.canPlaceAgainst(ctx, pos.offset(facing)) && ctx.world().mayPlace(bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()).getBlock(), pos, false, facing, null)) {
+            if (MovementHelper.canPlaceAgainst(ctx, pos.offset(facing)) && placementPlausible(pos, bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()))) {
                 return new GoalAdjacent(pos, allowSameLevel);
             }
         }
@@ -498,7 +562,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
     }
 
     public static class GoalAdjacent extends GoalGetToBlock {
-        boolean allowSameLevel;
+        private boolean allowSameLevel;
 
         public GoalAdjacent(BlockPos pos, boolean allowSameLevel) {
             super(pos);
@@ -540,11 +604,14 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
         incorrectPositions = null;
         name = null;
         schematic = null;
+        realSchematic = null;
+        layer = 0;
+        paused = false;
     }
 
     @Override
     public String displayName0() {
-        return "Building " + name;
+        return paused ? "Builder Paused" : "Building " + name;
     }
 
     public List<IBlockState> placable(int size) {
@@ -556,15 +623,21 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
                 continue;
             }
             // <toxic cloud>
-            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()));
+            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))));
             // </toxic cloud>
         }
         return result;
     }
 
     public 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 desired == null || current.equals(desired);
+        return current.equals(desired);
     }
 
     public class BuilderCalculationContext extends CalculationContext {
@@ -602,7 +675,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
             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() == Blocks.AIR) {
+                if (sch.getBlock() instanceof BlockAir) {
                     // 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
@@ -635,7 +708,7 @@ public class BuilderProcess extends BaritoneProcessHelper implements IBuilderPro
             }
             IBlockState sch = getSchematic(x, y, z);
             if (sch != null) {
-                if (sch.getBlock() == Blocks.AIR) {
+                if (sch.getBlock() instanceof BlockAir) {
                     // it should be air
                     // regardless of current contents, we can break it
                     return 1;

src/main/java/baritone/process/CustomGoalProcess.java

@@ -90,6 +90,9 @@ public class CustomGoalProcess extends BaritoneProcessHelper implements ICustomG
                 }
                 if (this.goal == null || (this.goal.isInGoal(ctx.playerFeet()) && this.goal.isInGoal(baritone.getPathingBehavior().pathStart()))) {
                     onLostControl(); // we're there xd
+                    if (Baritone.settings().disconnectOnArrival.value) {
+                        ctx.world().sendQuittingDisconnectingPacket();
+                    }
                     return new PathingCommand(this.goal, PathingCommandType.CANCEL_AND_SET_GOAL);
                 }
                 return new PathingCommand(this.goal, PathingCommandType.SET_GOAL_AND_PATH);

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.isDead) {
+        if (!entity.isAlive()) {
             return false;
         }
         if (entity.equals(ctx.player())) {

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

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

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

@@ -32,6 +32,7 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
 import net.minecraft.block.Block;
+import net.minecraft.block.BlockAir;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.init.Blocks;
@@ -72,22 +73,23 @@ 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(), new Random(), 0);
+            Item item = mining.get(0).getItemDropped(mining.get(0).getDefaultState(), ctx.world(), null, 0).asItem();
             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.getItemStackDisplayName(new ItemStack(item, 1)));
+                logDirect("Have " + curr + " " + item.getDisplayName(new ItemStack(item, 1)));
                 cancel();
                 return null;
             }
         }
+        boolean shouldCancel = calcFailed;
         if (calcFailed && !knownOreLocations.isEmpty() && Baritone.settings().blacklistClosestOnFailure.value) {
             logDirect("Unable to find any path to " + mining + ", blacklisting presumably unreachable closest instance...");
-            knownOreLocations.stream().sorted(Comparator.comparingDouble(ctx.player()::getDistanceSq)).findFirst().ifPresent(blacklist::add);
+            knownOreLocations.stream().min(Comparator.comparingDouble(ctx.player()::getDistanceSq)).ifPresent(blacklist::add);
             knownOreLocations.removeIf(blacklist::contains);
-            calcFailed = false; // 😎
+            shouldCancel = false; // 😎
         }
-        if (calcFailed) {
+        if (shouldCancel) {
             logDirect("Unable to find any path to " + mining + ", canceling Mine");
             cancel();
             return null;
@@ -183,8 +185,8 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         }
 
         // Here, BlockStateInterface is used because the position may be in a cached chunk (the targeted block is one that is kept track of)
-        boolean upwardGoal = locs.contains(loc.up()) || (Baritone.settings().internalMiningAirException.value && BlockStateInterface.getBlock(ctx, loc.up()) == Blocks.AIR);
-        boolean downwardGoal = locs.contains(loc.down()) || (Baritone.settings().internalMiningAirException.value && BlockStateInterface.getBlock(ctx, loc.down()) == Blocks.AIR);
+        boolean upwardGoal = locs.contains(loc.up()) || (Baritone.settings().internalMiningAirException.value && BlockStateInterface.getBlock(ctx, loc.up()) instanceof BlockAir);
+        boolean downwardGoal = locs.contains(loc.down()) || (Baritone.settings().internalMiningAirException.value && BlockStateInterface.getBlock(ctx, loc.down()) instanceof BlockAir);
         return upwardGoal == downwardGoal ? new GoalTwoBlocks(loc) : upwardGoal ? new GoalBlock(loc) : new GoalBlock(loc.down());
     }
 
@@ -194,8 +196,8 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         }
         Set<Item> searchingFor = new HashSet<>();
         for (Block block : mining) {
-            Item drop = block.getItemDropped(block.getDefaultState(), new Random(), 0);
-            Item ore = Item.getItemFromBlock(block);
+            Item drop = block.getItemDropped(block.getDefaultState(), world, null, 0).asItem();
+            Item ore = block.asItem();
             searchingFor.add(drop);
             searchingFor.add(ore);
         }

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

@@ -23,14 +23,21 @@ import baritone.api.event.listener.AbstractGameEventListener;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalBlock;
 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
@@ -88,11 +95,13 @@ 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 (mc.getIntegratedServer() != null && mc.getIntegratedServer().worlds[0] != null) {
-            mc.getIntegratedServer().worlds[0].setSpawnPoint(STARTING_POSITION);
-            mc.getIntegratedServer().worlds[0].getGameRules().setOrCreateGameRule("spawnRadius", "0");
+        if (server != null && server.getWorld(DimensionType.OVERWORLD) != null) {
+            server.getWorld(DimensionType.OVERWORLD).setSpawnPoint(STARTING_POSITION);
+            server.getWorld(DimensionType.OVERWORLD).getGameRules().setOrCreateGameRule("spawnRadius", "0", server);
         }
 
         if (event.getType() == TickEvent.Type.IN) { // If we're in-game
@@ -100,7 +109,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);
+                mc.getIntegratedServer().shareToLAN(GameType.getByName("survival"), false, HttpUtil.getSuitableLanPort());
             }
 
             // For the first 200 ticks, wait for the world to generate
@@ -122,7 +131,16 @@ 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

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

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

@@ -37,7 +37,7 @@ public class BlockPlaceHelper implements Helper {
             return;
         }
         RayTraceResult mouseOver = ctx.objectMouseOver();
-        if (!rightClickRequested || ctx.player().isRowingBoat() || mouseOver == null || mouseOver.getBlockPos() == null || mouseOver.typeOfHit != RayTraceResult.Type.BLOCK) {
+        if (!rightClickRequested || ctx.player().isRowingBoat() || mouseOver == null || mouseOver.getBlockPos() == null || mouseOver.type != 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.getMinecraft().isCallingFromMinecraftThread()) {
+        if (!Minecraft.getInstance().isCallingFromMinecraftThread()) {
             throw new IllegalStateException();
         }
     }

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

@@ -256,7 +256,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             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);
+                    Chunk chunk = cli.getChunk(x, z, false, false);
                     if (chunk != null) {
                         count++;
                         baritone.getWorldProvider().getCurrentWorld().getCachedWorld().queueForPacking(chunk);
@@ -353,6 +353,11 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             baritone.getBuilderProcess().clearArea(corner1, corner2);
             return true;
         }
+        if (msg.equals("resume")) {
+            baritone.getBuilderProcess().resume();
+            logDirect("resumed");
+            return true;
+        }
         if (msg.equals("reset")) {
             for (Settings.Setting setting : Baritone.settings().allSettings) {
                 setting.reset();
@@ -361,9 +366,14 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             logDirect("Baritone settings reset");
             return true;
         }
+        if (msg.equals("tunnel")) {
+            customGoalProcess.setGoalAndPath(new GoalStrictDirection(ctx.playerFeet(), ctx.player().getHorizontalFacing()));
+            logDirect("tunneling");
+            return true;
+        }
         if (msg.equals("render")) {
             BetterBlockPos pf = ctx.playerFeet();
-            Minecraft.getMinecraft().renderGlobal.markBlockRangeForRenderUpdate(pf.x - 500, pf.y - 500, pf.z - 500, pf.x + 500, pf.y + 500, pf.z + 500);
+            Minecraft.getInstance().worldRenderer.markBlockRangeForRenderUpdate(pf.x - 500, pf.y - 500, pf.z - 500, pf.x + 500, pf.y + 500, pf.z + 500);
             logDirect("okay");
             return true;
         }
@@ -406,8 +416,8 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
                 toFollow = ctx.getSelectedEntity();
             } else {
                 for (EntityPlayer pl : ctx.world().playerEntities) {
-                    String theirName = pl.getName().trim().toLowerCase();
-                    if (!theirName.equals(ctx.player().getName().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
+                    String theirName = pl.getName().getString().trim().toLowerCase();
+                    if (!theirName.equals(ctx.player().getName().getString().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
                         toFollow = Optional.of(pl);
                     }
                 }
@@ -639,7 +649,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
     private void log(List<ItemStack> stacks) {
         for (ItemStack stack : stacks) {
             if (!stack.isEmpty()) {
-                logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getItemDamage());
+                logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getDamage());
             }
         }
     }

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

@@ -25,13 +25,9 @@ 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.AxisAlignedBB;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.*;
 import org.lwjgl.BufferUtils;
-import org.lwjgl.input.Mouse;
-import org.lwjgl.util.glu.GLU;
+import org.lwjgl.opengl.GL11;
 
 import java.awt.*;
 import java.nio.FloatBuffer;
@@ -57,15 +53,18 @@ public class GuiClick extends GuiScreen {
     }
 
     @Override
-    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
-        int mx = Mouse.getX();
-        int my = Mouse.getY();
+    public void render(int mouseX, int mouseY, float partialTicks) {
+        double mx = mc.mouseHelper.getMouseX();
+        double my = mc.mouseHelper.getMouseY();
+        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), false, false, true);
-            if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
+            RayTraceResult result = mc.world.rayTraceBlocks(near.add(viewerPos), far.add(viewerPos), RayTraceFluidMode.NEVER, false, true);
+            if (result != null && result.type == RayTraceResult.Type.BLOCK) {
                 currentMouseOver = result.getBlockPos();
             }
         }
@@ -73,7 +72,7 @@ public class GuiClick extends GuiScreen {
     }
 
     @Override
-    protected void mouseReleased(int mouseX, int mouseY, int mouseButton) {
+    public boolean mouseReleased(double mouseX, double mouseY, int mouseButton) {
         if (mouseButton == 0) {
             if (clickStart != null && !clickStart.equals(currentMouseOver)) {
                 ((Baritone) BaritoneAPI.getProvider().getPrimaryBaritone()).getBuilderProcess().clearArea(clickStart, currentMouseOver);
@@ -85,18 +84,19 @@ public class GuiClick extends GuiScreen {
             BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAndPath(new GoalBlock(currentMouseOver.up()));
         }
         clickStart = null;
+        return super.mouseReleased(mouseX, mouseY, mouseButton);
     }
 
-
     @Override
-    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) {
+    public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
         clickStart = currentMouseOver;
+        return super.mouseClicked(mouseX, mouseY, mouseButton);
     }
 
     public void onRender() {
-        GlStateManager.getFloat(GL_MODELVIEW_MATRIX, (FloatBuffer) MODELVIEW.clear());
-        GlStateManager.getFloat(GL_PROJECTION_MATRIX, (FloatBuffer) PROJECTION.clear());
-        GlStateManager.glGetInteger(GL_VIEWPORT, (IntBuffer) VIEWPORT.clear());
+        GlStateManager.getFloatv(GL_MODELVIEW_MATRIX, (FloatBuffer) MODELVIEW.clear());
+        GlStateManager.getFloatv(GL_PROJECTION_MATRIX, (FloatBuffer) PROJECTION.clear());
+        GL11.glGetIntegerv(GL_VIEWPORT, (IntBuffer) VIEWPORT.clear());
 
         if (currentMouseOver != null) {
             Entity e = mc.getRenderViewEntity();
@@ -104,31 +104,213 @@ public class GuiClick extends GuiScreen {
             PathRenderer.drawManySelectionBoxes(e, Collections.singletonList(currentMouseOver), Color.CYAN);
             if (clickStart != null && !clickStart.equals(currentMouseOver)) {
                 GlStateManager.enableBlend();
-                GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
-                GlStateManager.color(Color.RED.getColorComponents(null)[0], Color.RED.getColorComponents(null)[1], Color.RED.getColorComponents(null)[2], 0.4F);
-                GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+                GlStateManager.blendFuncSeparate(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.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
                 GlStateManager.disableTexture2D();
                 GlStateManager.depthMask(false);
-                GlStateManager.disableDepth();
+                GlStateManager.disableDepthTest();
                 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.enableDepth();
+                GlStateManager.enableDepthTest();
 
                 GlStateManager.depthMask(true);
                 GlStateManager.enableTexture2D();
                 GlStateManager.disableBlend();
             }
         }
-
-
     }
 
     public Vec3d toWorld(double x, double y, double z) {
-        boolean result = GLU.gluUnProject((float) x, (float) y, (float) z, MODELVIEW, PROJECTION, VIEWPORT, (FloatBuffer) TO_WORLD_BUFFER.clear());
+        boolean result = 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/Helper.java

@@ -42,7 +42,7 @@ public interface Helper {
             TextFormatting.GRAY
     ));
 
-    Minecraft mc = Minecraft.getMinecraft();
+    Minecraft mc = Minecraft.getInstance();
 
     /**
      * 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.createCopy();
+        ITextComponent component = MESSAGE_PREFIX.shallowCopy();
         component.getStyle().setColor(TextFormatting.GRAY);
         component.appendSibling(new TextComponentString(" " + message));
-        Minecraft.getMinecraft().addScheduledTask(() -> Baritone.settings().logger.value.accept(component));
+        Minecraft.getInstance().addScheduledTask(() -> Baritone.settings().logger.value.accept(component));
     }
 }

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.getMinecraft().gameSettings);
+                ctx.player().movementInput = new MovementInputFromOptions(Minecraft.getInstance().gameSettings);
             }
         }
         // only set it if it was previously incorrect

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

@@ -33,10 +33,12 @@ 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.init.Blocks;
+import net.minecraft.util.ResourceLocation;
 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;
@@ -51,6 +53,7 @@ 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();
 
@@ -63,8 +66,8 @@ public final class PathRenderer implements Helper {
             ((GuiClick) mc.currentScreen).onRender();
         }
 
-        int thisPlayerDimension = behavior.baritone.getPlayerContext().world().provider.getDimensionType().getId();
-        int currentRenderViewDimension = BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext().world().provider.getDimensionType().getId();
+        int thisPlayerDimension = behavior.baritone.getPlayerContext().world().getDimension().getType().getId();
+        int currentRenderViewDimension = BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext().world().getDimension().getType().getId();
 
         if (thisPlayerDimension != currentRenderViewDimension) {
             // this is a path for a bot in a different dimension, don't render it
@@ -83,17 +86,22 @@ public final class PathRenderer implements Helper {
         if (goal != null && Baritone.settings().renderGoal.value) {
             drawDankLitGoalBox(renderView, goal, partialTicks, Baritone.settings().colorGoalBox.value);
         }
+
         if (!Baritone.settings().renderPath.value) {
             return;
         }
+        PathExecutor current = behavior.getCurrent(); // this should prevent most race conditions?
+        PathExecutor next = behavior.getNext(); // like, now it's not possible for current!=null to be true, then suddenly false because of another thread
+        if (current != null && Baritone.settings().renderSelectionBoxes.value) {
+            drawManySelectionBoxes(renderView, current.toBreak(), Baritone.settings().colorBlocksToBreak.value);
+            drawManySelectionBoxes(renderView, current.toPlace(), Baritone.settings().colorBlocksToPlace.value);
+            drawManySelectionBoxes(renderView, current.toWalkInto(), Baritone.settings().colorBlocksToWalkInto.value);
+        }
 
         //drawManySelectionBoxes(player, Collections.singletonList(behavior.pathStart()), partialTicks, Color.WHITE);
         //long start = System.nanoTime();
 
 
-        PathExecutor current = behavior.getCurrent(); // this should prevent most race conditions?
-        PathExecutor next = behavior.getNext(); // like, now it's not possible for current!=null to be true, then suddenly false because of another thread
-
         // Render the current path, if there is one
         if (current != null && current.getPath() != null) {
             int renderBegin = Math.max(current.getPosition() - 3, 0);
@@ -104,11 +112,6 @@ public final class PathRenderer implements Helper {
         }
 
         //long split = System.nanoTime();
-        if (current != null) {
-            drawManySelectionBoxes(renderView, current.toBreak(), Baritone.settings().colorBlocksToBreak.value);
-            drawManySelectionBoxes(renderView, current.toPlace(), Baritone.settings().colorBlocksToPlace.value);
-            drawManySelectionBoxes(renderView, current.toWalkInto(), Baritone.settings().colorBlocksToWalkInto.value);
-        }
 
         // If there is a path calculation currently running, render the path calculation process
         behavior.getInProgress().ifPresent(currentlyRunning -> {
@@ -130,13 +133,13 @@ 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.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
-        GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
+        GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
         if (Baritone.settings().renderPathIgnoreDepth.value) {
-            GlStateManager.disableDepth();
+            GlStateManager.disableDepthTest();
         }
         List<BetterBlockPos> positions = path.positions();
         int next;
@@ -173,13 +176,13 @@ public final class PathRenderer implements Helper {
                     }
                     alpha = 0.4F * (1.0F - (float) (i - fadeStart) / (float) (fadeEnd - fadeStart));
                 }
-                GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], alpha);
+                GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], alpha);
             }
-            drawLine(player, x1, y1, z1, x2, y2, z2);
+            drawLine(x1, y1, z1, x2, y2, z2);
             tessellator.draw();
         }
         if (Baritone.settings().renderPathIgnoreDepth.value) {
-            GlStateManager.enableDepth();
+            GlStateManager.enableDepthTest();
         }
         //GlStateManager.color(0.0f, 0.0f, 0.0f, 0.4f);
         GlStateManager.depthMask(true);
@@ -187,7 +190,7 @@ public final class PathRenderer implements Helper {
         GlStateManager.disableBlend();
     }
 
-    public static void drawLine(Entity player, double bp1x, double bp1y, double bp1z, double bp2x, double bp2y, double bp2z) {
+    public static void drawLine(double bp1x, double bp1y, double bp1z, double bp2x, double bp2y, double bp2z) {
         double d0 = mc.getRenderManager().viewerPosX;
         double d1 = mc.getRenderManager().viewerPosY;
         double d2 = mc.getRenderManager().viewerPosZ;
@@ -201,14 +204,14 @@ public final class PathRenderer implements Helper {
 
     public static void drawManySelectionBoxes(Entity player, Collection<BlockPos> positions, Color color) {
         GlStateManager.enableBlend();
-        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
-        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
-        GlStateManager.glLineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
+        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
+        GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
 
         if (Baritone.settings().renderSelectionBoxesIgnoreDepth.value) {
-            GlStateManager.disableDepth();
+            GlStateManager.disableDepthTest();
         }
 
 
@@ -216,17 +219,14 @@ 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);
-            AxisAlignedBB toDraw;
-            if (state.getBlock().equals(Blocks.AIR)) {
-                toDraw = Blocks.DIRT.getDefaultState().getSelectedBoundingBox(player.world, pos);
-            } else {
-                toDraw = state.getSelectedBoundingBox(player.world, pos);
-            }
+            VoxelShape shape = state.getShape(player.world, pos);
+            AxisAlignedBB toDraw = shape.isEmpty() ? VoxelShapes.fullCube().getBoundingBox() : shape.getBoundingBox();
+            toDraw = toDraw.offset(pos);
             drawAABB(toDraw);
         });
 
         if (Baritone.settings().renderSelectionBoxesIgnoreDepth.value) {
-            GlStateManager.enableDepth();
+            GlStateManager.enableDepthTest();
         }
 
         GlStateManager.depthMask(true);
@@ -300,10 +300,10 @@ public final class PathRenderer implements Helper {
             if (Baritone.settings().renderGoalXZBeacon.value) {
                 glPushAttrib(GL_LIGHTING_BIT);
 
-                mc.getTextureManager().bindTexture(TileEntityBeaconRenderer.TEXTURE_BEACON_BEAM);
+                mc.getTextureManager().bindTexture(TEXTURE_BEACON_BEAM);
 
                 if (Baritone.settings().renderGoalIgnoreDepth.value) {
-                    GlStateManager.disableDepth();
+                    GlStateManager.disableDepthTest();
                 }
 
                 TileEntityBeaconRenderer.renderBeamSegment(
@@ -312,14 +312,18 @@ public final class PathRenderer implements Helper {
                         goalPos.getZ() - renderPosZ,
                         partialTicks,
                         1.0,
-                        player.world.getTotalWorldTime(),
+                        player.world.getGameTime(),
                         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.enableDepth();
+                    GlStateManager.enableDepthTest();
                 }
 
                 glPopAttrib();
@@ -345,13 +349,13 @@ public final class PathRenderer implements Helper {
         }
 
         GlStateManager.enableBlend();
-        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
-        GlStateManager.color(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.6F);
-        GlStateManager.glLineWidth(Baritone.settings().goalRenderLineWidthPixels.value);
+        GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.6F);
+        GlStateManager.lineWidth(Baritone.settings().goalRenderLineWidthPixels.value);
         GlStateManager.disableTexture2D();
         GlStateManager.depthMask(false);
         if (Baritone.settings().renderGoalIgnoreDepth.value) {
-            GlStateManager.disableDepth();
+            GlStateManager.disableDepthTest();
         }
 
         renderHorizontalQuad(minX, maxX, minZ, maxZ, y1);
@@ -369,7 +373,7 @@ public final class PathRenderer implements Helper {
         TESSELLATOR.draw();
 
         if (Baritone.settings().renderGoalIgnoreDepth.value) {
-            GlStateManager.enableDepth();
+            GlStateManager.enableDepthTest();
         }
         GlStateManager.depthMask(true);
         GlStateManager.enableTexture2D();

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

@@ -24,7 +24,6 @@ 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;
 
@@ -75,19 +74,13 @@ public class ToolSet {
     }
 
     /**
-     * Evaluate the material cost of a possible tool. The priority matches the
-     * listed order in the Item.ToolMaterial enum.
+     * Evaluate the material cost of a possible tool. Will return 1 for tools, -1 for other
      *
      * @param itemStack a possibly empty ItemStack
-     * @return values range from -1 to 4
+     * @return Either 1 or -1
      */
     private int getMaterialCost(ItemStack itemStack) {
-        if (itemStack.getItem() instanceof ItemTool) {
-            ItemTool tool = (ItemTool) itemStack.getItem();
-            return ToolMaterial.valueOf(tool.getToolMaterialName()).ordinal();
-        } else {
-            return -1;
-        }
+        return itemStack.getItem() instanceof ItemTool ? 1 : -1;
     }
 
     /**

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

@@ -17,12 +17,10 @@
 
 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

@@ -17,8 +17,8 @@
 
 package baritone.utils.schematic;
 
+import net.minecraft.block.BlockAir;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.init.Blocks;
 import net.minecraft.nbt.NBTTagCompound;
 
 import java.util.OptionalInt;
@@ -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 != Blocks.AIR);
+                OptionalInt lowestBlockY = lastIndexMatching(column, block -> !(block instanceof BlockAir));
                 if (lowestBlockY.isPresent()) {
                     heightMap[x][z] = lowestBlockY.getAsInt();
                 } else {

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

@@ -18,7 +18,6 @@
 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;
 
@@ -29,7 +28,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);
         }
@@ -64,7 +63,8 @@ public class Schematic implements ISchematic {
                     states[x][z][y] = block.getStateFromMeta(meta);
                 }
             }
-        }
+        }*/
+        throw new UnsupportedOperationException("1.13 be like: numeric IDs btfo");
     }
 
     @Override