Merge branch 'master' into patch-1

.github/ISSUE_TEMPLATE/bug.md

@@ -14,12 +14,22 @@ Baritone version:
 Forge mods (if used): 
 
 ## Exception, error or logs
-You can find your logs in `%appdata%/.minecraft/logs/` (Windows) or `/Library/Application\ Support/minecraft/logs` (Mac).
+Please find your `latest.log` or `debug.log` in this folder and attach it to the issue
+
+Linux: `~/.minecraft/logs/`
+
+Windows: `%appdata%/.minecraft/logs/`
+
+Mac: `/Library/Application\ Support/minecraft/logs/`
 
 ## How to reproduce
 Add your steps to reproduce the issue/bug experienced here.
 
+## Modified settings
+To get the modified settings run `#modified` in game
+
 ## Final checklist
+- [x] I know how to properly use check boxes 
 - [ ] I have included the version of Minecraft I'm running, baritone's version and forge mods (if used).
 - [ ] I have included logs, exceptions and / or steps to reproduce the issue.
 - [ ] I have not used any OwO's or UwU's in this issue.

.github/ISSUE_TEMPLATE/question.md

@@ -10,4 +10,5 @@ assignees: ''
 With as much detail as possible, describe your question and what you may need help with.
 
 ## Final checklist
+- [x] I know how to properly use check boxes 
 - [ ] I have not used any OwO's or UwU's in this issue.

.github/ISSUE_TEMPLATE/suggestion.md

@@ -16,4 +16,5 @@ If applicable, what settings/customizability should be offered to tweak the func
 Describe how your suggestion would improve Baritone, or the reason behind it being added.
 
 ## Final checklist
+- [x] I know how to properly use check boxes 
 - [ ] I have not used any OwO's or UwU's in this issue.

.gitmessage

@@ -0,0 +1,31 @@
+<emoji> <title> (<ticket>)
+
+# 📝 Update README.md (WD-1234)
+# ✅ Add unit test for inputs (WD-1234)
+
+# <emoji> can be:
+# 🎨 :art: when improving structure of the code
+# ⚡️ :zap: when improving performance
+# 🔥 :fire: when removing code or files
+# ✨ :sparkles: when introducing new features
+# 🚧 :construction: when work in progress
+# 🔨 :hammer: when refactoring code
+# 📝 :memo: when writing docs
+# 💄 :lipstick: when updating the UI and style files
+# 📈 :chart_with_upwards_trend: when adding analytics or tracking code
+# 🌐 :globe_with_meridians: when adding internationalization and localization
+# ✏️ :pencil2: when fixing typos
+# 🚚 :truck: when moving or renaming files
+# ✅ :white_check_mark: when adding tests
+
+# 👌 :ok_hand: when updating code due to code review changes
+# 🐛 :bug: when fixing a bug
+# 🚑 :ambulance: when doing a critical hotfix
+# 🚨 :rotating_light: when removing linter warnings
+
+# 🔀 :twisted_rightwards_arrows: when merging branches
+# ⬆️ :arrow_up: when upgrading dependencies
+# ⬇️ :arrow_down: when downgrading dependencies
+# 🔧 :wrench: when changing configuration files
+# 🔖 :bookmark: when releasing / version tagging
+# 💚 :green_heart: when fixing the CI build

.travis.yml

@@ -9,8 +9,8 @@ install:
 - travis_retry docker build -t cabaletta/baritone .
 
 script:
-- docker run --rm cabaletta/baritone ./gradlew javadoc
+- docker run --name baritone 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 "set -e; /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -screen 0 128x128x24 -ac +extension GLX +render; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runClient"
 - docker cp baritone:/code/dist dist
 - ls dist
 - cat dist/checksums.txt

README.md

@@ -1,13 +1,15 @@
 # Baritone
+[![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/)
+
 [![Build Status](https://travis-ci.com/cabaletta/baritone.svg?branch=master)](https://travis-ci.com/cabaletta/baritone/)
 [![Release](https://img.shields.io/github/release/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/releases/)
 [![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&utm_medium=referral&utm_content=cabaletta/baritone&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-brightgreen.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/)
 [![Minecraft](https://img.shields.io/badge/MC-1.14.4-brightgreen.svg)](https://github.com/cabaletta/baritone/tree/1.14.4/)
+[![Minecraft](https://img.shields.io/badge/MC-1.15.2-brightgreen.svg)](https://github.com/cabaletta/baritone/tree/1.15.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/)
@@ -19,24 +21,27 @@
 ![Lines of Code](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
 [![GitHub contributors](https://img.shields.io/github/contributors/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/graphs/contributors/)
 [![GitHub commits](https://img.shields.io/github/commits-since/cabaletta/baritone/v1.0.0.svg)](https://github.com/cabaletta/baritone/commit/)
-[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.10%20/%20v1.3.5%20/%20v1.4.2-brightgreen.svg)](https://impactclient.net/)
+[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.14%20/%20v1.3.8%20/%20v1.4.6%20/%20v1.5.3-brightgreen.svg)](https://impactclient.net/)
+[![KAMI Blue integration](https://img.shields.io/badge/KAMI%20Blue%20integration-v1.2.14--master-green)](https://github.com/kami-blue/client)
 [![ForgeHax integration](https://img.shields.io/badge/ForgeHax%20%22integration%22-scuffed-yellow.svg)](https://github.com/fr1kin/ForgeHax/)
 [![Aristois add-on integration](https://img.shields.io/badge/Aristois%20add--on%20integration-v1.3.4%20/%20v1.4.1-green.svg)](https://gitlab.com/emc-mods-indrit/baritone_api)
+[![rootNET integration](https://img.shields.io/badge/rootNET%20integration-v1.2.11-green.svg)](https://rootnet.dev/)
 [![WWE integration](https://img.shields.io/badge/WWE%20%22integration%22-master%3F-green.svg)](https://wweclient.com/)
-[![Future integration](https://img.shields.io/badge/Future%20integration-Soon™%3F%3F%3F-red.svg)](https://futureclient.net/)
+[![Future integration](https://img.shields.io/badge/Future%20integration-v1.2.12%20%2F%20v1.3.6%20%2F%20v1.4.4-red)](https://futureclient.net/)
+[![RusherHack integration](https://img.shields.io/badge/RusherHack%20integration-v1.2.14-green)](https://rusherhack.org/)
 [![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://impactclient.net/) 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.
+Baritone is the pathfinding system used in [Impact](https://impactclient.net/) since 4.4. There's a [showcase video](https://youtu.be/CZkLXWo4Fg4) made by @Adovin#0730 on Baritone which I recommend. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a (very old!) video I made showing off what it can do.
 
-The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* forge API jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* `api-forge` jar from [releases](https://github.com/cabaletta/baritone/releases). **For 1.12.2 Forge, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.2.14/baritone-api-forge-1.2.14.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
 
-For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1). Or [with optifine](https://github.com/cabaletta/baritone/issues/797).
+For 1.15.2, [click here](https://www.youtube.com/watch?v=j1qKtCZFURM) and see description. If you need Forge 1.15.2, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.5.3), follow the instructions, and get the `api-forge` jar.
 
 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 through 1.15.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 from Aug 1, 2018, to Aug 1, 2019.
 
@@ -56,6 +61,10 @@ Here are some links to help to get started:
 
 - [Usage (chat control)](USAGE.md)
 
+## Stars over time
+
+[![Stargazers over time](https://starchart.cc/cabaletta/baritone.svg)](https://starchart.cc/cabaletta/baritone)
+
 # API
 
 The API is heavily documented, you can find the Javadocs for the latest release [here](https://baritone.leijurv.com/).
@@ -81,6 +90,16 @@ That's what it's for, sure! (As long as usage complies with the LGPL 3.0 License
 
 Magic. (Hours of [leijurv](https://github.com/leijurv/) enduring excruciating pain)
 
+### Additional Special Thanks To:
+
+![YourKit-Logo](https://www.yourkit.com/images/yklogo.png)
+
+YourKit supports open source projects with innovative and intelligent tools for monitoring and profiling Java and .NET applications.
+
+YourKit is the creator of the [YourKit Java Profiler](https://www.yourkit.com/java/profiler/), [YourKit .NET Profiler](https://www.yourkit.com/.net/profiler/), and [YourKit YouMonitor](https://www.yourkit.com/youmonitor/).
+
+We thank them for granting Baritone an OSS license so that we can make our software the best it can be.
+
 ## Why is it called Baritone?
 
 It's named for FitMC's deep sultry voice.

SETUP.md

@@ -2,7 +2,7 @@
 
 The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone.
 
-For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1).
+You can also use a custom version json for Minecraft, with the [1.14.4](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1) version or the [1.15.2](https://www.dropbox.com/s/8rx6f0kts9hvd4f/1.15.2-Baritone.zip?dl=1) version
 
 Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
 
@@ -47,6 +47,8 @@ You can verify whether or not it worked by running `.b version` in chat (only va
 ## Command Line
 On Mac OSX and Linux, use `./gradlew` instead of `gradlew`.
 
+If you have errors with a package missing please make sure you have setup your environment, and are using Oracle JDK 8.
+
 Setting up the Environment:
 
 ```
@@ -54,6 +56,12 @@ $ gradlew setupDecompWorkspace
 $ gradlew --refresh-dependencies
 ```
 
+Building Baritone: 
+
+```
+$ gradlew build
+```
+
 Running Baritone:
 
 ```
@@ -87,16 +95,6 @@ For information on how to build baritone, see [Building Baritone](#building-bari
   
   ![Image](https://i.imgur.com/hrLhG9u.png)
 
-# Building
-
-Make sure that you have properly [setup](#setup) the environment before trying to build it.
-
-## Command Line
-
-```
-$ gradlew build
-```
-
 ## IntelliJ
 
 - Navigate to the gradle tasks on the right tab as follows

USAGE.md

@@ -14,11 +14,19 @@ Lots of the commands have changed, BUT `#help` is improved vastly (its clickable
 
 Try `#help` I promise it won't just send you back here =)
 
+"wtf where is cleararea" -> look at `#help sel`
+
+"wtf where is goto death, goto waypoint" -> look at `#help wp` 
+
+just look at `#help` lmao
+
+Watch this [showcase video](https://youtu.be/CZkLXWo4Fg4)!
+
 # 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`
 
 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`.
 
@@ -32,11 +40,11 @@ Some common examples:
 - `goto portal` or `goto ender_chest` or `goto block_type` to go to a block. (in Impact, `.goto` is an alias for `.b goto` for the most part)
 - `mine diamond_ore iron_ore` to mine diamond ore or iron ore (turn on the setting `legitMine` to only mine ores that it can actually see. It will explore randomly around y=11 until it finds them.) An amount of blocks can also be specified, for example, `mine diamond_ore 64`.
 - `click` to click your destination on the screen. Right click path to on top of the block, left click to path into it (either at foot level or eye level), and left click and drag to clear all blocks from an area.
-- `follow playerName` to follow a player. `followplayers` to follow any players in range (combine with Kill Aura for a fun time). `followentities` to follow any entities. `followentity pig` to follow entities of a specific type.
+- `follow player playerName` to follow a player. `follow players` to follow any players in range (combine with Kill Aura for a fun time). `follow entities` to follow any entities. `follow entity pig` to follow entities of a specific type.
-- `save waypointName` to save a waypoint. `goto waypointName` to go to it.
+- `wp` for waypoints. A "tag" is like "home" (created automatically on right clicking a bed) or "death" (created automatically on death) or "user" (has to be created manually). So you might want `#wp save user coolbiome`, then to set the goal `#wp goal coolbiome` then `#path` to path to it. For death, `#wp goal death` will list waypoints under the "death" tag (remember stuff is clickable!)
-- `build` to build a schematic. `build blah` will load `schematics/blah.schematic` and build it with the origin being your player feet. `build blah x y z` to set the origin. Any of those can be relative to your player (`~ 69 ~-420` would build at x=player x, y=69, z=player z-420).
+- `build` to build a schematic. `build blah.schematic` will load `schematics/blah.schematic` and build it with the origin being your player feet. `build blah.schematic x y z` to set the origin. Any of those can be relative to your player (`~ 69 ~-420` would build at x=player x, y=69, z=player z-420).
 - `schematica` to build the schematic that is currently open in schematica
-- `tunnel` to dig just straight ahead and make a tunnel
+- `tunnel` to dig and make a tunnel, 1x2. It will only deviate from the straight line if necessary such as to avoid lava. For a dumber tunnel that is really just cleararea, you can `tunnel 3 2 100`, to clear an area 3 high, 2 wide, and 100 deep.
 - `farm` to automatically harvest, replant, or bone meal crops
 - `axis` to go to an axis or diagonal axis at y=120 (`axisHeight` is a configurable setting, defaults to 120).
 - `explore x z` to explore the world from the origin of x,z. Leave out x and z to default to player feet. This will continually path towards the closest chunk to the origin that it's never seen before. `explorefilter filter.json` with optional invert can be used to load in a list of chunks to load.
@@ -44,7 +52,7 @@ Some common examples:
 - `version` to get the version of Baritone you're running
 - `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://baritone.leijurv.com/baritone/api/Settings.html).
 
 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>.
 
@@ -65,6 +73,8 @@ There are about a hundred settings, but here are some fun / interesting / import
 - `worldExploringChunkOffset`
 - `acceptableThrowawayItems`
 - `blocksToAvoidBreaking`
+- `mineScanDroppedItems`
+- `allowDiagonalAscend`
 
 
 
@@ -84,4 +94,4 @@ So you'll need to use the `#` prefix or edit `baritone/settings.txt` in your Min
 
 ## Why can I do `.goto x z` in Impact but nowhere else? Why can I do `-path to x z` in KAMI but nowhere else?
 These are custom commands that they added; those aren't from Baritone.
-The equivalent you're looking for is `goal x z` then `path`.
+The equivalent you're looking for is `goto x z`.

build.gradle

@@ -16,7 +16,7 @@
  */
 
 group 'baritone'
-version '1.2.10'
+version '1.2.14'
 
 buildscript {
     repositories {

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

@@ -21,13 +21,21 @@ 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.JavaVersion;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.internal.file.IdentityFileResolver;
 import org.gradle.api.internal.plugins.DefaultConvention;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.api.tasks.TaskCollection;
+import org.gradle.api.tasks.compile.ForkOptions;
+import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.internal.Pair;
+import org.gradle.internal.jvm.Jvm;
+import org.gradle.internal.jvm.inspection.DefaultJvmVersionDetector;
+import org.gradle.process.internal.DefaultExecActionFactory;
 
 import java.io.*;
 import java.lang.reflect.Field;
@@ -101,6 +109,101 @@ public class ProguardTask extends BaritoneGradleTask {
         }
     }
 
+    private String getJavaBinPathForProguard() throws Exception {
+        String path;
+        try {
+            path = findJavaPathByGradleConfig();
+            if (path != null) return path;
+        }
+        catch (Exception ex) {
+            System.err.println("Unable to find java by javaCompile options");
+            ex.printStackTrace();
+        }
+
+        try {
+            path = findJavaByJavaHome();
+            if (path != null) return path;
+        }
+        catch(Exception ex) {
+            System.err.println("Unable to find java by JAVA_HOME");
+            ex.printStackTrace();
+        }
+
+
+        path = findJavaByGradleCurrentRuntime();
+        if (path != null) return path;
+        
+        throw new Exception("Unable to find java to determine ProGuard libraryjars. Please specify forkOptions.executable in javaCompile," +
+                " JAVA_HOME environment variable, or make sure to run Gradle with the correct JDK (a v1.8 only)");
+    }
+
+    private String findJavaByGradleCurrentRuntime() {
+        String path = Jvm.current().getJavaExecutable().getAbsolutePath();
+
+        if (this.validateJavaVersion(path)) {
+            System.out.println("Using Gradle's runtime Java for ProGuard");
+            return path;
+        }
+        return null;
+    }
+
+    private String findJavaByJavaHome() {
+        final String javaHomeEnv = System.getenv("JAVA_HOME");
+        if (javaHomeEnv != null) {
+
+            String path = Jvm.forHome(new File(javaHomeEnv)).getJavaExecutable().getAbsolutePath();
+            if (this.validateJavaVersion(path)) {
+                System.out.println("Detected Java path by JAVA_HOME");
+                return path;
+            }
+        }
+        return null;
+    }
+
+    private String findJavaPathByGradleConfig() {
+        final TaskCollection<JavaCompile> javaCompiles = super.getProject().getTasks().withType(JavaCompile.class);
+
+        final JavaCompile compileTask = javaCompiles.iterator().next();
+        final ForkOptions forkOptions = compileTask.getOptions().getForkOptions();
+
+        if (forkOptions != null) {
+            String javacPath = forkOptions.getExecutable();
+            if (javacPath != null) {
+                File javacFile = new File(javacPath);
+                if (javacFile.exists()) {
+                    File[] maybeJava = javacFile.getParentFile().listFiles(new FilenameFilter() {
+                        @Override
+                        public boolean accept(File dir, String name) {
+                            return name.equals("java");
+                        }
+                    });
+
+                    if (maybeJava != null && maybeJava.length > 0) {
+                        String path = maybeJava[0].getAbsolutePath();
+                        if (this.validateJavaVersion(path)) {
+                            System.out.println("Detected Java path by forkOptions");
+                            return path;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean validateJavaVersion(String java) {
+        final JavaVersion javaVersion = new DefaultJvmVersionDetector(new DefaultExecActionFactory(new IdentityFileResolver())).getJavaVersion(java);
+
+        if (!javaVersion.getMajorVersion().equals("8")) {
+            System.out.println("Failed to validate Java version " + javaVersion.toString() + " [" + java + "] for ProGuard libraryjars");
+            // throw new RuntimeException("Java version incorrect: " + javaVersion.getMajorVersion() + " for " + java);
+            return false;
+        }
+
+        System.out.println("Validated Java version " + javaVersion.toString() + " [" + java + "] for ProGuard libraryjars");
+        return true;
+    }
+
     private void generateConfigs() throws Exception {
         Files.copy(getRelativeFile(PROGUARD_CONFIG_TEMPLATE), getTemporaryFile(PROGUARD_CONFIG_DEST), REPLACE_EXISTING);
 
@@ -110,7 +213,7 @@ public class ProguardTask extends BaritoneGradleTask {
         template.add(1, "-outjars " + this.getTemporaryFile(PROGUARD_EXPORT_PATH));
 
         // Acquire the RT jar using "java -verbose". This doesn't work on Java 9+
-        Process p = new ProcessBuilder("java", "-verbose").start();
+        Process p = new ProcessBuilder(this.getJavaBinPathForProguard(), "-verbose").start();
         String out = IOUtils.toString(p.getInputStream(), "UTF-8").split("\n")[0].split("Opened ")[1].replace("]", "");
         template.add(2, "-libraryjars '" + out + "'");
 

scripts/proguard.pro

@@ -23,6 +23,13 @@
 
 -keep class baritone.api.utils.MyChunkPos { *; } # even in standalone we need to keep this for gson reflect
 
+# Keep any class or member annotated with @KeepName so we dont have to put everything in the script
+-keep,allowobfuscation @interface baritone.KeepName
+-keep @baritone.KeepName class *
+-keepclassmembers class * {
+    @baritone.KeepName *;
+}
+
 # setting names are reflected from field names, so keep field names
 -keepclassmembers class baritone.api.Settings {
     public <fields>;    
@@ -181,19 +188,19 @@
 -assumenosideeffects public class java.lang.* extends java.lang.Number {
     public static java.lang.String toString(byte);
     public static java.lang.Byte valueOf(byte);
-    public static byte parseByte(java.lang.String);
+#    public static byte parseByte(java.lang.String);
-    public static byte parseByte(java.lang.String,int);
+#    public static byte parseByte(java.lang.String,int);
-    public static java.lang.Byte valueOf(java.lang.String,int);
+#    public static java.lang.Byte valueOf(java.lang.String,int);
-    public static java.lang.Byte valueOf(java.lang.String);
+#    public static java.lang.Byte valueOf(java.lang.String);
-    public static java.lang.Byte decode(java.lang.String);
+#    public static java.lang.Byte decode(java.lang.String);
     public int compareTo(java.lang.Byte);
     public static java.lang.String toString(short);
-    public static short parseShort(java.lang.String);
+#    public static short parseShort(java.lang.String);
-    public static short parseShort(java.lang.String,int);
+#    public static short parseShort(java.lang.String,int);
-    public static java.lang.Short valueOf(java.lang.String,int);
+#    public static java.lang.Short valueOf(java.lang.String,int);
-    public static java.lang.Short valueOf(java.lang.String);
+#    public static java.lang.Short valueOf(java.lang.String);
     public static java.lang.Short valueOf(short);
-    public static java.lang.Short decode(java.lang.String);
+#    public static java.lang.Short decode(java.lang.String);
     public static short reverseBytes(short);
     public int compareTo(java.lang.Short);
     public static java.lang.String toString(int,int);
@@ -201,10 +208,10 @@
     public static java.lang.String toOctalString(int);
     public static java.lang.String toBinaryString(int);
     public static java.lang.String toString(int);
-    public static int parseInt(java.lang.String,int);
+#    public static int parseInt(java.lang.String,int);
-    public static int parseInt(java.lang.String);
+#    public static int parseInt(java.lang.String);
-    public static java.lang.Integer valueOf(java.lang.String,int);
+#    public static java.lang.Integer valueOf(java.lang.String,int);
-    public static java.lang.Integer valueOf(java.lang.String);
+#    public static java.lang.Integer valueOf(java.lang.String);
     public static java.lang.Integer valueOf(int);
     public static java.lang.Integer getInteger(java.lang.String);
     public static java.lang.Integer getInteger(java.lang.String,int);
@@ -226,12 +233,12 @@
     public static java.lang.String toOctalString(long);
     public static java.lang.String toBinaryString(long);
     public static java.lang.String toString(long);
-    public static long parseLong(java.lang.String,int);
+#    public static long parseLong(java.lang.String,int);
-    public static long parseLong(java.lang.String);
+#    public static long parseLong(java.lang.String);
-    public static java.lang.Long valueOf(java.lang.String,int);
+#    public static java.lang.Long valueOf(java.lang.String,int);
-    public static java.lang.Long valueOf(java.lang.String);
+#    public static java.lang.Long valueOf(java.lang.String);
     public static java.lang.Long valueOf(long);
-    public static java.lang.Long decode(java.lang.String);
+#    public static java.lang.Long decode(java.lang.String);
     public static java.lang.Long getLong(java.lang.String);
     public static java.lang.Long getLong(java.lang.String,long);
     public static java.lang.Long getLong(java.lang.String,java.lang.Long);
@@ -248,9 +255,9 @@
     public int compareTo(java.lang.Long);
     public static java.lang.String toString(float);
     public static java.lang.String toHexString(float);
-    public static java.lang.Float valueOf(java.lang.String);
+#    public static java.lang.Float valueOf(java.lang.String);
     public static java.lang.Float valueOf(float);
-    public static float parseFloat(java.lang.String);
+#    public static float parseFloat(java.lang.String);
     public static boolean isNaN(float);
     public static boolean isInfinite(float);
     public static int floatToIntBits(float);
@@ -262,9 +269,9 @@
     public int compareTo(java.lang.Float);
     public static java.lang.String toString(double);
     public static java.lang.String toHexString(double);
-    public static java.lang.Double valueOf(java.lang.String);
+#    public static java.lang.Double valueOf(java.lang.String);
-    public static java.lang.Double valueOf(double);
+#    public static java.lang.Double valueOf(double);
-    public static double parseDouble(java.lang.String);
+#    public static double parseDouble(java.lang.String);
     public static boolean isNaN(double);
     public static boolean isInfinite(double);
     public static long doubleToLongBits(double);

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

@@ -20,6 +20,7 @@ package baritone.api;
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommand;
 import baritone.api.command.ICommandSystem;
+import baritone.api.schematic.ISchematicSystem;
 import net.minecraft.client.entity.EntityPlayerSP;
 
 import java.util.List;
@@ -82,4 +83,9 @@ public interface IBaritoneProvider {
      * @return The {@link ICommandSystem} instance.
      */
     ICommandSystem getCommandSystem();
+
+    /**
+     * @return The {@link ISchematicSystem} instance.
+     */
+    ISchematicSystem getSchematicSystem();
 }

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

@@ -30,8 +30,8 @@ import java.awt.*;
 import java.lang.reflect.Field;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
-import java.util.*;
 import java.util.List;
+import java.util.*;
 import java.util.function.Consumer;
 
 /**
@@ -61,6 +61,19 @@ public final class Settings {
      */
     public final Setting<Boolean> allowInventory = new Setting<>(false);
 
+    /**
+     * Disable baritone's auto-tool at runtime, but still assume that another mod will provide auto tool functionality
+     * <p>
+     * Specifically, path calculation will still assume that an auto tool wil run at execution time, even though
+     * Baritone itself will not do that.
+     */
+    public final Setting<Boolean> assumeExternalAutoTool = new Setting<>(false);
+
+    /**
+     * If this setting is on, no auto tool will occur at all, not at calculation time nor execution time
+     */
+    public final Setting<Boolean> disableAutoTool = new Setting<>(false);
+
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
      * because we want to generally conserve blocks which might be limited.
@@ -184,6 +197,29 @@ public final class Settings {
             Blocks.WALL_SIGN
     )));
 
+    /**
+     * A list of blocks to be treated as if they're air.
+     * <p>
+     * If a schematic asks for air at a certain position, and that position currently contains a block on this list, it will be treated as correct.
+     */
+    public final Setting<List<Block>> buildIgnoreBlocks = new Setting<>(new ArrayList<>(Arrays.asList(
+
+    )));
+
+    /**
+     * A list of blocks to become air
+     * <p>
+     * If a schematic asks for a block on this list, only air will be accepted at that location (and nothing on buildIgnoreBlocks)
+     */
+    public final Setting<List<Block>> okIfAir = new Setting<>(new ArrayList<>(Arrays.asList(
+
+    )));
+
+    /**
+     * If this is true, the builder will treat all non-air blocks as correct. It will only place new blocks.
+     */
+    public final Setting<Boolean> buildIgnoreExisting = new Setting<>(false);
+
     /**
      * If this setting is true, Baritone will never break a block that is adjacent to an unsupported falling block.
      * <p>
@@ -234,7 +270,7 @@ public final class Settings {
     /**
      * If we overshoot a traverse and end up one block beyond the destination, mark it as successful anyway.
      * <p>
-     * This helps with speed at >=20m/s
+     * This helps with speed exceeding 20m/s
      */
     public final Setting<Boolean> overshootTraverse = new Setting<>(true);
 
@@ -248,6 +284,11 @@ public final class Settings {
      */
     public final Setting<Integer> rightClickSpeed = new Setting<>(4);
 
+    /**
+     * Block reach distance
+     */
+    public final Setting<Float> blockReachDistance = new Setting<>(4.5f);
+
     /**
      * How many degrees to randomize the pitch and yaw every tick. Set to 0 to disable
      */
@@ -411,6 +452,11 @@ public final class Settings {
      */
     public final Setting<Boolean> simplifyUnloadedYCoord = new Setting<>(true);
 
+    /**
+     * Whenever a block changes, repack the whole chunk that it's in
+     */
+    public final Setting<Boolean> repackOnAnyBlockChange = new Setting<>(true);
+
     /**
      * If a movement takes this many ticks more than its initial cost estimate, cancel it
      */
@@ -733,11 +779,22 @@ public final class Settings {
      */
     public final Setting<Boolean> layerOrder = new Setting<>(false);
 
+    /**
+     * Start building the schematic at a specific layer.
+     * Can help on larger builds when schematic wants to break things its already built
+     */
+    public final Setting<Integer> startAtLayer = new Setting<>(0);
+
     /**
      * How far to move before repeating the build. 0 to disable repeating on a certain axis, 0,0,0 to disable entirely
      */
     public final Setting<Vec3i> buildRepeat = new Setting<>(new Vec3i(0, 0, 0));
 
+    /**
+     * How many times to buildrepeat. -1 for infinite.
+     */
+    public final Setting<Integer> buildRepeatCount = new Setting<>(-1);
+
     /**
      * Allow standing above a block while mining it, in BuilderProcess
      * <p>
@@ -787,6 +844,12 @@ public final class Settings {
      */
     public final Setting<Boolean> schematicOrientationZ = new Setting<>(false);
 
+    /**
+     * The fallback used by the build command when no extension is specified. This may be useful if schematics of a
+     * particular format are used often, and the user does not wish to have to specify the extension with every usage.
+     */
+    public final Setting<String> schematicFallbackExtension = new Setting<>("schematic");
+
     /**
      * Distance to scan every tick for updates. Expanding this beyond player reach distance (i.e. setting it to 6 or above)
      * is only necessary in very large schematics where rescanning the whole thing is costly.
@@ -1016,6 +1079,35 @@ public final class Settings {
      */
     public final Setting<Boolean> renderSelectionCorners = new Setting<>(true);
 
+    /**
+     * Desktop notifications
+     */
+    public final Setting<Boolean> desktopNotifications = new Setting<>(false);
+
+    /**
+     * Desktop notification on path complete
+     */
+    public final Setting<Boolean> notificationOnPathComplete = new Setting<>(true);
+
+    /**
+     * Desktop notification on farm fail
+     */
+    public final Setting<Boolean> notificationOnFarmFail = new Setting<>(true);
+
+    /**
+     * Desktop notification on build finished
+     */
+    public final Setting<Boolean> notificationOnBuildFinished = new Setting<>(true);
+
+    /**
+     * Desktop notification on explore finished
+     */
+    public final Setting<Boolean> notificationOnExploreFinished = new Setting<>(true);
+
+    /**
+     * Desktop notification on mine fail
+     */
+    public final Setting<Boolean> notificationOnMineFail = new Setting<>(true);
 
     /**
      * A map of lowercase setting field names to their respective setting

src/api/java/baritone/api/command/datatypes/RelativeGoal.java

@@ -38,38 +38,26 @@ public enum RelativeGoal implements IDatatypePost<Goal, BetterBlockPos> {
         if (origin == null) {
             origin = BetterBlockPos.ORIGIN;
         }
+
         final IArgConsumer consumer = ctx.getConsumer();
 
-        List<IDatatypePostFunction<Double, Double>> coords = new ArrayList<>();
+        GoalBlock goalBlock = consumer.peekDatatypePostOrNull(RelativeGoalBlock.INSTANCE, origin);
-        final IArgConsumer copy = consumer.copy(); // This is a hack and should be fixed in the future probably
+        if (goalBlock != null) {
-        for (int i = 0; i < 3; i++) {
+            return goalBlock;
-            if (copy.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
-                coords.add(o -> consumer.getDatatypePost(RelativeCoordinate.INSTANCE, o));
-                copy.get(); // Consume so we actually decrement the remaining arguments
-            }
         }
 
-        switch (coords.size()) {
+        GoalXZ goalXZ = consumer.peekDatatypePostOrNull(RelativeGoalXZ.INSTANCE, origin);
-            case 0:
+        if (goalXZ != null) {
-                return new GoalBlock(origin);
+            return goalXZ;
-            case 1:
-                return new GoalYLevel(
-                        MathHelper.floor(coords.get(0).apply((double) origin.y))
-                );
-            case 2:
-                return new GoalXZ(
-                        MathHelper.floor(coords.get(0).apply((double) origin.x)),
-                        MathHelper.floor(coords.get(1).apply((double) origin.z))
-                );
-            case 3:
-                return new GoalBlock(
-                        MathHelper.floor(coords.get(0).apply((double) origin.x)),
-                        MathHelper.floor(coords.get(1).apply((double) origin.y)),
-                        MathHelper.floor(coords.get(2).apply((double) origin.z))
-                );
-            default:
-                throw new IllegalStateException("Unexpected coords size: " + coords.size());
         }
+
+        GoalYLevel goalYLevel = consumer.peekDatatypePostOrNull(RelativeGoalYLevel.INSTANCE, origin);
+        if (goalYLevel != null) {
+            return goalYLevel;
+        }
+
+        // when the user doesn't input anything, default to the origin
+        return new GoalBlock(origin);
     }
 
     @Override

src/api/java/baritone/api/command/datatypes/RelativeGoalXZ.java

@@ -37,7 +37,7 @@ public enum RelativeGoalXZ implements IDatatypePost<GoalXZ, BetterBlockPos> {
         final IArgConsumer consumer = ctx.getConsumer();
         return new GoalXZ(
                 MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.x)),
-                MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y))
+                MathHelper.floor(consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.z))
         );
     }
 

src/api/java/baritone/api/command/exception/CommandErrorMessageException.java

@@ -22,4 +22,8 @@ public abstract class CommandErrorMessageException extends CommandException {
     protected CommandErrorMessageException(String reason) {
         super(reason);
     }
+
+    protected CommandErrorMessageException(String reason, Throwable cause) {
+        super(reason, cause);
+    }
 }

src/api/java/baritone/api/command/exception/CommandException.java

@@ -22,4 +22,8 @@ public abstract class CommandException extends Exception implements ICommandExce
     protected CommandException(String reason) {
         super(reason);
     }
+
+    protected CommandException(String reason, Throwable cause) {
+        super(reason, cause);
+    }
 }

src/api/java/baritone/api/command/exception/CommandInvalidArgumentException.java

@@ -23,12 +23,21 @@ public abstract class CommandInvalidArgumentException extends CommandErrorMessag
 
     public final ICommandArgument arg;
 
-    protected CommandInvalidArgumentException(ICommandArgument arg, String reason) {
+    protected CommandInvalidArgumentException(ICommandArgument arg, String message) {
-        super(String.format(
+        super(formatMessage(arg, message));
-                "Error at argument #%s: %s",
-                arg.getIndex() == -1 ? "<unknown>" : Integer.toString(arg.getIndex() + 1),
-                reason
-        ));
         this.arg = arg;
     }
+
+    protected CommandInvalidArgumentException(ICommandArgument arg, String message, Throwable cause) {
+        super(formatMessage(arg, message), cause);
+        this.arg = arg;
+    }
+
+    private static String formatMessage(ICommandArgument arg, String message) {
+        return String.format(
+                "Error at argument #%s: %s",
+                arg.getIndex() == -1 ? "<unknown>" : Integer.toString(arg.getIndex() + 1),
+                message
+        );
+    }
 }

src/api/java/baritone/api/command/exception/CommandInvalidTypeException.java

@@ -26,7 +26,7 @@ public class CommandInvalidTypeException extends CommandInvalidArgumentException
     }
 
     public CommandInvalidTypeException(ICommandArgument arg, String expected, Throwable cause) {
-        super(arg, String.format("Expected %s.\nMore details: %s", expected, cause.getMessage()));
+        super(arg, String.format("Expected %s", expected), cause);
     }
 
     public CommandInvalidTypeException(ICommandArgument arg, String expected, String got) {
@@ -34,6 +34,6 @@ public class CommandInvalidTypeException extends CommandInvalidArgumentException
     }
 
     public CommandInvalidTypeException(ICommandArgument arg, String expected, String got, Throwable cause) {
-        super(arg, String.format("Expected %s, but got %s instead.\nMore details: %s", expected, got, cause.getMessage()));
+        super(arg, String.format("Expected %s, but got %s instead", expected, got), cause);
     }
 }

src/api/java/baritone/api/command/exception/CommandUnhandledException.java

@@ -37,7 +37,7 @@ public class CommandUnhandledException extends RuntimeException implements IComm
 
     @Override
     public void handle(ICommand command, List<ICommandArgument> args) {
-        HELPER.logDirect("An unhandled exception occurred." +
+        HELPER.logDirect("An unhandled exception occurred. " +
                 "The error is in your game's log, please report this at https://github.com/cabaletta/baritone/issues",
                 TextFormatting.RED);
 

src/api/java/baritone/api/event/events/TickEvent.java

@@ -19,22 +19,20 @@ package baritone.api.event.events;
 
 import baritone.api.event.events.type.EventState;
 
+import java.util.function.BiFunction;
+
 public final class TickEvent {
 
+    private static int overallTickCount;
+
     private final EventState state;
     private final Type type;
     private final int count;
 
-    private static int overallTickCount;
+    public TickEvent(EventState state, Type type, int count) {
-
-    public TickEvent(EventState state, Type type) {
         this.state = state;
         this.type = type;
-        this.count = incrementCount();
+        this.count = count;
-    }
-
-    private static synchronized int incrementCount() {
-        return overallTickCount++;
     }
 
     public int getCount() {
@@ -49,6 +47,10 @@ public final class TickEvent {
         return state;
     }
 
+    public static synchronized BiFunction<EventState, Type, TickEvent> createNextProvider() {
+        final int count = overallTickCount++;
+        return (state, type) -> new TickEvent(state, type, count);
+    }
 
     public enum Type {
         /**

src/api/java/baritone/api/schematic/AbstractSchematic.java

@@ -23,6 +23,10 @@ public abstract class AbstractSchematic implements ISchematic {
     protected int y;
     protected int z;
 
+    public AbstractSchematic() {
+        this(0, 0, 0);
+    }
+
     public AbstractSchematic(int x, int y, int z) {
         this.x = x;
         this.y = y;

src/api/java/baritone/api/schematic/FillSchematic.java

@@ -32,6 +32,10 @@ public class FillSchematic extends AbstractSchematic {
         this.bom = bom;
     }
 
+    public FillSchematic(int x, int y, int z, IBlockState state) {
+        this(x, y, z, new BlockOptionalMeta(state.getBlock(), state.getBlock().getMetaFromState(state)));
+    }
+
     public BlockOptionalMeta getBom() {
         return bom;
     }

src/api/java/baritone/api/schematic/ISchematicSystem.java

@@ -0,0 +1,44 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import baritone.api.command.registry.Registry;
+import baritone.api.schematic.format.ISchematicFormat;
+
+import java.io.File;
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 12/23/2019
+ */
+public interface ISchematicSystem {
+
+    /**
+     * @return The registry of supported schematic formats
+     */
+    Registry<ISchematicFormat> getRegistry();
+
+    /**
+     * Attempts to find an {@link ISchematicFormat} that supports the specified schematic file.
+     *
+     * @param file A schematic file
+     * @return The corresponding format for the file, {@link Optional#empty()} if no candidates were found.
+     */
+    Optional<ISchematicFormat> getByFile(File file);
+}

src/api/java/baritone/api/schematic/IStaticSchematic.java

@@ -0,0 +1,60 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * A static schematic is capable of providing the desired state at a given position without
+ * additional context. Schematics of this type are expected to have non-varying contents.
+ * 
+ * @see #getDirect(int, int, int) 
+ *
+ * @author Brady
+ * @since 12/24/2019
+ */
+public interface IStaticSchematic extends ISchematic {
+
+    /**
+     * Gets the {@link IBlockState} for a given position in this schematic. It should be guaranteed
+     * that the return value of this method will not change given that the parameters are the same.
+     *
+     * @param x The X block position
+     * @param y The Y block position
+     * @param z The Z block position
+     * @return The desired state at the specified position.
+     */
+    IBlockState getDirect(int x, int y, int z);
+
+    /**
+     * Returns an {@link IBlockState} array of size {@link #heightY()} which contains all
+     * desired block states in the specified vertical column. The index of {@link IBlockState}s
+     * in the array are equivalent to their Y position in the schematic.
+     *
+     * @param x The X column position
+     * @param z The Z column position
+     * @return An {@link IBlockState} array
+     */
+    default IBlockState[] getColumn(int x, int z) {
+        IBlockState[] column = new IBlockState[this.heightY()];
+        for (int i = 0; i < this.heightY(); i++) {
+            column[i] = getDirect(x, i, z);
+        }
+        return column;
+    }
+}

src/api/java/baritone/api/schematic/format/ISchematicFormat.java

@@ -0,0 +1,45 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic.format;
+
+import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * The base of a {@link ISchematic} file format
+ *
+ * @author Brady
+ * @since 12/23/2019
+ */
+public interface ISchematicFormat {
+
+    /**
+     * @return The parser for creating schematics of this format
+     */
+    IStaticSchematic parse(InputStream input) throws IOException;
+
+    /**
+     * @param file The file to check against
+     * @return Whether or not the specified file matches this schematic format
+     */
+    boolean isFileType(File file);
+}

src/api/java/baritone/api/utils/BlockOptionalMeta.java

@@ -178,16 +178,27 @@ public final class BlockOptionalMeta {
         normalizations = Collections.unmodifiableMap(_normalizations);
     }
 
-    private static <C extends Comparable<C>, P extends IProperty<C>> P castToIProperty(Object value) {
+    public static <C extends Comparable<C>, P extends IProperty<C>> P castToIProperty(Object value) {
         //noinspection unchecked
         return (P) value;
     }
 
-    private static <C extends Comparable<C>, P extends IProperty<C>> C castToIPropertyValue(P iproperty, Object value) {
+    public static <C extends Comparable<C>, P extends IProperty<C>> C castToIPropertyValue(P iproperty, Object value) {
         //noinspection unchecked
         return (C) value;
     }
 
+    /**
+     * Normalizes the specified blockstate by setting meta-affecting properties which
+     * are not being targeted by the meta parameter to their default values.
+     * <p>
+     * For example, block variant/color is the primary target for the meta value, so properties
+     * such as rotation/facing direction will be set to default values in order to nullify
+     * the effect that they have on the state's meta value.
+     *
+     * @param state The state to normalize
+     * @return The normalized block state
+     */
     public static IBlockState normalize(IBlockState state) {
         IBlockState newState = state;
 
@@ -220,6 +231,15 @@ public final class BlockOptionalMeta {
         return newState;
     }
 
+    /**
+     * Evaluate the target meta value for the specified state. The target meta value is
+     * most often that which is influenced by the variant/color property of the block state.
+     * 
+     * @see #normalize(IBlockState) 
+     * 
+     * @param state The state to check
+     * @return The target meta of the state
+     */
     public static int stateMeta(IBlockState state) {
         return state.getBlock().getMetaFromState(normalize(state));
     }

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

@@ -24,6 +24,7 @@ import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
 
 import java.util.Arrays;
+import java.util.Calendar;
 import java.util.stream.Stream;
 
 /**
@@ -47,7 +48,9 @@ public interface Helper {
 
     static ITextComponent getPrefix() {
         // Inner text component
-        ITextComponent baritone = new TextComponentString(BaritoneAPI.getSettings().shortBaritonePrefix.value ? "B" : "Baritone");
+        final Calendar now = Calendar.getInstance();
+        final boolean xd = now.get(Calendar.MONTH) == Calendar.APRIL && now.get(Calendar.DAY_OF_MONTH) <= 3;
+        ITextComponent baritone = new TextComponentString(xd ? "Baritoe" : BaritoneAPI.getSettings().shortBaritonePrefix.value ? "B" : "Baritone");
         baritone.getStyle().setColor(TextFormatting.LIGHT_PURPLE);
 
         // Outer brackets

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

@@ -77,6 +77,10 @@ public interface IPlayerContext {
         return new Rotation(player().rotationYaw, player().rotationPitch);
     }
 
+    static double eyeHeight(boolean ifSneaking) {
+        return ifSneaking ? 1.54 : 1.62;
+    }
+
     /**
      * Returns the block that the crosshair is currently placed over. Updated once per tick.
      *

src/api/java/baritone/api/utils/IPlayerController.java

@@ -17,6 +17,7 @@
 
 package baritone.api.utils;
 
+import baritone.api.BaritoneAPI;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.ClickType;
@@ -56,6 +57,6 @@ public interface IPlayerController {
     void setHittingBlock(boolean hittingBlock);
 
     default double getBlockReachDistance() {
-        return this.getGameType().isCreative() ? 5.0F : 4.5F;
+        return this.getGameType().isCreative() ? 5.0F : BaritoneAPI.getSettings().blockReachDistance.value;
     }
 }

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

@@ -40,7 +40,16 @@ 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);
+        return rayTraceTowards(entity, rotation, blockReachDistance, false);
+    }
+
+    public static RayTraceResult rayTraceTowards(Entity entity, Rotation rotation, double blockReachDistance, boolean wouldSneak) {
+        Vec3d start;
+        if (wouldSneak) {
+            start = inferSneakingEyePosition(entity);
+        } else {
+            start = entity.getPositionEyes(1.0F); // do whatever is correct
+        }
         Vec3d direction = RotationUtils.calcVec3dFromRotation(rotation);
         Vec3d end = start.add(
                 direction.x * blockReachDistance,
@@ -49,4 +58,8 @@ public final class RayTraceUtils {
         );
         return entity.world.rayTraceBlocks(start, end, false, false, true);
     }
+
+    public static Vec3d inferSneakingEyePosition(Entity entity) {
+        return new Vec3d(entity.posX, entity.posY + IPlayerContext.eyeHeight(true), entity.posZ);
+    }
 }

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

@@ -140,6 +140,10 @@ public final class RotationUtils {
         return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
     }
 
+    public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos, boolean wouldSneak) {
+        return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance(), wouldSneak);
+    }
+
     /**
      * Determines if the specified entity is able to reach the center of any of the sides
      * of the specified block. It first checks if the block center is reachable, and if so,
@@ -153,6 +157,10 @@ public final class RotationUtils {
      * @return The optional rotation
      */
     public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance) {
+        return reachable(entity, pos, blockReachDistance, false);
+    }
+
+    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
         IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
         if (baritone.getPlayerContext().isLookingAt(pos)) {
             /*
@@ -165,9 +173,18 @@ public final class RotationUtils {
              *
              * or if you're a normal person literally all this does it ensure that we don't nudge the pitch to a normal level
              */
-            return Optional.of(new Rotation(entity.rotationYaw, entity.rotationPitch + 0.0001F));
+            Rotation hypothetical = new Rotation(entity.rotationYaw, entity.rotationPitch + 0.0001F);
+            if (wouldSneak) {
+                // the concern here is: what if we're looking at it now, but as soon as we start sneaking we no longer are
+                RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, hypothetical, blockReachDistance, true);
+                if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(pos)) {
+                    return Optional.of(hypothetical); // yes, if we sneaked we would still be looking at the block
+                }
+            } else {
+                return Optional.of(hypothetical);
+            }
         }
-        Optional<Rotation> possibleRotation = reachableCenter(entity, pos, blockReachDistance);
+        Optional<Rotation> possibleRotation = reachableCenter(entity, pos, blockReachDistance, wouldSneak);
         //System.out.println("center: " + possibleRotation);
         if (possibleRotation.isPresent()) {
             return possibleRotation;
@@ -179,7 +196,7 @@ public final class RotationUtils {
             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);
-            possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance);
+            possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
             if (possibleRotation.isPresent()) {
                 return possibleRotation;
             }
@@ -198,9 +215,10 @@ public final class RotationUtils {
      * @param blockReachDistance The block reach distance of the entity
      * @return The optional rotation
      */
-    public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance) {
+    public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance, boolean wouldSneak) {
-        Rotation rotation = calcRotationFromVec3d(entity.getPositionEyes(1.0F), offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
+        Vec3d eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(entity) : entity.getPositionEyes(1.0F);
-        RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance);
+        Rotation rotation = calcRotationFromVec3d(eyes, offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
+        RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance, wouldSneak);
         //System.out.println(result);
         if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
             if (result.getBlockPos().equals(pos)) {
@@ -222,7 +240,7 @@ public final class RotationUtils {
      * @param blockReachDistance The block reach distance of the entity
      * @return The optional rotation
      */
-    public static Optional<Rotation> reachableCenter(Entity entity, BlockPos pos, double blockReachDistance) {
+    public static Optional<Rotation> reachableCenter(Entity entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
-        return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance);
+        return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance, wouldSneak);
     }
 }

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

@@ -41,6 +41,8 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
+import java.util.function.BiFunction;
+
 /**
  * @author Brady
  * @since 7/31/2018
@@ -84,13 +86,15 @@ public class MixinMinecraft {
             )
     )
     private void runTick(CallbackInfo ci) {
-        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+        final BiFunction<EventState, TickEvent.Type, TickEvent> tickProvider = TickEvent.createNextProvider();
 
-            TickEvent.Type type = ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().world() != null
+        for (IBaritone baritone : BaritoneAPI.getProvider().getAllBaritones()) {
+
+            TickEvent.Type type = baritone.getPlayerContext().player() != null && baritone.getPlayerContext().world() != null
                     ? TickEvent.Type.IN
                     : TickEvent.Type.OUT;
 
-            ibaritone.getGameEventHandler().onTick(new TickEvent(EventState.PRE, type));
+            baritone.getGameEventHandler().onTick(tickProvider.apply(EventState.PRE, type));
         }
 
     }
@@ -141,7 +145,7 @@ public class MixinMinecraft {
     )
     private boolean isAllowUserInput(GuiScreen screen) {
         // allow user input is only the primary baritone
-        return (BaritoneAPI.getProvider().getPrimaryBaritone().getPathingBehavior().getCurrent() != null && player != null) || screen.allowUserInput;
+        return (BaritoneAPI.getProvider().getPrimaryBaritone().getPathingBehavior().isPathing() && player != null) || screen.allowUserInput;
     }
 
     @Inject(

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

@@ -17,13 +17,19 @@
 
 package baritone.launch.mixins;
 
+import baritone.Baritone;
 import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.event.events.ChunkEvent;
 import baritone.api.event.events.type.EventState;
+import baritone.cache.CachedChunk;
+import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.network.play.server.SPacketBlockChange;
 import net.minecraft.network.play.server.SPacketChunkData;
 import net.minecraft.network.play.server.SPacketCombatEvent;
+import net.minecraft.network.play.server.SPacketMultiBlockChange;
+import net.minecraft.util.math.ChunkPos;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -45,7 +51,8 @@ public class MixinNetHandlerPlayClient {
     )
     private void preRead(SPacketChunkData packetIn, CallbackInfo ci) {
         for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
-            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+            EntityPlayerSP player = ibaritone.getPlayerContext().player();
+            if (player != null && player.connection == (NetHandlerPlayClient) (Object) this) {
                 ibaritone.getGameEventHandler().onChunkEvent(
                         new ChunkEvent(
                                 EventState.PRE,
@@ -64,7 +71,8 @@ public class MixinNetHandlerPlayClient {
     )
     private void postHandleChunkData(SPacketChunkData packetIn, CallbackInfo ci) {
         for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
-            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+            EntityPlayerSP player = ibaritone.getPlayerContext().player();
+            if (player != null && player.connection == (NetHandlerPlayClient) (Object) this) {
                 ibaritone.getGameEventHandler().onChunkEvent(
                         new ChunkEvent(
                                 EventState.POST,
@@ -77,6 +85,68 @@ public class MixinNetHandlerPlayClient {
         }
     }
 
+    @Inject(
+            method = "handleBlockChange",
+            at = @At("RETURN")
+    )
+    private void postHandleBlockChange(SPacketBlockChange packetIn, CallbackInfo ci) {
+        if (!Baritone.settings().repackOnAnyBlockChange.value) {
+            return;
+        }
+        if (!CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(packetIn.getBlockState().getBlock())) {
+            return;
+        }
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            EntityPlayerSP player = ibaritone.getPlayerContext().player();
+            if (player != null && player.connection == (NetHandlerPlayClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.POST,
+                                ChunkEvent.Type.POPULATE_FULL,
+                                packetIn.getBlockPosition().getX() >> 4,
+                                packetIn.getBlockPosition().getZ() >> 4
+                        )
+                );
+            }
+        }
+    }
+
+    @Inject(
+            method = "handleMultiBlockChange",
+            at = @At("RETURN")
+    )
+    private void postHandleMultiBlockChange(SPacketMultiBlockChange packetIn, CallbackInfo ci) {
+        if (!Baritone.settings().repackOnAnyBlockChange.value) {
+            return;
+        }
+        if (packetIn.getChangedBlocks().length == 0) {
+            return;
+        }
+        https://docs.oracle.com/javase/specs/jls/se7/html/jls-14.html#jls-14.15
+        {
+            for (SPacketMultiBlockChange.BlockUpdateData update : packetIn.getChangedBlocks()) {
+                if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(update.getBlockState().getBlock())) {
+                    break https;
+                }
+            }
+            return;
+        }
+        ChunkPos pos = new ChunkPos(packetIn.getChangedBlocks()[0].getPos());
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            EntityPlayerSP player = ibaritone.getPlayerContext().player();
+            if (player != null && player.connection == (NetHandlerPlayClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.POST,
+                                ChunkEvent.Type.POPULATE_FULL,
+                                pos.x,
+                                pos.z
+                        )
+                );
+            }
+        }
+    }
+
     @Inject(
             method = "handleCombatEvent",
             at = @At(
@@ -86,7 +156,8 @@ public class MixinNetHandlerPlayClient {
     )
     private void onPlayerDeath(SPacketCombatEvent packetIn, CallbackInfo ci) {
         for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
-            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+            EntityPlayerSP player = ibaritone.getPlayerContext().player();
+            if (player != null && player.connection == (NetHandlerPlayClient) (Object) this) {
                 ibaritone.getGameEventHandler().onPlayerDeath();
             }
         }

src/main/java/baritone/BaritoneProvider.java

@@ -21,9 +21,11 @@ import baritone.api.IBaritone;
 import baritone.api.IBaritoneProvider;
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommandSystem;
-import baritone.command.BaritoneChatControl;
+import baritone.api.schematic.ISchematicSystem;
+import baritone.command.ExampleBaritoneControl;
 import baritone.cache.WorldScanner;
 import baritone.command.CommandSystem;
+import baritone.utils.schematic.SchematicSystem;
 
 import java.util.Collections;
 import java.util.List;
@@ -42,7 +44,7 @@ public final class BaritoneProvider implements IBaritoneProvider {
         this.all = Collections.singletonList(this.primary);
 
         // Setup chat control, just for the primary instance
-        new BaritoneChatControl(this.primary);
+        new ExampleBaritoneControl(this.primary);
     }
 
     @Override
@@ -64,4 +66,9 @@ public final class BaritoneProvider implements IBaritoneProvider {
     public ICommandSystem getCommandSystem() {
         return CommandSystem.INSTANCE;
     }
+
+    @Override
+    public ISchematicSystem getSchematicSystem() {
+        return SchematicSystem.INSTANCE;
+    }
 }

src/main/java/baritone/KeepName.java

@@ -0,0 +1,21 @@
+/*
+ * 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;
+
+// Annotation for classes and class members that should not be renamed by proguard
+public @interface KeepName { }

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

@@ -103,7 +103,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
 
     @Override
     public void onPlayerSprintState(SprintStateEvent event) {
-        if (current != null) {
+        if (isPathing()) {
             event.setState(current.isSprinting());
         }
     }

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

@@ -26,6 +26,7 @@ import baritone.api.utils.Helper;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.chunk.Chunk;
 
 import java.io.IOException;
@@ -33,6 +34,8 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.LinkedBlockingQueue;
 
 /**
@@ -56,7 +59,17 @@ public final class CachedWorld implements ICachedWorld, Helper {
      */
     private final String directory;
 
-    private final LinkedBlockingQueue<Chunk> toPack = new LinkedBlockingQueue<>();
+    /**
+     * Queue of positions to pack. Refers to the toPackMap, in that every element of this queue will be a
+     * key in that map.
+     */
+    private final LinkedBlockingQueue<ChunkPos> toPackQueue = new LinkedBlockingQueue<>();
+
+    /**
+     * All chunk positions pending packing. This map will be updated in-place if a new update to the chunk occurs
+     * while waiting in the queue for the packer thread to get to it.
+     */
+    private final Map<ChunkPos, Chunk> toPackMap = new ConcurrentHashMap<>();
 
     private final int dimension;
 
@@ -89,10 +102,8 @@ public final class CachedWorld implements ICachedWorld, Helper {
 
     @Override
     public final void queueForPacking(Chunk chunk) {
-        try {
+        if (toPackMap.put(chunk.getPos(), chunk) == null) {
-            toPack.put(chunk);
+            toPackQueue.add(chunk.getPos());
-        } catch (InterruptedException e) {
-            e.printStackTrace();
         }
     }
 
@@ -184,7 +195,9 @@ public final class CachedWorld implements ICachedWorld, Helper {
             int distZ = ((region.getZ() << 9) + 256) - pruneCenter.getZ();
             double dist = Math.sqrt(distX * distX + distZ * distZ);
             if (dist > 1024) {
-                logDebug("Deleting cached region " + region.getX() + "," + region.getZ() + " from ram");
+                if (!Baritone.settings().censorCoordinates.value) {
+                    logDebug("Deleting cached region " + region.getX() + "," + region.getZ() + " from ram");
+                }
                 cachedRegions.remove(getRegionID(region.getX(), region.getZ()));
             }
         }
@@ -291,13 +304,9 @@ public final class CachedWorld implements ICachedWorld, Helper {
 
         public void run() {
             while (true) {
-                // TODO: Add CachedWorld unloading to remove the redundancy of having this
-                LinkedBlockingQueue<Chunk> queue = toPack;
-                if (queue == null) {
-                    break;
-                }
                 try {
-                    Chunk chunk = queue.take();
+                    ChunkPos pos = toPackQueue.take();
+                    Chunk chunk = toPackMap.remove(pos);
                     CachedChunk cached = ChunkPacker.pack(chunk);
                     CachedWorld.this.updateCachedChunk(cached);
                     //System.out.println("Processed chunk at " + chunk.x + "," + chunk.z);

src/main/java/baritone/command/ExampleBaritoneControl.java

@@ -49,12 +49,12 @@ import java.util.stream.Stream;
 
 import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
 
-public class BaritoneChatControl implements Helper, AbstractGameEventListener {
+public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
 
     private static final Settings settings = BaritoneAPI.getSettings();
     private final ICommandManager manager;
 
-    public BaritoneChatControl(IBaritone baritone) {
+    public ExampleBaritoneControl(IBaritone baritone) {
         this.manager = baritone.getCommandManager();
         baritone.getGameEventHandler().registerEventListener(this);
     }

src/main/java/baritone/command/argument/ArgConsumer.java

@@ -316,8 +316,7 @@ public class ArgConsumer implements IArgConsumer {
         try {
             return datatype.apply(this.context, original);
         } catch (Exception e) {
-            e.printStackTrace();
+            throw new CommandInvalidTypeException(hasAny() ? peek() : consumed(), datatype.getClass().getSimpleName(), e);
-            throw new CommandInvalidTypeException(hasAny() ? peek() : consumed(), datatype.getClass().getSimpleName());
         }
     }
 
@@ -346,7 +345,7 @@ public class ArgConsumer implements IArgConsumer {
         try {
             return datatype.get(this.context);
         } catch (Exception e) {
-            throw new CommandInvalidTypeException(hasAny() ? peek() : consumed(), datatype.getClass().getSimpleName());
+            throw new CommandInvalidTypeException(hasAny() ? peek() : consumed(), datatype.getClass().getSimpleName(), e);
         }
     }
 

src/main/java/baritone/command/defaults/BuildCommand.java

@@ -17,20 +17,21 @@
 
 package baritone.command.defaults;
 
+import baritone.Baritone;
 import baritone.api.IBaritone;
-import baritone.api.utils.BetterBlockPos;
 import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
 import baritone.api.command.datatypes.RelativeBlockPos;
 import baritone.api.command.datatypes.RelativeFile;
 import baritone.api.command.exception.CommandException;
 import baritone.api.command.exception.CommandInvalidStateException;
-import baritone.api.command.argument.IArgConsumer;
+import baritone.api.utils.BetterBlockPos;
 import net.minecraft.client.Minecraft;
+import org.apache.commons.io.FilenameUtils;
 
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Locale;
 import java.util.stream.Stream;
 
 public class BuildCommand extends Command {
@@ -44,8 +45,8 @@ public class BuildCommand extends Command {
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
         File file = args.getDatatypePost(RelativeFile.INSTANCE, schematicsDir).getAbsoluteFile();
-        if (!file.getName().toLowerCase(Locale.US).endsWith(".schematic")) {
+        if (FilenameUtils.getExtension(file.getAbsolutePath()).isEmpty()) {
-            file = new File(file.getAbsolutePath() + ".schematic");
+            file = new File(file.getAbsolutePath() + "." + Baritone.settings().schematicFallbackExtension.value);
         }
         BetterBlockPos origin = ctx.playerFeet();
         BetterBlockPos buildOrigin;
@@ -58,7 +59,7 @@ public class BuildCommand extends Command {
         }
         boolean success = baritone.getBuilderProcess().build(file.getName(), file, buildOrigin);
         if (!success) {
-            throw new CommandInvalidStateException("Couldn't load the schematic");
+            throw new CommandInvalidStateException("Couldn't load the schematic. Make sure to use the FULL file name, including the extension (e.g. blah.schematic).");
         }
         logDirect(String.format("Successfully loaded schematic for building\nOrigin: %s", buildOrigin));
     }

src/main/java/baritone/command/defaults/CancelCommand.java

@@ -1,61 +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.command.defaults;
-
-import baritone.api.IBaritone;
-import baritone.api.command.Command;
-import baritone.api.command.exception.CommandException;
-import baritone.api.command.argument.IArgConsumer;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Stream;
-
-public class CancelCommand extends Command {
-
-    public CancelCommand(IBaritone baritone) {
-        super(baritone, "cancel", "stop");
-    }
-
-    @Override
-    public void execute(String label, IArgConsumer args) throws CommandException {
-        args.requireMax(0);
-        baritone.getPathingBehavior().cancelEverything();
-        logDirect("ok canceled");
-    }
-
-    @Override
-    public Stream<String> tabComplete(String label, IArgConsumer args) {
-        return Stream.empty();
-    }
-
-    @Override
-    public String getShortDesc() {
-        return "Cancel what Baritone is currently doing";
-    }
-
-    @Override
-    public List<String> getLongDesc() {
-        return Arrays.asList(
-                "The cancel command tells Baritone to stop whatever it's currently doing.",
-                "",
-                "Usage:",
-                "> cancel"
-        );
-    }
-}

src/main/java/baritone/command/defaults/DefaultCommands.java

@@ -24,52 +24,53 @@ import java.util.*;
 
 public final class DefaultCommands {
 
-    private DefaultCommands() {}
+    private DefaultCommands() {
+    }
 
     public static List<ICommand> createAll(IBaritone baritone) {
         Objects.requireNonNull(baritone);
         List<ICommand> commands = new ArrayList<>(Arrays.asList(
-            new HelpCommand(baritone),
+                new HelpCommand(baritone),
-            new SetCommand(baritone),
+                new SetCommand(baritone),
-            new CommandAlias(baritone, Arrays.asList("modified", "mod", "baritone", "modifiedsettings"), "List modified settings", "set modified"),
+                new CommandAlias(baritone, Arrays.asList("modified", "mod", "baritone", "modifiedsettings"), "List modified settings", "set modified"),
-            new CommandAlias(baritone, "reset", "Reset all settings or just one", "set reset"),
+                new CommandAlias(baritone, "reset", "Reset all settings or just one", "set reset"),
-            new GoalCommand(baritone),
+                new GoalCommand(baritone),
-            new GotoCommand(baritone),
+                new GotoCommand(baritone),
-            new PathCommand(baritone),
+                new PathCommand(baritone),
-            new ProcCommand(baritone),
+                new ProcCommand(baritone),
-            new VersionCommand(baritone),
+                new VersionCommand(baritone),
-            new RepackCommand(baritone),
+                new RepackCommand(baritone),
-            new BuildCommand(baritone),
+                new BuildCommand(baritone),
-            new SchematicaCommand(baritone),
+                new SchematicaCommand(baritone),
-            new ComeCommand(baritone),
+                new ComeCommand(baritone),
-            new AxisCommand(baritone),
+                new AxisCommand(baritone),
-            new CancelCommand(baritone),
+                new ForceCancelCommand(baritone),
-            new ForceCancelCommand(baritone),
+                new GcCommand(baritone),
-            new GcCommand(baritone),
+                new InvertCommand(baritone),
-            new InvertCommand(baritone),
+                new TunnelCommand(baritone),
-            new TunnelCommand(baritone),
+                new RenderCommand(baritone),
-            new RenderCommand(baritone),
+                new FarmCommand(baritone),
-            new FarmCommand(baritone),
+                new ChestsCommand(baritone),
-            new ChestsCommand(baritone),
+                new FollowCommand(baritone),
-            new FollowCommand(baritone),
+                new ExploreFilterCommand(baritone),
-            new ExploreFilterCommand(baritone),
+                new ReloadAllCommand(baritone),
-            new ReloadAllCommand(baritone),
+                new SaveAllCommand(baritone),
-            new SaveAllCommand(baritone),
+                new ExploreCommand(baritone),
-            new ExploreCommand(baritone),
+                new BlacklistCommand(baritone),
-            new BlacklistCommand(baritone),
+                new FindCommand(baritone),
-            new FindCommand(baritone),
+                new MineCommand(baritone),
-            new MineCommand(baritone),
+                new ClickCommand(baritone),
-            new ClickCommand(baritone),
+                new ThisWayCommand(baritone),
-            new ThisWayCommand(baritone),
+                new WaypointsCommand(baritone),
-            new WaypointsCommand(baritone),
+                new CommandAlias(baritone, "sethome", "Sets your home waypoint", "waypoints save home"),
-            new CommandAlias(baritone, "sethome", "Sets your home waypoint", "waypoints save home"),
+                new CommandAlias(baritone, "home", "Set goal to your home waypoint", "waypoints goal home"),
-            new CommandAlias(baritone, "home", "Set goal to your home waypoint", "waypoints goal home"),
+                new SelCommand(baritone)
-            new SelCommand(baritone)
         ));
-        PauseResumeCommands prc = new PauseResumeCommands(baritone);
+        ExecutionControlCommands prc = new ExecutionControlCommands(baritone);
         commands.add(prc.pauseCommand);
         commands.add(prc.resumeCommand);
         commands.add(prc.pausedCommand);
+        commands.add(prc.cancelCommand);
         return Collections.unmodifiableList(commands);
     }
 }

src/main/java/baritone/command/defaults/ExecutionControlCommands.java

@@ -18,13 +18,13 @@
 package baritone.command.defaults;
 
 import baritone.api.IBaritone;
+import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.exception.CommandInvalidStateException;
 import baritone.api.process.IBaritoneProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
-import baritone.api.command.Command;
-import baritone.api.command.exception.CommandException;
-import baritone.api.command.exception.CommandInvalidStateException;
-import baritone.api.command.argument.IArgConsumer;
 
 import java.util.Arrays;
 import java.util.List;
@@ -37,13 +37,14 @@ import java.util.stream.Stream;
  * TO USE THIS to pause and resume Baritone. Make your own process that returns {@link PathingCommandType#REQUEST_PAUSE
  * REQUEST_PAUSE} as needed.
  */
-public class PauseResumeCommands {
+public class ExecutionControlCommands {
 
     Command pauseCommand;
     Command resumeCommand;
     Command pausedCommand;
+    Command cancelCommand;
 
-    public PauseResumeCommands(IBaritone baritone) {
+    public ExecutionControlCommands(IBaritone baritone) {
         // array for mutability, non-field so reflection can't touch it
         final boolean[] paused = {false};
         baritone.getPathingControlManager().registerProcess(
@@ -64,7 +65,8 @@ public class PauseResumeCommands {
                     }
 
                     @Override
-                    public void onLostControl() {}
+                    public void onLostControl() {
+                    }
 
                     @Override
                     public double priority() {
@@ -77,7 +79,7 @@ public class PauseResumeCommands {
                     }
                 }
         );
-        pauseCommand = new Command(baritone, "pause") {
+        pauseCommand = new Command(baritone, "pause", "p") {
             @Override
             public void execute(String label, IArgConsumer args) throws CommandException {
                 args.requireMax(0);
@@ -110,7 +112,7 @@ public class PauseResumeCommands {
                 );
             }
         };
-        resumeCommand = new Command(baritone, "resume") {
+        resumeCommand = new Command(baritone, "resume", "r") {
             @Override
             public void execute(String label, IArgConsumer args) throws CommandException {
                 args.requireMax(0);
@@ -169,5 +171,36 @@ public class PauseResumeCommands {
                 );
             }
         };
+        cancelCommand = new Command(baritone, "cancel", "c", "stop") {
+            @Override
+            public void execute(String label, IArgConsumer args) throws CommandException {
+                args.requireMax(0);
+                if (paused[0]) {
+                    paused[0] = false;
+                }
+                baritone.getPathingBehavior().cancelEverything();
+                logDirect("ok canceled");
+            }
+
+            @Override
+            public Stream<String> tabComplete(String label, IArgConsumer args) {
+                return Stream.empty();
+            }
+
+            @Override
+            public String getShortDesc() {
+                return "Cancel what Baritone is currently doing";
+            }
+
+            @Override
+            public List<String> getLongDesc() {
+                return Arrays.asList(
+                        "The cancel command tells Baritone to stop whatever it's currently doing.",
+                        "",
+                        "Usage:",
+                        "> cancel"
+                );
+            }
+        };
     }
 }

src/main/java/baritone/command/defaults/FollowCommand.java

@@ -17,6 +17,7 @@
 
 package baritone.command.defaults;
 
+import baritone.KeepName;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.datatypes.EntityClassById;
@@ -130,6 +131,7 @@ public class FollowCommand extends Command {
         );
     }
 
+    @KeepName
     private enum FollowGroup {
         ENTITIES(EntityLiving.class::isInstance),
         PLAYERS(EntityPlayer.class::isInstance); /* ,
@@ -142,6 +144,7 @@ public class FollowCommand extends Command {
         }
     }
 
+    @KeepName
     private enum FollowList {
         ENTITY(EntityClassById.INSTANCE),
         PLAYER(NearbyPlayer.INSTANCE);

src/main/java/baritone/command/defaults/GotoCommand.java

@@ -41,9 +41,13 @@ public class GotoCommand extends Command {
 
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
-        if (args.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) { // if we have a numeric first argument...
+        // If we have a numeric first argument, then parse arguments as coordinates.
+        // Note: There is no reason to want to go where you're already at so there
+        // is no need to handle the case of empty arguments.
+        if (args.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
+            args.requireMax(3);
             BetterBlockPos origin = baritone.getPlayerContext().playerFeet();
-            Goal goal = args.getDatatypePostOrNull(RelativeGoal.INSTANCE, origin);
+            Goal goal = args.getDatatypePost(RelativeGoal.INSTANCE, origin);
             logDirect(String.format("Going to: %s", goal.toString()));
             baritone.getCustomGoalProcess().setGoalAndPath(goal);
             return;
@@ -68,7 +72,7 @@ public class GotoCommand extends Command {
     @Override
     public List<String> getLongDesc() {
         return Arrays.asList(
-                "The got command tells Baritone to head towards a given goal or block.",
+                "The goto command tells Baritone to head towards a given goal or block.",
                 "",
                 "Wherever a coordinate is expected, you can use ~ just like in regular Minecraft commands. Or, you can just use regular numbers.",
                 "",

src/main/java/baritone/command/defaults/TunnelCommand.java

@@ -18,11 +18,13 @@
 package baritone.command.defaults;
 
 import baritone.api.IBaritone;
+import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalStrictDirection;
-import baritone.api.command.Command;
+import net.minecraft.util.EnumFacing;
-import baritone.api.command.exception.CommandException;
+import net.minecraft.util.math.BlockPos;
-import baritone.api.command.argument.IArgConsumer;
 
 import java.util.Arrays;
 import java.util.List;
@@ -36,13 +38,56 @@ public class TunnelCommand extends Command {
 
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
-        args.requireMax(0);
+        args.requireMax(3);
-        Goal goal = new GoalStrictDirection(
+        if (args.hasExactly(3)) {
-                ctx.playerFeet(),
+            boolean cont = true;
-                ctx.player().getHorizontalFacing()
+            int height = Integer.parseInt(args.getArgs().get(0).getValue());
-        );
+            int width = Integer.parseInt(args.getArgs().get(1).getValue());
-        baritone.getCustomGoalProcess().setGoalAndPath(goal);
+            int depth = Integer.parseInt(args.getArgs().get(2).getValue());
-        logDirect(String.format("Goal: %s", goal.toString()));
+
+            if (width < 1 || height < 2 || depth < 1 || height > 255) {
+                logDirect("Width and depth must at least be 1 block; Height must at least be 2 blocks, and cannot be greater than the build limit.");
+                cont = false;
+            }
+
+            if (cont) {
+                height--;
+                width--;
+                BlockPos corner1;
+                BlockPos corner2;
+                EnumFacing enumFacing = ctx.player().getHorizontalFacing();
+                int addition = ((width % 2 == 0) ? 0 : 1);
+                switch (enumFacing) {
+                    case EAST:
+                        corner1 = new BlockPos(ctx.playerFeet().x, ctx.playerFeet().y, ctx.playerFeet().z - width / 2);
+                        corner2 = new BlockPos(ctx.playerFeet().x + depth, ctx.playerFeet().y + height, ctx.playerFeet().z + width / 2 + addition);
+                        break;
+                    case WEST:
+                        corner1 = new BlockPos(ctx.playerFeet().x, ctx.playerFeet().y, ctx.playerFeet().z + width / 2 + addition);
+                        corner2 = new BlockPos(ctx.playerFeet().x - depth, ctx.playerFeet().y + height, ctx.playerFeet().z - width / 2);
+                        break;
+                    case NORTH:
+                        corner1 = new BlockPos(ctx.playerFeet().x - width / 2, ctx.playerFeet().y, ctx.playerFeet().z);
+                        corner2 = new BlockPos(ctx.playerFeet().x + width / 2 + addition, ctx.playerFeet().y + height, ctx.playerFeet().z - depth);
+                        break;
+                    case SOUTH:
+                        corner1 = new BlockPos(ctx.playerFeet().x + width / 2 + addition, ctx.playerFeet().y, ctx.playerFeet().z);
+                        corner2 = new BlockPos(ctx.playerFeet().x - width / 2, ctx.playerFeet().y + height, ctx.playerFeet().z + depth);
+                        break;
+                    default:
+                        throw new IllegalStateException("Unexpected value: " + enumFacing);
+                }
+                logDirect(String.format("Creating a tunnel %s block(s) high, %s block(s) wide, and %s block(s) deep", height+1, width+1, depth));
+                baritone.getBuilderProcess().clearArea(corner1, corner2);
+            }
+        } else {
+            Goal goal = new GoalStrictDirection(
+                    ctx.playerFeet(),
+                    ctx.player().getHorizontalFacing()
+            );
+            baritone.getCustomGoalProcess().setGoalAndPath(goal);
+            logDirect(String.format("Goal: %s", goal.toString()));
+        }
     }
 
     @Override
@@ -61,7 +106,8 @@ public class TunnelCommand extends Command {
                 "The tunnel command sets a goal that tells Baritone to mine completely straight in the direction that you're facing.",
                 "",
                 "Usage:",
-                "> tunnel"
+                "> tunnel - No arguments, mines in a 1x2 radius.",
+                "> tunnel <height> <width> <depth> - Tunnels in a user defined height, width and depth."
         );
     }
 }

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

@@ -26,6 +26,7 @@ import baritone.api.utils.Helper;
 import baritone.api.utils.PathCalculationResult;
 import baritone.pathing.movement.CalculationContext;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import baritone.utils.NotificationHelper;
 
 import java.util.Optional;
 
@@ -216,6 +217,9 @@ public abstract class AbstractNodeCostSearch implements IPathFinder, Helper {
         if (logInfo) {
             logDebug("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + Math.sqrt(bestDist) + " blocks");
             logDebug("No path found =(");
+            if (Baritone.settings().desktopNotifications.value) {
+                NotificationHelper.notify("No path found =(", true);
+            }
         }
         return Optional.empty();
     }

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

@@ -177,7 +177,7 @@ public abstract class Movement implements IMovement, MovementHelper {
                 //i'm doing it anyway
                 //i dont care if theres snow in the way!!!!!!!
                 //you dont own me!!!!
-                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getPositionEyes(1.0F),
+                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                         VecUtils.getBlockPosCenter(blockPos), ctx.playerRotations()), true)
                 );
                 // don't check selectedblock on this one, this is a fallback when we can't see any face directly, it's intended to be breaking the "incorrect" block

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

@@ -35,6 +35,7 @@ import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.IBlockAccess;
 
 import java.util.Optional;
 
@@ -88,7 +89,7 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (block == Blocks.AIR) { // 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.WEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockSkull || block instanceof BlockTrapDoor || block == Blocks.END_ROD) {
             return false;
         }
         if (Baritone.settings().blocksToAvoid.value.contains(block)) {
@@ -132,10 +133,8 @@ public interface MovementHelper extends ActionCosts, Helper {
             }
             return block == Blocks.WATER || block == Blocks.FLOWING_WATER;
         }
-        // every block that overrides isPassable with anything more complicated than a "return true;" or "return false;"
+
-        // has already been accounted for above
+        return block.isPassable(bsi.access, bsi.isPassableBlockPos.setPos(x, y, z));
-        // therefore it's safe to not construct a blockpos from our x, y, z ints and instead just pass null
-        return block.isPassable(null, BlockPos.ORIGIN);
     }
 
     /**
@@ -149,10 +148,18 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @return Whether or not the block at the specified position
      */
     static boolean fullyPassable(CalculationContext context, int x, int y, int z) {
-        return fullyPassable(context.get(x, y, z));
+        return fullyPassable(
+                context.bsi.access,
+                context.bsi.isPassableBlockPos.setPos(x, y, z),
+                context.bsi.get0(x, y, z)
+        );
     }
 
-    static boolean fullyPassable(IBlockState state) {
+    static boolean fullyPassable(IPlayerContext ctx, BlockPos pos) {
+        return fullyPassable(ctx.world(), pos, ctx.world().getBlockState(pos));
+    }
+
+    static boolean fullyPassable(IBlockAccess access, BlockPos pos, IBlockState state) {
         Block block = state.getBlock();
         if (block == Blocks.AIR) { // early return for most common case
             return true;
@@ -174,7 +181,7 @@ public interface MovementHelper extends ActionCosts, Helper {
             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 block.isPassable(access, pos);
     }
 
     static boolean isReplaceable(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
@@ -295,7 +302,7 @@ public interface MovementHelper extends ActionCosts, Helper {
         if (block == Blocks.FARMLAND || block == Blocks.GRASS_PATH) {
             return true;
         }
-        if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST) {
+        if (block == Blocks.ENDER_CHEST || block == Blocks.CHEST || block == Blocks.TRAPPED_CHEST) {
             return true;
         }
         if (isWater(block)) {
@@ -425,7 +432,9 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        if (!Baritone.settings().disableAutoTool.value && !Baritone.settings().assumeExternalAutoTool.value) {
+            ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        }
     }
 
     static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
@@ -495,9 +504,9 @@ public interface MovementHelper extends ActionCosts, Helper {
     }
 
 
-    static PlaceResult attemptToPlaceABlock(MovementState state, IBaritone baritone, BlockPos placeAt, boolean preferDown) {
+    static PlaceResult attemptToPlaceABlock(MovementState state, IBaritone baritone, BlockPos placeAt, boolean preferDown, boolean wouldSneak) {
         IPlayerContext ctx = baritone.getPlayerContext();
-        Optional<Rotation> direct = RotationUtils.reachable(ctx, placeAt); // we assume that if there is a block there, it must be replacable
+        Optional<Rotation> direct = RotationUtils.reachable(ctx, placeAt, wouldSneak); // we assume that if there is a block there, it must be replacable
         boolean found = false;
         if (direct.isPresent()) {
             state.setTarget(new MovementState.MovementTarget(direct.get(), true));
@@ -514,8 +523,8 @@ public interface MovementHelper extends ActionCosts, Helper {
                 double faceX = (placeAt.getX() + against1.getX() + 1.0D) * 0.5D;
                 double faceY = (placeAt.getY() + against1.getY() + 0.5D) * 0.5D;
                 double faceZ = (placeAt.getZ() + against1.getZ() + 1.0D) * 0.5D;
-                Rotation place = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), new Vec3d(faceX, faceY, faceZ), ctx.playerRotations());
+                Rotation place = RotationUtils.calcRotationFromVec3d(wouldSneak ? RayTraceUtils.inferSneakingEyePosition(ctx.player()) : ctx.playerHead(), new Vec3d(faceX, faceY, faceZ), ctx.playerRotations());
-                RayTraceResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance());
+                RayTraceResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance(), wouldSneak);
                 if (res != null && res.typeOfHit == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(placeAt)) {
                     state.setTarget(new MovementState.MovementTarget(place, true));
                     found = true;
@@ -533,11 +542,17 @@ public interface MovementHelper extends ActionCosts, Helper {
             EnumFacing side = ctx.objectMouseOver().sideHit;
             // only way for selectedBlock.equals(placeAt) to be true is if it's replacable
             if (selectedBlock.equals(placeAt) || (MovementHelper.canPlaceAgainst(ctx, selectedBlock) && selectedBlock.offset(side).equals(placeAt))) {
+                if (wouldSneak) {
+                    state.setInput(Input.SNEAK, true);
+                }
                 ((Baritone) baritone).getInventoryBehavior().selectThrowawayForLocation(true, placeAt.getX(), placeAt.getY(), placeAt.getZ());
                 return PlaceResult.READY_TO_PLACE;
             }
         }
         if (found) {
+            if (wouldSneak) {
+                state.setInput(Input.SNEAK, true);
+            }
             ((Baritone) baritone).getInventoryBehavior().selectThrowawayForLocation(true, placeAt.getX(), placeAt.getY(), placeAt.getZ());
             return PlaceResult.ATTEMPTING;
         }

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

@@ -175,7 +175,7 @@ public class MovementAscend extends Movement {
         IBlockState jumpingOnto = BlockStateInterface.get(ctx, positionToPlace);
         if (!MovementHelper.canWalkOn(ctx, positionToPlace, jumpingOnto)) {
             ticksWithoutPlacement++;
-            if (MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), false) == PlaceResult.READY_TO_PLACE) {
+            if (MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), false, true) == PlaceResult.READY_TO_PLACE) {
                 state.setInput(Input.SNEAK, true);
                 if (ctx.player().isSneaking()) {
                     state.setInput(Input.CLICK_RIGHT, true);

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

@@ -224,7 +224,7 @@ public class MovementDescend extends Movement {
             double destZ = (src.getZ() + 0.5) * 0.17 + (dest.getZ() + 0.5) * 0.83;
             EntityPlayerSP player = ctx.player();
             state.setTarget(new MovementState.MovementTarget(
-                    new Rotation(RotationUtils.calcRotationFromVec3d(player.getPositionEyes(1.0F),
+                    new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                             new Vec3d(destX, dest.getY(), destZ),
                             new Rotation(player.rotationYaw, player.rotationPitch)).getYaw(), player.rotationPitch),
                     false

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

@@ -56,6 +56,14 @@ public class MovementDiagonal extends Movement {
         super(baritone, start, end, new BetterBlockPos[]{dir1, dir1.up(), dir2, dir2.up(), end, end.up()});
     }
 
+    @Override
+    protected boolean safeToCancel(MovementState state) {
+        return ctx.playerFeet().equals(src) || ((
+                MovementHelper.canWalkOn(ctx, new BlockPos(src.x, src.y - 1, dest.z))
+        ) &&
+                MovementHelper.canWalkOn(ctx, new BlockPos(dest.x, src.y - 1, src.z)));
+    }
+
     @Override
     public double calculateCost(CalculationContext context) {
         MutableMoveResult result = new MutableMoveResult();

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

@@ -114,7 +114,7 @@ public class MovementParkour extends Movement {
                 return;
             }
             IBlockState destInto = context.bsi.get0(destX, y, destZ);
-            if (!MovementHelper.fullyPassable(destInto)) {
+            if (!MovementHelper.fullyPassable(context.bsi.access, context.bsi.isPassableBlockPos.setPos(destX, y, destZ), destInto)) {
                 if (i <= 3 && context.allowParkourAscend && context.canSprint && MovementHelper.canWalkOn(context.bsi, destX, y, destZ, destInto) && checkOvershootSafety(context.bsi, destX + xDiff, y + 1, destZ + zDiff)) {
                     res.x = destX;
                     res.y = y + 1;
@@ -250,7 +250,7 @@ public class MovementParkour extends Movement {
             }
         } else if (!ctx.playerFeet().equals(src)) {
             if (ctx.playerFeet().equals(src.offset(direction)) || ctx.player().posY - src.y > 0.0001) {
-                if (!MovementHelper.canWalkOn(ctx, dest.down()) && !ctx.player().onGround && MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), true) == PlaceResult.READY_TO_PLACE) {
+                if (!MovementHelper.canWalkOn(ctx, dest.down()) && !ctx.player().onGround && MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), true, false) == PlaceResult.READY_TO_PLACE) {
                     // go in the opposite order to check DOWN before all horizontals -- down is preferable because you don't have to look to the side while in midair, which could mess up the trajectory
                     state.setInput(Input.CLICK_RIGHT, true);
                 }

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

@@ -184,7 +184,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.playerHead(),
                 VecUtils.getBlockPosCenter(positionToPlace),
                 new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));
         if (!ladder) {

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

@@ -280,7 +280,7 @@ public class MovementTraverse extends Movement {
                 }
             }
             double dist1 = Math.max(Math.abs(ctx.player().posX - (dest.getX() + 0.5D)), Math.abs(ctx.player().posZ - (dest.getZ() + 0.5D)));
-            PlaceResult p = MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), false);
+            PlaceResult p = MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), false, true);
             if ((p == PlaceResult.READY_TO_PLACE || dist1 < 0.6) && !Baritone.settings().assumeSafeWalk.value) {
                 state.setInput(Input.SNEAK, true);
             }

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

@@ -466,7 +466,7 @@ public class PathExecutor implements IPathExecutor, Helper {
             }
             for (int y = next.getDest().y; y <= movement.getSrc().y + 1; y++) {
                 BlockPos chk = new BlockPos(next.getDest().x, y, next.getDest().z);
-                if (!MovementHelper.fullyPassable(ctx.world().getBlockState(chk))) {
+                if (!MovementHelper.fullyPassable(ctx, chk)) {
                     break outer;
                 }
             }
@@ -491,7 +491,7 @@ public class PathExecutor implements IPathExecutor, Helper {
         }
         // we are centered
         BlockPos headBonk = current.getSrc().subtract(current.getDirection()).up(2);
-        if (MovementHelper.fullyPassable(ctx.world().getBlockState(headBonk))) {
+        if (MovementHelper.fullyPassable(ctx, headBonk)) {
             return true;
         }
         // wait 0.3
@@ -524,7 +524,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                 if (x == 1) {
                     chk = chk.add(current.getDirection());
                 }
-                if (!MovementHelper.fullyPassable(ctx.world().getBlockState(chk))) {
+                if (!MovementHelper.fullyPassable(ctx, chk)) {
                     return false;
                 }
             }

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

@@ -75,7 +75,7 @@ public final class BackfillProcess extends BaritoneProcessHelper {
         baritone.getInputOverrideHandler().clearAllKeys();
         for (BlockPos toPlace : toFillIn()) {
             MovementState fake = new MovementState();
-            switch (MovementHelper.attemptToPlaceABlock(fake, baritone, toPlace, false)) {
+            switch (MovementHelper.attemptToPlaceABlock(fake, baritone, toPlace, false, false)) {
                 case NO_OPTION:
                     continue;
                 case READY_TO_PLACE:

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

@@ -25,18 +25,24 @@ import baritone.api.pathing.goals.GoalGetToBlock;
 import baritone.api.process.IBuilderProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
+import baritone.api.schematic.FillSchematic;
 import baritone.api.schematic.ISchematic;
-import baritone.api.utils.*;
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.format.ISchematicFormat;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.RayTraceUtils;
+import baritone.api.utils.Rotation;
+import baritone.api.utils.RotationUtils;
 import baritone.api.utils.input.Input;
 import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
+import baritone.utils.NotificationHelper;
 import baritone.utils.PathingCommandContext;
-import baritone.utils.schematic.FillSchematic;
 import baritone.utils.schematic.MapArtSchematic;
-import baritone.utils.schematic.Schematic;
+import baritone.utils.schematic.SchematicSystem;
 import baritone.utils.schematic.schematica.SchematicaHelper;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import net.minecraft.block.BlockAir;
@@ -45,15 +51,12 @@ import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
-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 java.io.File;
 import java.io.FileInputStream;
-import java.io.IOException;
 import java.util.*;
 
 import static baritone.api.pathing.movement.ActionCosts.COST_INF;
@@ -69,6 +72,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
     private int ticks;
     private boolean paused;
     private int layer;
+    private int numRepeats;
     private List<IBlockState> approxPlaceable;
 
     public BuilderProcess(Baritone baritone) {
@@ -94,7 +98,8 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         }
         this.origin = new Vec3i(x, y, z);
         this.paused = false;
-        this.layer = 0;
+        this.layer = Baritone.settings().startAtLayer.value;
+        this.numRepeats = 0;
         this.observedCompleted = new LongOpenHashSet();
     }
 
@@ -113,27 +118,38 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
 
     @Override
     public boolean build(String name, File schematic, Vec3i origin) {
-        NBTTagCompound tag;
+        Optional<ISchematicFormat> format = SchematicSystem.INSTANCE.getByFile(schematic);
-        try (FileInputStream fileIn = new FileInputStream(schematic)) {
+        if (!format.isPresent()) {
-            tag = CompressedStreamTools.readCompressed(fileIn);
+            return false;
-        } catch (IOException e) {
+        }
+
+        ISchematic parsed;
+        try {
+            parsed = format.get().parse(new FileInputStream(schematic));
+        } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
-        //noinspection ConstantConditions
+
-        if (tag == null) {
+        if (Baritone.settings().mapArtMode.value) {
-            return false;
+            parsed = new MapArtSchematic((IStaticSchematic) parsed);
         }
-        build(name, parse(tag), origin);
+
+        build(name, parsed, origin);
         return true;
     }
 
     @Override
     public void buildOpenSchematic() {
         if (SchematicaHelper.isSchematicaPresent()) {
-            Optional<Tuple<ISchematic, BlockPos>> schematic = SchematicaHelper.getOpenSchematic();
+            Optional<Tuple<IStaticSchematic, BlockPos>> schematic = SchematicaHelper.getOpenSchematic();
             if (schematic.isPresent()) {
-                this.build(schematic.get().getFirst().toString(), schematic.get().getFirst(), schematic.get().getSecond());
+                IStaticSchematic s = schematic.get().getFirst();
+                this.build(
+                        schematic.get().getFirst().toString(),
+                        Baritone.settings().mapArtMode.value ? new MapArtSchematic(s) : s,
+                        schematic.get().getSecond()
+                );
             } else {
                 logDirect("No schematic currently open");
             }
@@ -155,10 +171,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         return new ArrayList<>(approxPlaceable);
     }
 
-    private static ISchematic parse(NBTTagCompound schematic) {
-        return Baritone.settings().mapArtMode.value ? new MapArtSchematic(schematic) : new Schematic(schematic);
-    }
-
     @Override
     public boolean isActive() {
         return schematic != null;
@@ -195,7 +207,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() != Blocks.AIR && !(curr.getBlock() instanceof BlockLiquid) && !valid(curr, desired, false)) {
                         BetterBlockPos pos = new BetterBlockPos(x, y, z);
                         Optional<Rotation> rot = RotationUtils.reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
                         if (rot.isPresent()) {
@@ -236,7 +248,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                         continue; // irrelevant
                     }
                     IBlockState curr = bcc.bsi.get0(x, y, z);
-                    if (MovementHelper.isReplaceable(x, y, z, curr, bcc.bsi) && !valid(curr, desired)) {
+                    if (MovementHelper.isReplaceable(x, y, z, curr, bcc.bsi) && !valid(curr, desired, false)) {
                         if (dy == 1 && bcc.bsi.get0(x, y + 1, z).getBlock() == Blocks.AIR) {
                             continue;
                         }
@@ -267,8 +279,8 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                 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());
+                Rotation rot = RotationUtils.calcRotationFromVec3d(RayTraceUtils.inferSneakingEyePosition(ctx.player()), new Vec3d(placeX, placeY, placeZ), ctx.playerRotations());
-                RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot, ctx.playerController().getBlockReachDistance());
+                RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot, ctx.playerController().getBlockReachDistance(), true);
                 if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(placeAgainstPos) && result.sideHit == against.getOpposite()) {
                     OptionalInt hotbar = hasAnyItemThatWouldPlace(toPlace, result, rot);
                     if (hotbar.isPresent()) {
@@ -303,7 +315,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             );
             ctx.player().rotationYaw = originalYaw;
             ctx.player().rotationPitch = originalPitch;
-            if (valid(wouldBePlaced, desired)) {
+            if (valid(wouldBePlaced, desired, true)) {
                 return OptionalInt.of(i);
             }
         }
@@ -391,8 +403,13 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                 return onTick(calcFailed, isSafeToCancel);
             }
             Vec3i repeat = Baritone.settings().buildRepeat.value;
-            if (repeat.equals(new Vec3i(0, 0, 0))) {
+            int max = Baritone.settings().buildRepeatCount.value;
+            numRepeats++;
+            if (repeat.equals(new Vec3i(0, 0, 0)) || (max != -1 && numRepeats >= max)) {
                 logDirect("Done building");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnBuildFinished.value) {
+                    NotificationHelper.notify("Done building", false);
+                }
                 onLostControl();
                 return null;
             }
@@ -444,7 +461,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             outer:
             for (IBlockState desired : desirableOnHotbar) {
                 for (int i = 0; i < 9; i++) {
-                    if (valid(approxPlaceable.get(i), desired)) {
+                    if (valid(approxPlaceable.get(i), desired, true)) {
                         usefulSlots.add(i);
                         continue outer;
                     }
@@ -455,7 +472,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             outer:
             for (int i = 9; i < 36; i++) {
                 for (IBlockState desired : noValidHotbarOption) {
-                    if (valid(approxPlaceable.get(i), desired)) {
+                    if (valid(approxPlaceable.get(i), desired, true)) {
                         baritone.getInventoryBehavior().attemptToPutOnHotbar(i, usefulSlots::contains);
                         break outer;
                     }
@@ -511,7 +528,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                     if (desired != null) {
                         // we care about this position
                         BetterBlockPos pos = new BetterBlockPos(x, y, z);
-                        if (valid(bcc.bsi.get0(x, y, z), desired)) {
+                        if (valid(bcc.bsi.get0(x, y, z), desired, false)) {
                             incorrectPositions.remove(pos);
                             observedCompleted.add(BetterBlockPos.longHash(pos));
                         } else {
@@ -538,7 +555,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                     }
                     if (bcc.bsi.worldContainsLoadedChunk(blockX, blockZ)) { // check if its in render distance, not if its in cache
                         // we can directly observe this block, it is in render distance
-                        if (valid(bcc.bsi.get0(blockX, blockY, blockZ), schematic.desiredState(x, y, z, current, this.approxPlaceable))) {
+                        if (valid(bcc.bsi.get0(blockX, blockY, blockZ), schematic.desiredState(x, y, z, current, this.approxPlaceable), false)) {
                             observedCompleted.add(BetterBlockPos.longHash(blockX, blockY, blockZ));
                         } else {
                             incorrectPositions.add(new BetterBlockPos(blockX, blockY, blockZ));
@@ -730,7 +747,8 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         name = null;
         schematic = null;
         realSchematic = null;
-        layer = 0;
+        layer = Baritone.settings().startAtLayer.value;
+        numRepeats = 0;
         paused = false;
         observedCompleted = null;
     }
@@ -755,12 +773,23 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
         return result;
     }
 
-    private boolean valid(IBlockState current, IBlockState desired) {
+    private boolean valid(IBlockState current, IBlockState desired, boolean itemVerify) {
-        // TODO more complicated comparison logic I guess
+        if (desired == null) {
+            return true;
+        }
         if (current.getBlock() instanceof BlockLiquid && Baritone.settings().okIfWater.value) {
             return true;
         }
-        return desired == null || current.equals(desired);
+        if (current.getBlock() instanceof BlockAir && Baritone.settings().okIfAir.value.contains(desired.getBlock())) {
+            return true;
+        }
+        if (desired.getBlock() instanceof BlockAir && Baritone.settings().buildIgnoreBlocks.value.contains(current.getBlock())) {
+            return true;
+        }
+        if (!(current.getBlock() instanceof BlockAir) && Baritone.settings().buildIgnoreExisting.value && !itemVerify) {
+            return true;
+        }
+        return current.equals(desired);
     }
 
     public class BuilderCalculationContext extends CalculationContext {
@@ -839,7 +868,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                 }
                 // it should be a real block
                 // is it already that block?
-                if (valid(bsi.get0(x, y, z), sch)) {
+                if (valid(bsi.get0(x, y, z), sch, false)) {
                     return Baritone.settings().breakCorrectBlockPenaltyMultiplier.value;
                 } else {
                     // can break if it's wrong

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

@@ -23,6 +23,7 @@ import baritone.api.process.ICustomGoalProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 
 /**
  * As set by ExampleBaritoneControl or something idk
@@ -93,6 +94,9 @@ public final class CustomGoalProcess extends BaritoneProcessHelper implements IC
                     if (Baritone.settings().disconnectOnArrival.value) {
                         ctx.world().sendQuittingDisconnectingPacket();
                     }
+                    if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnPathComplete.value) {
+                        NotificationHelper.notify("Pathing complete", false);
+                    }
                     return new PathingCommand(this.goal, PathingCommandType.CANCEL_AND_SET_GOAL);
                 }
                 return new PathingCommand(this.goal, PathingCommandType.SET_GOAL_AND_PATH);

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

@@ -29,6 +29,7 @@ import baritone.api.process.PathingCommandType;
 import baritone.api.utils.MyChunkPos;
 import baritone.cache.CachedWorld;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
@@ -83,12 +84,18 @@ public final class ExploreProcess extends BaritoneProcessHelper implements IExpl
     public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
         if (calcFailed) {
             logDirect("Failed");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnExploreFinished.value) {
+                NotificationHelper.notify("Exploration failed", true);
+            }
             onLostControl();
             return null;
         }
         IChunkFilter filter = calcFilter();
         if (!Baritone.settings().disableCompletionCheck.value && filter.countRemain() == 0) {
             logDirect("Explored all chunks");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnExploreFinished.value) {
+                NotificationHelper.notify("Explored all chunks", false);
+            }
             onLostControl();
             return null;
         }

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

@@ -31,6 +31,7 @@ import baritone.api.utils.input.Input;
 import baritone.cache.WorldScanner;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
@@ -232,7 +233,7 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
         both.addAll(openSoulsand);
         for (BlockPos pos : both) {
             boolean soulsand = openSoulsand.contains(pos);
-            Optional<Rotation> rot = RotationUtils.reachableOffset(ctx.player(), pos, new Vec3d(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5), ctx.playerController().getBlockReachDistance());
+            Optional<Rotation> rot = RotationUtils.reachableOffset(ctx.player(), pos, new Vec3d(pos.getX() + 0.5, pos.getY() + 1, pos.getZ() + 0.5), ctx.playerController().getBlockReachDistance(), false);
             if (rot.isPresent() && isSafeToCancel && baritone.getInventoryBehavior().throwaway(true, soulsand ? this::isNetherWart : this::isPlantable)) {
                 RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot.get(), ctx.playerController().getBlockReachDistance());
                 if (result.typeOfHit == RayTraceResult.Type.BLOCK && result.sideHit == EnumFacing.UP) {
@@ -257,6 +258,9 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
 
         if (calcFailed) {
             logDirect("Farm failed");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnFarmFail.value) {
+                NotificationHelper.notify("Farm failed", true);
+            }
             onLostControl();
             return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
         }

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

@@ -30,6 +30,7 @@ import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
+import baritone.utils.NotificationHelper;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockAir;
 import net.minecraft.block.BlockFalling;
@@ -88,10 +89,16 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         if (calcFailed) {
             if (!knownOreLocations.isEmpty() && Baritone.settings().blacklistClosestOnFailure.value) {
                 logDirect("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                    NotificationHelper.notify("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...", true);
+                }
                 knownOreLocations.stream().min(Comparator.comparingDouble(ctx.player()::getDistanceSq)).ifPresent(blacklist::add);
                 knownOreLocations.removeIf(blacklist::contains);
             } else {
                 logDirect("Unable to find any path to " + filter + ", canceling mine");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                    NotificationHelper.notify("Unable to find any path to " + filter + ", canceling mine", true);
+                }
                 cancel();
                 return null;
             }
@@ -221,6 +228,9 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         locs.addAll(dropped);
         if (locs.isEmpty()) {
             logDirect("No locations for " + filter + " known, cancelling");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                NotificationHelper.notify("No locations for " + filter + " known, cancelling", true);
+            }
             cancel();
             return;
         }

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

@@ -29,9 +29,7 @@ import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraft.client.tutorial.TutorialSteps;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.GameType;
+import net.minecraft.world.*;
-import net.minecraft.world.WorldSettings;
-import net.minecraft.world.WorldType;
 
 /**
  * Responsible for automatically testing Baritone's pathing algorithm by automatically creating a world with a specific
@@ -85,15 +83,21 @@ public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
         if (mc.currentScreen instanceof GuiMainMenu) {
             System.out.println("Beginning Baritone automatic test routine");
             mc.displayGuiScreen(null);
-            WorldSettings worldsettings = new WorldSettings(TEST_SEED, GameType.getByName("survival"), true, false, WorldType.DEFAULT);
+            WorldSettings worldsettings = new WorldSettings(TEST_SEED, GameType.SURVIVAL, true, false, WorldType.DEFAULT);
             mc.launchIntegratedServer("BaritoneAutoTest", "BaritoneAutoTest", worldsettings);
         }
 
-        // If the integrated server is launched and the world has initialized, set the spawn point
+        // If the integrated server is running, set the difficulty to peaceful
-        // to our defined starting position
+        if (mc.getIntegratedServer() != null) {
-        if (mc.getIntegratedServer() != null && mc.getIntegratedServer().worlds[0] != null) {
+            mc.getIntegratedServer().setDifficultyForAllWorlds(EnumDifficulty.PEACEFUL);
-            mc.getIntegratedServer().worlds[0].setSpawnPoint(STARTING_POSITION);
+
-            mc.getIntegratedServer().worlds[0].getGameRules().setOrCreateGameRule("spawnRadius", "0");
+            for (final WorldServer world : mc.getIntegratedServer().worlds) {
+                // If the world has initialized, set the spawn point to our defined starting position
+                if (world != null) {
+                    world.setSpawnPoint(STARTING_POSITION);
+                    world.getGameRules().setOrCreateGameRule("spawnRadius", "0");
+                }
+            }
         }
 
         if (event.getType() == TickEvent.Type.IN) { // If we're in-game
@@ -101,7 +105,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.SURVIVAL, false);
             }
 
             // For the first 200 ticks, wait for the world to generate

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

@@ -30,6 +30,7 @@ import net.minecraft.client.Minecraft;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
 
@@ -42,6 +43,9 @@ public class BlockStateInterface {
 
     private final Long2ObjectMap<Chunk> loadedChunks;
     private final WorldData worldData;
+    protected final IBlockAccess world;
+    public final BlockPos.MutableBlockPos isPassableBlockPos;
+    public final IBlockAccess access;
 
     private Chunk prev = null;
     private CachedRegion prevCached = null;
@@ -59,6 +63,7 @@ public class BlockStateInterface {
     }
 
     public BlockStateInterface(World world, WorldData worldData, boolean copyLoadedChunks) {
+        this.world = world;
         this.worldData = worldData;
         Long2ObjectMap<Chunk> worldLoaded = ((IChunkProviderClient) world.getChunkProvider()).loadedChunks();
         if (copyLoadedChunks) {
@@ -70,6 +75,8 @@ public class BlockStateInterface {
         if (!Minecraft.getMinecraft().isCallingFromMinecraftThread()) {
             throw new IllegalStateException();
         }
+        this.isPassableBlockPos = new BlockPos.MutableBlockPos();
+        this.access = new BlockStateInterfaceAccessWrapper(this);
     }
 
     public boolean worldContainsLoadedChunk(int blockX, int blockZ) {

src/main/java/baritone/utils/BlockStateInterfaceAccessWrapper.java

@@ -0,0 +1,81 @@
+/*
+ * 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.utils;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Biomes;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.WorldType;
+import net.minecraft.world.biome.Biome;
+
+import javax.annotation.Nullable;
+
+/**
+ * @author Brady
+ * @since 11/5/2019
+ */
+@SuppressWarnings("NullableProblems")
+public final class BlockStateInterfaceAccessWrapper implements IBlockAccess {
+
+    private final BlockStateInterface bsi;
+
+    BlockStateInterfaceAccessWrapper(BlockStateInterface bsi) {
+        this.bsi = bsi;
+    }
+
+    @Nullable
+    @Override
+    public TileEntity getTileEntity(BlockPos pos) {
+        return null;
+    }
+
+    @Override
+    public int getCombinedLight(BlockPos pos, int lightValue) {
+        return 0;
+    }
+
+    @Override
+    public IBlockState getBlockState(BlockPos pos) {
+        // BlockStateInterface#get0(BlockPos) btfo!
+        return this.bsi.get0(pos.getX(), pos.getY(), pos.getZ());
+    }
+
+    @Override
+    public boolean isAirBlock(BlockPos pos) {
+        return this.bsi.get0(pos.getX(), pos.getY(), pos.getZ()).getMaterial() == Material.AIR;
+    }
+
+    @Override
+    public Biome getBiome(BlockPos pos) {
+        return Biomes.FOREST;
+    }
+
+    @Override
+    public int getStrongPower(BlockPos pos, EnumFacing direction) {
+        return 0;
+    }
+
+    @Override
+    public WorldType getWorldType() {
+        return this.bsi.world.getWorldType();
+    }
+}

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

@@ -108,6 +108,11 @@ public final class InputOverrideHandler extends Behavior implements IInputOverri
     }
 
     private boolean inControl() {
+        for (Input input : new Input[]{Input.MOVE_FORWARD, Input.MOVE_BACK, Input.MOVE_LEFT, Input.MOVE_RIGHT, Input.SNEAK}) {
+            if (isInputForcedDown(input)) {
+                return true;
+            }
+        }
         // if we are not primary (a bot) we should set the movementinput even when idle (not pathing)
         return baritone.getPathingBehavior().isPathing() || baritone != BaritoneAPI.getProvider().getPrimaryBaritone();
     }

src/main/java/baritone/utils/NotificationHelper.java

@@ -0,0 +1,89 @@
+/*
+ * 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.utils;
+
+import org.apache.commons.lang3.SystemUtils;
+
+import java.awt.*;
+import java.io.IOException;
+
+/**
+ * This class is not called from the main game thread.
+ * Do not refer to any Minecraft classes, it wouldn't be thread safe.
+ *
+ * @author aUniqueUser
+ */
+public class NotificationHelper {
+
+    private static TrayIcon trayIcon;
+
+    public static void notify(String text, boolean error) {
+        if (SystemUtils.IS_OS_WINDOWS) {
+            windows(text, error);
+        } else if (SystemUtils.IS_OS_MAC_OSX) {
+            mac(text);
+        } else if (SystemUtils.IS_OS_LINUX) {
+            linux(text);
+        }
+    }
+
+    private static void windows(String text, boolean error) {
+        if (SystemTray.isSupported()) {
+            try {
+                if (trayIcon == null) {
+                    SystemTray tray = SystemTray.getSystemTray();
+                    Image image = Toolkit.getDefaultToolkit().createImage("");
+
+                    trayIcon = new TrayIcon(image, "Baritone");
+                    trayIcon.setImageAutoSize(true);
+                    trayIcon.setToolTip("Baritone");
+                    tray.add(trayIcon);
+                }
+
+                trayIcon.displayMessage("Baritone", text, error ? TrayIcon.MessageType.ERROR : TrayIcon.MessageType.INFO);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            System.out.println("SystemTray is not supported");
+        }
+    }
+
+    private static void mac(String text) {
+        ProcessBuilder processBuilder = new ProcessBuilder();
+        processBuilder.command("osascript", "-e", "display notification \"" + text + "\" with title \"Baritone\"");
+        try {
+            processBuilder.start();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // The only way to display notifications on linux is to use the java-gnome library,
+    // or send notify-send to shell with a ProcessBuilder. Unfortunately the java-gnome
+    // library is licenced under the GPL, see (https://en.wikipedia.org/wiki/Java-gnome)
+    private static void linux(String text) {
+        ProcessBuilder processBuilder = new ProcessBuilder();
+        processBuilder.command("notify-send", "-a", "Baritone", text);
+        try {
+            processBuilder.start();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

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

@@ -96,12 +96,27 @@ public class ToolSet {
     }
 
     /**
-     * Calculate which tool on the hotbar is best for mining
+     * Calculate which tool on the hotbar is best for mining, depending on an override setting,
+     * related to auto tool movement cost, it will either return current selected slot, or the best slot.
      *
      * @param b the blockstate to be mined
      * @return An int containing the index in the tools array that worked best
      */
+
     public int getBestSlot(Block b, boolean preferSilkTouch) {
+        return getBestSlot(b, preferSilkTouch, false);
+    }
+
+    public int getBestSlot(Block b, boolean preferSilkTouch, boolean pathingCalculation) {
+
+        /*
+        If we actually want know what efficiency our held item has instead of the best one
+        possible, this lets us make pathing depend on the actual tool to be used (if auto tool is disabled)
+        */
+        if (Baritone.settings().disableAutoTool.value && pathingCalculation) {
+            return player.inventory.currentItem;
+        }
+
         int best = 0;
         double highestSpeed = Double.NEGATIVE_INFINITY;
         int lowestCost = Integer.MIN_VALUE;
@@ -137,7 +152,7 @@ public class ToolSet {
      * @return A double containing the destruction ticks with the best tool
      */
     private double getBestDestructionTime(Block b) {
-        ItemStack stack = player.inventory.getStackInSlot(getBestSlot(b, false));
+        ItemStack stack = player.inventory.getStackInSlot(getBestSlot(b, false, true));
         return calculateSpeedVsBlock(stack, b.getDefaultState()) * avoidanceMultiplier(b);
     }
 

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

@@ -17,24 +17,34 @@
 
 package baritone.utils.schematic;
 
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.MaskSchematic;
 import net.minecraft.block.BlockAir;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.nbt.NBTTagCompound;
 
 import java.util.OptionalInt;
 import java.util.function.Predicate;
 
-public class MapArtSchematic extends Schematic {
+public class MapArtSchematic extends MaskSchematic {
 
     private final int[][] heightMap;
 
-    public MapArtSchematic(NBTTagCompound schematic) {
+    public MapArtSchematic(IStaticSchematic schematic) {
         super(schematic);
-        heightMap = new int[widthX][lengthZ];
+        this.heightMap = generateHeightMap(schematic);
+    }
 
-        for (int x = 0; x < widthX; x++) {
+    @Override
-            for (int z = 0; z < lengthZ; z++) {
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
-                IBlockState[] column = states[x][z];
+        return y >= this.heightMap[x][z];
+    }
+
+    private static int[][] generateHeightMap(IStaticSchematic schematic) {
+        int[][] heightMap = new int[schematic.widthX()][schematic.lengthZ()];
+
+        for (int x = 0; x < schematic.widthX(); x++) {
+            for (int z = 0; z < schematic.lengthZ(); z++) {
+                IBlockState[] column = schematic.getColumn(x, z);
 
                 OptionalInt lowestBlockY = lastIndexMatching(column, state -> !(state.getBlock() instanceof BlockAir));
                 if (lowestBlockY.isPresent()) {
@@ -44,9 +54,9 @@ public class MapArtSchematic extends Schematic {
                     System.out.println("Letting it be whatever");
                     heightMap[x][z] = 256;
                 }
-
             }
         }
+        return heightMap;
     }
 
     private static <T> OptionalInt lastIndexMatching(T[] arr, Predicate<? super T> predicate) {
@@ -57,10 +67,4 @@ public class MapArtSchematic extends Schematic {
         }
         return OptionalInt.empty();
     }
-
-    @Override
-    public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
-        // in map art, we only care about coordinates in or above the art
-        return super.inSchematic(x, y, z, currentState) && y >= heightMap[x][z];
-    }
 }

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

@@ -0,0 +1,51 @@
+/*
+ * 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.utils.schematic;
+
+import baritone.api.command.registry.Registry;
+import baritone.api.schematic.ISchematicSystem;
+import baritone.api.schematic.format.ISchematicFormat;
+import baritone.utils.schematic.format.DefaultSchematicFormats;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 12/24/2019
+ */
+public enum SchematicSystem implements ISchematicSystem {
+    INSTANCE;
+
+    private final Registry<ISchematicFormat> registry = new Registry<>();
+
+    SchematicSystem() {
+        Arrays.stream(DefaultSchematicFormats.values()).forEach(this.registry::register);
+    }
+
+    @Override
+    public Registry<ISchematicFormat> getRegistry() {
+        return this.registry;
+    }
+
+    @Override
+    public Optional<ISchematicFormat> getByFile(File file) {
+        return this.registry.stream().filter(format -> format.isFileType(file)).findFirst();
+    }
+}

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

@@ -17,42 +17,34 @@
 
 package baritone.utils.schematic;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.AbstractSchematic;
+import baritone.api.schematic.IStaticSchematic;
 import net.minecraft.block.state.IBlockState;
 
 import java.util.List;
 
-public class FillSchematic implements ISchematic {
+/**
+ * Default implementation of {@link IStaticSchematic}
+ *
+ * @author Brady
+ * @since 12/23/2019
+ */
+public class StaticSchematic extends AbstractSchematic implements IStaticSchematic {
 
-    private final int widthX;
+    protected IBlockState[][][] states;
-    private final int heightY;
-    private final int lengthZ;
-    private final IBlockState state;
-
-    public FillSchematic(int widthX, int heightY, int lengthZ, IBlockState state) {
-        this.widthX = widthX;
-        this.heightY = heightY;
-        this.lengthZ = lengthZ;
-        this.state = state;
-    }
 
     @Override
     public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return state;
+        return this.states[x][z][y];
     }
 
     @Override
-    public int widthX() {
+    public IBlockState getDirect(int x, int y, int z) {
-        return widthX;
+        return this.states[x][z][y];
     }
 
     @Override
-    public int heightY() {
+    public IBlockState[] getColumn(int x, int z) {
-        return heightY;
+        return this.states[x][z];
-    }
-
-    @Override
-    public int lengthZ() {
-        return lengthZ;
     }
 }

src/main/java/baritone/utils/schematic/format/DefaultSchematicFormats.java

@@ -0,0 +1,82 @@
+/*
+ * 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.utils.schematic.format;
+
+import baritone.api.schematic.IStaticSchematic;
+import baritone.api.schematic.format.ISchematicFormat;
+import baritone.utils.schematic.format.defaults.MCEditSchematic;
+import baritone.utils.schematic.format.defaults.SpongeSchematic;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import org.apache.commons.io.FilenameUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Default implementations of {@link ISchematicFormat}
+ *
+ * @author Brady
+ * @since 12/13/2019
+ */
+public enum DefaultSchematicFormats implements ISchematicFormat {
+
+    /**
+     * The MCEdit schematic specification. Commonly denoted by the ".schematic" file extension.
+     */
+    MCEDIT("schematic") {
+
+        @Override
+        public IStaticSchematic parse(InputStream input) throws IOException {
+            return new MCEditSchematic(CompressedStreamTools.readCompressed(input));
+        }
+    },
+
+    /**
+     * The SpongePowered Schematic Specification. Commonly denoted by the ".schem" file extension.
+     *
+     * @see <a href="https://github.com/SpongePowered/Schematic-Specification">Sponge Schematic Specification</a>
+     */
+    SPONGE("schem") {
+
+        @Override
+        public IStaticSchematic parse(InputStream input) throws IOException {
+            NBTTagCompound nbt = CompressedStreamTools.readCompressed(input);
+            int version = nbt.getInteger("Version");
+            switch (version) {
+                case 1:
+                case 2:
+                    return new SpongeSchematic(nbt);
+                default:
+                    throw new UnsupportedOperationException("Unsupported Version of a Sponge Schematic");
+            }
+        }
+    };
+
+    private final String extension;
+
+    DefaultSchematicFormats(String extension) {
+        this.extension = extension;
+    }
+
+    @Override
+    public boolean isFileType(File file) {
+        return this.extension.equalsIgnoreCase(FilenameUtils.getExtension(file.getAbsolutePath()));
+    }
+}

src/main/java/baritone/utils/schematic/format/defaults/MCEditSchematic.java

@@ -15,30 +15,27 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.utils.schematic;
+package baritone.utils.schematic.format.defaults;
 
-import baritone.api.schematic.ISchematic;
+import baritone.utils.schematic.StaticSchematic;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.nbt.NBTTagCompound;
 
-import java.util.List;
+/**
+ * @author Brady
+ * @since 12/27/2019
+ */
+public final class MCEditSchematic extends StaticSchematic {
 
-public class Schematic implements ISchematic {
+    public MCEditSchematic(NBTTagCompound schematic) {
-
-    public final int widthX;
-    public final int heightY;
-    public final int lengthZ;
-    protected final IBlockState[][][] states;
-
-    public Schematic(NBTTagCompound schematic) {
         String type = schematic.getString("Materials");
         if (!type.equals("Alpha")) {
             throw new IllegalStateException("bad schematic " + type);
         }
-        widthX = schematic.getInteger("Width");
+        this.x = schematic.getInteger("Width");
-        heightY = schematic.getInteger("Height");
+        this.y = schematic.getInteger("Height");
-        lengthZ = schematic.getInteger("Length");
+        this.z = schematic.getInteger("Length");
         byte[] blocks = schematic.getByteArray("Blocks");
         byte[] metadata = schematic.getByteArray("Data");
 
@@ -51,11 +48,11 @@ public class Schematic implements ISchematic {
                 additional[i * 2 + 1] = (byte) ((addBlocks[i] >> 0) & 0xF); // upper nibble
             }
         }
-        states = new IBlockState[widthX][lengthZ][heightY];
+        this.states = new IBlockState[this.x][this.z][this.y];
-        for (int y = 0; y < heightY; y++) {
+        for (int y = 0; y < this.y; y++) {
-            for (int z = 0; z < lengthZ; z++) {
+            for (int z = 0; z < this.z; z++) {
-                for (int x = 0; x < widthX; x++) {
+                for (int x = 0; x < this.x; x++) {
-                    int blockInd = (y * lengthZ + z) * widthX + x;
+                    int blockInd = (y * this.z + z) * this.x + x;
 
                     int blockID = blocks[blockInd] & 0xFF;
                     if (additional != null) {
@@ -64,29 +61,9 @@ public class Schematic implements ISchematic {
                     }
                     Block block = Block.REGISTRY.getObjectById(blockID);
                     int meta = metadata[blockInd] & 0xFF;
-                    states[x][z][y] = block.getStateFromMeta(meta);
+                    this.states[x][z][y] = block.getStateFromMeta(meta);
                 }
             }
         }
     }
-
-    @Override
-    public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return states[x][z][y];
-    }
-
-    @Override
-    public int widthX() {
-        return widthX;
-    }
-
-    @Override
-    public int heightY() {
-        return heightY;
-    }
-
-    @Override
-    public int lengthZ() {
-        return lengthZ;
-    }
 }

src/main/java/baritone/utils/schematic/format/defaults/SpongeSchematic.java

@@ -0,0 +1,157 @@
+/*
+ * 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.utils.schematic.format.defaults;
+
+import baritone.utils.schematic.StaticSchematic;
+import baritone.utils.type.VarInt;
+import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Brady
+ * @since 12/27/2019
+ */
+public final class SpongeSchematic extends StaticSchematic {
+
+    public SpongeSchematic(NBTTagCompound nbt) {
+        this.x = nbt.getInteger("Width");
+        this.y = nbt.getInteger("Height");
+        this.z = nbt.getInteger("Length");
+        this.states = new IBlockState[this.x][this.z][this.y];
+
+        Int2ObjectArrayMap<IBlockState> palette = new Int2ObjectArrayMap<>();
+        NBTTagCompound paletteTag = nbt.getCompoundTag("Palette");
+        for (String tag : paletteTag.getKeySet()) {
+            int index = paletteTag.getInteger(tag);
+
+            SerializedBlockState serializedState = SerializedBlockState.getFromString(tag);
+            if (serializedState == null) {
+                throw new IllegalArgumentException("Unable to parse palette tag");
+            }
+
+            IBlockState state = serializedState.deserialize();
+            if (state == null) {
+                throw new IllegalArgumentException("Unable to deserialize palette tag");
+            }
+
+            palette.put(index, state);
+        }
+
+        // BlockData is stored as an NBT byte[], however, the actual data that is represented is a varint[]
+        byte[] rawBlockData = nbt.getByteArray("BlockData");
+        int[] blockData = new int[this.x * this.y * this.z];
+        int offset = 0;
+        for (int i = 0; i < blockData.length; i++) {
+            if (offset >= rawBlockData.length) {
+                throw new IllegalArgumentException("No remaining bytes in BlockData for complete schematic");
+            }
+
+            VarInt varInt = VarInt.read(rawBlockData, offset);
+            blockData[i] = varInt.getValue();
+            offset += varInt.getSize();
+        }
+
+        for (int y = 0; y < this.y; y++) {
+            for (int z = 0; z < this.z; z++) {
+                for (int x = 0; x < this.x; x++) {
+                    int index = (y * this.z + z) * this.x + x;
+                    IBlockState state = palette.get(blockData[index]);
+                    if (state == null) {
+                        throw new IllegalArgumentException("Invalid Palette Index " + index);
+                    }
+
+                    this.states[x][z][y] = state;
+                }
+            }
+        }
+    }
+
+    private static final class SerializedBlockState {
+
+        private static final Pattern REGEX = Pattern.compile("(?<location>(\\w+:)?\\w+)(\\[(?<properties>(\\w+=\\w+,?)+)])?");
+
+        private final ResourceLocation resourceLocation;
+        private final Map<String, String> properties;
+        private IBlockState blockState;
+
+        private SerializedBlockState(ResourceLocation resourceLocation, Map<String, String> properties) {
+            this.resourceLocation = resourceLocation;
+            this.properties = properties;
+        }
+
+        private IBlockState deserialize() {
+            if (this.blockState == null) {
+                Block block = Block.REGISTRY.getObject(this.resourceLocation);
+                this.blockState = block.getDefaultState();
+
+                this.properties.keySet().stream().sorted(String::compareTo).forEachOrdered(key -> {
+                    IProperty<?> property = block.getBlockState().getProperty(key);
+                    if (property != null) {
+                        this.blockState = setPropertyValue(this.blockState, property, this.properties.get(key));
+                    }
+                });
+            }
+            return this.blockState;
+        }
+
+        private static SerializedBlockState getFromString(String s) {
+            Matcher m = REGEX.matcher(s);
+            if (!m.matches()) {
+                return null;
+            }
+
+            try {
+                String location = m.group("location");
+                String properties = m.group("properties");
+
+                ResourceLocation resourceLocation = new ResourceLocation(location);
+                Map<String, String> propertiesMap = new HashMap<>();
+                if (properties != null) {
+                    for (String property : properties.split(",")) {
+                        String[] split = property.split("=");
+                        propertiesMap.put(split[0], split[1]);
+                    }
+                }
+
+                return new SerializedBlockState(resourceLocation, propertiesMap);
+            } catch (Exception e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+
+        private static <T extends Comparable<T>> IBlockState setPropertyValue(IBlockState state, IProperty<T> property, String value) {
+            Optional<T> parsed = property.parseValue(value).toJavaUtil();
+            if (parsed.isPresent()) {
+                return state.withProperty(property, parsed.get());
+            } else {
+                throw new IllegalArgumentException("Invalid value for property " + property);
+            }
+        }
+    }
+}

src/main/java/baritone/utils/schematic/schematica/SchematicAdapter.java

@@ -17,14 +17,14 @@
 
 package baritone.utils.schematic.schematica;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
 import com.github.lunatrius.schematica.client.world.SchematicWorld;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.List;
 
-public final class SchematicAdapter implements ISchematic {
+public final class SchematicAdapter implements IStaticSchematic {
 
     private final SchematicWorld schematic;
 
@@ -34,7 +34,12 @@ public final class SchematicAdapter implements ISchematic {
 
     @Override
     public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
-        return schematic.getSchematic().getBlockState(new BlockPos(x, y, z));
+        return this.getDirect(x, y, z);
+    }
+
+    @Override
+    public IBlockState getDirect(int x, int y, int z) {
+        return this.schematic.getSchematic().getBlockState(new BlockPos(x, y, z));
     }
 
     @Override

src/main/java/baritone/utils/schematic/schematica/SchematicaHelper.java

@@ -17,7 +17,7 @@
 
 package baritone.utils.schematic.schematica;
 
-import baritone.api.schematic.ISchematic;
+import baritone.api.schematic.IStaticSchematic;
 import com.github.lunatrius.schematica.Schematica;
 import com.github.lunatrius.schematica.proxy.ClientProxy;
 import net.minecraft.util.Tuple;
@@ -37,7 +37,7 @@ public enum SchematicaHelper {
         }
     }
 
-    public static Optional<Tuple<ISchematic, BlockPos>> getOpenSchematic() {
+    public static Optional<Tuple<IStaticSchematic, BlockPos>> getOpenSchematic() {
         return Optional.ofNullable(ClientProxy.schematic)
                 .map(world -> new Tuple<>(new SchematicAdapter(world), world.position));
     }

src/main/java/baritone/utils/type/VarInt.java

@@ -0,0 +1,95 @@
+/*
+ * 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.utils.type;
+
+import it.unimi.dsi.fastutil.bytes.ByteArrayList;
+import it.unimi.dsi.fastutil.bytes.ByteList;
+
+/**
+ * @author Brady
+ * @since 12/19/2019
+ */
+public final class VarInt {
+
+    private final int value;
+    private final byte[] serialized;
+    private final int size;
+
+    public VarInt(int value) {
+        this.value = value;
+        this.serialized = serialize0(this.value);
+        this.size = this.serialized.length;
+    }
+
+    /**
+     * @return The integer value that is represented by this {@link VarInt}.
+     */
+    public final int getValue() {
+        return this.value;
+    }
+
+    /**
+     * @return The size of this {@link VarInt}, in bytes, once serialized.
+     */
+    public final int getSize() {
+        return this.size;
+    }
+
+    public final byte[] serialize() {
+        return this.serialized;
+    }
+
+    private static byte[] serialize0(int valueIn) {
+        ByteList bytes = new ByteArrayList();
+
+        int value = valueIn;
+        while ((value & 0x80) != 0) {
+            bytes.add((byte) (value & 0x7F | 0x80));
+            value >>>= 7;
+        }
+        bytes.add((byte) (value & 0xFF));
+
+        return bytes.toByteArray();
+    }
+
+    public static VarInt read(byte[] bytes) {
+        return read(bytes, 0);
+    }
+
+    public static VarInt read(byte[] bytes, int start) {
+        int value = 0;
+        int size = 0;
+        int index = start;
+
+        while (true) {
+            byte b = bytes[index++];
+            value |= (b & 0x7F) << size++ * 7;
+
+            if (size > 5) {
+                throw new IllegalArgumentException("VarInt size cannot exceed 5 bytes");
+            }
+
+            // Most significant bit denotes another byte is to be read.
+            if ((b & 0x80) == 0) {
+                break;
+            }
+        }
+
+        return new VarInt(value);
+    }
+}