Wrong command...

Fix getting stuck due to impossible rotations

README.md

@@ -4,13 +4,16 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/cabaletta/baritone/tree/master"><img src="https://img.shields.io/badge/MC-1.12.2-brightgreen.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.13.2"><img src="https://img.shields.io/badge/MC-1.13.2-yellow.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.14.4"><img src="https://img.shields.io/badge/MC-1.14.4-yellow.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.15.2"><img src="https://img.shields.io/badge/MC-1.15.2-yellow.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.16.5"><img src="https://img.shields.io/badge/MC-1.16.5-brightgreen.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.17.1"><img src="https://img.shields.io/badge/MC-1.17.1-brightgreen.svg" alt="Minecraft"/></a>
-  <a href="https://github.com/cabaletta/baritone/tree/1.18.2"><img src="https://img.shields.io/badge/MC-1.18.2-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.12.2-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.13.2-yellow.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.14.4-yellow.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.15.2-yellow.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.16.5-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.17.1-yellow.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.18.2-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.19.2-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.19.4-brightgreen.svg" alt="Minecraft"/></a>
+  <a href="#Baritone"><img src="https://img.shields.io/badge/MC-1.20.1-brightgreen.svg" alt="Minecraft"/></a>
 </p>
 
 <p align="center">
@@ -33,7 +36,7 @@
 
 <p align="center">
   <a href="https://impactclient.net/"><img src="https://img.shields.io/badge/Impact%20integration-v1.2.14%20/%20v1.3.8%20/%20v1.4.6%20/%20v1.5.3%20/%20v1.6.3-brightgreen.svg" alt="Impact integration"/></a>
-  <a href="https://github.com/kami-blue/client"><img src="https://img.shields.io/badge/KAMI%20Blue%20integration-v1.2.14--master-green" alt="KAMI Blue integration"/></a>
+  <a href="https://github.com/lambda-client/lambda"><img src="https://img.shields.io/badge/Lambda%20integration-v1.2.17-brightgreen.svg" alt="Lambda integration"/></a>
   <a href="https://github.com/fr1kin/ForgeHax/"><img src="https://img.shields.io/badge/ForgeHax%20%22integration%22-scuffed-yellow.svg" alt="ForgeHax integration"/></a>
   <a href="https://aristois.net/"><img src="https://img.shields.io/badge/Aristois%20add--on%20integration-v1.6.3-green.svg" alt="Aristois add-on integration"/></a>
   <a href="https://rootnet.dev/"><img src="https://img.shields.io/badge/rootNET%20integration-v1.2.14-green.svg" alt="rootNET integration"/></a>
@@ -48,21 +51,26 @@
 
 A Minecraft pathfinder bot.
 
+Baritone is the pathfinding system used in [Impact](https://impactclient.net/) since 4.4. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a (very old!) video I made showing off what it can do.
+
 [**Baritone Discord Server**](http://discord.gg/s6fRBAUpmr)
 
-Baritone is the pathfinding system used in [Impact](https://impactclient.net/) since 4.4. There's a [showcase video](https://youtu.be/CZkLXWo4Fg4) made by @Adovin#0730 on Baritone which I recommend. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a (very old!) video I made showing off what it can do.
+**Quick download links:**
 
-[Tutorial playlist](https://www.youtube.com/playlist?list=PLnwnJ1qsS7CoQl9Si-RTluuzCo_4Oulpa)
+| Forge                                                                                                         | Fabric                                                                                                        |
+|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+| [1.12.2 Forge](https://github.com/cabaletta/baritone/releases/download/v1.2.17/baritone-api-forge-1.2.17.jar) |                                                                                                               |
+| [1.16.5 Forge](https://github.com/cabaletta/baritone/releases/download/v1.6.4/baritone-api-forge-1.6.4.jar)   | [1.16.5 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.6.4/baritone-api-fabric-1.6.4.jar) |
+| [1.17.1 Forge](https://github.com/cabaletta/baritone/releases/download/v1.7.3/baritone-api-forge-1.7.3.jar)   | [1.17.1 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.7.3/baritone-api-fabric-1.7.3.jar) |
+| [1.18.2 Forge](https://github.com/cabaletta/baritone/releases/download/v1.8.4/baritone-api-forge-1.8.4.jar)   | [1.18.2 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.8.4/baritone-api-fabric-1.8.4.jar) |
+| [1.19.2 Forge](https://github.com/cabaletta/baritone/releases/download/v1.9.4/baritone-api-forge-1.9.4.jar)   | [1.19.2 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.9.4/baritone-api-fabric-1.9.4.jar) |
+| [1.19.3 Forge](https://github.com/cabaletta/baritone/releases/download/v1.9.1/baritone-api-forge-1.9.1.jar)   | [1.19.3 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.9.1/baritone-api-fabric-1.9.1.jar) |
+| [1.19.4 Forge](https://github.com/cabaletta/baritone/releases/download/v1.9.3/baritone-api-forge-1.9.3.jar)   | [1.19.4 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.9.3/baritone-api-fabric-1.9.3.jar) |
+| [1.20.1 Forge](https://github.com/cabaletta/baritone/releases/download/v1.10.1/baritone-api-forge-1.10.1.jar)   | [1.20.1 Fabric](https://github.com/cabaletta/baritone/releases/download/v1.10.1/baritone-api-fabric-1.10.1.jar) |
 
-The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to 
-install the v1.2.* `api-forge` jar from [releases](https://github.com/cabaletta/baritone/releases). **For 1.12.2 Forge, just click 
-[here](https://github.com/cabaletta/baritone/releases/download/v1.2.17/baritone-api-forge-1.2.17.jar)**. Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+**How to immediately get started:** Type `#goto 1000 500` in chat to go to x=1000 z=500. Type `#mine diamond_ore` to mine diamond ore. Type `#stop` to stop. For more, read [the usage page](USAGE.md) and/or watch this [tutorial playlist](https://www.youtube.com/playlist?list=PLnwnJ1qsS7CoQl9Si-RTluuzCo_4Oulpa)
 
-For 1.16.5, [click here](https://www.youtube.com/watch?v=_4eVJ9Qz2J8) and see description. If you need Forge or Fabric 1.16.5, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.6.3) and get the `api-forge` or `api-fabric` jar. **For 1.16.5 Fabric, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.6.3/baritone-api-fabric-1.6.3.jar)**.
-
-If you need Forge or Fabric 1.17.1, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.7.2) and get the `api-forge` or `api-fabric` jar. **For 1.17.1 Fabric, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.7.2/baritone-api-fabric-1.7.2.jar)**.
-
-If you need Forge or Fabric 1.18.2, look [here](https://github.com/cabaletta/baritone/releases/tag/v1.8.3) and get the `api-forge` or `api-fabric` jar. **For 1.18.2 Fabric, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.8.3/baritone-api-fabric-1.8.3.jar)**. **For 1.18.2 Forge, just click [here](https://github.com/cabaletta/baritone/releases/download/v1.8.3/baritone-api-forge-1.8.3.jar)**.
+For other versions of Minecraft or more complicated situations or for development, see [Installation & setup](SETUP.md). Also consider just installing [Impact](https://impactclient.net/), which comes with Baritone and is easier to install than wrangling with version JSONs and zips. For 1.16.5, [click here](https://www.youtube.com/watch?v=_4eVJ9Qz2J8) and see description. Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it. There's a [showcase video](https://youtu.be/CZkLXWo4Fg4) made by @Adovin#6313 on Baritone which I recommend.
 
 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 onwards. 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).

SETUP.md

@@ -43,13 +43,13 @@ If another one of your Forge mods has a Baritone integration, you want `baritone
 ## Command Line
 On Mac OSX and Linux, use `./gradlew` instead of `gradlew`.
 
-If you have errors with a package missing please make sure you have setup your environment, and are using Oracle JDK 8 for 1.12.2-1.16.5, JDK 16 for 1.17.1, and JDK 17 for 1.18.1.
+If you have errors with a package missing please make sure you have setup your environment, and are using Oracle JDK 8 for 1.12.2-1.16.5, JDK 16+ for 1.17.1, and JDK 17+ for 1.18.1.
 
 To check which java you are using do 
 `java -version` in a command prompt or terminal.
 If you are using anything above OpenJDK 8 for 1.12.2-1.16.5, it might not work because the Java distributions above JDK 8 using may not have the needed javax classes.
 
-Open JDK download: https://openjdk.java.net/install/
+Download java: https://adoptium.net/
 #### macOS guide
 In order to get JDK 8, Try running the following command:
 `% /usr/libexec/java_home -V`
@@ -66,68 +66,13 @@ In order to get JDK 8 running in the **current terminal window** you will have t
 
 To add OpenJDK 8 to your PATH add the export line to the end of your `.zshrc / .bashrc` if you want it to apply to each new terminal. If you're using bash change the .bachrc and if you're using zsh change the .zshrc
 
-Setting up the Environment:
+### Building Baritone
 
-```
-$ gradlew setupDecompWorkspace
-$ gradlew --refresh-dependencies
-```
+These tasks depend on the minecraft version, but are (for the most part) standard for building mods.
 
-Building Baritone: 
-
-```
-$ gradlew build
-```
-
-For minecraft 1.15.2+, run the following instead to include the Forge jars:
-
-```
-$ gradlew build -Pbaritone.forge_build
-```
-
-Do this instead for Fabric jars:
-
-```
-$ gradlew build -Pbaritone.fabric_build
-```
-
-Running Baritone:
-
-```
-$ gradlew runClient
-```
-
-For information on how to build baritone, see [Building Baritone](#building-baritone)
+for more details, see [the build ci action](/.github/workflows/gradle_build.yml)
 
 ## IntelliJ
 - Open the project in IntelliJ as a Gradle project
-  
-  ![Image](https://i.imgur.com/jw7Q6vY.png)
-
-- Run the Gradle tasks `setupDecompWorkspace` then `genIntellijRuns`
-  
-  ![Image](https://i.imgur.com/QEfVvWP.png)
-
 - Refresh the Gradle project (or, to be safe, just restart IntelliJ)
-  
-  ![Image](https://i.imgur.com/3V7EdWr.png)
-
-- Select the "Minecraft Client" launch config
-  
-  ![Image](https://i.imgur.com/1qz2QGV.png)
-
-- Click on ``Edit Configurations...`` from the same dropdown and select the "Minecraft Client" config
-  
-  ![Image](https://i.imgur.com/s4ly0ZF.png)
-
-- In `Edit Configurations...` you need to select `baritone_launch` for `Use classpath of module:`.
-  
-  ![Image](https://i.imgur.com/hrLhG9u.png)
-
-## IntelliJ
-
-- Navigate to the gradle tasks on the right tab as follows
-
-  ![Image](https://i.imgur.com/PE6r9iN.png)
-
-- Double click on **build** to run it
+- depending on the minecraft version, you may need to run `setupDecompWorkspace` or `genIntellijRuns` in order to get everything working

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

@@ -42,6 +42,7 @@ import java.lang.reflect.Field;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -216,6 +217,7 @@ public class ProguardTask extends BaritoneGradleTask {
         Process p = new ProcessBuilder(this.getJavaBinPathForProguard(), "-verbose").start();
         String out = IOUtils.toString(p.getInputStream(), "UTF-8").split("\n")[0].split("Opened ")[1].replace("]", "");
         template.add(2, "-libraryjars '" + out + "'");
+        template.add(3, "-libraryjars '" + Paths.get(out).resolveSibling("jce.jar") + "'");
 
         // API config doesn't require any changes from the changes that we made to the template
         Files.write(getTemporaryFile(PROGUARD_API_CONFIG), template);

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

@@ -35,7 +35,7 @@ public final class BaritoneAPI {
 
     static {
         settings = new Settings();
-        SettingsUtil.readAndApply(settings);
+        SettingsUtil.readAndApply(settings, SettingsUtil.SETTINGS_DEFAULT_NAME);
 
         ServiceLoader<IBaritoneProvider> baritoneLoader = ServiceLoader.load(IBaritoneProvider.class);
         Iterator<IBaritoneProvider> instances = baritoneLoader.iterator();

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

@@ -17,10 +17,12 @@
 
 package baritone.api;
 
+import baritone.api.bot.IUserManager;
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommand;
 import baritone.api.command.ICommandSystem;
 import baritone.api.schematic.ISchematicSystem;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 
 import java.util.List;
@@ -52,15 +54,13 @@ public interface IBaritoneProvider {
     List<IBaritone> getAllBaritones();
 
     /**
-     * Provides the {@link IBaritone} instance for a given {@link EntityPlayerSP}. This will likely be
-     * replaced with or be overloaded in addition to {@code #getBaritoneForUser(IBaritoneUser)} when
-     * {@code bot-system} is merged into {@code master}.
+     * Provides the {@link IBaritone} instance for a given {@link EntityPlayerSP}.
      *
      * @param player The player
      * @return The {@link IBaritone} instance.
      */
     default IBaritone getBaritoneForPlayer(EntityPlayerSP player) {
-        for (IBaritone baritone : getAllBaritones()) {
+        for (IBaritone baritone : this.getAllBaritones()) {
             if (Objects.equals(player, baritone.getPlayerContext().player())) {
                 return baritone;
             }
@@ -68,6 +68,39 @@ public interface IBaritoneProvider {
         return null;
     }
 
+    /**
+     * Provides the {@link IBaritone} instance for a given {@link Minecraft}.
+     *
+     * @param minecraft The minecraft
+     * @return The {@link IBaritone} instance.
+     */
+    default IBaritone getBaritoneForMinecraft(Minecraft minecraft) {
+        for (IBaritone baritone : this.getAllBaritones()) {
+            if (Objects.equals(minecraft, baritone.getPlayerContext().minecraft())) {
+                return baritone;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Creates and registers a new {@link IBaritone} instance using the specified {@link Minecraft}. The existing
+     * instance is returned if already registered.
+     *
+     * @param minecraft The minecraft
+     * @return The {@link IBaritone} instance
+     */
+    IBaritone createBaritone(Minecraft minecraft);
+
+    /**
+     * Destroys and removes the specified {@link IBaritone} instance. If the specified instance is the
+     * {@link #getPrimaryBaritone() primary baritone}, this operation has no effect and will return {@code false}.
+     *
+     * @param baritone The baritone instance to remove
+     * @return Whether the baritone instance was removed
+     */
+    boolean destroyBaritone(IBaritone baritone);
+
     /**
      * Returns the {@link IWorldScanner} instance. This is not a type returned by
      * {@link IBaritone} implementation, because it is not linked with {@link IBaritone}.
@@ -76,6 +109,11 @@ public interface IBaritoneProvider {
      */
     IWorldScanner getWorldScanner();
 
+    /**
+     * @return The {@link IUserManager} instance.
+     */
+    IUserManager getUserManager();
+
     /**
      * 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.

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

@@ -29,6 +29,10 @@ import net.minecraft.util.math.Vec3i;
 import net.minecraft.util.text.ITextComponent;
 
 import java.awt.*;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.lang.reflect.Field;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -69,6 +73,16 @@ public final class Settings {
      */
     public final Setting<Boolean> allowInventory = new Setting<>(false);
 
+    /**
+     * Wait this many ticks between InventoryBehavior moving inventory items
+     */
+    public final Setting<Integer> ticksBetweenInventoryMoves = new Setting<>(1);
+
+    /**
+     * Come to a halt before doing any inventory moves. Intended for anticheat such as 2b2t
+     */
+    public final Setting<Boolean> inventoryMoveOnlyIfStationary = new Setting<>(false);
+
     /**
      * Disable baritone's auto-tool at runtime, but still assume that another mod will provide auto tool functionality
      * <p>
@@ -709,6 +723,18 @@ public final class Settings {
      */
     public final Setting<Boolean> freeLook = new Setting<>(true);
 
+    /**
+     * Break and place blocks without having to force the client-sided rotations. Having this setting enabled implies
+     * {@link #freeLook}.
+     */
+    public final Setting<Boolean> blockFreeLook = new Setting<>(false);
+
+    /**
+     * When true, the player will remain with its existing look direction as often as possible.
+     * Although, in some cases this can get it stuck, hence this setting to disable that behavior.
+     */
+    public final Setting<Boolean> remainWithExistingLookDirection = new Setting<>(true);
+
     /**
      * Will cause some minor behavioral differences to ensure that Baritone works on anticheats.
      * <p>
@@ -843,6 +869,11 @@ public final class Settings {
      */
     public final Setting<Integer> minYLevelWhileMining = new Setting<>(0);
 
+    /**
+     * Sets the maximum y level to mine ores at.
+     */
+    public final Setting<Integer> maxYLevelWhileMining = new Setting<>(255); // 1.17+ defaults to maximum possible world height
+
     /**
      * This will only allow baritone to mine exposed ores, can be used to stop ore obfuscators on servers that use them.
      */
@@ -1139,6 +1170,7 @@ public final class Settings {
      * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
      * {@link Setting#value};
      */
+    @JavaOnly
     public final Setting<Consumer<ITextComponent>> logger = new Setting<>(msg -> Minecraft.getMinecraft().ingameGUI.getChatGUI().printChatMessage(msg));
 
     /**
@@ -1146,6 +1178,7 @@ public final class Settings {
      * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
      * {@link Setting#value};
      */
+    @JavaOnly
     public final Setting<BiConsumer<String, Boolean>> notifier = new Setting<>(NotificationHelper::notify);
 
     /**
@@ -1153,6 +1186,7 @@ public final class Settings {
      * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
      * {@link Setting#value};
      */
+    @JavaOnly
     public final Setting<BiConsumer<ITextComponent, ITextComponent>> toaster = new Setting<>(BaritoneToast::addOrUpdate);
 
     /**
@@ -1255,6 +1289,13 @@ public final class Settings {
      */
     public final Setting<Boolean> desktopNotifications = new Setting<>(false);
 
+    /**
+     * Having this setting enabled keeps vanilla collision working. If disabled, bots will ignore
+     * collision boxes and be able to walk inside each other without issues. This should only be
+     * disabled when multiple bots are are needed to simultaneously use narrow tunnels.
+     */
+    public final Setting<Boolean> botCollision = new Setting<>(true);
+
     /**
      * Desktop notification on path complete
      */
@@ -1297,6 +1338,7 @@ public final class Settings {
         public T value;
         public final T defaultValue;
         private String name;
+        private boolean javaOnly;
 
         @SuppressWarnings("unchecked")
         private Setting(T value) {
@@ -1305,6 +1347,7 @@ public final class Settings {
             }
             this.value = value;
             this.defaultValue = value;
+            this.javaOnly = false;
         }
 
         /**
@@ -1341,8 +1384,25 @@ public final class Settings {
         public final Type getType() {
             return settingTypes.get(this);
         }
+
+        /**
+         * This should always be the same as whether the setting can be parsed from or serialized to a string; in other
+         * words, the only way to modify it is by writing to {@link #value} programatically.
+         *
+         * @return {@code true} if the setting can not be set or read by the user
+         */
+        public boolean isJavaOnly() {
+            return javaOnly;
+        }
     }
 
+    /**
+     * Marks a {@link Setting} field as being {@link Setting#isJavaOnly() Java-only}
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    private @interface JavaOnly {}
+
     // here be dragons
 
     Settings() {
@@ -1358,6 +1418,7 @@ public final class Settings {
                     Setting<?> setting = (Setting<?>) field.get(this);
                     String name = field.getName();
                     setting.name = name;
+                    setting.javaOnly = field.isAnnotationPresent(JavaOnly.class);
                     name = name.toLowerCase();
                     if (tmpByName.containsKey(name)) {
                         throw new IllegalStateException("Duplicate setting name");

src/api/java/baritone/api/behavior/ILookBehavior.java

@@ -17,6 +17,8 @@
 
 package baritone.api.behavior;
 
+import baritone.api.Settings;
+import baritone.api.behavior.look.IAimProcessor;
 import baritone.api.utils.Rotation;
 
 /**
@@ -26,14 +28,23 @@ import baritone.api.utils.Rotation;
 public interface ILookBehavior extends IBehavior {
 
     /**
-     * Updates the current {@link ILookBehavior} target to target
-     * the specified rotations on the next tick. If force is {@code true},
-     * then freeLook will be overriden and angles will be set regardless.
-     * If any sort of block interaction is required, force should be {@code true},
-     * otherwise, it should be {@code false};
+     * Updates the current {@link ILookBehavior} target to target the specified rotations on the next tick. If any sort
+     * of block interaction is required, {@code blockInteract} should be {@code true}. It is not guaranteed that the
+     * rotations set by the caller will be the exact rotations expressed by the client (This is due to settings like
+     * {@link Settings#randomLooking}). If the rotations produced by this behavior are required, then the
+     * {@link #getAimProcessor() aim processor} should be used.
      *
-     * @param rotation The target rotations
-     * @param force    Whether or not to "force" the rotations
+     * @param rotation      The target rotations
+     * @param blockInteract Whether the target rotations are needed for a block interaction
      */
-    void updateTarget(Rotation rotation, boolean force);
+    void updateTarget(Rotation rotation, boolean blockInteract);
+
+    /**
+     * The aim processor instance for this {@link ILookBehavior}, which is responsible for applying additional,
+     * deterministic transformations to the target rotation set by {@link #updateTarget}.
+     *
+     * @return The aim processor
+     * @see IAimProcessor#fork
+     */
+    IAimProcessor getAimProcessor();
 }

src/api/java/baritone/api/behavior/look/IAimProcessor.java

@@ -0,0 +1,45 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.behavior.look;
+
+import baritone.api.utils.Rotation;
+
+/**
+ * @author Brady
+ */
+public interface IAimProcessor {
+
+    /**
+     * Returns the actual rotation that will be used when the desired rotation is requested. The returned rotation
+     * always reflects what would happen in the upcoming tick. In other words, it is a pure function, and no internal
+     * state changes. If simulation of the rotation states beyond the next tick is required, then a
+     * {@link IAimProcessor#fork fork} should be created.
+     *
+     * @param desired The desired rotation to set
+     * @return The actual rotation
+     */
+    Rotation peekRotation(Rotation desired);
+
+    /**
+     * Returns a copy of this {@link IAimProcessor} which has its own internal state and is manually tickable.
+     *
+     * @return The forked processor
+     * @see ITickableAimProcessor
+     */
+    ITickableAimProcessor fork();
+}

src/api/java/baritone/api/behavior/look/ITickableAimProcessor.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.behavior.look;
+
+import baritone.api.utils.Rotation;
+
+/**
+ * @author Brady
+ */
+public interface ITickableAimProcessor extends IAimProcessor {
+
+    /**
+     * Advances the internal state of this aim processor by a single tick.
+     */
+    void tick();
+
+    /**
+     * Calls {@link #tick()} the specified number of times.
+     *
+     * @param ticks The number of calls
+     */
+    void advance(int ticks);
+
+    /**
+     * Returns the actual rotation as provided by {@link #peekRotation(Rotation)}, and then automatically advances the
+     * internal state by one {@link #tick() tick}.
+     *
+     * @param rotation The desired rotation to set
+     * @return The actual rotation
+     */
+    Rotation nextRotation(Rotation rotation);
+}

src/api/java/baritone/api/bot/IBaritoneUser.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.bot;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.IPlayerContext;
+import com.mojang.authlib.GameProfile;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.util.Session;
+
+/**
+ * @author Brady
+ * @since 10/23/2018
+ */
+public interface IBaritoneUser {
+
+    /**
+     * @return The Baritone instance
+     */
+    IBaritone getBaritone();
+
+    /**
+     * Returns the player context. Equivalent to {@code getBaritone().getPlayerContext()}.
+     *
+     * @return The player context
+     */
+    IPlayerContext getPlayerContext();
+
+    /**
+     * @return The network manager that is responsible for the current connection.
+     */
+    NetworkManager getNetworkManager();
+
+    /**
+     * Returns the user login session. Should never be {@code null}, as this should be set when the
+     * user is constructed.
+     *
+     * @return This users's login session
+     */
+    Session getSession();
+
+    /**
+     * Returns the game profile for the account represented by this user.
+     *
+     * @return This users's profile.
+     */
+    GameProfile getProfile();
+
+    /**
+     * @return The manager that spawned this {@link IBaritoneUser}.
+     */
+    IUserManager getManager();
+}

src/api/java/baritone/api/bot/IUserManager.java

@@ -0,0 +1,97 @@
+/*
+ * 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.bot;
+
+import baritone.api.bot.connect.ConnectionStatus;
+import baritone.api.bot.connect.IConnectionResult;
+import baritone.api.event.events.TickEvent;
+import com.mojang.authlib.GameProfile;
+import net.minecraft.util.Session;
+import net.minecraft.util.text.ITextComponent;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * @author Brady
+ * @since 1/17/2019
+ */
+public interface IUserManager {
+
+    /**
+     * Connects a new user with the specified {@link Session} to the current server. Returns
+     * a {@link IConnectionResult} describing the result of the attempted connection as well
+     * as a {@link IBaritoneUser} instance if it was {@link ConnectionStatus#SUCCESS}.
+     *
+     * @param session The user session
+     * @return The result of the attempted connection
+     */
+    IConnectionResult connect(Session session);
+
+    /**
+     * Disconnects the specified {@link IBaritoneUser} from its current server. All valid users
+     * are automatically disconnected when the current game state becomes {@link TickEvent.Type#OUT}.
+     * A reason may be specified, but is more widely used in server-initiated disconnects.
+     *
+     * @param user The user to disconnect
+     * @param reason The reason for the disconnect, may be {@code null}
+     */
+    void disconnect(IBaritoneUser user, ITextComponent reason);
+
+    /**
+     * Finds the {@link IBaritoneUser} associated with the specified {@link GameProfile}
+     *
+     * @param profile The game profile of the user
+     * @return The user, {@link Optional#empty()} if no match or {@code profile} is {@code null}
+     */
+    default Optional<IBaritoneUser> getUserByProfile(GameProfile profile) {
+        return profile == null
+            ? Optional.empty()
+            : this.getUsers().stream().filter(user -> user.getProfile().equals(profile)).findFirst();
+    }
+
+    /**
+     * Finds the {@link IBaritoneUser} associated with the specified {@link UUID}
+     *
+     * @param uuid The uuid of the user
+     * @return The user, {@link Optional#empty()} if no match or {@code uuid} is {@code null}
+     */
+    default Optional<IBaritoneUser> getUserByUUID(UUID uuid) {
+        return uuid == null
+                ? Optional.empty()
+                : this.getUsers().stream().filter(user -> user.getProfile().getId().equals(uuid)).findFirst();
+    }
+
+    /**
+     * Finds the {@link IBaritoneUser} associated with the specified username
+     *
+     * @param username The username of the user
+     * @return The user, {@link Optional#empty()} if no match or {@code uuid} is {@code null}
+     */
+    default Optional<IBaritoneUser> getUserByName(String username) {
+        return username == null || username.isEmpty()
+                ? Optional.empty()
+                : this.getUsers().stream().filter(user -> user.getProfile().getName().equalsIgnoreCase(username)).findFirst();
+    }
+
+    /**
+     * @return All of the users held by this manager
+     */
+    List<IBaritoneUser> getUsers();
+}

src/api/java/baritone/api/bot/connect/ConnectionStatus.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.bot.connect;
+
+/**
+ * @author Brady
+ * @since 11/6/2018
+ */
+public enum ConnectionStatus {
+
+    /**
+     * The local player is not connected to a server, therefore, there is no target server to connect to.
+     */
+    NO_CURRENT_CONNECTION,
+
+    /**
+     * The IP of the targetted address to connect to could not be resolved.
+     */
+    CANT_RESOLVE_HOST,
+
+    /**
+     * The port for the detected LAN server could not be resolved.
+     */
+    CANT_RESOLVE_LAN,
+
+    /**
+     * The connection initialization failed.
+     */
+    CONNECTION_FAILED,
+
+    /**
+     * The connection was a success
+     */
+    SUCCESS
+}

src/api/java/baritone/api/bot/connect/IConnectionResult.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.bot.connect;
+
+import baritone.api.bot.IBaritoneUser;
+
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 1/17/2019
+ */
+public interface IConnectionResult {
+
+    /**
+     * @return The actual status of the connection attempt.
+     * @see ConnectionStatus
+     */
+    ConnectionStatus getStatus();
+
+    /**
+     * Returns the user that was created in this connection this result reflects, if
+     * {@link #getStatus()} is {@link ConnectionStatus#SUCCESS}, otherwise it will
+     * return {@link Optional#empty()}.
+     *
+     * @return The user created in the connection
+     */
+    Optional<IBaritoneUser> getUser();
+}

src/api/java/baritone/api/cache/IWorldProvider.java

@@ -17,6 +17,8 @@
 
 package baritone.api.cache;
 
+import java.util.function.Consumer;
+
 /**
  * @author Brady
  * @since 9/24/2018
@@ -29,4 +31,11 @@ public interface IWorldProvider {
      * @return The current world data
      */
     IWorldData getCurrentWorld();
+
+    default void ifWorldLoaded(Consumer<IWorldData> callback) {
+        final IWorldData currentWorld = this.getCurrentWorld();
+        if (currentWorld != null) {
+            callback.accept(currentWorld);
+        }
+    }
 }

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

@@ -23,11 +23,17 @@ import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.ResourceLocation;
 
+import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 public enum BlockById implements IDatatypeFor<Block> {
     INSTANCE;
 
+    /**
+     * Matches (domain:)?name? where domain and name are [a-z0-9_.-]+ and [a-z0-9/_.-]+ respectively.
+     */
+    private static Pattern PATTERN = Pattern.compile("(?:[a-z0-9_.-]+:)?[a-z0-9/_.-]*");
+
     @Override
     public Block get(IDatatypeContext ctx) throws CommandException {
         ResourceLocation id = new ResourceLocation(ctx.getConsumer().getString());
@@ -40,13 +46,19 @@ public enum BlockById implements IDatatypeFor<Block> {
 
     @Override
     public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        String arg = ctx.getConsumer().getString();
+
+        if (!PATTERN.matcher(arg).matches()) {
+            return Stream.empty();
+        }
+
         return new TabCompleteHelper()
                 .append(
                         Block.REGISTRY.getKeys()
                                 .stream()
                                 .map(Object::toString)
                 )
-                .filterPrefixNamespaced(ctx.getConsumer().getString())
+                .filterPrefixNamespaced(arg)
                 .sortAlphabetically()
                 .stream();
     }

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

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

@@ -18,20 +18,136 @@
 package baritone.api.command.datatypes;
 
 import baritone.api.command.exception.CommandException;
+import baritone.api.command.helpers.TabCompleteHelper;
 import baritone.api.utils.BlockOptionalMeta;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.util.ResourceLocation;
 
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public enum ForBlockOptionalMeta implements IDatatypeFor<BlockOptionalMeta> {
     INSTANCE;
 
+    /**
+     * Matches (domain:)?name([(property=value)*])? but the input can be truncated at any position.
+     * domain and name are [a-z0-9_.-]+ and [a-z0-9/_.-]+ because that's what mc 1.13+ accepts.
+     * property and value use the same format as domain.
+     */
+    // Good luck reading this.
+    private static Pattern PATTERN = Pattern.compile("(?:[a-z0-9_.-]+:)?(?:[a-z0-9/_.-]+(?:\\[(?:(?:[a-z0-9_.-]+=[a-z0-9_.-]+,)*(?:[a-z0-9_.-]+(?:=(?:[a-z0-9_.-]+(?:\\])?)?)?)?|\\])?)?)?");
+
     @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);
+    public Stream<String> tabComplete(IDatatypeContext ctx) throws CommandException {
+        String arg = ctx.getConsumer().peekString();
+
+        if (!PATTERN.matcher(arg).matches()) {
+            // Invalid format; we can't complete this.
+            ctx.getConsumer().getString();
+            return Stream.empty();
+        }
+
+        if (arg.endsWith("]")) {
+            // We are already done.
+            ctx.getConsumer().getString();
+            return Stream.empty();
+        }
+
+        if (!arg.contains("[")) {
+            // no properties so we are completing the block id
+            return ctx.getConsumer().tabCompleteDatatype(BlockById.INSTANCE);
+        }
+
+        ctx.getConsumer().getString();
+
+        // destructuring assignment? Please?
+        String blockId, properties;
+        {
+            String[] parts = splitLast(arg, '[');
+            blockId = parts[0];
+            properties = parts[1];
+        }
+
+        Block block = Block.REGISTRY.getObject(new ResourceLocation(blockId));
+        if (block == null) {
+            // This block doesn't exist so there's no properties to complete.
+            return Stream.empty();
+        }
+
+        String leadingProperties, lastProperty;
+        {
+            String[] parts = splitLast(properties, ',');
+            leadingProperties = parts[0];
+            lastProperty = parts[1];
+        }
+
+        if (!lastProperty.contains("=")) {
+            // The last property-value pair doesn't have a value yet so we are completing its name
+            Set<String> usedProps = Stream.of(leadingProperties.split(","))
+                    .map(pair -> pair.split("=")[0])
+                    .collect(Collectors.toSet());
+
+            String prefix = arg.substring(0, arg.length() - lastProperty.length());
+            return new TabCompleteHelper()
+                    .append(
+                            block.getBlockState()
+                                    .getProperties()
+                                    .stream()
+                                    .map(IProperty::getName)
+                    )
+                    .filter(prop -> !usedProps.contains(prop))
+                    .filterPrefix(lastProperty)
+                    .sortAlphabetically()
+                    .map(prop -> prefix + prop)
+                    .stream();
+        }
+
+        String lastName, lastValue;
+        {
+            String[] parts = splitLast(lastProperty, '=');
+            lastName = parts[0];
+            lastValue = parts[1];
+        }
+
+        // We are completing the value of a property
+        String prefix = arg.substring(0, arg.length() - lastValue.length());
+
+        IProperty<?> property = block.getBlockState().getProperty(lastName);
+        if (property == null) {
+            // The property does not exist so there's no values to complete
+            return Stream.empty();
+        }
+
+        return new TabCompleteHelper()
+                .append(getValues(property))
+                .filterPrefix(lastValue)
+                .sortAlphabetically()
+                .map(val -> prefix + val)
+                .stream();
+    }
+
+    /**
+     * Always returns exactly two strings.
+     * If the separator is not found the FIRST returned string is empty.
+     */
+    private static String[] splitLast(String string, char chr) {
+        int idx = string.lastIndexOf(chr);
+        if (idx == -1) {
+            return new String[]{"", string};
+        }
+        return new String[]{string.substring(0, idx), string.substring(idx + 1)};
+    }
+
+    // this shouldn't need to be a separate method?
+    private static <T extends Comparable<T>> Stream<String> getValues(IProperty<T> property) {
+        return property.getAllowedValues().stream().map(property::getName);
     }
 }

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

@@ -19,6 +19,8 @@ package baritone.api.command.datatypes;
 
 import baritone.api.command.argument.IArgConsumer;
 import baritone.api.command.exception.CommandException;
+import baritone.api.utils.Helper;
+import net.minecraft.client.Minecraft;
 
 import java.io.File;
 import java.io.IOException;
@@ -93,8 +95,13 @@ public enum RelativeFile implements IDatatypePost<File, File> {
                 .filter(s -> !s.contains(" "));
     }
 
+    @Deprecated
     public static File gameDir() {
-        File gameDir = HELPER.mc.gameDir.getAbsoluteFile();
+        return gameDir(Helper.mc);
+    }
+
+    public static File gameDir(Minecraft mc) {
+        File gameDir = mc.gameDir.getAbsoluteFile();
         if (gameDir.getName().equals(".")) {
             return gameDir.getParentFile();
         }

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

@@ -253,7 +253,7 @@ public class TabCompleteHelper {
     public TabCompleteHelper addSettings() {
         return append(
                 BaritoneAPI.getSettings().allSettings.stream()
-                        .filter(s -> !SettingsUtil.javaOnlySetting(s))
+                        .filter(s -> !s.isJavaOnly())
                         .map(Settings.Setting::getName)
                         .sorted(String.CASE_INSENSITIVE_ORDER)
         );

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

@@ -17,6 +17,7 @@
 
 package baritone.api.event.events;
 
+import baritone.api.utils.Rotation;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 
@@ -31,14 +32,27 @@ public final class RotationMoveEvent {
      */
     private final Type type;
 
+    private final Rotation original;
+
     /**
      * The yaw rotation
      */
     private float yaw;
 
-    public RotationMoveEvent(Type type, float yaw) {
+    /**
+     * The pitch rotation
+     */
+    private float pitch;
+
+    public RotationMoveEvent(Type type, float yaw, float pitch) {
         this.type = type;
+        this.original = new Rotation(yaw, pitch);
         this.yaw = yaw;
+        this.pitch = pitch;
+    }
+
+    public Rotation getOriginal() {
+        return this.original;
     }
 
     /**
@@ -46,21 +60,37 @@ public final class RotationMoveEvent {
      *
      * @param yaw Yaw rotation
      */
-    public final void setYaw(float yaw) {
+    public void setYaw(float yaw) {
         this.yaw = yaw;
     }
 
     /**
      * @return The yaw rotation
      */
-    public final float getYaw() {
+    public float getYaw() {
         return this.yaw;
     }
 
+    /**
+     * Set the pitch movement rotation
+     *
+     * @param pitch Pitch rotation
+     */
+    public void setPitch(float pitch) {
+        this.pitch = pitch;
+    }
+
+    /**
+     * @return The pitch rotation
+     */
+    public float getPitch() {
+        return pitch;
+    }
+
     /**
      * @return The type of the event
      */
-    public final Type getType() {
+    public Type getType() {
         return this.type;
     }
 

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

@@ -42,6 +42,16 @@ public class GoalAxis implements Goal {
         return flatAxisDistance * BaritoneAPI.getSettings().costHeuristic.value + GoalYLevel.calculate(BaritoneAPI.getSettings().axisHeight.value, y);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        return o.getClass() == GoalAxis.class;
+    }
+
+    @Override
+    public int hashCode() {
+        return 201385781;
+    }
+
     @Override
     public String toString() {
         return "GoalAxis";

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
@@ -66,6 +67,26 @@ public class GoalBlock implements Goal, IGoalRenderPos {
         return calculate(xDiff, yDiff, zDiff);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalBlock goal = (GoalBlock) o;
+        return x == goal.x
+                && y == goal.y
+                && z == goal.z;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) BetterBlockPos.longHash(x, y, z) * 905165533;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -67,6 +67,24 @@ public class GoalComposite implements Goal {
         return min;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalComposite goal = (GoalComposite) o;
+        return Arrays.equals(goals, goal.goals);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(goals);
+    }
+
     @Override
     public String toString() {
         return "GoalComposite" + Arrays.toString(goals);

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
@@ -60,6 +61,26 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
         return GoalBlock.calculate(xDiff, yDiff < 0 ? yDiff + 1 : yDiff, zDiff);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalGetToBlock goal = (GoalGetToBlock) o;
+        return x == goal.x
+                && y == goal.y
+                && z == goal.z;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) BetterBlockPos.longHash(x, y, z) * -49639096;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -17,6 +17,8 @@
 
 package baritone.api.pathing.goals;
 
+import java.util.Objects;
+
 /**
  * Invert any goal.
  * <p>
@@ -50,6 +52,24 @@ public class GoalInverted implements Goal {
         return Double.NEGATIVE_INFINITY;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalInverted goal = (GoalInverted) o;
+        return Objects.equals(origin, goal.origin);
+    }
+
+    @Override
+    public int hashCode() {
+        return origin.hashCode() * 495796690;
+    }
+
     @Override
     public String toString() {
         return String.format("GoalInverted{%s}", origin.toString());

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import it.unimi.dsi.fastutil.doubles.DoubleIterator;
@@ -86,6 +87,27 @@ public class GoalNear implements Goal, IGoalRenderPos {
         return new BlockPos(x, y, z);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalNear goal = (GoalNear) o;
+        return x == goal.x
+                && y == goal.y
+                && z == goal.z
+                && rangeSq == goal.rangeSq;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) BetterBlockPos.longHash(x, y, z) + rangeSq;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -23,6 +23,7 @@ import it.unimi.dsi.fastutil.doubles.DoubleOpenHashSet;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.Arrays;
+import java.util.Objects;
 
 /**
  * Useful for automated combat (retreating specifically)
@@ -124,6 +125,29 @@ public class GoalRunAway implements Goal {
         return maxInside;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalRunAway goal = (GoalRunAway) o;
+        return distanceSq == goal.distanceSq
+                && Arrays.equals(from, goal.from)
+                && Objects.equals(maintainY, goal.maintainY);
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = Arrays.hashCode(from);
+        hash = hash * 1196803141 + distanceSq;
+        hash = hash * -2053788840 + maintainY;
+        return hash;
+    }
+
     @Override
     public String toString() {
         if (maintainY != null) {

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
@@ -69,6 +70,31 @@ public class GoalStrictDirection implements Goal {
         return Double.NEGATIVE_INFINITY;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalStrictDirection goal = (GoalStrictDirection) o;
+        return x == goal.x
+                && y == goal.y
+                && z == goal.z
+                && dx == goal.dx
+                && dz == goal.dz;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = (int) BetterBlockPos.longHash(x, y, z);
+        hash = hash * 630627507 + dx;
+        hash = hash * -283028380 + dz;
+        return hash;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -17,6 +17,7 @@
 
 package baritone.api.pathing.goals;
 
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
@@ -72,6 +73,26 @@ public class GoalTwoBlocks implements Goal, IGoalRenderPos {
         return new BlockPos(x, y, z);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalTwoBlocks goal = (GoalTwoBlocks) o;
+        return x == goal.x
+                && y == goal.y
+                && z == goal.z;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) BetterBlockPos.longHash(x, y, z) * 516508351;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -64,6 +64,27 @@ public class GoalXZ implements Goal {
         return calculate(xDiff, zDiff);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalXZ goal = (GoalXZ) o;
+        return x == goal.x && z == goal.z;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 1791873246;
+        hash = hash * 222601791 + x;
+        hash = hash * -1331679453 + z;
+        return hash;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -58,6 +58,24 @@ public class GoalYLevel implements Goal, ActionCosts {
         return 0;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GoalYLevel goal = (GoalYLevel) o;
+        return level == goal.level;
+    }
+
+    @Override
+    public int hashCode() {
+        return level * 1271009915;
+    }
+
     @Override
     public String toString() {
         return String.format(

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

@@ -51,6 +51,7 @@ public interface IBuilderProcess extends IBaritoneProcess {
      */
     boolean build(String name, File schematic, Vec3i origin);
 
+    @Deprecated
     default boolean build(String schematicFile, BlockPos origin) {
         File file = new File(new File(Minecraft.getMinecraft().gameDir, "schematics"), schematicFile);
         return build(schematicFile, file, origin);

src/api/java/baritone/api/schematic/MaskSchematic.java

@@ -17,6 +17,7 @@
 
 package baritone.api.schematic;
 
+import baritone.api.schematic.mask.Mask;
 import net.minecraft.block.state.IBlockState;
 
 import java.util.List;
@@ -41,4 +42,14 @@ public abstract class MaskSchematic extends AbstractSchematic {
     public IBlockState desiredState(int x, int y, int z, IBlockState current, List<IBlockState> approxPlaceable) {
         return schematic.desiredState(x, y, z, current, approxPlaceable);
     }
+
+    public static MaskSchematic create(ISchematic schematic, Mask function) {
+        return new MaskSchematic(schematic) {
+
+            @Override
+            protected boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+                return function.partOfMask(x, y, z, currentState);
+            }
+        };
+    }
 }

src/api/java/baritone/api/schematic/mask/AbstractMask.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.schematic.mask;
+
+/**
+ * @author Brady
+ */
+public abstract class AbstractMask implements Mask {
+
+    private final int widthX;
+    private final int heightY;
+    private final int lengthZ;
+
+    public AbstractMask(int widthX, int heightY, int lengthZ) {
+        this.widthX = widthX;
+        this.heightY = heightY;
+        this.lengthZ = lengthZ;
+    }
+
+    @Override
+    public int widthX() {
+        return this.widthX;
+    }
+
+    @Override
+    public int heightY() {
+        return this.heightY;
+    }
+
+    @Override
+    public int lengthZ() {
+        return this.lengthZ;
+    }
+}

src/api/java/baritone/api/schematic/mask/Mask.java

@@ -0,0 +1,60 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic.mask;
+
+import baritone.api.schematic.mask.operator.BinaryOperatorMask;
+import baritone.api.schematic.mask.operator.NotMask;
+import baritone.api.utils.BooleanBinaryOperators;
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * @author Brady
+ */
+public interface Mask {
+
+    /**
+     * @param x            The relative x position of the block
+     * @param y            The relative y position of the block
+     * @param z            The relative z position of the block
+     * @param currentState The current state of that block in the world, may be {@code null}
+     * @return Whether the given position is included in this mask
+     */
+    boolean partOfMask(int x, int y, int z, IBlockState currentState);
+
+    int widthX();
+
+    int heightY();
+
+    int lengthZ();
+
+    default Mask not() {
+        return new NotMask(this);
+    }
+
+    default Mask union(Mask other) {
+        return new BinaryOperatorMask(this, other, BooleanBinaryOperators.OR);
+    }
+
+    default Mask intersection(Mask other) {
+        return new BinaryOperatorMask(this, other, BooleanBinaryOperators.AND);
+    }
+
+    default Mask xor(Mask other) {
+        return new BinaryOperatorMask(this, other, BooleanBinaryOperators.XOR);
+    }
+}

src/api/java/baritone/api/schematic/mask/PreComputedMask.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.mask;
+
+/**
+ * @author Brady
+ */
+final class PreComputedMask extends AbstractMask implements StaticMask {
+
+    private final boolean[][][] mask;
+
+    public PreComputedMask(StaticMask mask) {
+        super(mask.widthX(), mask.heightY(), mask.lengthZ());
+
+        this.mask = new boolean[this.heightY()][this.lengthZ()][this.widthX()];
+        for (int y = 0; y < this.heightY(); y++) {
+            for (int z = 0; z < this.lengthZ(); z++) {
+                for (int x = 0; x < this.widthX(); x++) {
+                    this.mask[y][z][x] = mask.partOfMask(x, y, z);
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean partOfMask(int x, int y, int z) {
+        return this.mask[y][z][x];
+    }
+}

src/api/java/baritone/api/schematic/mask/StaticMask.java

@@ -0,0 +1,82 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic.mask;
+
+import baritone.api.schematic.mask.operator.BinaryOperatorMask;
+import baritone.api.schematic.mask.operator.NotMask;
+import baritone.api.utils.BooleanBinaryOperators;
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * A mask that is context-free. In other words, it doesn't require the current block state to determine if a relative
+ * position is a part of the mask.
+ *
+ * @author Brady
+ */
+public interface StaticMask extends Mask {
+
+    /**
+     * Determines if a given relative coordinate is included in this mask, without the need for the current block state.
+     *
+     * @param x The relative x position of the block
+     * @param y The relative y position of the block
+     * @param z The relative z position of the block
+     * @return Whether the given position is included in this mask
+     */
+    boolean partOfMask(int x, int y, int z);
+
+    /**
+     * Implements the parent {@link Mask#partOfMask partOfMask function} by calling the static function
+     * provided in this functional interface without needing the {@link IBlockState} argument. This {@code default}
+     * implementation should <b><u>NOT</u></b> be overriden.
+     *
+     * @param x            The relative x position of the block
+     * @param y            The relative y position of the block
+     * @param z            The relative z position of the block
+     * @param currentState The current state of that block in the world, may be {@code null}
+     * @return Whether the given position is included in this mask
+     */
+    @Override
+    default boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return this.partOfMask(x, y, z);
+    }
+
+    @Override
+    default StaticMask not() {
+        return new NotMask.Static(this);
+    }
+
+    default StaticMask union(StaticMask other) {
+        return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.OR);
+    }
+
+    default StaticMask intersection(StaticMask other) {
+        return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.AND);
+    }
+
+    default StaticMask xor(StaticMask other) {
+        return new BinaryOperatorMask.Static(this, other, BooleanBinaryOperators.XOR);
+    }
+
+    /**
+     * Returns a pre-computed mask using {@code this} function, with the specified size parameters.
+     */
+    default StaticMask compute() {
+        return new PreComputedMask(this);
+    }
+}

src/api/java/baritone/api/schematic/mask/operator/BinaryOperatorMask.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.schematic.mask.operator;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.Mask;
+import baritone.api.schematic.mask.StaticMask;
+import baritone.api.utils.BooleanBinaryOperator;
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * @author Brady
+ */
+public final class BinaryOperatorMask extends AbstractMask {
+
+    private final Mask a;
+    private final Mask b;
+    private final BooleanBinaryOperator operator;
+
+    public BinaryOperatorMask(Mask a, Mask b, BooleanBinaryOperator operator) {
+        super(Math.max(a.widthX(), b.widthX()), Math.max(a.heightY(), b.heightY()), Math.max(a.lengthZ(), b.lengthZ()));
+        this.a = a;
+        this.b = b;
+        this.operator = operator;
+    }
+
+    @Override
+    public boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return this.operator.applyAsBoolean(
+                partOfMask(a, x, y, z, currentState),
+                partOfMask(b, x, y, z, currentState)
+        );
+    }
+
+    private static boolean partOfMask(Mask mask, int x, int y, int z, IBlockState currentState) {
+        return x < mask.widthX() && y < mask.heightY() && z < mask.lengthZ() && mask.partOfMask(x, y, z, currentState);
+    }
+
+    public static final class Static extends AbstractMask implements StaticMask {
+
+        private final StaticMask a;
+        private final StaticMask b;
+        private final BooleanBinaryOperator operator;
+
+        public Static(StaticMask a, StaticMask b, BooleanBinaryOperator operator) {
+            super(Math.max(a.widthX(), b.widthX()), Math.max(a.heightY(), b.heightY()), Math.max(a.lengthZ(), b.lengthZ()));
+            this.a = a;
+            this.b = b;
+            this.operator = operator;
+        }
+
+        @Override
+        public boolean partOfMask(int x, int y, int z) {
+            return this.operator.applyAsBoolean(
+                    partOfMask(a, x, y, z),
+                    partOfMask(b, x, y, z)
+            );
+        }
+
+        private static boolean partOfMask(StaticMask mask, int x, int y, int z) {
+            return x < mask.widthX() && y < mask.heightY() && z < mask.lengthZ() && mask.partOfMask(x, y, z);
+        }
+    }
+}

src/api/java/baritone/api/schematic/mask/operator/NotMask.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.schematic.mask.operator;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.Mask;
+import baritone.api.schematic.mask.StaticMask;
+import net.minecraft.block.state.IBlockState;
+
+/**
+ * @author Brady
+ */
+public final class NotMask extends AbstractMask {
+
+    private final Mask source;
+
+    public NotMask(Mask source) {
+        super(source.widthX(), source.heightY(), source.lengthZ());
+        this.source = source;
+    }
+
+    @Override
+    public boolean partOfMask(int x, int y, int z, IBlockState currentState) {
+        return !this.source.partOfMask(x, y, z, currentState);
+    }
+
+    public static final class Static extends AbstractMask implements StaticMask {
+
+        private final StaticMask source;
+
+        public Static(StaticMask source) {
+            super(source.widthX(), source.heightY(), source.lengthZ());
+            this.source = source;
+        }
+
+        @Override
+        public boolean partOfMask(int x, int y, int z) {
+            return !this.source.partOfMask(x, y, z);
+        }
+    }
+}

src/api/java/baritone/api/schematic/mask/shape/CylinderMask.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.schematic.mask.shape;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.StaticMask;
+import net.minecraft.util.EnumFacing;
+
+/**
+ * @author Brady
+ */
+public final class CylinderMask extends AbstractMask implements StaticMask {
+
+    private final double centerA;
+    private final double centerB;
+    private final double radiusSqA;
+    private final double radiusSqB;
+    private final boolean filled;
+    private final EnumFacing.Axis alignment;
+
+    public CylinderMask(int widthX, int heightY, int lengthZ, boolean filled, EnumFacing.Axis alignment) {
+        super(widthX, heightY, lengthZ);
+        this.centerA = this.getA(widthX, heightY, alignment) / 2.0;
+        this.centerB = this.getB(heightY, lengthZ, alignment) / 2.0;
+        this.radiusSqA = (this.centerA - 1) * (this.centerA - 1);
+        this.radiusSqB = (this.centerB - 1) * (this.centerB - 1);
+        this.filled = filled;
+        this.alignment = alignment;
+    }
+
+    @Override
+    public boolean partOfMask(int x, int y, int z) {
+        double da = Math.abs((this.getA(x, y, this.alignment) + 0.5) - this.centerA);
+        double db = Math.abs((this.getB(y, z, this.alignment) + 0.5) - this.centerB);
+        if (this.outside(da, db)) {
+            return false;
+        }
+        return this.filled
+                || this.outside(da + 1, db)
+                || this.outside(da, db + 1);
+    }
+
+    private boolean outside(double da, double db) {
+        return da * da / this.radiusSqA + db * db / this.radiusSqB > 1;
+    }
+
+    private static int getA(int x, int y, EnumFacing.Axis alignment) {
+        return alignment == EnumFacing.Axis.X ? y : x;
+    }
+
+    private static int getB(int y, int z, EnumFacing.Axis alignment) {
+        return alignment == EnumFacing.Axis.Z ? y : z;
+    }
+}

src/api/java/baritone/api/schematic/mask/shape/SphereMask.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.schematic.mask.shape;
+
+import baritone.api.schematic.mask.AbstractMask;
+import baritone.api.schematic.mask.StaticMask;
+
+/**
+ * @author Brady
+ */
+public final class SphereMask extends AbstractMask implements StaticMask {
+
+    private final double centerX;
+    private final double centerY;
+    private final double centerZ;
+    private final double radiusSqX;
+    private final double radiusSqY;
+    private final double radiusSqZ;
+    private final boolean filled;
+
+    public SphereMask(int widthX, int heightY, int lengthZ, boolean filled) {
+        super(widthX, heightY, lengthZ);
+        this.centerX = widthX / 2.0;
+        this.centerY = heightY / 2.0;
+        this.centerZ = lengthZ / 2.0;
+        this.radiusSqX = this.centerX * this.centerX;
+        this.radiusSqY = this.centerY * this.centerY;
+        this.radiusSqZ = this.centerZ * this.centerZ;
+        this.filled = filled;
+    }
+
+    @Override
+    public boolean partOfMask(int x, int y, int z) {
+        double dx = Math.abs((x + 0.5) - this.centerX);
+        double dy = Math.abs((y + 0.5) - this.centerY);
+        double dz = Math.abs((z + 0.5) - this.centerZ);
+        if (this.outside(dx, dy, dz)) {
+            return false;
+        }
+        return this.filled
+                || this.outside(dx + 1, dy, dz)
+                || this.outside(dx, dy + 1, dz)
+                || this.outside(dx, dy, dz + 1);
+    }
+
+    private boolean outside(double dx, double dy, double dz) {
+        return dx * dx / this.radiusSqX + dy * dy / this.radiusSqY + dz * dz / this.radiusSqZ > 1;
+    }
+}

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

@@ -19,6 +19,7 @@ package baritone.api.utils;
 
 import baritone.api.utils.accessor.IItemStack;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableMap;
 import net.minecraft.block.*;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.state.IBlockState;
@@ -36,21 +37,24 @@ import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 public final class BlockOptionalMeta {
+    // id:meta or id[] or id[properties] where id and properties are any text with at least one character and meta is a one or two digit number
+    private static final Pattern PATTERN = Pattern.compile("^(?<id>.+?)(?::(?<meta>\\d\\d?)|\\[(?<properties>.+?)?\\])?$");
 
     private final Block block;
     private final int meta;
     private final boolean noMeta;
+    private final String propertiesDescription; // exists so toString() can return something more useful than a list of all blockstates
     private final Set<IBlockState> blockstates;
-    private final ImmutableSet<Integer> stateHashes;
-    private final ImmutableSet<Integer> stackHashes;
-    private static final Pattern pattern = Pattern.compile("^(.+?)(?::(\\d+))?$");
+    private final Set<Integer> stateHashes;
+    private final Set<Integer> stackHashes;
     private static final Map<Object, Object> normalizations;
 
     public BlockOptionalMeta(@Nonnull Block block, @Nullable Integer meta) {
         this.block = block;
         this.noMeta = meta == null;
         this.meta = noMeta ? 0 : meta;
-        this.blockstates = getStates(block, meta);
+        this.propertiesDescription = "{}";
+        this.blockstates = getStates(block, meta, Collections.emptyMap());
         this.stateHashes = getStateHashes(blockstates);
         this.stackHashes = getStackHashes(blockstates);
     }
@@ -60,24 +64,27 @@ public final class BlockOptionalMeta {
     }
 
     public BlockOptionalMeta(@Nonnull String selector) {
-        Matcher matcher = pattern.matcher(selector);
+        Matcher matcher = PATTERN.matcher(selector);
 
         if (!matcher.find()) {
             throw new IllegalArgumentException("invalid block selector");
         }
 
-        MatchResult matchResult = matcher.toMatchResult();
-        noMeta = matchResult.group(2) == null;
+        noMeta = matcher.group("meta") == null;
 
-        ResourceLocation id = new ResourceLocation(matchResult.group(1));
+        ResourceLocation id = new ResourceLocation(matcher.group("id"));
 
         if (!Block.REGISTRY.containsKey(id)) {
             throw new IllegalArgumentException("Invalid block ID");
         }
-
         block = Block.REGISTRY.getObject(id);
-        meta = noMeta ? 0 : Integer.parseInt(matchResult.group(2));
-        blockstates = getStates(block, getMeta());
+
+        String props = matcher.group("properties");
+        Map<IProperty<?>, ?> properties = props == null || props.equals("") ? Collections.emptyMap() : parseProperties(block, props);
+
+        propertiesDescription = props == null ? "{}" : "{" + props.replace("=", ":") + "}";
+        meta = noMeta ? 0 : Integer.parseInt(matcher.group("meta"));
+        blockstates = getStates(block, getMeta(), properties);
         stateHashes = getStateHashes(blockstates);
         stackHashes = getStackHashes(blockstates);
     }
@@ -243,9 +250,32 @@ public final class BlockOptionalMeta {
         return state.getBlock().getMetaFromState(normalize(state));
     }
 
-    private static Set<IBlockState> getStates(@Nonnull Block block, @Nullable Integer meta) {
+    private static Map<IProperty<?>, ?> parseProperties(Block block, String raw) {
+        ImmutableMap.Builder<IProperty<?>, Object> builder = ImmutableMap.builder();
+        for (String pair : raw.split(",")) {
+            String[] parts = pair.split("=");
+            if (parts.length != 2) {
+                throw new IllegalArgumentException(String.format("\"%s\" is not a valid property-value pair", pair));
+            }
+            String rawKey = parts[0];
+            String rawValue = parts[1];
+            IProperty<?> key = block.getBlockState().getProperty(rawKey);
+            Comparable<?> value = castToIProperty(key).parseValue(rawValue)
+                    .toJavaUtil().orElseThrow(() -> new IllegalArgumentException(String.format(
+                            "\"%s\" is not a valid value for %s on %s",
+                            rawValue, key, block
+                    )));
+            builder.put(key, value);
+        }
+        return builder.build();
+    }
+
+    private static Set<IBlockState> getStates(@Nonnull Block block, @Nullable Integer meta, @Nonnull Map<IProperty<?>, ?> properties) {
         return block.getBlockState().getValidStates().stream()
                 .filter(blockstate -> meta == null || stateMeta(blockstate) == meta)
+                .filter(blockstate -> properties.entrySet().stream().allMatch(entry ->
+                        blockstate.getValue(entry.getKey()) == entry.getValue()
+                ))
                 .collect(Collectors.toSet());
     }
 
@@ -274,6 +304,7 @@ public final class BlockOptionalMeta {
         return block;
     }
 
+    @Deprecated // deprecated because getMeta() == null no longer implies that this BOM only cares about the block
     public Integer getMeta() {
         return noMeta ? null : meta;
     }
@@ -300,7 +331,11 @@ public final class BlockOptionalMeta {
 
     @Override
     public String toString() {
-        return String.format("BlockOptionalMeta{block=%s,meta=%s}", block, getMeta());
+        if (noMeta) {
+            return String.format("BlockOptionalMeta{block=%s,properties=%s}", block, propertiesDescription);
+        } else {
+            return String.format("BlockOptionalMeta{block=%s,meta=%s}", block, getMeta());
+        }
     }
 
     public static IBlockState blockStateFromStack(ItemStack stack) {
@@ -315,4 +350,12 @@ public final class BlockOptionalMeta {
 
         return null;
     }
+
+    public Set<IBlockState> getAllBlockStates() {
+        return blockstates;
+    }
+
+    public Set<Integer> stackHashes() {
+        return stackHashes;
+    }
 }

src/api/java/baritone/api/utils/BlockOptionalMetaLookup.java

@@ -17,68 +17,70 @@
 
 package baritone.api.utils;
 
+import baritone.api.utils.accessor.IItemStack;
+import com.google.common.collect.ImmutableSet;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.ItemStack;
 
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Stream;
 
 public class BlockOptionalMetaLookup {
-
+    private final ImmutableSet<Block> blockSet;
+    private final ImmutableSet<IBlockState> blockStateSet;
+    private final ImmutableSet<Integer> stackHashes;
     private final BlockOptionalMeta[] boms;
 
     public BlockOptionalMetaLookup(BlockOptionalMeta... boms) {
         this.boms = boms;
+        Set<Block> blocks = new HashSet<>();
+        Set<IBlockState> blockStates = new HashSet<>();
+        Set<Integer> stacks = new HashSet<>();
+        for (BlockOptionalMeta bom : boms) {
+            blocks.add(bom.getBlock());
+            blockStates.addAll(bom.getAllBlockStates());
+            stacks.addAll(bom.stackHashes());
+        }
+        this.blockSet = ImmutableSet.copyOf(blocks);
+        this.blockStateSet = ImmutableSet.copyOf(blockStates);
+        this.stackHashes = ImmutableSet.copyOf(stacks);
     }
 
     public BlockOptionalMetaLookup(Block... blocks) {
-        this.boms = Stream.of(blocks)
+        this(Stream.of(blocks)
                 .map(BlockOptionalMeta::new)
-                .toArray(BlockOptionalMeta[]::new);
+                .toArray(BlockOptionalMeta[]::new));
+
     }
 
     public BlockOptionalMetaLookup(List<Block> blocks) {
-        this.boms = blocks.stream()
+        this(blocks.stream()
                 .map(BlockOptionalMeta::new)
-                .toArray(BlockOptionalMeta[]::new);
+                .toArray(BlockOptionalMeta[]::new));
     }
 
     public BlockOptionalMetaLookup(String... blocks) {
-        this.boms = Stream.of(blocks)
+        this(Stream.of(blocks)
                 .map(BlockOptionalMeta::new)
-                .toArray(BlockOptionalMeta[]::new);
+                .toArray(BlockOptionalMeta[]::new));
     }
 
     public boolean has(Block block) {
-        for (BlockOptionalMeta bom : boms) {
-            if (bom.getBlock() == block) {
-                return true;
-            }
-        }
-
-        return false;
+        return blockSet.contains(block);
     }
 
     public boolean has(IBlockState state) {
-        for (BlockOptionalMeta bom : boms) {
-            if (bom.matches(state)) {
-                return true;
-            }
-        }
-
-        return false;
+        return blockStateSet.contains(state);
     }
 
     public boolean has(ItemStack stack) {
-        for (BlockOptionalMeta bom : boms) {
-            if (bom.matches(stack)) {
-                return true;
-            }
-        }
-
-        return false;
+        int hash = ((IItemStack) (Object) stack).getBaritoneHash();
+        return stackHashes.contains(hash)
+                || stackHashes.contains(hash - stack.getItemDamage());
     }
 
     public List<BlockOptionalMeta> blocks() {

src/api/java/baritone/api/utils/BooleanBinaryOperator.java

@@ -0,0 +1,27 @@
+/*
+ * 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;
+
+/**
+ * @author Brady
+ */
+@FunctionalInterface
+public interface BooleanBinaryOperator {
+
+    boolean applyAsBoolean(boolean a, boolean b);
+}

src/api/java/baritone/api/utils/BooleanBinaryOperators.java

@@ -0,0 +1,38 @@
+/*
+ * 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;
+
+/**
+ * @author Brady
+ */
+public enum BooleanBinaryOperators implements BooleanBinaryOperator {
+    OR((a, b) -> a || b),
+    AND((a, b) -> a && b),
+    XOR((a, b) -> a ^ b);
+
+    private final BooleanBinaryOperator op;
+
+    BooleanBinaryOperators(BooleanBinaryOperator op) {
+        this.op = op;
+    }
+
+    @Override
+    public boolean applyAsBoolean(boolean a, boolean b) {
+        return this.op.applyAsBoolean(a, b);
+    }
+}

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

@@ -42,8 +42,10 @@ public interface Helper {
     Helper HELPER = new Helper() {};
 
     /**
-     * Instance of the game
+     * The main game instance returned by {@link Minecraft#getMinecraft()}.
+     * Deprecated since {@link IPlayerContext#minecraft()} should be used instead (In the majority of cases).
      */
+    @Deprecated
     Minecraft mc = Minecraft.getMinecraft();
 
     static ITextComponent getPrefix() {
@@ -70,7 +72,7 @@ public interface Helper {
      * @param message The message to display in the popup
      */
     default void logToast(ITextComponent title, ITextComponent message) {
-        mc.addScheduledTask(() -> BaritoneAPI.getSettings().toaster.value.accept(title, message));
+        Minecraft.getMinecraft().addScheduledTask(() -> BaritoneAPI.getSettings().toaster.value.accept(title, message));
     }
 
     /**
@@ -131,7 +133,7 @@ public interface Helper {
      * @param error   Whether to log as an error
      */
     default void logNotificationDirect(String message, boolean error) {
-        mc.addScheduledTask(() -> BaritoneAPI.getSettings().notifier.value.accept(message, error));
+        Minecraft.getMinecraft().addScheduledTask(() -> BaritoneAPI.getSettings().notifier.value.accept(message, error));
     }
 
     /**
@@ -168,7 +170,7 @@ public interface Helper {
         if (logAsToast) {
             logToast(getPrefix(), component);
         } else {
-            mc.addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
+            Minecraft.getMinecraft().addScheduledTask(() -> BaritoneAPI.getSettings().logger.value.accept(component));
         }
     }
 

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

@@ -19,6 +19,7 @@ package baritone.api.utils;
 
 import baritone.api.cache.IWorldData;
 import net.minecraft.block.BlockSlab;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
@@ -33,6 +34,8 @@ import java.util.Optional;
  */
 public interface IPlayerContext {
 
+    Minecraft minecraft();
+
     EntityPlayerSP player();
 
     IPlayerController playerController();
@@ -72,6 +75,8 @@ public interface IPlayerContext {
         return new Vec3d(player().posX, player().posY + player().getEyeHeight(), player().posZ);
     }
 
+    BetterBlockPos viewerPos();
+
     default Rotation playerRotations() {
         return new Rotation(player().rotationYaw, player().rotationPitch);
     }

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

@@ -46,6 +46,8 @@ public interface IPlayerController {
 
     ItemStack windowClick(int windowId, int slotId, int mouseButton, ClickType type, EntityPlayer player);
 
+    void setGameType(GameType type);
+
     GameType getGameType();
 
     EnumActionResult processRightClickBlock(EntityPlayerSP player, World world, BlockPos pos, EnumFacing direction, Vec3d vec, EnumHand hand);

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

@@ -26,12 +26,12 @@ public class Rotation {
     /**
      * The yaw angle of this Rotation
      */
-    private float yaw;
+    private final float yaw;
 
     /**
      * The pitch angle of this Rotation
      */
-    private float pitch;
+    private final float pitch;
 
     public Rotation(float yaw, float pitch) {
         this.yaw = yaw;
@@ -110,6 +110,10 @@ public class Rotation {
         );
     }
 
+    public Rotation withPitch(float pitch) {
+        return new Rotation(this.yaw, pitch);
+    }
+
     /**
      * Is really close to
      *

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

@@ -134,14 +134,14 @@ public final class RotationUtils {
      * @param ctx Context for the viewing entity
      * @param pos The target block position
      * @return The optional rotation
-     * @see #reachable(EntityPlayerSP, BlockPos, double)
+     * @see #reachable(IPlayerContext, BlockPos, double)
      */
     public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos) {
-        return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
+        return reachable(ctx, pos, false);
     }
 
     public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos, boolean wouldSneak) {
-        return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance(), wouldSneak);
+        return reachable(ctx, pos, ctx.playerController().getBlockReachDistance(), wouldSneak);
     }
 
     /**
@@ -151,18 +151,17 @@ public final class RotationUtils {
      * side that is reachable. The return type will be {@link Optional#empty()} if the entity is
      * unable to reach any of the sides of the block.
      *
-     * @param entity             The viewing entity
+     * @param ctx                Context for the viewing entity
      * @param pos                The target block position
      * @param blockReachDistance The block reach distance of the entity
      * @return The optional rotation
      */
-    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance) {
-        return reachable(entity, pos, blockReachDistance, false);
+    public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos, double blockReachDistance) {
+        return reachable(ctx, pos, blockReachDistance, false);
     }
 
-    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
-        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
-        if (baritone.getPlayerContext().isLookingAt(pos)) {
+    public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+        if (BaritoneAPI.getSettings().remainWithExistingLookDirection.value && ctx.isLookingAt(pos)) {
             /*
              * why add 0.0001?
              * to indicate that we actually have a desired pitch
@@ -173,10 +172,10 @@ public final class RotationUtils {
              *
              * or if you're a normal person literally all this does it ensure that we don't nudge the pitch to a normal level
              */
-            Rotation hypothetical = new Rotation(entity.rotationYaw, entity.rotationPitch + 0.0001F);
+            Rotation hypothetical = ctx.playerRotations().add(new Rotation(0, 0.0001F));
             if (wouldSneak) {
                 // the concern here is: what if we're looking at it now, but as soon as we start sneaking we no longer are
-                RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, hypothetical, blockReachDistance, true);
+                RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), hypothetical, blockReachDistance, true);
                 if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK && result.getBlockPos().equals(pos)) {
                     return Optional.of(hypothetical); // yes, if we sneaked we would still be looking at the block
                 }
@@ -184,19 +183,19 @@ public final class RotationUtils {
                 return Optional.of(hypothetical);
             }
         }
-        Optional<Rotation> possibleRotation = reachableCenter(entity, pos, blockReachDistance, wouldSneak);
+        Optional<Rotation> possibleRotation = reachableCenter(ctx, pos, blockReachDistance, wouldSneak);
         //System.out.println("center: " + possibleRotation);
         if (possibleRotation.isPresent()) {
             return possibleRotation;
         }
 
-        IBlockState state = entity.world.getBlockState(pos);
-        AxisAlignedBB aabb = state.getBoundingBox(entity.world, pos);
+        IBlockState state = ctx.world().getBlockState(pos);
+        AxisAlignedBB aabb = state.getBoundingBox(ctx.world(), pos);
         for (Vec3d sideOffset : BLOCK_SIDE_MULTIPLIERS) {
             double xDiff = aabb.minX * sideOffset.x + aabb.maxX * (1 - sideOffset.x);
             double yDiff = aabb.minY * sideOffset.y + aabb.maxY * (1 - sideOffset.y);
             double zDiff = aabb.minZ * sideOffset.z + aabb.maxZ * (1 - sideOffset.z);
-            possibleRotation = reachableOffset(entity, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
+            possibleRotation = reachableOffset(ctx, pos, new Vec3d(pos).add(xDiff, yDiff, zDiff), blockReachDistance, wouldSneak);
             if (possibleRotation.isPresent()) {
                 return possibleRotation;
             }
@@ -209,12 +208,55 @@ public final class RotationUtils {
      * the given offsetted position. The return type will be {@link Optional#empty()} if
      * the entity is unable to reach the block with the offset applied.
      *
-     * @param entity             The viewing entity
+     * @param ctx                Context for the viewing entity
      * @param pos                The target block position
      * @param offsetPos          The position of the block with the offset applied.
      * @param blockReachDistance The block reach distance of the entity
      * @return The optional rotation
      */
+    public static Optional<Rotation> reachableOffset(IPlayerContext ctx, BlockPos pos, Vec3d offsetPos, double blockReachDistance, boolean wouldSneak) {
+        Vec3d eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(ctx.player()) : ctx.player().getPositionEyes(1.0F);
+        Rotation rotation = calcRotationFromVec3d(eyes, offsetPos, ctx.playerRotations());
+        Rotation actualRotation = BaritoneAPI.getProvider().getBaritoneForPlayer(ctx.player()).getLookBehavior().getAimProcessor().peekRotation(rotation);
+        RayTraceResult result = RayTraceUtils.rayTraceTowards(ctx.player(), actualRotation, blockReachDistance, wouldSneak);
+        //System.out.println(result);
+        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
+            if (result.getBlockPos().equals(pos)) {
+                return Optional.of(rotation);
+            }
+            if (ctx.world().getBlockState(pos).getBlock() instanceof BlockFire && result.getBlockPos().equals(pos.down())) {
+                return Optional.of(rotation);
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Determines if the specified entity is able to reach the specified block where it is
+     * looking at the direct center of it's hitbox.
+     *
+     * @param ctx                Context for the viewing entity
+     * @param pos                The target block position
+     * @param blockReachDistance The block reach distance of the entity
+     * @return The optional rotation
+     */
+    public static Optional<Rotation> reachableCenter(IPlayerContext ctx, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+        return reachableOffset(ctx, pos, VecUtils.calculateBlockCenter(ctx.world(), pos), blockReachDistance, wouldSneak);
+    }
+
+    @Deprecated
+    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance) {
+        return reachable(entity, pos, blockReachDistance, false);
+    }
+
+    @Deprecated
+    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
+        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
+        IPlayerContext ctx = baritone.getPlayerContext();
+        return reachable(ctx, pos, blockReachDistance, wouldSneak);
+    }
+
+    @Deprecated
     public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance, boolean wouldSneak) {
         Vec3d eyes = wouldSneak ? RayTraceUtils.inferSneakingEyePosition(entity) : entity.getPositionEyes(1.0F);
         Rotation rotation = calcRotationFromVec3d(eyes, offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
@@ -231,15 +273,7 @@ public final class RotationUtils {
         return Optional.empty();
     }
 
-    /**
-     * Determines if the specified entity is able to reach the specified block where it is
-     * looking at the direct center of it's hitbox.
-     *
-     * @param entity             The viewing entity
-     * @param pos                The target block position
-     * @param blockReachDistance The block reach distance of the entity
-     * @return The optional rotation
-     */
+    @Deprecated
     public static Optional<Rotation> reachableCenter(Entity entity, BlockPos pos, double blockReachDistance, boolean wouldSneak) {
         return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance, wouldSneak);
     }

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

@@ -20,6 +20,7 @@ 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.math.Vec3i;
@@ -44,13 +45,10 @@ import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static net.minecraft.client.Minecraft.getMinecraft;
-
 public class SettingsUtil {
 
-    private static final Path SETTINGS_PATH = getMinecraft().gameDir.toPath().resolve("baritone").resolve("settings.txt");
+    public static final String SETTINGS_DEFAULT_NAME = "settings.txt";
     private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>.+)"); // key and value split by the first space
-    private static final String[] JAVA_ONLY_SETTINGS = {"logger", "notifier", "toaster"};
 
     private static boolean isComment(String line) {
         return line.startsWith("#") || line.startsWith("//");
@@ -68,12 +66,12 @@ public class SettingsUtil {
         }
     }
 
-    public static void readAndApply(Settings settings) {
+    public static void readAndApply(Settings settings, String settingsName) {
         try {
-            forEachLine(SETTINGS_PATH, line -> {
+            forEachLine(settingsByName(settingsName), line -> {
                 Matcher matcher = SETTING_PATTERN.matcher(line);
                 if (!matcher.matches()) {
-                    System.out.println("Invalid syntax in setting file: " + line);
+                    Helper.HELPER.logDirect("Invalid syntax in setting file: " + line);
                     return;
                 }
 
@@ -82,29 +80,33 @@ public class SettingsUtil {
                 try {
                     parseAndApply(settings, settingName, settingValue);
                 } catch (Exception ex) {
-                    System.out.println("Unable to parse line " + line);
+                    Helper.HELPER.logDirect("Unable to parse line " + line);
                     ex.printStackTrace();
                 }
             });
         } catch (NoSuchFileException ignored) {
-            System.out.println("Baritone settings file not found, resetting.");
+            Helper.HELPER.logDirect("Baritone settings file not found, resetting.");
         } catch (Exception ex) {
-            System.out.println("Exception while reading Baritone settings, some settings may be reset to default values!");
+            Helper.HELPER.logDirect("Exception while reading Baritone settings, some settings may be reset to default values!");
             ex.printStackTrace();
         }
     }
 
     public static synchronized void save(Settings settings) {
-        try (BufferedWriter out = Files.newBufferedWriter(SETTINGS_PATH)) {
+        try (BufferedWriter out = Files.newBufferedWriter(settingsByName(SETTINGS_DEFAULT_NAME))) {
             for (Settings.Setting setting : modifiedSettings(settings)) {
                 out.write(settingToString(setting) + "\n");
             }
         } catch (Exception ex) {
-            System.out.println("Exception thrown while saving Baritone settings!");
+            Helper.HELPER.logDirect("Exception thrown while saving Baritone settings!");
             ex.printStackTrace();
         }
     }
 
+    private static Path settingsByName(String name) {
+        return Minecraft.getMinecraft().gameDir.toPath().resolve("baritone").resolve(name);
+    }
+
     public static List<Settings.Setting> modifiedSettings(Settings settings) {
         List<Settings.Setting> modified = new ArrayList<>();
         for (Settings.Setting setting : settings.allSettings) {
@@ -112,7 +114,7 @@ public class SettingsUtil {
                 System.out.println("NULL SETTING?" + setting.getName());
                 continue;
             }
-            if (javaOnlySetting(setting)) {
+            if (setting.isJavaOnly()) {
                 continue; // NO
             }
             if (setting.value == setting.defaultValue) {
@@ -166,7 +168,7 @@ public class SettingsUtil {
     }
 
     public static String settingToString(Settings.Setting setting) throws IllegalStateException {
-        if (javaOnlySetting(setting)) {
+        if (setting.isJavaOnly()) {
             return setting.getName();
         }
 
@@ -174,18 +176,14 @@ public class SettingsUtil {
     }
 
     /**
-     * This should always be the same as whether the setting can be parsed from or serialized to a string
+     * Deprecated. Use {@link Settings.Setting#isJavaOnly()} instead.
      *
      * @param setting The Setting
      * @return true if the setting can not be set or read by the user
      */
+    @Deprecated
     public static boolean javaOnlySetting(Settings.Setting setting) {
-        for (String name : JAVA_ONLY_SETTINGS) { // no JAVA_ONLY_SETTINGS.contains(...) because that would be case sensitive
-            if (setting.getName().equalsIgnoreCase(name)) {
-                return true;
-            }
-        }
-        return false;
+        return setting.isJavaOnly();
     }
 
     public static void parseAndApply(Settings settings, String settingName, String settingValue) throws IllegalStateException, NumberFormatException {

src/api/java/baritone/api/utils/gui/BaritoneToast.java

@@ -17,6 +17,7 @@
 
 package baritone.api.utils.gui;
 
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.toasts.GuiToast;
 import net.minecraft.client.gui.toasts.IToast;
 import net.minecraft.client.renderer.GlStateManager;
@@ -73,6 +74,6 @@ public class BaritoneToast implements IToast {
     }
 
     public static void addOrUpdate(ITextComponent title, ITextComponent subtitle) {
-        addOrUpdate(net.minecraft.client.Minecraft.getMinecraft().getToastGui(), title, subtitle, baritone.api.BaritoneAPI.getSettings().toastTimer.value);
+        addOrUpdate(Minecraft.getMinecraft().getToastGui(), title, subtitle, baritone.api.BaritoneAPI.getSettings().toastTimer.value);
     }
 }

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

@@ -64,4 +64,14 @@ public abstract class MixinBitArray implements IBitArray {
 
         return out;
     }
+
+    @Override
+    public long getMaxEntryValue() {
+        return maxEntryValue;
+    }
+
+    @Override
+    public int getBitsPerEntry() {
+        return bitsPerEntry;
+    }
 }

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

@@ -35,6 +35,16 @@ public abstract class MixinBlockStateContainer implements IBlockStateContainer {
     @Shadow
     protected IBlockStatePalette palette;
 
+    @Override
+    public IBlockStatePalette getPalette() {
+        return palette;
+    }
+
+    @Override
+    public BitArray getStorage() {
+        return storage;
+    }
+
     @Override
     public IBlockState getAtPalette(int index) {
         return palette.getBlockState(index);

src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java

@@ -25,11 +25,14 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.util.Optional;
+
 import static org.spongepowered.asm.lib.Opcodes.GETFIELD;
 
 /**
@@ -42,11 +45,14 @@ public abstract class MixinEntityLivingBase extends Entity {
     /**
      * Event called to override the movement direction when jumping
      */
+    @Unique
     private RotationMoveEvent jumpRotationEvent;
 
-    public MixinEntityLivingBase(World worldIn, RotationMoveEvent jumpRotationEvent) {
+    @Unique
+    private RotationMoveEvent elytraRotationEvent;
+
+    public MixinEntityLivingBase(World worldIn) {
         super(worldIn);
-        this.jumpRotationEvent = jumpRotationEvent;
     }
 
     @Inject(
@@ -54,14 +60,10 @@ public abstract class MixinEntityLivingBase extends Entity {
             at = @At("HEAD")
     )
     private void preMoveRelative(CallbackInfo ci) {
-        // noinspection ConstantConditions
-        if (EntityPlayerSP.class.isInstance(this)) {
-            IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this);
-            if (baritone != null) {
-                this.jumpRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.JUMP, this.rotationYaw);
-                baritone.getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
-            }
-        }
+        this.getBaritone().ifPresent(baritone -> {
+            this.jumpRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.JUMP, this.rotationYaw, this.rotationPitch);
+            baritone.getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
+        });
     }
 
     @Redirect(
@@ -79,6 +81,38 @@ public abstract class MixinEntityLivingBase extends Entity {
         return self.rotationYaw;
     }
 
+    @Inject(
+            method = "travel",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/entity/EntityLivingBase.getLookVec()Lnet/minecraft/util/math/Vec3d;"
+            )
+    )
+    private void onPreElytraMove(float strafe, float vertical, float forward, CallbackInfo ci) {
+        this.getBaritone().ifPresent(baritone -> {
+            this.elytraRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw, this.rotationPitch);
+            baritone.getGameEventHandler().onPlayerRotationMove(this.elytraRotationEvent);
+            this.rotationYaw = this.elytraRotationEvent.getYaw();
+            this.rotationPitch = this.elytraRotationEvent.getPitch();
+        });
+    }
+
+    @Inject(
+            method = "travel",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/entity/EntityLivingBase.move(Lnet/minecraft/entity/MoverType;DDD)V",
+                    shift = At.Shift.AFTER
+            )
+    )
+    private void onPostElytraMove(float strafe, float vertical, float forward, CallbackInfo ci) {
+        if (this.elytraRotationEvent != null) {
+            this.rotationYaw = this.elytraRotationEvent.getOriginal().getYaw();
+            this.rotationPitch = this.elytraRotationEvent.getOriginal().getPitch();
+            this.elytraRotationEvent = null;
+        }
+    }
+
     @Redirect(
             method = "travel",
             at = @At(
@@ -86,17 +120,32 @@ public abstract class MixinEntityLivingBase extends Entity {
                     target = "net/minecraft/entity/EntityLivingBase.moveRelative(FFFF)V"
             )
     )
-    private void travel(EntityLivingBase self, float strafe, float up, float forward, float friction) {
-        // noinspection ConstantConditions
-        if (!EntityPlayerSP.class.isInstance(this) || BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this) == null) {
+    private void onMoveRelative(EntityLivingBase self, float strafe, float up, float forward, float friction) {
+        Optional<IBaritone> baritone = this.getBaritone();
+        if (!baritone.isPresent()) {
             moveRelative(strafe, up, forward, friction);
             return;
         }
-        RotationMoveEvent motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
-        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(motionUpdateRotationEvent);
-        float originalYaw = this.rotationYaw;
-        this.rotationYaw = motionUpdateRotationEvent.getYaw();
+
+        RotationMoveEvent event = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw, this.rotationPitch);
+        baritone.get().getGameEventHandler().onPlayerRotationMove(event);
+
+        this.rotationYaw = event.getYaw();
+        this.rotationPitch = event.getPitch();
+
         this.moveRelative(strafe, up, forward, friction);
-        this.rotationYaw = originalYaw;
+
+        this.rotationYaw = event.getOriginal().getYaw();
+        this.rotationPitch = event.getOriginal().getPitch();
+    }
+
+    @Unique
+    private Optional<IBaritone> getBaritone() {
+        // noinspection ConstantConditions
+        if (EntityPlayerSP.class.isInstance(this)) {
+            return Optional.ofNullable(BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this));
+        } else {
+            return Optional.empty();
+        }
     }
 }

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

@@ -61,9 +61,8 @@ public class MixinEntityPlayerSP {
             method = "onUpdate",
             at = @At(
                     value = "INVOKE",
-                    target = "net/minecraft/client/entity/EntityPlayerSP.isRiding()Z",
-                    shift = At.Shift.BY,
-                    by = -3
+                    target = "net/minecraft/client/entity/AbstractClientPlayer.onUpdate()V",
+                    shift = At.Shift.AFTER
             )
     )
     private void onPreUpdate(CallbackInfo ci) {
@@ -73,22 +72,6 @@ public class MixinEntityPlayerSP {
         }
     }
 
-    @Inject(
-            method = "onUpdate",
-            at = @At(
-                    value = "INVOKE",
-                    target = "net/minecraft/client/entity/EntityPlayerSP.onUpdateWalkingPlayer()V",
-                    shift = At.Shift.BY,
-                    by = 2
-            )
-    )
-    private void onPostUpdate(CallbackInfo ci) {
-        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this);
-        if (baritone != null) {
-            baritone.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.POST));
-        }
-    }
-
     @Redirect(
             method = "onLivingUpdate",
             at = @At(

src/launch/java/baritone/launch/mixins/MixinEntityRenderer.java

@@ -21,6 +21,7 @@ import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.event.events.RenderEvent;
 import net.minecraft.client.renderer.EntityRenderer;
+import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -38,7 +39,13 @@ public class MixinEntityRenderer {
             )
     )
     private void renderWorldPass(int pass, float partialTicks, long finishTimeNano, CallbackInfo ci) {
+        int renderViewDimension = BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext().world().provider.getDimensionType().getId();
+
         for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            World world = ibaritone.getPlayerContext().world();
+            if (world == null || world.provider.getDimensionType().getId() != renderViewDimension) {
+                continue;
+            }
             ibaritone.getGameEventHandler().onRenderPass(new RenderEvent(partialTicks));
         }
     }

src/launch/java/baritone/launch/mixins/MixinGameSettings.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.launch.mixins;
+
+import baritone.utils.accessor.IGameSettings;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.GameSettings;
+import net.minecraft.entity.player.EnumPlayerModelParts;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Set;
+
+/**
+ * @author Brady
+ * @since 3/6/2020
+ */
+@Mixin(GameSettings.class)
+public abstract class MixinGameSettings implements IGameSettings {
+
+    @Accessor
+    @Override
+    public abstract void setSetModelParts(Set<EnumPlayerModelParts> setModelParts);
+
+    @Accessor
+    @Override
+    public abstract void setMc(Minecraft mc);
+}

src/launch/java/baritone/launch/mixins/MixinIntegratedServer.java

@@ -0,0 +1,36 @@
+/*
+ * 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.IIntegratedServer;
+import net.minecraft.client.multiplayer.ThreadLanServerPing;
+import net.minecraft.server.integrated.IntegratedServer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+/**
+ * @author Brady
+ * @since 3/4/2020
+ */
+@Mixin(IntegratedServer.class)
+public abstract class MixinIntegratedServer implements IIntegratedServer {
+
+    @Accessor
+    @Override
+    public abstract ThreadLanServerPing getLanServerPing();
+}

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

@@ -20,9 +20,11 @@ package baritone.launch.mixins;
 import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.event.events.BlockInteractEvent;
+import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.TickEvent;
 import baritone.api.event.events.WorldEvent;
 import baritone.api.event.events.type.EventState;
+import baritone.utils.accessor.IMinecraft;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.gui.GuiScreen;
@@ -32,7 +34,9 @@ import net.minecraft.util.EnumActionResult;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -40,6 +44,7 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
+import java.io.File;
 import java.util.function.BiFunction;
 
 /**
@@ -47,13 +52,19 @@ import java.util.function.BiFunction;
  * @since 7/31/2018
  */
 @Mixin(Minecraft.class)
-public class MixinMinecraft {
+public class MixinMinecraft implements IMinecraft {
 
     @Shadow
     public EntityPlayerSP player;
+
     @Shadow
     public WorldClient world;
 
+    @Shadow
+    @Final
+    @Mutable
+    public File gameDir;
+
     @Inject(
             method = "init",
             at = @At("RETURN")
@@ -84,7 +95,21 @@ public class MixinMinecraft {
 
             baritone.getGameEventHandler().onTick(tickProvider.apply(EventState.PRE, type));
         }
+    }
 
+    @Inject(
+            method = "runTick",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/multiplayer/WorldClient.updateEntities()V",
+                    shift = At.Shift.AFTER
+            )
+    )
+    private void postUpdateEntities(CallbackInfo ci) {
+        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(this.player);
+        if (baritone != null) {
+            baritone.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.POST));
+        }
     }
 
     @Inject(
@@ -161,4 +186,9 @@ public class MixinMinecraft {
         // rightClickMouse is only for the main player
         BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onBlockInteract(new BlockInteractEvent(blockpos, BlockInteractEvent.Type.USE));
     }
+
+    @Override
+    public void setGameDir(File gameDir) {
+        this.gameDir = gameDir;
+    }
 }

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

@@ -23,7 +23,9 @@ import baritone.api.IBaritone;
 import baritone.api.event.events.ChunkEvent;
 import baritone.api.event.events.type.EventState;
 import baritone.cache.CachedChunk;
+import baritone.utils.accessor.INetHandlerPlayClient;
 import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.multiplayer.WorldClient;
 import net.minecraft.client.network.NetHandlerPlayClient;
 import net.minecraft.network.play.server.SPacketBlockChange;
 import net.minecraft.network.play.server.SPacketChunkData;
@@ -31,6 +33,7 @@ import net.minecraft.network.play.server.SPacketCombatEvent;
 import net.minecraft.network.play.server.SPacketMultiBlockChange;
 import net.minecraft.util.math.ChunkPos;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@@ -40,7 +43,11 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
  * @since 8/3/2018
  */
 @Mixin(NetHandlerPlayClient.class)
-public class MixinNetHandlerPlayClient {
+public abstract class MixinNetHandlerPlayClient implements INetHandlerPlayClient {
+
+    @Accessor
+    @Override
+    public abstract void setWorld(WorldClient world);
 
     @Inject(
             method = "handleChunkData",

src/launch/java/baritone/launch/mixins/MixinThreadLanServerPing.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.launch.mixins;
+
+import baritone.utils.accessor.IThreadLanServerPing;
+import net.minecraft.client.multiplayer.ThreadLanServerPing;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+/**
+ * @author Brady
+ * @since 3/4/2020
+ */
+@Mixin(ThreadLanServerPing.class)
+public abstract class MixinThreadLanServerPing implements IThreadLanServerPing {
+
+    @Accessor
+    @Override
+    public abstract String getMotd();
+
+    @Accessor
+    @Override
+    public abstract String getAddress();
+}

src/launch/resources/mixins.baritone.json

@@ -19,7 +19,9 @@
     "MixinEntityLivingBase",
     "MixinEntityPlayerSP",
     "MixinEntityRenderer",
+    "MixinGameSettings",
     "MixinGuiScreen",
+    "MixinIntegratedServer",
     "MixinItemStack",
     "MixinItemTool",
     "MixinMinecraft",
@@ -31,6 +33,7 @@
     "MixinRenderList",
     "MixinStateImplementation",
     "MixinTabCompleter",
+    "MixinThreadLanServerPing",
     "MixinVboRenderList",
     "MixinWorldClient"
   ]

src/main/java/baritone/Baritone.java

@@ -20,11 +20,13 @@ package baritone;
 import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.Settings;
+import baritone.api.behavior.IBehavior;
 import baritone.api.event.listener.IEventBus;
-import baritone.api.utils.Helper;
+import baritone.api.process.IBaritoneProcess;
 import baritone.api.utils.IPlayerContext;
 import baritone.behavior.*;
 import baritone.cache.WorldProvider;
+import baritone.command.ExampleBaritoneControl;
 import baritone.command.manager.CommandManager;
 import baritone.event.GameEventHandler;
 import baritone.process.*;
@@ -33,16 +35,18 @@ import baritone.utils.BlockStateInterface;
 import baritone.utils.GuiClick;
 import baritone.utils.InputOverrideHandler;
 import baritone.utils.PathingControlManager;
-import baritone.utils.player.PrimaryPlayerContext;
+import baritone.utils.player.BaritonePlayerContext;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
 
-import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.concurrent.Executor;
 import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 /**
  * @author Brady
@@ -50,87 +54,101 @@ import java.util.concurrent.TimeUnit;
  */
 public class Baritone implements IBaritone {
 
-    private static ThreadPoolExecutor threadPool;
-    private static File dir;
+    private static final ThreadPoolExecutor threadPool;
 
     static {
         threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
-
-        dir = new File(Minecraft.getMinecraft().gameDir, "baritone");
-        if (!Files.exists(dir.toPath())) {
-            try {
-                Files.createDirectories(dir.toPath());
-            } catch (IOException ignored) {}
-        }
     }
 
-    private GameEventHandler gameEventHandler;
+    private final Minecraft mc;
+    private final Path directory;
 
-    private PathingBehavior pathingBehavior;
-    private LookBehavior lookBehavior;
-    private InventoryBehavior inventoryBehavior;
-    private WaypointBehavior waypointBehavior;
-    private InputOverrideHandler inputOverrideHandler;
+    private final GameEventHandler gameEventHandler;
 
-    private FollowProcess followProcess;
-    private MineProcess mineProcess;
-    private GetToBlockProcess getToBlockProcess;
-    private CustomGoalProcess customGoalProcess;
-    private BuilderProcess builderProcess;
-    private ExploreProcess exploreProcess;
-    private BackfillProcess backfillProcess;
-    private FarmProcess farmProcess;
+    private final PathingBehavior pathingBehavior;
+    private final LookBehavior lookBehavior;
+    private final InventoryBehavior inventoryBehavior;
+    private final InputOverrideHandler inputOverrideHandler;
 
-    private PathingControlManager pathingControlManager;
-    private SelectionManager selectionManager;
-    private CommandManager commandManager;
+    private final FollowProcess followProcess;
+    private final MineProcess mineProcess;
+    private final GetToBlockProcess getToBlockProcess;
+    private final CustomGoalProcess customGoalProcess;
+    private final BuilderProcess builderProcess;
+    private final ExploreProcess exploreProcess;
+    private final FarmProcess farmProcess;
+    private final InventoryPauserProcess inventoryPauserProcess;
 
-    private IPlayerContext playerContext;
-    private WorldProvider worldProvider;
+    private final PathingControlManager pathingControlManager;
+    private final SelectionManager selectionManager;
+    private final CommandManager commandManager;
+
+    private final IPlayerContext playerContext;
+    private final WorldProvider worldProvider;
 
     public BlockStateInterface bsi;
 
-    Baritone() {
+    Baritone(Minecraft mc) {
+        this.mc = mc;
         this.gameEventHandler = new GameEventHandler(this);
 
+        this.directory = mc.gameDir.toPath().resolve("baritone");
+        if (!Files.exists(this.directory)) {
+            try {
+                Files.createDirectories(this.directory);
+            } catch (IOException ignored) {}
+        }
+
         // Define this before behaviors try and get it, or else it will be null and the builds will fail!
-        this.playerContext = PrimaryPlayerContext.INSTANCE;
+        this.playerContext = new BaritonePlayerContext(this, mc);
 
         {
-            // the Behavior constructor calls baritone.registerBehavior(this) so this populates the behaviors arraylist
-            pathingBehavior = new PathingBehavior(this);
-            lookBehavior = new LookBehavior(this);
-            inventoryBehavior = new InventoryBehavior(this);
-            inputOverrideHandler = new InputOverrideHandler(this);
-            waypointBehavior = new WaypointBehavior(this);
+            this.lookBehavior         = this.registerBehavior(LookBehavior::new);
+            this.pathingBehavior      = this.registerBehavior(PathingBehavior::new);
+            this.inventoryBehavior    = this.registerBehavior(InventoryBehavior::new);
+            this.inputOverrideHandler = this.registerBehavior(InputOverrideHandler::new);
+            this.registerBehavior(WaypointBehavior::new);
         }
 
         this.pathingControlManager = new PathingControlManager(this);
         {
-            this.pathingControlManager.registerProcess(followProcess = new FollowProcess(this));
-            this.pathingControlManager.registerProcess(mineProcess = new MineProcess(this));
-            this.pathingControlManager.registerProcess(customGoalProcess = new CustomGoalProcess(this)); // very high iq
-            this.pathingControlManager.registerProcess(getToBlockProcess = new GetToBlockProcess(this));
-            this.pathingControlManager.registerProcess(builderProcess = new BuilderProcess(this));
-            this.pathingControlManager.registerProcess(exploreProcess = new ExploreProcess(this));
-            this.pathingControlManager.registerProcess(backfillProcess = new BackfillProcess(this));
-            this.pathingControlManager.registerProcess(farmProcess = new FarmProcess(this));
+            this.followProcess           = this.registerProcess(FollowProcess::new);
+            this.mineProcess             = this.registerProcess(MineProcess::new);
+            this.customGoalProcess       = this.registerProcess(CustomGoalProcess::new); // very high iq
+            this.getToBlockProcess       = this.registerProcess(GetToBlockProcess::new);
+            this.builderProcess          = this.registerProcess(BuilderProcess::new);
+            this.exploreProcess          = this.registerProcess(ExploreProcess::new);
+            this.farmProcess             = this.registerProcess(FarmProcess::new);
+            this.inventoryPauserProcess  = this.registerProcess(InventoryPauserProcess::new);
+            this.registerProcess(BackfillProcess::new);
         }
 
-        this.worldProvider = new WorldProvider();
+        this.worldProvider = new WorldProvider(this);
         this.selectionManager = new SelectionManager(this);
         this.commandManager = new CommandManager(this);
     }
 
+    public void registerBehavior(IBehavior behavior) {
+        this.gameEventHandler.registerEventListener(behavior);
+    }
+
+    public <T extends IBehavior> T registerBehavior(Function<Baritone, T> constructor) {
+        final T behavior = constructor.apply(this);
+        this.registerBehavior(behavior);
+        return behavior;
+    }
+
+    public <T extends IBaritoneProcess> T registerProcess(Function<Baritone, T> constructor) {
+        final T behavior = constructor.apply(this);
+        this.pathingControlManager.registerProcess(behavior);
+        return behavior;
+    }
+
     @Override
     public PathingControlManager getPathingControlManager() {
         return this.pathingControlManager;
     }
 
-    public void registerBehavior(Behavior behavior) {
-        this.gameEventHandler.registerEventListener(behavior);
-    }
-
     @Override
     public InputOverrideHandler getInputOverrideHandler() {
         return this.inputOverrideHandler;
@@ -170,6 +188,7 @@ public class Baritone implements IBaritone {
         return this.lookBehavior;
     }
 
+    @Override
     public ExploreProcess getExploreProcess() {
         return this.exploreProcess;
     }
@@ -179,10 +198,15 @@ public class Baritone implements IBaritone {
         return this.mineProcess;
     }
 
+    @Override
     public FarmProcess getFarmProcess() {
         return this.farmProcess;
     }
 
+    public InventoryPauserProcess getInventoryPauserProcess() {
+        return this.inventoryPauserProcess;
+    }
+
     @Override
     public PathingBehavior getPathingBehavior() {
         return this.pathingBehavior;
@@ -210,22 +234,26 @@ public class Baritone implements IBaritone {
 
     @Override
     public void openClick() {
+        this.showScreen(new GuiClick());
+    }
+
+    public void showScreen(GuiScreen screen) {
         new Thread(() -> {
             try {
                 Thread.sleep(100);
-                Helper.mc.addScheduledTask(() -> Helper.mc.displayGuiScreen(new GuiClick()));
+                mc.addScheduledTask(() -> mc.displayGuiScreen(screen));
             } catch (Exception ignored) {}
         }).start();
     }
 
+    public Path getDirectory() {
+        return this.directory;
+    }
+
     public static Settings settings() {
         return BaritoneAPI.getSettings();
     }
 
-    public static File getDir() {
-        return dir;
-    }
-
     public static Executor getExecutor() {
         return threadPool;
     }

src/main/java/baritone/BaritoneProvider.java

@@ -19,16 +19,20 @@ package baritone;
 
 import baritone.api.IBaritone;
 import baritone.api.IBaritoneProvider;
+import baritone.api.bot.IUserManager;
 import baritone.api.cache.IWorldScanner;
 import baritone.api.command.ICommandSystem;
 import baritone.api.schematic.ISchematicSystem;
-import baritone.cache.WorldScanner;
+import baritone.bot.UserManager;
+import baritone.cache.FasterWorldScanner;
 import baritone.command.CommandSystem;
 import baritone.command.ExampleBaritoneControl;
 import baritone.utils.schematic.SchematicSystem;
+import net.minecraft.client.Minecraft;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
  * @author Brady
@@ -36,30 +40,50 @@ import java.util.List;
  */
 public final class BaritoneProvider implements IBaritoneProvider {
 
-    private final Baritone primary;
     private final List<IBaritone> all;
+    private final List<IBaritone> allView;
 
-    {
-        this.primary = new Baritone();
-        this.all = Collections.singletonList(this.primary);
+    public BaritoneProvider() {
+        this.all = new CopyOnWriteArrayList<>();
+        this.allView = Collections.unmodifiableList(this.all);
 
         // Setup chat control, just for the primary instance
-        new ExampleBaritoneControl(this.primary);
+        final Baritone primary = (Baritone) this.createBaritone(Minecraft.getMinecraft());
+        primary.registerBehavior(ExampleBaritoneControl::new);
     }
 
     @Override
     public IBaritone getPrimaryBaritone() {
-        return primary;
+        return this.all.get(0);
     }
 
     @Override
     public List<IBaritone> getAllBaritones() {
-        return all;
+        return this.allView;
+    }
+
+    @Override
+    public synchronized IBaritone createBaritone(Minecraft minecraft) {
+        IBaritone baritone = this.getBaritoneForMinecraft(minecraft);
+        if (baritone == null) {
+            this.all.add(baritone = new Baritone(minecraft));
+        }
+        return baritone;
+    }
+
+    @Override
+    public synchronized boolean destroyBaritone(IBaritone baritone) {
+        return baritone != this.getPrimaryBaritone() && this.all.remove(baritone);
     }
 
     @Override
     public IWorldScanner getWorldScanner() {
-        return WorldScanner.INSTANCE;
+        return FasterWorldScanner.INSTANCE;
+    }
+
+    @Override
+    public IUserManager getUserManager() {
+        return UserManager.INSTANCE;
     }
 
     @Override

src/main/java/baritone/behavior/Behavior.java

@@ -35,6 +35,5 @@ public class Behavior implements IBehavior {
     protected Behavior(Baritone baritone) {
         this.baritone = baritone;
         this.ctx = baritone.getPlayerContext();
-        baritone.registerBehavior(this);
     }
 }

src/main/java/baritone/behavior/InventoryBehavior.java

@@ -19,6 +19,7 @@ package baritone.behavior;
 
 import baritone.Baritone;
 import baritone.api.event.events.TickEvent;
+import baritone.api.utils.Helper;
 import baritone.utils.ToolSet;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
@@ -34,7 +35,10 @@ import java.util.OptionalInt;
 import java.util.Random;
 import java.util.function.Predicate;
 
-public final class InventoryBehavior extends Behavior {
+public final class InventoryBehavior extends Behavior implements Helper {
+
+    int ticksSinceLastInventoryMove;
+    int[] lastTickRequestedMove; // not everything asks every tick, so remember the request while coming to a halt
 
     public InventoryBehavior(Baritone baritone) {
         super(baritone);
@@ -52,20 +56,28 @@ public final class InventoryBehavior extends Behavior {
             // we have a crafting table or a chest or something open
             return;
         }
+        ticksSinceLastInventoryMove++;
         if (firstValidThrowaway() >= 9) { // aka there are none on the hotbar, but there are some in main inventory
-            swapWithHotBar(firstValidThrowaway(), 8);
+            requestSwapWithHotBar(firstValidThrowaway(), 8);
         }
         int pick = bestToolAgainst(Blocks.STONE, ItemPickaxe.class);
         if (pick >= 9) {
-            swapWithHotBar(pick, 0);
+            requestSwapWithHotBar(pick, 0);
+        }
+        if (lastTickRequestedMove != null) {
+            logDebug("Remembering to move " + lastTickRequestedMove[0] + " " + lastTickRequestedMove[1] + " from a previous tick");
+            requestSwapWithHotBar(lastTickRequestedMove[0], lastTickRequestedMove[1]);
         }
     }
 
-    public void attemptToPutOnHotbar(int inMainInvy, Predicate<Integer> disallowedHotbar) {
+    public boolean attemptToPutOnHotbar(int inMainInvy, Predicate<Integer> disallowedHotbar) {
         OptionalInt destination = getTempHotbarSlot(disallowedHotbar);
         if (destination.isPresent()) {
-            swapWithHotBar(inMainInvy, destination.getAsInt());
+            if (!requestSwapWithHotBar(inMainInvy, destination.getAsInt())) {
+                return false;
+            }
         }
+        return true;
     }
 
     public OptionalInt getTempHotbarSlot(Predicate<Integer> disallowedHotbar) {
@@ -89,8 +101,20 @@ public final class InventoryBehavior extends Behavior {
         return OptionalInt.of(candidates.get(new Random().nextInt(candidates.size())));
     }
 
-    private void swapWithHotBar(int inInventory, int inHotbar) {
+    private boolean requestSwapWithHotBar(int inInventory, int inHotbar) {
+        lastTickRequestedMove = new int[]{inInventory, inHotbar};
+        if (ticksSinceLastInventoryMove < Baritone.settings().ticksBetweenInventoryMoves.value) {
+            logDebug("Inventory move requested but delaying " + ticksSinceLastInventoryMove + " " + Baritone.settings().ticksBetweenInventoryMoves.value);
+            return false;
+        }
+        if (Baritone.settings().inventoryMoveOnlyIfStationary.value && !baritone.getInventoryPauserProcess().stationaryForInventoryMove()) {
+            logDebug("Inventory move requested but delaying until stationary");
+            return false;
+        }
         ctx.playerController().windowClick(ctx.player().inventoryContainer.windowId, inInventory < 9 ? inInventory + 36 : inInventory, inHotbar, ClickType.SWAP, ctx.player());
+        ticksSinceLastInventoryMove = 0;
+        lastTickRequestedMove = null;
+        return true;
     }
 
     private int firstValidThrowaway() { // TODO offhand idk
@@ -192,8 +216,8 @@ public final class InventoryBehavior extends Behavior {
         if (allowInventory) {
             for (int i = 9; i < 36; i++) {
                 if (desired.test(inv.get(i))) {
-                    swapWithHotBar(i, 7);
                     if (select) {
+                        requestSwapWithHotBar(i, 7);
                         p.inventory.currentItem = 7;
                     }
                     return true;

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

@@ -20,40 +20,57 @@ package baritone.behavior;
 import baritone.Baritone;
 import baritone.api.Settings;
 import baritone.api.behavior.ILookBehavior;
-import baritone.api.event.events.PlayerUpdateEvent;
-import baritone.api.event.events.RotationMoveEvent;
+import baritone.api.behavior.look.IAimProcessor;
+import baritone.api.behavior.look.ITickableAimProcessor;
+import baritone.api.event.events.*;
+import baritone.api.utils.IPlayerContext;
 import baritone.api.utils.Rotation;
+import baritone.behavior.look.ForkableRandom;
+import net.minecraft.network.play.client.CPacketPlayer;
+
+import java.util.Optional;
 
 public final class LookBehavior extends Behavior implements ILookBehavior {
 
     /**
-     * Target's values are as follows:
-     * <p>
-     * getFirst() -> yaw
-     * getSecond() -> pitch
+     * The current look target, may be {@code null}.
      */
-    private Rotation target;
+    private Target target;
 
     /**
-     * Whether or not rotations are currently being forced
+     * The rotation known to the server. Returned by {@link #getEffectiveRotation()} for use in {@link IPlayerContext}.
      */
-    private boolean force;
+    private Rotation serverRotation;
 
     /**
-     * The last player yaw angle. Used when free looking
+     * The last player rotation. Used to restore the player's angle when using free look.
      *
      * @see Settings#freeLook
      */
-    private float lastYaw;
+    private Rotation prevRotation;
+
+    private final AimProcessor processor;
 
     public LookBehavior(Baritone baritone) {
         super(baritone);
+        this.processor = new AimProcessor(baritone.getPlayerContext());
     }
 
     @Override
-    public void updateTarget(Rotation target, boolean force) {
-        this.target = target;
-        this.force = force || !Baritone.settings().freeLook.value;
+    public void updateTarget(Rotation rotation, boolean blockInteract) {
+        this.target = new Target(rotation, blockInteract);
+    }
+
+    @Override
+    public IAimProcessor getAimProcessor() {
+        return this.processor;
+    }
+
+    @Override
+    public void onTick(TickEvent event) {
+        if (event.getType() == TickEvent.Type.IN) {
+            this.processor.tick();
+        }
     }
 
     @Override
@@ -61,35 +78,30 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
         if (this.target == null) {
             return;
         }
-
-        // Whether or not we're going to silently set our angles
-        boolean silent = Baritone.settings().antiCheatCompatibility.value && !this.force;
-
         switch (event.getState()) {
             case PRE: {
-                if (this.force) {
-                    ctx.player().rotationYaw = this.target.getYaw();
-                    float oldPitch = ctx.player().rotationPitch;
-                    float desiredPitch = this.target.getPitch();
-                    ctx.player().rotationPitch = desiredPitch;
-                    ctx.player().rotationYaw += (Math.random() - 0.5) * Baritone.settings().randomLooking.value;
-                    ctx.player().rotationPitch += (Math.random() - 0.5) * Baritone.settings().randomLooking.value;
-                    if (desiredPitch == oldPitch && !Baritone.settings().freeLook.value) {
-                        nudgeToLevel();
-                    }
-                    this.target = null;
+                if (this.target.mode == Target.Mode.NONE) {
+                    // Just return for PRE, we still want to set target to null on POST
+                    return;
                 }
-                if (silent) {
-                    this.lastYaw = ctx.player().rotationYaw;
-                    ctx.player().rotationYaw = this.target.getYaw();
+                if (this.target.mode == Target.Mode.SERVER) {
+                    this.prevRotation = new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch);
                 }
+
+                final Rotation actual = this.processor.peekRotation(this.target.rotation);
+                ctx.player().rotationYaw = actual.getYaw();
+                ctx.player().rotationPitch = actual.getPitch();
                 break;
             }
             case POST: {
-                if (silent) {
-                    ctx.player().rotationYaw = this.lastYaw;
-                    this.target = null;
+                // Reset the player's rotations back to their original values
+                if (this.prevRotation != null) {
+                    ctx.player().rotationYaw = this.prevRotation.getYaw();
+                    ctx.player().rotationPitch = this.prevRotation.getPitch();
+                    this.prevRotation = null;
                 }
+                // The target is done being used for this game tick, so it can be invalidated
+                this.target = null;
                 break;
             }
             default:
@@ -97,34 +109,214 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
         }
     }
 
+    @Override
+    public void onSendPacket(PacketEvent event) {
+        if (!(event.getPacket() instanceof CPacketPlayer)) {
+            return;
+        }
+
+        final CPacketPlayer packet = (CPacketPlayer) event.getPacket();
+        if (packet instanceof CPacketPlayer.Rotation || packet instanceof CPacketPlayer.PositionRotation) {
+            this.serverRotation = new Rotation(packet.getYaw(0.0f), packet.getPitch(0.0f));
+        }
+    }
+
+    @Override
+    public void onWorldEvent(WorldEvent event) {
+        this.serverRotation = null;
+        this.target = null;
+    }
+
     public void pig() {
         if (this.target != null) {
-            ctx.player().rotationYaw = this.target.getYaw();
+            final Rotation actual = this.processor.peekRotation(this.target.rotation);
+            ctx.player().rotationYaw = actual.getYaw();
         }
     }
 
+    public Optional<Rotation> getEffectiveRotation() {
+        if (Baritone.settings().freeLook.value || Baritone.settings().blockFreeLook.value) {
+            return Optional.ofNullable(this.serverRotation);
+        }
+        // If neither of the freeLook settings are on, just defer to the player's actual rotations
+        return Optional.empty();
+    }
+
     @Override
     public void onPlayerRotationMove(RotationMoveEvent event) {
         if (this.target != null) {
+            final Rotation actual = this.processor.peekRotation(this.target.rotation);
+            event.setYaw(actual.getYaw());
+            event.setPitch(actual.getPitch());
+        }
+    }
 
-            event.setYaw(this.target.getYaw());
+    private static final class AimProcessor extends AbstractAimProcessor {
 
-            // If we have antiCheatCompatibility on, we're going to use the target value later in onPlayerUpdate()
-            // Also the type has to be MOTION_UPDATE because that is called after JUMP
-            if (!Baritone.settings().antiCheatCompatibility.value && event.getType() == RotationMoveEvent.Type.MOTION_UPDATE && !this.force) {
-                this.target = null;
+        public AimProcessor(final IPlayerContext ctx) {
+            super(ctx);
+        }
+
+        @Override
+        protected Rotation getPrevRotation() {
+            // Implementation will use LookBehavior.serverRotation
+            return ctx.playerRotations();
+        }
+    }
+
+    private static abstract class AbstractAimProcessor implements ITickableAimProcessor {
+
+        protected final IPlayerContext ctx;
+        private final ForkableRandom rand;
+        private double randomYawOffset;
+        private double randomPitchOffset;
+
+        public AbstractAimProcessor(IPlayerContext ctx) {
+            this.ctx = ctx;
+            this.rand = new ForkableRandom();
+        }
+
+        private AbstractAimProcessor(final AbstractAimProcessor source) {
+            this.ctx = source.ctx;
+            this.rand = source.rand.fork();
+            this.randomYawOffset = source.randomYawOffset;
+            this.randomPitchOffset = source.randomPitchOffset;
+        }
+
+        @Override
+        public final Rotation peekRotation(final Rotation rotation) {
+            final Rotation prev = this.getPrevRotation();
+
+            float desiredYaw = rotation.getYaw();
+            float desiredPitch = rotation.getPitch();
+
+            // In other words, the target doesn't care about the pitch, so it used playerRotations().getPitch()
+            // and it's safe to adjust it to a normal level
+            if (desiredPitch == prev.getPitch()) {
+                desiredPitch = nudgeToLevel(desiredPitch);
+            }
+
+            desiredYaw += this.randomYawOffset;
+            desiredPitch += this.randomPitchOffset;
+
+            return new Rotation(
+                    this.calculateMouseMove(prev.getYaw(), desiredYaw),
+                    this.calculateMouseMove(prev.getPitch(), desiredPitch)
+            ).clamp();
+        }
+
+        @Override
+        public final void tick() {
+            this.randomYawOffset = (this.rand.nextDouble() - 0.5) * Baritone.settings().randomLooking.value;
+            this.randomPitchOffset = (this.rand.nextDouble() - 0.5) * Baritone.settings().randomLooking.value;
+        }
+
+        @Override
+        public final void advance(int ticks) {
+            for (int i = 0; i < ticks; i++) {
+                this.tick();
+            }
+        }
+
+        @Override
+        public Rotation nextRotation(final Rotation rotation) {
+            final Rotation actual = this.peekRotation(rotation);
+            this.tick();
+            return actual;
+        }
+
+        @Override
+        public final ITickableAimProcessor fork() {
+            return new AbstractAimProcessor(this) {
+
+                private Rotation prev = AbstractAimProcessor.this.getPrevRotation();
+
+                @Override
+                public Rotation nextRotation(final Rotation rotation) {
+                    return (this.prev = super.nextRotation(rotation));
+                }
+
+                @Override
+                protected Rotation getPrevRotation() {
+                    return this.prev;
+                }
+            };
+        }
+
+        protected abstract Rotation getPrevRotation();
+
+        /**
+         * Nudges the player's pitch to a regular level. (Between {@code -20} and {@code 10}, increments are by {@code 1})
+         */
+        private float nudgeToLevel(float pitch) {
+            if (pitch < -20) {
+                return pitch + 1;
+            } else if (pitch > 10) {
+                return pitch - 1;
+            }
+            return pitch;
+        }
+
+        private float calculateMouseMove(float current, float target) {
+            final float delta = target - current;
+            final int deltaPx = angleToMouse(delta);
+            return current + mouseToAngle(deltaPx);
+        }
+
+        private int angleToMouse(float angleDelta) {
+            final float minAngleChange = mouseToAngle(1);
+            return Math.round(angleDelta / minAngleChange);
+        }
+
+        private float mouseToAngle(int mouseDelta) {
+            final float f = ctx.minecraft().gameSettings.mouseSensitivity * 0.6f + 0.2f;
+            return mouseDelta * f * f * f * 8.0f * 0.15f;
+        }
+    }
+
+    private static class Target {
+
+        public final Rotation rotation;
+        public final Mode mode;
+
+        public Target(Rotation rotation, boolean blockInteract) {
+            this.rotation = rotation;
+            this.mode = Mode.resolve(blockInteract);
+        }
+
+        enum Mode {
+            /**
+             * Rotation will be set client-side and is visual to the player
+             */
+            CLIENT,
+
+            /**
+             * Rotation will be set server-side and is silent to the player
+             */
+            SERVER,
+
+            /**
+             * Rotation will remain unaffected on both the client and server
+             */
+            NONE;
+
+            static Mode resolve(boolean blockInteract) {
+                final Settings settings = Baritone.settings();
+                final boolean antiCheat = settings.antiCheatCompatibility.value;
+                final boolean blockFreeLook = settings.blockFreeLook.value;
+                final boolean freeLook = settings.freeLook.value;
+
+                if (!freeLook && !blockFreeLook) return CLIENT;
+                if (!blockFreeLook && blockInteract) return CLIENT;
+
+                // Regardless of if antiCheatCompatibility is enabled, if a blockInteract is requested then the player
+                // rotation needs to be set somehow, otherwise Baritone will halt since objectMouseOver() will just be
+                // whatever the player is mousing over visually. Let's just settle for setting it silently.
+                if (antiCheat || blockInteract) return SERVER;
+
+                // Pathing regularly without antiCheatCompatibility, don't set the player rotation
+                return NONE;
             }
         }
     }
-
-    /**
-     * Nudges the player's pitch to a regular level. (Between {@code -20} and {@code 10}, increments are by {@code 1})
-     */
-    private void nudgeToLevel() {
-        if (ctx.player().rotationPitch < -20) {
-            ctx.player().rotationPitch++;
-        } else if (ctx.player().rotationPitch > 10) {
-            ctx.player().rotationPitch--;
-        }
-    }
 }

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

@@ -239,11 +239,11 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         if (current != null) {
             switch (event.getState()) {
                 case PRE:
-                    lastAutoJump = mc.gameSettings.autoJump;
-                    mc.gameSettings.autoJump = false;
+                    lastAutoJump = ctx.minecraft().gameSettings.autoJump;
+                    ctx.minecraft().gameSettings.autoJump = false;
                     break;
                 case POST:
-                    mc.gameSettings.autoJump = lastAutoJump;
+                    ctx.minecraft().gameSettings.autoJump = lastAutoJump;
                     break;
                 default:
                     break;

src/main/java/baritone/behavior/look/ForkableRandom.java

@@ -0,0 +1,85 @@
+/*
+ * 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.behavior.look;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongSupplier;
+
+/**
+ * Implementation of Xoroshiro256++
+ * <p>
+ * Extended to produce random double-precision floating point numbers, and allow copies to be spawned via {@link #fork},
+ * which share the same internal state as the source object.
+ *
+ * @author Brady
+ */
+public final class ForkableRandom {
+
+    private static final double DOUBLE_UNIT = 0x1.0p-53;
+
+    private final long[] s;
+
+    public ForkableRandom() {
+        this(System.nanoTime() ^ System.currentTimeMillis());
+    }
+
+    public ForkableRandom(long seedIn) {
+        final AtomicLong seed = new AtomicLong(seedIn);
+        final LongSupplier splitmix64 = () -> {
+            long z = seed.addAndGet(0x9e3779b97f4a7c15L);
+            z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
+            z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
+            return z ^ (z >>> 31);
+        };
+        this.s = new long[] {
+                splitmix64.getAsLong(),
+                splitmix64.getAsLong(),
+                splitmix64.getAsLong(),
+                splitmix64.getAsLong()
+        };
+    }
+
+    private ForkableRandom(long[] s) {
+        this.s = s;
+    }
+
+    public double nextDouble() {
+        return (this.next() >>> 11) * DOUBLE_UNIT;
+    }
+
+    public long next() {
+        final long result = rotl(this.s[0] + this.s[3], 23) + this.s[0];
+        final long t = this.s[1] << 17;
+        this.s[2] ^= this.s[0];
+        this.s[3] ^= this.s[1];
+        this.s[1] ^= this.s[2];
+        this.s[0] ^= this.s[3];
+        this.s[2] ^= t;
+        this.s[3] = rotl(this.s[3], 45);
+        return result;
+    }
+
+    public ForkableRandom fork() {
+        return new ForkableRandom(Arrays.copyOf(this.s, 4));
+    }
+
+    private static long rotl(long x, int k) {
+        return (x << k) | (x >>> (64 - k));
+    }
+}

src/main/java/baritone/bot/BaritoneUser.java

@@ -0,0 +1,107 @@
+/*
+ * 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.bot;
+
+import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
+import baritone.api.bot.IBaritoneUser;
+import baritone.api.event.events.WorldEvent;
+import baritone.api.event.events.type.EventState;
+import baritone.api.utils.IPlayerContext;
+import baritone.bot.impl.BotMinecraft;
+import baritone.bot.impl.BotWorld;
+import baritone.bot.impl.BotPlayer;
+import baritone.command.ExampleBaritoneControl;
+import com.mojang.authlib.GameProfile;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.util.Session;
+
+/**
+ * Implementation of {@link IBaritoneUser}
+ *
+ * @author Brady
+ * @since 11/6/2018
+ */
+public final class BaritoneUser implements IBaritoneUser {
+
+    private final BotMinecraft mc;
+    private final UserManager manager;
+    private final NetworkManager networkManager;
+    private final Session session;
+    private final Baritone baritone;
+
+    private GameProfile profile;
+
+    BaritoneUser(UserManager manager, NetworkManager networkManager, Session session, ServerData serverData) {
+        this.mc = BotMinecraft.allocate(this);
+        this.mc.setServerData(serverData);
+        this.manager = manager;
+        this.networkManager = networkManager;
+        this.session = session;
+        this.profile = session.getProfile();
+        this.baritone = (Baritone) BaritoneAPI.getProvider().createBaritone(this.mc);
+        this.baritone.registerBehavior(ExampleBaritoneControl::new);
+    }
+
+    public void onLoginSuccess(GameProfile profile) {
+        this.profile = profile;
+    }
+
+    public void onWorldLoad(BotWorld world, BotPlayer player, PlayerControllerMP playerController) {
+        this.baritone.getGameEventHandler().onWorldEvent(new WorldEvent(world, EventState.PRE));
+
+        this.mc.player = player;
+        this.mc.world = world;
+        this.mc.playerController = playerController;
+
+        this.baritone.getGameEventHandler().onWorldEvent(new WorldEvent(world, EventState.POST));
+    }
+
+    @Override
+    public IBaritone getBaritone() {
+        return this.baritone;
+    }
+
+    @Override
+    public IPlayerContext getPlayerContext() {
+        return this.baritone.getPlayerContext();
+    }
+
+    @Override
+    public NetworkManager getNetworkManager() {
+        return this.networkManager;
+    }
+
+    @Override
+    public Session getSession() {
+        return this.session;
+    }
+
+    @Override
+    public GameProfile getProfile() {
+        return this.profile;
+    }
+
+    @Override
+    public UserManager getManager() {
+        return this.manager;
+    }
+}

src/main/java/baritone/bot/BotWorldProvider.java

@@ -0,0 +1,66 @@
+/*
+ * 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.bot;
+
+import baritone.bot.impl.BotWorld;
+import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import net.minecraft.world.GameType;
+import net.minecraft.world.WorldSettings;
+import net.minecraft.world.WorldType;
+
+/**
+ * @author Brady
+ * @since 11/7/2018
+ */
+public final class BotWorldProvider {
+
+    /**
+     * Generic world settings for a typical survival world.
+     */
+    private static final WorldSettings GENERIC_WORLD_SETTINGS = new WorldSettings(0L, GameType.SURVIVAL, true, false, WorldType.DEFAULT);
+
+    /**
+     * All of the dimensions mapped to their respective worlds.
+     */
+    private final Int2ObjectMap<BotWorld> worlds = new Int2ObjectArrayMap<>();
+
+    /**
+     * Gets or creates the {@link BotWorld} for the specified dimension
+     *
+     * @param dimension The dimension id
+     * @return The world
+     */
+    public BotWorld getWorld(int dimension) {
+        return worlds.computeIfAbsent(dimension, this::createWorldForDim);
+    }
+
+    /**
+     * Creates a new {@link BotWorld} for the given dimension id.
+     *
+     * @param dimension The dimension id
+     * @return The new world
+     */
+    private BotWorld createWorldForDim(int dimension) {
+        return new BotWorld(GENERIC_WORLD_SETTINGS, dimension);
+    }
+
+    public void tick() {
+        this.worlds.forEach((dim, world) -> world.updateEntities());
+    }
+}

src/main/java/baritone/bot/UserManager.java

@@ -0,0 +1,203 @@
+/*
+ * 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.bot;
+
+import baritone.api.BaritoneAPI;
+import baritone.api.bot.IBaritoneUser;
+import baritone.api.bot.IUserManager;
+import baritone.api.bot.connect.IConnectionResult;
+import baritone.api.event.events.TickEvent;
+import baritone.api.event.events.type.EventState;
+import baritone.api.event.listener.AbstractGameEventListener;
+import baritone.api.utils.Helper;
+import baritone.api.utils.IPlayerContext;
+import baritone.bot.connect.ConnectionResult;
+import baritone.bot.handler.BotNetHandlerLoginClient;
+import baritone.bot.impl.BotPlayer;
+import baritone.bot.impl.BotWorld;
+import baritone.utils.accessor.IIntegratedServer;
+import baritone.utils.accessor.IThreadLanServerPing;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ServerAddress;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.network.EnumConnectionState;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.handshake.client.C00Handshake;
+import net.minecraft.network.login.client.CPacketLoginStart;
+import net.minecraft.util.Session;
+import net.minecraft.util.text.ITextComponent;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import static baritone.api.bot.connect.ConnectionStatus.*;
+
+/**
+ * @author Brady
+ * @since 11/6/2018
+ */
+public enum UserManager implements IUserManager, AbstractGameEventListener {
+    INSTANCE;
+
+    private static final Minecraft mc = Minecraft.getMinecraft();
+
+    private final List<IBaritoneUser> users;
+    private final BotWorldProvider worldProvider;
+
+    UserManager() {
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().registerEventListener(this);
+        this.users = new CopyOnWriteArrayList<>();
+        this.worldProvider = new BotWorldProvider();
+    }
+
+    @Override
+    public void onTick(TickEvent event) {
+        if (event.getState() != EventState.PRE) {
+            return;
+        }
+
+        this.users.forEach(user -> {
+            switch (event.getType()) {
+                case IN: {
+                    final IPlayerContext ctx = user.getPlayerContext();
+                    if (ctx.player() != null) {
+                        ctx.playerController().syncHeldItem();
+                    }
+                    if (user.getNetworkManager().isChannelOpen()) {
+                        user.getNetworkManager().processReceivedPackets();
+                    } else {
+                        user.getNetworkManager().handleDisconnection();
+                    }
+                    break;
+                }
+                case OUT: {
+                    this.disconnect(user, null);
+                    break;
+                }
+            }
+        });
+
+        this.worldProvider.tick();
+    }
+
+    /**
+     * Connects a new user with the specified {@link Session} to the current server.
+     *
+     * @param session The user session
+     * @return The result of the attempted connection
+     */
+    @Override
+    public final IConnectionResult connect(Session session) {
+        if (mc.getIntegratedServer() != null && mc.getIntegratedServer().getPublic()) {
+            try {
+                IIntegratedServer integratedServer = (IIntegratedServer) mc.getIntegratedServer();
+                IThreadLanServerPing lanServerPing = (IThreadLanServerPing) integratedServer.getLanServerPing();
+                int port = Integer.parseInt(lanServerPing.getAddress());
+
+                return connect0(session, new ServerData(lanServerPing.getMotd(), "localhost:" + port, true));
+            } catch (Exception e) {
+                e.printStackTrace();
+                return ConnectionResult.failed(CANT_RESOLVE_LAN);
+            }
+        }
+
+        ServerData data = mc.getCurrentServerData();
+        if (data == null) {
+            return ConnectionResult.failed(NO_CURRENT_CONNECTION);
+        }
+
+        // Connect to the server from the parsed server data
+        return connect0(session, data);
+    }
+
+    /**
+     * Connects a new user with the specified {@link Session} to the specified server.
+     * <p>
+     * Hi Mickey :)
+     *
+     * @param session The user session
+     * @param data The address of the server to connect to
+     * @return The result of the attempted connection
+     */
+    private IConnectionResult connect0(Session session, ServerData data) {
+        ServerAddress address = ServerAddress.fromString(data.serverIP);
+        InetAddress inetAddress;
+
+        try {
+            inetAddress = InetAddress.getByName(address.getIP());
+        } catch (UnknownHostException e) {
+            return ConnectionResult.failed(CANT_RESOLVE_HOST);
+        }
+
+        try {
+            // Initialize Connection
+            NetworkManager networkManager = NetworkManager.createNetworkManagerAndConnect(
+                    inetAddress,
+                    address.getPort(),
+                    mc.gameSettings.isUsingNativeTransport()
+            );
+
+            // Create User
+            BaritoneUser user = new BaritoneUser(this, networkManager, session, data);
+            this.users.add(user);
+
+            // Setup login handler and send connection packets
+            networkManager.setNetHandler(new BotNetHandlerLoginClient(networkManager, user));
+            networkManager.sendPacket(new C00Handshake(address.getIP(), address.getPort(), EnumConnectionState.LOGIN));
+            networkManager.sendPacket(new CPacketLoginStart(session.getProfile()));
+
+            return ConnectionResult.success(user);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ConnectionResult.failed(CONNECTION_FAILED);
+        }
+    }
+
+    /**
+     * @return The bot world provider
+     */
+    public final BotWorldProvider getWorldProvider() {
+        return this.worldProvider;
+    }
+
+    @Override
+    public final void disconnect(IBaritoneUser user, ITextComponent reason) {
+        if (this.users.contains(user)) {
+            if (user.getNetworkManager().isChannelOpen()) {
+                user.getNetworkManager().closeChannel(reason);
+            }
+            BaritoneAPI.getProvider().destroyBaritone(user.getBaritone());
+            this.users.remove(user);
+            Helper.HELPER.logDirect(user.getSession().getUsername() + " Disconnected: " +
+                    (reason == null ? "Unknown" : reason.getUnformattedText()));
+
+            final IPlayerContext ctx = user.getPlayerContext();
+            if (ctx.player() != null && ctx.world() != null) {
+                ((BotWorld) ctx.world()).handleWorldRemove((BotPlayer) ctx.player());
+            }
+        }
+    }
+
+    @Override
+    public final List<IBaritoneUser> getUsers() {
+        return Collections.unmodifiableList(this.users);
+    }
+}

src/main/java/baritone/bot/connect/ConnectionResult.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.bot.connect;
+
+import baritone.api.bot.IBaritoneUser;
+import baritone.api.bot.connect.ConnectionStatus;
+import baritone.api.bot.connect.IConnectionResult;
+
+import java.util.Objects;
+import java.util.Optional;
+
+import static baritone.api.bot.connect.ConnectionStatus.SUCCESS;
+
+/**
+ * @author Brady
+ * @since 11/6/2018
+ */
+public final class ConnectionResult implements IConnectionResult {
+
+    /**
+     * The result status
+     */
+    private final ConnectionStatus status;
+
+    /**
+     * The user created, if the status is {@link ConnectionStatus#SUCCESS}
+     */
+    private final IBaritoneUser user;
+
+    private ConnectionResult(ConnectionStatus status, IBaritoneUser user) {
+        this.status = status;
+        this.user = user;
+    }
+
+    @Override
+    public ConnectionStatus getStatus() {
+        return this.status;
+    }
+
+    @Override
+    public Optional<IBaritoneUser> getUser() {
+        return Optional.ofNullable(user);
+    }
+
+    /**
+     * Creates a new failed {@link ConnectionResult}.
+     *
+     * @param status The failed connection status
+     * @return The connection result
+     * @throws IllegalArgumentException if {@code status} is {@link ConnectionStatus#SUCCESS}
+     */
+    public static ConnectionResult failed(ConnectionStatus status) {
+        if (status == SUCCESS) {
+            throw new IllegalArgumentException("Status must be a failure type");
+        }
+
+        return new ConnectionResult(status, null);
+    }
+
+    /**
+     * Creates a new success {@link ConnectionResult}.
+     *
+     * @param user The user created
+     * @return The connection result
+     * @throws IllegalArgumentException if {@code user} is {@code null}
+     */
+    public static ConnectionResult success(IBaritoneUser user) {
+        Objects.requireNonNull(user);
+
+        return new ConnectionResult(SUCCESS, user);
+    }
+
+    @Override
+    public String toString() {
+        return "ConnectionResult{" +
+                "status=" + status +
+                ", user=" + user +
+                '}';
+    }
+}

src/main/java/baritone/bot/handler/BotNetHandlerLoginClient.java

@@ -0,0 +1,72 @@
+/*
+ * 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.bot.handler;
+
+import baritone.bot.BaritoneUser;
+import baritone.bot.impl.BotMinecraft;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.network.NetHandlerLoginClient;
+import net.minecraft.network.EnumConnectionState;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.login.server.SPacketLoginSuccess;
+import net.minecraft.util.text.ITextComponent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Handles the login stage when connecting to a server.
+ *
+ * @author Brady
+ * @since 10/29/2018
+ */
+public final class BotNetHandlerLoginClient extends NetHandlerLoginClient {
+
+    /**
+     * The {@link NetworkManager} that is managing the connection with the server.
+     */
+    private final NetworkManager networkManager;
+
+    /**
+     * The {@link Minecraft} game instance
+     */
+    private final BotMinecraft mc;
+
+    /**
+     * The bot of this connection
+     */
+    private final BaritoneUser user;
+
+    public BotNetHandlerLoginClient(NetworkManager networkManager, BaritoneUser user) {
+        super(networkManager, user.getPlayerContext().minecraft(), null);
+        this.networkManager = networkManager;
+        this.mc = (BotMinecraft) user.getPlayerContext().minecraft();
+        this.user = user;
+    }
+
+    @Override
+    public void handleLoginSuccess(SPacketLoginSuccess packetIn) {
+        this.networkManager.setConnectionState(EnumConnectionState.PLAY);
+        this.networkManager.setNetHandler(new BotNetHandlerPlayClient(this.networkManager, this.user, this.mc, packetIn.getProfile()));
+    }
+
+    @Override
+    public void onDisconnect(@Nonnull ITextComponent reason) {
+        // It's important that we don't call the superclass method because that would mess up GUIs and make us upset
+        this.user.getManager().disconnect(this.user, reason);
+    }
+}

src/main/java/baritone/bot/handler/BotNetHandlerPlayClient.java

@@ -0,0 +1,521 @@
+/*
+ * 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.bot.handler;
+
+import baritone.api.utils.Helper;
+import baritone.bot.BaritoneUser;
+import baritone.bot.impl.BotPlayer;
+import baritone.bot.impl.BotMinecraft;
+import baritone.bot.impl.BotWorld;
+import baritone.utils.accessor.INetHandlerPlayClient;
+import com.mojang.authlib.GameProfile;
+import io.netty.buffer.Unpooled;
+import net.minecraft.client.multiplayer.ClientAdvancementManager;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.client.util.RecipeBookClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.PacketThreadUtil;
+import net.minecraft.network.play.client.CPacketClientStatus;
+import net.minecraft.network.play.client.CPacketCustomPayload;
+import net.minecraft.network.play.client.CPacketResourcePackStatus;
+import net.minecraft.network.play.server.*;
+import net.minecraft.stats.StatisticsManager;
+import net.minecraft.util.text.ITextComponent;
+
+import javax.annotation.Nonnull;
+
+// Notes
+// - Make some sort of system that prevents repetition of entity info updating
+//   - For some packets, such as ones that modify position, we can check if the existing server state matches the packet proposed state
+//   - For other things, we'll actually need the system
+
+/**
+ * @author Brady
+ * @since 10/22/2018
+ */
+public final class BotNetHandlerPlayClient extends NetHandlerPlayClient {
+
+    /**
+     * The {@link NetworkManager} that is managing the connection with the server.
+     */
+    private final NetworkManager networkManager;
+
+    /**
+     * The bot's minecraft game instance
+     */
+    private final BotMinecraft client;
+
+    /**
+     * The bot of this connection
+     */
+    private final BaritoneUser user;
+
+    /**
+     * The bot player
+     */
+    private BotPlayer player;
+
+    /**
+     * The current world.
+     */
+    private BotWorld world;
+
+    /**
+     * The current player controller
+     */
+    private PlayerControllerMP playerController;
+
+    BotNetHandlerPlayClient(NetworkManager networkManager, BaritoneUser user, BotMinecraft client, GameProfile profile) {
+        // noinspection ConstantConditions
+        super(client, null, networkManager, profile);
+        this.networkManager = networkManager;
+        this.client = client;
+        this.user = user;
+
+        // Notify the user that we're ingame
+        this.user.onLoginSuccess(profile);
+    }
+
+    @Override
+    public void handleSpawnObject(@Nonnull SPacketSpawnObject packetIn) {
+        super.handleSpawnObject(packetIn);
+    }
+
+    @Override
+    public void handleSpawnExperienceOrb(@Nonnull SPacketSpawnExperienceOrb packetIn) {
+        super.handleSpawnExperienceOrb(packetIn);
+    }
+
+    @Override
+    public void handleSpawnGlobalEntity(@Nonnull SPacketSpawnGlobalEntity packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        if (this.world != null) {
+            if (this.world.weatherEffects.stream().noneMatch(entity -> entity.getEntityId() == packetIn.getEntityId())) {
+                super.handleSpawnGlobalEntity(packetIn);
+            }
+        }
+    }
+
+    @Override
+    public void handleSpawnMob(@Nonnull SPacketSpawnMob packetIn) {}
+
+    @Override
+    public void handleScoreboardObjective(@Nonnull SPacketScoreboardObjective packetIn) {}
+
+    @Override
+    public void handleSpawnPainting(@Nonnull SPacketSpawnPainting packetIn) {}
+
+    @Override
+    public void handleSpawnPlayer(@Nonnull SPacketSpawnPlayer packetIn) {}
+
+    @Override
+    public void handleAnimation(@Nonnull SPacketAnimation packetIn) {
+        super.handleAnimation(packetIn);
+    }
+
+    @Override
+    public void handleStatistics(@Nonnull SPacketStatistics packetIn) {
+        super.handleStatistics(packetIn);
+    }
+
+    @Override
+    public void handleRecipeBook(@Nonnull SPacketRecipeBook packetIn) {}
+
+    @Override
+    public void handleBlockBreakAnim(@Nonnull SPacketBlockBreakAnim packetIn) {
+        super.handleBlockBreakAnim(packetIn);
+    }
+
+    @Override
+    public void handleSignEditorOpen(@Nonnull SPacketSignEditorOpen packetIn) {}
+
+    @Override
+    public void handleUpdateTileEntity(@Nonnull SPacketUpdateTileEntity packetIn) {}
+
+    @Override
+    public void handleBlockAction(@Nonnull SPacketBlockAction packetIn) {}
+
+    @Override
+    public void handleBlockChange(@Nonnull SPacketBlockChange packetIn) {
+        super.handleBlockChange(packetIn);
+    }
+
+    @Override
+    public void handleChat(@Nonnull SPacketChat packetIn) {}
+
+    @Override
+    public void handleTabComplete(@Nonnull SPacketTabComplete packetIn) {}
+
+    @Override
+    public void handleMultiBlockChange(@Nonnull SPacketMultiBlockChange packetIn) {
+        super.handleMultiBlockChange(packetIn);
+    }
+
+    @Override
+    public void handleMaps(@Nonnull SPacketMaps packetIn) {}
+
+    @Override
+    public void handleConfirmTransaction(@Nonnull SPacketConfirmTransaction packetIn) {
+        super.handleConfirmTransaction(packetIn);
+    }
+
+    @Override
+    public void handleCloseWindow(@Nonnull SPacketCloseWindow packetIn) {
+        super.handleCloseWindow(packetIn);
+    }
+
+    @Override
+    public void handleWindowItems(@Nonnull SPacketWindowItems packetIn) {
+        super.handleWindowItems(packetIn);
+    }
+
+    @Override
+    public void handleOpenWindow(@Nonnull SPacketOpenWindow packetIn) {}
+
+    @Override
+    public void handleWindowProperty(@Nonnull SPacketWindowProperty packetIn) {
+        super.handleWindowProperty(packetIn);
+    }
+
+    @Override
+    public void handleSetSlot(@Nonnull SPacketSetSlot packetIn) {
+        super.handleSetSlot(packetIn);
+    }
+
+    @Override
+    public void handleCustomPayload(@Nonnull SPacketCustomPayload packetIn) {}
+
+    @Override
+    public void handleDisconnect(@Nonnull SPacketDisconnect packetIn) {
+        super.handleDisconnect(packetIn);
+    }
+
+    @Override
+    public void handleUseBed(@Nonnull SPacketUseBed packetIn) {}
+
+    @Override
+    public void handleEntityStatus(@Nonnull SPacketEntityStatus packetIn) {
+        super.handleEntityStatus(packetIn);
+    }
+
+    @Override
+    public void handleEntityAttach(@Nonnull SPacketEntityAttach packetIn) {
+        super.handleEntityAttach(packetIn);
+    }
+
+    @Override
+    public void handleSetPassengers(@Nonnull SPacketSetPassengers packetIn) {}
+
+    @Override
+    public void handleExplosion(@Nonnull SPacketExplosion packetIn) {
+        super.handleExplosion(packetIn);
+    }
+
+    @Override
+    public void handleChangeGameState(@Nonnull SPacketChangeGameState packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        if (packetIn.getGameState() == 4) {
+            this.client.player.connection.sendPacket(new CPacketClientStatus(CPacketClientStatus.State.PERFORM_RESPAWN));
+        } else if (packetIn.getGameState() != 5) {
+            super.handleChangeGameState(packetIn);
+        }
+    }
+
+    @Override
+    public void handleKeepAlive(@Nonnull SPacketKeepAlive packetIn) {
+        super.handleKeepAlive(packetIn);
+    }
+
+    @Override
+    public void handleChunkData(@Nonnull SPacketChunkData packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        if (packetIn.isFullChunk()) {
+            if (!this.world.handlePreChunk(this.player, packetIn.getChunkX(), packetIn.getChunkZ(), true)) {
+                return;
+            }
+        }
+        super.handleChunkData(packetIn);
+    }
+
+    @Override
+    public void processChunkUnload(@Nonnull SPacketUnloadChunk packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        if (this.world.handlePreChunk(this.player, packetIn.getX(), packetIn.getZ(), false)) {
+            super.processChunkUnload(packetIn);
+        }
+    }
+
+    @Override
+    public void handleEffect(@Nonnull SPacketEffect packetIn) {}
+
+    @Override
+    public void handleJoinGame(@Nonnull SPacketJoinGame packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        this.playerController = new PlayerControllerMP(this.user.getPlayerContext().minecraft(), this);
+        this.world = this.user.getManager().getWorldProvider().getWorld(packetIn.getDimension());
+        ((INetHandlerPlayClient) (Object) this).setWorld(this.world);
+        this.player = new BotPlayer(this.user, this.client, this.world, this, new StatisticsManager(), new RecipeBookClient());
+        this.user.onWorldLoad(this.world, this.player, this.playerController);
+        this.player.preparePlayerToSpawn();
+        this.player.setEntityId(packetIn.getPlayerId());
+        this.player.dimension = packetIn.getDimension();
+        this.world.addEntityToWorld(packetIn.getPlayerId(), this.player);
+        this.playerController.setGameType(packetIn.getGameType());
+        packetIn.getGameType().configurePlayerCapabilities(this.player.capabilities);
+
+        this.client.gameSettings.sendSettingsToServer();
+        this.networkManager.sendPacket(new CPacketCustomPayload("MC|Brand", new PacketBuffer(Unpooled.buffer()).writeString("vanilla")));
+
+        Helper.HELPER.logDirect("Initialized Player and World");
+    }
+
+    @Override
+    public void handleEntityMovement(@Nonnull SPacketEntity packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        Entity e = packetIn.getEntity(this.world);
+        if (e instanceof BotPlayer && !e.equals(this.player)) {
+            return;
+        }
+
+        super.handleEntityMovement(packetIn);
+    }
+
+    @Override
+    public void handlePlayerPosLook(@Nonnull SPacketPlayerPosLook packetIn) {
+        super.handlePlayerPosLook(packetIn);
+    }
+
+    @Override
+    public void handleParticles(@Nonnull SPacketParticles packetIn) {}
+
+    @Override
+    public void handlePlayerAbilities(@Nonnull SPacketPlayerAbilities packetIn) {
+        super.handlePlayerAbilities(packetIn);
+    }
+
+    @Override
+    public void handlePlayerListItem(@Nonnull SPacketPlayerListItem packetIn) {
+        super.handlePlayerListItem(packetIn);
+    }
+
+    @Override
+    public void handleDestroyEntities(@Nonnull SPacketDestroyEntities packetIn) {
+        super.handleDestroyEntities(packetIn);
+    }
+
+    @Override
+    public void handleRemoveEntityEffect(@Nonnull SPacketRemoveEntityEffect packetIn) {
+        super.handleRemoveEntityEffect(packetIn);
+    }
+
+    @Override
+    public void handleRespawn(@Nonnull SPacketRespawn packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        if (packetIn.getDimensionID() != this.player.dimension) {
+            this.world.handleWorldRemove(this.player);
+            this.world = this.user.getManager().getWorldProvider().getWorld(packetIn.getDimensionID());
+            ((INetHandlerPlayClient) (Object) this).setWorld(this.world);
+        }
+
+        BotPlayer prev = this.player;
+
+        this.player = new BotPlayer(this.user, this.client, this.world, this, prev.getStatFileWriter(), prev.getRecipeBook());
+        this.user.onWorldLoad(this.world, this.player, this.playerController);
+        // noinspection ConstantConditions
+        this.player.getDataManager().setEntryValues(prev.getDataManager().getAll());
+        this.player.preparePlayerToSpawn();
+        this.player.setEntityId(prev.getEntityId());
+        this.player.dimension = packetIn.getDimensionID();
+        this.player.setServerBrand(prev.getServerBrand());
+        this.world.addEntityToWorld(prev.getEntityId(), this.player);
+        this.playerController.setGameType(packetIn.getGameType());
+    }
+
+    @Override
+    public void handleEntityHeadLook(@Nonnull SPacketEntityHeadLook packetIn) {}
+
+    @Override
+    public void handleHeldItemChange(@Nonnull SPacketHeldItemChange packetIn) {
+        super.handleHeldItemChange(packetIn);
+    }
+
+    @Override
+    public void handleDisplayObjective(@Nonnull SPacketDisplayObjective packetIn) {}
+
+    @Override
+    public void handleEntityMetadata(@Nonnull SPacketEntityMetadata packetIn) {
+        super.handleEntityMetadata(packetIn);
+    }
+
+    @Override
+    public void handleEntityVelocity(@Nonnull SPacketEntityVelocity packetIn) {
+        super.handleEntityVelocity(packetIn);
+    }
+
+    @Override
+    public void handleEntityEquipment(@Nonnull SPacketEntityEquipment packetIn) {
+        super.handleEntityEquipment(packetIn);
+    }
+
+    @Override
+    public void handleSetExperience(@Nonnull SPacketSetExperience packetIn) {
+        super.handleSetExperience(packetIn);
+    }
+
+    @Override
+    public void handleUpdateHealth(@Nonnull SPacketUpdateHealth packetIn) {
+        super.handleUpdateHealth(packetIn);
+    }
+
+    @Override
+    public void handleTeams(@Nonnull SPacketTeams packetIn) {}
+
+    @Override
+    public void handleUpdateScore(@Nonnull SPacketUpdateScore packetIn) {}
+
+    @Override
+    public void handleSpawnPosition(@Nonnull SPacketSpawnPosition packetIn) { /* We probably don't need to know this, the server handles everything related to spawn psoition? */ }
+
+    @Override
+    public void handleTimeUpdate(@Nonnull SPacketTimeUpdate packetIn) {
+        super.handleTimeUpdate(packetIn);
+    }
+
+    @Override
+    public void handleSoundEffect(@Nonnull SPacketSoundEffect packetIn) {}
+
+    @Override
+    public void handleCustomSound(@Nonnull SPacketCustomSound packetIn) {}
+
+    @Override
+    public void handleCollectItem(@Nonnull SPacketCollectItem packetIn) {
+        super.handleCollectItem(packetIn);
+    }
+
+    @Override
+    public void handleEntityTeleport(@Nonnull SPacketEntityTeleport packetIn) {
+        super.handleEntityTeleport(packetIn);
+    }
+
+    @Override
+    public void handleEntityProperties(@Nonnull SPacketEntityProperties packetIn) {
+        super.handleEntityProperties(packetIn);
+    }
+
+    @Override
+    public void handleEntityEffect(@Nonnull SPacketEntityEffect packetIn) {
+        super.handleEntityEffect(packetIn);
+    }
+
+    @Override
+    public void handleCombatEvent(@Nonnull SPacketCombatEvent packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        // We only care if we died
+        if (packetIn.eventType == SPacketCombatEvent.Event.ENTITY_DIED) {
+            if (packetIn.playerId == this.player.getEntityId()) {
+                // Perform an instantaneous respawn
+                this.networkManager.sendPacket(new CPacketClientStatus(CPacketClientStatus.State.PERFORM_RESPAWN));
+                user.getBaritone().getGameEventHandler().onPlayerDeath();
+            }
+        }
+    }
+
+    @Override
+    public void handleServerDifficulty(@Nonnull SPacketServerDifficulty packetIn) {}
+
+    @Override
+    public void handleCamera(SPacketCamera packetIn) {}
+
+    @Override
+    public void handleWorldBorder(@Nonnull SPacketWorldBorder packetIn) {
+        super.handleWorldBorder(packetIn);
+    }
+
+    @Override
+    public void handleTitle(@Nonnull SPacketTitle packetIn) {}
+
+    @Override
+    public void handlePlayerListHeaderFooter(@Nonnull SPacketPlayerListHeaderFooter packetIn) {}
+
+    @Override
+    public void handleResourcePack(@Nonnull SPacketResourcePackSend packetIn) {
+        PacketThreadUtil.checkThreadAndEnqueue(packetIn, this, this.client);
+
+        // Lie to the server and tell them we accepted it in response
+        this.networkManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.ACCEPTED));
+        this.networkManager.sendPacket(new CPacketResourcePackStatus(CPacketResourcePackStatus.Action.SUCCESSFULLY_LOADED));
+    }
+
+    @Override
+    public void handleUpdateBossInfo(@Nonnull SPacketUpdateBossInfo packetIn) {}
+
+    @Override
+    public void handleCooldown(@Nonnull SPacketCooldown packetIn) {
+        super.handleCooldown(packetIn);
+    }
+
+    @Override
+    public void handleMoveVehicle(@Nonnull SPacketMoveVehicle packetIn) {
+        super.handleMoveVehicle(packetIn);
+    }
+
+    @Override
+    public void handleAdvancementInfo(@Nonnull SPacketAdvancementInfo packetIn) {
+        super.handleAdvancementInfo(packetIn);
+    }
+
+    @Override
+    public void handleSelectAdvancementsTab(@Nonnull SPacketSelectAdvancementsTab packetIn) {
+        super.handleSelectAdvancementsTab(packetIn);
+    }
+
+    @Override
+    public void func_194307_a(@Nonnull SPacketPlaceGhostRecipe p_194307_1_) {}
+
+    @Override
+    public void onDisconnect(@Nonnull ITextComponent reason) {
+        // TODO Maybe more world unloading
+        this.world.removeEntity(this.player);
+        this.user.getManager().disconnect(this.user, reason);
+    }
+
+    @Nonnull
+    @Override
+    public ClientAdvancementManager getAdvancementManager() {
+        throw new UnsupportedOperationException("This method shouldn't have been called; That is unepic!");
+    }
+
+    public BotPlayer player() {
+        return player;
+    }
+
+    public BotWorld world() {
+        return world;
+    }
+}

src/main/java/baritone/bot/impl/BotGuiInventory.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.bot.impl;
+
+import baritone.api.bot.IBaritoneUser;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiInventory;
+
+import javax.annotation.Nonnull;
+
+/**
+ * @author Brady
+ */
+public final class BotGuiInventory extends GuiInventory {
+
+    private final IBaritoneUser user;
+
+    public BotGuiInventory(IBaritoneUser user) {
+        super(user.getPlayerContext().player());
+        this.user = user;
+    }
+
+    @Override
+    public void setWorldAndResolution(@Nonnull Minecraft primary, int width, int height) {
+        final Minecraft mc = this.user.getPlayerContext().minecraft();
+        mc.displayWidth = primary.displayWidth;
+        mc.displayHeight = primary.displayHeight;
+        super.setWorldAndResolution(mc, width, height);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
+        final BotPlayer player = (BotPlayer) this.user.getPlayerContext().player();
+        player.isUser = false;
+        super.drawGuiContainerBackgroundLayer(partialTicks, mouseX, mouseY);
+        player.isUser = true;
+    }
+}

src/main/java/baritone/bot/impl/BotMinecraft.java

@@ -0,0 +1,187 @@
+/*
+ * 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.bot.impl;
+
+import baritone.api.bot.IBaritoneUser;
+import baritone.utils.ObjectAllocator;
+import baritone.utils.accessor.IGameSettings;
+import baritone.utils.accessor.IMinecraft;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.mojang.authlib.minecraft.MinecraftSessionService;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.SoundHandler;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.toasts.GuiToast;
+import net.minecraft.client.main.GameConfiguration;
+import net.minecraft.client.renderer.RenderItem;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.texture.TextureManager;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.settings.GameSettings;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.client.tutorial.Tutorial;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumHandSide;
+import net.minecraft.util.Session;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.HashSet;
+import java.util.concurrent.Callable;
+
+/**
+ * "Implementation" of {@link Minecraft} which gets allocated without receiving a constructor call.
+ * This allows us to avoid the game's setup process (moreso in versions after 1.12 than 1.12 itself).
+ *
+ * @author Brady
+ * @since 3/3/2020
+ */
+public final class BotMinecraft extends Minecraft {
+
+    private static final Minecraft mc = Minecraft.getMinecraft();
+
+    private IBaritoneUser user;
+    private Tutorial tutorial;
+    private GuiToast toastGui;
+
+    private BotMinecraft(GameConfiguration gameConfig) {
+        super(gameConfig);
+    }
+
+    @Nullable
+    @Override
+    public Entity getRenderViewEntity() {
+        return mc.getRenderViewEntity();
+    }
+
+    @Nonnull
+    @Override
+    public Session getSession() {
+        return this.user.getSession();
+    }
+
+    @Override
+    public @Nonnull MinecraftSessionService getSessionService() {
+        return mc.getSessionService();
+    }
+
+    @Override
+    public <V> @Nonnull ListenableFuture<V> addScheduledTask(@Nonnull Callable<V> callableToSchedule) {
+        return mc.addScheduledTask(callableToSchedule);
+    }
+
+    @Override
+    public boolean isCallingFromMinecraftThread() {
+        return mc.isCallingFromMinecraftThread();
+    }
+
+    @Nonnull
+    @Override
+    public Tutorial getTutorial() {
+        return this.tutorial;
+    }
+
+    @Nonnull
+    @Override
+    public SoundHandler getSoundHandler() {
+        return BotSoundHandler.INSTANCE;
+    }
+
+    @Nonnull
+    @Override
+    public GuiToast getToastGui() {
+        return this.toastGui;
+    }
+
+    @Override
+    public void displayGuiScreen(@Nullable GuiScreen guiScreenIn) {
+        // do nothing
+        if (guiScreenIn == null) {
+            if (mc.currentScreen instanceof BotGuiInventory) {
+                mc.displayGuiScreen(null);
+            }
+        }
+    }
+
+    @Nonnull
+    @Override
+    public TextureManager getTextureManager() {
+        return mc.getTextureManager();
+    }
+
+    @Nonnull
+    @Override
+    public RenderItem getRenderItem() {
+        return mc.getRenderItem();
+    }
+
+    @Nonnull
+    @Override
+    public TextureMap getTextureMapBlocks() {
+        return mc.getTextureMapBlocks();
+    }
+
+    @Override
+    public void dispatchKeypresses() {
+        // Do nothing
+    }
+
+    public static BotMinecraft allocate(IBaritoneUser user) {
+        BotMinecraft bm = ObjectAllocator.allocate(BotMinecraft.class);
+        ((IMinecraft) (Object) bm).setGameDir(mc.gameDir);
+
+        // Gui Compatibility
+        bm.fontRenderer = mc.fontRenderer;
+
+        bm.user = user;
+        bm.tutorial = new Tutorial(bm);
+        bm.gameSettings = createGameSettings(bm);
+        bm.effectRenderer = BotParticleManager.INSTANCE;
+        bm.toastGui = new GuiToast(bm);
+        return bm;
+    }
+
+    private static GameSettings createGameSettings(BotMinecraft bm) {
+        GameSettings settings = ObjectAllocator.allocate(GameSettings.class);
+
+        // Settings that get accessed on entity tick
+        settings.keyBindSprint = ObjectAllocator.allocate(KeyBinding.class);
+        settings.autoJump = false;
+
+        // Settings that are sent to the server
+        settings.language = "en_us";
+        settings.renderDistanceChunks = 8;
+        settings.chatVisibility = EntityPlayer.EnumChatVisibility.FULL;
+        settings.chatColours = true;
+        settings.mainHand = EnumHandSide.RIGHT;
+
+        // Gui Compatibility
+        settings.keyBindPickBlock = mc.gameSettings.keyBindPickBlock;
+        settings.keyBindsHotbar = mc.gameSettings.keyBindsHotbar;
+        settings.keyBindInventory = mc.gameSettings.keyBindInventory;
+        settings.keyBindDrop = mc.gameSettings.keyBindDrop;
+
+        // Private fields that must be initialized
+        IGameSettings accessor = (IGameSettings) settings;
+        accessor.setMc(bm);
+        accessor.setSetModelParts(new HashSet<>());
+
+        return settings;
+    }
+}

src/main/java/baritone/bot/impl/BotParticleManager.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.bot.impl;
+
+import net.minecraft.client.particle.ParticleManager;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.EnumParticleTypes;
+
+import javax.annotation.Nonnull;
+
+/**
+ * @author Brady
+ * @since 3/8/2020
+ */
+public final class BotParticleManager extends ParticleManager {
+
+    public static final BotParticleManager INSTANCE = new BotParticleManager();
+
+    private BotParticleManager() {
+        super(null, null);
+    }
+
+    @Override
+    public void emitParticleAtEntity(Entity entityIn, @Nonnull EnumParticleTypes particleTypes) {}
+
+    @Override
+    public void emitParticleAtEntity(Entity p_191271_1_, @Nonnull EnumParticleTypes p_191271_2_, int p_191271_3_) {}
+}

src/main/java/baritone/bot/impl/BotPlayer.java

@@ -0,0 +1,187 @@
+/*
+ * 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.bot.impl;
+
+import baritone.Baritone;
+import baritone.api.bot.IBaritoneUser;
+import baritone.utils.PlayerMovementInput;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.client.network.NetworkPlayerInfo;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.IMerchant;
+import net.minecraft.entity.passive.AbstractHorse;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.stats.RecipeBook;
+import net.minecraft.stats.StatisticsManager;
+import net.minecraft.tileentity.CommandBlockBaseLogic;
+import net.minecraft.tileentity.TileEntityCommandBlock;
+import net.minecraft.tileentity.TileEntitySign;
+import net.minecraft.tileentity.TileEntityStructure;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.world.GameType;
+import net.minecraft.world.IInteractionObject;
+import net.minecraft.world.World;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+// Some Notes:
+// - Inventory handling!
+//   - If chest deposit gets added it will be most useful for bot-system
+
+/**
+ * @author Brady
+ * @since 10/23/2018
+ */
+@SuppressWarnings("EntityConstructor")
+public final class BotPlayer extends EntityPlayerSP {
+
+    private final IBaritoneUser user;
+    private NetworkPlayerInfo playerInfo;
+    public boolean isUser;
+
+    public BotPlayer(IBaritoneUser user, Minecraft mc, World world, NetHandlerPlayClient netHandlerPlayClient, StatisticsManager statisticsManager, RecipeBook recipeBook) {
+        super(mc, world, netHandlerPlayClient, statisticsManager, recipeBook);
+        this.user = user;
+        this.movementInput = new PlayerMovementInput(this.user.getBaritone().getInputOverrideHandler());
+        this.isUser = true;
+    }
+
+    @Override
+    public void onUpdate() {
+        this.entityCollisionReduction = Baritone.settings().botCollision.value ? 0.0F : 1.0F;
+        super.onUpdate();
+    }
+
+    @Override
+    public boolean isUser() {
+        // Used by BotGuiInventory to fix player model rendering in the gui
+        return this.isUser;
+    }
+
+    @Override
+    public double getDistanceSq(@Nonnull Entity entityIn) {
+        if (entityIn == Minecraft.getMinecraft().getRenderViewEntity()) {
+            // Always render nametag in BotGuiInventory
+            return 0.0;
+        } else {
+            return super.getDistanceSq(entityIn);
+        }
+    }
+
+
+
+    @Override
+    public void sendStatusMessage(@Nonnull ITextComponent chatComponent, boolean actionBar) {
+        // TODO: Custom message handling
+    }
+
+    @Override
+    public void sendMessage(@Nonnull ITextComponent component) {
+        // TODO: Custom message handling
+    }
+
+    @Override
+    public void openEditSign(@Nonnull TileEntitySign signTile) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void displayGuiEditCommandCart(@Nonnull CommandBlockBaseLogic commandBlock) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void displayGuiCommandBlock(@Nonnull TileEntityCommandBlock commandBlock) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void openEditStructure(@Nonnull TileEntityStructure structure) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void openBook(ItemStack stack, EnumHand hand) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void displayGUIChest(@Nonnull IInventory chestInventory) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void openGuiHorseInventory(@Nonnull AbstractHorse horse, IInventory inventoryIn) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void displayGui(IInteractionObject guiOwner) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void displayVillagerTradeGui(IMerchant villager) {
+        // TODO: Custom GUI handling
+    }
+
+    @Override
+    public void onCriticalHit(@Nonnull Entity entityHit) {
+        // Don't render
+    }
+
+    @Override
+    public void onEnchantmentCritical(@Nonnull Entity entityHit) {
+        // Don't render
+    }
+
+    @Override
+    protected boolean isCurrentViewEntity() {
+        return true;
+    }
+
+    @Override
+    public boolean isSpectator() {
+        NetworkPlayerInfo networkplayerinfo = this.connection.getPlayerInfo(this.getGameProfile().getId());
+        // noinspection ConstantConditions
+        return networkplayerinfo != null && networkplayerinfo.getGameType() == GameType.SPECTATOR;
+    }
+
+    @Override
+    public boolean isCreative() {
+        NetworkPlayerInfo networkplayerinfo = this.connection.getPlayerInfo(this.getGameProfile().getId());
+        // noinspection ConstantConditions
+        return networkplayerinfo != null && networkplayerinfo.getGameType() == GameType.CREATIVE;
+    }
+
+    @Nullable
+    @Override
+    protected NetworkPlayerInfo getPlayerInfo() {
+        return this.playerInfo == null ? (this.playerInfo = this.connection.getPlayerInfo(this.getUniqueID())) : null;
+    }
+
+    @Override
+    public boolean isAutoJumpEnabled() {
+        return false;
+    }
+}

src/main/java/baritone/bot/impl/BotSoundHandler.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.bot.impl;
+
+import net.minecraft.client.audio.ISound;
+import net.minecraft.client.audio.SoundHandler;
+
+import javax.annotation.Nonnull;
+
+/**
+ * @author Brady
+ * @since 3/7/2020
+ */
+public final class BotSoundHandler extends SoundHandler {
+
+    public static final BotSoundHandler INSTANCE = new BotSoundHandler();
+
+    private BotSoundHandler() {
+        super(null, null);
+    }
+
+    @Override
+    public void playSound(@Nonnull ISound sound) {}
+}

src/main/java/baritone/bot/impl/BotWorld.java

@@ -0,0 +1,106 @@
+/*
+ * 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.bot.impl;
+
+import it.unimi.dsi.fastutil.ints.*;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.profiler.Profiler;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvent;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.EnumDifficulty;
+import net.minecraft.world.WorldSettings;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Brady
+ * @since 11/7/2018
+ */
+public final class BotWorld extends WorldClient {
+
+    private static Profiler BOT_WORLD_PROFILER = new Profiler();
+    private final Map<ChunkPos, IntSet> loadedChunksMap;
+
+    public BotWorld(WorldSettings settings, int dimension) {
+        super(null, settings, dimension, EnumDifficulty.EASY, BOT_WORLD_PROFILER);
+        this.loadedChunksMap = new HashMap<>();
+    }
+
+    @Override
+    public void playSound(double x, double y, double z, SoundEvent soundIn, SoundCategory category, float volume, float pitch, boolean distanceDelay) {
+        // Do nothing
+    }
+
+    @Override
+    public void addEntityToWorld(int entityID, Entity entity) {
+        this.removeEntityFromWorld(entityID);
+        this.spawnEntity(entity);
+        this.entitiesById.addKey(entityID, entity);
+    }
+
+    @Override
+    public Entity removeEntityFromWorld(int entityID) {
+        Entity entity = this.entitiesById.lookup(entityID);
+        if (entity != null && !(entity instanceof BotPlayer)) {
+            this.removeEntity(entity);
+            this.entitiesById.removeObject(entityID);
+        }
+        return entity;
+    }
+
+    @Nullable
+    @Override
+    public Entity getEntityByID(int id) {
+        return this.entitiesById.lookup(id);
+    }
+
+    /**
+     * @param bot    The bot requesting the chunk
+     * @param chunkX The chunk X position
+     * @param chunkZ The chunk Z position
+     * @param load   {@code true} if the chunk is being loaded, {@code false} if the chunk is being unloaded.
+     * @return Whether or not the chunk needs to be loaded or unloaded accordingly.
+     */
+    public boolean handlePreChunk(BotPlayer bot, int chunkX, int chunkZ, boolean load) {
+        IntSet bots = this.loadedChunksMap.computeIfAbsent(new ChunkPos(chunkX, chunkZ), $ -> new IntArraySet());
+        if (load) {
+            boolean wasEmpty = bots.isEmpty();
+            bots.add(bot.getEntityId());
+            return wasEmpty;
+        } else {
+            bots.remove(bot.getEntityId());
+            return bots.isEmpty();
+        }
+    }
+
+    public void handleWorldRemove(BotPlayer bot) {
+        // Remove Bot from world
+        this.removeEntity(bot);
+        this.entitiesById.removeObject(bot.getEntityId());
+
+        // Unload all chunks that are no longer loaded by the removed Bot
+        this.loadedChunksMap.entrySet().stream()
+                .peek(entry -> entry.getValue().remove(bot.getEntityId()))
+                .filter(entry -> entry.getValue().isEmpty())
+                .forEach(entry -> this.doPreChunk(entry.getKey().x, entry.getKey().z, false));
+    }
+}

src/main/java/baritone/cache/FasterWorldScanner.java

@@ -0,0 +1,276 @@
+/*
+ * 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.cache;
+
+import baritone.api.cache.ICachedWorld;
+import baritone.api.cache.IWorldScanner;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.BlockOptionalMetaLookup;
+import baritone.api.utils.IPlayerContext;
+import baritone.utils.accessor.IBitArray;
+import baritone.utils.accessor.IBlockStateContainer;
+import io.netty.buffer.Unpooled;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.ints.IntList;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.BitArray;
+import net.minecraft.util.ObjectIntIdentityMap;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.chunk.*;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.IntConsumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public enum FasterWorldScanner implements IWorldScanner {
+    INSTANCE;
+    @Override
+    public List<BlockPos> scanChunkRadius(IPlayerContext ctx, BlockOptionalMetaLookup filter, int max, int yLevelThreshold, int maxSearchRadius) {
+        assert ctx.world() != null;
+        if (maxSearchRadius < 0) {
+            throw new IllegalArgumentException("chunkRange must be >= 0");
+        }
+        return scanChunksInternal(ctx, filter, getChunkRange(ctx.playerFeet().x >> 4, ctx.playerFeet().z >> 4, maxSearchRadius), max);
+    }
+
+    @Override
+    public List<BlockPos> scanChunk(IPlayerContext ctx, BlockOptionalMetaLookup filter, ChunkPos pos, int max, int yLevelThreshold) {
+        Stream<BlockPos> stream = scanChunkInternal(ctx, filter, pos);
+        if (max >= 0) {
+            stream = stream.limit(max);
+        }
+        return stream.collect(Collectors.toList());
+    }
+
+    @Override
+    public int repack(IPlayerContext ctx) {
+        return this.repack(ctx, 40);
+    }
+
+    @Override
+    public int repack(IPlayerContext ctx, int range) {
+        IChunkProvider chunkProvider = ctx.world().getChunkProvider();
+        ICachedWorld cachedWorld = ctx.worldData().getCachedWorld();
+
+        BetterBlockPos playerPos = ctx.playerFeet();
+
+        int playerChunkX = playerPos.getX() >> 4;
+        int playerChunkZ = playerPos.getZ() >> 4;
+
+        int minX = playerChunkX - range;
+        int minZ = playerChunkZ - range;
+        int maxX = playerChunkX + range;
+        int maxZ = playerChunkZ + range;
+
+        int queued = 0;
+        for (int x = minX; x <= maxX; x++) {
+            for (int z = minZ; z <= maxZ; z++) {
+                Chunk chunk = chunkProvider.getLoadedChunk(x, z);
+
+                if (chunk != null && !chunk.isEmpty()) {
+                    queued++;
+                    cachedWorld.queueForPacking(chunk);
+                }
+            }
+        }
+
+        return queued;
+    }
+
+    // ordered in a way that the closest blocks are generally first
+    public static List<ChunkPos> getChunkRange(int centerX, int centerZ, int chunkRadius) {
+        List<ChunkPos> chunks = new ArrayList<>();
+        // spiral out
+        chunks.add(new ChunkPos(centerX, centerZ));
+        for (int i = 1; i < chunkRadius; i++) {
+            for (int j = 0; j <= i; j++) {
+                chunks.add(new ChunkPos(centerX - j, centerZ - i));
+                if (j != 0) {
+                    chunks.add(new ChunkPos(centerX + j, centerZ - i));
+                    chunks.add(new ChunkPos(centerX - j, centerZ + i));
+                }
+                chunks.add(new ChunkPos(centerX + j, centerZ + i));
+                if (j != i) {
+                    chunks.add(new ChunkPos(centerX - i, centerZ - j));
+                    chunks.add(new ChunkPos(centerX + i, centerZ - j));
+                    if (j != 0) {
+                        chunks.add(new ChunkPos(centerX - i, centerZ + j));
+                        chunks.add(new ChunkPos(centerX + i, centerZ + j));
+                    }
+                }
+            }
+        }
+        return chunks;
+    }
+
+    private List<BlockPos> scanChunksInternal(IPlayerContext ctx, BlockOptionalMetaLookup lookup, List<ChunkPos> chunkPositions, int maxBlocks) {
+        assert ctx.world() != null;
+        try {
+            // p -> scanChunkInternal(ctx, lookup, p)
+            Stream<BlockPos> posStream = chunkPositions.parallelStream().flatMap(p -> scanChunkInternal(ctx, lookup, p));
+            if (maxBlocks >= 0) {
+                // WARNING: this can be expensive if maxBlocks is large...
+                // see limit's javadoc
+                posStream = posStream.limit(maxBlocks);
+            }
+            return posStream.collect(Collectors.toList());
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw e;
+        }
+    }
+
+    private Stream<BlockPos> scanChunkInternal(IPlayerContext ctx, BlockOptionalMetaLookup lookup, ChunkPos pos) {
+        IChunkProvider chunkProvider = ctx.world().getChunkProvider();
+        // if chunk is not loaded, return empty stream
+        if (!chunkProvider.isChunkGeneratedAt(pos.x, pos.z)) {
+            return Stream.empty();
+        }
+
+        long chunkX = (long) pos.x << 4;
+        long chunkZ = (long) pos.z << 4;
+
+        int playerSectionY = ctx.playerFeet().y >> 4;
+
+        return collectChunkSections(lookup, chunkProvider.getLoadedChunk(pos.x, pos.z), chunkX, chunkZ, playerSectionY).stream();
+    }
+
+
+
+    private List<BlockPos> collectChunkSections(BlockOptionalMetaLookup lookup, Chunk chunk, long chunkX, long chunkZ, int playerSection) {
+        // iterate over sections relative to player
+        List<BlockPos> blocks = new ArrayList<>();
+        ExtendedBlockStorage[] sections = chunk.getBlockStorageArray();
+        int l = sections.length;
+        int i = playerSection - 1;
+        int j = playerSection;
+        for (; i >= 0 || j < l; ++j, --i) {
+            if (j < l) {
+                visitSection(lookup, sections[j], blocks, chunkX, chunkZ);
+            }
+            if (i >= 0) {
+                visitSection(lookup, sections[i], blocks, chunkX, chunkZ);
+            }
+        }
+        return blocks;
+    }
+
+    private void visitSection(BlockOptionalMetaLookup lookup, ExtendedBlockStorage section, List<BlockPos> blocks, long chunkX, long chunkZ) {
+        if (section == null || section.isEmpty()) {
+            return;
+        }
+
+        BlockStateContainer sectionContainer = section.getData();
+        //this won't work if the PaletteStorage is of the type EmptyPaletteStorage
+        if (((IBlockStateContainer) sectionContainer).getStorage() == null) {
+            return;
+        }
+
+        boolean[] isInFilter = getIncludedFilterIndices(lookup, ((IBlockStateContainer) sectionContainer).getPalette());
+        if (isInFilter.length == 0) {
+            return;
+        }
+
+        BitArray array = ((IBlockStateContainer) section.getData()).getStorage();
+        long[] longArray = array.getBackingLongArray();
+        int arraySize = array.size();
+        int bitsPerEntry = ((IBitArray) array).getBitsPerEntry();
+        long maxEntryValue = ((IBitArray) array).getMaxEntryValue();
+
+
+        int yOffset = section.getYLocation();
+
+        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) {
+                if (isInFilter[(int) (jl & maxEntryValue)]) {
+                    //noinspection DuplicateExpressions
+                    blocks.add(new BlockPos(
+                        chunkX + ((idx & 255) & 15),
+                        yOffset + (idx >> 8),
+                        chunkZ + ((idx & 255) >> 4)
+                    ));
+                }
+            } else {
+                if (isInFilter[(int) ((jl | longArray[k] << (64 - l)) & maxEntryValue)]) {
+                    //noinspection DuplicateExpressions
+                    blocks.add(new BlockPos(
+                        chunkX + ((idx & 255) & 15),
+                        yOffset + (idx >> 8),
+                        chunkZ + ((idx & 255) >> 4)
+                    ));
+                }
+            }
+        }
+    }
+
+    private boolean[] getIncludedFilterIndices(BlockOptionalMetaLookup lookup, IBlockStatePalette palette) {
+        boolean commonBlockFound = false;
+        ObjectIntIdentityMap<IBlockState> paletteMap = getPalette(palette);
+        int size = paletteMap.size();
+
+        boolean[] isInFilter = new boolean[size];
+
+        for (int i = 0; i < size; i++) {
+            IBlockState state = paletteMap.getByValue(i);
+            if (lookup.has(state)) {
+                isInFilter[i] = true;
+                commonBlockFound = true;
+            } else {
+                isInFilter[i] = false;
+            }
+        }
+
+        if (!commonBlockFound) {
+            return new boolean[0];
+        }
+        return isInFilter;
+    }
+
+    /**
+     * cheats to get the actual map of id -> blockstate from the various palette implementations
+     */
+    private static ObjectIntIdentityMap<IBlockState> getPalette(IBlockStatePalette palette) {
+        if (palette instanceof BlockStatePaletteRegistry) {
+            return Block.BLOCK_STATE_IDS;
+        } else {
+            PacketBuffer buf = new PacketBuffer(Unpooled.buffer());
+            palette.write(buf);
+            int size = buf.readVarInt();
+            ObjectIntIdentityMap<IBlockState> states = new ObjectIntIdentityMap<>();
+            for (int i = 0; i < size; i++) {
+                IBlockState state = Block.BLOCK_STATE_IDS.getByValue(buf.readVarInt());
+                assert state != null;
+                states.put(state, i);
+            }
+            return states;
+        }
+    }
+}

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

@@ -18,104 +18,87 @@
 package baritone.cache;
 
 import baritone.Baritone;
+import baritone.api.BaritoneAPI;
 import baritone.api.cache.IWorldProvider;
-import baritone.api.utils.Helper;
+import baritone.api.utils.IPlayerContext;
 import baritone.utils.accessor.IAnvilChunkLoader;
 import baritone.utils.accessor.IChunkProviderServer;
-import net.minecraft.server.integrated.IntegratedServer;
+import net.minecraft.client.multiplayer.ServerData;
+import net.minecraft.util.Tuple;
 import net.minecraft.world.World;
 import net.minecraft.world.WorldServer;
 import org.apache.commons.lang3.SystemUtils;
 
-import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Consumer;
+import java.util.Optional;
 
 /**
  * @author Brady
  * @since 8/4/2018
  */
-public class WorldProvider implements IWorldProvider, Helper {
+public class WorldProvider implements IWorldProvider {
 
-    private static final Map<Path, WorldData> worldCache = new HashMap<>(); // this is how the bots have the same cached world
+    private static final Map<Path, WorldData> worldCache = new HashMap<>();
 
+    private final Baritone baritone;
+    private final IPlayerContext ctx;
     private WorldData currentWorld;
-    private World mcWorld; // this let's us detect a broken load/unload hook
+
+    /**
+     * This lets us detect a broken load/unload hook.
+     * @see #detectAndHandleBrokenLoading()
+     */
+    private World mcWorld;
+
+    public WorldProvider(Baritone baritone) {
+        this.baritone = baritone;
+        this.ctx = baritone.getPlayerContext();
+    }
 
     @Override
     public final WorldData getCurrentWorld() {
-        detectAndHandleBrokenLoading();
+        this.detectAndHandleBrokenLoading();
         return this.currentWorld;
     }
 
     /**
      * Called when a new world is initialized to discover the
      *
-     * @param dimension The ID of the world's dimension
+     * @param world The new world
      */
-    public final void initWorld(int dimension) {
-        File directory;
-        File readme;
+    public final void initWorld(World world) {
+        this.getSaveDirectories(world).ifPresent(dirs -> {
+            final Path worldDir = dirs.getFirst();
+            final Path readmeDir = dirs.getSecond();
 
-        IntegratedServer integratedServer = mc.getIntegratedServer();
-
-        // If there is an integrated server running (Aka Singleplayer) then do magic to find the world save file
-        if (mc.isSingleplayer()) {
-            WorldServer localServerWorld = integratedServer.getWorld(dimension);
-            IChunkProviderServer provider = (IChunkProviderServer) localServerWorld.getChunkProvider();
-            IAnvilChunkLoader loader = (IAnvilChunkLoader) provider.getChunkLoader();
-            directory = loader.getChunkSaveLocation();
-
-            // Gets the "depth" of this directory relative the the game's run directory, 2 is the location of the world
-            if (directory.toPath().relativize(mc.gameDir.toPath()).getNameCount() != 2) {
-                // subdirectory of the main save directory for this world
-                directory = directory.getParentFile();
-            }
-
-            directory = new File(directory, "baritone");
-            readme = directory;
-        } else { // Otherwise, the server must be remote...
-            String folderName;
-            if (mc.getCurrentServerData() != null) {
-                folderName = mc.getCurrentServerData().serverIP;
-            } else {
-                //replaymod causes null currentServerData and false singleplayer.
-                System.out.println("World seems to be a replay. Not loading Baritone cache.");
-                currentWorld = null;
-                mcWorld = mc.world;
-                return;
-            }
-            if (SystemUtils.IS_OS_WINDOWS) {
-                folderName = folderName.replace(":", "_");
-            }
-            directory = new File(Baritone.getDir(), folderName);
-            readme = Baritone.getDir();
-        }
-
-        // lol wtf is this baritone folder in my minecraft save?
-        try (FileOutputStream out = new FileOutputStream(new File(readme, "readme.txt"))) {
-            // good thing we have a readme
-            out.write("https://github.com/cabaletta/baritone\n".getBytes());
-        } catch (IOException ignored) {}
-
-        // We will actually store the world data in a subfolder: "DIM<id>"
-        Path dir = new File(directory, "DIM" + dimension).toPath();
-        if (!Files.exists(dir)) {
             try {
-                Files.createDirectories(dir);
+                // lol wtf is this baritone folder in my minecraft save?
+                // good thing we have a readme
+                Files.createDirectories(readmeDir);
+                Files.write(
+                        readmeDir.resolve("readme.txt"),
+                        "https://github.com/cabaletta/baritone\n".getBytes(StandardCharsets.US_ASCII)
+                );
             } catch (IOException ignored) {}
-        }
 
-        System.out.println("Baritone world data dir: " + dir);
-        synchronized (worldCache) {
-            this.currentWorld = worldCache.computeIfAbsent(dir, d -> new WorldData(d, dimension));
-        }
-        this.mcWorld = mc.world;
+            // We will actually store the world data in a subfolder: "DIM<id>"
+            final Path worldDataDir = this.getWorldDataDirectory(worldDir, world);
+            try {
+                Files.createDirectories(worldDataDir);
+            } catch (IOException ignored) {}
+
+            System.out.println("Baritone world data dir: " + worldDataDir);
+            synchronized (worldCache) {
+                final int dimension = world.provider.getDimensionType().getId();
+                this.currentWorld = worldCache.computeIfAbsent(worldDataDir, d -> new WorldData(d, dimension));
+            }
+            this.mcWorld = ctx.world();
+        });
     }
 
     public final void closeWorld() {
@@ -128,26 +111,79 @@ public class WorldProvider implements IWorldProvider, Helper {
         world.onClose();
     }
 
-    public final void ifWorldLoaded(Consumer<WorldData> currentWorldConsumer) {
-        detectAndHandleBrokenLoading();
-        if (this.currentWorld != null) {
-            currentWorldConsumer.accept(this.currentWorld);
-        }
+    private Path getWorldDataDirectory(Path parent, World world) {
+        return parent.resolve("DIM" + world.provider.getDimensionType().getId());
     }
 
-    private final void detectAndHandleBrokenLoading() {
-        if (this.mcWorld != mc.world) {
+    /**
+     * @param world The world
+     * @return An {@link Optional} containing the world's baritone dir and readme dir, or {@link Optional#empty()} if
+     *         the world isn't valid for caching.
+     */
+    private Optional<Tuple<Path, Path>> getSaveDirectories(World world) {
+        Path worldDir;
+        Path readmeDir;
+
+        // If there is an integrated server running (Aka Singleplayer) then do magic to find the world save file
+        if (ctx.minecraft().isSingleplayer()) {
+            final int dimension = world.provider.getDimensionType().getId();
+            final WorldServer localServerWorld = ctx.minecraft().getIntegratedServer().getWorld(dimension);
+            final IChunkProviderServer provider = (IChunkProviderServer) localServerWorld.getChunkProvider();
+            final IAnvilChunkLoader loader = (IAnvilChunkLoader) provider.getChunkLoader();
+            worldDir = loader.getChunkSaveLocation().toPath();
+
+            // Gets the "depth" of this directory relative to the game's run directory, 2 is the location of the world
+            if (worldDir.relativize(ctx.minecraft().gameDir.toPath()).getNameCount() != 2) {
+                // subdirectory of the main save directory for this world
+                worldDir = worldDir.getParent();
+            }
+
+            worldDir = worldDir.resolve("baritone");
+            readmeDir = worldDir;
+        } else { // Otherwise, the server must be remote...
+            String folderName;
+            final ServerData serverData = ctx.minecraft().getCurrentServerData();
+            if (serverData != null) {
+                folderName = serverData.serverIP;
+            } else {
+                //replaymod causes null currentServerData and false singleplayer.
+                System.out.println("World seems to be a replay. Not loading Baritone cache.");
+                currentWorld = null;
+                mcWorld = ctx.world();
+                return Optional.empty();
+            }
+            if (SystemUtils.IS_OS_WINDOWS) {
+                folderName = folderName.replace(":", "_");
+            }
+            // TODO: This should probably be in "baritone/servers"
+            worldDir = baritone.getDirectory().resolve(folderName);
+            // Just write the readme to the baritone directory instead of each server save in it
+            readmeDir = baritone.getDirectory();
+        }
+
+        if (this.baritone != BaritoneAPI.getProvider().getPrimaryBaritone()) {
+            worldDir = worldDir.resolve("bot");
+        }
+
+        return Optional.of(new Tuple<>(worldDir, readmeDir));
+    }
+
+    /**
+     * Why does this exist instead of fixing the event? Some mods break the event. Lol.
+     */
+    private void detectAndHandleBrokenLoading() {
+        if (this.mcWorld != ctx.world()) {
             if (this.currentWorld != null) {
                 System.out.println("mc.world unloaded unnoticed! Unloading Baritone cache now.");
                 closeWorld();
             }
-            if (mc.world != null) {
+            if (ctx.world() != null) {
                 System.out.println("mc.world loaded unnoticed! Loading Baritone cache now.");
-                initWorld(mc.world.provider.getDimensionType().getId());
+                initWorld(ctx.world());
             }
-        } else if (currentWorld == null && mc.world != null && (mc.isSingleplayer() || mc.getCurrentServerData() != null)) {
+        } else if (this.currentWorld == null && ctx.world() != null && (ctx.minecraft().isSingleplayer() || ctx.minecraft().getCurrentServerData() != null)) {
             System.out.println("Retrying to load Baritone cache");
-            initWorld(mc.world.provider.getDimensionType().getId());
+            initWorld(ctx.world());
         }
     }
 }

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

@@ -17,8 +17,8 @@
 
 package baritone.command;
 
+import baritone.Baritone;
 import baritone.api.BaritoneAPI;
-import baritone.api.IBaritone;
 import baritone.api.Settings;
 import baritone.api.command.argument.ICommandArgument;
 import baritone.api.command.exception.CommandNotEnoughArgumentsException;
@@ -30,6 +30,7 @@ import baritone.api.event.events.TabCompleteEvent;
 import baritone.api.event.listener.AbstractGameEventListener;
 import baritone.api.utils.Helper;
 import baritone.api.utils.SettingsUtil;
+import baritone.behavior.Behavior;
 import baritone.command.argument.ArgConsumer;
 import baritone.command.argument.CommandArguments;
 import baritone.command.manager.CommandManager;
@@ -49,14 +50,14 @@ import java.util.stream.Stream;
 
 import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
 
-public class ExampleBaritoneControl implements Helper, AbstractGameEventListener {
+public class ExampleBaritoneControl extends Behavior implements Helper {
 
     private static final Settings settings = BaritoneAPI.getSettings();
     private final ICommandManager manager;
 
-    public ExampleBaritoneControl(IBaritone baritone) {
+    public ExampleBaritoneControl(Baritone baritone) {
+        super(baritone);
         this.manager = baritone.getCommandManager();
-        baritone.getGameEventHandler().registerEventListener(this);
     }
 
     @Override
@@ -100,7 +101,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             return false;
         } else if (msg.trim().equalsIgnoreCase("orderpizza")) {
             try {
-                ((IGuiScreen) mc.currentScreen).openLink(new URI("https://www.dominos.com/en/pages/order/"));
+                ((IGuiScreen) ctx.minecraft().currentScreen).openLink(new URI("https://www.dominos.com/en/pages/order/"));
             } catch (NullPointerException | URISyntaxException ignored) {}
             return false;
         }
@@ -124,7 +125,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
             }
         } else if (argc.hasExactlyOne()) {
             for (Settings.Setting setting : settings.allSettings) {
-                if (SettingsUtil.javaOnlySetting(setting)) {
+                if (setting.isJavaOnly()) {
                     continue;
                 }
                 if (setting.getName().equalsIgnoreCase(pair.getFirst())) {
@@ -177,7 +178,7 @@ public class ExampleBaritoneControl implements Helper, AbstractGameEventListener
                             .stream();
                 }
                 Settings.Setting setting = settings.byLowerName.get(argc.getString().toLowerCase(Locale.US));
-                if (setting != null && !SettingsUtil.javaOnlySetting(setting)) {
+                if (setting != null && !setting.isJavaOnly()) {
                     if (setting.getValueClass() == Boolean.class) {
                         TabCompleteHelper helper = new TabCompleteHelper();
                         if ((Boolean) setting.value) {

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

@@ -373,6 +373,8 @@ public class ArgConsumer implements IArgConsumer {
     public <T extends IDatatype> Stream<String> tabCompleteDatatype(T datatype) {
         try {
             return datatype.tabComplete(this.context);
+        } catch (CommandException ignored) {
+            // NOP
         } catch (Exception e) {
             e.printStackTrace();
         }

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

@@ -0,0 +1,168 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.command.defaults;
+
+import baritone.Baritone;
+import baritone.api.IBaritone;
+import baritone.api.bot.IBaritoneUser;
+import baritone.api.bot.connect.IConnectionResult;
+import baritone.api.command.Command;
+import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.exception.CommandException;
+import baritone.api.command.exception.CommandInvalidTypeException;
+import baritone.api.event.events.ChatEvent;
+import baritone.bot.UserManager;
+import baritone.bot.impl.BotGuiInventory;
+import net.minecraft.util.Session;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static baritone.api.command.IBaritoneChatControl.FORCE_COMMAND_PREFIX;
+
+/**
+ * @author Brady
+ * @since 3/2/2020
+ */
+public class BotCommand extends Command {
+
+    public BotCommand(IBaritone baritone) {
+        super(baritone, "bot");
+    }
+
+    @Override
+    public void execute(String label, IArgConsumer args) throws CommandException {
+        final Action action = Action.getByName(args.getString());
+        if (action == null) {
+            throw new CommandInvalidTypeException(args.consumed(), "an action");
+        }
+
+        if (action == Action.ADD) {
+            final String username = args.hasAny() ? args.getString() : "Bot" + System.currentTimeMillis() % 1000;
+            final Session session = new Session(username, UUID.randomUUID().toString(), "", "");
+            final IConnectionResult result = UserManager.INSTANCE.connect(session);
+            logDirect(result.toString());
+        } else if (action.requiresBotSelector()) {
+            final String selector = args.getString();
+            final List<IBaritoneUser> bots;
+
+            if (selector.equals("*")) {
+                bots = UserManager.INSTANCE.getUsers();
+            } else if (selector.contains(",")) {
+                bots = Arrays.stream(selector.split(","))
+                        .map(UserManager.INSTANCE::getUserByName)
+                        .filter(Optional::isPresent)
+                        .map(Optional::get)
+                        .collect(Collectors.toList());
+            } else {
+                bots = UserManager.INSTANCE.getUserByName(selector)
+                        .map(Collections::singletonList)
+                        .orElseGet(Collections::emptyList);
+            }
+
+            if (bots.isEmpty()) {
+                throw new CommandInvalidTypeException(args.consumed(), "selector didn't match any bots");
+            }
+
+            if (action == Action.INVENTORY) {
+                // Only display one inventory lol
+                final IBaritoneUser bot = bots.get(0);
+                ((Baritone) baritone).showScreen(new BotGuiInventory(bot));
+                return;
+            }
+
+            switch (action) {
+                case DISCONNECT: {
+                    bots.forEach(bot -> UserManager.INSTANCE.disconnect(bot, null));
+                    break;
+                }
+                case SAY: {
+                    final String message = args.rawRest();
+                    bots.forEach(bot -> bot.getPlayerContext().player().sendChatMessage(message));
+                    break;
+                }
+                case EXECUTE: {
+                    final String command = FORCE_COMMAND_PREFIX + args.rawRest();
+                    bots.forEach(bot -> bot.getBaritone().getGameEventHandler().onSendChatMessage(new ChatEvent(command)));
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public Stream<String> tabComplete(String label, IArgConsumer args) {
+        return Stream.empty();
+    }
+
+    @Override
+    public String getShortDesc() {
+        return "Manage bots";
+    }
+
+    @Override
+    public List<String> getLongDesc() {
+        return Arrays.asList(
+                "Spawns a bot",
+                "",
+                "Usage:",
+                "> bot add/a <name>",
+                "> bot inventory/i [bot]",
+                "> bot disconnect/d [bot]",
+                "> bot say/s [bot] [args...]",
+                "> bot execute/e [bot] [args...]"
+        );
+    }
+
+    private enum Action {
+        ADD("add", "a"),
+        INVENTORY("inventory", "i"),
+        DISCONNECT("disconnect", "d"),
+        SAY("say", "s"),
+        EXECUTE("execute", "e");
+        private final String[] names;
+
+        Action(String... names) {
+            this.names = names;
+        }
+
+        public boolean requiresBotSelector() {
+            return this == INVENTORY || this == DISCONNECT || this == SAY || this == EXECUTE;
+        }
+
+        public static Action getByName(String name) {
+            for (Action action : Action.values()) {
+                for (String alias : action.names) {
+                    if (alias.equalsIgnoreCase(name)) {
+                        return action;
+                    }
+                }
+            }
+            return null;
+        }
+
+        public static String[] getAllNames() {
+            Set<String> names = new HashSet<>();
+            for (Action action : Action.values()) {
+                names.addAll(Arrays.asList(action.names));
+            }
+            return names.toArray(new String[0]);
+        }
+    }
+}

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

@@ -26,7 +26,6 @@ import baritone.api.command.datatypes.RelativeFile;
 import baritone.api.command.exception.CommandException;
 import baritone.api.command.exception.CommandInvalidStateException;
 import baritone.api.utils.BetterBlockPos;
-import net.minecraft.client.Minecraft;
 import org.apache.commons.io.FilenameUtils;
 
 import java.io.File;
@@ -36,10 +35,11 @@ import java.util.stream.Stream;
 
 public class BuildCommand extends Command {
 
-    private static final File schematicsDir = new File(Minecraft.getMinecraft().gameDir, "schematics");
+    private final File schematicsDir;
 
     public BuildCommand(IBaritone baritone) {
         super(baritone, "build");
+        this.schematicsDir = new File(baritone.getPlayerContext().minecraft().gameDir, "schematics");
     }
 
     @Override

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

@@ -21,10 +21,7 @@ import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
 import baritone.api.command.exception.CommandException;
-import baritone.api.command.exception.CommandInvalidStateException;
 import baritone.api.pathing.goals.GoalBlock;
-import net.minecraft.entity.Entity;
-import net.minecraft.util.math.BlockPos;
 
 import java.util.Arrays;
 import java.util.List;
@@ -39,11 +36,7 @@ public class ComeCommand extends Command {
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
         args.requireMax(0);
-        Entity entity = mc.getRenderViewEntity();
-        if (entity == null) {
-            throw new CommandInvalidStateException("render view entity is null");
-        }
-        baritone.getCustomGoalProcess().setGoalAndPath(new GoalBlock(new BlockPos(entity)));
+        baritone.getCustomGoalProcess().setGoalAndPath(new GoalBlock(ctx.viewerPos()));
         logDirect("Coming");
     }
 

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

@@ -46,6 +46,7 @@ public final class DefaultCommands {
                 new LitematicaCommand(baritone),
                 new ComeCommand(baritone),
                 new AxisCommand(baritone),
+                new BotCommand(baritone),
                 new ForceCancelCommand(baritone),
                 new GcCommand(baritone),
                 new InvertCommand(baritone),

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

@@ -41,7 +41,7 @@ public class ExploreFilterCommand extends Command {
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
         args.requireMax(2);
-        File file = args.getDatatypePost(RelativeFile.INSTANCE, mc.gameDir.getAbsoluteFile().getParentFile());
+        File file = args.getDatatypePost(RelativeFile.INSTANCE, ctx.minecraft().gameDir.getAbsoluteFile().getParentFile());
         boolean invert = false;
         if (args.hasAny()) {
             if (args.getString().equalsIgnoreCase("invert")) {
@@ -65,7 +65,7 @@ public class ExploreFilterCommand extends Command {
     @Override
     public Stream<String> tabComplete(String label, IArgConsumer args) throws CommandException {
         if (args.hasExactlyOne()) {
-            return RelativeFile.tabComplete(args, RelativeFile.gameDir());
+            return RelativeFile.tabComplete(args, RelativeFile.gameDir(ctx.minecraft()));
         }
         return Stream.empty();
     }

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

@@ -51,7 +51,7 @@ public class GoalCommand extends Command {
             }
         } else {
             args.requireMax(3);
-            BetterBlockPos origin = baritone.getPlayerContext().playerFeet();
+            BetterBlockPos origin = ctx.playerFeet();
             Goal goal = args.getDatatypePost(RelativeGoal.INSTANCE, origin);
             goalProcess.setGoal(goal);
             logDirect(String.format("Goal: %s", goal.toString()));

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

@@ -20,7 +20,6 @@ package baritone.command.defaults;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
-import baritone.api.command.datatypes.BlockById;
 import baritone.api.command.datatypes.ForBlockOptionalMeta;
 import baritone.api.command.datatypes.RelativeCoordinate;
 import baritone.api.command.datatypes.RelativeGoal;
@@ -46,7 +45,7 @@ public class GotoCommand extends Command {
         // is no need to handle the case of empty arguments.
         if (args.peekDatatypeOrNull(RelativeCoordinate.INSTANCE) != null) {
             args.requireMax(3);
-            BetterBlockPos origin = baritone.getPlayerContext().playerFeet();
+            BetterBlockPos origin = ctx.playerFeet();
             Goal goal = args.getDatatypePost(RelativeGoal.INSTANCE, origin);
             logDirect(String.format("Going to: %s", goal.toString()));
             baritone.getCustomGoalProcess().setGoalAndPath(goal);
@@ -61,7 +60,8 @@ public class GotoCommand extends Command {
     public Stream<String> tabComplete(String label, IArgConsumer args) throws CommandException {
         // since it's either a goal or a block, I don't think we can tab complete properly?
         // so just tab complete for the block variant
-        return args.tabCompleteDatatype(BlockById.INSTANCE);
+        args.requireMax(1);
+        return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
     }
 
     @Override

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

@@ -17,10 +17,10 @@
 
 package baritone.command.defaults;
 
+import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
-import baritone.api.command.datatypes.BlockById;
 import baritone.api.command.datatypes.ForBlockOptionalMeta;
 import baritone.api.command.exception.CommandException;
 import baritone.api.utils.BlockOptionalMeta;
@@ -45,14 +45,18 @@ public class MineCommand extends Command {
         while (args.hasAny()) {
             boms.add(args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE));
         }
-        WorldScanner.INSTANCE.repack(ctx);
+        BaritoneAPI.getProvider().getWorldScanner().repack(ctx);
         logDirect(String.format("Mining %s", boms.toString()));
         baritone.getMineProcess().mine(quantity, boms.toArray(new BlockOptionalMeta[0]));
     }
 
     @Override
-    public Stream<String> tabComplete(String label, IArgConsumer args) {
-        return args.tabCompleteDatatype(BlockById.INSTANCE);
+    public Stream<String> tabComplete(String label, IArgConsumer args) throws CommandException {
+        args.getAsOrDefault(Integer.class, 0);
+        while (args.has(2)) {
+            args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
+        }
+        return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
     }
 
     @Override

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

@@ -17,6 +17,7 @@
 
 package baritone.command.defaults;
 
+import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
@@ -38,7 +39,7 @@ public class PathCommand extends Command {
     public void execute(String label, IArgConsumer args) throws CommandException {
         ICustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
         args.requireMax(0);
-        WorldScanner.INSTANCE.repack(ctx);
+        BaritoneAPI.getProvider().getWorldScanner().repack(ctx);
         customGoalProcess.path();
         logDirect("Now pathing");
     }

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

@@ -37,8 +37,8 @@ public class RenderCommand extends Command {
     public void execute(String label, IArgConsumer args) throws CommandException {
         args.requireMax(0);
         BetterBlockPos origin = ctx.playerFeet();
-        int renderDistance = (mc.gameSettings.renderDistanceChunks + 1) * 16;
-        mc.renderGlobal.markBlockRangeForRenderUpdate(
+        int renderDistance = (ctx.minecraft().gameSettings.renderDistanceChunks + 1) * 16;
+        ctx.minecraft().renderGlobal.markBlockRangeForRenderUpdate(
                 origin.x - renderDistance,
                 0,
                 origin.z - renderDistance,

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

@@ -17,6 +17,7 @@
 
 package baritone.command.defaults;
 
+import baritone.api.BaritoneAPI;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
@@ -36,7 +37,7 @@ public class RepackCommand extends Command {
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
         args.requireMax(0);
-        logDirect(String.format("Queued %d chunks for repacking", WorldScanner.INSTANCE.repack(ctx)));
+        logDirect(String.format("Queued %d chunks for repacking", BaritoneAPI.getProvider().getWorldScanner().repack(ctx)));
     }
 
     @Override

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

@@ -21,6 +21,7 @@ import baritone.Baritone;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.datatypes.ForAxis;
 import baritone.api.command.datatypes.ForBlockOptionalMeta;
 import baritone.api.command.datatypes.ForEnumFacing;
 import baritone.api.command.datatypes.RelativeBlockPos;
@@ -31,6 +32,8 @@ import baritone.api.command.helpers.TabCompleteHelper;
 import baritone.api.event.events.RenderEvent;
 import baritone.api.event.listener.AbstractGameEventListener;
 import baritone.api.schematic.*;
+import baritone.api.schematic.mask.shape.CylinderMask;
+import baritone.api.schematic.mask.shape.SphereMask;
 import baritone.api.selection.ISelection;
 import baritone.api.selection.ISelectionManager;
 import baritone.api.utils.BetterBlockPos;
@@ -50,6 +53,7 @@ import java.awt.*;
 import java.util.List;
 import java.util.*;
 import java.util.function.Function;
+import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
 public class SelCommand extends Command {
@@ -72,7 +76,7 @@ public class SelCommand extends Command {
                 float lineWidth = Baritone.settings().selectionLineWidth.value;
                 boolean ignoreDepth = Baritone.settings().renderSelectionIgnoreDepth.value;
                 IRenderer.startLines(color, opacity, lineWidth, ignoreDepth);
-                IRenderer.drawAABB(new AxisAlignedBB(pos1, pos1.add(1, 1, 1)));
+                IRenderer.emitAABB(new AxisAlignedBB(pos1, pos1.add(1, 1, 1)));
                 IRenderer.endLines(ignoreDepth);
             }
         });
@@ -88,7 +92,7 @@ public class SelCommand extends Command {
             if (action == Action.POS2 && pos1 == null) {
                 throw new CommandInvalidStateException("Set pos1 first before using pos2");
             }
-            BetterBlockPos playerPos = mc.getRenderViewEntity() != null ? BetterBlockPos.from(new BlockPos(mc.getRenderViewEntity())) : ctx.playerFeet();
+            BetterBlockPos playerPos = ctx.viewerPos();
             BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
             args.requireMax(0);
             if (action == Action.POS1) {
@@ -117,11 +121,13 @@ public class SelCommand extends Command {
                     logDirect("Undid pos2");
                 }
             }
-        } else if (action == Action.SET || action == Action.WALLS || action == Action.SHELL || action == Action.CLEARAREA || action == Action.REPLACE) {
+        } else if (action.isFillAction()) {
             BlockOptionalMeta type = action == Action.CLEARAREA
                     ? new BlockOptionalMeta(Blocks.AIR)
                     : args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
-            BlockOptionalMetaLookup replaces = null;
+
+            final BlockOptionalMetaLookup replaces; // Action.REPLACE
+            final EnumFacing.Axis alignment;        // Action.(H)CYLINDER
             if (action == Action.REPLACE) {
                 args.requireMin(1);
                 List<BlockOptionalMeta> replacesList = new ArrayList<>();
@@ -131,8 +137,15 @@ public class SelCommand extends Command {
                 }
                 type = args.getDatatypeFor(ForBlockOptionalMeta.INSTANCE);
                 replaces = new BlockOptionalMetaLookup(replacesList.toArray(new BlockOptionalMeta[0]));
+                alignment = null;
+            } else if (action == Action.CYLINDER || action == Action.HCYLINDER) {
+                args.requireMax(1);
+                alignment = args.hasAny() ? args.getDatatypeFor(ForAxis.INSTANCE) : EnumFacing.Axis.Y;
+                replaces = null;
             } else {
                 args.requireMax(0);
+                replaces = null;
+                alignment = null;
             }
             ISelection[] selections = manager.getSelections();
             if (selections.length == 0) {
@@ -151,20 +164,41 @@ public class SelCommand extends Command {
             for (ISelection selection : selections) {
                 Vec3i size = selection.size();
                 BetterBlockPos min = selection.min();
-                ISchematic schematic = new FillSchematic(size.getX(), size.getY(), size.getZ(), type);
-                if (action == Action.WALLS) {
-                    schematic = new WallsSchematic(schematic);
-                } else if (action == Action.SHELL) {
-                    schematic = new ShellSchematic(schematic);
-                } else if (action == Action.REPLACE) {
-                    schematic = new ReplaceSchematic(schematic, replaces);
-                }
+
+                // Java 8 so no switch expressions 😿
+                UnaryOperator<ISchematic> create = fill -> {
+                    final int w = fill.widthX();
+                    final int h = fill.heightY();
+                    final int l = fill.lengthZ();
+
+                    switch (action) {
+                        case WALLS:
+                            return new WallsSchematic(fill);
+                        case SHELL:
+                            return new ShellSchematic(fill);
+                        case REPLACE:
+                            return new ReplaceSchematic(fill, replaces);
+                        case SPHERE:
+                            return MaskSchematic.create(fill, new SphereMask(w, h, l, true).compute());
+                        case HSPHERE:
+                            return MaskSchematic.create(fill, new SphereMask(w, h, l, false).compute());
+                        case CYLINDER:
+                            return MaskSchematic.create(fill, new CylinderMask(w, h, l, true, alignment).compute());
+                        case HCYLINDER:
+                            return MaskSchematic.create(fill, new CylinderMask(w, h, l, false, alignment).compute());
+                        default:
+                            // Silent fail
+                            return fill;
+                    }
+                };
+
+                ISchematic schematic = create.apply(new FillSchematic(size.getX(), size.getY(), size.getZ(), type));
                 composite.put(schematic, min.x - origin.x, min.y - origin.y, min.z - origin.z);
             }
             baritone.getBuilderProcess().build("Fill", composite, origin);
             logDirect("Filling now");
         } else if (action == Action.COPY) {
-            BetterBlockPos playerPos = mc.getRenderViewEntity() != null ? BetterBlockPos.from(new BlockPos(mc.getRenderViewEntity())) : ctx.playerFeet();
+            BetterBlockPos playerPos = ctx.viewerPos();
             BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
             args.requireMax(0);
             ISelection[] selections = manager.getSelections();
@@ -205,7 +239,7 @@ public class SelCommand extends Command {
             clipboardOffset = origin.subtract(pos);
             logDirect("Selection copied");
         } else if (action == Action.PASTE) {
-            BetterBlockPos playerPos = mc.getRenderViewEntity() != null ? BetterBlockPos.from(new BlockPos(mc.getRenderViewEntity())) : ctx.playerFeet();
+            BetterBlockPos playerPos = ctx.viewerPos();
             BetterBlockPos pos = args.hasAny() ? args.getDatatypePost(RelativeBlockPos.INSTANCE, playerPos) : playerPos;
             args.requireMax(0);
             if (clipboard == null) {
@@ -254,12 +288,15 @@ public class SelCommand extends Command {
                     if (args.hasAtMost(3)) {
                         return args.tabCompleteDatatype(RelativeBlockPos.INSTANCE);
                     }
-                } else if (action == Action.SET || action == Action.WALLS || action == Action.CLEARAREA || action == Action.REPLACE) {
+                } else if (action.isFillAction()) {
                     if (args.hasExactlyOne() || action == Action.REPLACE) {
                         while (args.has(2)) {
                             args.get();
                         }
                         return args.tabCompleteDatatype(ForBlockOptionalMeta.INSTANCE);
+                    } else if (args.hasExactly(2) && (action == Action.CYLINDER || action == Action.HCYLINDER)) {
+                        args.get();
+                        return args.tabCompleteDatatype(ForAxis.INSTANCE);
                     }
                 } else if (action == Action.EXPAND || action == Action.CONTRACT || action == Action.SHIFT) {
                     if (args.hasExactlyOne()) {
@@ -305,6 +342,10 @@ public class SelCommand extends Command {
                 "> sel set/fill/s/f [block] - Completely fill all selections with a block.",
                 "> sel walls/w [block] - Fill in the walls of the selection with a specified block.",
                 "> sel shell/shl [block] - The same as walls, but fills in a ceiling and floor too.",
+                "> sel sphere/sph [block] - Fills the selection with a sphere bounded by the sides.",
+                "> sel hsphere/hsph [block] - The same as sphere, but hollow.",
+                "> sel cylinder/cyl [block] <axis> - Fills the selection with a cylinder bounded by the sides, oriented about the given axis. (default=y)",
+                "> sel hcylinder/hcyl [block] <axis> - The same as cylinder, but hollow.",
                 "> sel cleararea/ca - Basically 'set air'.",
                 "> sel replace/r <blocks...> <with> - Replaces blocks with another block.",
                 "> sel copy/cp <x> <y> <z> - Copy the selected area relative to the specified or your position.",
@@ -324,6 +365,10 @@ public class SelCommand extends Command {
         SET("set", "fill", "s", "f"),
         WALLS("walls", "w"),
         SHELL("shell", "shl"),
+        SPHERE("sphere", "sph"),
+        HSPHERE("hsphere", "hsph"),
+        CYLINDER("cylinder", "cyl"),
+        HCYLINDER("hcylinder", "hcyl"),
         CLEARAREA("cleararea", "ca"),
         REPLACE("replace", "r"),
         EXPAND("expand", "ex"),
@@ -355,6 +400,18 @@ public class SelCommand extends Command {
             }
             return names.toArray(new String[0]);
         }
+
+        public final boolean isFillAction() {
+            return this == SET
+                    || this == WALLS
+                    || this == SHELL
+                    || this == SPHERE
+                    || this == HSPHERE
+                    || this == CYLINDER
+                    || this == HCYLINDER
+                    || this == CLEARAREA
+                    || this == REPLACE;
+        }
     }
 
     enum TransformTarget {

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

@@ -22,12 +22,14 @@ import baritone.api.IBaritone;
 import baritone.api.Settings;
 import baritone.api.command.Command;
 import baritone.api.command.argument.IArgConsumer;
+import baritone.api.command.datatypes.RelativeFile;
 import baritone.api.command.exception.CommandException;
 import baritone.api.command.exception.CommandInvalidStateException;
 import baritone.api.command.exception.CommandInvalidTypeException;
 import baritone.api.command.helpers.Paginator;
 import baritone.api.command.helpers.TabCompleteHelper;
 import baritone.api.utils.SettingsUtil;
+import net.minecraft.client.Minecraft;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
@@ -57,6 +59,18 @@ public class SetCommand extends Command {
             logDirect("Settings saved");
             return;
         }
+        if (Arrays.asList("load", "ld").contains(arg)) {
+            String file = SETTINGS_DEFAULT_NAME;
+            if (args.hasAny()) {
+                file = args.getString();
+            }
+            // reset to defaults
+            SettingsUtil.modifiedSettings(Baritone.settings()).forEach(Settings.Setting::reset);
+            // then load from disk
+            SettingsUtil.readAndApply(Baritone.settings(), file);
+            logDirect("Settings reloaded from " + file);
+            return;
+        }
         boolean viewModified = Arrays.asList("m", "mod", "modified").contains(arg);
         boolean viewAll = Arrays.asList("all", "l", "list").contains(arg);
         boolean paginate = viewModified || viewAll;
@@ -65,7 +79,7 @@ public class SetCommand extends Command {
             args.requireMax(1);
             List<? extends Settings.Setting> toPaginate =
                     (viewModified ? SettingsUtil.modifiedSettings(Baritone.settings()) : Baritone.settings().allSettings).stream()
-                            .filter(s -> !javaOnlySetting(s))
+                            .filter(s -> !s.isJavaOnly())
                             .filter(s -> s.getName().toLowerCase(Locale.US).contains(search.toLowerCase(Locale.US)))
                             .sorted((s1, s2) -> String.CASE_INSENSITIVE_ORDER.compare(s1.getName(), s2.getName()))
                             .collect(Collectors.toList());
@@ -129,7 +143,7 @@ public class SetCommand extends Command {
         if (setting == null) {
             throw new CommandInvalidTypeException(args.consumed(), "a valid setting");
         }
-        if (javaOnlySetting(setting)) {
+        if (setting.isJavaOnly()) {
             // ideally it would act as if the setting didn't exist
             // but users will see it in Settings.java or its javadoc
             // so at some point we have to tell them or they will see it as a bug
@@ -209,6 +223,9 @@ public class SetCommand extends Command {
                             .addToggleableSettings()
                             .filterPrefix(args.getString())
                             .stream();
+                } else if (Arrays.asList("ld", "load").contains(arg.toLowerCase(Locale.US))) {
+                    // settings always use the directory of the main Minecraft instance
+                    return RelativeFile.tabComplete(args, Minecraft.getMinecraft().gameDir.toPath().resolve("baritone").toFile());
                 }
                 Settings.Setting setting = Baritone.settings().byLowerName.get(arg.toLowerCase(Locale.US));
                 if (setting != null) {
@@ -228,7 +245,7 @@ public class SetCommand extends Command {
                 return new TabCompleteHelper()
                         .addSettings()
                         .sortAlphabetically()
-                        .prepend("list", "modified", "reset", "toggle", "save")
+                        .prepend("list", "modified", "reset", "toggle", "save", "load")
                         .filterPrefix(arg)
                         .stream();
             }
@@ -255,7 +272,9 @@ public class SetCommand extends Command {
                 "> set reset all - Reset ALL SETTINGS to their defaults",
                 "> set reset <setting> - Reset a setting to its default",
                 "> set toggle <setting> - Toggle a boolean setting",
-                "> set save - Save all settings (this is automatic tho)"
+                "> set save - Save all settings (this is automatic tho)",
+                "> set load - Load settings from settings.txt",
+                "> set load [filename] - Load settings from another file in your minecraft/baritone"
         );
     }
 }

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

@@ -38,13 +38,13 @@ public class SurfaceCommand extends Command {
 
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
-        final BetterBlockPos playerPos = baritone.getPlayerContext().playerFeet();
-        final int surfaceLevel = baritone.getPlayerContext().world().getSeaLevel();
-        final int worldHeight = baritone.getPlayerContext().world().getActualHeight();
+        final BetterBlockPos playerPos = ctx.playerFeet();
+        final int surfaceLevel = ctx.world().getSeaLevel();
+        final int worldHeight = ctx.world().getActualHeight();
 
         // Ensure this command will not run if you are above the surface level and the block above you is air
         // As this would imply that your are already on the open surface
-        if (playerPos.getY() > surfaceLevel && mc.world.getBlockState(playerPos.up()).getBlock() instanceof BlockAir) {
+        if (playerPos.getY() > surfaceLevel && ctx.world().getBlockState(playerPos.up()).getBlock() instanceof BlockAir) {
             logDirect("Already at surface");
             return;
         }
@@ -54,7 +54,7 @@ public class SurfaceCommand extends Command {
         for (int currentIteratedY = startingYPos; currentIteratedY < worldHeight; currentIteratedY++) {
             final BetterBlockPos newPos = new BetterBlockPos(playerPos.getX(), currentIteratedY, playerPos.getZ());
 
-            if (!(mc.world.getBlockState(newPos).getBlock() instanceof BlockAir) && newPos.getY() > playerPos.getY()) {
+            if (!(ctx.world().getBlockState(newPos).getBlock() instanceof BlockAir) && newPos.getY() > playerPos.getY()) {
                 Goal goal = new GoalBlock(newPos.up());
                 logDirect(String.format("Going to: %s", goal.toString()));
                 baritone.getCustomGoalProcess().setGoalAndPath(goal);