v1.3.8

Merge branch 'master' into 1.13.2
v1.2.14
2020-04-21 12:05:09 -07:00 · 2020-04-21 12:04:44 -07:00 · 2020-04-21 12:02:07 -07:00 · 2020-04-18 22:07:18 -07:00 · 2020-04-09 14:02:28 -07:00 · 2020-04-09 17:01:26 -04:00
71 changed files with 1338 additions and 577 deletions
--- a/.github/ISSUE_TEMPLATE/bug.md
+++ b/.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.
+- [ ] I have not used any OwO's or UwU's in this issue.
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.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
- [ ] I have not used any OwO's or UwU's in this issue.
+- [x] I know how to properly use check boxes 
+- [ ] I have not used any OwO's or UwU's in this issue.
--- a/.github/ISSUE_TEMPLATE/suggestion.md
+++ b/.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
- [ ] I have not used any OwO's or UwU's in this issue.
+- [x] I know how to properly use check boxes 
+- [ ] I have not used any OwO's or UwU's in this issue.
--- a/.travis.yml
+++ b/.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 /bin/sh -c "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -screen 0 128x128x24 -ac +extension GLX +render; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runAutoTest; cat /code/autotest/success"
+- docker run --name baritone cabaletta/baritone ./gradlew javadoc
+#- docker run --name baritone cabaletta/baritone /bin/sh -c "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -screen 0 128x128x24 -ac +extension GLX +render; DISPLAY=:99 BARITONE_AUTO_TEST=true ./gradlew runAutoTest; cat /code/autotest/success"
 - docker cp baritone:/code/dist dist
 - ls dist
 - cat dist/checksums.txt
--- a/README.md
+++ b/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&amp;utm_medium=referral&amp;utm_content=cabaletta/baritone&amp;utm_campaign=Badge_Grade)
-[![HitCount](http://hits.dwyl.com/cabaletta/baritone.svg)](http://hits.dwyl.com/cabaletta/baritone/)
-[![GitHub All Releases](https://img.shields.io/github/downloads/cabaletta/baritone/total.svg)](https://github.com/cabaletta/baritone/releases/)
 [![Minecraft](https://img.shields.io/badge/MC-1.12.2-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,9 +21,10 @@
 ![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.8%20/%20v1.3.4%20/%20v1.4.1-brightgreen.svg)](https://impactclient.net/)
+[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.10%20/%20v1.3.5%20/%20v1.4.3-brightgreen.svg)](https://impactclient.net/)
 [![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/)
 [![forthebadge](https://forthebadge.com/images/badges/built-with-swag.svg)](http://forthebadge.com/)
@@ -29,14 +32,14 @@

 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.

-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.

 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 +59,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/).
--- a/SETUP.md
+++ b/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
--- a/USAGE.md
+++ b/USAGE.md
@@ -8,11 +8,25 @@ Baritone commands can also by default be typed in the chatbox. However if you ma

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

+# For Baritone 1.2.10+, 1.3.5+, 1.4.2+
+
+Lots of the commands have changed, BUT `#help` is improved vastly (its clickable! commands have tab completion! oh my!).
+
+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`.

@@ -26,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.
- `save waypointName` to save a waypoint. `goto waypointName` to go to it.
- `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).
+- `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.
+- `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.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.
@@ -38,12 +52,6 @@ Some common examples:
 - `version` to get the version of Baritone you're running
 - `damn` daniel

-
-New commands:
- `sel` to manage selections
- some others
-
-
 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).

 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`.
--- a/build.gradle
+++ b/build.gradle
@@ -16,11 +16,10 @@
 */

 group 'baritone'
-version '1.3.5'
+version '1.3.8'

 buildscript {
    repositories {
-        jcenter()
        maven {
            name = 'forge'
            url = 'http://files.minecraftforge.net/maven'
@@ -29,6 +28,7 @@ buildscript {
            name = 'impactdevelopment-repo'
            url = 'https://impactdevelopment.github.io/maven/'
        }
+        jcenter()
    }

    dependencies {
--- a/scripts/proguard.pro
+++ b/scripts/proguard.pro
@@ -134,19 +134,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,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 decode(java.lang.String);
+#    public static byte parseByte(java.lang.String);
+#    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);
+#    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,int);
-    public static java.lang.Short valueOf(java.lang.String,int);
-    public static java.lang.Short valueOf(java.lang.String);
+#    public static short parseShort(java.lang.String);
+#    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);
    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);
@@ -154,10 +154,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);
-    public static java.lang.Integer valueOf(java.lang.String,int);
-    public static java.lang.Integer valueOf(java.lang.String);
+#    public static int parseInt(java.lang.String,int);
+#    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);
    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);
@@ -179,12 +179,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);
-    public static java.lang.Long valueOf(java.lang.String,int);
-    public static java.lang.Long valueOf(java.lang.String);
+#    public static long parseLong(java.lang.String,int);
+#    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);
    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);
@@ -201,9 +201,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);
@@ -215,9 +215,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(double);
-    public static double parseDouble(java.lang.String);
+#    public static java.lang.Double valueOf(java.lang.String);
+#    public static java.lang.Double valueOf(double);
+#    public static double parseDouble(java.lang.String);
    public static boolean isNaN(double);
    public static boolean isInfinite(double);
    public static long doubleToLongBits(double);
--- a/src/api/java/baritone/api/IBaritoneProvider.java
+++ b/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();
 }
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -183,6 +183,20 @@ 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(
+
+    )));
+
+    /**
+     * 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>
@@ -233,7 +247,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);

@@ -252,6 +266,11 @@ public final class Settings {
     */
    public final Setting<Double> randomLooking113 = new Setting<>(2d);

+    /**
+     * 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
     */
@@ -742,6 +761,11 @@ public final class Settings {
     */
    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>
@@ -791,6 +815,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.
@@ -1020,6 +1050,10 @@ public final class Settings {
     */
    public final Setting<Boolean> renderSelectionCorners = new Setting<>(true);

+    /**
+     * Desktop Notifications
+     */
+    public final Setting<Boolean> desktopNotifications = new Setting<>(false);

    /**
     * A map of lowercase setting field names to their respective setting
--- a/src/api/java/baritone/api/cache/ICachedWorld.java
+++ b/src/api/java/baritone/api/cache/ICachedWorld.java
@@ -81,6 +81,4 @@ public interface ICachedWorld {
     * in a new thread by default.
     */
    void save();
-
-
 }
--- a/src/api/java/baritone/api/cache/IWorldScanner.java
+++ b/src/api/java/baritone/api/cache/IWorldScanner.java
@@ -77,10 +77,20 @@ public interface IWorldScanner {
    }

    /**
-     * Repacks 40 chunks around the player.
+     * Overload of {@link #repack(IPlayerContext, int)} where the value of the {@code range} parameter is {@code 40}.
     *
-     * @param ctx The player context for that player.
-     * @return The number of chunks queued for repacking.
+     * @param ctx The player, describing the origin
+     * @return The amount of chunks successfully queued for repacking
     */
    int repack(IPlayerContext ctx);
+
+    /**
+     * Queues the chunks in a square formation around the specified player, using the specified
+     * range, which represents 1/2 the square's dimensions, where the player is in the center.
+     *
+     * @param ctx The player, describing the origin
+     * @param range The range to repack
+     * @return The amount of chunks successfully queued for repacking
+     */
+    int repack(IPlayerContext ctx, int range);
 }
--- a/src/api/java/baritone/api/command/datatypes/RelativeGoal.java
+++ b/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<>();
-        final IArgConsumer copy = consumer.copy(); // This is a hack and should be fixed in the future probably
-        for (int i = 0; i < 3; i++) {
-            if (copy.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
-                coords.add(o -> consumer.getDatatypePost(RelativeCoordinate.INSTANCE, o));
-                copy.get(); // Consume so we actually decrement the remaining arguments
-            }
+        GoalBlock goalBlock = consumer.peekDatatypePostOrNull(RelativeGoalBlock.INSTANCE, origin);
+        if (goalBlock != null) {
+            return goalBlock;
        }

-        switch (coords.size()) {
-            case 0:
-                return new GoalBlock(origin);
-            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());
+        GoalXZ goalXZ = consumer.peekDatatypePostOrNull(RelativeGoalXZ.INSTANCE, origin);
+        if (goalXZ != null) {
+            return goalXZ;
        }
+
+        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
--- a/src/api/java/baritone/api/command/datatypes/RelativeGoalXZ.java
+++ b/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))
        );
    }

--- a/src/api/java/baritone/api/command/exception/CommandErrorMessageException.java
+++ b/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);
+    }
 }
--- a/src/api/java/baritone/api/command/exception/CommandException.java
+++ b/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);
+    }
 }
--- a/src/api/java/baritone/api/command/exception/CommandInvalidArgumentException.java
+++ b/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) {
-        super(String.format(
-                "Error at argument #%s: %s",
-                arg.getIndex() == -1 ? "<unknown>" : Integer.toString(arg.getIndex() + 1),
-                reason
-        ));
+    protected CommandInvalidArgumentException(ICommandArgument arg, String message) {
+        super(formatMessage(arg, message));
        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
+        );
+    }
 }
--- a/src/api/java/baritone/api/command/exception/CommandInvalidTypeException.java
+++ b/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);
    }
 }
--- a/src/api/java/baritone/api/command/exception/CommandUnhandledException.java
+++ b/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);

--- a/src/api/java/baritone/api/event/events/TickEvent.java
+++ b/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) {
+    public TickEvent(EventState state, Type type, int count) {
        this.state = state;
        this.type = type;
-        this.count = incrementCount();
-    }
-
-    private static synchronized int incrementCount() {
-        return overallTickCount++;
+        this.count = count;
    }

    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 {
        /**
--- a/src/api/java/baritone/api/schematic/AbstractSchematic.java
+++ b/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;
--- a/src/api/java/baritone/api/schematic/FillSchematic.java
+++ b/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()));
+    }
+
    public BlockOptionalMeta getBom() {
        return bom;
    }
--- a/src/api/java/baritone/api/schematic/ISchematicSystem.java
+++ b/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);
+}
--- a/src/api/java/baritone/api/schematic/IStaticSchematic.java
+++ b/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;
+    }
+}
--- a/src/api/java/baritone/api/schematic/format/ISchematicFormat.java
+++ b/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);
+}
--- a/src/api/java/baritone/api/utils/BlockOptionalMeta.java
+++ b/src/api/java/baritone/api/utils/BlockOptionalMeta.java
@@ -42,7 +42,6 @@ public final class BlockOptionalMeta {
    private final ImmutableSet<Integer> stateHashes;
    private final ImmutableSet<Integer> stackHashes;
    private static final Pattern pattern = Pattern.compile("^(.+?)(?::(\\d+))?$");
-    private static final Map<Object, Object> normalizations;

    public BlockOptionalMeta(@Nonnull Block block) {
        this.block = block;
@@ -72,142 +71,6 @@ public final class BlockOptionalMeta {
        stackHashes = getStackHashes(blockstates);
    }

-    static {
-        Map<Object, Object> _normalizations = new HashMap<>();
-        Consumer<Enum> put = instance -> _normalizations.put(instance.getClass(), instance);
-        put.accept(EnumFacing.NORTH);
-        put.accept(EnumFacing.Axis.Y);
-        put.accept(Half.BOTTOM);
-        put.accept(StairsShape.STRAIGHT);
-        put.accept(AttachFace.FLOOR);
-        put.accept(DoubleBlockHalf.UPPER);
-        put.accept(SlabType.BOTTOM);
-        put.accept(DoorHingeSide.LEFT);
-        put.accept(BedPart.HEAD);
-        put.accept(RailShape.NORTH_SOUTH);
-        _normalizations.put(BlockBanner.ROTATION, 0);
-        _normalizations.put(BlockBed.OCCUPIED, false);
-        _normalizations.put(BlockBrewingStand.HAS_BOTTLE[0], false);
-        _normalizations.put(BlockBrewingStand.HAS_BOTTLE[1], false);
-        _normalizations.put(BlockBrewingStand.HAS_BOTTLE[2], false);
-        _normalizations.put(BlockButton.POWERED, false);
-        // _normalizations.put(BlockCactus.AGE, 0);
-        // _normalizations.put(BlockCauldron.LEVEL, 0);
-        // _normalizations.put(BlockChorusFlower.AGE, 0);
-        _normalizations.put(BlockChorusPlant.NORTH, false);
-        _normalizations.put(BlockChorusPlant.EAST, false);
-        _normalizations.put(BlockChorusPlant.SOUTH, false);
-        _normalizations.put(BlockChorusPlant.WEST, false);
-        _normalizations.put(BlockChorusPlant.UP, false);
-        _normalizations.put(BlockChorusPlant.DOWN, false);
-        // _normalizations.put(BlockCocoa.AGE, 0);
-        // _normalizations.put(BlockCrops.AGE, 0);
-        _normalizations.put(BlockDirtSnowy.SNOWY, false);
-        _normalizations.put(BlockDoor.OPEN, false);
-        _normalizations.put(BlockDoor.POWERED, false);
-        // _normalizations.put(BlockFarmland.MOISTURE, 0);
-        _normalizations.put(BlockFence.NORTH, false);
-        _normalizations.put(BlockFence.EAST, false);
-        _normalizations.put(BlockFence.WEST, false);
-        _normalizations.put(BlockFence.SOUTH, false);
-        // _normalizations.put(BlockFenceGate.POWERED, false);
-        // _normalizations.put(BlockFenceGate.IN_WALL, false);
-        _normalizations.put(BlockFire.AGE, 0);
-        _normalizations.put(BlockFire.NORTH, false);
-        _normalizations.put(BlockFire.EAST, false);
-        _normalizations.put(BlockFire.SOUTH, false);
-        _normalizations.put(BlockFire.WEST, false);
-        _normalizations.put(BlockFire.UP, false);
-        // _normalizations.put(BlockFrostedIce.AGE, 0);
-        _normalizations.put(BlockGrass.SNOWY, false);
-        // _normalizations.put(BlockHopper.ENABLED, true);
-        // _normalizations.put(BlockLever.POWERED, false);
-        // _normalizations.put(BlockLiquid.LEVEL, 0);
-        // _normalizations.put(BlockMycelium.SNOWY, false);
-        // _normalizations.put(BlockNetherWart.AGE, false);
-        _normalizations.put(BlockLeaves.DISTANCE, false);
-        // _normalizations.put(BlockLeaves.DECAYABLE, false);
-        // _normalizations.put(BlockObserver.POWERED, false);
-        _normalizations.put(BlockPane.NORTH, false);
-        _normalizations.put(BlockPane.EAST, false);
-        _normalizations.put(BlockPane.WEST, false);
-        _normalizations.put(BlockPane.SOUTH, false);
-        // _normalizations.put(BlockPistonBase.EXTENDED, false);
-        // _normalizations.put(BlockPressurePlate.POWERED, false);
-        // _normalizations.put(BlockPressurePlateWeighted.POWER, false);
-        // _normalizations.put(BlockRailDetector.POWERED, false);
-        // _normalizations.put(BlockRailPowered.POWERED, false);
-        _normalizations.put(BlockRedstoneWire.NORTH, false);
-        _normalizations.put(BlockRedstoneWire.EAST, false);
-        _normalizations.put(BlockRedstoneWire.SOUTH, false);
-        _normalizations.put(BlockRedstoneWire.WEST, false);
-        // _normalizations.put(BlockReed.AGE, false);
-        _normalizations.put(BlockSapling.STAGE, 0);
-        _normalizations.put(BlockStandingSign.ROTATION, 0);
-        _normalizations.put(BlockStem.AGE, 0);
-        _normalizations.put(BlockTripWire.NORTH, false);
-        _normalizations.put(BlockTripWire.EAST, false);
-        _normalizations.put(BlockTripWire.WEST, false);
-        _normalizations.put(BlockTripWire.SOUTH, false);
-        _normalizations.put(BlockVine.NORTH, false);
-        _normalizations.put(BlockVine.EAST, false);
-        _normalizations.put(BlockVine.SOUTH, false);
-        _normalizations.put(BlockVine.WEST, false);
-        _normalizations.put(BlockVine.UP, false);
-        _normalizations.put(BlockWall.UP, false);
-        _normalizations.put(BlockWall.NORTH, false);
-        _normalizations.put(BlockWall.EAST, false);
-        _normalizations.put(BlockWall.WEST, false);
-        _normalizations.put(BlockWall.SOUTH, false);
-        normalizations = Collections.unmodifiableMap(_normalizations);
-    }
-
-    private 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) {
-        //noinspection unchecked
-        return (C) value;
-    }
-
-    public static IBlockState normalize(IBlockState state) {
-        IBlockState newState = state;
-
-        for (IProperty<?> property : state.getProperties()) {
-            Class<?> valueClass = property.getValueClass();
-            if (normalizations.containsKey(property)) {
-                try {
-                    newState = newState.with(
-                            castToIProperty(property),
-                            castToIPropertyValue(property, normalizations.get(property))
-                    );
-                } catch (IllegalArgumentException ignored) {}
-            } else if (normalizations.containsKey(state.get(property))) {
-                try {
-                    newState = newState.with(
-                            castToIProperty(property),
-                            castToIPropertyValue(property, normalizations.get(state.get(property)))
-                    );
-                } catch (IllegalArgumentException ignored) {}
-            } else if (normalizations.containsKey(valueClass)) {
-                try {
-                    newState = newState.with(
-                            castToIProperty(property),
-                            castToIPropertyValue(property, normalizations.get(valueClass))
-                    );
-                } catch (IllegalArgumentException ignored) {}
-            }
-        }
-
-        return newState;
-    }
-
-    public static int stateMeta(IBlockState state) {
-        return state.hashCode();
-    }
-
    private static Set<IBlockState> getStates(@Nonnull Block block) {
        return new HashSet<>(block.getStateContainer().getValidStates());
    }
--- a/src/api/java/baritone/api/utils/Helper.java
+++ b/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
--- a/src/api/java/baritone/api/utils/IPlayerContext.java
+++ b/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.
     *
--- a/src/api/java/baritone/api/utils/IPlayerController.java
+++ b/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;
    }
 }
--- a/src/api/java/baritone/api/utils/RayTraceUtils.java
+++ b/src/api/java/baritone/api/utils/RayTraceUtils.java
@@ -41,7 +41,16 @@ public final class RayTraceUtils {
     * @return The calculated raytrace result
     */
    public static RayTraceResult rayTraceTowards(Entity entity, Rotation rotation, double blockReachDistance) {
-        Vec3d start = entity.getEyePosition(1.0F);
+        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.getEyePosition(1.0F); // do whatever is correct
+        }
        Vec3d direction = RotationUtils.calcVec3dFromRotation(rotation);
        Vec3d end = start.add(
                direction.x * blockReachDistance,
@@ -50,4 +59,8 @@ public final class RayTraceUtils {
        );
        return entity.world.rayTraceBlocks(start, end, RayTraceFluidMode.NEVER, false, true);
    }
+
+    public static Vec3d inferSneakingEyePosition(Entity entity) {
+        return new Vec3d(entity.posX, entity.posY + IPlayerContext.eyeHeight(true), entity.posZ);
+    }
 }
--- a/src/api/java/baritone/api/utils/RotationUtils.java
+++ b/src/api/java/baritone/api/utils/RotationUtils.java
@@ -146,6 +146,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,
@@ -159,6 +163,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)) {
            /*
@@ -171,9 +179,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.type == 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;
@@ -188,7 +205,7 @@ public final class RotationUtils {
            double xDiff = shape.getStart(EnumFacing.Axis.X) * sideOffset.x + shape.getEnd(EnumFacing.Axis.X) * (1 - sideOffset.x);
            double yDiff = shape.getStart(EnumFacing.Axis.Y) * sideOffset.y + shape.getEnd(EnumFacing.Axis.Y) * (1 - sideOffset.y);
            double zDiff = shape.getStart(EnumFacing.Axis.Z) * sideOffset.z + shape.getEnd(EnumFacing.Axis.Z) * (1 - sideOffset.z);
-            possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance);
+            possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
            if (possibleRotation.isPresent()) {
                return possibleRotation;
            }
@@ -207,9 +224,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) {
-        Rotation rotation = calcRotationFromVec3d(entity.getEyePosition(1.0F), offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
-        RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance);
+    public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance, boolean wouldSneak) {
+        Vec3d eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(entity) : entity.getEyePosition(1.0F);
+        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.type == RayTraceResult.Type.BLOCK) {
            if (result.getBlockPos().equals(pos)) {
@@ -231,7 +249,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) {
-        return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance);
+    public static Optional<Rotation> reachableCenter(Entity entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+        return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance, wouldSneak);
    }
 }
--- a/src/launch/java/baritone/launch/mixins/MixinMinecraft.java
+++ b/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(
--- a/src/launch/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java
+++ b/src/launch/java/baritone/launch/mixins/MixinNetHandlerPlayClient.java
@@ -21,6 +21,7 @@ import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.event.events.ChunkEvent;
 import baritone.api.event.events.type.EventState;
+import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.network.NetHandlerPlayClient;
 import net.minecraft.network.play.server.SPacketChunkData;
 import net.minecraft.network.play.server.SPacketCombatEvent;
@@ -46,7 +47,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,
@@ -65,7 +67,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,
@@ -84,7 +87,8 @@ public class MixinNetHandlerPlayClient {
    )
    private void preChunkUnload(SPacketUnloadChunk packet, 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, ChunkEvent.Type.UNLOAD, packet.getX(), packet.getZ())
                );
@@ -98,7 +102,8 @@ public class MixinNetHandlerPlayClient {
    )
    private void postChunkUnload(SPacketUnloadChunk packet, 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, ChunkEvent.Type.UNLOAD, packet.getX(), packet.getZ())
                );
@@ -115,7 +120,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();
            }
        }
--- a/src/main/java/baritone/BaritoneProvider.java
+++ b/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.api.schematic.ISchematicSystem;
 import baritone.command.BaritoneChatControl;
 import baritone.cache.WorldScanner;
 import baritone.command.CommandSystem;
+import baritone.utils.schematic.SchematicSystem;

 import java.util.Collections;
 import java.util.List;
@@ -64,4 +66,9 @@ public final class BaritoneProvider implements IBaritoneProvider {
    public ICommandSystem getCommandSystem() {
        return CommandSystem.INSTANCE;
    }
+
+    @Override
+    public ISchematicSystem getSchematicSystem() {
+        return SchematicSystem.INSTANCE;
+    }
 }
--- a/src/main/java/baritone/behavior/PathingBehavior.java
+++ b/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());
        }
    }
--- a/src/main/java/baritone/cache/CachedWorld.java
+++ b/src/main/java/baritone/cache/CachedWorld.java
@@ -184,7 +184,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()));
            }
        }
--- a/src/main/java/baritone/cache/WorldScanner.java
+++ b/src/main/java/baritone/cache/WorldScanner.java
@@ -111,6 +111,41 @@ public enum WorldScanner implements IWorldScanner {
        return res;
    }

+    @Override
+    public int repack(IPlayerContext ctx) {
+        return this.repack(ctx, 40);
+    }
+
+    @Override
+    public int repack(IPlayerContext ctx, int range) {
+        IChunkProvider chunkProvider = ctx.world().getChunkProvider();
+        ICachedWorld cachedWorld = ctx.worldData().getCachedWorld();
+
+        BetterBlockPos playerPos = ctx.playerFeet();
+
+        int playerChunkX = playerPos.getX() >> 4;
+        int playerChunkZ = playerPos.getZ() >> 4;
+
+        int minX = playerChunkX - range;
+        int minZ = playerChunkZ - range;
+        int maxX = playerChunkX + range;
+        int maxZ = playerChunkZ + range;
+
+        int queued = 0;
+        for (int x = minX; x <= maxX; x++) {
+            for (int z = minZ; z <= maxZ; z++) {
+                Chunk chunk = chunkProvider.getChunk(x, z, false, false);
+
+                if (chunk != null && !chunk.isEmpty()) {
+                    queued++;
+                    cachedWorld.queueForPacking(chunk);
+                }
+            }
+        }
+
+        return queued;
+    }
+
    private boolean scanChunkInto(int chunkX, int chunkZ, Chunk chunk, BlockOptionalMetaLookup filter, Collection<BlockPos> result, int max, int yLevelThreshold, int playerY, int[] coordinateIterationOrder) {
        ChunkSection[] chunkInternalStorageArray = chunk.getSections();
        boolean foundWithinY = false;
@@ -147,26 +182,4 @@ public enum WorldScanner implements IWorldScanner {
        }
        return foundWithinY;
    }
-
-    public int repack(IPlayerContext ctx) {
-        IChunkProvider chunkProvider = ctx.world().getChunkProvider();
-        ICachedWorld cachedWorld = ctx.worldData().getCachedWorld();
-
-        BetterBlockPos playerPos = ctx.playerFeet();
-        int playerChunkX = playerPos.getX() >> 4;
-        int playerChunkZ = playerPos.getZ() >> 4;
-        int queued = 0;
-        for (int x = playerChunkX - 40; x <= playerChunkX + 40; x++) {
-            for (int z = playerChunkZ - 40; z <= playerChunkZ + 40; z++) {
-                Chunk chunk = chunkProvider.getChunk(x, z, false, false);
-
-                if (chunk != null && !chunk.isEmpty()) {
-                    queued++;
-                    cachedWorld.queueForPacking(chunk);
-                }
-            }
-        }
-
-        return queued;
-    }
 }
--- a/src/main/java/baritone/command/argument/ArgConsumer.java
+++ b/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());
+            throw new CommandInvalidTypeException(hasAny() ? peek() : consumed(), datatype.getClass().getSimpleName(), e);
        }
    }

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

--- a/src/main/java/baritone/command/defaults/BuildCommand.java
+++ b/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")) {
-            file = new File(file.getAbsolutePath() + ".schematic");
+        if (FilenameUtils.getExtension(file.getAbsolutePath()).isEmpty()) {
+            file = new File(file.getAbsolutePath() + "." + Baritone.settings().schematicFallbackExtension);
        }
        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));
    }
--- a/src/main/java/baritone/command/defaults/CancelCommand.java
+++ b/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"
-        );
-    }
-}
--- a/src/main/java/baritone/command/defaults/DefaultCommands.java
+++ b/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 SetCommand(baritone),
-            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 GoalCommand(baritone),
-            new GotoCommand(baritone),
-            new PathCommand(baritone),
-            new ProcCommand(baritone),
-            new VersionCommand(baritone),
-            new RepackCommand(baritone),
-            new BuildCommand(baritone),
-            new SchematicaCommand(baritone),
-            new ComeCommand(baritone),
-            new AxisCommand(baritone),
-            new CancelCommand(baritone),
-            new ForceCancelCommand(baritone),
-            new GcCommand(baritone),
-            new InvertCommand(baritone),
-            new TunnelCommand(baritone),
-            new RenderCommand(baritone),
-            new FarmCommand(baritone),
-            new ChestsCommand(baritone),
-            new FollowCommand(baritone),
-            new ExploreFilterCommand(baritone),
-            new ReloadAllCommand(baritone),
-            new SaveAllCommand(baritone),
-            new ExploreCommand(baritone),
-            new BlacklistCommand(baritone),
-            new FindCommand(baritone),
-            new MineCommand(baritone),
-            new ClickCommand(baritone),
-            new ThisWayCommand(baritone),
-            new WaypointsCommand(baritone),
-            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 SelCommand(baritone)
+                new HelpCommand(baritone),
+                new SetCommand(baritone),
+                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 GoalCommand(baritone),
+                new GotoCommand(baritone),
+                new PathCommand(baritone),
+                new ProcCommand(baritone),
+                new VersionCommand(baritone),
+                new RepackCommand(baritone),
+                new BuildCommand(baritone),
+                new SchematicaCommand(baritone),
+                new ComeCommand(baritone),
+                new AxisCommand(baritone),
+                new ForceCancelCommand(baritone),
+                new GcCommand(baritone),
+                new InvertCommand(baritone),
+                new TunnelCommand(baritone),
+                new RenderCommand(baritone),
+                new FarmCommand(baritone),
+                new ChestsCommand(baritone),
+                new FollowCommand(baritone),
+                new ExploreFilterCommand(baritone),
+                new ReloadAllCommand(baritone),
+                new SaveAllCommand(baritone),
+                new ExploreCommand(baritone),
+                new BlacklistCommand(baritone),
+                new FindCommand(baritone),
+                new MineCommand(baritone),
+                new ClickCommand(baritone),
+                new ThisWayCommand(baritone),
+                new WaypointsCommand(baritone),
+                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 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);
    }
 }
--- a/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
+++ b/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() {
@@ -169,5 +171,36 @@ public class PauseResumeCommands {
                );
            }
        };
+        cancelCommand = new Command(baritone, "cancel", "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"
+                );
+            }
+        };
    }
 }
--- a/src/main/java/baritone/command/defaults/GotoCommand.java
+++ b/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;
--- a/src/main/java/baritone/command/defaults/TunnelCommand.java
+++ b/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 baritone.api.command.exception.CommandException;
-import baritone.api.command.argument.IArgConsumer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;

 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);
-        Goal goal = new GoalStrictDirection(
-                ctx.playerFeet(),
-                ctx.player().getHorizontalFacing()
-        );
-        baritone.getCustomGoalProcess().setGoalAndPath(goal);
-        logDirect(String.format("Goal: %s", goal.toString()));
+        args.requireMax(3);
+        if (args.hasExactly(3)) {
+            boolean cont = true;
+            int height = Integer.parseInt(args.getArgs().get(0).getValue());
+            int width = Integer.parseInt(args.getArgs().get(1).getValue());
+            int depth = Integer.parseInt(args.getArgs().get(2).getValue());
+
+            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."
        );
    }
 }
--- a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java
+++ b/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();
    }
--- a/src/main/java/baritone/pathing/movement/Movement.java
+++ b/src/main/java/baritone/pathing/movement/Movement.java
@@ -176,7 +176,7 @@ public abstract class Movement implements IMovement, MovementHelper {
                //i'm doing it anyway
                //i dont care if theres snow in the way!!!!!!!
                //you dont own me!!!!
-                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getEyePosition(1.0F),
+                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.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
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -42,6 +42,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.IBlockReader;

 import java.util.Optional;

@@ -95,7 +96,7 @@ public interface MovementHelper extends ActionCosts, Helper {
        if (block instanceof BlockAir) { // early return for most common case
            return true;
        }
-        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.COBWEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockAbstractSkull || block == Blocks.BUBBLE_COLUMN || block instanceof BlockShulkerBox || block instanceof BlockSlab || block instanceof BlockTrapDoor) {
+        if (block == Blocks.FIRE || block == Blocks.TRIPWIRE || block == Blocks.COBWEB || block == Blocks.END_PORTAL || block == Blocks.COCOA || block instanceof BlockAbstractSkull || block == Blocks.BUBBLE_COLUMN || block instanceof BlockShulkerBox || block instanceof BlockSlab || block instanceof BlockTrapDoor || block == Blocks.END_ROD) {
            return false;
        }
        if (Baritone.settings().blocksToAvoid.value.contains(block)) {
@@ -143,7 +144,7 @@ public interface MovementHelper extends ActionCosts, Helper {
        // every block that overrides isPassable with anything more complicated than a "return true;" or "return false;"
        // has already been accounted for above
        // therefore it's safe to not construct a blockpos from our x, y, z ints and instead just pass null
-        return state.allowsMovement(null, BlockPos.ORIGIN, PathType.LAND); // workaround for future compatibility =P
+        return state.allowsMovement(bsi.access, BlockPos.ORIGIN, PathType.LAND); // workaround for future compatibility =P
    }

    /**
@@ -157,10 +158,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(IBlockReader access, BlockPos pos, IBlockState state) {
        Block block = state.getBlock();
        if (block instanceof BlockAir) { // early return for most common case
            return true;
@@ -183,7 +192,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 state.allowsMovement(null, null, PathType.LAND);
+        return state.allowsMovement(access, pos, PathType.LAND);
    }

    static boolean isReplaceable(int x, int y, int z, IBlockState state, BlockStateInterface bsi) {
@@ -305,7 +314,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(state)) {
@@ -509,9 +518,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));
@@ -528,8 +537,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());
-                RayTraceResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance());
+                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(), wouldSneak);
                if (res != null && res.type == RayTraceResult.Type.BLOCK && res.getBlockPos().equals(against1) && res.getBlockPos().offset(res.sideHit).equals(placeAt)) {
                    state.setTarget(new MovementState.MovementTarget(place, true));
                    found = true;
@@ -547,11 +556,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;
        }
--- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java
+++ b/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);
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/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.getEyePosition(1.0F),
+                    new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                            new Vec3d(destX, dest.getY(), destZ),
                            new Rotation(player.rotationYaw, player.rotationPitch)).getYaw(), player.rotationPitch),
                    false
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -115,7 +115,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;
@@ -251,7 +251,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);
                }
--- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
+++ b/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().getEyePosition(1.0F),
+        Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                VecUtils.getBlockPosCenter(positionToPlace),
                new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));
        if (!ladder) {
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -283,7 +283,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);
            }
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -465,7 +465,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;
                }
            }
@@ -490,7 +490,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
@@ -523,7 +523,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;
                }
            }
--- a/src/main/java/baritone/process/BackfillProcess.java
+++ b/src/main/java/baritone/process/BackfillProcess.java
@@ -74,7 +74,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:
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -25,8 +25,14 @@ 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;
@@ -34,9 +40,8 @@ import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
 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;
@@ -47,8 +52,6 @@ import net.minecraft.item.BlockItemUseContext;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUseContext;
-import net.minecraft.nbt.CompressedStreamTools;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.*;
@@ -56,7 +59,6 @@ import net.minecraft.util.math.shapes.VoxelShape;

 import java.io.File;
 import java.io.FileInputStream;
-import java.io.IOException;
 import java.util.*;

 import static baritone.api.pathing.movement.ActionCosts.COST_INF;
@@ -72,6 +74,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) {
@@ -98,6 +101,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
        this.origin = new Vec3i(x, y, z);
        this.paused = false;
        this.layer = 0;
+        this.numRepeats = 0;
        this.observedCompleted = new LongOpenHashSet();
    }

@@ -116,27 +120,38 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil

    @Override
    public boolean build(String name, File schematic, Vec3i origin) {
-        NBTTagCompound tag;
-        try (FileInputStream fileIn = new FileInputStream(schematic)) {
-            tag = CompressedStreamTools.readCompressed(fileIn);
-        } catch (IOException e) {
+        Optional<ISchematicFormat> format = SchematicSystem.INSTANCE.getByFile(schematic);
+        if (!format.isPresent()) {
+            return false;
+        }
+
+        ISchematic parsed;
+        try {
+            parsed = format.get().parse(new FileInputStream(schematic));
+        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
-        //noinspection ConstantConditions
-        if (tag == null) {
-            return false;
+
+        if (Baritone.settings().mapArtMode.value) {
+            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().getA().toString(), schematic.get().getA(), schematic.get().getB());
+                IStaticSchematic s = schematic.get().getA();
+                this.build(
+                        schematic.get().getA().toString(),
+                        Baritone.settings().mapArtMode.value ? new MapArtSchematic(s) : s,
+                        schematic.get().getB()
+                );
            } else {
                logDirect("No schematic currently open");
            }
@@ -158,10 +173,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;
@@ -198,7 +209,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
                        continue; // irrelevant
                    }
                    IBlockState curr = bcc.bsi.get0(x, y, z);
-                    if (!(curr.getBlock() instanceof BlockAir) && !(curr.getBlock() == Blocks.WATER || curr.getBlock() == Blocks.LAVA) && !valid(curr, desired)) {
+                    if (!(curr.getBlock() instanceof BlockAir) && !(curr.getBlock() == Blocks.WATER || curr.getBlock() == Blocks.LAVA) && !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()) {
@@ -239,7 +250,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() instanceof BlockAir) {
                            continue;
                        }
@@ -278,8 +289,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());
-                RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), rot, ctx.playerController().getBlockReachDistance());
+                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(), true);
                if (result != null && result.type == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(placeAgainstPos) && result.sideHit == against.getOpposite()) {
                    OptionalInt hotbar = hasAnyItemThatWouldPlace(toPlace, result, rot);
                    if (hotbar.isPresent()) {
@@ -320,7 +331,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            if (!meme.canPlace()) {
                continue;
            }
-            if (valid(wouldBePlaced, desired)) {
+            if (valid(wouldBePlaced, desired, true)) {
                return OptionalInt.of(i);
            }
        }
@@ -408,7 +419,9 @@ 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");
                onLostControl();
                return null;
@@ -461,7 +474,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;
                    }
@@ -472,7 +485,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;
                    }
@@ -528,7 +541,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 {
@@ -555,7 +568,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));
@@ -748,6 +761,7 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
        schematic = null;
        realSchematic = null;
        layer = 0;
+        numRepeats = 0;
        paused = false;
        observedCompleted = null;
    }
@@ -772,7 +786,7 @@ 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) {
        if (desired == null) {
            return true;
        }
@@ -783,6 +797,12 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
            return true;
        }
        // TODO more complicated comparison logic I guess
+        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);
    }

@@ -862,7 +882,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
--- a/src/main/java/baritone/process/FarmProcess.java
+++ b/src/main/java/baritone/process/FarmProcess.java
@@ -230,7 +230,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.type == RayTraceResult.Type.BLOCK && result.sideHit == EnumFacing.UP) {
--- a/src/main/java/baritone/utils/BaritoneAutoTest.java
+++ b/src/main/java/baritone/utils/BaritoneAutoTest.java
@@ -28,13 +28,9 @@ import net.minecraft.client.GameSettings;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.tutorial.TutorialSteps;
-import net.minecraft.server.integrated.IntegratedServer;
 import net.minecraft.util.HttpUtil;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.GameType;
-import net.minecraft.world.WorldSettings;
-import net.minecraft.world.WorldType;
-import net.minecraft.world.dimension.DimensionType;
+import net.minecraft.world.*;

 import java.io.File;
 import java.io.IOException;
@@ -92,17 +88,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);
        }

-        IntegratedServer server = mc.getIntegratedServer();
+        // If the integrated server is running, set the difficulty to peaceful
+        if (mc.getIntegratedServer() != null) {
+            mc.getIntegratedServer().setDifficultyForAllWorlds(EnumDifficulty.PEACEFUL);

-        // If the integrated server is launched and the world has initialized, set the spawn point
-        // to our defined starting position
-        if (server != null && server.getWorld(DimensionType.OVERWORLD) != null) {
-            server.getWorld(DimensionType.OVERWORLD).setSpawnPoint(STARTING_POSITION);
-            server.getWorld(DimensionType.OVERWORLD).getGameRules().setOrCreateGameRule("spawnRadius", "0", server);
+            for (final WorldServer world : mc.getIntegratedServer().getWorlds()) {
+                // 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", mc.getIntegratedServer());
+                }
+            }
        }

        if (event.getType() == TickEvent.Type.IN) { // If we're in-game
@@ -110,7 +110,7 @@ public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
            // Force the integrated server to share the world to LAN so that
            // the ingame pause menu gui doesn't actually pause our game
            if (mc.isSingleplayer() && !mc.getIntegratedServer().getPublic()) {
-                mc.getIntegratedServer().shareToLAN(GameType.getByName("survival"), false, HttpUtil.getSuitableLanPort());
+                mc.getIntegratedServer().shareToLAN(GameType.SURVIVAL, false, HttpUtil.getSuitableLanPort());
            }

            // For the first 200 ticks, wait for the world to generate
--- a/src/main/java/baritone/utils/BlockStateInterface.java
+++ b/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.IBlockReader;
 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 IBlockReader world;
+    public final BlockPos.MutableBlockPos isPassableBlockPos;
+    public final IBlockReader 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.getInstance().isCallingFromMinecraftThread()) {
            throw new IllegalStateException();
        }
+        this.isPassableBlockPos = new BlockPos.MutableBlockPos();
+        this.access = new BlockStateInterfaceAccessWrapper(this);
    }

    public boolean worldContainsLoadedChunk(int blockX, int blockZ) {
--- a/src/main/java/baritone/utils/BlockStateInterfaceAccessWrapper.java
+++ b/src/main/java/baritone/utils/BlockStateInterfaceAccessWrapper.java
@@ -0,0 +1,57 @@
+/*
+ * 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.state.IBlockState;
+import net.minecraft.fluid.IFluidState;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockReader;
+
+import javax.annotation.Nullable;
+
+/**
+ * @author Brady
+ * @since 11/5/2019
+ */
+@SuppressWarnings("NullableProblems")
+public final class BlockStateInterfaceAccessWrapper implements IBlockReader {
+
+    private final BlockStateInterface bsi;
+
+    BlockStateInterfaceAccessWrapper(BlockStateInterface bsi) {
+        this.bsi = bsi;
+    }
+
+    @Nullable
+    @Override
+    public TileEntity getTileEntity(BlockPos pos) {
+        return null;
+    }
+
+    @Override
+    public IBlockState getBlockState(BlockPos pos) {
+        // BlockStateInterface#get0(BlockPos) btfo!
+        return this.bsi.get0(pos.getX(), pos.getY(), pos.getZ());
+    }
+
+    @Override
+    public IFluidState getFluidState(BlockPos blockPos) {
+        return getBlockState(blockPos).getFluidState();
+    }
+}
--- a/src/main/java/baritone/utils/InputOverrideHandler.java
+++ b/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();
    }
--- a/src/main/java/baritone/utils/NotificationHelper.java
+++ b/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();
+        }
+    }
+}
--- a/src/main/java/baritone/utils/schematic/MapArtSchematic.java
+++ 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++) {
-            for (int z = 0; z < lengthZ; z++) {
-                IBlockState[] column = states[x][z];
+    @Override
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        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()) {
                    heightMap[x][z] = lowestBlockY.getAsInt();
@@ -43,9 +53,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) {
@@ -56,10 +66,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];
-    }
 }
--- a/src/main/java/baritone/utils/schematic/SchematicSystem.java
+++ b/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();
+    }
+}
--- a/src/main/java/baritone/utils/schematic/StaticSchematic.java
+++ b/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;
-    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;
-    }
+    protected IBlockState[][][] states;

    @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() {
-        return widthX;
+    public IBlockState getDirect(int x, int y, int z) {
+        return this.states[x][z][y];
    }

    @Override
-    public int heightY() {
-        return heightY;
-    }
-
-    @Override
-    public int lengthZ() {
-        return lengthZ;
+    public IBlockState[] getColumn(int x, int z) {
+        return this.states[x][z];
    }
 }
--- a/src/main/java/baritone/utils/schematic/format/DefaultSchematicFormats.java
+++ b/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.getInt("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()));
+    }
+}
--- a/src/main/java/baritone/utils/schematic/format/defaults/MCEditSchematic.java
+++ b/src/main/java/baritone/utils/schematic/format/defaults/MCEditSchematic.java
@@ -15,34 +15,35 @@
 * 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 net.minecraft.util.ResourceLocation;
+import net.minecraft.util.datafix.fixes.ItemIntIDToString;
+import net.minecraft.util.registry.IRegistry;

-import java.util.List;
+/**
+ * @author Brady
+ * @since 12/27/2019
+ */
+public final class MCEditSchematic extends StaticSchematic {

-public class Schematic implements ISchematic {
-
-    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");
+    public MCEditSchematic(NBTTagCompound schematic) {
+        String type = schematic.getString("Materials");
        if (!type.equals("Alpha")) {
            throw new IllegalStateException("bad schematic " + type);
        }
-        widthX = schematic.getInteger("Width");
-        heightY = schematic.getInteger("Height");
-        lengthZ = schematic.getInteger("Length");
+        this.x = schematic.getInt("Width");
+        this.y = schematic.getInt("Height");
+        this.z = schematic.getInt("Length");
        byte[] blocks = schematic.getByteArray("Blocks");
-        byte[] metadata = schematic.getByteArray("Data");
+//        byte[] metadata = schematic.getByteArray("Data");

        byte[] additional = null;
-        if (schematic.hasKey("AddBlocks")) {
+        if (schematic.contains("AddBlocks")) {
            byte[] addBlocks = schematic.getByteArray("AddBlocks");
            additional = new byte[addBlocks.length * 2];
            for (int i = 0; i < addBlocks.length; i++) {
@@ -50,43 +51,23 @@ public class Schematic implements ISchematic {
                additional[i * 2 + 1] = (byte) ((addBlocks[i] >> 0) & 0xF); // upper nibble
            }
        }
-        states = new IBlockState[widthX][lengthZ][heightY];
-        for (int y = 0; y < heightY; y++) {
-            for (int z = 0; z < lengthZ; z++) {
-                for (int x = 0; x < widthX; x++) {
-                    int blockInd = (y * lengthZ + z) * widthX + x;
+        this.states = new IBlockState[this.x][this.z][this.y];
+        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 blockInd = (y * this.z + z) * this.x + x;

                    int blockID = blocks[blockInd] & 0xFF;
                    if (additional != null) {
                        // additional is 0 through 15 inclusive since it's & 0xF above
                        blockID |= additional[blockInd] << 8;
                    }
-                    Block block = Block.REGISTRY.getObjectById(blockID);
-                    int meta = metadata[blockInd] & 0xFF;
-                    states[x][z][y] = block.getStateFromMeta(meta);
+                    Block block = IRegistry.BLOCK.get(ResourceLocation.tryCreate(ItemIntIDToString.getItem(blockID)));
+//                    int meta = metadata[blockInd] & 0xFF;
+//                    this.states[x][z][y] = block.getStateFromMeta(meta);
+                    this.states[x][z][y] = block.getDefaultState();
                }
            }
-        }*/
-        throw new UnsupportedOperationException("1.13 be like: numeric IDs btfo");
-    }
-
-    @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;
+        }
    }
 }
--- a/src/main/java/baritone/utils/schematic/format/defaults/SpongeSchematic.java
+++ b/src/main/java/baritone/utils/schematic/format/defaults/SpongeSchematic.java
@@ -0,0 +1,158 @@
+/*
+ * 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.state.IBlockState;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.state.IProperty;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+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.getInt("Width");
+        this.y = nbt.getInt("Height");
+        this.z = nbt.getInt("Length");
+        this.states = new IBlockState[this.x][this.z][this.y];
+
+        Int2ObjectArrayMap<IBlockState> palette = new Int2ObjectArrayMap<>();
+        NBTTagCompound paletteTag = nbt.getCompound("Palette");
+        for (String tag : paletteTag.keySet()) {
+            int index = paletteTag.getInt(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 = IRegistry.BLOCK.get(this.resourceLocation);
+                this.blockState = block.getDefaultState();
+
+                this.properties.keySet().stream().sorted(String::compareTo).forEachOrdered(key -> {
+                    IProperty<?> property = block.getStateContainer().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);
+            if (parsed.isPresent()) {
+                return state.with(property, parsed.get());
+            } else {
+                throw new IllegalArgumentException("Invalid value for property " + property);
+            }
+        }
+    }
+}
--- a/src/main/java/baritone/utils/schematic/schematica/SchematicAdapter.java
+++ b/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
--- a/src/main/java/baritone/utils/schematic/schematica/SchematicaHelper.java
+++ b/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));
    }
--- a/src/main/java/baritone/utils/type/VarInt.java
+++ b/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);
+    }
+}
Author	SHA1	Message	Date
Leijurv	2a830b6b68	v1.3.8	2020-04-21 12:05:09 -07:00
Leijurv	fc620f8ba8	Merge branch 'master' into 1.13.2	2020-04-21 12:04:44 -07:00
Leijurv	33d4dd47bb	v1.2.14	2020-04-21 12:02:07 -07:00
Leijurv	ec92ab8b39	Update README.md	2020-04-18 22:07:18 -07:00
Leijurv	580ba60762	Merge pull request #1344 from dominikaaaa/fix/setupmd Change 1.14 to 1.15 in SETUP.md	2020-04-09 14:02:28 -07:00
Dominika	0e7bf25de7	fix setup.md as per leij's recommendations	2020-04-09 17:01:26 -04:00
Leijurv	e7658b75ef	Merge branch 'master' into 1.13.2	2020-04-07 23:45:42 -07:00
Leijurv	e218ced2c7	i hate myself	2020-03-30 22:23:43 -07:00
Leijurv	3cc4c0ea98	Revert "Update README.md" This reverts commit `ac2a88d186`.	2020-03-25 21:52:42 -07:00
Leijurv	ac2a88d186	Update README.md	2020-03-25 21:50:12 -07:00
Leijurv	b9a7efc25b	v1.3.7	2020-03-25 17:26:18 -07:00
Leijurv	3b7f13babd	Merge branch 'master' into 1.13.2	2020-03-25 17:25:25 -07:00
Leijurv	dff92beea1	v1.2.13	2020-03-25 17:17:10 -07:00
Leijurv	62b808ad48	nickhasbugs	2020-03-18 19:15:47 -07:00
Leijurv	520142427d	Merge branch 'master' into 1.13.2	2020-03-14 12:25:22 -07:00
Leijurv	69e871eaad	we can copy from this image sure	2020-03-14 12:19:39 -07:00
Leijurv	d759c676f7	disable broken code	2020-03-14 12:13:45 -07:00
Leijurv	12481cc491	v1.2.12	2020-03-14 12:09:35 -07:00
Leijurv	43f11aaf0c	finally update usage to furry code	2020-03-14 12:09:19 -07:00
Leijurv	f4842aa512	fix actual underlying sneak issue	2020-03-14 11:51:26 -07:00
Leijurv	bcd3fd3266	Merge pull request #1401 from S-B99/patch-1 Add modified settings to bug template	2020-03-14 10:59:39 -07:00
Bella Who	67256c17cf	Add modified settings to bug template	2020-03-14 12:10:26 -04:00
Bella Who	d6106a44f7	Remove dropbox link as 1.15.2 is now officially released	2020-03-13 09:00:17 -04:00
Brady	ebe3f457c6	Fix additional injection points in 1.13.2	2020-03-07 20:27:29 -06:00
Brady	6289e540b8	Merge branch 'master' into 1.13.2	2020-03-07 20:23:09 -06:00
Brady	eda1820773	Fix Cubecraft Crash (Affects 1.13.2+)	2020-03-07 20:17:53 -06:00
Brady	c8856cfea4	Fix #1250	2020-03-07 17:34:27 -06:00
Leijurv	217e0da4a6	Merge pull request #1340 from fw4hre0xxq/issue-1339-trapchest-pathing fix #1339	2020-03-02 12:50:35 -08:00
Brady	96a8bb90c9	Fix tunnel usage in USAGE.md	2020-03-02 13:41:21 -06:00
Brady	0ca3c496de	Fix tunnel command usage	2020-03-02 13:40:43 -06:00
Bella	5f49bedc42	Change 1.14 to 1.15 in SETUP.md	2020-02-28 17:26:59 -05:00
Leijurv	d9fc825b0f	Merge pull request #1336 from S-B99/patch-1 Update USAGE.md as per #1332	2020-02-27 18:07:16 -08:00
Leijurv	17c691b1cf	the whole point is its better to do something nonsensical than to crash, so lets continue in that direction	2020-02-27 18:06:11 -08:00
Leijurv	9fb46946b5	fix sprint while paused bug, fixes #1331	2020-02-27 18:05:48 -08:00
fw4hre0xxq	220fa79057	fix #1339	2020-02-27 17:14:41 -08:00
Bella Who	f1f4adf8a6	Update USAGE.md as per #1332	2020-02-27 17:42:12 -05:00
Leijurv	448dd979a2	Merge pull request #1332 from aUniqueUser/master #740 (Custom tunneling) Updated for new command system	2020-02-27 14:29:18 -08:00
Leijurv	3386947522	Merge pull request #1020 from Xephorix/patch-1 Update USAGE.md	2020-02-27 09:25:25 -08:00
aUniqueUser	628ec0f2b5	updated longDesc	2020-02-26 13:04:10 -05:00
aUniqueUser	e3b91c884a	More logical argument order	2020-02-26 12:30:07 -05:00
aUniqueUser	10bb935a42	Merge pull request #1 from CDAGaming/CDAGaming-patch-1 [Change] Adjustments	2020-02-26 11:14:45 -05:00
CDAGaming	6f136a90a2	[Change] Adjustments	2020-02-26 07:55:21 -06:00
aUniqueUser	acd9bcceeb	Codacy	2020-02-25 21:47:35 -05:00
aUniqueUser	3c2838df9e	lol	2020-02-25 21:22:35 -05:00
aUniqueUser	4b526f7242	Custom Tunneling	2020-02-25 21:13:20 -05:00
Leijurv	399037b866	Merge branch 'master' into 1.13.2	2020-02-24 19:28:05 -08:00
Leijurv	61563c9359	builderprocess should use hypothetical sneaking	2020-02-24 19:27:11 -08:00
Leijurv	50783e65a9	Merge branch 'master' into 1.13.2	2020-02-24 18:39:36 -08:00
Leijurv	e854bf59f8	fix sneaking based issues	2020-02-24 18:31:42 -08:00
Leijurv	393a3a87b6	Update USAGE.md	2020-02-24 12:20:13 -08:00
Brady	888b2723e0	Fix critical prefix tag bug	2020-02-23 21:13:51 -06:00
Leijurv	6ed03d0858	Merge pull request #1328 from babbaj/baritoe toe	2020-02-23 18:55:22 -08:00
Babbaj	ee33666b38	3 days	2020-02-23 21:54:18 -05:00
Babbaj	07c406aa16	baritoe	2020-02-23 21:48:15 -05:00
Brady	c578d5c1a3	Fix additional TrayIcon creation and support Mac notifs	2020-02-23 12:51:14 -06:00
Leijurv	2ea66ea8fc	Merge pull request #1324 from aUniqueUser/master Desktop Notification System	2020-02-23 10:05:30 -08:00
Leijurv	27440fc147	Update README.md	2020-02-22 22:42:22 -08:00
Leijurv	b1f5429db9	Update README.md	2020-02-22 18:37:29 -08:00
Leijurv	042b1ed6d7	Update README.md	2020-02-22 18:37:10 -08:00
aUniqueUser	a8645afbdb	Revert "mfw" This reverts commit `25b85f17a3`.	2020-02-22 21:09:36 -05:00
aUniqueUser	25b85f17a3	mfw	2020-02-22 20:41:06 -05:00
aUniqueUser	cf691118b9	comment fixed	2020-02-22 20:19:25 -05:00
aUniqueUser	0dcb9d4b69	Formatting	2020-02-22 20:12:43 -05:00
aUniqueUser	2d2571cff5	Desktop Notification System	2020-02-22 18:31:41 -05:00
Leijurv	ec8d5c0f4d	Merge pull request #1314 from babbaj/proguard-patch Remove string parsing functions from -assumenosideeffects	2020-02-20 17:35:21 -08:00
Babbaj	85d63c9d7f	Exceptions are side effects	2020-02-20 20:29:36 -05:00
Leijurv	19f70f5a79	Merge pull request #1306 from S-B99/patch-1 Make setup instructions more clear	2020-02-17 14:43:05 -08:00
Bella Who	80955cad8b	Make setup instructions more clear	2020-02-17 17:42:05 -05:00
Leijurv	01ba712d33	Update README.md	2020-02-14 13:49:53 -08:00
Leijurv	e0985d3b68	Update README.md	2020-02-14 13:49:15 -08:00
Leijurv	7181d2c91a	Merge pull request #1287 from S-B99/master Add Linux support to issue templates	2020-02-09 17:15:52 -08:00
Bella Who	e66d8616ce	fixed space	2020-02-09 19:28:19 -05:00
Bella Who	656dd91004	Update bug.md	2020-02-09 19:12:40 -05:00
Leijurv	d88b3a7799	Merge pull request #1286 from S-B99/master Make how to use checkboxes more clear in issue templates	2020-02-09 14:54:35 -08:00
Bella Who	7cdbc4acca	Update suggestion.md	2020-02-09 17:45:28 -05:00
Bella Who	de68e6630e	Update question.md	2020-02-09 17:45:09 -05:00
Bella Who	de89da20b2	Update bug.md	2020-02-09 17:44:50 -05:00
Leijurv	17a06621f5	rootnet shill	2020-02-01 16:42:14 -08:00
Leijurv	b3de840e04	no reason for this now that impact is 1.14.4 for all	2020-01-26 12:41:15 -08:00
Leijurv	539b8ef973	fix oversight in coordinate censorship	2020-01-25 22:35:01 -08:00
Brady	f7041022d0	Merge branch 'master' into 1.13.2	2020-01-10 20:13:57 -06:00
Brady	710170ef2d	Fix RelativeGoalXZ coordinate mix-up Basically for many months now RelativeGoalXZ produced (~X, ~Y), not (~X, ~Z).	2020-01-10 20:10:16 -06:00
Leijurv	dd76d2eabc	v1.3.6	2020-01-04 21:58:21 -08:00
Leijurv	fb22cf05eb	v1.2.11	2020-01-04 21:57:16 -08:00
Brady	e3d3407de5	Remove normalizations from BlockOptionalMeta	2019-12-31 19:44:44 -06:00
Brady	f3d860e8fa	Merge branch 'master' into 1.13.2	2019-12-31 19:40:14 -06:00
Brady	adff391e45	Merge branch 'schematic-formats'	2019-12-31 18:25:21 -06:00
Brady	4a05837b01	Requested changes	2019-12-31 17:44:20 -06:00
Leijurv	1edd7126fd	Merge branch 'master' into 1.13.2	2019-12-31 15:44:03 -08:00
Leijurv	a0014fda12	Merge pull request #1216 from FTC55/master Fixed a rather obnoxious bug that would require a full restart of the client.	2019-12-31 15:35:01 -08:00
FTC55	04190af340	...more than I thought. Autoreformatted file x2	2019-12-31 19:45:08 +01:00
FTC55	4b10904b97	Git missed some changes. Autoreformatted files.	2019-12-31 19:43:54 +01:00
FTC55	bbb25acff3	Fixed the bug, merged CancelCommand into ExecutionControlCommands	2019-12-31 19:31:30 +01:00
Brady	fcfa022232	Clean up BlockOptionalMeta comment and add behavioral clarification	2019-12-30 02:27:20 -06:00
Brady	220ee30d35	Appease Codacy	2019-12-27 21:28:05 -06:00
Brady	812bc0d8c4	Remove redundant parser layer	2019-12-27 01:14:31 -06:00
Brady	d712839c25	Make Schematica respect mapArtMode setting	2019-12-25 01:35:10 -06:00
Brady	eee705b371	Schematic Format API support	2019-12-24 17:20:00 -06:00
Brady	77bdf6e444	Fix MapSchematic	2019-12-23 18:05:50 -06:00
Brady	0a858c040c	Working	2019-12-19 22:15:14 -06:00
Brady	eea5b69b6c	Utilize new FillSchematic	2019-12-19 12:03:02 -06:00
Brady	6759917a2f	Additional clean up	2019-12-19 11:58:47 -06:00
Brady	aa3bd80ab2	Clean ups	2019-12-19 11:40:38 -06:00
Brady	ea8d7fb3b9	Improve file extension fallback mechanism	2019-12-18 15:19:58 -06:00
Brady	b4ddf38116	Check if state is null	2019-12-18 10:27:34 -06:00
Brady	5c9f028103	Initial sponge support	2019-12-18 10:24:43 -06:00
Leijurv	937d4cc884	whoops	2019-12-13 20:46:12 -08:00
Leijurv	2c3e1f4232	builder stuff, fixes #1059	2019-12-13 20:09:04 -08:00
Leijurv	ddc681fe77	build repeat count	2019-11-24 11:11:28 -08:00
Leijurv	2b71b31cfa	Merge pull request #1087 from cabaletta/ispassable-crash-fix Fix isPassable crash	2019-11-10 22:52:29 -08:00
Leijurv	ed144e995b	apparently this usage of > was an invalid javadoc command lol	2019-11-10 14:04:27 -08:00
Brady	7e3a2d3c0a	Create a BlockStateInterface specialized IBlockAccess wrapper	2019-11-05 18:17:10 -06:00
Leijurv	152285043d	Update USAGE.md	2019-11-05 11:50:27 -08:00
Leijurv	ce52201e45	Merge pull request #1097 from greg904/fix-goto-errmsg Remove error message when running goto with less than 3 args	2019-10-29 21:33:27 -07:00
Leijurv	45ea776090	Update README.md	2019-10-28 10:47:20 -07:00
Leijurv	2ae16d8bb1	configurable block reach distance	2019-10-26 16:01:08 -07:00
Greg Depoire--Ferrer	23fc6c8b49	Add a space between sentences in error message	2019-10-25 14:49:57 +02:00
Greg Depoire--Ferrer	0db4b193e1	Remove hack, add comment, don't use default when arg is required	2019-10-25 14:49:08 +02:00
Greg Depoire--Ferrer	82d520d808	Don't print invalid type error to stderr	2019-10-25 14:42:36 +02:00
Brady	5201d39adf	Retain old method signature	2019-10-24 15:20:23 -05:00
Brady	f02c33d95a	Fix improper tick count incrementation	2019-10-23 17:47:20 -05:00
Brady	43ab4f7d3b	Fix isPassable crash	2019-10-22 15:58:10 -05:00
Leijurv	a57668bd15	Merge pull request #1073 from 0-x-2-2/1.13.2 Merged master into 1.13.2 branch. 😎	2019-10-17 13:54:06 -07:00
0x22	a324b58f55	Merged master into 1.13.2 branch. 😎	2019-10-17 16:01:35 -04:00
Leijurv	6341f9fcb4	Merge pull request #1072 from 0-x-2-2/disable-autotest-mob-spawning Disable harmful mob spawning in Travis auto test.	2019-10-17 12:05:24 -07:00
0x22	66ffd1e0d9	Disable harmful mob spawning in Travis auto test.	2019-10-17 14:35:28 -04:00
Leijurv	e65c854e6a	Update USAGE.md	2019-10-15 11:25:35 -07:00
Brady	4eca960a4c	Specify range in IWorldScanner#repack	2019-10-14 15:45:41 -05:00
Leijurv	69bceb43f8	Update USAGE.md	2019-10-12 13:07:12 -07:00
Leijurv	6a8807b0fa	documentation stuff	2019-10-12 10:43:01 -07:00
Leijurv	e49549117b	v1.2.10	2019-10-11 17:08:28 -07:00
Xennex	bd345ae041	Update USAGE.md added a few commands to the list of "fun / interesting / important ones that you might want to look at"	2019-10-07 09:50:10 -06:00