v1.3.5

#1015 Feature/1015/goal revamps

.gitignore

@@ -16,6 +16,8 @@ classes/
 # IntelliJ Files
 .idea/
 *.iml
+*.ipr
+*.iws
 /logs/
 
 # Copyright Files

CODE_OF_CONDUCT.md

@@ -14,10 +14,10 @@ appearance, race, religion, or sexual identity and orientation.
 Examples of behavior that contributes to creating a positive environment
 include:
 
-* No Anime
+* No Anime (including uwu's or owo's)
 * Using welcoming and inclusive language
 * Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
+* Giving and gracefully accepting constructive criticism
 * Focusing on what is best for the community
 * Showing empathy towards other community members
 
@@ -29,7 +29,7 @@ Examples of unacceptable behavior by participants include:
 * ~~Trolling, insulting/derogatory comments, and personal or political attacks~~
 * Public or private harassment
 * Publishing others' private information, such as a physical or electronic
- address, without explicit permission
+ address, without explicit permission or consent
 * Other conduct which could reasonably be considered inappropriate in a
  professional setting
 

README.md

@@ -19,8 +19,9 @@
 ![Lines of Code](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
 [![GitHub contributors](https://img.shields.io/github/contributors/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/graphs/contributors/)
 [![GitHub commits](https://img.shields.io/github/commits-since/cabaletta/baritone/v1.0.0.svg)](https://github.com/cabaletta/baritone/commit/)
-[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.6%20/%20v1.3.2-brightgreen.svg)](https://impactdevelopment.github.io/)
+[![Impact integration](https://img.shields.io/badge/Impact%20integration-v1.2.8%20/%20v1.3.4%20/%20v1.4.1-brightgreen.svg)](https://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)
 [![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/)
@@ -28,16 +29,16 @@
 
 A Minecraft pathfinder bot. 
 
-Baritone is the pathfinding system used in [Impact](https://impactdevelopment.github.io/) since 4.4. There's a [showcase video](https://www.youtube.com/watch?v=yI8hgW_m6dQ) made by @Adovin#3153 on Baritone's integration into Impact. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a video I made showing off what it can do.
+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.
 
-The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the forge jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+The easiest way to install Baritone is to install [Impact](https://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).
+For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1). Or [with optifine](https://github.com/cabaletta/baritone/issues/797).
 
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8.9, rebuilt for 1.12.2 and 1.13.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
 
-Have committed at least once a day for the last 11 months =D 🦀
+Have committed at least once a day from Aug 1 2018 to Aug 1 2019.
 
 1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2
 

SETUP.md

@@ -1,6 +1,6 @@
 # Installation
 
-The easiest way to install Baritone is to install [Impact](https://impactdevelopment.github.io/), which comes with Baritone.
+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).
 
@@ -11,6 +11,8 @@ These releases are not always completely up to date with latest features, and ar
 
 Link to the releases page: [Releases](https://github.com/cabaletta/baritone/releases)
 
+v1.2.* is for 1.12.2, v1.3.* is for 1.13.2
+
 Any official release will be GPG signed by leijurv (44A3EA646EADAC6A) and ZeroMemes (73A788379A197567). Please verify that the hash of the file you download is in `checksums.txt` and that `checksums_signed.asc` is a valid signature by those two public keys of `checksums.txt`. 
 
 The build is fully deterministic and reproducible, and you can verify Travis did it properly by running `docker build --no-cache -t cabaletta/baritone .` yourself and comparing the shasum. This works identically on Travis, Mac, and Linux (if you have docker on Windows, I'd be grateful if you could let me know if it works there too).
@@ -101,4 +103,4 @@ $ gradlew build
 
   ![Image](https://i.imgur.com/PE6r9iN.png)
 
-- Double click on **build** to run it
+- Double click on **build** to run it

USAGE.md

@@ -24,7 +24,7 @@ Some common examples:
 - `goal clear` to clear the goal
 - `cancel` or `stop` to stop everything
 - `goto portal` or `goto ender_chest` or `goto block_type` to go to a block. (in Impact, `.goto` is an alias for `.b goto` for the most part)
-- `mine diamond_ore` to mine diamond ore (turn on the setting `legitMine` to only mine ores that it can actually see. It will explore randomly around y=11 until it finds them.)
+- `mine diamond_ore 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.
@@ -39,6 +39,11 @@ Some common examples:
 - `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>.

build.gradle

@@ -16,7 +16,7 @@
  */
 
 group 'baritone'
-version '1.3.4'
+version '1.3.5'
 
 buildscript {
     repositories {
@@ -70,7 +70,7 @@ sourceSets {
     schematica_api {
         compileClasspath += main.compileClasspath
     }
-    
+
     main {
         compileClasspath += schematica_api.output
     }

src/api/java/baritone/api/BaritoneAPI.java

@@ -34,12 +34,12 @@ public final class BaritoneAPI {
     private static final Settings settings;
 
     static {
+        settings = new Settings();
+        SettingsUtil.readAndApply(settings);
+
         ServiceLoader<IBaritoneProvider> baritoneLoader = ServiceLoader.load(IBaritoneProvider.class);
         Iterator<IBaritoneProvider> instances = baritoneLoader.iterator();
         provider = instances.next();
-
-        settings = new Settings();
-        SettingsUtil.readAndApply(settings);
     }
 
     public static IBaritoneProvider getProvider() {

src/api/java/baritone/api/IBaritone.java

@@ -23,8 +23,10 @@ import baritone.api.cache.IWorldProvider;
 import baritone.api.event.listener.IEventBus;
 import baritone.api.pathing.calc.IPathingControlManager;
 import baritone.api.process.*;
+import baritone.api.selection.ISelectionManager;
 import baritone.api.utils.IInputOverrideHandler;
 import baritone.api.utils.IPlayerContext;
+import baritone.api.command.manager.ICommandManager;
 
 /**
  * @author Brady
@@ -32,15 +34,6 @@ import baritone.api.utils.IPlayerContext;
  */
 public interface IBaritone {
 
-    /**
-     * Call as soon as Minecraft is ready, initializes all of the processes, behaviors, etc. This will
-     * only effectively be ran once, any additional calls are redundant because the initialization state
-     * is saved.
-     * <p>
-     * Or whenever your overeager utility client wants.
-     */
-    void init();
-
     /**
      * @return The {@link IPathingBehavior} instance
      * @see IPathingBehavior
@@ -128,6 +121,18 @@ public interface IBaritone {
      */
     IEventBus getGameEventHandler();
 
+    /**
+     * @return The {@link ISelectionManager} instance
+     * @see ISelectionManager
+     */
+    ISelectionManager getSelectionManager();
+
+    /**
+     * @return The {@link ICommandManager} instance
+     * @see ICommandManager
+     */
+    ICommandManager getCommandManager();
+
     /**
      * Open click
      */

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

@@ -18,12 +18,15 @@
 package baritone.api;
 
 import baritone.api.cache.IWorldScanner;
+import baritone.api.command.ICommand;
+import baritone.api.command.ICommandSystem;
 import net.minecraft.client.entity.EntityPlayerSP;
 
 import java.util.List;
+import java.util.Objects;
 
 /**
- * Provides the present {@link IBaritone} instances
+ * Provides the present {@link IBaritone} instances, as well as non-baritone instance related APIs.
  *
  * @author leijurv
  */
@@ -57,7 +60,7 @@ public interface IBaritoneProvider {
      */
     default IBaritone getBaritoneForPlayer(EntityPlayerSP player) {
         for (IBaritone baritone : getAllBaritones()) {
-            if (player.equals(baritone.getPlayerContext().player())) {
+            if (Objects.equals(player, baritone.getPlayerContext().player())) {
                 return baritone;
             }
         }
@@ -71,4 +74,12 @@ public interface IBaritoneProvider {
      * @return The {@link IWorldScanner} instance.
      */
     IWorldScanner getWorldScanner();
+
+    /**
+     * Returns the {@link ICommandSystem} instance. This is not bound to a specific {@link IBaritone}
+     * instance because {@link ICommandSystem} itself controls global behavior for {@link ICommand}s.
+     *
+     * @return The {@link ICommandSystem} instance.
+     */
+    ICommandSystem getCommandSystem();
 }

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

@@ -124,6 +124,13 @@ public final class Settings {
      */
     public final Setting<Boolean> allowJumpAt256 = new Setting<>(false);
 
+    /**
+     * This should be monetized it's so good
+     * <p>
+     * Defaults to true, but only actually takes effect if allowParkour is also true
+     */
+    public final Setting<Boolean> allowParkourAscend = new Setting<>(true);
+
     /**
      * Allow descending diagonally
      * <p>
@@ -133,6 +140,13 @@ public final class Settings {
      */
     public final Setting<Boolean> allowDiagonalDescend = new Setting<>(false);
 
+    /**
+     * Allow diagonal ascending
+     * <p>
+     * Actually pretty safe, much safer than diagonal descend tbh
+     */
+    public final Setting<Boolean> allowDiagonalAscend = new Setting<>(false);
+
     /**
      * Allow mining the block directly beneath its feet
      * <p>
@@ -164,7 +178,9 @@ public final class Settings {
             Blocks.CRAFTING_TABLE,
             Blocks.FURNACE,
             Blocks.CHEST,
-            Blocks.TRAPPED_CHEST
+            Blocks.TRAPPED_CHEST,
+            Blocks.SIGN,
+            Blocks.WALL_SIGN
     )));
 
     /**
@@ -178,7 +194,7 @@ public final class Settings {
      * Enables some more advanced vine features. They're honestly just gimmicks and won't ever be needed in real
      * pathing scenarios. And they can cause Baritone to get trapped indefinitely in a strange scenario.
      * <p>
-     * Never turn this on lol
+     * Almost never turn this on lol
      */
     public final Setting<Boolean> allowVines = new Setting<>(false);
 
@@ -234,7 +250,12 @@ public final class Settings {
     /**
      * How many degrees to randomize the yaw every tick. Set to 0 to disable
      */
-    public final Setting<Double> randomLooking = new Setting<>(2d);
+    public final Setting<Double> randomLooking113 = new Setting<>(2d);
+
+    /**
+     * How many degrees to randomize the pitch and yaw every tick. Set to 0 to disable
+     */
+    public final Setting<Double> randomLooking = new Setting<>(0.01d);
 
     /**
      * This is the big A* setting.
@@ -478,15 +499,20 @@ public final class Settings {
     public final Setting<Boolean> chatControl = new Setting<>(true);
 
     /**
-     * A second override over chatControl to force it on
+     * Some clients like Impact try to force chatControl to off, so here's a second setting to do it anyway
      */
-    public final Setting<Boolean> removePrefix = new Setting<>(false);
+    public final Setting<Boolean> chatControlAnyway = new Setting<>(false);
 
     /**
      * Render the path
      */
     public final Setting<Boolean> renderPath = new Setting<>(true);
 
+    /**
+     * Render the path as a line instead of a frickin thingy
+     */
+    public final Setting<Boolean> renderPathAsLine = new Setting<>(false);
+
     /**
      * Render the goal
      */
@@ -587,10 +613,41 @@ public final class Settings {
     public final Setting<Float> cachedChunksOpacity = new Setting<>(0.5f);
 
     /**
-     * Whether or not to use the "#" command prefix
+     * Whether or not to allow you to run Baritone commands with the prefix
      */
     public final Setting<Boolean> prefixControl = new Setting<>(true);
 
+    /**
+     * The command prefix for chat control
+     */
+    public final Setting<String> prefix = new Setting<>("#");
+
+    /**
+     * Use a short Baritone prefix [B] instead of [Baritone] when logging to chat
+     */
+    public final Setting<Boolean> shortBaritonePrefix = new Setting<>(false);
+
+    /**
+     * Echo commands to chat when they are run
+     */
+    public final Setting<Boolean> echoCommands = new Setting<>(true);
+
+    /**
+     * Censor coordinates in goals and block positions
+     */
+    public final Setting<Boolean> censorCoordinates = new Setting<>(false);
+
+    /**
+     * Censor arguments to ran commands, to hide, for example, coordinates to #goal
+     */
+    public final Setting<Boolean> censorRanCommands = new Setting<>(false);
+
+    /**
+     * Always prefer silk touch tools over regular tools. This will not sacrifice speed, but it will always prefer silk
+     * touch tools over other tools of the same speed. This includes always choosing ANY silk touch tool over your hand.
+     */
+    public final Setting<Boolean> preferSilkTouch = new Setting<>(false);
+
     /**
      * Don't stop walking forward when you need to break blocks in your way
      */
@@ -652,7 +709,12 @@ public final class Settings {
     public final Setting<Integer> exploreMaintainY = new Setting<>(64);
 
     /**
-     * Replant nether wart while farming
+     * Replant normal Crops while farming and leave cactus and sugarcane to regrow
+     */
+    public final Setting<Boolean> replantCrops = new Setting<>(true);
+
+    /**
+     * Replant nether wart while farming. This setting only has an effect when replantCrops is also enabled
      */
     public final Setting<Boolean> replantNetherWart = new Setting<>(false);
 
@@ -694,11 +756,65 @@ public final class Settings {
      */
     public final Setting<Boolean> goalBreakFromAbove = new Setting<>(false);
 
+    /**
+     * Build in map art mode, which makes baritone only care about the top block in each column
+     */
+    public final Setting<Boolean> mapArtMode = new Setting<>(false);
+
+    /**
+     * Override builder's behavior to not attempt to correct blocks that are currently water
+     */
+    public final Setting<Boolean> okIfWater = new Setting<>(false);
+
+    /**
+     * The set of incorrect blocks can never grow beyond this size
+     */
+    public final Setting<Integer> incorrectSize = new Setting<>(100);
+
+    /**
+     * Multiply the cost of breaking a block that's correct in the builder's schematic by this coefficient
+     */
+    public final Setting<Double> breakCorrectBlockPenaltyMultiplier = new Setting<>(10d);
+
+    /**
+     * When this setting is true, build a schematic with the highest X coordinate being the origin, instead of the lowest
+     */
+    public final Setting<Boolean> schematicOrientationX = new Setting<>(false);
+
+    /**
+     * When this setting is true, build a schematic with the highest Y coordinate being the origin, instead of the lowest
+     */
+    public final Setting<Boolean> schematicOrientationY = new Setting<>(false);
+
+    /**
+     * When this setting is true, build a schematic with the highest Z coordinate being the origin, instead of the lowest
+     */
+    public final Setting<Boolean> schematicOrientationZ = new Setting<>(false);
+
+    /**
+     * 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.
+     */
+    public final Setting<Integer> builderTickScanRadius = new Setting<>(5);
+
     /**
      * While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
      */
     public final Setting<Boolean> mineScanDroppedItems = new Setting<>(true);
 
+    /**
+     * While mining, wait this number of milliseconds after mining an ore to see if it will drop an item
+     * instead of immediately going onto the next one
+     * <p>
+     * Thanks Louca
+     */
+    public final Setting<Long> mineDropLoiterDurationMSThanksLouca = new Setting<>(250L);
+
+    /**
+     * Trim incorrect positions too far away, helps performance but hurts reliability in very large schematics
+     */
+    public final Setting<Boolean> distanceTrim = new Setting<>(true);
+
     /**
      * Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
      * <p>
@@ -859,6 +975,51 @@ public final class Settings {
      */
     public final Setting<Color> colorGoalBox = new Setting<>(Color.GREEN);
 
+    /**
+     * The color of the goal box when it's inverted
+     */
+    public final Setting<Color> colorInvertedGoalBox = new Setting<>(Color.RED);
+
+    /**
+     * The color of all selections
+     */
+    public final Setting<Color> colorSelection = new Setting<>(Color.CYAN);
+
+    /**
+     * The color of the selection pos 1
+     */
+    public final Setting<Color> colorSelectionPos1 = new Setting<>(Color.BLACK);
+
+    /**
+     * The color of the selection pos 2
+     */
+    public final Setting<Color> colorSelectionPos2 = new Setting<>(Color.ORANGE);
+
+    /**
+     * The opacity of the selection. 0 is completely transparent, 1 is completely opaque
+     */
+    public final Setting<Float> selectionOpacity = new Setting<>(.5f);
+
+    /**
+     * Line width of the goal when rendered, in pixels
+     */
+    public final Setting<Float> selectionLineWidth = new Setting<>(2F);
+
+    /**
+     * Render selections
+     */
+    public final Setting<Boolean> renderSelection = new Setting<>(true);
+
+    /**
+     * Ignore depth when rendering selections
+     */
+    public final Setting<Boolean> renderSelectionIgnoreDepth = new Setting<>(true);
+
+    /**
+     * Render selection corners
+     */
+    public final Setting<Boolean> renderSelectionCorners = new Setting<>(true);
+
 
     /**
      * A map of lowercase setting field names to their respective setting
@@ -873,6 +1034,7 @@ public final class Settings {
     public final Map<Setting<?>, Type> settingTypes;
 
     public final class Setting<T> {
+
         public T value;
         public final T defaultValue;
         private String name;
@@ -955,10 +1117,10 @@ public final class Settings {
     }
 
     @SuppressWarnings("unchecked")
-    public <T> List<Setting<T>> getAllValuesByType(Class<T> klass) {
+    public <T> List<Setting<T>> getAllValuesByType(Class<T> cla$$) {
         List<Setting<T>> result = new ArrayList<>();
         for (Setting<?> setting : allSettings) {
-            if (setting.getValueClass().equals(klass)) {
+            if (setting.getValueClass().equals(cla$$)) {
                 result.add((Setting<T>) setting);
             }
         }

src/api/java/baritone/api/behavior/IPathingBehavior.java

@@ -64,9 +64,17 @@ public interface IPathingBehavior extends IBehavior {
     Goal getGoal();
 
     /**
-     * @return Whether or not a path is currently being executed.
+     * @return Whether or not a path is currently being executed. This will be false if there's currently a pause.
+     * @see #hasPath()
      */
-    default boolean isPathing() {
+    boolean isPathing();
+
+    /**
+     * @return If there is a current path. Note that the path is not necessarily being executed, for example when there
+     * is a pause in effect.
+     * @see #isPathing()
+     */
+    default boolean hasPath() {
         return getCurrent() != null;
     }
 

src/api/java/baritone/api/cache/IWaypoint.java

@@ -17,12 +17,9 @@
 
 package baritone.api.cache;
 
-import net.minecraft.util.math.BlockPos;
-import org.apache.commons.lang3.ArrayUtils;
+import baritone.api.utils.BetterBlockPos;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 /**
  * A marker for a position in the world.
@@ -60,7 +57,7 @@ public interface IWaypoint {
      *
      * @return The block position of this waypoint
      */
-    BlockPos getLocation();
+    BetterBlockPos getLocation();
 
     enum Tag {
 
@@ -92,20 +89,48 @@ public interface IWaypoint {
         /**
          * The names for the tag, anything that the tag can be referred to as.
          */
-        private final String[] names;
+        public final String[] names;
 
         Tag(String... names) {
             this.names = names;
         }
 
         /**
-         * Finds a tag from one of the names that could be used to identify said tag.
-         *
-         * @param name The name of the tag
-         * @return The tag, if one is found, otherwise, {@code null}
+         * @return A name that can be passed to {@link #getByName(String)} to retrieve this tag
          */
-        public static Tag fromString(String name) {
-            return TAG_LIST.stream().filter(tag -> ArrayUtils.contains(tag.names, name.toLowerCase())).findFirst().orElse(null);
+        public String getName() {
+            return names[0];
+        }
+
+        /**
+         * Gets a tag by one of its names.
+         *
+         * @param name The name to search for.
+         * @return The tag, if found, or null.
+         */
+        public static Tag getByName(String name) {
+            for (Tag action : Tag.values()) {
+                for (String alias : action.names) {
+                    if (alias.equalsIgnoreCase(name)) {
+                        return action;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /**
+         * @return All tag names.
+         */
+        public static String[] getAllNames() {
+            Set<String> names = new HashSet<>();
+
+            for (Tag tag : Tag.values()) {
+                names.addAll(Arrays.asList(tag.names));
+            }
+
+            return names.toArray(new String[0]);
         }
     }
 }

src/api/java/baritone/api/cache/IWorldScanner.java

@@ -17,6 +17,7 @@
 
 package baritone.api.cache;
 
+import baritone.api.utils.BlockOptionalMetaLookup;
 import baritone.api.utils.IPlayerContext;
 import net.minecraft.block.Block;
 import net.minecraft.util.math.BlockPos;
@@ -33,28 +34,53 @@ public interface IWorldScanner {
     /**
      * Scans the world, up to the specified max chunk radius, for the specified blocks.
      *
-     * @param ctx             The {@link IPlayerContext} containing player and world info that the
-     *                        scan is based upon
-     * @param blocks          The blocks to scan for
+     * @param ctx             The {@link IPlayerContext} containing player and world info that the scan is based upon
+     * @param filter          The blocks to scan for
      * @param max             The maximum number of blocks to scan before cutoff
-     * @param yLevelThreshold If a block is found within this Y level, the current result will be
-     *                        returned, if the value is negative, then this condition doesn't apply.
+     * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+     *                        is negative, then this condition doesn't apply.
      * @param maxSearchRadius The maximum chunk search radius
      * @return The matching block positions
      */
-    List<BlockPos> scanChunkRadius(IPlayerContext ctx, List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius);
+    List<BlockPos> scanChunkRadius(IPlayerContext ctx, BlockOptionalMetaLookup filter, int max, int yLevelThreshold, int maxSearchRadius);
+
+    default List<BlockPos> scanChunkRadius(IPlayerContext ctx, List<Block> filter, int max, int yLevelThreshold, int maxSearchRadius) {
+        return scanChunkRadius(ctx, new BlockOptionalMetaLookup(filter.toArray(new Block[0])), max, yLevelThreshold, maxSearchRadius);
+    }
 
     /**
      * Scans a single chunk for the specified blocks.
      *
-     * @param ctx             The {@link IPlayerContext} containing player and world info that the
-     *                        scan is based upon
+     * @param ctx             The {@link IPlayerContext} containing player and world info that the scan is based upon
+     * @param filter          The blocks to scan for
+     * @param pos             The position of the target chunk
+     * @param max             The maximum number of blocks to scan before cutoff
+     * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+     *                        is negative, then this condition doesn't apply.
+     * @return The matching block positions
+     */
+    List<BlockPos> scanChunk(IPlayerContext ctx, BlockOptionalMetaLookup filter, ChunkPos pos, int max, int yLevelThreshold);
+
+    /**
+     * Scans a single chunk for the specified blocks.
+     *
+     * @param ctx             The {@link IPlayerContext} containing player and world info that the scan is based upon
      * @param blocks          The blocks to scan for
      * @param pos             The position of the target chunk
      * @param max             The maximum number of blocks to scan before cutoff
-     * @param yLevelThreshold If a block is found within this Y level, the current result will be
-     *                        returned, if the value is negative, then this condition doesn't apply.
+     * @param yLevelThreshold If a block is found within this Y level, the current result will be returned, if the value
+     *                        is negative, then this condition doesn't apply.
      * @return The matching block positions
      */
-    List<BlockPos> scanChunk(IPlayerContext ctx, List<Block> blocks, ChunkPos pos, int max, int yLevelThreshold);
+    default List<BlockPos> scanChunk(IPlayerContext ctx, List<Block> blocks, ChunkPos pos, int max, int yLevelThreshold) {
+        return scanChunk(ctx, new BlockOptionalMetaLookup(blocks), pos, max, yLevelThreshold);
+    }
+
+    /**
+     * Repacks 40 chunks around the player.
+     *
+     * @param ctx The player context for that player.
+     * @return The number of chunks queued for repacking.
+     */
+    int repack(IPlayerContext ctx);
 }

src/api/java/baritone/api/cache/Waypoint.java

@@ -17,7 +17,7 @@
 
 package baritone.api.cache;
 
-import net.minecraft.util.math.BlockPos;
+import baritone.api.utils.BetterBlockPos;
 
 import java.util.Date;
 
@@ -31,9 +31,9 @@ public class Waypoint implements IWaypoint {
     private final String name;
     private final Tag tag;
     private final long creationTimestamp;
-    private final BlockPos location;
+    private final BetterBlockPos location;
 
-    public Waypoint(String name, Tag tag, BlockPos location) {
+    public Waypoint(String name, Tag tag, BetterBlockPos location) {
         this(name, tag, location, System.currentTimeMillis());
     }
 
@@ -46,7 +46,7 @@ public class Waypoint implements IWaypoint {
      * @param location          The waypoint location
      * @param creationTimestamp When the waypoint was created
      */
-    public Waypoint(String name, Tag tag, BlockPos location, long creationTimestamp) {
+    public Waypoint(String name, Tag tag, BetterBlockPos location, long creationTimestamp) {
         this.name = name;
         this.tag = tag;
         this.location = location;
@@ -55,7 +55,7 @@ public class Waypoint implements IWaypoint {
 
     @Override
     public int hashCode() {
-        return name.hashCode() + tag.hashCode() + location.hashCode(); //lol
+        return name.hashCode() ^ tag.hashCode() ^ location.hashCode() ^ Long.hashCode(creationTimestamp);
     }
 
     @Override
@@ -74,13 +74,18 @@ public class Waypoint implements IWaypoint {
     }
 
     @Override
-    public BlockPos getLocation() {
+    public BetterBlockPos getLocation() {
         return this.location;
     }
 
     @Override
     public String toString() {
-        return name + " " + location.toString() + " " + new Date(creationTimestamp).toString();
+        return String.format(
+                "%s %s %s",
+                name,
+                BetterBlockPos.from(location).toString(),
+                new Date(creationTimestamp).toString()
+        );
     }
 
     @Override

src/api/java/baritone/api/command/Command.java

@@ -0,0 +1,68 @@
+/*
+ * 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.command;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.IPlayerContext;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * A default implementation of {@link ICommand} which provides easy access to the
+ * command's bound {@link IBaritone} instance, {@link IPlayerContext} and an easy
+ * way to provide multiple valid command execution names through the default constructor.
+ * <p>
+ * So basically, you should use it because it provides a small amount of boilerplate,
+ * but you're not forced to use it.
+ *
+ * @see ICommand
+ *
+ * @author LoganDark
+ */
+public abstract class Command implements ICommand {
+
+    protected IBaritone baritone;
+    protected IPlayerContext ctx;
+
+    /**
+     * The names of this command. This is what you put after the command prefix.
+     */
+    protected final List<String> names;
+
+    /**
+     * Creates a new Baritone control command.
+     *
+     * @param names The names of this command. This is what you put after the command prefix.
+     */
+    protected Command(IBaritone baritone, String... names) {
+        this.names = Collections.unmodifiableList(Stream.of(names)
+                .map(s -> s.toLowerCase(Locale.US))
+                .collect(Collectors.toList()));
+        this.baritone = baritone;
+        this.ctx = baritone.getPlayerContext();
+    }
+
+    @Override
+    public final List<String> getNames() {
+        return this.names;
+    }
+}

src/api/java/baritone/api/command/IBaritoneChatControl.java

@@ -0,0 +1,42 @@
+/*
+ * 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.command;
+
+import baritone.api.Settings;
+
+import java.util.UUID;
+
+/**
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IBaritoneChatControl {
+
+    /**
+     * In certain cases chat components need to execute commands for you. For example, the paginator automatically runs
+     * commands when you click the forward and back arrows to show you the previous/next page.
+     * <p>
+     * If the prefix is changed in the meantime, then the command will go to chat. That's no good. So here's a permanent
+     * prefix that forces a command to run, regardless of the current prefix, chat/prefix control being enabled, etc.
+     * <p>
+     * If used right (by both developers and users), it should be impossible to expose a command accidentally to the
+     * server. As a rule of thumb, if you have a clickable chat component, always use this prefix. If you're suggesting
+     * a command (a component that puts text into your text box, or something else), use {@link Settings#prefix}.
+     */
+    String FORCE_COMMAND_PREFIX = String.format("<<%s>>", UUID.randomUUID().toString());
+}

src/api/java/baritone/api/command/ICommand.java

@@ -0,0 +1,67 @@
+/*
+ * 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.command;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+import baritone.api.utils.Helper;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * The base for a command.
+ *
+ * @author Brady
+ * @since 10/7/2019
+ */
+public interface ICommand extends Helper {
+
+    /**
+     * Called when this command is executed.
+     */
+    void execute(String label, IArgConsumer args) throws CommandException;
+
+    /**
+     * Called when the command needs to tab complete. Return a Stream representing the entries to put in the completions
+     * list.
+     */
+    Stream<String> tabComplete(String label, IArgConsumer args) throws CommandException;
+
+    /**
+     * @return A <b>single-line</b> string containing a short description of this command's purpose.
+     */
+    String getShortDesc();
+
+    /**
+     * @return A list of lines that will be printed by the help command when the user wishes to view them.
+     */
+    List<String> getLongDesc();
+
+    /**
+     * @return A list of the names that can be accepted to have arguments passed to this command
+     */
+    List<String> getNames();
+
+    /**
+     * @return {@code true} if this command should be hidden from the help menu
+     */
+    default boolean hiddenFromHelp() {
+        return false;
+    }
+}

src/api/java/baritone/api/command/ICommandSystem.java

@@ -0,0 +1,29 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.command;
+
+import baritone.api.command.argparser.IArgParserManager;
+
+/**
+ * @author Brady
+ * @since 10/4/2019
+ */
+public interface ICommandSystem {
+
+    IArgParserManager getParserManager();
+}

src/api/java/baritone/api/command/argparser/IArgParser.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.command.argparser;
+
+import baritone.api.command.argument.ICommandArgument;
+
+public interface IArgParser<T> {
+
+    /**
+     * @return the class of this parser.
+     */
+    Class<T> getTarget();
+
+    /**
+     * A stateless argument parser is just that. It takes a {@link ICommandArgument} and outputs its type.
+     */
+    interface Stateless<T> extends IArgParser<T> {
+
+        /**
+         * @param arg The argument to parse.
+         * @return What it was parsed into.
+         * @throws RuntimeException if you want the parsing to fail. The exception will be caught and turned into an
+         *                          appropriate error.
+         */
+        T parseArg(ICommandArgument arg) throws Exception;
+    }
+
+    /**
+     * A stated argument parser is similar to a stateless one. It also takes a {@link ICommandArgument}, but it also
+     * takes a second argument that can be any type, referred to as the state.
+     */
+    interface Stated<T, S> extends IArgParser<T> {
+
+        Class<S> getStateType();
+
+        /**
+         * @param arg   The argument to parse.
+         * @param state Can be anything.
+         * @return What it was parsed into.
+         * @throws RuntimeException if you want the parsing to fail. The exception will be caught and turned into an
+         *                          appropriate error.
+         */
+        T parseArg(ICommandArgument arg, S state) throws Exception;
+    }
+}

src/api/java/baritone/api/command/argparser/IArgParserManager.java

@@ -0,0 +1,69 @@
+/*
+ * 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.command.argparser;
+
+import baritone.api.command.argument.ICommandArgument;
+import baritone.api.command.exception.CommandInvalidTypeException;
+import baritone.api.command.registry.Registry;
+
+/**
+ * Used to retrieve {@link IArgParser} instances from the registry, by their target class.
+ * It can be assumed that a {@link IArgParser} exists for {@link Integer}, {@link Long},
+ * {@link Float}, {@link Double} and {@link Boolean}.
+ *
+ * @author Brady
+ * @since 10/4/2019
+ */
+public interface IArgParserManager {
+
+    /**
+     * @param type The type trying to be parsed
+     * @return A parser that can parse arguments into this class, if found.
+     */
+    <T> IArgParser.Stateless<T> getParserStateless(Class<T> type);
+
+    /**
+     * @param type The type trying to be parsed
+     * @return A parser that can parse arguments into this class, if found.
+     */
+    <T, S> IArgParser.Stated<T, S> getParserStated(Class<T> type, Class<S> stateKlass);
+
+    /**
+     * Attempt to parse the specified argument with a stateless {@link IArgParser} that outputs the specified class.
+     *
+     * @param type  The type to try and parse the argument into.
+     * @param arg   The argument to parse.
+     * @return An instance of the specified class.
+     * @throws CommandInvalidTypeException If the parsing failed
+     */
+    <T> T parseStateless(Class<T> type, ICommandArgument arg) throws CommandInvalidTypeException;
+
+    /**
+     * Attempt to parse the specified argument with a stated {@link IArgParser} that outputs the specified class.
+     *
+     * @param type  The type to try and parse the argument into.
+     * @param arg   The argument to parse.
+     * @param state The state to pass to the {@link IArgParser.Stated}.
+     * @return An instance of the specified class.
+     * @throws CommandInvalidTypeException If the parsing failed
+     * @see IArgParser.Stated
+     */
+    <T, S> T parseStated(Class<T> type, Class<S> stateKlass, ICommandArgument arg, S state) throws CommandInvalidTypeException;
+
+    Registry<IArgParser> getRegistry();
+}

src/api/java/baritone/api/command/argument/IArgConsumer.java

@@ -0,0 +1,594 @@
+/*
+ * 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.command.argument;
+
+import baritone.api.command.ICommand;
+import baritone.api.command.exception.CommandTooManyArgumentsException;
+import baritone.api.utils.Helper;
+import baritone.api.command.argparser.IArgParser;
+import baritone.api.command.datatypes.IDatatype;
+import baritone.api.command.datatypes.IDatatypeFor;
+import baritone.api.command.datatypes.IDatatypePost;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.exception.CommandInvalidTypeException;
+import baritone.api.command.exception.CommandNotEnoughArgumentsException;
+import net.minecraft.util.EnumFacing;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.stream.Stream;
+
+/**
+ * The {@link IArgConsumer} is how {@link ICommand}s read the arguments passed to them. This class has many benefits:
+ *
+ * <ul>
+ * <li>Mutability. The whole concept of the {@link IArgConsumer}} is to let you gradually consume arguments in any way
+ * you'd like. You can change your consumption based on earlier arguments, for subcommands for example.</li>
+ * <li>You don't need to keep track of your consumption. The {@link IArgConsumer}} keeps track of the arguments you
+ * consume so that it can throw detailed exceptions whenever something is out of the ordinary. Additionally, if you
+ * need to retrieve an argument after you've already consumed it - look no further than {@link #consumed()}!</li>
+ * <li>Easy retrieval of many different types. If you need to retrieve an instance of an int or float for example,
+ * look no further than {@link #getAs(Class)}. If you need a more powerful way of retrieving data, try out the many
+ * {@code getDatatype...} methods.</li>
+ * <li>It's very easy to throw detailed exceptions. The {@link IArgConsumer}} has many different methods that can
+ * enforce the number of arguments, the type of arguments, and more, throwing different types of
+ * {@link CommandException}s if something seems off. You're recommended to do all validation and store all needed
+ * data in variables BEFORE logging any data to chat via {@link Helper#logDirect(String)}, so that the error
+ * handlers can do their job and log the error to chat.</li>
+ * </ul>
+ */
+public interface IArgConsumer {
+
+    LinkedList<ICommandArgument> getArgs();
+
+    Deque<ICommandArgument> getConsumed();
+
+    /**
+     * @param num The number of arguments to check for
+     * @return {@code true} if there are <i>at least</i> {@code num} arguments left in this {@link IArgConsumer}}
+     * @see #hasAny()
+     * @see #hasAtMost(int)
+     * @see #hasExactly(int)
+     */
+    boolean has(int num);
+
+    /**
+     * @return {@code true} if there is <i>at least</i> 1 argument left in this {@link IArgConsumer}}
+     * @see #has(int)
+     * @see #hasAtMostOne()
+     * @see #hasExactlyOne()
+     */
+    boolean hasAny();
+
+    /**
+     * @param num The number of arguments to check for
+     * @return {@code true} if there are <i>at most</i> {@code num} arguments left in this {@link IArgConsumer}}
+     * @see #has(int)
+     * @see #hasAtMost(int)
+     * @see #hasExactly(int)
+     */
+    boolean hasAtMost(int num);
+
+    /**
+     * @return {@code true} if there is <i>at most</i> 1 argument left in this {@link IArgConsumer}}
+     * @see #hasAny()
+     * @see #hasAtMostOne()
+     * @see #hasExactlyOne()
+     */
+    boolean hasAtMostOne();
+
+    /**
+     * @param num The number of arguments to check for
+     * @return {@code true} if there are <i>exactly</i> {@code num} arguments left in this {@link IArgConsumer}}
+     * @see #has(int)
+     * @see #hasAtMost(int)
+     */
+    boolean hasExactly(int num);
+
+    /**
+     * @return {@code true} if there is <i>exactly</i> 1 argument left in this {@link IArgConsumer}}
+     * @see #hasAny()
+     * @see #hasAtMostOne()
+     */
+    boolean hasExactlyOne();
+
+    /**
+     * @param index The index to peek
+     * @return The argument at index {@code index} in this {@link IArgConsumer}}, with 0 being the next one. This does not
+     * mutate the {@link IArgConsumer}}
+     * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+     * @see #peek()
+     * @see #peekString(int)
+     * @see #peekAs(Class, int)
+     * @see #get()
+     */
+    ICommandArgument peek(int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @return The next argument in this {@link IArgConsumer}}. This does not mutate the {@link IArgConsumer}}
+     * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+     * @see #peek(int)
+     * @see #peekString()
+     * @see #peekAs(Class)
+     * @see #get()
+     */
+    ICommandArgument peek() throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param index The index to peek
+     * @param type  The type to check for
+     * @return If an ArgParser.Stateless for the specified {@code type} would succeed in parsing the next
+     * argument
+     * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+     * @see #peek()
+     * @see #getAs(Class)
+     */
+    boolean is(Class<?> type, int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param type The type to check for
+     * @return If an ArgParser.Stateless for the specified {@code type} would succeed in parsing the next
+     * argument
+     * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+     * @see #peek()
+     * @see #getAs(Class)
+     */
+    boolean is(Class<?> type) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param index The index to peek
+     * @return The value of the argument at index {@code index} in this {@link IArgConsumer}}, with 0 being the next one
+     * This does not mutate the {@link IArgConsumer}}
+     * @throws CommandNotEnoughArgumentsException If there is less than {@code index + 1} arguments left
+     * @see #peek()
+     * @see #peekString()
+     */
+    String peekString(int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @return The value of the next argument in this {@link IArgConsumer}}. This does not mutate the {@link IArgConsumer}}
+     * @throws CommandNotEnoughArgumentsException If there is less than one argument left
+     * @see #peekString(int)
+     * @see #getString()
+     */
+    String peekString() throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param index     The index to peek
+     * @param enumClass The class to search
+     * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+     * next argument's value
+     * @throws java.util.NoSuchElementException If the constant couldn't be found
+     * @see #peekEnumOrNull(Class)
+     * @see #getEnum(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E peekEnum(Class<E> enumClass, int index) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * @param enumClass The class to search
+     * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+     * next argument's value
+     * @throws CommandInvalidTypeException If the constant couldn't be found
+     * @see #peekEnumOrNull(Class)
+     * @see #getEnum(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E peekEnum(Class<E> enumClass) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * @param index     The index to peek
+     * @param enumClass The class to search
+     * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+     * next argument's value. If no constant could be found, null
+     * @see #peekEnum(Class)
+     * @see #getEnumOrNull(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E peekEnumOrNull(Class<E> enumClass, int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param enumClass The class to search
+     * @return From the specified enum class, an enum constant of that class. The enum constant's name will match the
+     * next argument's value. If no constant could be found, null
+     * @see #peekEnum(Class)
+     * @see #getEnumOrNull(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E peekEnumOrNull(Class<E> enumClass) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the argument at the specified index into the specified
+     * class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type  The type to peek as
+     * @param index The index to peek
+     * @return An instance of the specified type
+     * @throws CommandInvalidTypeException     If the parsing failed
+     * @see IArgParser
+     * @see #peekAs(Class)
+     * @see #peekAsOrDefault(Class, Object, int)
+     * @see #peekAsOrNull(Class, int)
+     */
+    <T> T peekAs(Class<T> type, int index) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @return An instance of the specified type
+     * @throws CommandInvalidTypeException     If the parsing failed
+     * @see IArgParser
+     * @see #peekAs(Class, int)
+     * @see #peekAsOrDefault(Class, Object)
+     * @see #peekAsOrNull(Class)
+     */
+    <T> T peekAs(Class<T> type) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the argument at the specified index into the specified
+     * class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type  The type to peek as
+     * @param def   The value to return if the argument can't be parsed
+     * @param index The index to peek
+     * @return An instance of the specified type, or {@code def} if it couldn't be parsed
+     * @see IArgParser
+     * @see #peekAsOrDefault(Class, Object)
+     * @see #peekAs(Class, int)
+     * @see #peekAsOrNull(Class, int)
+     */
+    <T> T peekAsOrDefault(Class<T> type, T def, int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @param def  The value to return if the argument can't be parsed
+     * @return An instance of the specified type, or {@code def} if it couldn't be parsed
+     * @see IArgParser
+     * @see #peekAsOrDefault(Class, Object, int)
+     * @see #peekAs(Class)
+     * @see #peekAsOrNull(Class)
+     */
+    <T> T peekAsOrDefault(Class<T> type, T def) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the argument at the specified index into the specified
+     * class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type  The type to peek as
+     * @param index The index to peek
+     * @return An instance of the specified type, or {@code null} if it couldn't be parsed
+     * @see IArgParser
+     * @see #peekAsOrNull(Class)
+     * @see #peekAs(Class, int)
+     * @see #peekAsOrDefault(Class, Object, int)
+     */
+    <T> T peekAsOrNull(Class<T> type, int index) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @return An instance of the specified type, or {@code null} if it couldn't be parsed
+     * @see IArgParser
+     * @see #peekAsOrNull(Class, int)
+     * @see #peekAs(Class)
+     * @see #peekAsOrDefault(Class, Object)
+     */
+    <T> T peekAsOrNull(Class<T> type) throws CommandNotEnoughArgumentsException;
+
+    <T> T peekDatatype(IDatatypeFor<T> datatype) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T, O> T peekDatatype(IDatatypePost<T, O> datatype) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T, O> T peekDatatype(IDatatypePost<T, O> datatype, O original) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T> T peekDatatypeOrNull(IDatatypeFor<T> datatype);
+
+    <T, O> T peekDatatypeOrNull(IDatatypePost<T, O> datatype);
+
+    <T, O, D extends IDatatypePost<T, O>> T peekDatatypePost(D datatype, O original) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T, O, D extends IDatatypePost<T, O>> T peekDatatypePostOrDefault(D datatype, O original, T def);
+
+    <T, O, D extends IDatatypePost<T, O>> T peekDatatypePostOrNull(D datatype, O original);
+
+    /**
+     * Attempts to get the specified {@link IDatatypeFor} from this ArgConsumer
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     * <p>
+     * Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.
+     *
+     * @param datatype The datatype to get
+     * @return The datatype instance
+     * @see IDatatype
+     * @see IDatatypeFor
+     */
+    <T, D extends IDatatypeFor<T>> T peekDatatypeFor(Class<D> datatype);
+
+    /**
+     * Attempts to get the specified {@link IDatatypeFor} from this ArgConsumer
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     * <p>
+     * Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.
+     *
+     * @param datatype The datatype to get
+     * @param def      The default value
+     * @return The datatype instance, or {@code def} if it throws an exception
+     * @see IDatatype
+     * @see IDatatypeFor
+     */
+    <T, D extends IDatatypeFor<T>> T peekDatatypeForOrDefault(Class<D> datatype, T def);
+
+    /**
+     * Attempts to get the specified {@link IDatatypeFor} from this ArgConsumer
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     * <p>
+     * Since this is a peek operation, this ArgConsumer will not be mutated by any call to this method.
+     *
+     * @param datatype The datatype to get
+     * @return The datatype instance, or {@code null} if it throws an exception
+     * @see IDatatype
+     * @see IDatatypeFor
+     */
+    <T, D extends IDatatypeFor<T>> T peekDatatypeForOrNull(Class<D> datatype);
+
+    /**
+     * Gets the next argument and returns it. This consumes the first argument so that subsequent calls will return
+     * later arguments
+     *
+     * @return The next argument
+     * @throws CommandNotEnoughArgumentsException If there's less than one argument left
+     */
+    ICommandArgument get() throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Gets the value of the next argument and returns it. This consumes the first argument so that subsequent calls
+     * will return later arguments
+     *
+     * @return The value of the next argument
+     * @throws CommandNotEnoughArgumentsException If there's less than one argument left
+     */
+    String getString() throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Gets an enum value from the enum class with the same name as the next argument's value
+     * <p>
+     * For example if you getEnum as an {@link EnumFacing}, and the next argument's value is "up", this will return
+     * {@link EnumFacing#UP}
+     *
+     * @param enumClass The enum class to search
+     * @return An enum constant of that class with the same name as the next argument's value
+     * @throws CommandInvalidTypeException If the constant couldn't be found
+     * @see #peekEnum(Class)
+     * @see #getEnumOrNull(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E getEnum(Class<E> enumClass) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * Gets an enum value from the enum class with the same name as the next argument's value
+     * <p>
+     * For example if you getEnum as an {@link EnumFacing}, and the next argument's value is "up", this will return
+     * {@link EnumFacing#UP}
+     *
+     * @param enumClass The enum class to search
+     * @param def       The default value
+     * @return An enum constant of that class with the same name as the next argument's value, or {@code def} if it
+     * couldn't be found
+     * @see #getEnum(Class)
+     * @see #getEnumOrNull(Class)
+     * @see #peekEnumOrNull(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E getEnumOrDefault(Class<E> enumClass, E def) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Gets an enum value from the enum class with the same name as the next argument's value
+     * <p>
+     * For example if you getEnum as an {@link EnumFacing}, and the next argument's value is "up", this will return
+     * {@link EnumFacing#UP}
+     *
+     * @param enumClass The enum class to search
+     * @return An enum constant of that class with the same name as the next argument's value, or {@code null} if it
+     * couldn't be found
+     * @see #getEnum(Class)
+     * @see #getEnumOrDefault(Class, Enum)
+     * @see #peekEnumOrNull(Class)
+     * @see ICommandArgument#getEnum(Class)
+     */
+    <E extends Enum<?>> E getEnumOrNull(Class<E> enumClass) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @return An instance of the specified type
+     * @throws CommandInvalidTypeException     If the parsing failed
+     * @see IArgParser
+     * @see #get()
+     * @see #getAsOrDefault(Class, Object)
+     * @see #getAsOrNull(Class)
+     * @see #peekAs(Class)
+     * @see #peekAsOrDefault(Class, Object, int)
+     * @see #peekAsOrNull(Class, int)
+     */
+    <T> T getAs(Class<T> type) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @param def  The default value
+     * @return An instance of the specified type, or {@code def} if it couldn't be parsed
+     * @see IArgParser
+     * @see #get()
+     * @see #getAs(Class)
+     * @see #getAsOrNull(Class)
+     * @see #peekAs(Class)
+     * @see #peekAsOrDefault(Class, Object, int)
+     * @see #peekAsOrNull(Class, int)
+     */
+    <T> T getAsOrDefault(Class<T> type, T def) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse the next argument into the specified class
+     * <p>
+     * A critical difference between {@link IDatatype}s and {@link IArgParser}s is how many arguments they can take.
+     * While {@link IArgParser}s always operate on a single argument's value, {@link IDatatype}s get access to the entire
+     * {@link IArgConsumer}}.
+     *
+     * @param type The type to peek as
+     * @return An instance of the specified type, or {@code null} if it couldn't be parsed
+     * @see IArgParser
+     * @see #get()
+     * @see #getAs(Class)
+     * @see #getAsOrDefault(Class, Object)
+     * @see #peekAs(Class)
+     * @see #peekAsOrDefault(Class, Object, int)
+     * @see #peekAsOrNull(Class, int)
+     */
+    <T> T getAsOrNull(Class<T> type) throws CommandNotEnoughArgumentsException;
+
+    <T, O, D extends IDatatypePost<T, O>> T getDatatypePost(D datatype, O original) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T, O, D extends IDatatypePost<T, O>> T getDatatypePostOrDefault(D datatype, O original, T _default);
+
+    <T, O, D extends IDatatypePost<T, O>> T getDatatypePostOrNull(D datatype, O original);
+
+    <T, D extends IDatatypeFor<T>> T getDatatypeFor(D datatype) throws CommandInvalidTypeException, CommandNotEnoughArgumentsException;
+
+    <T, D extends IDatatypeFor<T>> T getDatatypeForOrDefault(D datatype, T def);
+
+    <T, D extends IDatatypeFor<T>> T getDatatypeForOrNull(D datatype);
+
+    <T extends IDatatype> Stream<String> tabCompleteDatatype(T datatype);
+
+    /**
+     * Returns the "raw rest" of the string. For example, from a string <code>arg1 arg2&nbsp;&nbsp;arg3</code>, split
+     * into three {@link ICommandArgument}s {@code "arg1"}, {@code "arg2"}, and {@code "arg3"}:
+     *
+     * <ul>
+     * <li>{@code rawRest()} would return <code>arg1 arg2&nbsp;&nbsp;arg3</code></li>
+     * <li>After calling {@link #get()}, {@code rawRest()} would return <code>arg2&nbsp;&nbsp;arg3</code> (note the
+     * double space - it is preserved!)</li>
+     * <li>After calling {@link #get()} again, {@code rawRest()} would return {@code "arg3"}</li>
+     * <li>After calling {@link #get()} one last time, {@code rawRest()} would return {@code ""}</li>
+     * </ul>
+     *
+     * @return The "raw rest" of the string.
+     */
+    String rawRest();
+
+    /**
+     * @param min The minimum amount of arguments to require.
+     * @throws CommandNotEnoughArgumentsException If there are less than {@code min} arguments left.
+     * @see #requireMax(int)
+     * @see #requireExactly(int)
+     */
+    void requireMin(int min) throws CommandNotEnoughArgumentsException;
+
+    /**
+     * @param max The maximum amount of arguments allowed.
+     * @throws CommandTooManyArgumentsException If there are more than {@code max} arguments left.
+     * @see #requireMin(int)
+     * @see #requireExactly(int)
+     */
+    void requireMax(int max) throws CommandTooManyArgumentsException;
+
+    /**
+     * @param args The exact amount of arguments to require.
+     * @throws CommandNotEnoughArgumentsException If there are less than {@code args} arguments left.
+     * @throws CommandTooManyArgumentsException   If there are more than {@code args} arguments left.
+     * @see #requireMin(int)
+     * @see #requireMax(int)
+     */
+    void requireExactly(int args) throws CommandException;
+
+    /**
+     * @return If this {@link IArgConsumer}} has consumed at least one argument.
+     * @see #consumed()
+     * @see #consumedString()
+     */
+    boolean hasConsumed();
+
+    /**
+     * @return The last argument this {@link IArgConsumer}} has consumed, or an "unknown" argument, indicated by a
+     * comamnd argument index that has a value of {@code -1}, if no arguments have been consumed yet.
+     * @see #consumedString()
+     * @see #hasConsumed()
+     */
+    ICommandArgument consumed();
+
+    /**
+     * @return The value of thelast argument this {@link IArgConsumer}} has consumed, or an empty string if no arguments
+     * have been consumed yet
+     * @see #consumed()
+     * @see #hasConsumed()
+     */
+    String consumedString();
+
+    /**
+     * @return A copy of this {@link IArgConsumer}}. It has the same arguments (both consumed and not), but does not
+     * affect or mutate this instance. Useful for the various {@code peek} functions
+     */
+    IArgConsumer copy();
+}

src/api/java/baritone/api/command/argument/ICommandArgument.java

@@ -0,0 +1,101 @@
+/*
+ * 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.command.argument;
+
+import baritone.api.command.argparser.IArgParser;
+import baritone.api.command.exception.CommandInvalidTypeException;
+import net.minecraft.util.EnumFacing;
+
+/**
+ * A {@link ICommandArgument} is an immutable object representing one command argument. It contains data on the index of
+ * that argument, its value, and the rest of the string that argument was found in
+ * <p>
+ * You're recommended to use {@link IArgConsumer}}s to handle these.
+ *
+ * @author Brady
+ * @since 10/2/2019
+ */
+public interface ICommandArgument {
+
+    /**
+     * @return The index of this command argument in the list of command arguments generated
+     */
+    int getIndex();
+
+    /**
+     * @return The raw value of just this argument
+     */
+    String getValue();
+
+    /**
+     * @return The raw value of the remaining arguments after this one was captured
+     */
+    String getRawRest();
+
+    /**
+     * Gets an enum value from the enum class with the same name as this argument's value
+     * <p>
+     * For example if you getEnum as an {@link EnumFacing}, and this argument's value is "up", it will return {@link
+     * EnumFacing#UP}
+     *
+     * @param enumClass The enum class to search
+     * @return An enum constant of that class with the same name as this argument's value
+     * @throws CommandInvalidTypeException If the constant couldn't be found
+     * @see IArgConsumer#peekEnum(Class)
+     * @see IArgConsumer#peekEnum(Class, int)
+     * @see IArgConsumer#peekEnumOrNull(Class)
+     * @see IArgConsumer#peekEnumOrNull(Class, int)
+     * @see IArgConsumer#getEnum(Class)
+     * @see IArgConsumer#getEnumOrNull(Class)
+     */
+    <E extends Enum<?>> E getEnum(Class<E> enumClass) throws CommandInvalidTypeException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse this argument into the specified class
+     *
+     * @param type The class to parse this argument into
+     * @return An instance of the specified type
+     * @throws CommandInvalidTypeException If the parsing failed
+     */
+    <T> T getAs(Class<T> type) throws CommandInvalidTypeException;
+
+    /**
+     * Tries to use a <b>stateless</b> {@link IArgParser} to parse this argument into the specified class
+     *
+     * @param type The class to parse this argument into
+     * @return If the parser succeeded
+     */
+    <T> boolean is(Class<T> type);
+
+    /**
+     * Tries to use a <b>stated</b> {@link IArgParser} to parse this argument into the specified class
+     *
+     * @param type The class to parse this argument into
+     * @return An instance of the specified type
+     * @throws CommandInvalidTypeException     If the parsing failed
+     */
+    <T, S> T getAs(Class<T> type, Class<S> stateType, S state) throws CommandInvalidTypeException;
+
+    /**
+     * Tries to use a <b>stated</b> {@link IArgParser} to parse this argument into the specified class
+     *
+     * @param type The class to parse this argument into
+     * @return If the parser succeeded
+     */
+    <T, S> boolean is(Class<T> type, Class<S> stateType, S state);
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.helpers.TabCompleteHelper;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import java.util.stream.Stream;
+
+public enum BlockById implements IDatatypeFor<Block> {
+    INSTANCE;
+
+    @Override
+    public Block get(IDatatypeContext ctx) throws CommandException {
+        ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
+        Block block;
+        if ((block = IRegistry.BLOCK.get(id)) == Blocks.AIR) {
+            throw new IllegalArgumentException("no block found by that id");
+        }
+        return block;
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(
+                        IRegistry.BLOCK.keySet()
+                                .stream()
+                                .map(Object::toString)
+                )
+                .filterPrefixNamespaced(ctx.getConsumer().getString())
+                .sortAlphabetically()
+                .stream();
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
+import net.minecraft.entity.EntityType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import java.util.stream.Stream;
+
+public enum EntityClassById implements IDatatypeFor<EntityType> {
+    INSTANCE;
+
+    @Override
+    public EntityType get(IDatatypeContext ctx) throws CommandException {
+        ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
+        EntityType entity;
+        if ((entity = IRegistry.ENTITY_TYPE.get(id)) == null) {
+            throw new IllegalArgumentException("no entity found by that id");
+        }
+        return entity;
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(IRegistry.ENTITY_TYPE.stream().map(Object::toString))
+                .filterPrefixNamespaced(ctx.getConsumer().getString())
+                .sortAlphabetically()
+                .stream();
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.utils.BlockOptionalMeta;
+import baritone.api.command.exception.CommandException;
+
+import java.util.stream.Stream;
+
+public enum ForBlockOptionalMeta implements IDatatypeFor<BlockOptionalMeta> {
+    INSTANCE;
+
+    @Override
+    public BlockOptionalMeta get(IDatatypeContext ctx) throws CommandException {
+        return new BlockOptionalMeta(ctx.getConsumer().getString());
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        return ctx.getConsumer().tabCompleteDatatype(BlockById.INSTANCE);
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.helpers.TabCompleteHelper;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.util.EnumFacing;
+
+import java.util.Locale;
+import java.util.stream.Stream;
+
+public enum ForEnumFacing implements IDatatypeFor<EnumFacing> {
+    INSTANCE;
+
+    @Override
+    public EnumFacing get(IDatatypeContext ctx) throws CommandException {
+        return EnumFacing.valueOf(ctx.getConsumer().getString().toUpperCase(Locale.US));
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(Stream.of(EnumFacing.values())
+                        .map(EnumFacing::getName).map(String::toLowerCase))
+                .filterPrefix(ctx.getConsumer().getString())
+                .stream();
+    }
+}

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

@@ -0,0 +1,81 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.cache.IWaypoint;
+import baritone.api.cache.IWaypointCollection;
+import baritone.api.command.helpers.TabCompleteHelper;
+import baritone.api.command.exception.CommandException;
+
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+public enum ForWaypoints implements IDatatypeFor<IWaypoint[]> {
+    INSTANCE;
+
+    @Override
+    public IWaypoint[] get(IDatatypeContext ctx) throws CommandException {
+        final String input = ctx.getConsumer().getString();
+        final IWaypoint.Tag tag = IWaypoint.Tag.getByName(input);
+
+        // If the input doesn't resolve to a valid tag, resolve by name
+        return tag == null
+                ? getWaypointsByName(ctx.getBaritone(), input)
+                : getWaypointsByTag(ctx.getBaritone(), tag);
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(getWaypointNames(ctx.getBaritone()))
+                .sortAlphabetically()
+                .prepend(IWaypoint.Tag.getAllNames())
+                .filterPrefix(ctx.getConsumer().getString())
+                .stream();
+    }
+
+    public static IWaypointCollection waypoints(IBaritone baritone) {
+        return baritone.getWorldProvider().getCurrentWorld().getWaypoints();
+    }
+
+    public static IWaypoint[] getWaypoints(IBaritone baritone) {
+        return waypoints(baritone).getAllWaypoints().stream()
+                .sorted(Comparator.comparingLong(IWaypoint::getCreationTimestamp).reversed())
+                .toArray(IWaypoint[]::new);
+    }
+
+    public static String[] getWaypointNames(IBaritone baritone) {
+        return Stream.of(getWaypoints(baritone))
+                .map(IWaypoint::getName)
+                .filter(name -> !name.isEmpty())
+                .toArray(String[]::new);
+    }
+
+    public static IWaypoint[] getWaypointsByTag(IBaritone baritone, IWaypoint.Tag tag) {
+        return waypoints(baritone).getByTag(tag).stream()
+                .sorted(Comparator.comparingLong(IWaypoint::getCreationTimestamp).reversed())
+                .toArray(IWaypoint[]::new);
+    }
+
+    public static IWaypoint[] getWaypointsByName(IBaritone baritone, String name) {
+        return Stream.of(getWaypoints(baritone))
+                .filter(waypoint -> waypoint.getName().equalsIgnoreCase(name))
+                .toArray(IWaypoint[]::new);
+    }
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argparser.IArgParser;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+
+import java.util.stream.Stream;
+
+/**
+ * An {@link IDatatype} is similar to an {@link IArgParser} in the sense that it is capable of consuming an argument
+ * to transform it into a usable form as the code desires.
+ * <p>
+ * A fundamental difference is that an {@link IDatatype} is capable of consuming multiple arguments. For example,
+ * {@link RelativeBlockPos} is an {@link IDatatypePost} which requires at least 3 {@link RelativeCoordinate} arguments
+ * to be specified.
+ * <p>
+ * Another difference is that an {@link IDatatype} can be tab-completed, providing comprehensive auto completion
+ * that can substitute based on existing input or provide possibilities for the next piece of input.
+ *
+ * @see IDatatypeContext
+ * @see IDatatypeFor
+ * @see IDatatypePost
+ */
+public interface IDatatype {
+
+    /**
+     * Attempts to complete missing or partial input provided through the {@link IArgConsumer}} provided by
+     * {@link IDatatypeContext#getConsumer()} in order to aide the user in executing commands.
+     * <p>
+     * One benefit over datatypes over {@link IArgParser}s is that instead of each command trying to guess what values
+     * the datatype will accept, or simply not tab completing at all, datatypes that support tab completion can provide
+     * accurate information using the same methods used to parse arguments in the first place.
+     *
+     * @param ctx The argument consumer to tab complete
+     * @return A stream representing the strings that can be tab completed. DO NOT INCLUDE SPACES IN ANY STRINGS.
+     * @see IArgConsumer#tabCompleteDatatype(IDatatype)
+     */
+    Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException;
+}

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

@@ -0,0 +1,47 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.command.argument.IArgConsumer;
+
+/**
+ * Provides an {@link IDatatype} with contextual information so
+ * that it can perform the desired operation on the target level.
+ *
+ * @see IDatatype
+ *
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IDatatypeContext {
+
+    /**
+     * Provides the {@link IBaritone} instance that is associated with the action relating to datatype handling.
+     *
+     * @return The context {@link IBaritone} instance.
+     */
+    IBaritone getBaritone();
+
+    /**
+     * Provides the {@link IArgConsumer}} to fetch input information from.
+     *
+     * @return The context {@link IArgConsumer}}.
+     */
+    IArgConsumer getConsumer();
+}

src/api/java/baritone/api/command/datatypes/IDatatypeFor.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.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+
+import java.util.function.Supplier;
+
+/**
+ * An {@link IDatatype} which acts as a {@link Supplier}, in essence. The only difference
+ * is that it requires an {@link IDatatypeContext} to be provided due to the expectation that
+ * implementations of {@link IDatatype} are singletons.
+ */
+public interface IDatatypeFor<T> extends IDatatype {
+
+    /**
+     * Consumes the desired amount of arguments from the specified {@link IDatatypeContext}, and
+     * then returns the parsed value. This method will more than likely return a {@link IllegalArgumentException}
+     * if the expected input does not conform to a parseable value. As far as a {@link CommandException} being
+     * thrown is concerned, see the note below for specifics.
+     *
+     * @see IDatatypeContext
+     *
+     * @param ctx The context
+     * @return The parsed data-type
+     * @throws CommandException If there was an issue parsing using another type or arguments could not be polled.
+     */
+    T get(IDatatypeContext ctx) throws CommandException;
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+
+import java.util.function.Function;
+
+/**
+ * An {@link IDatatype} which acts as a {@link Function}, in essence. The only difference
+ * is that it requires an {@link IDatatypeContext} to be provided due to the expectation that
+ * implementations of {@link IDatatype} are singletons.
+ */
+public interface IDatatypePost<T, O> extends IDatatype {
+
+    /**
+     * Takes the expected input and transforms it based on the value held by {@code original}. If {@code original}
+     * is null, it is expected that the implementation of this method has a case to handle it, such that a
+     * {@link NullPointerException} will never be thrown as a result.
+     *
+     * @param ctx      The datatype context
+     * @param original The transformable value
+     * @return The transformed value
+     */
+    T apply(IDatatypeContext ctx, O original) throws CommandException;
+}

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

@@ -0,0 +1,29 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.command.datatypes;
+
+import baritone.api.command.exception.CommandException;
+
+/**
+ * @author Brady
+ * @since 9/26/2019
+ */
+public interface IDatatypePostFunction<T, O> {
+
+    T apply(O original) throws CommandException;
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.IBaritone;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.text.ITextComponent;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * An {@link IDatatype} used to resolve nearby players, those within
+ * render distance of the target {@link IBaritone} instance.
+ */
+public enum NearbyPlayer implements IDatatypeFor<EntityPlayer> {
+    INSTANCE;
+
+    @Override
+    public EntityPlayer get(IDatatypeContext ctx) throws CommandException {
+        final String username = ctx.getConsumer().getString();
+        return getPlayers(ctx).stream()
+                .filter(s -> s.getName().getString().equalsIgnoreCase(username))
+                .findFirst().orElse(null);
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        return new TabCompleteHelper()
+                .append(getPlayers(ctx).stream().map(EntityPlayer::getName).map(ITextComponent::getString))
+                .filterPrefix(ctx.getConsumer().getString())
+                .sortAlphabetically()
+                .stream();
+    }
+
+    private static List<EntityPlayer> getPlayers(IDatatypeContext ctx) {
+        return ctx.getBaritone().getPlayerContext().world().playerEntities;
+    }
+}

src/api/java/baritone/api/command/datatypes/RelativeBlockPos.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.api.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.command.exception.CommandException;
+
+import java.util.stream.Stream;
+
+public enum RelativeBlockPos implements IDatatypePost<BetterBlockPos, BetterBlockPos> {
+    INSTANCE;
+
+    @Override
+    public BetterBlockPos apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+        if (origin == null) {
+            origin = BetterBlockPos.ORIGIN;
+        }
+
+        final IArgConsumer consumer = ctx.getConsumer();
+        return new BetterBlockPos(
+                consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.x),
+                consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y),
+                consumer.getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.z)
+        );
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        final IArgConsumer consumer = ctx.getConsumer();
+        if (consumer.hasAny() && !consumer.has(4)) {
+            while (consumer.has(2)) {
+                if (consumer.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) == null) {
+                    break;
+                }
+                consumer.get();
+            }
+            return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+        }
+        return Stream.empty();
+    }
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+public enum RelativeCoordinate implements IDatatypePost<Double, Double> {
+    INSTANCE;
+    private static Pattern PATTERN = Pattern.compile("^(~?)([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)([k-k]?)|)$");
+
+    @Override
+    public Double apply(IDatatypeContext ctx, Double origin) throws CommandException {
+        if (origin == null) {
+            origin = 0.0D;
+        }
+
+        Matcher matcher = PATTERN.matcher(ctx.getConsumer().getString());
+        if (!matcher.matches()) {
+            throw new IllegalArgumentException("pattern doesn't match");
+        }
+
+        boolean isRelative = !matcher.group(1).isEmpty();
+
+        double offset = matcher.group(2).isEmpty() ? 0 : Double.parseDouble(matcher.group(2).replaceAll("k", ""));
+
+        if (matcher.group(2).contains("k")) {
+            offset *= 1000;
+        }
+
+        if (isRelative) {
+            return origin + offset;
+        }
+        return offset;
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        final IArgConsumer consumer = ctx.getConsumer();
+        if (!consumer.has(2) && consumer.getString().matches("^(~|$)")) {
+            return Stream.of("~");
+        }
+        return Stream.empty();
+    }
+}

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

@@ -0,0 +1,103 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.FileSystems;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Path;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import static baritone.api.utils.Helper.HELPER;
+
+public enum RelativeFile implements IDatatypePost<File, File> {
+    INSTANCE;
+
+    @Override
+    public File apply(IDatatypeContext ctx, File original) throws CommandException {
+        if (original == null) {
+            original = new File("./");
+        }
+
+        Path path;
+        try {
+            path = FileSystems.getDefault().getPath(ctx.getConsumer().getString());
+        } catch (InvalidPathException e) {
+            throw new IllegalArgumentException("invalid path");
+        }
+        return getCanonicalFileUnchecked(original.toPath().resolve(path).toFile());
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        return Stream.empty();
+    }
+
+    /**
+     * Seriously
+     *
+     * @param file File
+     * @return Canonical file of file
+     * @author LoganDark
+     */
+    private static File getCanonicalFileUnchecked(File file) {
+        try {
+            return file.getCanonicalFile();
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    public static Stream<String> tabComplete(IArgConsumer consumer, File base0) throws CommandException {
+        // I will not make the caller deal with this, seriously
+        // Tab complete code is beautiful and I'm not going to bloat it with dumb ass checked exception bullshit -LoganDark
+
+        // lol owned -Brady
+
+        File base = getCanonicalFileUnchecked(base0);
+        String currentPathStringThing = consumer.getString();
+        Path currentPath = FileSystems.getDefault().getPath(currentPathStringThing);
+        Path basePath = currentPath.isAbsolute() ? currentPath.getRoot() : base.toPath();
+        boolean useParent = !currentPathStringThing.isEmpty() && !currentPathStringThing.endsWith(File.separator);
+        File currentFile = currentPath.isAbsolute() ? currentPath.toFile() : new File(base, currentPathStringThing);
+        return Stream.of(Objects.requireNonNull(getCanonicalFileUnchecked(
+                useParent
+                        ? currentFile.getParentFile()
+                        : currentFile
+        ).listFiles()))
+                .map(f -> (currentPath.isAbsolute() ? f : basePath.relativize(f.toPath()).toString()) +
+                        (f.isDirectory() ? File.separator : ""))
+                .filter(s -> s.toLowerCase(Locale.US).startsWith(currentPathStringThing.toLowerCase(Locale.US)))
+                .filter(s -> !s.contains(" "));
+    }
+
+    public static File gameDir() {
+        File gameDir = HELPER.mc.gameDir.getAbsoluteFile();
+        if (gameDir.getName().equals(".")) {
+            return gameDir.getParentFile();
+        }
+        return gameDir;
+    }
+}

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

@@ -0,0 +1,79 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.pathing.goals.GoalYLevel;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+public enum RelativeGoal implements IDatatypePost<Goal, BetterBlockPos> {
+    INSTANCE;
+
+    @Override
+    public Goal apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+        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
+            }
+        }
+
+        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());
+        }
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        return ctx.getConsumer().tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.pathing.goals.GoalBlock;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalBlock implements IDatatypePost<GoalBlock, BetterBlockPos> {
+    INSTANCE;
+
+    @Override
+    public GoalBlock apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+        if (origin == null) {
+            origin = BetterBlockPos.ORIGIN;
+        }
+
+        final IArgConsumer consumer = ctx.getConsumer();
+        return new GoalBlock(
+                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))
+        );
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        final IArgConsumer consumer = ctx.getConsumer();
+        if (consumer.hasAtMost(3)) {
+            return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+        }
+        return Stream.empty();
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.pathing.goals.GoalXZ;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalXZ implements IDatatypePost<GoalXZ, BetterBlockPos> {
+    INSTANCE;
+
+    @Override
+    public GoalXZ apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+        if (origin == null) {
+            origin = BetterBlockPos.ORIGIN;
+        }
+
+        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))
+        );
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        final IArgConsumer consumer = ctx.getConsumer();
+        if (consumer.hasAtMost(2)) {
+            return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+        }
+        return Stream.empty();
+    }
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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.command.datatypes;
+
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.pathing.goals.GoalYLevel;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.command.exception.CommandException;
+import net.minecraft.util.math.MathHelper;
+
+import java.util.stream.Stream;
+
+public enum RelativeGoalYLevel implements IDatatypePost<GoalYLevel, BetterBlockPos> {
+    INSTANCE;
+
+    @Override
+    public GoalYLevel apply(IDatatypeContext ctx, BetterBlockPos origin) throws CommandException {
+        if (origin == null) {
+            origin = BetterBlockPos.ORIGIN;
+        }
+
+        return new GoalYLevel(
+                MathHelper.floor(ctx.getConsumer().getDatatypePost(RelativeCoordinate.INSTANCE, (double) origin.y))
+        );
+    }
+
+    @Override
+    public Stream<String> tabComplete(IDatatypeContext ctx) {
+        final IArgConsumer consumer = ctx.getConsumer();
+        if (consumer.hasAtMost(1)) {
+            return consumer.tabCompleteDatatype(RelativeCoordinate.INSTANCE);
+        }
+        return Stream.empty();
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public abstract class CommandErrorMessageException extends CommandException {
+
+    protected CommandErrorMessageException(String reason) {
+        super(reason);
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public abstract class CommandException extends Exception implements ICommandException {
+
+    protected CommandException(String reason) {
+        super(reason);
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.command.argument.ICommandArgument;
+
+public abstract class CommandInvalidArgumentException extends CommandErrorMessageException {
+
+    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
+        ));
+        this.arg = arg;
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandInvalidStateException extends CommandErrorMessageException {
+
+    public CommandInvalidStateException(String reason) {
+        super(reason);
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.command.argument.ICommandArgument;
+
+public class CommandInvalidTypeException extends CommandInvalidArgumentException {
+
+    public CommandInvalidTypeException(ICommandArgument arg, String expected) {
+        super(arg, String.format("Expected %s", expected));
+    }
+
+    public CommandInvalidTypeException(ICommandArgument arg, String expected, Throwable cause) {
+        super(arg, String.format("Expected %s.\nMore details: %s", expected, cause.getMessage()));
+    }
+
+    public CommandInvalidTypeException(ICommandArgument arg, String expected, String got) {
+        super(arg, String.format("Expected %s, but got %s instead", expected, got));
+    }
+
+    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()));
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandNoParserForTypeException extends CommandUnhandledException {
+
+    public CommandNoParserForTypeException(Class<?> klass) {
+        super(String.format("Could not find a handler for type %s", klass.getSimpleName()));
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandNotEnoughArgumentsException extends CommandErrorMessageException {
+
+    public CommandNotEnoughArgumentsException(int minArgs) {
+        super(String.format("Not enough arguments (expected at least %d)", minArgs));
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.command.ICommand;
+import baritone.api.command.argument.ICommandArgument;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+public class CommandNotFoundException extends CommandException {
+
+    public final String command;
+
+    public CommandNotFoundException(String command) {
+        super(String.format("Command not found: %s", command));
+        this.command = command;
+    }
+
+    @Override
+    public void handle(ICommand command, List<ICommandArgument> args) {
+        HELPER.logDirect(getMessage());
+    }
+}

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

@@ -0,0 +1,25 @@
+/*
+ * 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.command.exception;
+
+public class CommandTooManyArgumentsException extends CommandErrorMessageException {
+
+    public CommandTooManyArgumentsException(int maxArgs) {
+        super(String.format("Too many arguments (expected at most %d)", maxArgs));
+    }
+}

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

@@ -0,0 +1,46 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.command.ICommand;
+import baritone.api.command.argument.ICommandArgument;
+import net.minecraft.util.text.TextFormatting;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+public class CommandUnhandledException extends RuntimeException implements ICommandException {
+
+    public CommandUnhandledException(String message) {
+        super(message);
+    }
+
+    public CommandUnhandledException(Throwable cause) {
+        super(cause);
+    }
+
+    @Override
+    public void handle(ICommand command, List<ICommandArgument> args) {
+        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);
+
+        this.printStackTrace();
+    }
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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.command.exception;
+
+import baritone.api.command.ICommand;
+import baritone.api.command.argument.ICommandArgument;
+import net.minecraft.util.text.TextFormatting;
+
+import java.util.List;
+
+import static baritone.api.utils.Helper.HELPER;
+
+/**
+ * The base for a Baritone Command Exception, checked or unchecked. Provides a
+ * {@link #handle(ICommand, List)} method that is used to provide useful output
+ * to the user for diagnosing issues that may have occurred during execution.
+ * <p>
+ * Anything implementing this interface should be assignable to {@link Exception}.
+ *
+ * @author Brady
+ * @since 9/20/2019
+ */
+public interface ICommandException {
+
+    /**
+     * @see Exception#getMessage()
+     * @return The exception details
+     */
+    String getMessage();
+
+    /**
+     * Called when this exception is thrown, to handle the exception.
+     *
+     * @param command The command that threw it.
+     * @param args    The arguments the command was called with.
+     */
+    default void handle(ICommand command, List<ICommandArgument> args) {
+        HELPER.logDirect(this.getMessage(), TextFormatting.RED);
+    }
+}

src/api/java/baritone/api/command/helpers/Paginator.java

@@ -0,0 +1,184 @@
+/*
+ * 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.command.helpers;
+
+import baritone.api.utils.Helper;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.exception.CommandInvalidTypeException;
+import baritone.api.command.argument.IArgConsumer;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.event.ClickEvent;
+import net.minecraft.util.text.event.HoverEvent;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+public class Paginator<E> implements Helper {
+
+    public final List<E> entries;
+    public int pageSize = 8;
+    public int page = 1;
+
+    public Paginator(List<E> entries) {
+        this.entries = entries;
+    }
+
+    public Paginator(E... entries) {
+        this.entries = Arrays.asList(entries);
+    }
+
+    public Paginator<E> setPageSize(int pageSize) {
+        this.pageSize = pageSize;
+        return this;
+    }
+
+    public int getMaxPage() {
+        return (entries.size() - 1) / pageSize + 1;
+    }
+
+    public boolean validPage(int page) {
+        return page > 0 && page <= getMaxPage();
+    }
+
+    public Paginator<E> skipPages(int pages) {
+        page += pages;
+        return this;
+    }
+
+    public void display(Function<E, ITextComponent> transform, String commandPrefix) {
+        int offset = (page - 1) * pageSize;
+        for (int i = offset; i < offset + pageSize; i++) {
+            if (i < entries.size()) {
+                logDirect(transform.apply(entries.get(i)));
+            } else {
+                logDirect("--", TextFormatting.DARK_GRAY);
+            }
+        }
+        boolean hasPrevPage = commandPrefix != null && validPage(page - 1);
+        boolean hasNextPage = commandPrefix != null && validPage(page + 1);
+        ITextComponent prevPageComponent = new TextComponentString("<<");
+        if (hasPrevPage) {
+            prevPageComponent.getStyle()
+                    .setClickEvent(new ClickEvent(
+                            ClickEvent.Action.RUN_COMMAND,
+                            String.format("%s %d", commandPrefix, page - 1)
+                    ))
+                    .setHoverEvent(new HoverEvent(
+                            HoverEvent.Action.SHOW_TEXT,
+                            new TextComponentString("Click to view previous page")
+                    ));
+        } else {
+            prevPageComponent.getStyle().setColor(TextFormatting.DARK_GRAY);
+        }
+        ITextComponent nextPageComponent = new TextComponentString(">>");
+        if (hasNextPage) {
+            nextPageComponent.getStyle()
+                    .setClickEvent(new ClickEvent(
+                            ClickEvent.Action.RUN_COMMAND,
+                            String.format("%s %d", commandPrefix, page + 1)
+                    ))
+                    .setHoverEvent(new HoverEvent(
+                            HoverEvent.Action.SHOW_TEXT,
+                            new TextComponentString("Click to view next page")
+                    ));
+        } else {
+            nextPageComponent.getStyle().setColor(TextFormatting.DARK_GRAY);
+        }
+        ITextComponent pagerComponent = new TextComponentString("");
+        pagerComponent.getStyle().setColor(TextFormatting.GRAY);
+        pagerComponent.appendSibling(prevPageComponent);
+        pagerComponent.appendText(" | ");
+        pagerComponent.appendSibling(nextPageComponent);
+        pagerComponent.appendText(String.format(" %d/%d", page, getMaxPage()));
+        logDirect(pagerComponent);
+    }
+
+    public void display(Function<E, ITextComponent> transform) {
+        display(transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, Paginator<T> pagi, Runnable pre, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        int page = 1;
+        consumer.requireMax(1);
+        if (consumer.hasAny()) {
+            page = consumer.getAs(Integer.class);
+            if (!pagi.validPage(page)) {
+                throw new CommandInvalidTypeException(
+                        consumer.consumed(),
+                        String.format(
+                                "a valid page (1-%d)",
+                                pagi.getMaxPage()
+                        ),
+                        consumer.consumed().getValue()
+                );
+            }
+        }
+        pagi.skipPages(page - pagi.page);
+        if (pre != null) {
+            pre.run();
+        }
+        pagi.display(transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, List<T> elems, Runnable pre, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        paginate(consumer, new Paginator<>(elems), pre, transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, T[] elems, Runnable pre, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        paginate(consumer, Arrays.asList(elems), pre, transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, Paginator<T> pagi, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        paginate(consumer, pagi, null, transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, List<T> elems, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        paginate(consumer, new Paginator<>(elems), null, transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, T[] elems, Function<T, ITextComponent> transform, String commandPrefix) throws CommandException {
+        paginate(consumer, Arrays.asList(elems), null, transform, commandPrefix);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, Paginator<T> pagi, Runnable pre, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, pagi, pre, transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, List<T> elems, Runnable pre, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, new Paginator<>(elems), pre, transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, T[] elems, Runnable pre, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, Arrays.asList(elems), pre, transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, Paginator<T> pagi, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, pagi, null, transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, List<T> elems, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, new Paginator<>(elems), null, transform, null);
+    }
+
+    public static <T> void paginate(IArgConsumer consumer, T[] elems, Function<T, ITextComponent> transform) throws CommandException {
+        paginate(consumer, Arrays.asList(elems), null, transform, null);
+    }
+}

src/api/java/baritone/api/command/helpers/TabCompleteHelper.java

@@ -0,0 +1,288 @@
+/*
+ * 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.command.helpers;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.Settings;
+import baritone.api.event.events.TabCompleteEvent;
+import baritone.api.utils.SettingsUtil;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.manager.ICommandManager;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+/**
+ * The {@link TabCompleteHelper} is a <b>single-use</b> object that helps you handle tab completion. It includes helper
+ * methods for appending and prepending streams, sorting, filtering by prefix, and so on.
+ * <p>
+ * The recommended way to use this class is:
+ * <ul>
+ * <li>Create a new instance with the empty constructor</li>
+ * <li>Use {@code append}, {@code prepend} or {@code add<something>} methods to add completions</li>
+ * <li>Sort using {@link #sort(Comparator)} or {@link #sortAlphabetically()} and then filter by prefix using
+ * {@link #filterPrefix(String)}</li>
+ * <li>Get the stream using {@link #stream()}</li>
+ * <li>Pass it up to whatever's calling your tab complete function (i.e.
+ * {@link ICommandManager#tabComplete(String)} or {@link IArgConsumer}#tabCompleteDatatype(IDatatype)})</li>
+ * </ul>
+ * <p>
+ * For advanced users: if you're intercepting {@link TabCompleteEvent}s directly, use {@link #build()} instead for an
+ * array.
+ */
+public class TabCompleteHelper {
+
+    private Stream<String> stream;
+
+    public TabCompleteHelper(String[] base) {
+        stream = Stream.of(base);
+    }
+
+    public TabCompleteHelper(List<String> base) {
+        stream = base.stream();
+    }
+
+    public TabCompleteHelper() {
+        stream = Stream.empty();
+    }
+
+    /**
+     * Appends the specified stream to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param source The stream to append
+     * @return This {@link TabCompleteHelper} after having appended the stream
+     * @see #append(String...)
+     * @see #append(Class)
+     */
+    public TabCompleteHelper append(Stream<String> source) {
+        stream = Stream.concat(stream, source);
+        return this;
+    }
+
+    /**
+     * Appends the specified strings to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param source The stream to append
+     * @return This {@link TabCompleteHelper} after having appended the strings
+     * @see #append(Stream)
+     * @see #append(Class)
+     */
+    public TabCompleteHelper append(String... source) {
+        return append(Stream.of(source));
+    }
+
+    /**
+     * Appends all values of the specified enum to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param num The enum to append the values of
+     * @return This {@link TabCompleteHelper} after having appended the values
+     * @see #append(Stream)
+     * @see #append(String...)
+     */
+    public TabCompleteHelper append(Class<? extends Enum<?>> num) {
+        return append(
+                Stream.of(num.getEnumConstants())
+                        .map(Enum::name)
+                        .map(String::toLowerCase)
+        );
+    }
+
+    /**
+     * Prepends the specified stream to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param source The stream to prepend
+     * @return This {@link TabCompleteHelper} after having prepended the stream
+     * @see #prepend(String...)
+     * @see #prepend(Class)
+     */
+    public TabCompleteHelper prepend(Stream<String> source) {
+        stream = Stream.concat(source, stream);
+        return this;
+    }
+
+    /**
+     * Prepends the specified strings to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param source The stream to prepend
+     * @return This {@link TabCompleteHelper} after having prepended the strings
+     * @see #prepend(Stream)
+     * @see #prepend(Class)
+     */
+    public TabCompleteHelper prepend(String... source) {
+        return prepend(Stream.of(source));
+    }
+
+    /**
+     * Prepends all values of the specified enum to this {@link TabCompleteHelper} and returns it for chaining
+     *
+     * @param num The enum to prepend the values of
+     * @return This {@link TabCompleteHelper} after having prepended the values
+     * @see #prepend(Stream)
+     * @see #prepend(String...)
+     */
+    public TabCompleteHelper prepend(Class<? extends Enum<?>> num) {
+        return prepend(
+                Stream.of(num.getEnumConstants())
+                        .map(Enum::name)
+                        .map(String::toLowerCase)
+        );
+    }
+
+    /**
+     * Apply the specified {@code transform} to every element <b>currently</b> in this {@link TabCompleteHelper} and
+     * return this object for chaining
+     *
+     * @param transform The transform to apply
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper map(Function<String, String> transform) {
+        stream = stream.map(transform);
+        return this;
+    }
+
+    /**
+     * Apply the specified {@code filter} to every element <b>currently</b> in this {@link TabCompleteHelper} and return
+     * this object for chaining
+     *
+     * @param filter The filter to apply
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper filter(Predicate<String> filter) {
+        stream = stream.filter(filter);
+        return this;
+    }
+
+    /**
+     * Apply the specified {@code sort} to every element <b>currently</b> in this {@link TabCompleteHelper} and return
+     * this object for chaining
+     *
+     * @param comparator The comparator to use
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper sort(Comparator<String> comparator) {
+        stream = stream.sorted(comparator);
+        return this;
+    }
+
+    /**
+     * Sort every element <b>currently</b> in this {@link TabCompleteHelper} alphabetically and return this object for
+     * chaining
+     *
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper sortAlphabetically() {
+        return sort(String.CASE_INSENSITIVE_ORDER);
+    }
+
+    /**
+     * Filter out any element that doesn't start with {@code prefix} and return this object for chaining
+     *
+     * @param prefix The prefix to filter for
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper filterPrefix(String prefix) {
+        return filter(x -> x.toLowerCase(Locale.US).startsWith(prefix.toLowerCase(Locale.US)));
+    }
+
+    /**
+     * Filter out any element that doesn't start with {@code prefix} and return this object for chaining
+     * <p>
+     * Assumes every element in this {@link TabCompleteHelper} is a {@link ResourceLocation}
+     *
+     * @param prefix The prefix to filter for
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper filterPrefixNamespaced(String prefix) {
+        return filterPrefix(new ResourceLocation(prefix).toString());
+    }
+
+    /**
+     * @return An array containing every element in this {@link TabCompleteHelper}
+     * @see #stream()
+     */
+    public String[] build() {
+        return stream.toArray(String[]::new);
+    }
+
+    /**
+     * @return A stream containing every element in this {@link TabCompleteHelper}
+     * @see #build()
+     */
+    public Stream<String> stream() {
+        return stream;
+    }
+
+    /**
+     * Appends every command in the specified {@link ICommandManager} to this {@link TabCompleteHelper}
+     *
+     * @param manager A command manager
+     *
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper addCommands(ICommandManager manager) {
+        return append(manager.getRegistry().descendingStream()
+                .flatMap(command -> command.getNames().stream())
+                .distinct()
+        );
+    }
+
+    /**
+     * Appends every setting in the {@link Settings} to this {@link TabCompleteHelper}
+     *
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper addSettings() {
+        return append(
+                BaritoneAPI.getSettings().allSettings.stream()
+                        .map(Settings.Setting::getName)
+                        .filter(s -> !s.equalsIgnoreCase("logger"))
+                        .sorted(String.CASE_INSENSITIVE_ORDER)
+        );
+    }
+
+    /**
+     * Appends every modified setting in the {@link Settings} to this {@link TabCompleteHelper}
+     *
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper addModifiedSettings() {
+        return append(
+                SettingsUtil.modifiedSettings(BaritoneAPI.getSettings()).stream()
+                        .map(Settings.Setting::getName)
+                        .sorted(String.CASE_INSENSITIVE_ORDER)
+        );
+    }
+
+    /**
+     * Appends every {@link Boolean} setting in the {@link Settings} to this {@link TabCompleteHelper}
+     *
+     * @return This {@link TabCompleteHelper}
+     */
+    public TabCompleteHelper addToggleableSettings() {
+        return append(
+                BaritoneAPI.getSettings().getAllValuesByType(Boolean.class).stream()
+                        .map(Settings.Setting::getName)
+                        .sorted(String.CASE_INSENSITIVE_ORDER)
+        );
+    }
+}

src/api/java/baritone/api/command/manager/ICommandManager.java

@@ -0,0 +1,52 @@
+/*
+ * 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.command.manager;
+
+import baritone.api.IBaritone;
+import baritone.api.command.ICommand;
+import baritone.api.command.argument.ICommandArgument;
+import baritone.api.command.registry.Registry;
+import net.minecraft.util.Tuple;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * @author Brady
+ * @since 9/21/2019
+ */
+public interface ICommandManager {
+
+    IBaritone getBaritone();
+
+    Registry<ICommand> getRegistry();
+
+    /**
+     * @param name The command name to search for.
+     * @return The command, if found.
+     */
+    ICommand getCommand(String name);
+
+    boolean execute(String string);
+
+    boolean execute(Tuple<String, List<ICommandArgument>> expanded);
+
+    Stream<String> tabComplete(Tuple<String, List<ICommandArgument>> expanded);
+
+    Stream<String> tabComplete(String prefix);
+}

src/api/java/baritone/api/command/registry/Registry.java

@@ -0,0 +1,135 @@
+/*
+ * 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.command.registry;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * This registry class allows for registration and unregistration of a certain type. This is mainly designed for use by
+ * event handlers where newly registered ones are encountered first during iteration and can therefore override older
+ * ones. In Baritone, this is used for commands and argument parsers so that mods and addons can extend Baritone's
+ * functionality without resorting to hacks, wrappers, or mixins.
+ *
+ * @param <V> The entry type that will be stored in this registry. This can be anything, really - preferably anything
+ *            that works as a HashMap key, as that's what's used to keep track of which entries are registered or not.
+ */
+public class Registry<V> {
+
+    /**
+     * An internal linked list of all the entries that are currently registered. This is a linked list so that entries
+     * can be inserted at the beginning, which means that newer entries are encountered first during iteration. This is
+     * an important property of the registry that makes it more useful than a simple list, and also the reason it does
+     * not just use a map.
+     */
+    private final Deque<V> _entries = new LinkedList<>();
+    /**
+     * A HashSet containing every entry currently registered. Entries are added to this set when something is registered
+     * and removed from the set when they are unregistered. An entry being present in this set indicates that it is
+     * currently registered, can be removed, and should not be reregistered until it is removed.
+     */
+    private final Set<V> registered = new HashSet<>();
+    /**
+     * The collection of entries that are currently in this registry. This is a collection (and not a list) because,
+     * internally, entries are stored in a linked list, which is not the same as a normal list.
+     */
+    public final Collection<V> entries = Collections.unmodifiableCollection(_entries);
+
+    /**
+     * @param entry The entry to check.
+     * @return If this entry is currently registered in this registry.
+     */
+    public boolean registered(V entry) {
+        return registered.contains(entry);
+    }
+
+    /**
+     * Ensures that the entry {@code entry} is registered.
+     *
+     * @param entry The entry to register.
+     * @return A boolean indicating whether or not this is a new registration. No matter the value of this boolean, the
+     * entry is always guaranteed to now be in this registry. This boolean simply indicates if the entry was <i>not</i>
+     * in the map prior to this method call.
+     */
+    public boolean register(V entry) {
+        if (!registered(entry)) {
+            _entries.addFirst(entry);
+            registered.add(entry);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Unregisters this entry from this registry. After this method call, the entry is guaranteed to be removed from the
+     * registry, since each entry only ever appears once.
+     *
+     * @param entry The entry to unregister.
+     */
+    public void unregister(V entry) {
+        if (registered(entry)) {
+            return;
+        }
+        _entries.remove(entry);
+        registered.remove(entry);
+    }
+
+    /**
+     * Returns an iterator that iterates over each entry in this registry, with the newest elements iterated over first.
+     * Internally, as new elements are prepended to the registry rather than appended to the end, this order is the best
+     * way to search through the registry if you want to discover newer items first.
+     */
+    public Iterator<V> iterator() {
+        return _entries.iterator();
+    }
+
+    /**
+     * Returns an iterator that iterates over each entry in this registry, in the order they were added. Internally,
+     * this iterates through the registry backwards, as new elements are prepended to the registry rather than appended
+     * to the end. You should only do this when you need to, for example, list elements in order - it is almost always
+     * fine to simply use {@link Iterable#forEach(Consumer) forEach} on the {@link #entries} collection instead.
+     */
+    public Iterator<V> descendingIterator() {
+        return _entries.descendingIterator();
+    }
+
+    /**
+     * Returns a stream that contains each entry in this registry, with the newest elements ordered first. Internally,
+     * as new elements are prepended to the registry rather than appended to the end, this order is the best way to
+     * search through the registry if you want to discover newer items first.
+     */
+    public Stream<V> stream() {
+        return _entries.stream();
+    }
+
+    /**
+     * Returns a stream that returns each entry in this registry, in the order they were added. Internally, this orders
+     * the registry backwards, as new elements are prepended to the registry rather than appended to the end. You should
+     * only use this when you need to, for example, list elements in order - it is almost always fine to simply use the
+     * regular {@link #stream()} method instead.
+     */
+    public Stream<V> descendingStream() {
+        return StreamSupport.stream(Spliterators.spliterator(
+                descendingIterator(),
+                _entries.size(),
+                Spliterator.SIZED | Spliterator.SUBSIZED
+        ), false);
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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.event.events;
+
+import baritone.api.event.events.type.Cancellable;
+import baritone.api.event.events.type.Overrideable;
+
+/**
+ * @author LoganDark
+ */
+public final class TabCompleteEvent extends Cancellable {
+
+    public final String prefix;
+    public String[] completions;
+
+    public TabCompleteEvent(String prefix) {
+        this.prefix = prefix;
+        this.completions = null;
+    }
+}

src/api/java/baritone/api/event/events/type/Overrideable.java

@@ -0,0 +1,53 @@
+/*
+ * 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.event.events.type;
+
+/**
+ * @author LoganDark
+ */
+public class Overrideable<T> {
+
+    private T value;
+    private boolean modified;
+
+    public Overrideable(T current) {
+        value = current;
+    }
+
+    public T get() {
+        return value;
+    }
+
+    public void set(T newValue) {
+        value = newValue;
+        modified = true;
+    }
+
+    public boolean wasModified() {
+        return modified;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "Overrideable{modified=%b,value=%s}",
+                modified,
+                value.toString()
+        );
+    }
+}

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

@@ -39,6 +39,9 @@ public interface AbstractGameEventListener extends IGameEventListener {
     @Override
     default void onSendChatMessage(ChatEvent event) {}
 
+    @Override
+    default void onPreTabComplete(TabCompleteEvent event) {}
+
     @Override
     default void onChunkEvent(ChunkEvent event) {}
 

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

@@ -56,6 +56,13 @@ public interface IGameEventListener {
      */
     void onSendChatMessage(ChatEvent event);
 
+    /**
+     * Runs whenever the client player tries to tab complete in chat.
+     *
+     * @param event The event
+     */
+    void onPreTabComplete(TabCompleteEvent event);
+
     /**
      * Runs before and after whenever a chunk is either loaded, unloaded, or populated.
      *

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
@@ -67,7 +68,12 @@ public class GoalBlock implements Goal, IGoalRenderPos {
 
     @Override
     public String toString() {
-        return "GoalBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
+        return String.format(
+                "GoalBlock{x=%s,y=%s,z=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z)
+        );
     }
 
     /**

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
@@ -61,6 +62,11 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
 
     @Override
     public String toString() {
-        return "GoalGetToBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
+        return String.format(
+                "GoalGetToBlock{x=%s,y=%s,z=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z)
+        );
     }
 }

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

@@ -0,0 +1,52 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.pathing.goals;
+
+/**
+ * Invert any goal.
+ * <p>
+ * In the old chat control system, #invert just tried to pick a {@link GoalRunAway} that <i>effectively</i> inverted the
+ * current goal. This goal just reverses the heuristic to act as a TRUE invert. Inverting a Y level? Baritone tries to
+ * get away from that Y level. Inverting a GoalBlock? Baritone will try to make distance whether it's in the X, Y or Z
+ * directions. And of course, you can always invert a GoalXZ.
+ *
+ * @author LoganDark
+ */
+public class GoalInverted implements Goal {
+
+    public final Goal origin;
+
+    public GoalInverted(Goal origin) {
+        this.origin = origin;
+    }
+
+    @Override
+    public boolean isInGoal(int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public double heuristic(int x, int y, int z) {
+        return -origin.heuristic(x, y, z);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("GoalInverted{%s}", origin.toString());
+    }
+}

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

@@ -17,10 +17,12 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
 public class GoalNear implements Goal, IGoalRenderPos {
+
     private final int x;
     private final int y;
     private final int z;
@@ -56,11 +58,12 @@ public class GoalNear implements Goal, IGoalRenderPos {
 
     @Override
     public String toString() {
-        return "GoalNear{" +
-                "x=" + x +
-                ", y=" + y +
-                ", z=" + z +
-                ", rangeSq=" + rangeSq +
-                "}";
+        return String.format(
+                "GoalNear{x=%s, y=%s, z=%s, rangeSq=%d}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z),
+                rangeSq
+        );
     }
 }

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.Arrays;
@@ -82,7 +83,11 @@ public class GoalRunAway implements Goal {
     @Override
     public String toString() {
         if (maintainY != null) {
-            return "GoalRunAwayFromMaintainY y=" + maintainY + ", " + Arrays.asList(from);
+            return String.format(
+                    "GoalRunAwayFromMaintainY y=%s, %s",
+                    SettingsUtil.maybeCensor(maintainY),
+                    Arrays.asList(from)
+            );
         } else {
             return "GoalRunAwayFrom" + Arrays.asList(from);
         }

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 
@@ -24,6 +25,7 @@ import net.minecraft.util.math.BlockPos;
  * Dig a tunnel in a certain direction, but if you have to deviate from the path, go back to where you started
  */
 public class GoalStrictDirection implements Goal {
+
     public final int x;
     public final int y;
     public final int z;
@@ -64,12 +66,13 @@ public class GoalStrictDirection implements Goal {
 
     @Override
     public String toString() {
-        return "GoalStrictDirection{" +
-                "x=" + x +
-                ", y=" + y +
-                ", z=" + z +
-                ", dx=" + dx +
-                ", dz=" + dz +
-                "}";
+        return String.format(
+                "GoalStrictDirection{x=%s, y=%s, z=%s, dx=%s, dz=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z),
+                SettingsUtil.maybeCensor(dx),
+                SettingsUtil.maybeCensor(dz)
+        );
     }
 }

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
@@ -73,6 +74,11 @@ public class GoalTwoBlocks implements Goal, IGoalRenderPos {
 
     @Override
     public String toString() {
-        return "GoalTwoBlocks{x=" + x + ",y=" + y + ",z=" + z + "}";
+        return String.format(
+                "GoalTwoBlocks{x=%s,y=%s,z=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z)
+        );
     }
 }

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

@@ -18,6 +18,8 @@
 package baritone.api.pathing.goals;
 
 import baritone.api.BaritoneAPI;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.SettingsUtil;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 
@@ -45,6 +47,11 @@ public class GoalXZ implements Goal {
         this.z = z;
     }
 
+    public GoalXZ(BetterBlockPos pos) {
+        this.x = pos.x;
+        this.z = pos.z;
+    }
+
     @Override
     public boolean isInGoal(int x, int y, int z) {
         return x == this.x && z == this.z;
@@ -59,7 +66,11 @@ public class GoalXZ implements Goal {
 
     @Override
     public String toString() {
-        return "GoalXZ{x=" + x + ",z=" + z + "}";
+        return String.format(
+                "GoalXZ{x=%s,z=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(z)
+        );
     }
 
     public static double calculate(double xDiff, double zDiff) {
@@ -87,7 +98,7 @@ public class GoalXZ implements Goal {
         float theta = (float) Math.toRadians(yaw);
         double x = origin.x - MathHelper.sin(theta) * distance;
         double z = origin.z + MathHelper.cos(theta) * distance;
-        return new GoalXZ((int) x, (int) z);
+        return new GoalXZ(MathHelper.floor(x), MathHelper.floor(z));
     }
 
     public int getX() {

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

@@ -18,6 +18,7 @@
 package baritone.api.pathing.goals;
 
 import baritone.api.pathing.movement.ActionCosts;
+import baritone.api.utils.SettingsUtil;
 
 /**
  * Useful for mining (getting to diamond / iron level)
@@ -59,6 +60,9 @@ public class GoalYLevel implements Goal, ActionCosts {
 
     @Override
     public String toString() {
-        return "GoalYLevel{y=" + level + "}";
+        return String.format(
+                "GoalYLevel{y=%s}",
+                SettingsUtil.maybeCensor(level)
+        );
     }
 }

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

@@ -17,12 +17,14 @@
 
 package baritone.api.process;
 
-import baritone.api.utils.ISchematic;
+import baritone.api.schematic.ISchematic;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3i;
 
 import java.io.File;
+import java.util.List;
 
 /**
  * @author Brady
@@ -58,7 +60,16 @@ public interface IBuilderProcess extends IBaritoneProcess {
 
     void pause();
 
+    boolean isPaused();
+
     void resume();
 
     void clearArea(BlockPos corner1, BlockPos corner2);
+
+    /**
+     * @return A list of block states that are estimated to be placeable by this builder process. You can use this in
+     * schematics, for example, to pick a state that the builder process will be happy with, because any variation will
+     * cause it to give up. This is updated every tick, but only while the builder process is active.
+     */
+    List<IBlockState> getApproxPlaceable();
 }

src/api/java/baritone/api/process/IExploreProcess.java

@@ -20,6 +20,7 @@ package baritone.api.process;
 import java.nio.file.Path;
 
 public interface IExploreProcess extends IBaritoneProcess {
+
     void explore(int centerX, int centerZ);
 
     void applyJsonFilter(Path path, boolean invert) throws Exception;

src/api/java/baritone/api/process/IFarmProcess.java

@@ -18,5 +18,6 @@
 package baritone.api.process;
 
 public interface IFarmProcess extends IBaritoneProcess {
+
     void farm();
 }

src/api/java/baritone/api/process/IGetToBlockProcess.java

@@ -17,6 +17,7 @@
 
 package baritone.api.process;
 
+import baritone.api.utils.BlockOptionalMeta;
 import net.minecraft.block.Block;
 
 /**
@@ -24,7 +25,11 @@ import net.minecraft.block.Block;
  */
 public interface IGetToBlockProcess extends IBaritoneProcess {
 
-    void getToBlock(Block block);
+    void getToBlock(BlockOptionalMeta block);
+
+    default void getToBlock(Block block) {
+        getToBlock(new BlockOptionalMeta(block));
+    }
 
     boolean blacklistClosest();
 }

src/api/java/baritone/api/process/IMineProcess.java

@@ -17,8 +17,12 @@
 
 package baritone.api.process;
 
+import baritone.api.utils.BlockOptionalMeta;
+import baritone.api.utils.BlockOptionalMetaLookup;
 import net.minecraft.block.Block;
 
+import java.util.stream.Stream;
+
 /**
  * @author Brady
  * @since 9/23/2018
@@ -28,9 +32,9 @@ public interface IMineProcess extends IBaritoneProcess {
     /**
      * Begin to search for and mine the specified blocks until
      * the number of specified items to get from the blocks that
-     * are mined. This is based on the first target block to mine.
+     * are mined.
      *
-     * @param quantity The number of items to get from blocks mined
+     * @param quantity The total number of items to get
      * @param blocks   The blocks to mine
      */
     void mineByName(int quantity, String... blocks);
@@ -41,9 +45,18 @@ public interface IMineProcess extends IBaritoneProcess {
      * are mined. This is based on the first target block to mine.
      *
      * @param quantity The number of items to get from blocks mined
-     * @param blocks   The blocks to mine
+     * @param filter   The blocks to mine
      */
-    void mine(int quantity, Block... blocks);
+    void mine(int quantity, BlockOptionalMetaLookup filter);
+
+    /**
+     * Begin to search for and mine the specified blocks.
+     *
+     * @param filter The blocks to mine
+     */
+    default void mine(BlockOptionalMetaLookup filter) {
+        mine(0, filter);
+    }
 
     /**
      * Begin to search for and mine the specified blocks.
@@ -54,6 +67,38 @@ public interface IMineProcess extends IBaritoneProcess {
         mineByName(0, blocks);
     }
 
+    /**
+     * Begin to search for and mine the specified blocks.
+     *
+     * @param boms The blocks to mine
+     */
+    default void mine(int quantity, BlockOptionalMeta... boms) {
+        mine(quantity, new BlockOptionalMetaLookup(boms));
+    }
+
+    /**
+     * Begin to search for and mine the specified blocks.
+     *
+     * @param boms The blocks to mine
+     */
+    default void mine(BlockOptionalMeta... boms) {
+        mine(0, boms);
+    }
+
+    /**
+     * Begin to search for and mine the specified blocks.
+     *
+     * @param quantity The total number of items to get
+     * @param blocks   The blocks to mine
+     */
+    default void mine(int quantity, Block... blocks) {
+        mine(quantity, new BlockOptionalMetaLookup(
+                Stream.of(blocks)
+                        .map(BlockOptionalMeta::new)
+                        .toArray(BlockOptionalMeta[]::new)
+        ));
+    }
+
     /**
      * Begin to search for and mine the specified blocks.
      *

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

@@ -0,0 +1,46 @@
+/*
+ * 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;
+
+public abstract class AbstractSchematic implements ISchematic {
+
+    protected int x;
+    protected int y;
+    protected int z;
+
+    public AbstractSchematic(int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public int widthX() {
+        return x;
+    }
+
+    @Override
+    public int heightY() {
+        return y;
+    }
+
+    @Override
+    public int lengthZ() {
+        return z;
+    }
+}

src/api/java/baritone/api/schematic/CompositeSchematic.java

@@ -0,0 +1,74 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CompositeSchematic extends AbstractSchematic {
+
+    private final List<CompositeSchematicEntry> schematics;
+    private CompositeSchematicEntry[] schematicArr;
+
+    private void recalcArr() {
+        schematicArr = schematics.toArray(new CompositeSchematicEntry[0]);
+        for (CompositeSchematicEntry entry : schematicArr) {
+            this.x = Math.max(x, entry.x + entry.schematic.widthX());
+            this.y = Math.max(y, entry.y + entry.schematic.heightY());
+            this.z = Math.max(z, entry.z + entry.schematic.lengthZ());
+        }
+    }
+
+    public CompositeSchematic(int x, int y, int z) {
+        super(x, y, z);
+        schematics = new ArrayList<>();
+        recalcArr();
+    }
+
+    public void put(ISchematic extra, int x, int y, int z) {
+        schematics.add(new CompositeSchematicEntry(extra, x, y, z));
+        recalcArr();
+    }
+
+    private CompositeSchematicEntry getSchematic(int x, int y, int z, IBlockState currentState) {
+        for (CompositeSchematicEntry entry : schematicArr) {
+            if (x >= entry.x && y >= entry.y && z >= entry.z &&
+                    entry.schematic.inSchematic(x - entry.x, y - entry.y, z - entry.z, currentState)) {
+                return entry;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
+        CompositeSchematicEntry entry = getSchematic(x, y, z, currentState);
+        return entry != null && entry.schematic.inSchematic(x - entry.x, y - entry.y, z - entry.z, currentState);
+    }
+
+    @Override
+    public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
+        CompositeSchematicEntry entry = getSchematic(x, y, z, current);
+        if (entry == null) {
+            throw new IllegalStateException("couldn't find schematic for this position");
+        }
+        return entry.schematic.desiredState(x - entry.x, y - entry.y, z - entry.z, current, approxPlaceable);
+    }
+}

src/api/java/baritone/api/schematic/CompositeSchematicEntry.java

@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+public class CompositeSchematicEntry {
+
+    public final ISchematic schematic;
+    public final int x;
+    public final int y;
+    public final int z;
+
+    public CompositeSchematicEntry(ISchematic schematic, int x, int y, int z) {
+        this.schematic = schematic;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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.utils.BlockOptionalMeta;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Blocks;
+
+import java.util.List;
+
+public class FillSchematic extends AbstractSchematic {
+
+    private final BlockOptionalMeta bom;
+
+    public FillSchematic(int x, int y, int z, BlockOptionalMeta bom) {
+        super(x, y, z);
+        this.bom = bom;
+    }
+
+    public BlockOptionalMeta getBom() {
+        return bom;
+    }
+
+    @Override
+    public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
+        if (bom.matches(current)) {
+            return current;
+        } else if (current.getBlock() != Blocks.AIR) {
+            return Blocks.AIR.getDefaultState();
+        }
+        for (IBlockState placeable : approxPlaceable) {
+            if (bom.matches(placeable)) {
+                return placeable;
+            }
+        }
+        return bom.getAnyBlockState();
+    }
+}

src/api/java/baritone/api/schematic/ISchematic.java

@@ -15,14 +15,16 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.utils;
+package baritone.api.schematic;
 
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.EnumFacing;
 
+import java.util.List;
+
 /**
- * Basic representation of a schematic. Provides the dimensions and
- * the desired statefor a given position relative to the origin.
+ * Basic representation of a schematic. Provides the dimensions and the desired state for a given position relative to
+ * the origin.
  *
  * @author leijurv
  */
@@ -36,12 +38,13 @@ public interface ISchematic {
      * However, in the case of something like a map art, anything that's below the level of the map art doesn't matter,
      * so this function should return false in that case. (i.e. it doesn't really have to be air below the art blocks)
      *
-     * @param x The x position of the block, relative to the origin
-     * @param y The y position of the block, relative to the origin
-     * @param z The z position of the block, relative to the origin
+     * @param x            The x position of the block, relative to the origin
+     * @param y            The y position of the block, relative to the origin
+     * @param z            The z position of the block, relative to the origin
+     * @param currentState The current state of that block in the world, or null
      * @return Whether or not the specified position is within the bounds of this schematic
      */
-    default boolean inSchematic(int x, int y, int z) {
+    default boolean inSchematic(int x, int y, int z, IBlockState currentState) {
         return x >= 0 && x < widthX() && y >= 0 && y < heightY() && z >= 0 && z < lengthZ();
     }
 
@@ -61,12 +64,14 @@ public interface ISchematic {
     /**
      * Returns the desired block state at a given (X, Y, Z) position relative to the origin (0, 0, 0).
      *
-     * @param x The x position of the block, relative to the origin
-     * @param y The y position of the block, relative to the origin
-     * @param z The z position of the block, relative to the origin
+     * @param x               The x position of the block, relative to the origin
+     * @param y               The y position of the block, relative to the origin
+     * @param z               The z position of the block, relative to the origin
+     * @param current         The current state of that block in the world, or null
+     * @param approxPlaceable The list of blockstates estimated to be placeable
      * @return The desired block state at the specified position
      */
-    IBlockState desiredState(int x, int y, int z);
+    IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable);
 
     /**
      * @return The width (X axis length) of this schematic
@@ -82,4 +87,4 @@ public interface ISchematic {
      * @return The length (Z axis length) of this schematic
      */
     int lengthZ();
-}
+}

src/api/java/baritone/api/schematic/MaskSchematic.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 net.minecraft.block.state.IBlockState;
+
+import java.util.List;
+
+public abstract class MaskSchematic extends AbstractSchematic {
+
+    private final ISchematic schematic;
+
+    public MaskSchematic(ISchematic schematic) {
+        super(schematic.widthX(), schematic.heightY(), schematic.lengthZ());
+        this.schematic = schematic;
+    }
+
+    protected abstract boolean partOfMask(int x, int y, int z, IBlockState currentState);
+
+    @Override
+    public boolean inSchematic(int x, int y, int z, IBlockState currentState) {
+        return schematic.inSchematic(x, y, z, currentState) && partOfMask(x, y, z, currentState);
+    }
+
+    @Override
+    public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
+        return schematic.desiredState(x, y, z, current, approxPlaceable);
+    }
+}

src/api/java/baritone/api/schematic/ReplaceSchematic.java

@@ -0,0 +1,41 @@
+/*
+ * 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.utils.BlockOptionalMetaLookup;
+import net.minecraft.block.state.IBlockState;
+
+public class ReplaceSchematic extends MaskSchematic {
+
+    private final BlockOptionalMetaLookup filter;
+    private final Boolean[][][] cache;
+
+    public ReplaceSchematic(ISchematic schematic, BlockOptionalMetaLookup filter) {
+        super(schematic);
+        this.filter = filter;
+        this.cache = new Boolean[widthX()][heightY()][lengthZ()];
+    }
+
+    @Override
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        if (cache[x][y][z] == null) {
+            cache[x][y][z] = filter.has(currentState);
+        }
+        return cache[x][y][z];
+    }
+}

src/api/java/baritone/api/schematic/ShellSchematic.java

@@ -0,0 +1,32 @@
+/*
+ * 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;
+
+public class ShellSchematic extends MaskSchematic {
+
+    public ShellSchematic(ISchematic schematic) {
+        super(schematic);
+    }
+
+    @Override
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return x == 0 || y == 0 || z == 0 || x == widthX() - 1 || y == heightY() - 1 || z == lengthZ() - 1;
+    }
+}

src/api/java/baritone/api/schematic/WallsSchematic.java

@@ -0,0 +1,32 @@
+/*
+ * 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;
+
+public class WallsSchematic extends MaskSchematic {
+
+    public WallsSchematic(ISchematic schematic) {
+        super(schematic);
+    }
+
+    @Override
+    protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return x == 0 || z == 0 || x == widthX() - 1 || z == lengthZ() - 1;
+    }
+}

src/api/java/baritone/api/selection/ISelection.java

@@ -0,0 +1,91 @@
+/*
+ * 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.selection;
+
+import baritone.api.utils.BetterBlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.Vec3i;
+
+/**
+ * A selection is an immutable object representing the current selection. The selection is commonly used for certain
+ * types of build commands, however it can be used for anything.
+ */
+public interface ISelection {
+
+    /**
+     * @return The first corner of this selection. This is meant to preserve the user's original first corner.
+     */
+    BetterBlockPos pos1();
+
+    /**
+     * @return The second corner of this selection. This is meant to preserve the user's original second corner.
+     */
+    BetterBlockPos pos2();
+
+    /**
+     * @return The {@link BetterBlockPos} with the lowest x, y, and z position in the selection.
+     */
+    BetterBlockPos min();
+
+    /**
+     * @return The opposite corner from the {@link #min()}.
+     */
+    BetterBlockPos max();
+
+    /**
+     * @return The size of this ISelection.
+     */
+    Vec3i size();
+
+    /**
+     * @return An {@link AxisAlignedBB} encompassing all blocks in this selection.
+     */
+    AxisAlignedBB aabb();
+
+    /**
+     * Returns a new {@link ISelection} expanded in the specified direction by the specified number of blocks.
+     *
+     * @param direction The direction to expand the selection.
+     * @param blocks    How many blocks to expand it.
+     * @return A new selection, expanded as specified.
+     */
+    ISelection expand(EnumFacing direction, int blocks);
+
+    /**
+     * Returns a new {@link ISelection} contracted in the specified direction by the specified number of blocks.
+     * <p>
+     * Note that, for example, if the direction specified is UP, the bottom of the selection will be shifted up. If it
+     * is DOWN, the top of the selection will be shifted down.
+     *
+     * @param direction The direction to contract the selection.
+     * @param blocks    How many blocks to contract it.
+     * @return A new selection, contracted as specified.
+     */
+    ISelection contract(EnumFacing direction, int blocks);
+
+    /**
+     * Returns a new {@link ISelection} shifted in the specified direction by the specified number of blocks. This moves
+     * the whole selection.
+     *
+     * @param direction The direction to shift the selection.
+     * @param blocks    How many blocks to shift it.
+     * @return A new selection, shifted as specified.
+     */
+    ISelection shift(EnumFacing direction, int blocks);
+}

src/api/java/baritone/api/selection/ISelectionManager.java

@@ -0,0 +1,116 @@
+/*
+ * 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.selection;
+
+import baritone.api.utils.BetterBlockPos;
+import net.minecraft.util.EnumFacing;
+
+/**
+ * The selection manager handles setting Baritone's selections. You can set the selection here, as well as retrieving
+ * the current selection.
+ */
+public interface ISelectionManager {
+
+    /**
+     * Adds a new selection. The added selection is returned.
+     *
+     * @param selection The new selection to add.
+     */
+    ISelection addSelection(ISelection selection);
+
+    /**
+     * Adds a new {@link ISelection} constructed from the given block positions. The new selection is returned.
+     *
+     * @param pos1 One corner of the selection
+     * @param pos2 The new corner of the selection
+     */
+    ISelection addSelection(BetterBlockPos pos1, BetterBlockPos pos2);
+
+    /**
+     * Removes the selection from the current selections.
+     *
+     * @param selection The selection to remove.
+     * @return The removed selection.
+     */
+    ISelection removeSelection(ISelection selection);
+
+    /**
+     * Removes all selections.
+     *
+     * @return The selections that were removed, sorted from oldest to newest..
+     */
+    ISelection[] removeAllSelections();
+
+    /**
+     * @return The current selections, sorted from oldest to newest.
+     */
+    ISelection[] getSelections();
+
+    /**
+     * For anything expecting only one selection, this method is provided. However, to enforce multi-selection support,
+     * this method will only return a selection if there is ONLY one.
+     *
+     * @return The only selection, or null if there isn't only one.
+     */
+    ISelection getOnlySelection();
+
+    /**
+     * This method will always return the last selection. ONLY use this if you want to, for example, modify the most
+     * recent selection based on user input. ALWAYS use {@link #getOnlySelection()} or, ideally,
+     * {@link #getSelections()} for retrieving the content of selections.
+     *
+     * @return The last selection, or null if it doesn't exist.
+     */
+    ISelection getLastSelection();
+
+    /**
+     * Replaces the specified {@link ISelection} with one expanded in the specified direction by the specified number of
+     * blocks. Returns the new selection.
+     *
+     * @param selection The selection to expand.
+     * @param direction The direction to expand the selection.
+     * @param blocks    How many blocks to expand it.
+     * @return The new selection, expanded as specified.
+     */
+    ISelection expand(ISelection selection, EnumFacing direction, int blocks);
+
+    /**
+     * Replaces the specified {@link ISelection} with one contracted in the specified direction by the specified number
+     * of blocks.
+     * <p>
+     * Note that, for example, if the direction specified is UP, the bottom of the selection will be shifted up. If it
+     * is DOWN, the top of the selection will be shifted down.
+     *
+     * @param selection The selection to contract.
+     * @param direction The direction to contract the selection.
+     * @param blocks    How many blocks to contract it.
+     * @return The new selection, contracted as specified.
+     */
+    ISelection contract(ISelection selection, EnumFacing direction, int blocks);
+
+    /**
+     * Replaces the specified {@link ISelection} with one shifted in the specified direction by the specified number of
+     * blocks. This moves the whole selection.
+     *
+     * @param selection The selection to shift.
+     * @param direction The direction to shift the selection.
+     * @param blocks    How many blocks to shift it.
+     * @return The new selection, shifted as specified.
+     */
+    ISelection shift(ISelection selection, EnumFacing direction, int blocks);
+}

src/api/java/baritone/api/utils/BetterBlockPos.java

@@ -22,6 +22,8 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3i;
 
+import javax.annotation.Nonnull;
+
 /**
  * A better BlockPos that has fewer hash collisions (and slightly more performant offsets)
  * <p>
@@ -32,6 +34,9 @@ import net.minecraft.util.math.Vec3i;
  * @author leijurv
  */
 public final class BetterBlockPos extends BlockPos {
+
+    public static final BetterBlockPos ORIGIN = new BetterBlockPos(0, 0, 0);
+
     public final int x;
     public final int y;
     public final int z;
@@ -51,6 +56,20 @@ public final class BetterBlockPos extends BlockPos {
         this(pos.getX(), pos.getY(), pos.getZ());
     }
 
+    /**
+     * Like constructor but returns null if pos is null, good if you just need to possibly censor coordinates
+     *
+     * @param pos The BlockPos, possibly null, to convert
+     * @return A BetterBlockPos or null if pos was null
+     */
+    public static BetterBlockPos from(BlockPos pos) {
+        if (pos == null) {
+            return null;
+        }
+
+        return new BetterBlockPos(pos);
+    }
+
     @Override
     public int hashCode() {
         return (int) longHash(x, y, z);
@@ -182,4 +201,15 @@ public final class BetterBlockPos extends BlockPos {
     public BetterBlockPos west(int amt) {
         return amt == 0 ? this : new BetterBlockPos(x - amt, y, z);
     }
+
+    @Override
+    @Nonnull
+    public String toString() {
+        return String.format(
+                "BetterBlockPos{x=%s,y=%s,z=%s}",
+                SettingsUtil.maybeCensor(x),
+                SettingsUtil.maybeCensor(y),
+                SettingsUtil.maybeCensor(z)
+        );
+    }
 }

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

@@ -0,0 +1,270 @@
+/*
+ * 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.utils;
+
+import baritone.api.utils.accessor.IItemStack;
+import com.google.common.collect.ImmutableSet;
+import net.minecraft.block.*;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.state.IProperty;
+import net.minecraft.state.properties.*;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.IRegistry;
+
+import javax.annotation.Nonnull;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class BlockOptionalMeta {
+
+    private final Block block;
+    private final Set<IBlockState> blockstates;
+    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;
+        this.blockstates = getStates(block);
+        this.stateHashes = getStateHashes(blockstates);
+        this.stackHashes = getStackHashes(blockstates);
+    }
+
+    public BlockOptionalMeta(@Nonnull String selector) {
+        Matcher matcher = pattern.matcher(selector);
+
+        if (!matcher.find()) {
+            throw new IllegalArgumentException("invalid block selector");
+        }
+
+        MatchResult matchResult = matcher.toMatchResult();
+
+        ResourceLocation id = new ResourceLocation(matchResult.group(1));
+
+        if (!IRegistry.BLOCK.containsKey(id)) {
+            throw new IllegalArgumentException("Invalid block ID");
+        }
+
+        block = IRegistry.BLOCK.get(id);
+        blockstates = getStates(block);
+        stateHashes = getStateHashes(blockstates);
+        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());
+    }
+
+    private static ImmutableSet<Integer> getStateHashes(Set<IBlockState> blockstates) {
+        return ImmutableSet.copyOf(
+                blockstates.stream()
+                        .map(IBlockState::hashCode)
+                        .toArray(Integer[]::new)
+        );
+    }
+
+    private static ImmutableSet<Integer> getStackHashes(Set<IBlockState> blockstates) {
+        //noinspection ConstantConditions
+        return ImmutableSet.copyOf(
+                blockstates.stream()
+                        .map(state -> new ItemStack(
+                                state.getBlock().getItemDropped(state, null, null, 0).asItem(),
+                                1
+                        ))
+                        .map(stack -> ((IItemStack) (Object) stack).getBaritoneHash())
+                        .toArray(Integer[]::new)
+        );
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+
+    public boolean matches(@Nonnull Block block) {
+        return block == this.block;
+    }
+
+    public boolean matches(@Nonnull IBlockState blockstate) {
+        Block block = blockstate.getBlock();
+        return block == this.block && stateHashes.contains(blockstate.hashCode());
+    }
+
+    public boolean matches(ItemStack stack) {
+        //noinspection ConstantConditions
+        int hash = ((IItemStack) (Object) stack).getBaritoneHash();
+
+        hash -= stack.getDamage();
+
+        return stackHashes.contains(hash);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("BlockOptionalMeta{block=%s}", block);
+    }
+
+    public IBlockState getAnyBlockState() {
+        if (blockstates.size() > 0) {
+            return blockstates.iterator().next();
+        }
+
+        return null;
+    }
+}

src/api/java/baritone/api/utils/BlockOptionalMetaLookup.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.api.utils;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.item.ItemStack;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class BlockOptionalMetaLookup {
+
+    private final BlockOptionalMeta[] boms;
+
+    public BlockOptionalMetaLookup(BlockOptionalMeta... boms) {
+        this.boms = boms;
+    }
+
+    public BlockOptionalMetaLookup(Block... blocks) {
+        this.boms = Stream.of(blocks)
+                .map(BlockOptionalMeta::new)
+                .toArray(BlockOptionalMeta[]::new);
+    }
+
+    public BlockOptionalMetaLookup(List<Block> blocks) {
+        this.boms = blocks.stream()
+                .map(BlockOptionalMeta::new)
+                .toArray(BlockOptionalMeta[]::new);
+    }
+
+    public BlockOptionalMetaLookup(String... blocks) {
+        this.boms = Stream.of(blocks)
+                .map(BlockOptionalMeta::new)
+                .toArray(BlockOptionalMeta[]::new);
+    }
+
+    public boolean has(Block block) {
+        for (BlockOptionalMeta bom : boms) {
+            if (bom.getBlock() == block) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean has(IBlockState state) {
+        for (BlockOptionalMeta bom : boms) {
+            if (bom.matches(state)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean has(ItemStack stack) {
+        for (BlockOptionalMeta bom : boms) {
+            if (bom.matches(stack)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public List<BlockOptionalMeta> blocks() {
+        return Arrays.asList(boms);
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "BlockOptionalMetaLookup{%s}",
+                Arrays.toString(boms)
+        );
+    }
+}

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

@@ -23,9 +23,9 @@ import net.minecraft.util.registry.IRegistry;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Objects;
 
 public class BlockUtils {
+
     private static transient Map<String, Block> resourceCache = new HashMap<>();
 
     public static String blockToString(Block block) {
@@ -40,7 +40,11 @@ public class BlockUtils {
 
     public static Block stringToBlockRequired(String name) {
         Block block = stringToBlockNullable(name);
-        Objects.requireNonNull(block);
+
+        if (block == null) {
+            throw new IllegalArgumentException(String.format("Invalid block name %s", name));
+        }
+
         return block;
     }
 

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

@@ -1,712 +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.api.utils;
-
-import baritone.api.BaritoneAPI;
-import baritone.api.IBaritone;
-import baritone.api.Settings;
-import baritone.api.behavior.IPathingBehavior;
-import baritone.api.cache.IRememberedInventory;
-import baritone.api.cache.IWaypoint;
-import baritone.api.cache.Waypoint;
-import baritone.api.event.events.ChatEvent;
-import baritone.api.event.listener.AbstractGameEventListener;
-import baritone.api.pathing.goals.*;
-import baritone.api.process.IBaritoneProcess;
-import baritone.api.process.ICustomGoalProcess;
-import baritone.api.process.IGetToBlockProcess;
-import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ChunkProviderClient;
-import net.minecraft.crash.CrashReport;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.text.ITextComponent;
-import net.minecraft.util.text.TextComponentString;
-import net.minecraft.util.text.TextFormatting;
-import net.minecraft.util.text.event.ClickEvent;
-import net.minecraft.world.chunk.Chunk;
-
-import java.nio.file.Path;
-import java.util.*;
-
-public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
-    private static final String COMMAND_PREFIX = "#";
-
-    public final IBaritone baritone;
-    public final IPlayerContext ctx;
-
-    public ExampleBaritoneControl(IBaritone baritone) {
-        this.baritone = baritone;
-        this.ctx = baritone.getPlayerContext();
-        baritone.getGameEventHandler().registerEventListener(this);
-    }
-
-    @Override
-    public void onSendChatMessage(ChatEvent event) {
-        String msg = event.getMessage();
-        if (BaritoneAPI.getSettings().prefixControl.value && msg.startsWith(COMMAND_PREFIX)) {
-            if (!runCommand(msg.substring(COMMAND_PREFIX.length()))) {
-                logDirect("Invalid command");
-            }
-            event.cancel(); // always cancel if using prefixControl
-            return;
-        }
-        if (!BaritoneAPI.getSettings().chatControl.value && !BaritoneAPI.getSettings().removePrefix.value) {
-            return;
-        }
-        if (runCommand(msg)) {
-            event.cancel();
-        }
-    }
-
-    public boolean runCommand(String msg0) { // you may think this can be private, but impcat calls it from .b =)
-        String msg = msg0.toLowerCase(Locale.US).trim(); // don't reassign the argument LOL
-        IPathingBehavior pathingBehavior = baritone.getPathingBehavior();
-        ICustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
-        List<Settings.Setting<Boolean>> toggleable = BaritoneAPI.getSettings().getAllValuesByType(Boolean.class);
-        for (Settings.Setting<Boolean> setting : toggleable) {
-            if (msg.equalsIgnoreCase(setting.getName())) {
-                setting.value ^= true;
-                logDirect("Toggled " + setting.getName() + " to " + setting.value);
-                SettingsUtil.save(BaritoneAPI.getSettings());
-                return true;
-            }
-        }
-        if (msg.equals("baritone") || msg.equals("modifiedsettings") || msg.startsWith("settings m") || msg.equals("modified")) {
-            logDirect("All settings that have been modified from their default values:");
-            for (Settings.Setting<?> setting : SettingsUtil.modifiedSettings(BaritoneAPI.getSettings())) {
-                logDirect(setting.toString());
-            }
-            return true;
-        }
-        if (msg.startsWith("settings")) {
-            String rest = msg.substring("settings".length());
-            try {
-                int page = Integer.parseInt(rest.trim());
-                int min = page * 10;
-                int max = Math.min(BaritoneAPI.getSettings().allSettings.size(), (page + 1) * 10);
-                logDirect("Settings " + min + " to " + (max - 1) + ":");
-                for (int i = min; i < max; i++) {
-                    logDirect(BaritoneAPI.getSettings().allSettings.get(i).toString());
-                }
-            } catch (Exception ex) { // NumberFormatException | ArrayIndexOutOfBoundsException and probably some others I'm forgetting lol
-                ex.printStackTrace();
-                logDirect("All settings:");
-                for (Settings.Setting<?> setting : BaritoneAPI.getSettings().allSettings) {
-                    logDirect(setting.toString());
-                }
-                logDirect("To get one page of ten settings at a time, do settings <num>");
-            }
-            return true;
-        }
-        if (msg.equals("") || msg.equals("help") || msg.equals("?")) {
-            ITextComponent component = MESSAGE_PREFIX.shallowCopy();
-            component.getStyle().setColor(TextFormatting.GRAY);
-            TextComponentString helpLink = new TextComponentString(" Click here for instructions on how to use Baritone (https://github.com/cabaletta/baritone/blob/master/USAGE.md)");
-            helpLink.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, "https://github.com/cabaletta/baritone/blob/master/USAGE.md"));
-            component.appendSibling(helpLink);
-            BaritoneAPI.getSettings().logger.value.accept(component);
-            return true;
-        }
-        if (msg.contains(" ")) {
-            String settingName = msg.substring(0, msg.indexOf(' '));
-            String settingValue = msg.substring(msg.indexOf(' ') + 1);
-            Settings.Setting setting = BaritoneAPI.getSettings().byLowerName.get(settingName);
-            if (setting != null) {
-                if (settingValue.equals("reset")) {
-                    logDirect("Resetting setting " + settingName + " to default value.");
-                    setting.reset();
-                } else {
-                    try {
-                        SettingsUtil.parseAndApply(BaritoneAPI.getSettings(), settingName, settingValue);
-                    } catch (Exception ex) {
-                        logDirect("Unable to parse setting");
-                        return true;
-                    }
-                }
-                SettingsUtil.save(BaritoneAPI.getSettings());
-                logDirect(setting.toString());
-                return true;
-            }
-        }
-        if (BaritoneAPI.getSettings().byLowerName.containsKey(msg)) {
-            Settings.Setting<?> setting = BaritoneAPI.getSettings().byLowerName.get(msg);
-            logDirect(setting.toString());
-            return true;
-        }
-
-        if (msg.startsWith("goal")) {
-            String rest = msg.substring(4).trim();
-            Goal goal;
-            if (rest.equals("clear") || rest.equals("none")) {
-                goal = null;
-            } else {
-                String[] params = rest.split(" ");
-                if (params[0].equals("")) {
-                    params = new String[]{};
-                }
-                goal = parseGoal(params);
-                if (goal == null) {
-                    return true;
-                }
-            }
-            customGoalProcess.setGoal(goal);
-            logDirect("Goal: " + goal);
-            return true;
-        }
-        if (msg.equals("crash")) {
-            StringBuilder meme = new StringBuilder();
-            CrashReport rep = new CrashReport("Manually triggered debug crash", new Throwable());
-            mc.addGraphicsAndWorldToCrashReport(rep);
-            rep.getSectionsInStringBuilder(meme);
-            System.out.println(meme);
-            logDirect(meme.toString());
-            logDirect("ok");
-            return true;
-        }
-        if (msg.equals("path")) {
-            if (pathingBehavior.getGoal() == null) {
-                logDirect("No goal.");
-            } else if (pathingBehavior.getGoal().isInGoal(ctx.playerFeet())) {
-                logDirect("Already in goal");
-            } else if (pathingBehavior.isPathing()) {
-                logDirect("Currently executing a path. Please cancel it first.");
-            } else {
-                customGoalProcess.setGoalAndPath(pathingBehavior.getGoal());
-            }
-            return true;
-        }
-        /*if (msg.equals("fullpath")) {
-            if (pathingBehavior.getGoal() == null) {
-                logDirect("No goal.");
-            } else {
-                logDirect("Started segmented calculator");
-                SegmentedCalculator.calculateSegmentsThreaded(pathingBehavior.pathStart(), pathingBehavior.getGoal(), new CalculationContext(baritone, true), ipath -> {
-                    logDirect("Found a path");
-                    logDirect("Ends at " + ipath.getDest());
-                    logDirect("Length " + ipath.length());
-                    logDirect("Estimated time " + ipath.ticksRemainingFrom(0));
-                    pathingBehavior.secretCursedFunctionDoNotCall(ipath); // it's okay when *I* do it
-                }, () -> {
-                    logDirect("Path calculation failed, no path");
-                });
-            }
-            return true;
-        }*/
-        if (msg.equals("proc")) {
-            Optional<IBaritoneProcess> proc = baritone.getPathingControlManager().mostRecentInControl();
-            if (!proc.isPresent()) {
-                logDirect("No process is in control");
-                return true;
-            }
-            IBaritoneProcess p = proc.get();
-            logDirect("Class: " + p.getClass());
-            logDirect("Priority: " + p.priority());
-            logDirect("Temporary: " + p.isTemporary());
-            logDirect("Display name: " + p.displayName());
-            logDirect("Command: " + baritone.getPathingControlManager().mostRecentCommand());
-            return true;
-        }
-        if (msg.equals("version")) {
-            String version = ExampleBaritoneControl.class.getPackage().getImplementationVersion();
-            if (version == null) {
-                logDirect("No version detected. Either dev environment or broken install.");
-            } else {
-                logDirect("You are using Baritone v" + version);
-            }
-            return true;
-        }
-        if (msg.equals("repack") || msg.equals("rescan")) {
-            ChunkProviderClient cli = (ChunkProviderClient) ctx.world().getChunkProvider();
-            int playerChunkX = ctx.playerFeet().getX() >> 4;
-            int playerChunkZ = ctx.playerFeet().getZ() >> 4;
-            int count = 0;
-            for (int x = playerChunkX - 40; x <= playerChunkX + 40; x++) {
-                for (int z = playerChunkZ - 40; z <= playerChunkZ + 40; z++) {
-                    Chunk chunk = cli.getChunk(x, z, false, false);
-                    if (chunk != null) {
-                        count++;
-                        baritone.getWorldProvider().getCurrentWorld().getCachedWorld().queueForPacking(chunk);
-                    }
-                }
-            }
-            logDirect("Queued " + count + " chunks for repacking");
-            return true;
-        }
-        if (msg.startsWith("build")) {
-            String file;
-            BlockPos origin;
-            try {
-                String[] coords = msg.substring("build".length()).trim().split(" ");
-                file = coords[0] + ".schematic";
-                origin = new BlockPos(parseOrDefault(coords[1], ctx.playerFeet().x), parseOrDefault(coords[2], ctx.playerFeet().y), parseOrDefault(coords[3], ctx.playerFeet().z));
-            } catch (Exception ex) {
-                file = msg.substring(5).trim() + ".schematic";
-                origin = ctx.playerFeet();
-            }
-            logDirect("Loading '" + file + "' to build from origin " + origin);
-            boolean success = baritone.getBuilderProcess().build(file, origin);
-            logDirect(success ? "Loaded" : "Unable to load");
-            return true;
-        }
-        if (msg.startsWith("schematica")) {
-            baritone.getBuilderProcess().buildOpenSchematic();
-            return true;
-        }
-        if (msg.equals("come")) {
-            customGoalProcess.setGoalAndPath(new GoalBlock(new BlockPos(Helper.mc.getRenderViewEntity())));
-            logDirect("Coming");
-            return true;
-        }
-        if (msg.equals("axis") || msg.equals("highway")) {
-            customGoalProcess.setGoalAndPath(new GoalAxis());
-            return true;
-        }
-        if (msg.equals("cancel") || msg.equals("stop")) {
-            pathingBehavior.cancelEverything();
-            logDirect("ok canceled");
-            return true;
-        }
-        if (msg.equals("forcecancel")) {
-            pathingBehavior.cancelEverything();
-            pathingBehavior.forceCancel();
-            logDirect("ok force canceled");
-            return true;
-        }
-        if (msg.equals("gc")) {
-            System.gc();
-            logDirect("Called System.gc();");
-            return true;
-        }
-        if (msg.equals("invert")) {
-            Goal goal = pathingBehavior.getGoal();
-            BlockPos runAwayFrom;
-            if (goal instanceof GoalXZ) {
-                runAwayFrom = new BlockPos(((GoalXZ) goal).getX(), 0, ((GoalXZ) goal).getZ());
-            } else if (goal instanceof GoalBlock) {
-                runAwayFrom = ((GoalBlock) goal).getGoalPos();
-            } else {
-                logDirect("Goal must be GoalXZ or GoalBlock to invert");
-                logDirect("Inverting goal of player feet");
-                runAwayFrom = ctx.playerFeet();
-            }
-            customGoalProcess.setGoalAndPath(new GoalRunAway(1, runAwayFrom) {
-                @Override
-                public boolean isInGoal(int x, int y, int z) {
-                    return false;
-                }
-            });
-            return true;
-        }
-        if (msg.startsWith("cleararea")) {
-            String suffix = msg.substring("cleararea".length());
-            BlockPos corner1;
-            BlockPos corner2;
-            if (suffix.isEmpty()) {
-                // clear the area from the current goal to here
-                Goal goal = baritone.getPathingBehavior().getGoal();
-                if (!(goal instanceof GoalBlock)) {
-                    logDirect("Need to specify goal of opposite corner");
-                    return true;
-                }
-                corner1 = ((GoalBlock) goal).getGoalPos();
-                corner2 = ctx.playerFeet();
-            } else {
-                try {
-                    String[] spl = suffix.split(" ");
-                    corner1 = ctx.playerFeet();
-                    corner2 = new BlockPos(Integer.parseInt(spl[0]), Integer.parseInt(spl[1]), Integer.parseInt(spl[2]));
-                } catch (NumberFormatException | ArrayIndexOutOfBoundsException | NullPointerException ex) {
-                    logDirect("unable to parse");
-                    return true;
-                }
-            }
-            baritone.getBuilderProcess().clearArea(corner1, corner2);
-            return true;
-        }
-        if (msg.equals("resume")) {
-            baritone.getBuilderProcess().resume();
-            logDirect("resumed");
-            return true;
-        }
-        if (msg.equals("pause")) {
-            baritone.getBuilderProcess().pause();
-            logDirect("paused");
-            return true;
-        }
-        if (msg.equals("reset")) {
-            for (Settings.Setting setting : BaritoneAPI.getSettings().allSettings) {
-                setting.reset();
-            }
-            SettingsUtil.save(BaritoneAPI.getSettings());
-            logDirect("Baritone settings reset");
-            return true;
-        }
-        if (msg.equals("tunnel")) {
-            customGoalProcess.setGoalAndPath(new GoalStrictDirection(ctx.playerFeet(), ctx.player().getHorizontalFacing()));
-            logDirect("tunneling");
-            return true;
-        }
-        if (msg.equals("render")) {
-            BetterBlockPos pf = ctx.playerFeet();
-            Minecraft.getInstance().worldRenderer.markBlockRangeForRenderUpdate(pf.x - 500, pf.y - 500, pf.z - 500, pf.x + 500, pf.y + 500, pf.z + 500);
-            logDirect("okay");
-            return true;
-        }
-        if (msg.equals("farm")) {
-            baritone.getFarmProcess().farm();
-            logDirect("farming");
-            return true;
-        }
-        if (msg.equals("chests")) {
-            for (Map.Entry<BlockPos, IRememberedInventory> entry : baritone.getWorldProvider().getCurrentWorld().getContainerMemory().getRememberedInventories().entrySet()) {
-                logDirect(entry.getKey() + "");
-                log(entry.getValue().getContents());
-            }
-            return true;
-        }
-        if (msg.startsWith("followentities")) {
-            baritone.getFollowProcess().follow(Entity.class::isInstance);
-            logDirect("Following any entities");
-            return true;
-        }
-        if (msg.startsWith("followplayers")) {
-            baritone.getFollowProcess().follow(EntityPlayer.class::isInstance); // O P P A
-            logDirect("Following any players");
-            return true;
-        }
-        if (msg.startsWith("followentity")) {
-            String name = msg.substring(12).trim();
-            Optional<Entity> toFollow = Optional.empty();
-            for (Entity entity : ctx.world().loadedEntityList) {
-                String entityName = entity.getName().getFormattedText().trim().toLowerCase();
-                if ((entityName.contains(name) || name.contains(entityName)) && !(entity instanceof EntityItem || entity instanceof EntityPlayer)) { // We dont want it following players while `#follow` exists.
-                    toFollow = Optional.of(entity);
-                }
-            }
-            if (!toFollow.isPresent()) {
-                logDirect("Entity not found");
-                return true;
-            }
-            Entity effectivelyFinal = toFollow.get();
-            baritone.getFollowProcess().follow(effectivelyFinal::equals);
-            logDirect("Following entity " + toFollow.get());
-            return true;
-        }
-        if (msg.startsWith("follow")) {
-            String name = msg.substring(6).trim();
-            Optional<Entity> toFollow = Optional.empty();
-            if (name.length() == 0) {
-                toFollow = ctx.getSelectedEntity();
-            } else {
-                for (EntityPlayer pl : ctx.world().playerEntities) {
-                    String theirName = pl.getName().getString().trim().toLowerCase();
-                    if (!theirName.equals(ctx.player().getName().getString().trim().toLowerCase()) && (theirName.contains(name) || name.contains(theirName))) { // don't follow ourselves lol
-                        toFollow = Optional.of(pl);
-                    }
-                }
-            }
-            if (!toFollow.isPresent()) {
-                logDirect("Not found");
-                return true;
-            }
-            Entity effectivelyFinal = toFollow.get();
-            baritone.getFollowProcess().follow(effectivelyFinal::equals);
-            logDirect("Following " + toFollow.get());
-            return true;
-        }
-        if (msg.startsWith("explorefilter")) {
-            // explorefilter blah.json
-            // means that entries in blah.json are already explored
-            // explorefilter blah.json invert
-            // means that entries in blah.json are NOT already explored
-            String path = msg.substring("explorefilter".length()).trim();
-            String[] parts = path.split(" ");
-            Path path1 = Minecraft.getInstance().gameDir.toPath().resolve(parts[0]);
-            boolean invert = parts.length > 1;
-            try {
-                baritone.getExploreProcess().applyJsonFilter(path1, invert);
-                logDirect("Loaded filter. Inverted: " + invert);
-                if (invert) {
-                    logDirect("Chunks on this list will be treated as possibly unexplored, all others will be treated as certainly explored");
-                } else {
-                    logDirect("Chunks on this list will be treated as certainly explored, all others will be treated as possibly unexplored");
-                }
-            } catch (Exception e) {
-                e.printStackTrace();
-                logDirect("Unable to load " + path1);
-            }
-            return true;
-        }
-        if (msg.equals("reloadall")) {
-            baritone.getWorldProvider().getCurrentWorld().getCachedWorld().reloadAllFromDisk();
-            logDirect("ok");
-            return true;
-        }
-        if (msg.equals("saveall")) {
-            baritone.getWorldProvider().getCurrentWorld().getCachedWorld().save();
-            logDirect("ok");
-            return true;
-        }
-        if (msg.startsWith("explore")) {
-            String rest = msg.substring("explore".length()).trim();
-            int centerX;
-            int centerZ;
-            try {
-                centerX = Integer.parseInt(rest.split(" ")[0]);
-                centerZ = Integer.parseInt(rest.split(" ")[1]);
-            } catch (Exception ex) {
-                centerX = ctx.playerFeet().x;
-                centerZ = ctx.playerFeet().z;
-            }
-            baritone.getExploreProcess().explore(centerX, centerZ);
-            logDirect("Exploring from " + centerX + "," + centerZ);
-            return true;
-        }
-        if (msg.equals("blacklist")) {
-            IGetToBlockProcess proc = baritone.getGetToBlockProcess();
-            if (!proc.isActive()) {
-                logDirect("GetToBlockProcess is not currently active");
-                return true;
-            }
-            if (proc.blacklistClosest()) {
-                logDirect("Blacklisted closest instances");
-            } else {
-                logDirect("No known locations, unable to blacklist");
-            }
-            return true;
-        }
-        if (msg.startsWith("find")) {
-            String blockType = msg.substring(4).trim();
-            ArrayList<BlockPos> locs = baritone.getWorldProvider().getCurrentWorld().getCachedWorld().getLocationsOf(blockType, 1, ctx.playerFeet().getX(), ctx.playerFeet().getZ(), 4);
-            logDirect("Have " + locs.size() + " locations");
-            for (BlockPos pos : locs) {
-                Block actually = ctx.world().getBlockState(pos).getBlock();
-                if (!BlockUtils.blockToString(actually).equalsIgnoreCase(blockType)) {
-                    logDebug("Was looking for " + blockType + " but actually found " + actually + " " + BlockUtils.blockToString(actually));
-                }
-            }
-            return true;
-        }
-        if (msg.startsWith("mine")) {
-            String[] blockTypes = msg.substring(4).trim().split(" ");
-            try {
-                int quantity = Integer.parseInt(blockTypes[1]);
-                Block block = BlockUtils.stringToBlockRequired(blockTypes[0]);
-                baritone.getMineProcess().mine(quantity, block);
-                logDirect("Will mine " + quantity + " " + blockTypes[0]);
-                return true;
-            } catch (NumberFormatException | ArrayIndexOutOfBoundsException | NullPointerException ex) {}
-            for (String s : blockTypes) {
-                if (BlockUtils.stringToBlockNullable(s) == null) {
-                    logDirect(s + " isn't a valid block name");
-                    return true;
-                }
-
-            }
-            baritone.getMineProcess().mineByName(0, blockTypes);
-            logDirect("Started mining blocks of type " + Arrays.toString(blockTypes));
-            return true;
-        }
-        if (msg.equals("click")) {
-            baritone.openClick();
-            logDirect("aight dude");
-            return true;
-        }
-        if (msg.startsWith("thisway") || msg.startsWith("forward")) {
-            try {
-                Goal goal = GoalXZ.fromDirection(ctx.playerFeetAsVec(), ctx.player().rotationYaw, Double.parseDouble(msg.substring(7).trim()));
-                customGoalProcess.setGoal(goal);
-                logDirect("Goal: " + goal);
-            } catch (NumberFormatException ex) {
-                logDirect("Error unable to parse '" + msg.substring(7).trim() + "' to a double.");
-            }
-            return true;
-        }
-        if (msg.startsWith("list") || msg.startsWith("get ") || msg.startsWith("show")) {
-            String waypointType = msg.substring(4).trim();
-            if (waypointType.endsWith("s")) {
-                // for example, "show deaths"
-                waypointType = waypointType.substring(0, waypointType.length() - 1);
-            }
-            IWaypoint.Tag tag = IWaypoint.Tag.fromString(waypointType);
-            if (tag == null) {
-                logDirect("Not a valid tag. Tags are: " + Arrays.asList(IWaypoint.Tag.values()).toString().toLowerCase());
-                return true;
-            }
-            Set<IWaypoint> waypoints = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getByTag(tag);
-            // might as well show them from oldest to newest
-            List<IWaypoint> sorted = new ArrayList<>(waypoints);
-            sorted.sort(Comparator.comparingLong(IWaypoint::getCreationTimestamp));
-            logDirect("Waypoints under tag " + tag + ":");
-            for (IWaypoint waypoint : sorted) {
-                logDirect(waypoint.toString());
-            }
-            return true;
-        }
-        if (msg.startsWith("save")) {
-            String name = msg.substring(4).trim();
-            BlockPos pos = ctx.playerFeet();
-            if (name.contains(" ")) {
-                logDirect("Name contains a space, assuming it's in the format 'save waypointName X Y Z'");
-                String[] parts = name.split(" ");
-                if (parts.length != 4) {
-                    logDirect("Unable to parse, expected four things");
-                    return true;
-                }
-                try {
-                    pos = new BlockPos(Integer.parseInt(parts[1]), Integer.parseInt(parts[2]), Integer.parseInt(parts[3]));
-                } catch (NumberFormatException ex) {
-                    logDirect("Unable to parse coordinate integers");
-                    return true;
-                }
-                name = parts[0];
-            }
-            baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint(name, IWaypoint.Tag.USER, pos));
-            logDirect("Saved user defined position " + pos + " under name '" + name + "'. Say 'goto " + name + "' to set goal, say 'list user' to list custom waypoints.");
-            return true;
-        }
-        if (msg.startsWith("delete")) {
-            String name = msg.substring(6).trim();
-            IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w -> w.getTag() == IWaypoint.Tag.USER && w.getName().equalsIgnoreCase(name)).findFirst().orElse(null);
-            if (waypoint == null) {
-                logDirect("No user defined position under the name '" + name + "' found.");
-                return true;
-            }
-            baritone.getWorldProvider().getCurrentWorld().getWaypoints().removeWaypoint(waypoint);
-            logDirect("Deleted user defined position under name '" + name + "'.");
-            return true;
-        }
-        if (msg.startsWith("goto")) {
-            String waypointType = msg.substring(4).trim();
-            if (waypointType.endsWith("s") && IWaypoint.Tag.fromString(waypointType.substring(0, waypointType.length() - 1)) != null) {
-                // for example, "show deaths"
-                waypointType = waypointType.substring(0, waypointType.length() - 1);
-            }
-            IWaypoint.Tag tag = IWaypoint.Tag.fromString(waypointType);
-            IWaypoint waypoint;
-            if (tag == null) {
-                String mining = waypointType;
-                Block block = BlockUtils.stringToBlockNullable(mining);
-                //logDirect("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase());
-                if (block == null) {
-                    waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w -> w.getName().equalsIgnoreCase(mining)).max(Comparator.comparingLong(IWaypoint::getCreationTimestamp)).orElse(null);
-                    if (waypoint == null) {
-                        Goal goal = parseGoal(waypointType.split(" "));
-                        if (goal != null) {
-                            logDirect("Going to " + goal);
-                            customGoalProcess.setGoalAndPath(goal);
-                        }
-                        return true;
-                    }
-                } else {
-                    baritone.getGetToBlockProcess().getToBlock(block);
-                    return true;
-                }
-            } else {
-                waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(tag);
-                if (waypoint == null) {
-                    logDirect("None saved for tag " + tag);
-                    return true;
-                }
-            }
-            Goal goal = waypoint.getTag() == IWaypoint.Tag.BED ? new GoalGetToBlock(waypoint.getLocation()) : new GoalBlock(waypoint.getLocation());
-            customGoalProcess.setGoalAndPath(goal);
-            return true;
-        }
-        if (msg.equals("spawn") || msg.equals("bed")) {
-            IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(IWaypoint.Tag.BED);
-            if (waypoint == null) {
-                BlockPos spawnPoint = ctx.player().getBedLocation();
-                // for some reason the default spawnpoint is underground sometimes
-                Goal goal = new GoalXZ(spawnPoint.getX(), spawnPoint.getZ());
-                logDirect("spawn not saved, defaulting to world spawn. set goal to " + goal);
-                customGoalProcess.setGoalAndPath(goal);
-            } else {
-                Goal goal = new GoalGetToBlock(waypoint.getLocation());
-                customGoalProcess.setGoalAndPath(goal);
-                logDirect("Set goal to most recent bed " + goal);
-            }
-            return true;
-        }
-        if (msg.equals("sethome")) {
-            baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("", IWaypoint.Tag.HOME, ctx.playerFeet()));
-            logDirect("Saved. Say home to set goal.");
-            return true;
-        }
-        if (msg.equals("home")) {
-            IWaypoint waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getMostRecentByTag(IWaypoint.Tag.HOME);
-            if (waypoint == null) {
-                logDirect("home not saved");
-            } else {
-                Goal goal = new GoalBlock(waypoint.getLocation());
-                customGoalProcess.setGoalAndPath(goal);
-                logDirect("Going to saved home " + goal);
-            }
-            return true;
-        }
-        if (msg.equals("damn")) {
-            logDirect("daniel");
-        }
-        return false;
-    }
-
-    private int parseOrDefault(String str, int i) {
-        return str.equals("~") ? i : str.startsWith("~") ? Integer.parseInt(str.substring(1)) + i : Integer.parseInt(str);
-    }
-
-    private void log(List<ItemStack> stacks) {
-        for (ItemStack stack : stacks) {
-            if (!stack.isEmpty()) {
-                logDirect(stack.getCount() + "x " + stack.getDisplayName() + "@" + stack.getDamage());
-            }
-        }
-    }
-
-    private Goal parseGoal(String[] params) {
-        Goal goal;
-        try {
-            BetterBlockPos playerFeet = ctx.playerFeet();
-            switch (params.length) {
-                case 0:
-                    goal = new GoalBlock(playerFeet);
-                    break;
-                case 1:
-                    goal = new GoalYLevel(parseOrDefault(params[0], playerFeet.y));
-                    break;
-                case 2:
-                    goal = new GoalXZ(parseOrDefault(params[0], playerFeet.x), parseOrDefault(params[1], playerFeet.z));
-                    break;
-                case 3:
-                    goal = new GoalBlock(new BlockPos(parseOrDefault(params[0], playerFeet.x), parseOrDefault(params[1], playerFeet.y), parseOrDefault(params[2], playerFeet.z)));
-                    break;
-                default:
-                    logDirect("unable to understand lol");
-                    return null;
-            }
-        } catch (NumberFormatException ex) {
-            logDirect("unable to parse integer " + ex);
-            return null;
-        }
-        return goal;
-    }
-}

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

@@ -23,7 +23,13 @@ import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
 
+import java.util.Arrays;
+import java.util.stream.Stream;
+
 /**
+ * An ease-of-access interface to provide the {@link Minecraft} game instance,
+ * chat and console logging mechanisms, and the Baritone chat prefix.
+ *
  * @author Brady
  * @since 8/1/2018
  */
@@ -34,16 +40,26 @@ public interface Helper {
      */
     Helper HELPER = new Helper() {};
 
-    ITextComponent MESSAGE_PREFIX = new TextComponentString(String.format(
-            "%s[%sBaritone%s]%s",
-            TextFormatting.DARK_PURPLE,
-            TextFormatting.LIGHT_PURPLE,
-            TextFormatting.DARK_PURPLE,
-            TextFormatting.GRAY
-    ));
-
+    /**
+     * Instance of the game
+     */
     Minecraft mc = Minecraft.getInstance();
 
+    static ITextComponent getPrefix() {
+        // Inner text component
+        ITextComponent baritone = new TextComponentString(BaritoneAPI.getSettings().shortBaritonePrefix.value ? "B" : "Baritone");
+        baritone.getStyle().setColor(TextFormatting.LIGHT_PURPLE);
+
+        // Outer brackets
+        ITextComponent prefix = new TextComponentString("");
+        prefix.getStyle().setColor(TextFormatting.DARK_PURPLE);
+        prefix.appendText("[");
+        prefix.appendSibling(baritone);
+        prefix.appendText("]");
+
+        return prefix;
+    }
+
     /**
      * Send a message to chat only if chatDebug is on
      *
@@ -59,14 +75,40 @@ public interface Helper {
     }
 
     /**
-     * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a direct response to a chat command)
+     * Send components to chat with the [Baritone] prefix
+     *
+     * @param components The components to send
+     */
+    default void logDirect(ITextComponent... components) {
+        ITextComponent component = new TextComponentString("");
+        component.appendSibling(getPrefix());
+        component.appendSibling(new TextComponentString(" "));
+        Arrays.asList(components).forEach(component::appendSibling);
+        mc.addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+    }
+
+    /**
+     * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a
+     * direct response to a chat command)
+     *
+     * @param message The message to display in chat
+     * @param color   The color to print that message in
+     */
+    default void logDirect(String message, TextFormatting color) {
+        Stream.of(message.split("\n")).forEach(line -> {
+            ITextComponent component = new TextComponentString(line.replace("\t", "    "));
+            component.getStyle().setColor(color);
+            logDirect(component);
+        });
+    }
+
+    /**
+     * Send a message to chat regardless of chatDebug (should only be used for critically important messages, or as a
+     * direct response to a chat command)
      *
      * @param message The message to display in chat
      */
     default void logDirect(String message) {
-        ITextComponent component = MESSAGE_PREFIX.shallowCopy();
-        component.getStyle().setColor(TextFormatting.GRAY);
-        component.appendSibling(new TextComponentString(" " + message));
-        Minecraft.getInstance().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+        logDirect(message, TextFormatting.GRAY);
     }
 }

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

@@ -47,9 +47,21 @@ public interface IPlayerContext {
     default BetterBlockPos playerFeet() {
         // TODO find a better way to deal with soul sand!!!!!
         BetterBlockPos feet = new BetterBlockPos(player().posX, player().posY + 0.1251, player().posZ);
-        if (world().getBlockState(feet).getBlock() instanceof BlockSlab) {
-            return feet.up();
-        }
+
+        // sometimes when calling this from another thread or while world is null, it'll throw a NullPointerException
+        // that causes the game to immediately crash
+        //
+        // so of course crashing on 2b is horribly bad due to queue times and logout spot
+        // catch the NPE and ignore it if it does happen
+        //
+        // this does not impact performance at all since we're not null checking constantly
+        // if there is an exception, the only overhead is Java generating the exception object... so we can ignore it
+        try {
+            if (world().getBlockState(feet).getBlock() instanceof BlockSlab) {
+                return feet.up();
+            }
+        } catch (NullPointerException ignored) {}
+
         return feet;
     }
 

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

@@ -35,21 +35,27 @@ import net.minecraft.world.World;
  */
 public interface IPlayerController {
 
+    void syncHeldItem();
+
+    boolean hasBrokenBlock();
+
     boolean onPlayerDamageBlock(BlockPos pos, EnumFacing side);
 
     void resetBlockRemoving();
 
     ItemStack windowClick(int windowId, int slotId, int mouseButton, ClickType type, EntityPlayer player);
 
-    void setGameType(GameType type);
-
     GameType getGameType();
 
-    default double getBlockReachDistance() {
-        return this.getGameType().isCreative() ? 5.0F : 4.5F;
-    }
-
     EnumActionResult processRightClickBlock(EntityPlayerSP player, World world, BlockPos pos, EnumFacing direction, Vec3d vec, EnumHand hand);
 
     EnumActionResult processRightClick(EntityPlayerSP player, World world, EnumHand hand);
+
+    boolean clickBlock(BlockPos loc, EnumFacing face);
+
+    void setHittingBlock(boolean hittingBlock);
+
+    default double getBlockReachDistance() {
+        return this.getGameType().isCreative() ? 5.0F : 4.5F;
+    }
 }

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

@@ -27,11 +27,11 @@ public class MyChunkPos {
     @SerializedName("x")
     public int x;
 
-    @SerializedName("y")
+    @SerializedName("z")
     public int z;
 
     @Override
     public String toString() {
         return x + ", " + z;
     }
-}
+}

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

@@ -17,14 +17,15 @@
 
 package baritone.api.utils;
 
+import baritone.api.BaritoneAPI;
 import baritone.api.Settings;
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
 import net.minecraft.item.Item;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.registry.IRegistry;
 import net.minecraft.util.math.Vec3i;
+import net.minecraft.util.registry.IRegistry;
 
 import java.awt.*;
 import java.io.BufferedReader;
@@ -36,7 +37,6 @@ import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -44,9 +44,11 @@ import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 
 public class SettingsUtil {
+
     private static final Path SETTINGS_PATH = Minecraft.getInstance().gameDir.toPath().resolve("baritone").resolve("settings.txt");
     private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>.+)"); // key and value split by the first space
 
@@ -122,15 +124,54 @@ public class SettingsUtil {
         return modified;
     }
 
+    /**
+     * Gets the type of a setting and returns it as a string, with package names stripped.
+     * <p>
+     * For example, if the setting type is {@code java.util.List<java.lang.String>}, this function returns
+     * {@code List<String>}.
+     *
+     * @param setting The setting
+     * @return The type
+     */
+    public static String settingTypeToString(Settings.Setting setting) {
+        return setting.getType().getTypeName()
+                .replaceAll("(?:\\w+\\.)+(\\w+)", "$1");
+    }
+
+    public static <T> String settingValueToString(Settings.Setting<T> setting, T value) throws IllegalArgumentException {
+        Parser io = Parser.getParser(setting.getType());
+
+        if (io == null) {
+            throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting.getName());
+        }
+
+        return io.toString(new ParserContext(setting), value);
+    }
+
+    public static String settingValueToString(Settings.Setting setting) throws IllegalArgumentException {
+        //noinspection unchecked
+        return settingValueToString(setting, setting.value);
+    }
+
+    public static String settingDefaultToString(Settings.Setting setting) throws IllegalArgumentException {
+        //noinspection unchecked
+        return settingValueToString(setting, setting.defaultValue);
+    }
+
+    public static String maybeCensor(int coord) {
+        if (BaritoneAPI.getSettings().censorCoordinates.value) {
+            return "<censored>";
+        }
+
+        return Integer.toString(coord);
+    }
+
     public static String settingToString(Settings.Setting setting) throws IllegalStateException {
         if (setting.getName().equals("logger")) {
             return "logger";
         }
-        Parser io = Parser.getParser(setting.getType());
-        if (io == null) {
-            throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting.getName());
-        }
-        return setting.getName() + " " + io.toString(new ParserContext(setting), setting.value);
+
+        return setting.getName() + " " + settingValueToString(setting);
     }
 
     public static void parseAndApply(Settings settings, String settingName, String settingValue) throws IllegalStateException, NumberFormatException {
@@ -176,6 +217,7 @@ public class SettingsUtil {
         INTEGER(Integer.class, Integer::parseInt),
         FLOAT(Float.class, Float::parseFloat),
         LONG(Long.class, Long::parseLong),
+        STRING(String.class, String::new),
         ENUMFACING(EnumFacing.class, EnumFacing::byName),
         COLOR(
                 Color.class,
@@ -202,7 +244,7 @@ public class SettingsUtil {
             public Object parse(ParserContext context, String raw) {
                 Type type = ((ParameterizedType) context.getSetting().getType()).getActualTypeArguments()[0];
                 Parser parser = Parser.getParser(type);
-                return Arrays.stream(raw.split(","))
+                return Stream.of(raw.split(","))
                         .map(s -> parser.parse(context, s))
                         .collect(Collectors.toList());
             }
@@ -223,22 +265,22 @@ public class SettingsUtil {
             }
         };
 
-        private final Class<?> klass;
+        private final Class<?> cla$$;
         private final Function<String, Object> parser;
         private final Function<Object, String> toString;
 
         Parser() {
-            this.klass = null;
+            this.cla$$ = null;
             this.parser = null;
             this.toString = null;
         }
 
-        <T> Parser(Class<T> klass, Function<String, T> parser) {
-            this(klass, parser, Object::toString);
+        <T> Parser(Class<T> cla$$, Function<String, T> parser) {
+            this(cla$$, parser, Object::toString);
         }
 
-        <T> Parser(Class<T> klass, Function<String, T> parser, Function<T, String> toString) {
-            this.klass = klass;
+        <T> Parser(Class<T> cla$$, Function<String, T> parser, Function<T, String> toString) {
+            this.cla$$ = cla$$;
             this.parser = parser::apply;
             this.toString = x -> toString.apply((T) x);
         }
@@ -257,11 +299,11 @@ public class SettingsUtil {
 
         @Override
         public boolean accepts(Type type) {
-            return type instanceof Class && this.klass.isAssignableFrom((Class) type);
+            return type instanceof Class && this.cla$$.isAssignableFrom((Class) type);
         }
 
         public static Parser getParser(Type type) {
-            return Arrays.stream(values())
+            return Stream.of(values())
                     .filter(parser -> parser.accepts(type))
                     .findFirst().orElse(null);
         }

src/api/java/baritone/api/utils/accessor/IItemStack.java

@@ -0,0 +1,23 @@
+/*
+ * 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.utils.accessor;
+
+public interface IItemStack {
+
+    int getBaritoneHash();
+}

src/api/java/baritone/api/utils/interfaces/IGoalRenderPos.java

@@ -20,5 +20,6 @@ package baritone.api.utils.interfaces;
 import net.minecraft.util.math.BlockPos;
 
 public interface IGoalRenderPos {
+
     BlockPos getGoalPos();
 }

src/launch/java/baritone/launch/mixins/MixinBitArray.java

@@ -0,0 +1,67 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IBitArray;
+import net.minecraft.util.BitArray;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+
+@Mixin(BitArray.class)
+public abstract class MixinBitArray implements IBitArray {
+
+    @Shadow
+    @Final
+    private long[] longArray;
+
+    @Shadow
+    @Final
+    private int bitsPerEntry;
+
+    @Shadow
+    @Final
+    private long maxEntryValue;
+
+    @Shadow
+    @Final
+    private int arraySize;
+
+    @Override
+    @Unique
+    public int[] toArray() {
+        int[] out = new int[arraySize];
+
+        for (int idx = 0, kl = bitsPerEntry - 1; idx < arraySize; idx++, kl += bitsPerEntry) {
+            final int i = idx * bitsPerEntry;
+            final int j = i >> 6;
+            final int l = i & 63;
+            final int k = kl >> 6;
+            final long jl = longArray[j] >>> l;
+
+            if (j == k) {
+                out[idx] = (int) (jl & maxEntryValue);
+            } else {
+                out[idx] = (int) ((jl | longArray[k] << (64 - l)) & maxEntryValue);
+            }
+        }
+
+        return out;
+    }
+}

src/launch/java/baritone/launch/mixins/MixinBlockStateContainer.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IBitArray;
+import baritone.utils.accessor.IBlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.BitArray;
+import net.minecraft.world.chunk.BlockStateContainer;
+import net.minecraft.world.chunk.IBlockStatePalette;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(BlockStateContainer.class)
+public abstract class MixinBlockStateContainer implements IBlockStateContainer {
+
+    @Shadow
+    protected BitArray storage;
+
+    @Shadow
+    protected IBlockStatePalette<IBlockState> palette;
+
+    @Override
+    public IBlockState getAtPalette(int index) {
+        return palette.get(index);
+    }
+
+    @Override
+    public int[] storageArray() {
+        return ((IBitArray) storage).toArray();
+    }
+}

src/launch/java/baritone/launch/mixins/MixinGuiChat.java

@@ -0,0 +1,99 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.event.events.TabCompleteEvent;
+import com.mojang.brigadier.context.StringRange;
+import com.mojang.brigadier.suggestion.Suggestion;
+import com.mojang.brigadier.suggestion.Suggestions;
+import net.minecraft.client.gui.GuiChat;
+import net.minecraft.client.gui.GuiTextField;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * @author Brady
+ * @since 10/9/2019
+ */
+@Mixin(GuiChat.class)
+public class MixinGuiChat {
+
+    @Shadow
+    protected GuiTextField inputField;
+
+    @Shadow
+    @Final
+    protected List<String> commandUsage;
+
+    @Shadow
+    private CompletableFuture<Suggestions> pendingSuggestions;
+
+    @Inject(
+            method = "updateSuggestion",
+            at = @At("HEAD"),
+            cancellable = true
+    )
+    private void preUpdateSuggestion(CallbackInfo ci) {
+        // Anything that is present in the input text before the cursor position
+        String prefix = this.inputField.getText().substring(0, Math.min(this.inputField.getText().length(), this.inputField.getCursorPosition()));
+
+        TabCompleteEvent event = new TabCompleteEvent(prefix);
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onPreTabComplete(event);
+
+        if (event.isCancelled()) {
+            ci.cancel();
+            return;
+        }
+
+        if (event.completions != null) {
+            ci.cancel();
+
+            // TODO: Support populating the command usage
+            this.commandUsage.clear();
+
+            if (event.completions.length == 0) {
+                this.pendingSuggestions = Suggestions.empty();
+            } else {
+                int offset = this.inputField.getText().endsWith(" ")
+                        ? this.inputField.getCursorPosition()
+                        : this.inputField.getText().lastIndexOf(" ") + 1; // If there is no space this is still 0 haha yes
+
+                List<Suggestion> suggestionList = Stream.of(event.completions)
+                        .map(s -> new Suggestion(StringRange.between(offset, offset + s.length()), s))
+                        .collect(Collectors.toList());
+
+                Suggestions suggestions = new Suggestions(
+                        StringRange.between(offset, offset + suggestionList.stream().mapToInt(s -> s.getText().length()).max().orElse(0)),
+                        suggestionList);
+
+                this.pendingSuggestions = new CompletableFuture<>();
+                this.pendingSuggestions.complete(suggestions);
+            }
+        }
+    }
+}

src/launch/java/baritone/launch/mixins/MixinGuiScreen.java

@@ -0,0 +1,33 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.utils.accessor.IGuiScreen;
+import net.minecraft.client.gui.GuiScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import java.net.URI;
+
+@Mixin(GuiScreen.class)
+public abstract class MixinGuiScreen implements IGuiScreen {
+
+    @Override
+    @Invoker("openWebLink")
+    public abstract void openLink(URI url);
+}