v1.3.2

Merge branch 'master' into 1.13.2
fix dummy merge typo
2019-05-16 14:57:26 -07:00 · 2019-05-16 14:55:37 -07:00 · 2019-05-02 11:42:49 -07:00 · 2019-05-01 23:12:19 -07:00 · 2019-05-01 12:15:31 -07:00 · 2019-04-16 20:15:51 -05:00
90 changed files with 1194 additions and 1162 deletions
@@ -11,6 +11,8 @@ build/
 classes/
 *.class

+/out
+
 # IntelliJ Files
 .idea/
 *.iml
@@ -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
@@ -4,9 +4,6 @@
 [![License](https://img.shields.io/badge/license-LGPL--3.0%20with%20anime%20exception-green.svg)](LICENSE)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/a73d037823b64a5faf597a18d71e3400)](https://www.codacy.com/app/leijurv/baritone?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=cabaletta/baritone&amp;utm_campaign=Badge_Grade)
 [![HitCount](http://hits.dwyl.com/cabaletta/baritone.svg)](http://hits.dwyl.com/cabaletta/baritone)
-[![GitHub All Releases](https://img.shields.io/github/downloads/cabaletta/baritone/total.svg)](https://github.com/cabaletta/baritone/releases)
-[![Minecraft](https://img.shields.io/badge/MC-1.12.2-green.svg)](https://github.com/cabaletta/baritone/tree/master/)
-[![Minecraft](https://img.shields.io/badge/MC-1.13.2-brightgreen.svg)](https://github.com/cabaletta/baritone/tree/1.13.2/)
 [![Code of Conduct](https://img.shields.io/badge/%E2%9D%A4-code%20of%20conduct-blue.svg?style=flat)](https://github.com/cabaletta/baritone/blob/master/CODE_OF_CONDUCT.md)
 [![Known Vulnerabilities](https://snyk.io/test/github/cabaletta/baritone/badge.svg?targetFile=build.gradle)](https://snyk.io/test/github/cabaletta/baritone?targetFile=build.gradle)
 [![Contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/cabaletta/baritone/issues)
@@ -15,26 +12,26 @@
 [![Pull Requests](https://img.shields.io/github/issues-pr/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/pulls/)
 ![Code size](https://img.shields.io/github/languages/code-size/cabaletta/baritone.svg)
 ![GitHub repo size](https://img.shields.io/github/repo-size/cabaletta/baritone.svg)
-![Lines of Code](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
+![](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
+[![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.6%20/%20v1.3.2-brightgreen.svg)](https://impactdevelopment.github.io/)
-[![ForgeHax integration](https://img.shields.io/badge/ForgeHax%20%22integration%22-scuffed-yellow.svg)](https://github.com/fr1kin/ForgeHax/)
+[![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/)
-[![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/)
+[![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. 

 Baritone is the pathfinding system used in [Impact](https://impactdevelopment.github.io/) since 4.4. There's a [showcase video](https://www.youtube.com/watch?v=yI8hgW_m6dQ) made by @Adovin#3153 on Baritone's integration into Impact. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a video I made showing off what it can do.

-The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the forge jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
-
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
-the original version of the bot for Minecraft 1.8.9, rebuilt for 1.12.2 and 1.13.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
+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 11 months =D 🦀
+Have committed at least once a day for the last 8 months =D 🦀

 1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2

@@ -50,11 +47,11 @@ Here are some links to help to get started:

 - [Settings](https://baritone.leijurv.com/baritone/api/Settings.html#field.detail)

- [Usage (chat control)](USAGE.md)
+- [Baritone chat control usage](USAGE.md)

 # API

-The API is heavily documented, you can find the Javadocs for the latest release [here](https://baritone.leijurv.com/).
+The API is heavily documented, you can find the Javadocs for the latest release [here](https://baritone.leijurv.com).
 Please note that usage of anything located outside of the ``baritone.api`` package is not supported by the API release
 jar.

@@ -71,7 +68,7 @@ BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAnd

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

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

 ## How is it so fast?

@@ -1,9 +1,5 @@
 # Installation

-The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone.
-
-Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
-
 ## 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 `backfill-2` branch for example, you'll have to build it yourself)

@@ -2,20 +2,30 @@

 # Prefix

-Baritone's chat control prefix is `#` by default. In Impact, you can also use `.b` as a prefix. (for example, `.b click` instead of `#click`)
+Baritone commands can by default be typed in the chatbox. However if you make a typo, like typing "gola 10000 10000" instead of goal it goes into public chat, which is bad.
+
+Therefore you can use a prefix before your messages.
+
+On Baritone v1.1.0 and newer: The prefix is `#` by default. Anything beginning with `#` isn't sent, and is only interpreted by Baritone.
+For older than v1.1.0, `#` must be enabled by toggling on the `prefix` setting.
+
+**Only** in Impact is `.b` also a valid prefix. In 4.4, `#` does **not** work, neither does saying the commands directly in chat. `#` works by default in 4.5 (not 4.4).
+
+Other clients like Kami and Asuna have their own custom things (like `-path`), and can disable direct chat control entirely.

-Baritone commands can also by default be typed in the chatbox. However if you make a typo, like typing "gola 10000 10000" instead of "goal" it goes into public chat, which is bad, so using `#` is suggested.

-To disable direct chat control (with no prefix), turn off the `chatControl` setting. To disable chat control with the `#` prefix, turn off the `prefixControl` setting. In Impact, `.b` cannot be disabled. Be careful that you don't leave yourself with all control methods disabled (if you do, reset your settings by deleting the file `minecraft/baritone/settings.txt` and relaunching).

 # Commands

 **All** of these commands may need a prefix before them, as above ^.

-`help` for (rudimentary) help. You can see what it says [here](https://github.com/cabaletta/baritone/blob/master/src/api/java/baritone/api/utils/ExampleBaritoneControl.java#L47).
+`help` for (rudimentary) help. You can see what it says [here](https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java#L53).

 To toggle a boolean setting, just say its name in chat (for example saying `allowBreak` toggles whether Baritone will consider breaking blocks). For a numeric setting, say its name then the new value (like `primaryTimeoutMS 250`). It's case insensitive. To reset a setting to its default value, say `acceptableThrowawayItems reset`. To reset all settings, say `reset`. To see all settings that have been modified from their default values, say `modified`.

+
+
+
 Some common examples:
 - `thisway 1000` then `path` to go in the direction you're facing for a thousand blocks
 - `goal x y z` or `goal x z` or `goal y`, then `path` to go to a certain coordinate
@@ -37,7 +47,7 @@ Some common examples:
 - `damn` daniel


-For the rest of the commands, you can take a look at the code [here](https://github.com/cabaletta/baritone/blob/master/src/api/java/baritone/api/utils/ExampleBaritoneControl.java).
+For the rest of the commands, you can take a look at the code [here](https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java).

 All the settings and documentation are <a href="https://github.com/cabaletta/baritone/blob/master/src/api/java/baritone/api/Settings.java">here</a>. If you find HTML easier to read than Javadoc, you can look <a href="https://baritone.leijurv.com/baritone/api/Settings.html#field.detail">here</a>.

@@ -16,33 +16,33 @@
 */

 group 'baritone'
-version '1.2.7'
+version '1.3.2'

 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'
 }

@@ -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);

@@ -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());

@@ -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() {
@@ -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();
        }
    }
@@ -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
-}
@@ -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);
-        }
-    }
-}
@@ -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

@@ -31,56 +33,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 * {
@@ -144,10 +144,10 @@ public final class Settings {
     * Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)
     */
    public final Setting<List<Item>> acceptableThrowawayItems = new Setting<>(new ArrayList<>(Arrays.asList(
-            Item.getItemFromBlock(Blocks.DIRT),
-            Item.getItemFromBlock(Blocks.COBBLESTONE),
-            Item.getItemFromBlock(Blocks.NETHERRACK),
-            Item.getItemFromBlock(Blocks.STONE)
+            Blocks.DIRT.asItem(),
+            Blocks.COBBLESTONE.asItem(),
+            Blocks.NETHERRACK.asItem(),
+            Blocks.STONE.asItem()
    )));

    /**
@@ -163,7 +163,6 @@ public final class Settings {
    public final Setting<List<Block>> blocksToAvoidBreaking = new Setting<>(new ArrayList<>(Arrays.asList( // TODO can this be a HashSet or ImmutableSet?
            Blocks.CRAFTING_TABLE,
            Blocks.FURNACE,
-            Blocks.LIT_FURNACE,
            Blocks.CHEST,
            Blocks.TRAPPED_CHEST
    )));
@@ -808,7 +807,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 size of the box that is rendered when the current goal is a GoalYLevel
@@ -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);

@@ -50,7 +50,7 @@ public interface IBuilderProcess extends IBaritoneProcess {
    boolean build(String name, File schematic, Vec3i origin);

    default boolean build(String schematicFile, BlockPos origin) {
-        File file = new File(new File(Minecraft.getMinecraft().gameDir, "schematics"), schematicFile);
+        File file = new File(new File(Minecraft.getInstance().gameDir, "schematics"), schematicFile);
        return build(schematicFile, file, origin);
    }

@@ -19,6 +19,7 @@ package baritone.api.utils;

 import net.minecraft.block.Block;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;

 import java.util.HashMap;
 import java.util.Map;
@@ -28,7 +29,7 @@ public class BlockUtils {
    private static transient Map<String, Block> resourceCache = new HashMap<>();

    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?
@@ -38,6 +39,9 @@ public class BlockUtils {
    }

    public static Block stringToBlockRequired(String name) {
+        if (name.equals("lit_redstone_ore")) { // workaround for Impact 4.6 only
+            return stringToBlockRequired("redstone_ore");
+        }
        Block block = stringToBlockNullable(name);
        Objects.requireNonNull(block);
        return block;
@@ -52,7 +56,7 @@ public class BlockUtils {
        if (resourceCache.containsKey(name)) {
            return null; // cached as null
        }
-        block = Block.getBlockFromName(name.contains(":") ? name : "minecraft:" + name);
+        block = IRegistry.BLOCK.get(ResourceLocation.tryCreate(name.contains(":") ? name : "minecraft:" + name));
        Map<String, Block> copy = new HashMap<>(resourceCache); // read only copy is safe, wont throw concurrentmodification
        copy.put(name, block);
        resourceCache = copy;
@@ -33,11 +33,9 @@ import baritone.api.process.IGetToBlockProcess;
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.ChunkProviderClient;
-import net.minecraft.crash.CrashReport;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.ReportedException;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.Chunk;

@@ -68,7 +66,6 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
                    "get - Same as list\n" +
                    "show - Same as list\n" +
                    "save - Saves a waypoint (works but don't try to make sense of it)\n" +
-                    "delete - Deletes a waypoint\n" +
                    "goto - Paths towards specified block or waypoint\n" +
                    "spawn - Paths towards world spawn or your most recent bed right-click\n" +
                    "sethome - Sets \"home\"\n" +
@@ -198,17 +195,6 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            logDirect("Goal: " + goal);
            return true;
        }
-        if (msg.equals("crash")) {
-            StringBuilder meme = new StringBuilder();
-            CrashReport rep = new CrashReport("Manually triggered debug crash", new Throwable());
-            mc.addGraphicsAndWorldToCrashReport(rep);
-            new ReportedException(rep).printStackTrace();
-            rep.getSectionsInStringBuilder(meme);
-            System.out.println(meme);
-            logDirect(meme.toString());
-            logDirect("ok");
-            return true;
-        }
        if (msg.equals("path")) {
            if (pathingBehavior.getGoal() == null) {
                logDirect("No goal.");
@@ -268,7 +254,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            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);
@@ -346,7 +332,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            if (suffix.isEmpty()) {
                // clear the area from the current goal to here
                Goal goal = baritone.getPathingBehavior().getGoal();
-                if (!(goal instanceof GoalBlock)) {
+                if (goal == null || !(goal instanceof GoalBlock)) {
                    logDirect("Need to specify goal of opposite corner");
                    return true;
                }
@@ -390,7 +376,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
        }
        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;
        }
@@ -399,6 +385,17 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            logDirect("farming");
            return true;
        }
+        // this literally doesn't work, memory is disabled lol
+        /*if (msg.equals("echest")) {
+            Optional<List<ItemStack>> contents = baritone.getMemoryBehavior().echest();
+            if (contents.isPresent()) {
+                logDirect("echest contents:");
+                log(contents.get());
+            } else {
+                logDirect("echest contents unknown");
+            }
+            return true;
+        }*/
        if (msg.equals("chests")) {
            for (Map.Entry<BlockPos, IRememberedInventory> entry : baritone.getWorldProvider().getCurrentWorld().getContainerMemory().getRememberedInventories().entrySet()) {
                logDirect(entry.getKey() + "");
@@ -418,8 +415,8 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
                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);
                    }
                }
@@ -429,7 +426,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
                return true;
            }
            Entity effectivelyFinal = toFollow.get();
-            baritone.getFollowProcess().follow(effectivelyFinal::equals);
+            baritone.getFollowProcess().follow(x -> effectivelyFinal.equals(x));
            logDirect("Following " + toFollow.get());
            return true;
        }
@@ -440,7 +437,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            // means that entries in blah.json are NOT already explored
            String path = msg.substring("explorefilter".length()).trim();
            String[] parts = path.split(" ");
-            Path path1 = Minecraft.getMinecraft().gameDir.toPath().resolve(parts[0]);
+            Path path1 = Minecraft.getInstance().gameDir.toPath().resolve(parts[0]);
            boolean invert = parts.length > 1;
            try {
                baritone.getExploreProcess().applyJsonFilter(path1, invert);
@@ -584,17 +581,6 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            logDirect("Saved user defined position " + pos + " under name '" + name + "'. Say 'goto " + name + "' to set goal, say 'list user' to list custom waypoints.");
            return true;
        }
-        if (msg.startsWith("delete")) {
-            String name = msg.substring(6).trim();
-            IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w ->  w.getTag() == IWaypoint.Tag.USER && w.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
-            if (waypoint == null) {
-                logDirect("No user defined position under the name '" + name + "' found.");
-                return true;
-            }
-            baritone.getWorldProvider().getCurrentWorld().getWaypoints().removeWaypoint(waypoint);
-            logDirect("Deleted user defined position under name '" + name + "'.");
-            return true;
-        }
        if (msg.startsWith("goto")) {
            String waypointType = msg.substring(4).trim();
            if (waypointType.endsWith("s") && IWaypoint.Tag.fromString(waypointType.substring(0, waypointType.length() - 1)) != null) {
@@ -663,6 +649,24 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
            }
            return true;
        }
+        // this is completely impossible from api
+        /*if (msg.equals("costs")) {
+            List<Movement> moves = Stream.of(Moves.values()).map(x -> x.apply0(new CalculationContext(baritone), ctx.playerFeet())).collect(Collectors.toCollection(ArrayList::new));
+            while (moves.contains(null)) {
+                moves.remove(null);
+            }
+            moves.sort(Comparator.comparingDouble(move -> move.getCost(new CalculationContext(baritone))));
+            for (Movement move : moves) {
+                String[] parts = move.getClass().toString().split("\\.");
+                double cost = move.getCost();
+                String strCost = cost + "";
+                if (cost >= ActionCosts.COST_INF) {
+                    strCost = "IMPOSSIBLE";
+                }
+                logDirect(parts[parts.length - 1] + " " + move.getDest().getX() + "," + move.getDest().getY() + "," + move.getDest().getZ() + " " + strCost);
+            }
+            return true;
+        }*/
        if (msg.equals("damn")) {
            logDirect("daniel");
        }
@@ -676,7 +680,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
    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());
            }
        }
    }
@@ -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(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+        Minecraft.getInstance().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
    }
 }
@@ -72,7 +72,7 @@ public interface IPlayerContext {
     */
    default Optional<BlockPos> getSelectedBlock() {
        RayTraceResult result = objectMouseOver();
-        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
+        if (result != null && result.type == RayTraceResult.Type.BLOCK) {
            return Optional.of(result.getBlockPos());
        }
        return Optional.empty();
@@ -89,8 +89,8 @@ public interface IPlayerContext {
     */
    default Optional<Entity> getSelectedEntity() {
        RayTraceResult result = objectMouseOver();
-        if (result != null && result.typeOfHit == RayTraceResult.Type.ENTITY) {
-            return Optional.of(result.entityHit);
+        if (result != null && result.type == RayTraceResult.Type.ENTITY) {
+            return Optional.of(result.entity);
        }
        return Optional.empty();
    }
@@ -17,17 +17,11 @@

 package baritone.api.utils;

-import com.google.gson.annotations.SerializedName;
-
 /**
 * Need a non obfed chunkpos that we can load using GSON
 */
 public class MyChunkPos {
-
-    @SerializedName("x")
    public int x;
-
-    @SerializedName("y")
    public int z;

    @Override
@@ -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);
    }
 }
@@ -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);
+        }
    }

    /**
@@ -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);
            }
@@ -19,8 +19,11 @@ package baritone.api.utils;

 import baritone.api.Settings;
 import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
 import net.minecraft.item.Item;
 import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
 import net.minecraft.util.math.Vec3i;

 import java.awt.*;
@@ -42,13 +45,12 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;

-import static net.minecraft.client.Minecraft.getMinecraft;

 public class SettingsUtil {
-
-    private static final Path SETTINGS_PATH = 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>.+)"); // key and value split by the first space

+
    private static boolean isComment(String line) {
        return line.startsWith("#") || line.startsWith("//");
    }
@@ -158,11 +160,11 @@ public class SettingsUtil {

        private final Settings.Setting<?> setting;

-        private ParserContext(Settings.Setting<?> setting) {
+        public ParserContext(Settings.Setting<?> setting) {
            this.setting = setting;
        }

-        private Settings.Setting<?> getSetting() {
+        final Settings.Setting<?> getSetting() {
            return this.setting;
        }
    }
@@ -192,15 +194,14 @@ public class SettingsUtil {
        ),
        ITEM(
                Item.class,
-                str -> Item.getByNameOrId(str.trim()),
-                item -> Item.REGISTRY.getNameForObject(item).toString()
+                str -> IRegistry.ITEM.get(new ResourceLocation(str.trim())),
+                item -> IRegistry.ITEM.getKey(item).toString()
        ),
        LIST() {
            @Override
            public Object parse(ParserContext context, String raw) {
                Type type = ((ParameterizedType) context.getSetting().getType()).getActualTypeArguments()[0];
                Parser parser = Parser.getParser(type);
-
                return Arrays.stream(raw.split(","))
                        .map(s -> parser.parse(context, s))
                        .collect(Collectors.toList());
@@ -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;
        }
@@ -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()));
+    }
+}
@@ -28,7 +28,10 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;

-import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL11.GL_ONE;
+import static org.lwjgl.opengl.GL11.GL_ZERO;
+import static org.lwjgl.opengl.GL14.GL_CONSTANT_ALPHA;
+import static org.lwjgl.opengl.GL14.GL_ONE_MINUS_CONSTANT_ALPHA;

@Mixin(ChunkRenderContainer.class)
 public class MixinChunkRenderContainer {
@@ -41,11 +44,11 @@ public class MixinChunkRenderContainer {
            )
    )
    private BlockPos getPosition(RenderChunk renderChunkIn) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer() && 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();
    }
@@ -43,7 +43,7 @@ public abstract class MixinChunkRenderWorker {
            )
    )
    private boolean isChunkExisting(ChunkRenderWorker worker, BlockPos pos, World world) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
+        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) {
@@ -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(
@@ -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"
@@ -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));
        }
@@ -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
@@ -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(
@@ -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) {
@@ -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().isSingleplayer()) {
-            Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
-            IPlayerContext ctx = baritone.getPlayerContext();
-            if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {
-                BlockPos position = ((RenderChunk) (Object) this).getPosition();
-                // RenderChunk extends from -1,-1,-1 to +16,+16,+16
-                // then the constructor of ChunkCache extends it one more (presumably to get things like the connected status of fences? idk)
-                // so if ANY of the adjacent chunks are loaded, we are unempty
-                for (int dx = -1; dx <= 1; dx++) {
-                    for (int dz = -1; dz <= 1; dz++) {
-                        if (baritone.bsi.isLoaded(16 * dx + position.getX(), 16 * dz + position.getZ())) {
-                            return false;
-                        }
-                    }
-                }
-            }
-        }
-
-        return true;
-    }
-
-    @Redirect(
-            method = "rebuildChunk",
-            at = @At(
-                    value = "INVOKE",
-                    target = "net/minecraft/world/ChunkCache.getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/state/IBlockState;"
-            )
-    )
-    private IBlockState getBlockState(ChunkCache chunkCache, BlockPos pos) {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
+    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) {
@@ -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;
+    }
+}
@@ -38,9 +38,9 @@ public class MixinRenderList {
            )
    )
    private void popMatrix() {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
+        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();
    }
@@ -38,9 +38,9 @@ public class MixinVboRenderList {
            )
    )
    private void popMatrix() {
-        if (Baritone.settings().renderCachedChunks.value && !Minecraft.getMinecraft().isSingleplayer()) {
+        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();
    }
@@ -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
-                        )
-                );
-            }
-        }
-    }
-}
@@ -16,13 +16,13 @@
    "MixinChunkRenderWorker",
    "MixinEntityLivingBase",
    "MixinEntityPlayerSP",
-    "MixinEntityRenderer",
+    "MixinGameRenderer",
    "MixinMinecraft",
    "MixinNetHandlerPlayClient",
    "MixinNetworkManager",
    "MixinRenderChunk",
+    "MixinRenderChunkCache",
    "MixinRenderList",
-    "MixinVboRenderList",
-    "MixinWorldClient"
+    "MixinVboRenderList"
  ]
 }
@@ -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());
@@ -32,7 +32,6 @@ import java.util.List;
 public final class BaritoneProvider implements IBaritoneProvider {

    private final Baritone primary = new Baritone();
-    private final List<IBaritone> all = Collections.singletonList(primary);

    @Override
    public IBaritone getPrimaryBaritone() {
@@ -41,7 +40,8 @@ public final class BaritoneProvider implements IBaritoneProvider {

    @Override
    public List<IBaritone> getAllBaritones() {
-        return all;
+        // TODO return a CopyOnWriteArrayList
+        return Collections.singletonList(primary);
    }

    @Override
@@ -33,7 +33,7 @@ import java.util.OptionalInt;
 import java.util.Random;
 import java.util.function.Predicate;

-public final class InventoryBehavior extends Behavior {
+public class InventoryBehavior extends Behavior {
    public InventoryBehavior(Baritone baritone) {
        super(baritone);
    }
@@ -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;

@@ -65,7 +65,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,

    private boolean lastAutoJump;

-    private BetterBlockPos expectedSegmentStart;
+    private BlockPos expectedSegmentStart;

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

@@ -19,7 +19,6 @@ package baritone.cache;

 import baritone.api.utils.BlockUtils;
 import baritone.utils.pathing.PathingBlockType;
-import com.google.common.collect.ImmutableSet;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
@@ -34,60 +33,99 @@ import java.util.*;
 */
 public final class CachedChunk {

-    public static final ImmutableSet<Block> BLOCKS_TO_KEEP_TRACK_OF = ImmutableSet.of(
-        Blocks.DIAMOND_BLOCK,
-        //Blocks.COAL_ORE,
-        Blocks.COAL_BLOCK,
-        //Blocks.IRON_ORE,
-        Blocks.IRON_BLOCK,
-        //Blocks.GOLD_ORE,
-        Blocks.GOLD_BLOCK,
-        Blocks.EMERALD_ORE,
-        Blocks.EMERALD_BLOCK,
+    public static final Set<Block> BLOCKS_TO_KEEP_TRACK_OF;

-        Blocks.ENDER_CHEST,
-        Blocks.FURNACE,
-        Blocks.CHEST,
-        Blocks.TRAPPED_CHEST,
-        Blocks.END_PORTAL,
-        Blocks.END_PORTAL_FRAME,
-        Blocks.MOB_SPAWNER,
-        Blocks.BARRIER,
-        Blocks.OBSERVER,
-        Blocks.WHITE_SHULKER_BOX,
-        Blocks.ORANGE_SHULKER_BOX,
-        Blocks.MAGENTA_SHULKER_BOX,
-        Blocks.LIGHT_BLUE_SHULKER_BOX,
-        Blocks.YELLOW_SHULKER_BOX,
-        Blocks.LIME_SHULKER_BOX,
-        Blocks.PINK_SHULKER_BOX,
-        Blocks.GRAY_SHULKER_BOX,
-        Blocks.SILVER_SHULKER_BOX,
-        Blocks.CYAN_SHULKER_BOX,
-        Blocks.PURPLE_SHULKER_BOX,
-        Blocks.BLUE_SHULKER_BOX,
-        Blocks.BROWN_SHULKER_BOX,
-        Blocks.GREEN_SHULKER_BOX,
-        Blocks.RED_SHULKER_BOX,
-        Blocks.BLACK_SHULKER_BOX,
-        Blocks.PORTAL,
-        Blocks.HOPPER,
-        Blocks.BEACON,
-        Blocks.BREWING_STAND,
-        Blocks.SKULL,
-        Blocks.ENCHANTING_TABLE,
-        Blocks.ANVIL,
-        Blocks.LIT_FURNACE,
-        Blocks.BED,
-        Blocks.DRAGON_EGG,
-        Blocks.JUKEBOX,
-        Blocks.END_GATEWAY,
-        Blocks.WEB,
-        Blocks.NETHER_WART,
-        Blocks.LADDER,
-        Blocks.VINE
-    );
+    static {
+        HashSet<Block> temp = new HashSet<>();
+        //temp.add(Blocks.DIAMOND_ORE);
+        temp.add(Blocks.DIAMOND_BLOCK);
+        //temp.add(Blocks.COAL_ORE);
+        temp.add(Blocks.COAL_BLOCK);
+        //temp.add(Blocks.IRON_ORE);
+        temp.add(Blocks.IRON_BLOCK);
+        //temp.add(Blocks.GOLD_ORE);
+        temp.add(Blocks.GOLD_BLOCK);
+        temp.add(Blocks.EMERALD_ORE);
+        temp.add(Blocks.EMERALD_BLOCK);

+        temp.add(Blocks.ENDER_CHEST);
+        temp.add(Blocks.FURNACE);
+        temp.add(Blocks.CHEST);
+        temp.add(Blocks.TRAPPED_CHEST);
+        temp.add(Blocks.END_PORTAL);
+        temp.add(Blocks.END_PORTAL_FRAME);
+        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);
+        temp.add(Blocks.LIGHT_BLUE_SHULKER_BOX);
+        temp.add(Blocks.YELLOW_SHULKER_BOX);
+        temp.add(Blocks.LIME_SHULKER_BOX);
+        temp.add(Blocks.PINK_SHULKER_BOX);
+        temp.add(Blocks.GRAY_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);
+        temp.add(Blocks.BROWN_SHULKER_BOX);
+        temp.add(Blocks.GREEN_SHULKER_BOX);
+        temp.add(Blocks.RED_SHULKER_BOX);
+        temp.add(Blocks.BLACK_SHULKER_BOX);
+
+        temp.add(Blocks.NETHER_PORTAL);
+        temp.add(Blocks.HOPPER);
+        temp.add(Blocks.BEACON);
+        temp.add(Blocks.BREWING_STAND);
+
+        // 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.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.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
+    }

    /**
     * The size of the chunk data in bits. Equal to 16 KiB.
@@ -167,8 +205,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];
        }
@@ -303,9 +303,6 @@ public final class CachedWorld implements ICachedWorld, Helper {
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
-                } catch (Throwable th) {
-                    // in the case of an exception, keep consuming from the queue so as not to leak memory
-                    th.printStackTrace();
                }
            }
        }
@@ -24,9 +24,10 @@ import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraft.world.chunk.ChunkSection;

 import java.util.*;

@@ -44,9 +45,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
@@ -58,7 +59,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
@@ -103,10 +104,9 @@ public final class ChunkPacker {
        return new CachedChunk(chunk.x, chunk.z, bitSet, blocks, specialBlocks, System.currentTimeMillis());
    }

-
    private static PathingBlockType getPathingBlockType(IBlockState state, Chunk chunk, int x, int y, int z) {
        Block block = state.getBlock();
-        if (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)) {
@@ -121,7 +121,8 @@ public final class ChunkPacker {
                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;
@@ -129,14 +130,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;
        }

@@ -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,14 +56,14 @@ 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;

        IntegratedServer integratedServer = mc.getIntegratedServer();

        // If there is an integrated server running (Aka Singleplayer) then do magic to find the world save file
-        if (mc.isSingleplayer()) {
+        if (integratedServer != null) {
            WorldServer localServerWorld = integratedServer.getWorld(dimension);
            IChunkProviderServer provider = (IChunkProviderServer) localServerWorld.getChunkProvider();
            IAnvilChunkLoader loader = (IAnvilChunkLoader) provider.getChunkLoader();
@@ -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()));
        }
    }

@@ -26,7 +26,7 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraft.world.chunk.ChunkSection;

 import java.util.*;
 import java.util.stream.IntStream;
@@ -70,7 +70,7 @@ public enum WorldScanner implements IWorldScanner {
                    foundChunks = true;
                    int chunkX = xoff + playerChunkX;
                    int chunkZ = zoff + playerChunkZ;
-                    Chunk chunk = chunkProvider.getLoadedChunk(chunkX, chunkZ);
+                    Chunk chunk = chunkProvider.getChunk(chunkX, chunkZ, false, false);
                    if (chunk == null) {
                        continue;
                    }
@@ -97,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()) {
@@ -110,16 +110,16 @@ public enum WorldScanner implements IWorldScanner {
    }

    private boolean scanChunkInto(int chunkX, int chunkZ, Chunk chunk, List<Block> search, Collection<BlockPos> result, int max, int yLevelThreshold, int playerY, int[] coordinateIterationOrder) {
-        ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
+        ChunkSection[] chunkInternalStorageArray = chunk.getSections();
        boolean foundWithinY = false;
        for (int yIndex = 0; yIndex < 16; yIndex++) {
            int y0 = coordinateIterationOrder[yIndex];
-            ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
+            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++) {
@@ -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());
            }
        }

@@ -86,7 +86,8 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
            if (slowPath) {
                try {
                    Thread.sleep(Baritone.settings().slowPathTimeDelayMS.value);
-                } catch (InterruptedException ignored) {}
+                } catch (InterruptedException ex) {
+                }
            }
            PathNode currentNode = openSet.removeLowest();
            mostRecentConsidered = currentNode;
@@ -96,7 +96,7 @@ class Path extends PathBase {
        }
        PathNode current = end;
        LinkedList<BetterBlockPos> tempPath = new LinkedList<>();
-        LinkedList<PathNode> tempNodes = new LinkedList<>();
+        LinkedList<PathNode> tempNodes = new LinkedList();
        // Repeatedly inserting to the beginning of an arraylist is O(n^2)
        // Instead, do it into a linked list, then convert at the end
        while (current != null) {
@@ -83,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;
@@ -23,19 +23,19 @@ import baritone.api.pathing.movement.IMovement;
 import baritone.api.pathing.movement.MovementStatus;
 import baritone.api.utils.*;
 import baritone.api.utils.input.Input;
-import baritone.behavior.PathingBehavior;
 import baritone.utils.BlockStateInterface;
-import net.minecraft.block.BlockLiquid;
 import net.minecraft.entity.item.EntityFallingBlock;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;

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

 public abstract class Movement implements IMovement, MovementHelper {

-    public static final EnumFacing[] HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST, EnumFacing.DOWN};
+    public static final EnumFacing[] HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST, EnumFacing.DOWN};

    protected final IBaritone baritone;
    protected final IPlayerContext ctx;
@@ -62,8 +62,6 @@ public abstract class Movement implements IMovement, MovementHelper {
    public List<BlockPos> toPlaceCached = null;
    public List<BlockPos> toWalkIntoCached = null;

-    private Set<BetterBlockPos> validPositionsCached = null;
-
    private Boolean calculatedWhileLoaded;

    protected Movement(IBaritone baritone, BetterBlockPos src, BetterBlockPos dest, BetterBlockPos[] toBreak, BetterBlockPos toPlace) {
@@ -101,20 +99,6 @@ public abstract class Movement implements IMovement, MovementHelper {
        this.cost = cost;
    }

-    protected abstract Set<BetterBlockPos> calculateValidPositions();
-
-    public Set<BetterBlockPos> getValidPositions() {
-        if (validPositionsCached == null) {
-            validPositionsCached = calculateValidPositions();
-            Objects.requireNonNull(validPositionsCached);
-        }
-        return validPositionsCached;
-    }
-
-    protected boolean playerInValidPosition() {
-        return getValidPositions().contains(ctx.playerFeet()) || getValidPositions().contains(((PathingBehavior) baritone.getPathingBehavior()).pathStart());
-    }
-
    /**
     * Handles the execution of the latest Movement
     * State, and offers a Status to the calling class.
@@ -123,13 +107,12 @@ 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);
        }
        if (ctx.player().isEntityInsideOpaqueBlock()) {
-            ctx.getSelectedBlock().ifPresent(pos -> MovementHelper.switchToBestToolFor(ctx, BlockStateInterface.get(ctx, pos)));
            currentState.setInput(Input.CLICK_LEFT, true);
        }

@@ -161,12 +144,12 @@ public abstract class Movement implements IMovement, MovementHelper {
            if (!ctx.world().getEntitiesWithinAABB(EntityFallingBlock.class, new AxisAlignedBB(0, 0, 0, 1, 1.1, 1).offset(blockPos)).isEmpty() && Baritone.settings().pauseMiningForFallingBlocks.value) {
                return false;
            }
-            if (!MovementHelper.canWalkThrough(ctx, blockPos) && !(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;
-                MovementHelper.switchToBestToolFor(ctx, BlockStateInterface.get(ctx, blockPos));
                Optional<Rotation> reachable = RotationUtils.reachable(ctx.player(), blockPos, ctx.playerController().getBlockReachDistance());
                if (reachable.isPresent()) {
                    Rotation rotTowardsBlock = reachable.get();
+                    MovementHelper.switchToBestToolFor(ctx, BlockStateInterface.get(ctx, blockPos));
                    state.setTarget(new MovementState.MovementTarget(rotTowardsBlock, true));
                    if (ctx.isLookingAt(blockPos) || ctx.playerRotations().isReallyCloseTo(rotTowardsBlock)) {
                        state.setInput(Input.CLICK_LEFT, true);
@@ -177,7 +160,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
@@ -27,9 +27,16 @@ import baritone.pathing.movement.MovementState.MovementTarget;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.ToolSet;
 import net.minecraft.block.*;
-import net.minecraft.block.properties.PropertyBool;
 import net.minecraft.block.state.IBlockState;
+import net.minecraft.fluid.FlowingFluid;
+import net.minecraft.fluid.Fluid;
+import net.minecraft.fluid.IFluidState;
+import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Fluids;
+import net.minecraft.pathfinding.PathType;
+import net.minecraft.state.BooleanProperty;
+import net.minecraft.state.properties.SlabType;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
@@ -37,7 +44,7 @@ import net.minecraft.util.math.Vec3d;

 import java.util.Optional;

-import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP;
+import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP;

 /**
 * Static helpers for cost calculation
@@ -71,7 +78,7 @@ public interface MovementHelper extends ActionCosts, Helper {
                && BlockFalling.canFallThrough(bsi.get0(x, y - 1, z))) { // and if it would fall (i.e. it's unsupported)
            return true; // dont break a block that is adjacent to unsupported gravel because it can cause really weird stuff
        }
-        return block instanceof BlockLiquid;
+        return !state.getFluidState().isEmpty();
    }

    static boolean canWalkThrough(IPlayerContext ctx, BetterBlockPos pos) {
@@ -84,10 +91,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 (Baritone.settings().blocksToAvoid.value.contains(block)) {
@@ -99,10 +106,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
@@ -112,7 +119,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?
@@ -121,20 +128,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);
    }

    /**
@@ -153,27 +161,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) {
@@ -188,20 +197,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();
    }
@@ -229,16 +237,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)) {
@@ -252,14 +260,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;
    }

    /**
@@ -276,7 +285,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;
@@ -293,33 +302,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 (Baritone.settings().assumeWalkOnLava.value && isLava(block) && !isFlowing(x, y, z, state, bsi)) {
+        if (Baritone.settings().assumeWalkOnLava.value && isLava(state) && !isFlowing(x, y, z, state, bsi)) {
            return true;
        }
-        if (block == Blocks.GLASS || block == Blocks.STAINED_GLASS) {
+        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;
        }
@@ -358,7 +365,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) {
@@ -368,7 +375,7 @@ public interface MovementHelper extends ActionCosts, Helper {
    static double getMiningDurationTicks(CalculationContext context, int x, int y, int z, IBlockState state, boolean includeFalling) {
        Block block = state.getBlock();
        if (!canWalkThrough(context.bsi, x, y, z, state)) {
-            if (block instanceof BlockLiquid) {
+            if (!state.getFluidState().isEmpty()) {
                return COST_INF;
            }
            double mult = context.breakCostMultiplierAt(x, y, z);
@@ -398,8 +405,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;
    }

    /**
@@ -436,11 +442,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;
    }

    /**
@@ -452,11 +459,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;
    }

    /**
@@ -467,20 +475,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))
@@ -499,7 +512,7 @@ public interface MovementHelper extends ActionCosts, Helper {
            found = true;
        }
        for (int i = 0; i < 5; i++) {
-            BlockPos against1 = placeAt.offset(HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i]);
+            BlockPos against1 = placeAt.offset(HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i]);
            if (MovementHelper.canPlaceAgainst(ctx, against1)) {
                if (!((Baritone) baritone).getInventoryBehavior().selectThrowawayForLocation(false, placeAt.getX(), placeAt.getY(), placeAt.getZ())) { // get ready to place a throwaway block
                    Helper.HELPER.logDebug("bb pls get me some blocks. dirt, netherrack, cobble");
@@ -511,7 +524,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;

@@ -27,14 +27,11 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.BlockFalling;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.EnumFacing;

-import java.util.Set;
-
 public class MovementAscend extends Movement {

    private int ticksWithoutPlacement = 0;
@@ -54,17 +51,6 @@ public class MovementAscend extends Movement {
        return cost(context, src.x, src.y, src.z, dest.x, dest.z);
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        BetterBlockPos prior = new BetterBlockPos(src.subtract(getDirection()).up()); // sometimes we back up to place the block, also sprint ascends, also skip descend to straight ascend
-        return ImmutableSet.of(src,
-                src.up(),
-                dest,
-                prior,
-                prior.up()
-        );
-    }
-
    public static double cost(CalculationContext context, int x, int y, int z, int destX, int destZ) {
        IBlockState toPlace = context.get(destX, y, destZ);
        double additionalPlacementCost = 0;
@@ -78,9 +64,9 @@ public class MovementAscend extends Movement {
            }
            boolean foundPlaceOption = false;
            for (int i = 0; i < 5; i++) {
-                int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
-                int againstY = y + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
-                int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
+                int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
+                int againstY = y + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
+                int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
                if (againstX == x && againstZ == z) { // we might be able to backplace now, but it doesn't matter because it will have been broken by the time we'd need to use it
                    continue;
                }
@@ -157,10 +143,6 @@ public class MovementAscend extends Movement {

    @Override
    public MovementState updateState(MovementState state) {
-        if (ctx.playerFeet().y < src.y) {
-            // this check should run even when in preparing state (breaking blocks)
-            return state.setStatus(MovementStatus.UNREACHABLE);
-        }
        super.updateState(state);
        // TODO incorporate some behavior from ActionClimb (specifically how it waited until it was at most 1.2 blocks away before starting to jump
        // for efficiency in ascending minimal height staircases, which is just repeated MovementAscend, so that it doesn't bonk its head on the ceiling repeatedly)
@@ -172,6 +154,10 @@ public class MovementAscend extends Movement {
            return state.setStatus(MovementStatus.SUCCESS);
        }

+        if (ctx.playerFeet().y < src.y) {
+            return state.setStatus(MovementStatus.UNREACHABLE);
+        }
+
        IBlockState jumpingOnto = BlockStateInterface.get(ctx, positionToPlace);
        if (!MovementHelper.canWalkOn(ctx, positionToPlace, jumpingOnto)) {
            ticksWithoutPlacement++;
@@ -29,7 +29,6 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.pathing.MutableMoveResult;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockFalling;
 import net.minecraft.block.state.IBlockState;
@@ -38,8 +37,6 @@ import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;

-import java.util.Set;
-
 public class MovementDescend extends Movement {

    private int numTicks = 0;
@@ -64,11 +61,6 @@ public class MovementDescend extends Movement {
        return result.cost;
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        return ImmutableSet.of(src, dest.up(), dest);
-    }
-
    public static void cost(CalculationContext context, int x, int y, int z, int destX, int destZ, MutableMoveResult res) {
        double totalCost = 0;
        IBlockState destDown = context.get(destX, y - 1, destZ);
@@ -145,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;
                }
@@ -224,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
@@ -256,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;
            }
        }
@@ -28,7 +28,6 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.pathing.MutableMoveResult;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
@@ -37,7 +36,6 @@ import net.minecraft.util.math.BlockPos;

 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;

 public class MovementDiagonal extends Movement {

@@ -66,16 +64,6 @@ public class MovementDiagonal extends Movement {
        return result.cost;
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        BetterBlockPos diagA = new BetterBlockPos(src.x, src.y, dest.z);
-        BetterBlockPos diagB = new BetterBlockPos(dest.x, src.y, src.z);
-        if (dest.y != src.y) { // only if allowDiagonalDescend
-            return ImmutableSet.of(src, dest.up(), diagA, diagB, dest, diagA.down(), diagB.down());
-        }
-        return ImmutableSet.of(src, dest, diagA, diagB);
-    }
-
    public static void cost(CalculationContext context, int x, int y, int z, int destX, int destZ, MutableMoveResult res) {
        IBlockState destInto = context.get(destX, y, destZ);
        if (!MovementHelper.canWalkThrough(context.bsi, destX, y, destZ, destInto) || !MovementHelper.canWalkThrough(context.bsi, destX, y + 1, destZ)) {
@@ -103,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);
@@ -127,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;
        }
@@ -136,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
@@ -183,9 +172,8 @@ public class MovementDiagonal extends Movement {
        }

        if (ctx.playerFeet().equals(dest)) {
-            return state.setStatus(MovementStatus.SUCCESS);
-        } else if (!playerInValidPosition() && !(MovementHelper.isLiquid(ctx, src) && getValidPositions().contains(ctx.playerFeet().up()))) {
-            return state.setStatus(MovementStatus.UNREACHABLE);
+            state.setStatus(MovementStatus.SUCCESS);
+            return state;
        }
        if (sprint()) {
            state.setInput(Input.SPRINT, true);
@@ -194,7 +182,7 @@ public class MovementDiagonal extends Movement {
        return state;
    }

-    private boolean sprint() {
+    public boolean sprint() {
        if (MovementHelper.isLiquid(ctx, ctx.playerFeet()) && !Baritone.settings().sprintInWater.value) {
            return false;
        }
@@ -24,13 +24,10 @@ import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;

-import java.util.Set;
-
 public class MovementDownward extends Movement {

    private int numTicks = 0;
@@ -50,11 +47,6 @@ public class MovementDownward extends Movement {
        return cost(context, src.x, src.y, src.z);
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        return ImmutableSet.of(src, dest);
-    }
-
    public static double cost(CalculationContext context, int x, int y, int z) {
        if (!context.allowDownward) {
            return COST_INF;
@@ -81,8 +73,6 @@ public class MovementDownward extends Movement {

        if (ctx.playerFeet().equals(dest)) {
            return state.setStatus(MovementStatus.SUCCESS);
-        } else if (!playerInValidPosition()) {
-            return state.setStatus(MovementStatus.UNREACHABLE);
        }
        double diffX = ctx.player().posX - (dest.getX() + 0.5);
        double diffZ = ctx.player().posZ - (dest.getZ() + 0.5);
@@ -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;
@@ -42,9 +43,7 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.math.Vec3i;

-import java.util.HashSet;
 import java.util.Optional;
-import java.util.Set;

 public class MovementFall extends Movement {

@@ -65,16 +64,6 @@ public class MovementFall extends Movement {
        return result.cost;
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        Set<BetterBlockPos> set = new HashSet<>();
-        set.add(src);
-        for (int y = src.y - dest.y; y >= 0; y--) {
-            set.add(dest.up(y));
-        }
-        return set;
-    }
-
    private boolean willPlaceBucket() {
        CalculationContext context = new CalculationContext(baritone);
        MutableMoveResult result = new MutableMoveResult();
@@ -91,10 +80,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);
            }

@@ -160,7 +150,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;
@@ -28,15 +28,13 @@ import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.pathing.MutableMoveResult;
 import net.minecraft.block.Block;
-import net.minecraft.block.BlockLiquid;
 import net.minecraft.block.BlockStairs;
 import net.minecraft.block.state.IBlockState;
+import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Fluids;
 import net.minecraft.util.EnumFacing;

-import java.util.HashSet;
-import java.util.Set;
-
 public class MovementParkour extends Movement {

    private static final BetterBlockPos[] EMPTY = new BetterBlockPos[]{};
@@ -76,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)) {
@@ -89,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;
@@ -137,9 +135,9 @@ public class MovementParkour extends Movement {
            return;
        }
        for (int i = 0; i < 5; i++) {
-            int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
-            int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
-            int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
+            int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
+            int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
+            int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
            if (againstX == x + xDiff * 3 && againstZ == z + zDiff * 3) { // we can't turn around that fast
                continue;
            }
@@ -177,17 +175,6 @@ public class MovementParkour extends Movement {
        return res.cost;
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        Set<BetterBlockPos> set = new HashSet<>();
-        for (int i = 0; i <= dist; i++) {
-            for (int y = 0; y < 2; y++) {
-                set.add(src.offset(direction, i).up(y));
-            }
-        }
-        return set;
-    }
-
    @Override
    public boolean safeToCancel(MovementState state) {
        // once this movement is instantiated, the state is default to PREPPING
@@ -30,7 +30,6 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
@@ -38,7 +37,7 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;

 import java.util.Objects;
-import java.util.Set;
+import java.util.Optional;

 public class MovementPillar extends Movement {

@@ -51,20 +50,16 @@ public class MovementPillar extends Movement {
        return cost(context, src.x, src.y, src.z);
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        return ImmutableSet.of(src, dest);
-    }
-
    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
            }
        }
@@ -76,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
            }
@@ -90,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
@@ -112,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;
                    }
                }
@@ -169,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);
@@ -183,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) {
@@ -192,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);
@@ -246,9 +241,10 @@ public class MovementPillar extends Movement {
                Block fr = frState.getBlock();
                // TODO: Evaluate usage of getMaterial().isReplaceable()
                if (!(fr instanceof BlockAir || frState.getMaterial().isReplaceable())) {
-                    RotationUtils.reachable(ctx.player(), src, ctx.playerController().getBlockReachDistance())
-                            .map(rot -> new MovementState.MovementTarget(rot, true))
-                            .ifPresent(state::setTarget);
+                    Optional<Rotation> reachable = RotationUtils.reachable(ctx.player(), src, ctx.playerController().getBlockReachDistance());
+                    if (reachable.isPresent()) {
+                        state.setTarget(new MovementState.MovementTarget(reachable.get(), true));
+                    }
                    state.setInput(Input.JUMP, false); // breaking is like 5x slower when you're jumping
                    state.setInput(Input.CLICK_LEFT, true);
                    blockIsThere = false;
@@ -30,15 +30,14 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
-import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
+import net.minecraft.fluid.WaterFluid;
 import net.minecraft.init.Blocks;
+import net.minecraft.state.properties.SlabType;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;

-import java.util.Set;
-
 public class MovementTraverse extends Movement {

    /**
@@ -61,20 +60,16 @@ public class MovementTraverse extends Movement {
        return cost(context, src.x, src.y, src.z, dest.x, dest.z);
    }

-    @Override
-    protected Set<BetterBlockPos> calculateValidPositions() {
-        return ImmutableSet.of(src, dest);
-    }
-
    public static double cost(CalculationContext context, int x, int y, int z, int destX, int destZ) {
        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 {
@@ -111,8 +106,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;
                }
@@ -127,9 +122,9 @@ public class MovementTraverse extends Movement {
                double hardness2 = MovementHelper.getMiningDurationTicks(context, destX, y + 1, destZ, pb0, true); // only include falling on the upper block to break
                double WC = throughWater ? context.waterWalkSpeed : WALK_ONE_BLOCK_COST;
                for (int i = 0; i < 5; i++) {
-                    int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
-                    int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
-                    int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
+                    int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
+                    int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
+                    int againstZ = destZ + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getZOffset();
                    if (againstX == x && againstZ == z) { // this would be a backplace
                        continue;
                    }
@@ -138,10 +133,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
@@ -166,10 +161,10 @@ public class MovementTraverse extends Movement {
                return state;
            }
            // and if it's fine to walk into the blocks in front
-            if (MovementHelper.avoidWalkingInto(pb0.getBlock())) {
+            if (MovementHelper.avoidWalkingInto(pb0)) {
                return state;
            }
-            if (MovementHelper.avoidWalkingInto(pb1.getBlock())) {
+            if (MovementHelper.avoidWalkingInto(pb1)) {
                return state;
            }
            // and we aren't already pressed up against the block
@@ -177,10 +172,6 @@ public class MovementTraverse extends Movement {
            if (dist < 0.83) {
                return state;
            }
-            if (!state.getTarget().getRotation().isPresent()) {
-                // this can happen rarely when the server lags and doesn't send the falling sand entity until you've already walked through the block and are now mining the next one
-                return state;
-            }

            // combine the yaw to the center of the destination, and the pitch to the specific block we're trying to break
            // it's safe to do this since the two blocks we break (in a traverse) are right on top of each other and so will have the same yaw
@@ -191,9 +182,8 @@ public class MovementTraverse extends Movement {
                pitchToBreak = 26;
            }

-            return state.setTarget(new MovementState.MovementTarget(new Rotation(yawToDest, pitchToBreak), true))
-                    .setInput(Input.MOVE_FORWARD, true)
-                    .setInput(Input.SPRINT, true);
+            state.setTarget(new MovementState.MovementTarget(new Rotation(yawToDest, pitchToBreak), true));
+            return state.setInput(Input.MOVE_FORWARD, true).setInput(Input.SPRINT, true);
        }

        //sneak may have been set to true in the PREPPING state while mining an adjacent block
@@ -202,18 +192,28 @@ public class MovementTraverse extends Movement {
        Block fd = BlockStateInterface.get(ctx, src.down()).getBlock();
        boolean ladder = fd == Blocks.LADDER || fd == Blocks.VINE;

-        if ((pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor)
-                && (pb0.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, src, dest)
-                || pb1.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, dest, src))
-                && !(Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()))) {
-            return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), positionsToBreak[0]), ctx.playerRotations()), true))
-                    .setInput(Input.CLICK_RIGHT, true);
+        boolean door = pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor;
+        if (door) {
+            boolean isDoorActuallyBlockingUs = false;
+            if (pb0.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, src, dest)) {
+                isDoorActuallyBlockingUs = true;
+            } else if (pb1.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, dest, src)) {
+                isDoorActuallyBlockingUs = true;
+            }
+            if (isDoorActuallyBlockingUs && !(Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()))) {
+                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), positionsToBreak[0]), ctx.playerRotations()), true))
+                        .setInput(Input.CLICK_RIGHT, true);
+            }
        }

        if (pb0.getBlock() instanceof BlockFenceGate || pb1.getBlock() instanceof BlockFenceGate) {
-            BlockPos blocked = !MovementHelper.isGatePassable(ctx, positionsToBreak[0], src.up()) ? positionsToBreak[0]
-                    : !MovementHelper.isGatePassable(ctx, positionsToBreak[1], src) ? positionsToBreak[1]
-                    : null;
+            BlockPos blocked = null;
+            if (!MovementHelper.isGatePassable(ctx, positionsToBreak[0], src.up())) {
+                blocked = positionsToBreak[0];
+            } else if (!MovementHelper.isGatePassable(ctx, positionsToBreak[1], src)) {
+                blocked = positionsToBreak[1];
+            }
+
            if (blocked != null) {
                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), blocked), ctx.playerRotations()), true))
                        .setInput(Input.CLICK_RIGHT, true);
@@ -221,16 +221,17 @@ public class MovementTraverse extends Movement {
        }

        boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder;
-        BlockPos feet = ctx.playerFeet();
-        if (feet.getY() != dest.getY() && !ladder) {
+        BlockPos whereAmI = ctx.playerFeet();
+        if (whereAmI.getY() != dest.getY() && !ladder) {
            logDebug("Wrong Y coordinate");
-            if (feet.getY() < dest.getY()) {
-                return state.setInput(Input.JUMP, true);
+            if (whereAmI.getY() < dest.getY()) {
+                state.setInput(Input.JUMP, true);
            }
            return state;
        }

        if (isTheBridgeBlockThere) {
+            BetterBlockPos feet = ctx.playerFeet();
            if (feet.equals(dest)) {
                return state.setStatus(MovementStatus.SUCCESS);
            }
@@ -245,22 +246,22 @@ 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();
-            if (wasTheBridgeBlockAlwaysThere && (!MovementHelper.isLiquid(ctx, feet) || Baritone.settings().sprintInWater.value) && (!MovementHelper.avoidWalkingInto(intoBelow) || MovementHelper.isWater(intoBelow)) && !MovementHelper.avoidWalkingInto(intoAbove)) {
+            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);
            }

            IBlockState destDown = BlockStateInterface.get(ctx, dest.down());
            BlockPos against = positionsToBreak[0];
-            if (feet.getY() != dest.getY() && ladder && (destDown.getBlock() == Blocks.VINE || destDown.getBlock() == Blocks.LADDER)) {
-                against = destDown.getBlock() == Blocks.VINE ? MovementPillar.getAgainst(new CalculationContext(baritone), dest.down()) : dest.offset(destDown.getValue(BlockLadder.FACING).getOpposite());
+            if (whereAmI.getY() != dest.getY() && ladder && (destDown.getBlock() == Blocks.VINE || destDown.getBlock() == Blocks.LADDER)) {
+                against = destDown.getBlock() == Blocks.VINE ? MovementPillar.getAgainst(new CalculationContext(baritone), dest.down()) : dest.offset(destDown.get(BlockLadder.FACING).getOpposite());
            }
            MovementHelper.moveTowards(ctx, state, against);
            return state;
        } else {
            wasTheBridgeBlockAlwaysThere = false;
-            Block standingOn = BlockStateInterface.get(ctx, feet.down()).getBlock();
+            Block standingOn = BlockStateInterface.get(ctx, ctx.playerFeet().down()).getBlock();
            if (standingOn.equals(Blocks.SOUL_SAND) || standingOn instanceof BlockSlab) { // see issue #118
                double dist = Math.max(Math.abs(dest.getX() + 0.5 - ctx.player().posX), Math.abs(dest.getZ() + 0.5 - ctx.player().posZ));
                if (dist < 0.85) { // 0.5 + 0.3 + epsilon
@@ -298,7 +299,7 @@ public class MovementTraverse extends Movement {
                default:
                    break;
            }
-            if (feet.equals(dest)) {
+            if (whereAmI.equals(dest)) {
                // If we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of
                // Out.log(from + " " + to + " " + faceX + "," + faceY + "," + faceZ + " " + whereAmI);
                double faceX = (dest.getX() + src.getX() + 1.0D) * 0.5D;
@@ -32,7 +32,7 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.movements.*;
 import baritone.utils.BlockStateInterface;
-import net.minecraft.block.BlockLiquid;
+import net.minecraft.init.Blocks;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
@@ -99,13 +99,14 @@ public class PathExecutor implements IPathExecutor, Helper {
        if (pathPosition >= path.length()) {
            return true; // stop bugging me, I'm done
        }
-        Movement movement = (Movement) path.movements().get(pathPosition);
+        BetterBlockPos whereShouldIBe = path.positions().get(pathPosition);
        BetterBlockPos whereAmI = ctx.playerFeet();
-        if (!movement.getValidPositions().contains(whereAmI)) {
-            for (int i = 0; i < pathPosition && i < path.length(); i++) {//this happens for example when you lag out and get teleported back a couple blocks
-                if (((Movement) path.movements().get(i)).getValidPositions().contains(whereAmI)) {
+        if (!whereShouldIBe.equals(whereAmI) && !Blocks.AIR.equals(BlockStateInterface.getBlock(ctx, whereAmI.down()))) {//do not skip if standing on air, because our position isn't stable to skip
+            for (int i = 0; i < pathPosition - 1 && i < path.length(); i++) {//this happens for example when you lag out and get teleported back a couple blocks
+                if (whereAmI.equals(path.positions().get(i))) {
+                    logDebug("Skipping back " + (pathPosition - i) + " steps, to " + i);
                    int previousPos = pathPosition;
-                    pathPosition = i;
+                    pathPosition = Math.max(i - 1, 0); // previous step might not actually be done
                    for (int j = pathPosition; j <= previousPos; j++) {
                        path.movements().get(j).reset();
                    }
@@ -114,9 +115,9 @@ public class PathExecutor implements IPathExecutor, Helper {
                    return false;
                }
            }
-            for (int i = pathPosition + 3; i < path.length() - 1; i++) { //dont check pathPosition+1. the movement tells us when it's done (e.g. sneak placing)
+            for (int i = pathPosition + 3; i < path.length(); i++) { //dont check pathPosition+1. the movement tells us when it's done (e.g. sneak placing)
                // also don't check pathPosition+2 because reasons
-                if (((Movement) path.movements().get(i)).getValidPositions().contains(whereAmI)) {
+                if (whereAmI.equals(path.positions().get(i))) {
                    if (i - pathPosition > 2) {
                        logDebug("Skipping forward " + (i - pathPosition) + " steps, to " + i);
                    }
@@ -131,7 +132,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();
@@ -145,6 +146,38 @@ public class PathExecutor implements IPathExecutor, Helper {
            cancel();
            return false;
        }
+        //this commented block is literally cursed.
+        /*Out.log(actions.get(pathPosition));
+        if (pathPosition < actions.size() - 1) {//if there are two ActionBridges in a row and they are at right angles, walk diagonally. This makes it so you walk at 45 degrees along a zigzag path instead of doing inefficient zigging and zagging
+            if ((actions.get(pathPosition) instanceof ActionBridge) && (actions.get(pathPosition + 1) instanceof ActionBridge)) {
+                ActionBridge curr = (ActionBridge) actions.get(pathPosition);
+                ActionBridge next = (ActionBridge) actions.get(pathPosition + 1);
+                if (curr.dx() != next.dx() || curr.dz() != next.dz()) {//two movement are not parallel, so this is a right angle
+                    if (curr.amIGood() && next.amIGood()) {//nothing in the way
+                        BlockPos cornerToCut1 = new BlockPos(next.to.getX() - next.from.getX() + curr.from.getX(), next.to.getY(), next.to.getZ() - next.from.getZ() + curr.from.getZ());
+                        BlockPos cornerToCut2 = cornerToCut1.up();
+                        //Block corner1 = Baritone.get(cornerToCut1).getBlock();
+                        //Block corner2 = Baritone.get(cornerToCut2).getBlock();
+                        //Out.gui("Cutting conner " + cornerToCut1 + " " + corner1, Out.Mode.Debug);
+                        if (!Action.avoidWalkingInto(cornerToCut1) && !Action.avoidWalkingInto(cornerToCut2)) {
+                            double x = (next.from.getX() + next.to.getX() + 1.0D) * 0.5D;
+                            double z = (next.from.getZ() + next.to.getZ() + 1.0D) * 0.5D;
+                            MovementManager.clearMovement();
+                            if (!MovementManager.forward && curr.oneInTen != null && curr.oneInTen) {
+                                MovementManager.clearMovement();
+                                MovementManager.forward = LookManager.lookAtCoords(x, 0, z, false);
+                            } else {
+                                MovementManager.moveTowardsCoords(x, 0, z);
+                            }
+                            if (MovementManager.forward && !MovementManager.backward) {
+                                thePlayer.setSprinting(true);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+        }*/
        //long start = System.nanoTime() / 1000000L;
        BlockStateInterface bsi = new BlockStateInterface(ctx);
        for (int i = pathPosition - 10; i < pathPosition + 10; i++) {
@@ -171,10 +204,10 @@ public class PathExecutor implements IPathExecutor, Helper {
            HashSet<BlockPos> newPlace = new HashSet<>();
            HashSet<BlockPos> newWalkInto = new HashSet<>();
            for (int i = pathPosition; i < path.movements().size(); i++) {
-                Movement m = (Movement) path.movements().get(i);
-                newBreak.addAll(m.toBreak(bsi));
-                newPlace.addAll(m.toPlace(bsi));
-                newWalkInto.addAll(m.toWalkInto(bsi));
+                Movement movement = (Movement) path.movements().get(i);
+                newBreak.addAll(movement.toBreak(bsi));
+                newPlace.addAll(movement.toPlace(bsi));
+                newWalkInto.addAll(movement.toWalkInto(bsi));
            }
            toBreak = newBreak;
            toPlace = newPlace;
@@ -185,14 +218,7 @@ public class PathExecutor implements IPathExecutor, Helper {
        if (end - start > 0) {
            System.out.println("Recalculating break and place took " + (end - start) + "ms");
        }*/
-        if (pathPosition < path.movements().size() - 1) {
-            IMovement next = path.movements().get(pathPosition + 1);
-            if (!behavior.baritone.bsi.worldContainsLoadedChunk(next.getDest().x, next.getDest().z)) {
-                logDebug("Pausing since destination is at edge of loaded chunks");
-                clearKeys();
-                return true;
-            }
-        }
+        IMovement movement = path.movements().get(pathPosition);
        boolean canCancel = movement.safeToCancel();
        if (costEstimateIndex == null || costEstimateIndex != pathPosition) {
            costEstimateIndex = pathPosition;
@@ -206,7 +232,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                }
            }
        }
-        double currentCost = movement.recalculateCost(behavior.secretInternalGetCalculationContext());
+        double currentCost = ((Movement) movement).recalculateCost(behavior.secretInternalGetCalculationContext());
        if (currentCost >= ActionCosts.COST_INF && canCancel) {
            logDebug("Something has changed in the world and this movement has become impossible. Cancelling.");
            cancel();
@@ -258,13 +284,11 @@ public class PathExecutor implements IPathExecutor, Helper {
    private Tuple<Double, BlockPos> closestPathPos(IPath path) {
        double best = -1;
        BlockPos bestPos = null;
-        for (IMovement movement : path.movements()) {
-            for (BlockPos pos : ((Movement) movement).getValidPositions()) {
-                double dist = VecUtils.entityDistanceToCenter(ctx.player(), pos);
-                if (dist < best || best == -1) {
-                    best = dist;
-                    bestPos = pos;
-                }
+        for (BlockPos pos : path.positions()) {
+            double dist = VecUtils.entityDistanceToCenter(ctx.player(), pos);
+            if (dist < best || best == -1) {
+                best = dist;
+                bestPos = pos;
            }
        }
        return new Tuple<>(best, bestPos);
@@ -304,7 +328,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) {
@@ -324,7 +348,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 {
@@ -427,7 +451,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();
                }
@@ -438,7 +462,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;
            }
@@ -530,10 +554,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) {
@@ -28,14 +28,13 @@ import baritone.pathing.path.PathExecutor;
 import baritone.utils.BaritoneProcessHelper;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
-import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.EmptyChunk;

 import java.util.*;
 import java.util.stream.Collectors;

-public final class BackfillProcess extends BaritoneProcessHelper {
+public class BackfillProcess extends BaritoneProcessHelper {

    public HashMap<BlockPos, IBlockState> blocksToReplace = new HashMap<>();

@@ -85,8 +84,6 @@ public final class BackfillProcess extends BaritoneProcessHelper {
                    // patience
                    baritone.getLookBehavior().updateTarget(fake.getTarget().getRotation().get(), true);
                    return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
-                default:
-                    throw new IllegalStateException();
            }
        }
        return new PathingCommand(null, PathingCommandType.DEFER); // cede to other process
@@ -104,7 +101,7 @@ public final class BackfillProcess extends BaritoneProcessHelper {
                .keySet()
                .stream()
                .filter(pos -> ctx.world().getBlockState(pos).getBlock() == Blocks.AIR)
-                .filter(pos -> ctx.world().mayPlace(Blocks.DIRT, pos, false, EnumFacing.UP, null))
+                .filter(pos -> baritone.getBuilderProcess().placementPlausible(pos, Blocks.DIRT.getDefaultState()))
                .filter(pos -> !partOfCurrentMovement(pos))
                .sorted(Comparator.<BlockPos>comparingDouble(ctx.player()::getDistanceSq).reversed())
                .collect(Collectors.toList());
@@ -37,16 +37,19 @@ import baritone.utils.schematic.AirSchematic;
 import baritone.utils.schematic.Schematic;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import net.minecraft.block.BlockAir;
-import net.minecraft.block.BlockLiquid;
+import net.minecraft.block.BlockFlowingFluid;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
+import net.minecraft.item.BlockItemUseContext;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.*;
+import net.minecraft.util.math.shapes.VoxelShape;

 import java.io.File;
 import java.io.FileInputStream;
@@ -55,7 +58,7 @@ import java.util.*;

 import static baritone.api.pathing.movement.ActionCosts.COST_INF;

-public final class BuilderProcess extends BaritoneProcessHelper implements IBuilderProcess {
+public class BuilderProcess extends BaritoneProcessHelper implements IBuilderProcess {

    private HashSet<BetterBlockPos> incorrectPositions;
    private LongOpenHashSet observedCompleted; // positions that are completed even if they're out of render distance and we can't make sure right now
@@ -131,7 +134,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            return null;
        }
        IBlockState state = schematic.desiredState(x - origin.getX(), y - origin.getY(), z - origin.getZ());
-        if (state.getBlock() == Blocks.AIR) {
+        if (state.getBlock() instanceof BlockAir) {
            return null;
        }
        return state;
@@ -154,7 +157,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                        continue; // irrelevant
                    }
                    IBlockState curr = bcc.bsi.get0(x, y, z);
-                    if (curr.getBlock() != Blocks.AIR && !(curr.getBlock() instanceof BlockLiquid) && !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()) {
@@ -195,7 +198,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                    }
                    IBlockState curr = bcc.bsi.get0(x, y, z);
                    if (MovementHelper.isReplacable(x, y, z, curr, bcc.bsi) && !valid(curr, desired)) {
-                        if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() == Blocks.AIR) {
+                        if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() instanceof BlockAir) {
                            continue;
                        }
                        desirableOnHotbar.add(desired);
@@ -210,6 +213,11 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
        return Optional.empty();
    }

+    public boolean placementPlausible(BlockPos pos, IBlockState state) {
+        VoxelShape voxelshape = state.getCollisionShape(ctx.world(), pos);
+        return voxelshape.isEmpty() || ctx.world().checkNoEntityCollision(null, voxelshape.withOffset(pos.getX(), pos.getY(), pos.getZ()));
+    }
+
    private Optional<Placement> possibleToPlace(IBlockState toPlace, int x, int y, int z, BlockStateInterface bsi) {
        for (EnumFacing against : EnumFacing.values()) {
            BetterBlockPos placeAgainstPos = new BetterBlockPos(x, y, z).offset(against);
@@ -217,17 +225,20 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            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));
@@ -249,18 +260,24 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            // the state depends on the facing of the player sometimes
            ctx.player().rotationYaw = rot.getYaw();
            ctx.player().rotationPitch = rot.getPitch();
-            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);
            }
@@ -359,14 +376,14 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            logDirect("Repeating build in vector " + repeat + ", new origin is " + origin);
            return onTick(calcFailed, isSafeToCancel);
        }
-        trim();
+        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()) {
@@ -447,7 +464,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
        return !incorrectPositions.isEmpty();
    }

-    private void trim() {
+    private void trim(BuilderCalculationContext bcc) {
        HashSet<BetterBlockPos> copy = new HashSet<>(incorrectPositions);
        copy.removeIf(pos -> pos.distanceSq(ctx.player().posX, ctx.player().posY, ctx.player().posZ) > 200);
        if (!copy.isEmpty()) {
@@ -523,7 +540,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                    placable.add(pos);
                }
            } else {
-                if (state.getBlock() instanceof BlockLiquid) {
+                if (state.getBlock() instanceof BlockFlowingFluid) {
                    // if the block itself is JUST a liquid (i.e. not just a waterlogged block), we CANNOT break it
                    // TODO for 1.13 make sure that this only matches pure water, not waterlogged blocks
                    if (!MovementHelper.possiblyFlowing(state)) {
@@ -598,12 +615,12 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
    }

    private Goal placementGoal(BlockPos pos, BuilderCalculationContext bcc) {
-        if (ctx.world().getBlockState(pos).getBlock() != Blocks.AIR) { // TODO can this even happen?
+        if (!(ctx.world().getBlockState(pos).getBlock() instanceof BlockAir)) {  // TODO can this even happen?
            return new GoalPlace(pos);
        }
-        boolean allowSameLevel = ctx.world().getBlockState(pos.up()).getBlock() != Blocks.AIR;
-        for (EnumFacing facing : Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP) {
-            if (MovementHelper.canPlaceAgainst(ctx, pos.offset(facing)) && ctx.world().mayPlace(bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()).getBlock(), pos, false, facing, null)) {
+        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)) && placementPlausible(pos, bcc.getSchematic(pos.getX(), pos.getY(), pos.getZ()))) {
                return new GoalAdjacent(pos, allowSameLevel);
            }
        }
@@ -688,15 +705,21 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                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;
    }

    private boolean valid(IBlockState current, IBlockState desired) {
+        if (desired == null) {
+            return true;
+        }
+        if (current.getBlock() instanceof BlockAir && desired.getBlock() instanceof BlockAir) {
+            return true;
+        }
        // TODO more complicated comparison logic I guess
-        return desired == null || current.equals(desired);
+        return current.equals(desired);
    }

    public class BuilderCalculationContext extends CalculationContext {
@@ -734,7 +757,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            IBlockState sch = getSchematic(x, y, z);
            if (sch != null) {
                // TODO this can return true even when allowPlace is off.... is that an issue?
-                if (sch.getBlock() == 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
@@ -767,7 +790,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            }
            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;
@@ -29,7 +29,7 @@ import baritone.utils.BaritoneProcessHelper;
 *
 * @author leijurv
 */
-public final class CustomGoalProcess extends BaritoneProcessHelper implements ICustomGoalProcess {
+public class CustomGoalProcess extends BaritoneProcessHelper implements ICustomGoalProcess {

    /**
     * The current goal
@@ -41,7 +41,7 @@ import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;

-public final class ExploreProcess extends BaritoneProcessHelper implements IExploreProcess {
+public class ExploreProcess extends BaritoneProcessHelper implements IExploreProcess {

    private BlockPos explorationOrigin;

@@ -122,7 +122,6 @@ public final class ExploreProcess extends BaritoneProcessHelper implements IExpl
                            break; // note: this breaks the switch not the for
                        case EXPLORED:
                            continue; // note: this continues the for
-                        default:
                    }
                    int centerX = ((chunkX + dx) << 4) + 8;
                    int centerZ = ((chunkZ + dz) << 4) + 8;
@@ -36,9 +36,7 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
-import net.minecraft.item.EnumDyeColor;
 import net.minecraft.item.Item;
-import net.minecraft.item.ItemDye;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
@@ -50,7 +48,7 @@ import java.util.List;
 import java.util.Optional;
 import java.util.function.Predicate;

-public final class FarmProcess extends BaritoneProcessHelper implements IFarmProcess {
+public class FarmProcess extends BaritoneProcessHelper implements IFarmProcess {

    private boolean active;

@@ -67,18 +65,18 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
            Items.BEETROOT_SEEDS,
            Items.WHEAT,
            Items.MELON_SEEDS,
-            Items.MELON,
+            Items.MELON_SLICE,
            Items.WHEAT_SEEDS,
            Items.WHEAT,
            Items.PUMPKIN_SEEDS,
            Items.POTATO,
            Items.CARROT,
            Items.BEETROOT,
-            Item.getItemFromBlock(Blocks.PUMPKIN),
-            Item.getItemFromBlock(Blocks.MELON_BLOCK),
+            Blocks.PUMPKIN.asItem(),
+            Blocks.MELON.asItem(),
            Items.NETHER_WART,
-            Items.REEDS,
-            Item.getItemFromBlock(Blocks.CACTUS)
+            Blocks.SUGAR_CANE.asItem(),
+            Blocks.CACTUS.asItem()
    );

    public FarmProcess(Baritone baritone) {
@@ -101,9 +99,9 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
        POTATOES((BlockCrops) Blocks.POTATOES),
        BEETROOT((BlockCrops) Blocks.BEETROOTS),
        PUMPKIN(Blocks.PUMPKIN, state -> true),
-        MELON(Blocks.MELON_BLOCK, state -> true),
-        NETHERWART(Blocks.NETHER_WART, state -> state.getValue(BlockNetherWart.AGE) >= 3),
-        SUGARCANE(Blocks.REEDS, null) {
+        MELON(Blocks.MELON, state -> true),
+        NETHERWART(Blocks.NETHER_WART, state -> state.get(BlockNetherWart.AGE) >= 3),
+        SUGARCANE(Blocks.SUGAR_CANE, null) {
            @Override
            public boolean readyToHarvest(World world, BlockPos pos, IBlockState state) {
                return world.getBlockState(pos.down()).getBlock() instanceof BlockReed;
@@ -147,7 +145,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
    }

    private boolean isBoneMeal(ItemStack stack) {
-        return !stack.isEmpty() && stack.getItem() instanceof ItemDye && EnumDyeColor.byDyeDamage(stack.getMetadata()) == EnumDyeColor.WHITE;
+        return !stack.isEmpty() && stack.getItem().equals(Items.BONE_MEAL);
    }

    private boolean isNetherWart(ItemStack stack) {
@@ -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())) {
@@ -82,12 +82,7 @@ public final class FollowProcess extends BaritoneProcessHelper implements IFollo
    }

    private void scanWorld() {
-        cache = Stream.of(ctx.world().loadedEntityList, ctx.world().playerEntities)
-            .flatMap(List::stream)
-            .filter(this::followable)
-            .filter(this.filter)
-            .distinct()
-            .collect(Collectors.toCollection(ArrayList::new));
+        cache = Stream.of(ctx.world().loadedEntityList, ctx.world().playerEntities).flatMap(List::stream).filter(this::followable).filter(this.filter).distinct().collect(Collectors.toCollection(ArrayList::new));
    }

    @Override
@@ -34,7 +34,7 @@ import net.minecraft.util.math.BlockPos;

 import java.util.*;

-public final class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBlockProcess {
+public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBlockProcess {

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

    private boolean rightClickOnArrival(Block block) {
@@ -79,11 +79,11 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
    @Override
    public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
        if (desiredQuantity > 0) {
-            Item item = mining.get(0).getItemDropped(mining.get(0).getDefaultState(), 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;
            }
@@ -114,7 +114,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
                .filter(pos -> !(BlockStateInterface.get(ctx, pos).getBlock() instanceof BlockAir)) // after breaking a block, it takes mineGoalUpdateInterval ticks for it to actually update this list =(
                .min(Comparator.comparingDouble(ctx.player()::getDistanceSq));
        baritone.getInputOverrideHandler().clearAllKeys();
-        if (shaft.isPresent() && ctx.player().onGround) {
+        if (shaft.isPresent()) {
            BlockPos pos = shaft.get();
            IBlockState state = baritone.bsi.get0(pos);
            if (!MovementHelper.avoidBreaking(baritone.bsi, pos.getX(), pos.getY(), pos.getZ(), state)) {
@@ -281,12 +281,12 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro

    public static List<BlockPos> droppedItemsScan(List<Block> mining, World world) {
        if (!Baritone.settings().mineScanDroppedItems.value) {
-            return Collections.emptyList();
+            return new ArrayList<>();
        }
        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);
        }
@@ -24,14 +24,21 @@ import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalBlock;
 import baritone.api.utils.Helper;
 import baritone.api.utils.IPlayerContext;
+import net.minecraft.client.GameSettings;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiMainMenu;
-import net.minecraft.client.settings.GameSettings;
 import net.minecraft.client.tutorial.TutorialSteps;
+import net.minecraft.server.integrated.IntegratedServer;
+import net.minecraft.util.HttpUtil;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.GameType;
 import net.minecraft.world.WorldSettings;
 import net.minecraft.world.WorldType;
+import net.minecraft.world.dimension.DimensionType;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;

 /**
 * Responsible for automatically testing Baritone's pathing algorithm by automatically creating a world with a specific
@@ -89,11 +96,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
@@ -101,7 +110,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
@@ -123,7 +132,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
@@ -54,7 +54,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);
@@ -38,7 +38,7 @@ public class BlockPlaceHelper implements Helper {
            return;
        }
        RayTraceResult mouseOver = ctx.objectMouseOver();
-        if (!rightClickRequested || ctx.player().isRowingBoat() || mouseOver == null || mouseOver.getBlockPos() == null || mouseOver.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;
@@ -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();
        }
    }
@@ -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,22 +53,26 @@ 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();
            }
        }
+
    }

    @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);
@@ -84,17 +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();
@@ -102,16 +104,16 @@ public class GuiClick extends GuiScreen {
            PathRenderer.drawManySelectionBoxes(e, Collections.singletonList(currentMouseOver), Color.CYAN);
            if (clickStart != null && !clickStart.equals(currentMouseOver)) {
                GlStateManager.enableBlend();
-                GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-                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();
@@ -120,11 +122,195 @@ public class GuiClick extends GuiScreen {
        }
    }

-    private 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());
+    public Vec3d toWorld(double x, double y, double z) {
+        boolean result = gluUnProject((float) x, (float) y, (float) z, MODELVIEW, PROJECTION, VIEWPORT, (FloatBuffer) TO_WORLD_BUFFER.clear());
        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);
+    }
 }
@@ -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
@@ -34,10 +34,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;
@@ -52,6 +54,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();

@@ -64,8 +67,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
@@ -131,13 +134,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;
@@ -174,13 +177,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(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);
@@ -202,14 +205,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();
        }


@@ -217,17 +220,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);
@@ -301,10 +301,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(
@@ -313,14 +313,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();
@@ -356,13 +360,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);
@@ -380,7 +384,7 @@ public final class PathRenderer implements Helper {
        TESSELLATOR.draw();

        if (Baritone.settings().renderGoalIgnoreDepth.value) {
-            GlStateManager.enableDepth();
+            GlStateManager.enableDepthTest();
        }
        GlStateManager.depthMask(true);
        GlStateManager.enableTexture2D();
@@ -92,7 +92,7 @@ public class PathingControlManager implements IPathingControlManager {
            p.secretInternalSetGoal(null);
            return;
        }
-        if (!Objects.equals(inControlThisTick, inControlLastTick) && command.commandType != PathingCommandType.REQUEST_PAUSE && inControlLastTick != null && !inControlLastTick.isTemporary()) {
+        if (inControlThisTick != inControlLastTick && command.commandType != PathingCommandType.REQUEST_PAUSE && inControlLastTick != null && !inControlLastTick.isTemporary()) {
            // if control has changed from a real process to another real process, and the new process wants to do something
            p.cancelSegmentIfSafe();
            // get rid of the in progress stuff from the last process
@@ -23,7 +23,7 @@ import net.minecraft.util.MovementInput;
 public class PlayerMovementInput extends MovementInput {
    private final InputOverrideHandler handler;

-    PlayerMovementInput(InputOverrideHandler handler) {
+    public PlayerMovementInput(InputOverrideHandler handler) {
        this.handler = handler;
    }

@@ -31,7 +31,7 @@ public class PlayerMovementInput extends MovementInput {
        this.moveStrafe = 0.0F;
        this.moveForward = 0.0F;

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

        if (this.forwardKeyDown = handler.isInputForcedDown(Input.MOVE_FORWARD)) {
            this.moveForward++;
@@ -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;
    }

    /**
@@ -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 {
@@ -64,13 +64,10 @@ public class Avoidance {
        double mobSpawnerCoeff = Baritone.settings().mobSpawnerAvoidanceCoefficient.value;
        double mobCoeff = Baritone.settings().mobAvoidanceCoefficient.value;
        if (mobSpawnerCoeff != 1.0D) {
-            ctx.worldData().getCachedWorld().getLocationsOf("mob_spawner", 1, ctx.playerFeet().x, ctx.playerFeet().z, 2)
-                    .forEach(mobspawner -> res.add(new Avoidance(mobspawner, mobSpawnerCoeff, Baritone.settings().mobSpawnerAvoidanceRadius.value)));
+            ctx.worldData().getCachedWorld().getLocationsOf("mob_spawner", 1, ctx.playerFeet().x, ctx.playerFeet().z, 2).forEach(mobspawner -> res.add(new Avoidance(mobspawner, mobSpawnerCoeff, Baritone.settings().mobSpawnerAvoidanceRadius.value)));
        }
        if (mobCoeff != 1.0D) {
-            ctx.world().loadedEntityList.stream()
-                    .filter(entity -> entity instanceof EntityMob)
-                    .forEach(entity -> res.add(new Avoidance(new BlockPos(entity), mobCoeff, Baritone.settings().mobAvoidanceRadius.value)));
+            ctx.world().loadedEntityList.stream().filter(entity -> entity instanceof EntityMob).forEach(entity -> res.add(new Avoidance(new BlockPos(entity), mobCoeff, Baritone.settings().mobAvoidanceRadius.value)));
        }
        return res;
    }
@@ -51,7 +51,7 @@ public class SegmentedCalculator {
    private Optional<IPath> doCalc() {
        Optional<IPath> soFar = Optional.empty();
        while (true) {
-            PathCalculationResult result = segment(soFar.orElse(null));
+            PathCalculationResult result = segment(soFar);
            switch (result.getType()) {
                case SUCCESS_SEGMENT:
                case SUCCESS_TO_GOAL:
@@ -62,8 +62,8 @@ public class SegmentedCalculator {
                default: // CANCELLATION and null should not be possible, nothing else has access to this, so it can't have been canceled
                    throw new IllegalStateException();
            }
-            IPath segment = result.getPath().orElseThrow(IllegalStateException::new); // path calculation result type is SUCCESS_SEGMENT, so the path must be present
-            IPath combined = soFar.map(previous -> (IPath) SplicedPath.trySplice(previous, segment, true).orElseThrow(IllegalStateException::new)).orElse(segment);
+            IPath segment = result.getPath().get(); // path calculation result type is SUCCESS_SEGMENT, so the path must be present
+            IPath combined = soFar.map(previous -> (IPath) SplicedPath.trySplice(previous, segment, true).get()).orElse(segment);
            loadAdjacent(combined.getDest().getX(), combined.getDest().getZ());
            soFar = Optional.of(combined);
            if (result.getType() == PathCalculationResult.Type.SUCCESS_TO_GOAL) {
@@ -85,9 +85,9 @@ public class SegmentedCalculator {
        }
    }

-    private PathCalculationResult segment(IPath previous) {
-        BetterBlockPos segmentStart = previous != null ? previous.getDest() : start;
-        AbstractNodeCostSearch search = new AStarPathFinder(segmentStart.x, segmentStart.y, segmentStart.z, goal, new Favoring(previous, context), context); // this is on another thread, so cannot include mob avoidances.
+    private PathCalculationResult segment(Optional<IPath> previous) {
+        BetterBlockPos segmentStart = previous.map(IPath::getDest).orElse(start); // <-- e p i c
+        AbstractNodeCostSearch search = new AStarPathFinder(segmentStart.x, segmentStart.y, segmentStart.z, goal, new Favoring(previous.orElse(null), context), context); // this is on another thread, so cannot include mob avoidances.
        return search.calculate(Baritone.settings().primaryTimeoutMS.value, Baritone.settings().failureTimeoutMS.value); // use normal time settings, not the plan ahead settings, so as to not overwhelm the computer
    }

@@ -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 {
@@ -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
@@ -50,14 +50,14 @@ public class OpenSetsTest {
        return testSizes;
    }

-    private static void removeAndTest(int amount, IOpenSet[] test, Collection<PathNode> mustContain) {
+    private static void removeAndTest(int amount, IOpenSet[] test, Optional<Collection<PathNode>> mustContain) {
        double[][] results = new double[test.length][amount];
        for (int i = 0; i < test.length; i++) {
            long before = System.nanoTime() / 1000000L;
            for (int j = 0; j < amount; j++) {
                PathNode pn = test[i].removeLowest();
-                if (mustContain != null && !mustContain.contains(pn)) {
-                    throw new IllegalStateException(mustContain + " " + pn);
+                if (mustContain.isPresent() && !mustContain.get().contains(pn)) {
+                    throw new IllegalStateException(mustContain.get() + " " + pn);
                }
                results[i][j] = pn.combinedCost;
            }
@@ -131,7 +131,7 @@ public class OpenSetsTest {

        System.out.println("Removal round 1");
        // remove a quarter of the nodes and verify that they are indeed the size/4 lowest ones
-        removeAndTest(size / 4, test, lowestQuarter);
+        removeAndTest(size / 4, test, Optional.of(lowestQuarter));

        // none of them should be empty (sanity check)
        for (IOpenSet set : test) {
@@ -160,7 +160,7 @@ public class OpenSetsTest {

        System.out.println("Removal round 2");
        // remove the remaining 3/4
-        removeAndTest(size - size / 4, test, null);
+        removeAndTest(size - size / 4, test, Optional.empty());

        // every set should now be empty
        for (IOpenSet set : test) {
Author	SHA1	Message	Date
Leijurv	16b74ff53c	v1.3.2	2019-05-16 14:57:26 -07:00
Leijurv	9297e98ac3	Merge branch 'master' into 1.13.2	2019-05-16 14:55:37 -07:00
Leijurv	b521d7bee1	fix dummy merge typo	2019-05-02 11:42:49 -07:00
Leijurv	4e96c5e5ee	Merge branch 'master' into 1.13.2	2019-05-01 23:12:19 -07:00
Leijurv	ec819220b7	Merge branch 'master' into 1.13.2	2019-05-01 12:15:31 -07:00
Brady	3d3a5f420e	Fix unsafe creation of potentially invalid ResourceLocation	2019-04-16 20:15:51 -05:00
Leijurv	9c9c9d4387	fix region pruning	2019-04-14 10:06:37 -07:00
Leijurv	82d09a536d	v1.3.1	2019-04-13 19:21:44 -07:00
Leijurv	6e49adea33	i WUV impact	2019-04-13 19:10:13 -07:00
Leijurv	f85afdbc70	Merge branch 'master' into 1.13.2	2019-04-12 21:57:01 -07:00
Leijurv	563028a5b3	fix invalid player move packet, and a bunch of things in world scanner	2019-04-09 19:30:48 -07:00
Leijurv	d5c317b88b	Merge branch 'master' into 1.13.2	2019-04-09 18:17:53 -07:00
Leijurv	c59ec9da10	blank space	2019-03-23 22:17:40 -08:00
Leijurv	3a675836da	Merge pull request #370 from babbaj/patch-1 use runAutoTest	2019-03-23 13:03:19 -07:00
babbaj	7e0fc81246	use runAutoTest	2019-03-23 15:55:16 -04:00
Leijurv	f970f932c7	great	2019-03-23 10:52:03 -07:00
Leijurv	52d2741f52	and lets try making it fail delibrately	2019-03-23 10:31:36 -07:00
Leijurv	7bc6765cac	rart	2019-03-23 10:13:14 -07:00
Leijurv	85b2aea6e9	where is this writing???	2019-03-23 09:52:49 -07:00
Leijurv	c6ba5481d9	one final attempt	2019-03-22 22:33:40 -07:00
Leijurv	81f47d5632	forgot file name lollll	2019-03-22 22:19:13 -07:00
Leijurv	9b1440ed2c	that needs to be allowed	2019-03-22 22:07:12 -07:00
Leijurv	2a8dcee028	write to a file to indicate success	2019-03-22 22:05:27 -07:00
Leijurv	277ba3643c	Merge branch 'master' into 1.13.2	2019-03-22 21:24:43 -07:00
Leijurv	e5fbaf60f3	shutdownminecraftapplet	2019-03-22 21:04:35 -07:00
Leijurv	0deb854e1b	v1.3.0	2019-03-21 16:40:18 -07:00
Leijurv	8268e3ec1b	Merge branch 'master' into 1.13.2	2019-03-21 15:51:36 -07:00
Leijurv	af91da6a28	Merge branch 'master' into 1.13.2	2019-03-19 18:12:26 -07:00
Leijurv	9a15a65ad5	not needed anymore	2019-03-19 13:59:56 -07:00
Leijurv	0cbe9f81c8	Merge branch 'master' into 1.13.2	2019-03-15 16:58:23 -07:00
Leijurv	42afd2dd54	maybe proper exit code	2019-03-15 16:49:36 -07:00
Leijurv	315929f31c	hey so what if we didnt do that	2019-03-15 16:39:59 -07:00
Leijurv	358aa80280	docker time	2019-03-15 16:22:51 -07:00
Leijurv	1dd9e11994	documentation resigned	2019-03-15 16:19:07 -07:00
Leijurv	5a8f02c944	unscuff everything	2019-03-15 16:11:14 -07:00
Leijurv	f248a5b677	make runClient work	2019-03-15 15:32:51 -07:00
Leijurv	e4a49c5529	fix launchtesting not found on runClient	2019-03-15 14:00:11 -07:00
Leijurv	449b44ba50	line	2019-03-14 16:32:14 -07:00
Leijurv	a00eec402e	i love retina wtf	2019-03-14 16:32:04 -07:00
Leijurv	717779f742	air is stupid	2019-03-14 16:06:32 -07:00
Leijurv	6f843bd24d	Merge branch 'master' into 1.13.2	2019-03-13 20:09:08 -07:00
Leijurv	d79fbea433	scuffed air	2019-03-13 18:08:15 -07:00
Leijurv	4d22c10ddb	unscuff water, thanks wwe	2019-03-12 23:08:06 -07:00
Leijurv	1ea92a6092	😎	2019-03-12 22:49:23 -07:00
Leijurv	66eba84d06	consistent spacing	2019-03-12 18:54:36 -07:00
Leijurv	92e39b5d1d	its over its done	2019-03-12 18:45:54 -07:00
Leijurv	0ddc47f473	i am rarted	2019-03-12 18:21:29 -07:00
Leijurv	ddfeca6947	unproject click cursed	2019-03-12 18:00:30 -07:00
Leijurv	6bd2e90cfd	crash when pathing near shulker boxes	2019-03-12 17:18:58 -07:00
Leijurv	82505ddb01	online mode via env	2019-03-12 17:18:52 -07:00
Leijurv	2790d1d308	Merge branch 'master' into 1.13.2	2019-03-12 16:19:06 -07:00
Leijurv	11e503a022	many fixes	2019-03-12 16:17:43 -07:00
Leijurv	6fe49380ba	pwned	2019-03-12 15:42:25 -07:00
Leijurv	1f2e267e3d	fix a bunch of scuff	2019-03-12 15:41:58 -07:00
Leijurv	4cf6783622	fix the tests	2019-03-12 09:38:05 -07:00
Brady	82d77a7bac	Update MixinGradle to 0.6.2 Includes fix ensuring that the SRGs are generated prior to Mixin annotation processing	2019-03-12 01:43:03 -05:00
Brady	841a927033	Merge remote-tracking branch 'origin/master' into 1.13.2	2019-03-12 01:09:11 -05:00
Brady	5a16561954	Working 1.13.2 development environment Including a couple bugfixes to bad 1.13.2 code!!!	2019-03-12 01:05:39 -05:00
Brady	e2cc51908b	Notch builds	2019-03-08 23:18:00 -06:00
Brady	1390e04435	Add versions in parenthesis for todos to fix stuff	2019-03-08 15:14:52 -06:00
Brady	84d961cbab	Fix usages of Setting#get()	2019-03-08 15:12:55 -06:00
Brady	87b9d3915c	Fix compiler errors unproject needs to be resolved	2019-03-08 15:03:58 -06:00
Brady	c38d17563d	Resolve merge conflicts oh my god I should've updated my local branch before doing this	2019-03-08 14:44:49 -06:00
Brady	0c2af85ac0	Update to 1.13.2 Still need to setup method of launching, and Mixin support for ModLauncher	2019-03-08 14:30:43 -06:00