fixes

currentlyTicking Solution

.gitignore

@@ -3,6 +3,7 @@
 
 run/
 autotest/
+dist/
 
 # Gradle
 build/

.travis.yml

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

Dockerfile

@@ -13,14 +13,12 @@ RUN apt install --target-release jessie-backports \
 
 RUN apt install -qq --force-yes mesa-utils libgl1-mesa-glx libxcursor1 libxrandr2 libxxf86vm1 x11-xserver-utils xfonts-base xserver-common
 
-RUN apt install -qq --force-yes unzip wget
-
 COPY . /code
 
-# this .deb is specially patched to support lwjgl
-# source: https://github.com/tectonicus/tectonicus/issues/60#issuecomment-154239173
-RUN dpkg -i /code/scripts/xvfb_1.16.4-1_amd64.deb
-
 WORKDIR /code
 
+# this .deb is specially patched to support lwjgl
+# source: https://github.com/tectonicus/tectonicus/issues/60#issuecomment-154239173
+RUN dpkg -i scripts/xvfb_1.16.4-1_amd64.deb
+
 RUN ./gradlew build

IMPACT.md

@@ -1,91 +1 @@
-# Integration between Baritone and Impact
-Impact 4.4 will have Baritone included on release, however, if you're impatient, you can install Baritone into Impact 4.3 right now!
-
-## An Introduction
-There are some basic steps to getting Baritone setup with Impact.
-- Acquiring a build of Baritone
-- Placing Baritone in the libraries directory
-- Modifying the Impact Profile JSON to run baritone
-- How to use Baritone
-
-## Acquiring a build of Baritone
-There are 3 methods of acquiring a build of Baritone (While it is still in development)
-
-### Official Release (Not always up to date)
-https://github.com/cabaletta/baritone/releases
-
-For Impact 4.3, there is no Baritone integration yet, so you will want `baritone-standalone-X.Y.Z.jar`.
-
-Any official release will be GPG signed by leijurv (44A3EA646EADAC6A) and ZeroMemes (73A788379A197567). Please verify that the hash of the file you download is in `checksums.txt` and that `checksums_signed.asc` is a valid signature by those two public keys of `checksums.txt`. 
-
-The build for `baritone-unoptimized-X.Y.Z.jar` is deterministic, and you can verify Travis did it properly by running `scripts/build.sh` yourself and comparing the shasum. The proguarded files (api and standalone) aren't yet reproducible, because proguard annoyingly includes the current timestamp into the final jar.
-
-### Building Baritone yourself
-There are a few steps to this
-- Clone this repository
-- Setup the project as instructed in the README
-- Run the ``build`` gradle task. You can either do this using IntelliJ's gradle UI or through a
-command line
-  - Windows: ``gradlew build``
-  - Mac/Linux: ``./gradlew build``
-- The build should be exported into ``/build/libs/baritone-X.Y.Z.jar``
-
-### Cutting Edge Release
-If you want to trust @Plutie#9079, you can download an automatically generated build of the latest commit
-from his Jenkins server, found <a href="https://plutiejenkins.leijurv.com/job/baritone/lastSuccessfulBuild/">here</a>.
-
-## Placing Baritone in the libraries directory
-``/libraries`` is a neat directory in your <a href="https://minecraft.gamepedia.com/.minecraft">Minecraft Installation Directory</a>
-that contains all of the dependencies that are required from the game and some mods. This is where we will be
-putting baritone.
-- Locate the ``libraries`` folder, it should be in the Minecraft Installation Directory
-- Create 3 new subdirectories starting from ``libraries``
-  - ``cabaletta``
-    - ``baritone``
-      - ``X.Y.Z``
- - Copy the build of Baritone that was acquired earlier, and place it into the ``X.Y.Z`` folder
-   - The full path should look like ``<Minecraft>/libraries/cabaletta/baritone/X.Y.Z/baritone-X.Y.Z.jar``
-
-## Modifying the Impact Profile JSON to run baritone
-The final step is "registering" the Baritone library with Impact, so that it loads on launch.
-- Ensure your Minecraft launcher is closed
-- Navigate back to the Minecraft Installation Directory
-- Find the ``versions`` directory, and open in
-- In here there should be a ``1.12.2-Impact_4.3`` folder.
-  - If you don't have any Impact folder or have a version older than 4.3, you can download Impact <a href="https://impactdevelopment.github.io">here</a>.
-- Open the folder and inside there should be a file called ``1.12.2-Impact_4.3.json``
-- Open the JSON file with a text editor that supports your system's line endings
-  - For example, Notepad on Windows likely will NOT work for this. You should instead use a Text Editor like
-  <a href="https://notepad-plus-plus.org/">Notepad++</a> if you're on Windows. (For other systems, I'm not sure
-  what would work the best so you may have to do some research.)
-- Find the ``libraries`` array in the JSON. It should look something like this.
-    ```
-    "libraries": [
-        {
-            "name": "net.minecraft:launchwrapper:1.12"
-        },
-        {
-            "name": "com.github.ImpactDevelopment:Impact:4.3-1.12.2",
-            "url": "https://impactdevelopment.github.io/maven/"
-        },
-        {
-            "name": "com.github.ImpactDeveloment:ClientAPI:3.0.2",
-            "url": "https://impactdevelopment.github.io/maven/"
-        },
-        ...
-    ```
-- Create a new object in the array, between the ``Impact`` and ``ClientAPI`` dependencies preferably.
-    ```
-    {
-        "name": "cabaletta:baritone:X.Y.Z"
-    },
-    ```
-- Now find the ``"minecraftArguments": "..."`` text near the top.
-- At the very end of the quotes where it says ``--tweakClass clientapi.load.ClientTweaker"``, add on the following so it looks like:
-  - ``--tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine"``
-- If you didn't close your launcher for this step, restart it now.
-- You can now launch Impact 4.3 as normal, and Baritone should start up
- 
- ## How to use Baritone
- Instructions on how to use Baritone are limited, and you may have to read a little bit of code (Really nothing much
-  just plain English), you can view that <a href="https://github.com/cabaletta/baritone#chat-control">here</a>.
+Impact 4.4 is out. See <a href="INSTALL.md">INSTALL.md</a>

INSTALL.md

@@ -0,0 +1,96 @@
+# Integration between Baritone and Impact
+Impact 4.4 has Baritone included.
+
+These instructions apply to Impact 4.3 (and potentially other hacked clients).
+
+To run Baritone on Vanilla, just follow the instructions in the README (it's `./gradlew runClient`).
+
+
+## An Introduction
+There are some basic steps to getting Baritone setup with Impact.
+- Acquiring a build of Baritone
+- Placing Baritone in the libraries directory
+- Modifying the Impact Profile JSON to run baritone
+- How to use Baritone
+
+## Acquiring a build of Baritone
+There are two methods of acquiring a build of Baritone
+
+### Official Release (Not always up to date)
+https://github.com/cabaletta/baritone/releases
+
+For Impact 4.3, there is no Baritone integration yet, so you will want `baritone-standalone-X.Y.Z.jar`.
+
+Any official release will be GPG signed by leijurv (44A3EA646EADAC6A) and ZeroMemes (73A788379A197567). Please verify that the hash of the file you download is in `checksums.txt` and that `checksums_signed.asc` is a valid signature by those two public keys of `checksums.txt`. 
+
+The build is fully deterministic and reproducible, and you can verify Travis did it properly by running `docker build --no-cache -t cabaletta/baritone . && docker run --rm cabaletta/baritone cat /code/dist/checksums.txt` yourself and comparing the shasum. This works identically on Travis, Mac, and Linux (if you have docker on Windows, I'd be grateful if you could let me know if it works there too).
+
+### Building Baritone yourself
+There are a few steps to this
+- Clone this repository
+- Setup the project as instructed in the README
+- Run the ``build`` gradle task. You can either do this using IntelliJ's gradle UI or through a
+command line
+  - Windows: ``gradlew build``
+  - Mac/Linux: ``./gradlew build``
+- The build should be exported into ``/build/libs/baritone-X.Y.Z.jar``
+
+## Placing Baritone in the libraries directory
+``/libraries`` is a neat directory in your <a href="https://minecraft.gamepedia.com/.minecraft">Minecraft Installation Directory</a>
+that contains all of the dependencies that are required from the game and some mods. This is where we will be
+putting baritone.
+- Locate the ``libraries`` folder, it should be in the Minecraft Installation Directory
+- Create 3 new subdirectories starting from ``libraries``
+  - ``cabaletta``
+    - ``baritone``
+      - ``X.Y.Z``
+ - Copy the build of Baritone that was acquired earlier, and place it into the ``X.Y.Z`` folder
+   - The full path should look like ``<Minecraft>/libraries/cabaletta/baritone/X.Y.Z/baritone-X.Y.Z.jar``
+
+## Modifying the Impact Profile JSON to run baritone
+The final step is "registering" the Baritone library with Impact, so that it loads on launch.
+- Ensure your Minecraft launcher is closed
+- Navigate back to the Minecraft Installation Directory
+- Find the ``versions`` directory, and open in
+- In here there should be a ``1.12.2-Impact_4.3`` folder.
+  - If you don't have any Impact folder or have a version older than 4.3, you can download Impact <a href="https://impactdevelopment.github.io">here</a>.
+- Open the folder and inside there should be a file called ``1.12.2-Impact_4.3.json``
+- Open the JSON file with a text editor that supports your system's line endings
+  - For example, Notepad on Windows likely will NOT work for this. You should instead use a Text Editor like
+  <a href="https://notepad-plus-plus.org/">Notepad++</a> if you're on Windows. (For other systems, I'm not sure
+  what would work the best so you may have to do some research.)
+- Find the ``libraries`` array in the JSON. It should look something like this.
+    ```
+    "libraries": [
+        {
+            "name": "net.minecraft:launchwrapper:1.12"
+        },
+        {
+            "name": "com.github.ImpactDevelopment:Impact:4.3-1.12.2",
+            "url": "https://impactdevelopment.github.io/maven/"
+        },
+        {
+            "name": "com.github.ImpactDeveloment:ClientAPI:3.0.2",
+            "url": "https://impactdevelopment.github.io/maven/"
+        },
+        ...
+    ```
+- Create two new objects in the array, between the ``Impact`` and ``ClientAPI`` dependencies preferably.
+    ```
+    {
+        "name": "cabaletta:baritone:X.Y.Z"
+    },
+    {
+        "name": "com.github.ImpactDevelopment:SimpleTweaker:1.2",
+        "url": "https://impactdevelopment.github.io/maven/"
+    },
+    ```
+- Now find the ``"minecraftArguments": "..."`` text near the top.
+- At the very end of the quotes where it says ``--tweakClass clientapi.load.ClientTweaker"``, add on the following so it looks like:
+  - ``--tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine"``
+- If you didn't close your launcher for this step, restart it now.
+- You can now launch Impact 4.3 as normal, and Baritone should start up
+ 
+ ## How to use Baritone
+ Instructions on how to use Baritone are limited, and you may have to read a little bit of code (Really nothing much
+  just plain English), you can view that <a href="https://github.com/cabaletta/baritone#chat-control">here</a>.

PROTOCOL.md

@@ -0,0 +1,36 @@
+# Baritone Comms Protocol
+
+## Data Types
+
+| Name       | Descriptor                                                | Java                        |
+|------------|-----------------------------------------------------------|-----------------------------|
+| coordinate | Big endian 8-byte floating point number                   | [readDouble], [writeDouble] |
+| string     | unsigned short (length) followed by UTF-8 character bytes | [readUTF],    [writeUTF]    |
+
+## Inbound
+
+Allows the server to execute a chat command on behalf of the client's player
+
+### Chat
+
+| Name    | Type   |
+|---------|--------|
+| Message | string |
+
+## Outbound
+
+Update the player position with the server
+
+### Status
+
+| Name | Type       |
+|------|------------|
+| X    | coordinate |
+| Y    | coordinate |
+| Z    | coordinate |
+
+<!-- External links -->
+[readUTF]:     https://docs.oracle.com/javase/7/docs/api/java/io/DataInputStream.html#readUTF()
+[writeUTF]:    https://docs.oracle.com/javase/7/docs/api/java/io/DataOutputStream.html#writeUTF(java.lang.String)
+[readDouble]:  https://docs.oracle.com/javase/7/docs/api/java/io/DataInputStream.html#readDouble()
+[writeDouble]: https://docs.oracle.com/javase/7/docs/api/java/io/DataOutputStream.html#writeDouble(double)

README.md

@@ -1,46 +1,52 @@
 # Baritone
 [![Build Status](https://travis-ci.com/cabaletta/baritone.svg?branch=master)](https://travis-ci.com/cabaletta/baritone)
+[![Release](https://img.shields.io/github/release/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/releases)
 [![License](https://img.shields.io/github/license/cabaletta/baritone.svg)](LICENSE)
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/7150d8ccf6094057b1782aa7a8f92d7d)](https://www.codacy.com/app/leijurv/baritone?utm_source=github.com&utm_medium=referral&utm_content=cabaletta/baritone&utm_campaign=Badge_Grade)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/a73d037823b64a5faf597a18d71e3400)](https://www.codacy.com/app/leijurv/baritone?utm_source=github.com&utm_medium=referral&utm_content=cabaletta/baritone&utm_campaign=Badge_Grade)
+[![HitCount](http://hits.dwyl.com/cabaletta/baritone.svg)](http://hits.dwyl.com/cabaletta/baritone)
+[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/cabaletta/baritone/issues)
+[![Minecraft](https://img.shields.io/badge/MC-1.12.2-green.svg)](https://minecraft.gamepedia.com/1.12.2)
 
-Unofficial Jenkins: [![Build Status](https://plutiejenkins.leijurv.com/job/baritone/badge/icon)](https://plutiejenkins.leijurv.com/job/baritone/lastSuccessfulBuild/)
+A Minecraft pathfinder bot. 
 
-A Minecraft pathfinder bot. This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
+Baritone is the pathfinding system used in [Impact](https://impactdevelopment.github.io/) since 4.4. There's a [showcase video](https://www.youtube.com/watch?v=yI8hgW_m6dQ) made by @Adovin#3153 on Baritone's integration into Impact. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a video I made showing off what it can do.
+
+This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. Baritone focuses on reliability and particularly performance (it's over [29x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
 
 Here are some links to help to get started:
 
 - [Features](FEATURES.md)
 
-- [Baritone + Impact](IMPACT.md)
+- [Installation](INSTALL.md)
 
 There's also some useful information down below
 
 # Setup
 
-## IntelliJ's Gradle UI
-- Open the project in IntelliJ as a Gradle project
-- Run the Gradle task `setupDecompWorkspace`
-- Run the Gradle task `genIntellijRuns`
-- Refresh the Gradle project (or just restart IntelliJ)
-- Select the "Minecraft Client" launch config and run
-
 ## Command Line
 On Mac OSX and Linux, use `./gradlew` instead of `gradlew`.
 
 Running Baritone:
 
 ```
-$ gradlew run
+$ gradlew runClient
 ```
 
-Setting up for IntelliJ:
+Building Baritone:
 ```
-$ gradlew setupDecompWorkspace
-$ gradlew --refresh-dependencies
-$ gradlew genIntellijRuns
+$ gradlew build
 ```
 
+For example, to replace out Impact 4.4's Baritone build with a customized one, switch to the `impact4.4-compat` branch, build Baritone as above then copy `dist/baritone-api-$VERSION$.jar` into `minecraft/libraries/cabaletta/baritone-api/1.0.0/baritone-api-1.0.0.jar`, replacing the jar that was previously there. You also need to edit `minecraft/versions/1.12.2-Impact_4.4/1.12.2-Impact_4.4.json`, find the line `"name": "cabaletta:baritone-api:1.0.0"`, remove the comma from the end, and entirely remove the line that's immediately after (starts with `"url"`). 
+
+## IntelliJ's Gradle UI
+- Open the project in IntelliJ as a Gradle project
+- Run the Gradle tasks `setupDecompWorkspace` then `genIntellijRuns`
+- Refresh the Gradle project (or, to be safe, just restart IntelliJ)
+- Select the "Minecraft Client" launch config
+- In `Edit Configurations...` you may need to select `baritone_launch` for `Use classpath of module:`.
+
 # Chat control
 [Defined Here](src/main/java/baritone/utils/ExampleBaritoneControl.java)
 
@@ -52,13 +58,12 @@ Quick start example: `thisway 1000` or `goal 70` to set the goal, `path` to actu
 BaritoneAPI.getSettings().allowSprint.value = true;
 BaritoneAPI.getSettings().pathTimeoutMS.value = 2000L;
 
-BaritoneAPI.getPathingBehavior().setGoal(new GoalXZ(10000, 20000));
-BaritoneAPI.getPathingBehavior().path();
+BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAndPath(new GoalXZ(10000, 20000));
 ```
 
 # FAQ
 
-## Can I use Baritone as a library in my hacked client?
+## Can I use Baritone as a library in my custom utility client?
 
 Sure! (As long as usage is in compliance with the LGPL 3 License)
 

build.gradle

@@ -1,7 +1,3 @@
-import java.util.jar.JarEntry
-import java.util.jar.JarFile
-import java.util.jar.JarOutputStream
-
 /*
  * This file is part of Baritone.
  *
@@ -20,7 +16,7 @@ import java.util.jar.JarOutputStream
  */
 
 group 'baritone'
-version '0.0.8'
+version '1.0.0-hotfix-2'
 
 buildscript {
     repositories {
@@ -41,6 +37,10 @@ buildscript {
     }
 }
 
+
+import baritone.gradle.task.CreateDistTask
+import baritone.gradle.task.ProguardTask
+
 apply plugin: 'java'
 apply plugin: 'net.minecraftforge.gradle.tweaker-client'
 apply plugin: 'org.spongepowered.mixin'
@@ -51,14 +51,24 @@ compileJava {
 }
 
 sourceSets {
+    comms {}
+    main {
+        compileClasspath += comms.compileClasspath + comms.output
+    }
     launch {
         compileClasspath += main.compileClasspath + main.runtimeClasspath + main.output
     }
+    tenor {
+        compileClasspath += comms.compileClasspath + comms.output
+    }
+    main {
+        compileClasspath += tenor.compileClasspath + tenor.output
+    }
 }
 
 minecraft {
     version = '1.12.2'
-    mappings = 'snapshot_20180731'
+    mappings = 'stable_39'
     tweakClass = 'baritone.launch.BaritoneTweaker'
     runDir = 'run'
 
@@ -73,9 +83,15 @@ repositories {
         name = 'spongepowered-repo'
         url = 'http://repo.spongepowered.org/maven/'
     }
+
+    maven {
+        name = 'impactdevelopment-repo'
+        url = 'https://impactdevelopment.github.io/maven/'
+    }
 }
 
 dependencies {
+    runtime launchCompile('com.github.ImpactDevelopment:SimpleTweaker:1.2')
     runtime launchCompile('org.spongepowered:mixin:0.7.11-SNAPSHOT') {
         // Mixin includes a lot of dependencies that are too up-to-date
         exclude module: 'launchwrapper'
@@ -93,37 +109,17 @@ mixin {
 }
 
 jar {
-    from sourceSets.launch.output, sourceSets.api.output
+    from sourceSets.comms.output, sourceSets.launch.output, sourceSets.api.output
     preserveFileTimestamps = false
     reproducibleFileOrder = true
 }
 
-build {
-    // while "jar" supports preserveFileTimestamps false
-    // reobfJar doesn't, it just sets all the last modified times to that instant where it runs the reobfuscator
-    // so we have to set all those last modified times back to zero
-    doLast {
-        File jarFile = new File("build/libs/baritone-" + version + ".jar")
-        JarFile jf = new JarFile(jarFile)
-        JarOutputStream jos = new JarOutputStream(new FileOutputStream(new File("temp.jar")))
-        jf.entries().unique { it.name }.sort { it.name }.each {
-            if (it.name != "META-INF/fml_cache_annotation.json" && it.name != "META-INF/fml_cache_class_versions.json") {
-                JarEntry clone = new JarEntry(it)
-                clone.time = 0
-                jos.putNextEntry(clone)
-                copy(jf.getInputStream(it), jos)
-            }
-        }
-        jos.finish()
-        jf.close()
-        file("temp.jar").renameTo(jarFile)
-    }
+task proguard(type: ProguardTask) {
+    url 'https://downloads.sourceforge.net/project/proguard/proguard/6.0/proguard6.0.3.zip'
+    extract 'proguard6.0.3/lib/proguard.jar'
+    versionManifest 'https://launchermeta.mojang.com/mc/game/version_manifest.json'
 }
 
-void copy(InputStream is, OutputStream os) {
-    byte[] buffer = new byte[1024]
-    int len = 0
-    while ((len = is.read(buffer)) != -1) {
-        os.write(buffer, 0, len)
-    }
-}
+task createDist(type: CreateDistTask, dependsOn: proguard)
+
+build.finalizedBy(createDist)

buildSrc/.gitignore

@@ -0,0 +1,3 @@
+build/
+.gradle/
+out/

buildSrc/build.gradle

@@ -0,0 +1,25 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile group: 'com.google.code.gson', name: 'gson', version: '2.8.5'
+    compile group: 'commons-io', name: 'commons-io', version: '2.6'
+}

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

@@ -0,0 +1,102 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.gradle.task;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+import org.gradle.api.DefaultTask;
+
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+/**
+ * @author Brady
+ * @since 10/12/2018
+ */
+class BaritoneGradleTask extends DefaultTask {
+
+    protected static final JsonParser PARSER = new JsonParser();
+
+    protected static final String
+            PROGUARD_ZIP                    = "proguard.zip",
+            PROGUARD_JAR                    = "proguard.jar",
+            PROGUARD_CONFIG_TEMPLATE        = "scripts/proguard.pro",
+            PROGUARD_CONFIG_DEST            = "template.pro",
+            PROGUARD_API_CONFIG             = "api.pro",
+            PROGUARD_STANDALONE_CONFIG      = "standalone.pro",
+            PROGUARD_EXPORT_PATH            = "proguard_out.jar",
+
+            VERSION_MANIFEST = "version_manifest.json",
+
+            TEMP_LIBRARY_DIR = "tempLibraries/",
+
+            ARTIFACT_STANDARD    = "%s-%s.jar",
+            ARTIFACT_UNOPTIMIZED = "%s-unoptimized-%s.jar",
+            ARTIFACT_API         = "%s-api-%s.jar",
+            ARTIFACT_STANDALONE  = "%s-standalone-%s.jar";
+
+    protected String artifactName, artifactVersion;
+    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, proguardOut;
+
+    protected void verifyArtifacts() throws IllegalStateException {
+        this.artifactName = getProject().getName();
+        this.artifactVersion = getProject().getVersion().toString();
+
+        this.artifactPath            = this.getBuildFile(formatVersion(ARTIFACT_STANDARD));
+        this.artifactUnoptimizedPath = this.getBuildFile(formatVersion(ARTIFACT_UNOPTIMIZED));
+        this.artifactApiPath         = this.getBuildFile(formatVersion(ARTIFACT_API));
+        this.artifactStandalonePath  = this.getBuildFile(formatVersion(ARTIFACT_STANDALONE));
+
+        this.proguardOut = this.getTemporaryFile(PROGUARD_EXPORT_PATH);
+
+        if (!Files.exists(this.artifactPath)) {
+            throw new IllegalStateException("Artifact not found! Run build first!");
+        }
+    }
+
+    protected void write(InputStream stream, Path file) throws Exception {
+        if (Files.exists(file)) {
+            Files.delete(file);
+        }
+        Files.copy(stream, file);
+    }
+
+    protected String formatVersion(String string) {
+        return String.format(string, this.artifactName, this.artifactVersion);
+    }
+
+    protected Path getRelativeFile(String file) {
+        return Paths.get(new File(file).getAbsolutePath());
+    }
+
+    protected Path getTemporaryFile(String file) {
+        return Paths.get(new File(getTemporaryDir(), file).getAbsolutePath());
+    }
+
+    protected Path getBuildFile(String file) {
+        return getRelativeFile("build/libs/" + file);
+    }
+
+    protected JsonElement readJson(List<String> lines) {
+        return PARSER.parse(String.join("\n", lines));
+    }
+}

buildSrc/src/main/java/baritone/gradle/task/CreateDistTask.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.gradle.task;
+
+import org.gradle.api.tasks.TaskAction;
+
+import javax.xml.bind.DatatypeConverter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+
+/**
+ * @author Brady
+ * @since 10/12/2018
+ */
+public class CreateDistTask extends BaritoneGradleTask {
+
+    private static MessageDigest SHA1_DIGEST;
+
+    @TaskAction
+    protected void exec() throws Exception {
+        super.verifyArtifacts();
+
+        // Define the distribution file paths
+        Path api         = getRelativeFile("dist/" + formatVersion(ARTIFACT_API));
+        Path standalone  = getRelativeFile("dist/" + formatVersion(ARTIFACT_STANDALONE));
+        Path unoptimized = getRelativeFile("dist/" + formatVersion(ARTIFACT_UNOPTIMIZED));
+
+        // NIO will not automatically create directories
+        Path dir = getRelativeFile("dist/");
+        if (!Files.exists(dir)) {
+            Files.createDirectory(dir);
+        }
+
+        // Copy build jars to dist/
+        Files.copy(this.artifactApiPath,         api,         REPLACE_EXISTING);
+        Files.copy(this.artifactStandalonePath,  standalone,  REPLACE_EXISTING);
+        Files.copy(this.artifactUnoptimizedPath, unoptimized, REPLACE_EXISTING);
+
+        // Calculate all checksums and format them like "shasum"
+        List<String> shasum = Stream.of(api, standalone, unoptimized)
+                .map(path -> sha1(path) + "  " + path.getFileName().toString())
+                .collect(Collectors.toList());
+
+        shasum.forEach(System.out::println);
+
+        // Write the checksums to a file
+        Files.write(getRelativeFile("dist/checksums.txt"), shasum);
+    }
+
+    private static synchronized String sha1(Path path) {
+        try {
+            if (SHA1_DIGEST == null) {
+                SHA1_DIGEST = MessageDigest.getInstance("SHA-1");
+            }
+            return DatatypeConverter.printHexBinary(SHA1_DIGEST.digest(Files.readAllBytes(path))).toLowerCase();
+        } catch (Exception e) {
+            // haha no thanks
+            throw new IllegalStateException(e);
+        }
+    }
+}

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

@@ -0,0 +1,260 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.gradle.task;
+
+import baritone.gradle.util.Determinizer;
+import com.google.gson.*;
+import org.apache.commons.io.IOUtils;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.internal.Pair;
+
+import java.io.*;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+
+/**
+ * @author Brady
+ * @since 10/11/2018
+ */
+public class ProguardTask extends BaritoneGradleTask {
+
+    private static final Pattern TEMP_LIBRARY_PATTERN = Pattern.compile("-libraryjars 'tempLibraries\\/([a-zA-Z0-9/_\\-\\.]+)\\.jar'");
+
+    @Input
+    private String url;
+
+    @Input
+    private String extract;
+
+    @Input
+    private String versionManifest;
+
+    private Map<String, String> versionDownloadMap;
+    private List<String> requiredLibraries;
+
+    @TaskAction
+    protected void exec() throws Exception {
+        super.verifyArtifacts();
+
+        // "Haha brady why don't you make separate tasks"
+        processArtifact();
+        downloadProguard();
+        extractProguard();
+        generateConfigs();
+        downloadVersionManifest();
+        acquireDependencies();
+        proguardApi();
+        proguardStandalone();
+        cleanup();
+    }
+
+    private void processArtifact() throws Exception {
+        if (Files.exists(this.artifactUnoptimizedPath)) {
+            Files.delete(this.artifactUnoptimizedPath);
+        }
+
+        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString());
+    }
+
+    private void downloadProguard() throws Exception {
+        Path proguardZip = getTemporaryFile(PROGUARD_ZIP);
+        if (!Files.exists(proguardZip)) {
+            write(new URL(this.url).openStream(), proguardZip);
+        }
+    }
+
+    private void extractProguard() throws Exception {
+        Path proguardJar = getTemporaryFile(PROGUARD_JAR);
+        if (!Files.exists(proguardJar)) {
+            ZipFile zipFile = new ZipFile(getTemporaryFile(PROGUARD_ZIP).toFile());
+            ZipEntry zipJarEntry = zipFile.getEntry(this.extract);
+            write(zipFile.getInputStream(zipJarEntry), proguardJar);
+            zipFile.close();
+        }
+    }
+
+    private void generateConfigs() throws Exception {
+        Files.copy(getRelativeFile(PROGUARD_CONFIG_TEMPLATE), getTemporaryFile(PROGUARD_CONFIG_DEST), REPLACE_EXISTING);
+
+        // Setup the template that will be used to derive the API and Standalone configs
+        List<String> template = Files.readAllLines(getTemporaryFile(PROGUARD_CONFIG_DEST));
+        template.add(0, "-injars " + this.artifactPath.toString());
+        template.add(1, "-outjars " + this.getTemporaryFile(PROGUARD_EXPORT_PATH));
+
+        // Acquire the RT jar using "java -verbose". This doesn't work on Java 9+
+        Process p = new ProcessBuilder("java", "-verbose").start();
+        String out = IOUtils.toString(p.getInputStream(), "UTF-8").split("\n")[0].split("Opened ")[1].replace("]", "");
+        template.add(2, "-libraryjars '" + out + "'");
+
+        // API config doesn't require any changes from the changes that we made to the template
+        Files.write(getTemporaryFile(PROGUARD_API_CONFIG), template);
+
+        // For the Standalone config, don't keep the API package
+        List<String> standalone = new ArrayList<>(template);
+        standalone.removeIf(s -> s.contains("# this is the keep api"));
+        Files.write(getTemporaryFile(PROGUARD_STANDALONE_CONFIG), standalone);
+
+        // Discover all of the libraries that we will need to acquire from gradle
+        this.requiredLibraries = new ArrayList<>();
+        template.forEach(line -> {
+            if (!line.startsWith("#")) {
+                Matcher m = TEMP_LIBRARY_PATTERN.matcher(line);
+                if (m.find()) {
+                    this.requiredLibraries.add(m.group(1));
+                }
+            }
+        });
+    }
+
+    private void downloadVersionManifest() throws Exception {
+        Path manifestJson = getTemporaryFile(VERSION_MANIFEST);
+        write(new URL(this.versionManifest).openStream(), manifestJson);
+
+        // Place all the versions in the map with their download URL
+        this.versionDownloadMap = new HashMap<>();
+        JsonObject json = readJson(Files.readAllLines(manifestJson)).getAsJsonObject();
+        JsonArray versions = json.getAsJsonArray("versions");
+        versions.forEach(element -> {
+            JsonObject object = element.getAsJsonObject();
+            this.versionDownloadMap.put(object.get("id").getAsString(), object.get("url").getAsString());
+        });
+    }
+
+    private void acquireDependencies() throws Exception {
+
+        // Create a map of all of the dependencies that we are able to access in this project
+        // Likely a better way to do this, I just pair the dependency with the first valid configuration
+        Map<String, Pair<Configuration, Dependency>> dependencyLookupMap = new HashMap<>();
+        getProject().getConfigurations().stream().filter(Configuration::isCanBeResolved).forEach(config ->
+                config.getAllDependencies().forEach(dependency ->
+                        dependencyLookupMap.putIfAbsent(dependency.getName() + "-" + dependency.getVersion(), Pair.of(config, dependency))));
+
+        // Create the directory if it doesn't already exist
+        Path tempLibraries = getTemporaryFile(TEMP_LIBRARY_DIR);
+        if (!Files.exists(tempLibraries)) {
+            Files.createDirectory(tempLibraries);
+        }
+
+        // Iterate the required libraries to copy them to tempLibraries
+        for (String lib : this.requiredLibraries) {
+            // Download the version jar from the URL acquired from the version manifest
+            if (lib.startsWith("minecraft")) {
+                String version = lib.split("-")[1];
+                Path versionJar = getTemporaryFile("tempLibraries/" + lib + ".jar");
+                if (!Files.exists(versionJar)) {
+                    JsonObject versionJson = PARSER.parse(new InputStreamReader(new URL(this.versionDownloadMap.get(version)).openStream())).getAsJsonObject();
+                    String url = versionJson.getAsJsonObject("downloads").getAsJsonObject("client").getAsJsonPrimitive("url").getAsString();
+                    write(new URL(url).openStream(), versionJar);
+                }
+                continue;
+            }
+
+            // Find a configuration/dependency pair that matches the desired library
+            Pair<Configuration, Dependency> pair = null;
+            for (Map.Entry<String, Pair<Configuration, Dependency>> entry : dependencyLookupMap.entrySet()) {
+                if (entry.getKey().startsWith(lib)) {
+                    pair = entry.getValue();
+                }
+            }
+
+            // The pair must be non-null
+            Objects.requireNonNull(pair);
+
+            // Find the library jar file, and copy it to tempLibraries
+            for (File file : pair.getLeft().files(pair.getRight())) {
+                if (file.getName().startsWith(lib)) {
+                    Files.copy(file.toPath(), getTemporaryFile("tempLibraries/" + lib + ".jar"), REPLACE_EXISTING);
+                }
+            }
+        }
+    }
+
+    private void proguardApi() throws Exception {
+        runProguard(getTemporaryFile(PROGUARD_API_CONFIG));
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString());
+    }
+
+    private void proguardStandalone() throws Exception {
+        runProguard(getTemporaryFile(PROGUARD_STANDALONE_CONFIG));
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString());
+    }
+
+    private void cleanup() {
+        try {
+            Files.delete(this.proguardOut);
+        } catch (IOException ignored) {}
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public void setExtract(String extract) {
+        this.extract = extract;
+    }
+
+    public void setVersionManifest(String versionManifest) {
+        this.versionManifest = versionManifest;
+    }
+
+    private void runProguard(Path config) throws Exception {
+        // Delete the existing proguard output file. Proguard probably handles this already, but why not do it ourselves
+        if (Files.exists(this.proguardOut)) {
+            Files.delete(this.proguardOut);
+        }
+
+        Path proguardJar = getTemporaryFile(PROGUARD_JAR);
+        Process p = new ProcessBuilder("java", "-jar", proguardJar.toString(), "@" + config.toString())
+                .directory(getTemporaryFile("").toFile()) // Set the working directory to the temporary folder]
+                .start();
+
+        // We can't do output inherit process I/O with gradle for some reason and have it work, so we have to do this
+        this.printOutputLog(p.getInputStream());
+        this.printOutputLog(p.getErrorStream());
+
+        // Halt the current thread until the process is complete, if the exit code isn't 0, throw an exception
+        int exitCode = p.waitFor();
+        if (exitCode != 0) {
+            throw new IllegalStateException("Proguard exited with code " + exitCode);
+        }
+    }
+
+    private void printOutputLog(InputStream stream) {
+        new Thread(() -> {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    System.out.println(line);
+                }
+            } catch (final Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+}

buildSrc/src/main/java/baritone/gradle/util/Determinizer.java

@@ -0,0 +1,143 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.gradle.util;
+
+import com.google.gson.*;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.stream.Collectors;
+
+/**
+ * Make a .jar file deterministic by sorting all entries by name, and setting all the last modified times to 42069.
+ * This makes the build 100% reproducible since the timestamp when you built it no longer affects the final file.
+ *
+ * @author leijurv
+ */
+public class Determinizer {
+
+    public static void determinize(String inputPath, String outputPath) throws IOException {
+        System.out.println("Running Determinizer");
+        System.out.println(" Input path: " + inputPath);
+        System.out.println(" Output path: " + outputPath);
+
+        try (
+                JarFile jarFile = new JarFile(new File(inputPath));
+                JarOutputStream jos = new JarOutputStream(new FileOutputStream(new File(outputPath)))
+        ) {
+
+            List<JarEntry> entries = jarFile.stream()
+                    .sorted(Comparator.comparing(JarEntry::getName))
+                    .collect(Collectors.toList());
+
+            for (JarEntry entry : entries) {
+                if (entry.getName().equals("META-INF/fml_cache_annotation.json")) {
+                    continue;
+                }
+                if (entry.getName().equals("META-INF/fml_cache_class_versions.json")) {
+                    continue;
+                }
+                JarEntry clone = new JarEntry(entry.getName());
+                clone.setTime(42069);
+                jos.putNextEntry(clone);
+                if (entry.getName().endsWith(".refmap.json")) {
+                    JsonObject object = new JsonParser().parse(new InputStreamReader(jarFile.getInputStream(entry))).getAsJsonObject();
+                    jos.write(writeSorted(object).getBytes());
+                } else {
+                    copy(jarFile.getInputStream(entry), jos);
+                }
+            }
+            jos.finish();
+        }
+    }
+
+    private static void copy(InputStream is, OutputStream os) throws IOException {
+        byte[] buffer = new byte[1024];
+        int len;
+        while ((len = is.read(buffer)) != -1) {
+            os.write(buffer, 0, len);
+        }
+    }
+
+    private static String writeSorted(JsonObject in) throws IOException {
+        StringWriter writer = new StringWriter();
+        JsonWriter jw = new JsonWriter(writer);
+        ORDERED_JSON_WRITER.write(jw, in);
+        return writer.toString() + "\n";
+    }
+
+    /**
+     * All credits go to GSON and its contributors. GSON is licensed under the Apache 2.0 License.
+     * This implementation has been modified to write {@link JsonObject} keys in order.
+     *
+     * @see <a href="https://github.com/google/gson/blob/master/LICENSE">GSON License</a>
+     * @see <a href="https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java#L698">Original Source</a>
+     */
+    private static final TypeAdapter<JsonElement> ORDERED_JSON_WRITER = new TypeAdapter<JsonElement>() {
+
+        @Override
+        public JsonElement read(JsonReader in) {
+            return null;
+        }
+
+        @Override
+        public void write(JsonWriter out, JsonElement value) throws IOException {
+            if (value == null || value.isJsonNull()) {
+                out.nullValue();
+            } else if (value.isJsonPrimitive()) {
+                JsonPrimitive primitive = value.getAsJsonPrimitive();
+                if (primitive.isNumber()) {
+                    out.value(primitive.getAsNumber());
+                } else if (primitive.isBoolean()) {
+                    out.value(primitive.getAsBoolean());
+                } else {
+                    out.value(primitive.getAsString());
+                }
+
+            } else if (value.isJsonArray()) {
+                out.beginArray();
+                for (JsonElement e : value.getAsJsonArray()) {
+                    write(out, e);
+                }
+                out.endArray();
+
+            } else if (value.isJsonObject()) {
+                out.beginObject();
+
+                List<Map.Entry<String, JsonElement>> entries = new ArrayList<>(value.getAsJsonObject().entrySet());
+                entries.sort(Comparator.comparing(Map.Entry::getKey));
+                for (Map.Entry<String, JsonElement> e : entries) {
+                    out.name(e.getKey());
+                    write(out, e.getValue());
+                }
+                out.endObject();
+
+            } else {
+                throw new IllegalArgumentException("Couldn't write " + value.getClass());
+            }
+        }
+    };
+}

scripts/build.sh

@@ -1,27 +0,0 @@
-#!/bin/sh
-set -e # this makes the whole script fail immediately if any one of these commands fails
-./gradlew build
-export VERSION=$(cat build.gradle | grep "version '" | cut -d "'" -f 2-2)
-
-wget -nv https://downloads.sourceforge.net/project/proguard/proguard/6.0/proguard6.0.3.zip
-unzip proguard6.0.3.zip 2>&1 > /dev/null
-cd build/libs
-echo "-injars 'baritone-$VERSION.jar'" >> api.pro # insert current version
-cat ../../scripts/proguard.pro | grep -v "this is the rt jar" | grep -v "\-injars" >> api.pro # remove default rt jar and injar lines
-echo "-libraryjars '$(java -verbose 2>/dev/null | sed -ne '1 s/\[Opened \(.*\)\]/\1/p')'" >> api.pro # insert correct rt.jar location
-tail api.pro # debug, print out what the previous two commands generated
-cat api.pro | grep -v "this is the keep api" > standalone.pro # standalone doesn't keep baritone api
-
-#instead of downloading these jars from my dropbox in a zip, just assume gradle's already got them for us
-mkdir -p tempLibraries
-cat ../../scripts/proguard.pro | grep tempLibraries | grep .jar | cut -d "/" -f 2- | cut -d "'" -f -1 | xargs -n1 -I{} bash -c "find ~/.gradle -name {}" | tee /dev/stderr | xargs -n1 -I{} cp {} tempLibraries
-
-mkdir ../../dist
-java -jar ../../proguard6.0.3/lib/proguard.jar @api.pro
-mv Obfuscated/baritone-$VERSION.jar ../../dist/baritone-api-$VERSION.jar
-java -jar ../../proguard6.0.3/lib/proguard.jar @standalone.pro
-mv Obfuscated/baritone-$VERSION.jar ../../dist/baritone-standalone-$VERSION.jar
-mv baritone-$VERSION.jar ../../dist/baritone-unoptimized-$VERSION.jar
-cd ../../dist
-shasum * | tee checksums.txt
-cd ..

scripts/proguard.pro

@@ -1,7 +1,3 @@
--injars baritone-0.0.8.jar
--outjars Obfuscated
-
-
 -keepattributes Signature
 -keepattributes *Annotation*
 
@@ -17,9 +13,14 @@
 -repackageclasses 'baritone'
 
 -keep class baritone.api.** { *; } # this is the keep api
+
+# service provider needs these class names
 -keep class baritone.BaritoneProvider
 -keep class baritone.api.IBaritoneProvider
 
+# hack
+-keep class baritone.utils.ExampleBaritoneControl { *; } # have to include this string to remove this keep in the standalone build: # this is the keep api
+
 # setting names are reflected from field names, so keep field names
 -keepclassmembers class baritone.api.Settings {
     public <fields>;    
@@ -29,10 +30,11 @@
 -keep class baritone.launch.** { *; }
 
 # copy all necessary libraries into tempLibraries to build
--libraryjars '/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/rt.jar' # this is the rt jar
 
 -libraryjars 'tempLibraries/minecraft-1.12.2.jar'
 
+-libraryjars 'tempLibraries/SimpleTweaker-1.2.jar'
+
 -libraryjars 'tempLibraries/authlib-1.5.25.jar'
 -libraryjars 'tempLibraries/codecjorbis-20101023.jar'
 -libraryjars 'tempLibraries/codecwav-20101023.jar'
@@ -47,7 +49,6 @@
 -libraryjars 'tempLibraries/httpclient-4.3.3.jar'
 -libraryjars 'tempLibraries/httpcore-4.3.2.jar'
 -libraryjars 'tempLibraries/icu4j-core-mojang-51.2.jar'
--libraryjars 'tempLibraries/java-objc-bridge-1.0.0.jar'
 -libraryjars 'tempLibraries/jinput-2.0.5.jar'
 -libraryjars 'tempLibraries/jna-4.4.0.jar'
 -libraryjars 'tempLibraries/jopt-simple-5.0.3.jar'
@@ -58,13 +59,10 @@
 -libraryjars 'tempLibraries/log4j-api-2.8.1.jar'
 -libraryjars 'tempLibraries/log4j-core-2.8.1.jar'
 
-# linux / travis
--libraryjars 'tempLibraries/lwjgl-2.9.4-nightly-20150209.jar'
--libraryjars 'tempLibraries/lwjgl_util-2.9.4-nightly-20150209.jar'
-
-# mac
-#-libraryjars 'tempLibraries/lwjgl_util-2.9.2-nightly-20140822.jar'
-#-libraryjars 'tempLibraries/lwjgl-2.9.2-nightly-20140822.jar'
+# startsWith is used to check the library, and mac/linux differ in which version they use
+# this is FINE
+-libraryjars 'tempLibraries/lwjgl-.jar'
+-libraryjars 'tempLibraries/lwjgl_util-.jar'
 
 -libraryjars 'tempLibraries/netty-all-4.1.9.Final.jar'
 -libraryjars 'tempLibraries/oshi-core-1.1.jar'

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

@@ -17,10 +17,6 @@
 
 package baritone.api;
 
-import baritone.api.behavior.*;
-import baritone.api.cache.IWorldProvider;
-import baritone.api.cache.IWorldScanner;
-import baritone.api.event.listener.IGameEventListener;
 import baritone.api.utils.SettingsUtil;
 
 import java.util.Iterator;
@@ -36,51 +32,23 @@ import java.util.ServiceLoader;
  */
 public final class BaritoneAPI {
 
-    private final static IBaritoneProvider baritone;
-    private final static Settings settings;
+    private static final IBaritoneProvider provider;
+    private static final Settings settings;
 
     static {
         ServiceLoader<IBaritoneProvider> baritoneLoader = ServiceLoader.load(IBaritoneProvider.class);
         Iterator<IBaritoneProvider> instances = baritoneLoader.iterator();
-        baritone = instances.next();
+        provider = instances.next();
 
         settings = new Settings();
         SettingsUtil.readAndApply(settings);
     }
 
-    public static IFollowBehavior getFollowBehavior() {
-        return baritone.getFollowBehavior();
-    }
-
-    public static ILookBehavior getLookBehavior() {
-        return baritone.getLookBehavior();
-    }
-
-    public static IMemoryBehavior getMemoryBehavior() {
-        return baritone.getMemoryBehavior();
-    }
-
-    public static IMineBehavior getMineBehavior() {
-        return baritone.getMineBehavior();
-    }
-
-    public static IPathingBehavior getPathingBehavior() {
-        return baritone.getPathingBehavior();
+    public static IBaritoneProvider getProvider() {
+        return BaritoneAPI.provider;
     }
 
     public static Settings getSettings() {
-        return settings;
-    }
-
-    public static IWorldProvider getWorldProvider() {
-        return baritone.getWorldProvider();
-    }
-
-    public static IWorldScanner getWorldScanner() {
-        return baritone.getWorldScanner();
-    }
-
-    public static void registerEventListener(IGameEventListener listener) {
-        baritone.registerEventListener(listener);
+        return BaritoneAPI.settings;
     }
 }

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

@@ -0,0 +1,86 @@
+/*
+ * 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;
+
+import baritone.api.behavior.ILookBehavior;
+import baritone.api.behavior.IMemoryBehavior;
+import baritone.api.behavior.IPathingBehavior;
+import baritone.api.cache.IWorldProvider;
+import baritone.api.event.listener.IEventBus;
+import baritone.api.pathing.calc.IPathingControlManager;
+import baritone.api.process.ICustomGoalProcess;
+import baritone.api.process.IFollowProcess;
+import baritone.api.process.IGetToBlockProcess;
+import baritone.api.process.IMineProcess;
+import baritone.api.utils.IInputOverrideHandler;
+import baritone.api.utils.IPlayerContext;
+
+/**
+ * @author Brady
+ * @since 9/29/2018
+ */
+public interface IBaritone {
+
+    /**
+     * @return The {@link IFollowProcess} instance
+     * @see IFollowProcess
+     */
+    IFollowProcess getFollowProcess();
+
+    /**
+     * @return The {@link ILookBehavior} instance
+     * @see ILookBehavior
+     */
+    ILookBehavior getLookBehavior();
+
+    /**
+     * @return The {@link IMemoryBehavior} instance
+     * @see IMemoryBehavior
+     */
+    IMemoryBehavior getMemoryBehavior();
+
+    /**
+     * @return The {@link IMineProcess} instance
+     * @see IMineProcess
+     */
+    IMineProcess getMineProcess();
+
+    IPathingControlManager getPathingControlManager();
+
+    /**
+     * @return The {@link IPathingBehavior} instance
+     * @see IPathingBehavior
+     */
+    IPathingBehavior getPathingBehavior();
+
+    /**
+     * @return The {@link IWorldProvider} instance
+     * @see IWorldProvider
+     */
+    IWorldProvider getWorldProvider();
+
+    IInputOverrideHandler getInputOverrideHandler();
+
+    ICustomGoalProcess getCustomGoalProcess();
+
+    IGetToBlockProcess getGetToBlockProcess();
+
+    IPlayerContext getPlayerContext();
+
+    IEventBus getGameEventHandler();
+}

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

@@ -17,70 +17,55 @@
 
 package baritone.api;
 
-import baritone.api.behavior.*;
-import baritone.api.cache.IWorldProvider;
 import baritone.api.cache.IWorldScanner;
-import baritone.api.event.listener.IGameEventListener;
+import net.minecraft.client.entity.EntityPlayerSP;
+
+import java.util.List;
 
 /**
- * @author Brady
- * @since 9/29/2018
+ * @author Leijurv
  */
 public interface IBaritoneProvider {
 
     /**
-     * @see IFollowBehavior
+     * Returns the primary {@link IBaritone} instance. This instance is persistent, and
+     * is represented by the local player that is created by the game itself, not a "bot"
+     * player through Baritone.
      *
-     * @return The {@link IFollowBehavior} instance
+     * @return The primary {@link IBaritone} instance.
      */
-    IFollowBehavior getFollowBehavior();
+    IBaritone getPrimaryBaritone();
 
     /**
-     * @see ILookBehavior
+     * Returns all of the active {@link IBaritone} instances. This includes the local one
+     * returned by {@link #getPrimaryBaritone()}.
      *
-     * @return The {@link ILookBehavior} instance
+     * @return All active {@link IBaritone} instances.
+     * @see #getBaritoneForPlayer(EntityPlayerSP)
      */
-    ILookBehavior getLookBehavior();
+    List<IBaritone> getAllBaritones();
 
     /**
-     * @see IMemoryBehavior
+     * Provides the {@link IBaritone} instance for a given {@link EntityPlayerSP}. This will likely be
+     * replaced with {@code #getBaritoneForUser(IBaritoneUser)} when {@code bot-system} is merged.
      *
-     * @return The {@link IMemoryBehavior} instance
+     * @param player The player
+     * @return The {@link IBaritone} instance.
      */
-    IMemoryBehavior getMemoryBehavior();
+    default IBaritone getBaritoneForPlayer(EntityPlayerSP player) {
+        for (IBaritone baritone : getAllBaritones()) {
+            if (player.equals(baritone.getPlayerContext().player())) {
+                return baritone;
+            }
+        }
+        throw new IllegalStateException("No baritone for player " + player);
+    }
 
     /**
-     * @see IMineBehavior
+     * Returns the {@link IWorldScanner} instance. This is not a type returned by
+     * {@link IBaritone} implementation, because it is not linked with {@link IBaritone}.
      *
-     * @return The {@link IMineBehavior} instance
-     */
-    IMineBehavior getMineBehavior();
-
-    /**
-     * @see IPathingBehavior
-     *
-     * @return The {@link IPathingBehavior} instance
-     */
-    IPathingBehavior getPathingBehavior();
-
-    /**
-     * @see IWorldProvider
-     *
-     * @return The {@link IWorldProvider} instance
-     */
-    IWorldProvider getWorldProvider();
-
-    /**
-     * @see IWorldScanner
-     *
-     * @return The {@link IWorldScanner} instance
+     * @return The {@link IWorldScanner} instance.
      */
     IWorldScanner getWorldScanner();
-
-    /**
-     * Registers a {@link IGameEventListener} with Baritone's "event bus".
-     *
-     * @param listener The listener
-     */
-    void registerEventListener(IGameEventListener listener);
 }

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

@@ -247,14 +247,28 @@ public class Settings {
     public Setting<Integer> movementTimeoutTicks = new Setting<>(100);
 
     /**
-     * Pathing can never take longer than this
+     * Pathing ends after this amount of time, but only if a path has been found
+     * <p>
+     * If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout
      */
-    public Setting<Long> pathTimeoutMS = new Setting<>(2000L);
+    public Setting<Long> primaryTimeoutMS = new Setting<>(500L);
 
     /**
-     * Planning ahead while executing a segment can never take longer than this
+     * Pathing can never take longer than this, even if that means failing to find any path at all
      */
-    public Setting<Long> planAheadTimeoutMS = new Setting<>(4000L);
+    public Setting<Long> failureTimeoutMS = new Setting<>(2000L);
+
+    /**
+     * Planning ahead while executing a segment ends after this amount of time, but only if a path has been found
+     * <p>
+     * If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout
+     */
+    public Setting<Long> planAheadPrimaryTimeoutMS = new Setting<>(4000L);
+
+    /**
+     * Planning ahead while executing a segment can never take longer than this, even if that means failing to find any path at all
+     */
+    public Setting<Long> planAheadFailureTimeoutMS = new Setting<>(5000L);
 
     /**
      * For debugging, consider nodes much much slower
@@ -276,6 +290,13 @@ public class Settings {
      */
     public Setting<Boolean> chunkCaching = new Setting<>(true);
 
+    /**
+     * On save, delete from RAM any cached regions that are more than 1024 blocks away from the player
+     * <p>
+     * Temporarily disabled, see issue #248
+     */
+    public Setting<Boolean> pruneRegionsFromRAM = new Setting<>(false);
+
     /**
      * Print all the debug messages to chat
      */
@@ -305,17 +326,17 @@ public class Settings {
     /**
      * Ignore depth when rendering the goal
      */
-    public Setting<Boolean> renderGoalIgnoreDepth = new Setting<>(false);
+    public Setting<Boolean> renderGoalIgnoreDepth = new Setting<>(true);
 
     /**
      * Ignore depth when rendering the selection boxes (to break, to place, to walk into)
      */
-    public Setting<Boolean> renderSelectionBoxesIgnoreDepth = new Setting<>(false);
+    public Setting<Boolean> renderSelectionBoxesIgnoreDepth = new Setting<>(true);
 
     /**
      * Ignore depth when rendering the path
      */
-    public Setting<Boolean> renderPathIgnoreDepth = new Setting<>(false);
+    public Setting<Boolean> renderPathIgnoreDepth = new Setting<>(true);
 
     /**
      * Line width of the path when rendered, in pixels
@@ -370,12 +391,27 @@ public class Settings {
      */
     public Setting<Boolean> walkWhileBreaking = new Setting<>(true);
 
+    /**
+     * If we are more than 500 movements into the current path, discard the oldest segments, as they are no longer useful
+     */
+    public Setting<Integer> maxPathHistoryLength = new Setting<>(300);
+
+    /**
+     * If the current path is too long, cut off this many movements from the beginning.
+     */
+    public Setting<Integer> pathHistoryCutoffAmount = new Setting<>(50);
+
     /**
      * Rescan for the goal once every 5 ticks.
      * Set to 0 to disable.
      */
     public Setting<Integer> mineGoalUpdateInterval = new Setting<>(5);
 
+    /**
+     * While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
+     */
+    public Setting<Boolean> mineScanDroppedItems = new Setting<>(true);
+
     /**
      * Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
      * <p>
@@ -389,13 +425,25 @@ public class Settings {
      * <p>
      * Also on cosmic prisons this should be set to true since you don't actually mine the ore it just gets replaced with stone.
      */
-    public Setting<Boolean> cancelOnGoalInvalidation = new Setting<>(false);
+    public Setting<Boolean> cancelOnGoalInvalidation = new Setting<>(true);
 
     /**
      * The "axis" command (aka GoalAxis) will go to a axis, or diagonal axis, at this Y level.
      */
     public Setting<Integer> axisHeight = new Setting<>(120);
 
+    /**
+     * Allow MineBehavior to use X-Ray to see where the ores are. Turn this option off to force it to mine "legit"
+     * where it will only mine an ore once it can actually see it, so it won't do or know anything that a normal player
+     * couldn't. If you don't want it to look like you're X-Raying, turn this off
+     */
+    public Setting<Boolean> legitMine = new Setting<>(false);
+
+    /**
+     * What Y level to go to for legit strip mining
+     */
+    public Setting<Integer> legitMineYLevel = new Setting<>(11);
+
     /**
      * When mining block of a certain type, try to mine two at once instead of one.
      * If the block above is also a goal block, set GoalBlock instead of GoalTwoBlocks

src/api/java/baritone/api/behavior/IBehavior.java

@@ -18,10 +18,9 @@
 package baritone.api.behavior;
 
 import baritone.api.event.listener.AbstractGameEventListener;
-import baritone.api.utils.interfaces.Toggleable;
 
 /**
  * @author Brady
  * @since 9/23/2018
  */
-public interface IBehavior extends AbstractGameEventListener, Toggleable {}
+public interface IBehavior extends AbstractGameEventListener {}

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

@@ -33,7 +33,7 @@ public interface ILookBehavior extends IBehavior {
      * otherwise, it should be {@code false};
      *
      * @param rotation The target rotations
-     * @param force Whether or not to "force" the rotations
+     * @param force    Whether or not to "force" the rotations
      */
     void updateTarget(Rotation rotation, boolean force);
 }

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

@@ -17,9 +17,9 @@
 
 package baritone.api.behavior;
 
+import baritone.api.pathing.calc.IPath;
 import baritone.api.pathing.calc.IPathFinder;
 import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.calc.IPath;
 import baritone.api.pathing.path.IPathExecutor;
 
 import java.util.Optional;
@@ -39,35 +39,25 @@ public interface IPathingBehavior extends IBehavior {
      */
     Optional<Double> ticksRemainingInSegment();
 
-    /**
-     * Sets the pathing goal.
-     *
-     * @param goal The pathing goal
-     */
-    void setGoal(Goal goal);
-
     /**
      * @return The current pathing goal
      */
     Goal getGoal();
 
-    /**
-     * Begins pathing. Calculation will start in a new thread, and once completed,
-     * movement will commence. Returns whether or not the operation was successful.
-     *
-     * @return Whether or not the operation was successful
-     */
-    boolean path();
-
     /**
      * @return Whether or not a path is currently being executed.
      */
     boolean isPathing();
 
     /**
-     * Cancels the pathing behavior or the current path calculation.
+     * Cancels the pathing behavior or the current path calculation, and all processes that could be controlling path.
+     * <p>
+     * Basically, "MAKE IT STOP".
+     *
+     * @return Whether or not the pathing behavior was canceled. All processes are guaranteed to be canceled, but the
+     * PathingBehavior might be in the middle of an uncancelable action like a parkour jump
      */
-    void cancel();
+    boolean cancelEverything();
 
     /**
      * Returns the current path, from the current path executor, if there is one.
@@ -81,7 +71,7 @@ public interface IPathingBehavior extends IBehavior {
     /**
      * @return The current path finder being executed
      */
-    Optional<IPathFinder> getPathFinder();
+    Optional<? extends IPathFinder> getInProgress();
 
     /**
      * @return The current path executor

src/api/java/baritone/api/cache/IBlockTypeAccess.java

@@ -22,7 +22,7 @@ import net.minecraft.util.math.BlockPos;
 
 /**
  * @author Brady
- * @since 8/4/2018 2:01 AM
+ * @since 8/4/2018
  */
 public interface IBlockTypeAccess {
 

src/api/java/baritone/api/cache/ICachedRegion.java

@@ -29,11 +29,10 @@ public interface ICachedRegion extends IBlockTypeAccess {
      * however, the block coordinates should in on a scale from 0 to 511 (inclusive)
      * because region sizes are 512x512 blocks.
      *
-     * @see ICachedWorld#isCached(int, int)
-     *
      * @param blockX The block X coordinate
      * @param blockZ The block Z coordinate
      * @return Whether or not the specified XZ location is cached
+     * @see ICachedWorld#isCached(int, int)
      */
     boolean isCached(int blockX, int blockZ);
 

src/api/java/baritone/api/cache/ICachedWorld.java

@@ -61,12 +61,14 @@ public interface ICachedWorld {
      * information that is returned by this method may not be up to date, because
      * older cached chunks can contain data that is much more likely to have changed.
      *
-     * @param block The special block to search for
-     * @param maximum The maximum number of position results to receive
+     * @param block               The special block to search for
+     * @param maximum             The maximum number of position results to receive
+     * @param centerX             The x block coordinate center of the search
+     * @param centerZ             The z block coordinate center of the search
      * @param maxRegionDistanceSq The maximum region distance, squared
      * @return The locations found that match the special block
      */
-    LinkedList<BlockPos> getLocationsOf(String block, int maximum, int maxRegionDistanceSq);
+    LinkedList<BlockPos> getLocationsOf(String block, int maximum, int centerX, int centerZ, int maxRegionDistanceSq);
 
     /**
      * Reloads all of the cached regions in this world from disk. Anything that is not saved

src/api/java/baritone/api/cache/IWaypointCollection.java

@@ -50,19 +50,17 @@ public interface IWaypointCollection {
     /**
      * Gets all of the waypoints that have the specified tag
      *
-     * @see IWaypointCollection#getAllWaypoints()
-     *
      * @param tag The tag
      * @return All of the waypoints with the specified tag
+     * @see IWaypointCollection#getAllWaypoints()
      */
     Set<IWaypoint> getByTag(IWaypoint.Tag tag);
 
     /**
      * Gets all of the waypoints in this collection, regardless of the tag.
      *
-     * @see IWaypointCollection#getByTag(IWaypoint.Tag)
-     *
      * @return All of the waypoints in this collection
+     * @see IWaypointCollection#getByTag(IWaypoint.Tag)
      */
     Set<IWaypoint> getAllWaypoints();
 }

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

@@ -17,6 +17,7 @@
 
 package baritone.api.cache;
 
+import baritone.api.utils.IPlayerContext;
 import net.minecraft.block.Block;
 import net.minecraft.util.math.BlockPos;
 
@@ -31,6 +32,8 @@ public interface IWorldScanner {
     /**
      * Scans the world, up to the specified max chunk radius, for the specified blocks.
      *
+     * @param ctx             The {@link IPlayerContext} containing player and world info that the
+     *                        scan is based upon
      * @param blocks          The blocks to scan for
      * @param max             The maximum number of blocks to scan before cutoff
      * @param yLevelThreshold If a block is found within this Y level, the current result will be
@@ -38,5 +41,5 @@ public interface IWorldScanner {
      * @param maxSearchRadius The maximum chunk search radius
      * @return The matching block positions
      */
-    List<BlockPos> scanLoadedChunks(List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius);
+    List<BlockPos> scanChunkRadius(IPlayerContext ctx, List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius);
 }

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

@@ -22,7 +22,7 @@ import net.minecraft.client.entity.EntityPlayerSP;
 
 /**
  * @author Brady
- * @since 8/1/2018 6:39 PM
+ * @since 8/1/2018
  */
 public final class ChatEvent extends ManagedPlayerEvent.Cancellable {
 

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

@@ -21,7 +21,7 @@ import baritone.api.event.events.type.EventState;
 
 /**
  * @author Brady
- * @since 8/2/2018 12:32 AM
+ * @since 8/2/2018
  */
 public final class ChunkEvent {
 
@@ -94,7 +94,16 @@ public final class ChunkEvent {
 
         /**
          * When the chunk is being populated with blocks, tile entities, etc.
+         * <p>
+         * And it's a full chunk
          */
-        POPULATE
+        POPULATE_FULL,
+
+        /**
+         * When the chunk is being populated with blocks, tile entities, etc.
+         * <p>
+         * And it's a partial chunk
+         */
+        POPULATE_PARTIAL
     }
 }

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

@@ -23,7 +23,7 @@ import net.minecraft.network.Packet;
 
 /**
  * @author Brady
- * @since 8/6/2018 9:31 PM
+ * @since 8/6/2018
  */
 public final class PacketEvent {
 

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

@@ -19,7 +19,7 @@ package baritone.api.event.events;
 
 /**
  * @author Brady
- * @since 8/5/2018 12:28 AM
+ * @since 8/5/2018
  */
 public final class RenderEvent {
 

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

@@ -17,7 +17,6 @@
 
 package baritone.api.event.events;
 
-import baritone.api.event.events.type.EventState;
 import baritone.api.event.events.type.ManagedPlayerEvent;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.entity.Entity;
@@ -35,21 +34,30 @@ public final class RotationMoveEvent extends ManagedPlayerEvent {
     private final Type type;
 
     /**
-     * The state of the event
+     * The yaw rotation
      */
-    private final EventState state;
+    private float yaw;
 
-    public RotationMoveEvent(EntityPlayerSP player, EventState state, Type type) {
+    public RotationMoveEvent(EntityPlayerSP player, Type type, float yaw) {
         super(player);
-        this.state = state;
         this.type = type;
+        this.yaw = yaw;
     }
 
     /**
-     * @return The state of the event
+     * Set the yaw movement rotation
+     *
+     * @param yaw Yaw rotation
      */
-    public final EventState getState() {
-        return this.state;
+    public final void setYaw(float yaw) {
+        this.yaw = yaw;
+    }
+
+    /**
+     * @return The yaw rotation
+     */
+    public final float getYaw() {
+        return this.yaw;
     }
 
     /**

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

@@ -22,7 +22,7 @@ import net.minecraft.client.multiplayer.WorldClient;
 
 /**
  * @author Brady
- * @since 8/4/2018 3:13 AM
+ * @since 8/4/2018
  */
 public final class WorldEvent {
 

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

@@ -19,7 +19,7 @@ package baritone.api.event.events.type;
 
 /**
  * @author Brady
- * @since 8/1/2018 6:41 PM
+ * @since 8/1/2018
  */
 public class Cancellable implements ICancellable {
 

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

@@ -19,19 +19,17 @@ package baritone.api.event.events.type;
 
 /**
  * @author Brady
- * @since 8/2/2018 12:34 AM
+ * @since 8/2/2018
  */
 public enum EventState {
 
     /**
-     * Indicates that whatever movement the event is being
-     * dispatched as a result of is about to occur.
+     * Before the dispatching of what the event is targetting
      */
     PRE,
 
     /**
-     * Indicates that whatever movement the event is being
-     * dispatched as a result of has already occurred.
+     * After the dispatching of what the event is targetting
      */
     POST
 }

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

@@ -26,7 +26,7 @@ import baritone.api.event.events.*;
  *
  * @author Brady
  * @see IGameEventListener
- * @since 8/1/2018 6:29 PM
+ * @since 8/1/2018
  */
 public interface AbstractGameEventListener extends IGameEventListener {
 

src/api/java/baritone/api/event/listener/IEventBus.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.api.event.listener;
+
+/**
+ * A type of {@link IGameEventListener} that can have additional listeners
+ * registered so that they receive the events that are dispatched to this
+ * listener.
+ *
+ * @author Brady
+ * @since 11/14/2018
+ */
+public interface IEventBus extends IGameEventListener {
+
+    /**
+     * Registers the specified {@link IGameEventListener} to this event bus
+     *
+     * @param listener The listener
+     */
+    void registerEventListener(IGameEventListener listener);
+}

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

@@ -33,7 +33,7 @@ import net.minecraft.util.text.ITextComponent;
 
 /**
  * @author Brady
- * @since 7/31/2018 11:05 PM
+ * @since 7/31/2018
  */
 public interface IGameEventListener {
 

src/api/java/baritone/api/pathing/calc/IPath.java

@@ -21,7 +21,9 @@ import baritone.api.Settings;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.movement.IMovement;
 import baritone.api.utils.BetterBlockPos;
+import net.minecraft.world.World;
 
+import java.util.HashSet;
 import java.util.List;
 
 /**
@@ -51,7 +53,9 @@ public interface IPath {
      * This path is actually going to be executed in the world. Do whatever additional processing is required.
      * (as opposed to Path objects that are just constructed every frame for rendering)
      */
-    default void postProcess() {}
+    default IPath postProcess() {
+        throw new UnsupportedOperationException();
+    }
 
     /**
      * Returns the number of positions in this path. Equivalent to {@code positions().size()}.
@@ -100,7 +104,7 @@ public interface IPath {
      * Returns the estimated number of ticks to complete the path from the given node index.
      *
      * @param pathPosition The index of the node we're calculating from
-     * @return The estimated number of ticks remaining frm the given position
+     * @return The estimated number of ticks remaining from the given position
      */
     default double ticksRemainingFrom(int pathPosition) {
         double sum = 0;
@@ -111,26 +115,68 @@ public interface IPath {
         return sum;
     }
 
+    /**
+     * Returns the estimated amount of time needed to complete this path from start to finish
+     *
+     * @return The estimated amount of time, in ticks
+     */
+    default double totalTicks() {
+        return ticksRemainingFrom(0);
+    }
+
     /**
      * Cuts off this path at the loaded chunk border, and returns the resulting path. Default
      * implementation just returns this path, without the intended functionality.
      *
      * @return The result of this cut-off operation
      */
-    default IPath cutoffAtLoadedChunks() {
-        return this;
+    default IPath cutoffAtLoadedChunks(World world) {
+        throw new UnsupportedOperationException();
     }
 
     /**
      * Cuts off this path using the min length and cutoff factor settings, and returns the resulting path.
      * Default implementation just returns this path, without the intended functionality.
      *
+     * @return The result of this cut-off operation
      * @see Settings#pathCutoffMinimumLength
      * @see Settings#pathCutoffFactor
-     *
-     * @return The result of this cut-off operation
      */
     default IPath staticCutoff(Goal destination) {
-        return this;
+        throw new UnsupportedOperationException();
+    }
+
+
+    /**
+     * Performs a series of checks to ensure that the assembly of the path went as expected.
+     */
+    default void sanityCheck() {
+        List<BetterBlockPos> path = positions();
+        List<IMovement> movements = movements();
+        if (!getSrc().equals(path.get(0))) {
+            throw new IllegalStateException("Start node does not equal first path element");
+        }
+        if (!getDest().equals(path.get(path.size() - 1))) {
+            throw new IllegalStateException("End node does not equal last path element");
+        }
+        if (path.size() != movements.size() + 1) {
+            throw new IllegalStateException("Size of path array is unexpected");
+        }
+        HashSet<BetterBlockPos> seenSoFar = new HashSet<>();
+        for (int i = 0; i < path.size() - 1; i++) {
+            BetterBlockPos src = path.get(i);
+            BetterBlockPos dest = path.get(i + 1);
+            IMovement movement = movements.get(i);
+            if (!src.equals(movement.getSrc())) {
+                throw new IllegalStateException("Path source is not equal to the movement source");
+            }
+            if (!dest.equals(movement.getDest())) {
+                throw new IllegalStateException("Path destination is not equal to the movement destination");
+            }
+            if (seenSoFar.contains(src)) {
+                throw new IllegalStateException("Path doubles back on itself, making a loop");
+            }
+            seenSoFar.add(src);
+        }
     }
 }

src/api/java/baritone/api/pathing/calc/IPathFinder.java

@@ -18,6 +18,7 @@
 package baritone.api.pathing.calc;
 
 import baritone.api.pathing.goals.Goal;
+import baritone.api.utils.PathCalculationResult;
 
 import java.util.Optional;
 
@@ -35,7 +36,7 @@ public interface IPathFinder {
      *
      * @return The final path
      */
-    Optional<IPath> calculate(long timeout);
+    PathCalculationResult calculate(long primaryTimeout, long failureTimeout);
 
     /**
      * Intended to be called concurrently with calculatePath from a different thread to tell if it's finished yet

src/api/java/baritone/api/pathing/calc/IPathingControlManager.java

@@ -0,0 +1,31 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.pathing.calc;
+
+import baritone.api.process.IBaritoneProcess;
+import baritone.api.process.PathingCommand;
+
+import java.util.Optional;
+
+public interface IPathingControlManager {
+    void registerProcess(IBaritoneProcess process);
+
+    Optional<IBaritoneProcess> mostRecentInControl();
+
+    Optional<PathingCommand> mostRecentCommand();
+}

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

@@ -17,10 +17,7 @@
 
 package baritone.api.pathing.goals;
 
-import net.minecraft.util.math.BlockPos;
-
 import java.util.Arrays;
-import java.util.Collection;
 
 /**
  * A composite of many goals, any one of which satisfies the composite.
@@ -40,14 +37,6 @@ public class GoalComposite implements Goal {
         this.goals = goals;
     }
 
-    public GoalComposite(BlockPos... blocks) {
-        this(Arrays.asList(blocks));
-    }
-
-    public GoalComposite(Collection<BlockPos> blocks) {
-        this(blocks.stream().map(GoalBlock::new).toArray(Goal[]::new));
-    }
-
     @Override
     public boolean isInGoal(int x, int y, int z) {
         for (Goal goal : goals) {

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

@@ -48,10 +48,7 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
         int xDiff = x - this.x;
         int yDiff = y - this.y;
         int zDiff = z - this.z;
-        if (yDiff < 0) {
-            yDiff++;
-        }
-        return Math.abs(xDiff) + Math.abs(yDiff) + Math.abs(zDiff) <= 1;
+        return Math.abs(xDiff) + Math.abs(yDiff < 0 ? yDiff + 1 : yDiff) + Math.abs(zDiff) <= 1;
     }
 
     @Override
@@ -59,7 +56,7 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
         int xDiff = x - this.x;
         int yDiff = y - this.y;
         int zDiff = z - this.z;
-        return GoalBlock.calculate(xDiff, yDiff, zDiff);
+        return GoalBlock.calculate(xDiff, yDiff < 0 ? yDiff + 1 : yDiff, zDiff);
     }
 
     @Override

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

@@ -32,16 +32,26 @@ public class GoalRunAway implements Goal {
 
     private final double distanceSq;
 
+    private final Integer maintainY;
+
     public GoalRunAway(double distance, BlockPos... from) {
+        this(distance, null, from);
+    }
+
+    public GoalRunAway(double distance, Integer maintainY, BlockPos... from) {
         if (from.length == 0) {
             throw new IllegalArgumentException();
         }
         this.from = from;
         this.distanceSq = distance * distance;
+        this.maintainY = maintainY;
     }
 
     @Override
     public boolean isInGoal(int x, int y, int z) {
+        if (maintainY != null && maintainY != y) {
+            return false;
+        }
         for (BlockPos p : from) {
             int diffX = x - p.getX();
             int diffZ = z - p.getZ();
@@ -62,11 +72,19 @@ public class GoalRunAway implements Goal {
                 min = h;
             }
         }
-        return -min;
+        min = -min;
+        if (maintainY != null) {
+            min = min * 0.6 + GoalYLevel.calculate(maintainY, y) * 1.5;
+        }
+        return min;
     }
 
     @Override
     public String toString() {
-        return "GoalRunAwayFrom" + Arrays.asList(from);
+        if (maintainY != null) {
+            return "GoalRunAwayFromMaintainY y=" + maintainY + ", " + Arrays.asList(from);
+        } else {
+            return "GoalRunAwayFrom" + Arrays.asList(from);
+        }
     }
 }

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

@@ -63,10 +63,7 @@ public class GoalTwoBlocks implements Goal, IGoalRenderPos {
         int xDiff = x - this.x;
         int yDiff = y - this.y;
         int zDiff = z - this.z;
-        if (yDiff < 0) {
-            yDiff++;
-        }
-        return GoalBlock.calculate(xDiff, yDiff, zDiff);
+        return GoalBlock.calculate(xDiff, yDiff < 0 ? yDiff + 1 : yDiff, zDiff);
     }
 
     @Override

src/api/java/baritone/api/process/IBaritoneProcess.java

@@ -0,0 +1,99 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.process;
+
+import baritone.api.IBaritone;
+import baritone.api.behavior.IPathingBehavior;
+import baritone.api.event.events.PathEvent;
+
+/**
+ * A process that can control the PathingBehavior.
+ * <p>
+ * Differences between a baritone process and a behavior:
+ * Only one baritone process can be active at a time
+ * PathingBehavior can only be controlled by a process
+ * <p>
+ * That's it actually
+ *
+ * @author leijurv
+ */
+public interface IBaritoneProcess {
+
+    /**
+     * Would this process like to be in control?
+     *
+     * @return Whether or not this process would like to be in contorl.
+     */
+    boolean isActive();
+
+    /**
+     * Called when this process is in control of pathing; Returns what Baritone should do.
+     *
+     * @param calcFailed     {@code true} if this specific process was in control last tick,
+     *                       and there was a {@link PathEvent#CALC_FAILED} event last tick
+     * @param isSafeToCancel {@code true} if a {@link PathingCommandType#REQUEST_PAUSE} would happen this tick, and
+     *                       {@link IPathingBehavior} wouldn't actually tick. {@code false} if the PathExecutor reported
+     *                       pausing would be unsafe at the end of the last tick. Effectively "could request cancel or
+     *                       pause and have it happen right away"
+     * @return What the {@link IPathingBehavior} should do
+     */
+    PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel);
+
+    /**
+     * Returns whether or not this process should be treated as "temporary".
+     * <p>
+     * If a process is temporary, it doesn't call {@link #onLostControl} on the processes that aren't execute because of it.
+     * <p>
+     * For example, {@code CombatPauserProcess} and {@code PauseForAutoEatProcess} should return {@code true} always,
+     * and should return {@link #isActive} {@code true} only if there's something in range this tick, or if the player would like
+     * to start eating this tick. {@code PauseForAutoEatProcess} should only actually right click once onTick is called with
+     * {@code isSafeToCancel} true though.
+     *
+     * @return Whethor or not if this control is temporary
+     */
+    boolean isTemporary();
+
+    /**
+     * Called if {@link #isActive} returned {@code true}, but another non-temporary
+     * process has control. Effectively the same as cancel. You want control but you
+     * don't get it.
+     */
+    void onLostControl();
+
+    /**
+     * Used to determine which Process gains control if multiple are reporting {@link #isActive()}. The one
+     * that returns the highest value will be given control.
+     *
+     * @return A double representing the priority
+     */
+    double priority();
+
+    /**
+     * Returns which bot this process is associated with. (5000000iq forward thinking)
+     *
+     * @return The Bot associated with this process
+     */
+    IBaritone associatedWith();
+
+    /**
+     * Returns a user-friendly name for this process. Suitable for a HUD.
+     *
+     * @return A display name that's suitable for a HUD
+     */
+    String displayName();
+}

src/api/java/baritone/api/process/ICustomGoalProcess.java

@@ -15,40 +15,36 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.utils.interfaces;
+package baritone.api.process;
 
-/**
- * @author Brady
- * @since 8/20/2018
- */
-public interface Toggleable {
+import baritone.api.pathing.goals.Goal;
+
+public interface ICustomGoalProcess extends IBaritoneProcess {
 
     /**
-     * Toggles the enabled state of this {@link Toggleable}.
+     * Sets the pathing goal
      *
-     * @return The new state.
+     * @param goal The new goal
      */
-    boolean toggle();
+    void setGoal(Goal goal);
 
     /**
-     * Sets the enabled state of this {@link Toggleable}.
+     * Starts path calculation and execution.
+     */
+    void path();
+
+    /**
+     * @return The current goal
+     */
+    Goal getGoal();
+
+    /**
+     * Sets the goal and begins the path execution.
      *
-     * @return The new state.
+     * @param goal The new goal
      */
-    boolean setEnabled(boolean enabled);
-
-    /**
-     * @return Whether or not this {@link Toggleable} object is enabled
-     */
-    boolean isEnabled();
-
-    /**
-     * Called when the state changes from disabled to enabled
-     */
-    default void onEnable() {}
-
-    /**
-     * Called when the state changes from enabled to disabled
-     */
-    default void onDisable() {}
+    default void setGoalAndPath(Goal goal) {
+        this.setGoal(goal);
+        this.path();
+    }
 }

src/api/java/baritone/api/process/IFollowProcess.java

@@ -15,30 +15,37 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.behavior;
+package baritone.api.process;
 
 import net.minecraft.entity.Entity;
 
+import java.util.List;
+import java.util.function.Predicate;
+
 /**
  * @author Brady
  * @since 9/23/2018
  */
-public interface IFollowBehavior extends IBehavior {
+public interface IFollowProcess extends IBaritoneProcess {
 
     /**
-     * Set the follow target to the specified entity;
+     * Set the follow target to any entities matching this predicate
      *
-     * @param entity The entity to follow
+     * @param filter the predicate
      */
-    void follow(Entity entity);
+    void follow(Predicate<Entity> filter);
 
     /**
-     * @return The entity that is currently being followed
+     * @return The entities that are currently being followed. null if not currently following, empty if nothing matches the predicate
      */
-    Entity following();
+    List<Entity> following();
+
+    Predicate<Entity> currentFilter();
 
     /**
      * Cancels the follow behavior, this will clear the current follow target.
      */
-    void cancel();
+    default void cancel() {
+        onLostControl();
+    }
 }

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

@@ -0,0 +1,28 @@
+/*
+ * 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.process;
+
+import net.minecraft.block.Block;
+
+/**
+ * but it rescans the world every once in a while so it doesn't get fooled by its cache
+ */
+public interface IGetToBlockProcess extends IBaritoneProcess {
+
+    void getToBlock(Block block);
+}

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

@@ -15,7 +15,7 @@
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.behavior;
+package baritone.api.process;
 
 import net.minecraft.block.Block;
 
@@ -23,7 +23,7 @@ import net.minecraft.block.Block;
  * @author Brady
  * @since 9/23/2018
  */
-public interface IMineBehavior extends IBehavior {
+public interface IMineProcess extends IBaritoneProcess {
 
     /**
      * Begin to search for and mine the specified blocks until
@@ -31,9 +31,9 @@ public interface IMineBehavior extends IBehavior {
      * are mined. This is based on the first target block to mine.
      *
      * @param quantity The number of items to get from blocks mined
-     * @param blocks The blocks to mine
+     * @param blocks   The blocks to mine
      */
-    void mine(int quantity, String... blocks);
+    void mineByName(int quantity, String... blocks);
 
     /**
      * Begin to search for and mine the specified blocks until
@@ -41,7 +41,7 @@ public interface IMineBehavior extends IBehavior {
      * are mined. This is based on the first target block to mine.
      *
      * @param quantity The number of items to get from blocks mined
-     * @param blocks The blocks to mine
+     * @param blocks   The blocks to mine
      */
     void mine(int quantity, Block... blocks);
 
@@ -50,8 +50,8 @@ public interface IMineBehavior extends IBehavior {
      *
      * @param blocks The blocks to mine
      */
-    default void mine(String... blocks) {
-        this.mine(0, blocks);
+    default void mineByName(String... blocks) {
+        mineByName(0, blocks);
     }
 
     /**
@@ -60,11 +60,13 @@ public interface IMineBehavior extends IBehavior {
      * @param blocks The blocks to mine
      */
     default void mine(Block... blocks) {
-        this.mine(0, blocks);
+        mine(0, blocks);
     }
 
     /**
      * Cancels the current mining task
      */
-    void cancel();
+    default void cancel() {
+        onLostControl();
+    }
 }

src/api/java/baritone/api/process/PathingCommand.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.process;
+
+import baritone.api.pathing.goals.Goal;
+
+import java.util.Objects;
+
+/**
+ * @author leijurv
+ */
+public class PathingCommand {
+
+    /**
+     * The target goal, may be {@code null}.
+     */
+    public final Goal goal;
+
+    /**
+     * The command type.
+     *
+     * @see PathingCommandType
+     */
+    public final PathingCommandType commandType;
+
+    /**
+     * Create a new {@link PathingCommand}.
+     *
+     * @param goal        The target goal, may be {@code null}.
+     * @param commandType The command type, cannot be {@code null}.
+     * @throws NullPointerException if {@code commandType} is {@code null}.
+     * @see Goal
+     * @see PathingCommandType
+     */
+    public PathingCommand(Goal goal, PathingCommandType commandType) {
+        Objects.requireNonNull(commandType);
+
+        this.goal = goal;
+        this.commandType = commandType;
+    }
+}

src/api/java/baritone/api/process/PathingCommandType.java

@@ -0,0 +1,55 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.process;
+
+import baritone.api.Settings;
+
+public enum PathingCommandType {
+
+    /**
+     * Set the goal and path.
+     * <p>
+     * If you use this alongside a {@code null} goal, it will continue along its current path and current goal.
+     */
+    SET_GOAL_AND_PATH,
+
+    /**
+     * Has no effect on the current goal or path, just requests a pause
+     */
+    REQUEST_PAUSE,
+
+    /**
+     * Set the goal (regardless of {@code null}), and request a cancel of the current path (when safe)
+     */
+    CANCEL_AND_SET_GOAL,
+
+    /**
+     * Set the goal and path.
+     * <p>
+     * If {@link Settings#cancelOnGoalInvalidation} is {@code true}, revalidate the
+     * current goal, and cancel if it's no longer valid, or if the new goal is {@code null}.
+     */
+    REVALIDATE_GOAL_AND_PATH,
+
+    /**
+     * Set the goal and path.
+     * <p>
+     * Cancel the current path if the goals are not equal
+     */
+    FORCE_REVALIDATE_GOAL_AND_PATH
+}

src/api/java/baritone/api/utils/IInputOverrideHandler.java

@@ -0,0 +1,39 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.utils;
+
+import baritone.api.behavior.IBehavior;
+import baritone.api.utils.input.Input;
+import net.minecraft.client.settings.KeyBinding;
+
+/**
+ * @author Brady
+ * @since 11/12/2018
+ */
+public interface IInputOverrideHandler extends IBehavior {
+
+    default boolean isInputForcedDown(KeyBinding key) {
+        return isInputForcedDown(Input.getInputForBind(key));
+    }
+
+    boolean isInputForcedDown(Input input);
+
+    void setInputForceState(Input input, boolean forced);
+
+    void clearAllKeys();
+}

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

@@ -0,0 +1,92 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.utils;
+
+import baritone.api.cache.IWorldData;
+import net.minecraft.block.BlockSlab;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+
+import java.util.Optional;
+
+/**
+ * @author Brady
+ * @since 11/12/2018
+ */
+public interface IPlayerContext {
+
+    EntityPlayerSP player();
+
+    PlayerControllerMP playerController();
+
+    World world();
+
+    IWorldData worldData();
+
+    RayTraceResult objectMouseOver();
+
+    default BetterBlockPos playerFeet() {
+        // TODO find a better way to deal with soul sand!!!!!
+        BetterBlockPos feet = new BetterBlockPos(player().posX, player().posY + 0.1251, player().posZ);
+        if (world().getBlockState(feet).getBlock() instanceof BlockSlab) {
+            return feet.up();
+        }
+        return feet;
+    }
+
+    default Vec3d playerFeetAsVec() {
+        return new Vec3d(player().posX, player().posY, player().posZ);
+    }
+
+    default Vec3d playerHead() {
+        return new Vec3d(player().posX, player().posY + player().getEyeHeight(), player().posZ);
+    }
+
+    default Rotation playerRotations() {
+        return new Rotation(player().rotationYaw, player().rotationPitch);
+    }
+
+    /**
+     * Returns the block that the crosshair is currently placed over. Updated once per tick.
+     *
+     * @return The position of the highlighted block
+     */
+    default Optional<BlockPos> getSelectedBlock() {
+        if (objectMouseOver() != null && objectMouseOver().typeOfHit == RayTraceResult.Type.BLOCK) {
+            return Optional.of(objectMouseOver().getBlockPos());
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Returns the entity that the crosshair is currently placed over. Updated once per tick.
+     *
+     * @return The entity
+     */
+    default Optional<Entity> getSelectedEntity() {
+        if (objectMouseOver() != null && objectMouseOver().typeOfHit == RayTraceResult.Type.ENTITY) {
+            return Optional.of(objectMouseOver().entityHit);
+        }
+        return Optional.empty();
+    }
+}

src/api/java/baritone/api/utils/PathCalculationResult.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.utils;
+
+import baritone.api.pathing.calc.IPath;
+
+import java.util.Optional;
+
+public class PathCalculationResult {
+
+    private final IPath path;
+    private final Type type;
+
+    public PathCalculationResult(Type type) {
+        this(type, null);
+    }
+
+    public PathCalculationResult(Type type, IPath path) {
+        this.path = path;
+        this.type = type;
+        if (type == null) {
+            throw new IllegalArgumentException("come on");
+        }
+    }
+
+    public final Optional<IPath> getPath() {
+        return Optional.ofNullable(this.path);
+    }
+
+    public final Type getType() {
+        return this.type;
+    }
+
+    public enum Type {
+        SUCCESS_TO_GOAL,
+        SUCCESS_SEGMENT,
+        FAILURE,
+        CANCELLATION,
+        EXCEPTION,
+    }
+}

src/api/java/baritone/api/utils/RayTraceUtils.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.utils;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
+
+/**
+ * @author Brady
+ * @since 8/25/2018
+ */
+public final class RayTraceUtils {
+
+    private RayTraceUtils() {}
+
+    /**
+     * Performs a block raytrace with the specified rotations. This should only be used when
+     * any entity collisions can be ignored, because this method will not recognize if an
+     * entity is in the way or not. The local player's block reach distance will be used.
+     *
+     * @param rotation The rotation to raytrace towards
+     * @return The calculated raytrace result
+     */
+    public static RayTraceResult rayTraceTowards(Entity entity, Rotation rotation, double blockReachDistance) {
+        Vec3d start = entity.getPositionEyes(1.0F);
+        Vec3d direction = RotationUtils.calcVec3dFromRotation(rotation);
+        Vec3d end = start.add(
+                direction.x * blockReachDistance,
+                direction.y * blockReachDistance,
+                direction.z * blockReachDistance
+        );
+        return entity.world.rayTraceBlocks(start, end, false, false, true);
+    }
+}

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

@@ -86,7 +86,7 @@ public class Rotation {
     public Rotation clamp() {
         return new Rotation(
                 this.yaw,
-                RotationUtils.clampPitch(this.pitch)
+                clampPitch(this.pitch)
         );
     }
 
@@ -95,7 +95,7 @@ public class Rotation {
      */
     public Rotation normalize() {
         return new Rotation(
-                RotationUtils.normalizeYaw(this.yaw),
+                normalizeYaw(this.yaw),
                 this.pitch
         );
     }
@@ -105,8 +105,35 @@ public class Rotation {
      */
     public Rotation normalizeAndClamp() {
         return new Rotation(
-                RotationUtils.normalizeYaw(this.yaw),
-                RotationUtils.clampPitch(this.pitch)
+                normalizeYaw(this.yaw),
+                clampPitch(this.pitch)
         );
     }
+
+    /**
+     * Clamps the specified pitch value between -90 and 90.
+     *
+     * @param pitch The input pitch
+     * @return The clamped pitch
+     */
+    public static float clampPitch(float pitch) {
+        return Math.max(-90, Math.min(90, pitch));
+    }
+
+    /**
+     * Normalizes the specified yaw value between -180 and 180.
+     *
+     * @param yaw The input yaw
+     * @return The normalized yaw
+     */
+    public static float normalizeYaw(float yaw) {
+        float newYaw = yaw % 360F;
+        if (newYaw < -180F) {
+            newYaw += 360F;
+        }
+        if (newYaw >= 180F) {
+            newYaw -= 360F;
+        }
+        return newYaw;
+    }
 }

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

@@ -17,38 +17,196 @@
 
 package baritone.api.utils;
 
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
+import net.minecraft.block.BlockFire;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.*;
+
+import java.util.Optional;
+
 /**
  * @author Brady
  * @since 9/25/2018
  */
 public final class RotationUtils {
 
+    /**
+     * Constant that a degree value is multiplied by to get the equivalent radian value
+     */
+    public static final double DEG_TO_RAD = Math.PI / 180.0;
+
+    /**
+     * Constant that a radian value is multiplied by to get the equivalent degree value
+     */
+    public static final double RAD_TO_DEG = 180.0 / Math.PI;
+
+    /**
+     * Offsets from the root block position to the center of each side.
+     */
+    private static final Vec3d[] BLOCK_SIDE_MULTIPLIERS = new Vec3d[]{
+            new Vec3d(0.5, 0, 0.5), // Down
+            new Vec3d(0.5, 1, 0.5), // Up
+            new Vec3d(0.5, 0.5, 0), // North
+            new Vec3d(0.5, 0.5, 1), // South
+            new Vec3d(0, 0.5, 0.5), // West
+            new Vec3d(1, 0.5, 0.5)  // East
+    };
+
     private RotationUtils() {}
 
     /**
-     * Clamps the specified pitch value between -90 and 90.
+     * Calculates the rotation from BlockPos<sub>dest</sub> to BlockPos<sub>orig</sub>
      *
-     * @param pitch The input pitch
-     * @return The clamped pitch
+     * @param orig The origin position
+     * @param dest The destination position
+     * @return The rotation from the origin to the destination
      */
-    public static float clampPitch(float pitch) {
-        return Math.max(-90, Math.min(90, pitch));
+    public static Rotation calcRotationFromCoords(BlockPos orig, BlockPos dest) {
+        return calcRotationFromVec3d(new Vec3d(orig), new Vec3d(dest));
     }
 
     /**
-     * Normalizes the specified yaw value between -180 and 180.
+     * Wraps the target angles to a relative value from the current angles. This is done by
+     * subtracting the current from the target, normalizing it, and then adding the current
+     * angles back to it.
      *
-     * @param yaw The input yaw
-     * @return The normalized yaw
+     * @param current The current angles
+     * @param target  The target angles
+     * @return The wrapped angles
      */
-    public static float normalizeYaw(float yaw) {
-        float newYaw = yaw % 360F;
-        if (newYaw < -180F) {
-            newYaw += 360F;
+    public static Rotation wrapAnglesToRelative(Rotation current, Rotation target) {
+        return target.subtract(current).normalize().add(current);
+    }
+
+    /**
+     * Calculates the rotation from Vec<sub>dest</sub> to Vec<sub>orig</sub> and makes the
+     * return value relative to the specified current rotations.
+     *
+     * @param orig    The origin position
+     * @param dest    The destination position
+     * @param current The current rotations
+     * @return The rotation from the origin to the destination
+     * @see #wrapAnglesToRelative(Rotation, Rotation)
+     */
+    public static Rotation calcRotationFromVec3d(Vec3d orig, Vec3d dest, Rotation current) {
+        return wrapAnglesToRelative(current, calcRotationFromVec3d(orig, dest));
+    }
+
+    /**
+     * Calculates the rotation from Vec<sub>dest</sub> to Vec<sub>orig</sub>
+     *
+     * @param orig The origin position
+     * @param dest The destination position
+     * @return The rotation from the origin to the destination
+     */
+    public static Rotation calcRotationFromVec3d(Vec3d orig, Vec3d dest) {
+        double[] delta = {orig.x - dest.x, orig.y - dest.y, orig.z - dest.z};
+        double yaw = MathHelper.atan2(delta[0], -delta[2]);
+        double dist = Math.sqrt(delta[0] * delta[0] + delta[2] * delta[2]);
+        double pitch = MathHelper.atan2(delta[1], dist);
+        return new Rotation(
+                (float) (yaw * RAD_TO_DEG),
+                (float) (pitch * RAD_TO_DEG)
+        );
+    }
+
+    /**
+     * Calculates the look vector for the specified yaw/pitch rotations.
+     *
+     * @param rotation The input rotation
+     * @return Look vector for the rotation
+     */
+    public static Vec3d calcVec3dFromRotation(Rotation rotation) {
+        float f = MathHelper.cos(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
+        float f1 = MathHelper.sin(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
+        float f2 = -MathHelper.cos(-rotation.getPitch() * (float) DEG_TO_RAD);
+        float f3 = MathHelper.sin(-rotation.getPitch() * (float) DEG_TO_RAD);
+        return new Vec3d((double) (f1 * f2), (double) f3, (double) (f * f2));
+    }
+
+    /**
+     * Determines if the specified entity is able to reach the center of any of the sides
+     * of the specified block. It first checks if the block center is reachable, and if so,
+     * that rotation will be returned. If not, it will return the first center of a given
+     * 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 pos    The target block position
+     * @return The optional rotation
+     */
+    public static Optional<Rotation> reachable(EntityPlayerSP entity, BlockPos pos, double blockReachDistance) {
+        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer(entity);
+        if (pos.equals(baritone.getPlayerContext().getSelectedBlock().orElse(null))) {
+            /*
+             * why add 0.0001?
+             * to indicate that we actually have a desired pitch
+             * the way we indicate that the pitch can be whatever and we only care about the yaw
+             * is by setting the desired pitch to the current pitch
+             * setting the desired pitch to the current pitch + 0.0001 means that we do have a desired pitch, it's
+             * just what it currently is
+             *
+             * or if you're a normal person literally all this does it ensure that we don't nudge the pitch to a normal level
+             */
+            return Optional.of(new Rotation(entity.rotationYaw, entity.rotationPitch + 0.0001F));
         }
-        if (newYaw >= 180F) {
-            newYaw -= 360F;
+        Optional<Rotation> possibleRotation = reachableCenter(entity, pos, blockReachDistance);
+        //System.out.println("center: " + possibleRotation);
+        if (possibleRotation.isPresent()) {
+            return possibleRotation;
         }
-        return newYaw;
+
+        IBlockState state = entity.world.getBlockState(pos);
+        AxisAlignedBB aabb = state.getBoundingBox(entity.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);
+            if (possibleRotation.isPresent()) {
+                return possibleRotation;
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Determines if the specified entity is able to reach the specified block with
+     * 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 pos       The target block position
+     * @param offsetPos The position of the block with the offset applied.
+     * @return The optional rotation
+     */
+    public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance) {
+        Rotation rotation = calcRotationFromVec3d(entity.getPositionEyes(1.0F), offsetPos);
+        RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance);
+        //System.out.println(result);
+        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
+            if (result.getBlockPos().equals(pos)) {
+                return Optional.of(rotation);
+            }
+            if (entity.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 entity The viewing entity
+     * @param pos    The target block position
+     * @return The optional rotation
+     */
+    public static Optional<Rotation> reachableCenter(Entity entity, BlockPos pos, double blockReachDistance) {
+        return reachableOffset(entity, pos, VecUtils.calculateBlockCenter(entity.world, pos), blockReachDistance);
     }
 }

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

@@ -31,6 +31,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class SettingsUtil {
+
     private static final File settingsFile = new File(new File(Minecraft.getMinecraft().gameDir, "baritone"), "settings.txt");
 
     private static final Map<Class<?>, SettingsIO> map;

src/api/java/baritone/api/utils/VecUtils.java

@@ -0,0 +1,116 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.utils;
+
+import net.minecraft.block.BlockFire;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+
+/**
+ * @author Brady
+ * @since 10/13/2018
+ */
+public final class VecUtils {
+
+    private VecUtils() {}
+
+    /**
+     * Calculates the center of the block at the specified position's bounding box
+     *
+     * @param pos The block position
+     * @return The center of the block's bounding box
+     * @see #getBlockPosCenter(BlockPos)
+     */
+    public static Vec3d calculateBlockCenter(World world, BlockPos pos) {
+        IBlockState b = world.getBlockState(pos);
+        AxisAlignedBB bbox = b.getBoundingBox(world, pos);
+        double xDiff = (bbox.minX + bbox.maxX) / 2;
+        double yDiff = (bbox.minY + bbox.maxY) / 2;
+        double zDiff = (bbox.minZ + bbox.maxZ) / 2;
+        if (b.getBlock() instanceof BlockFire) {//look at bottom of fire when putting it out
+            yDiff = 0;
+        }
+        return new Vec3d(
+                pos.getX() + xDiff,
+                pos.getY() + yDiff,
+                pos.getZ() + zDiff
+        );
+    }
+
+    /**
+     * Gets the assumed center position of the given block position.
+     * This is done by adding 0.5 to the X, Y, and Z axes.
+     * <p>
+     * TODO: We may want to consider replacing many usages of this method with #calculateBlockCenter(BlockPos)
+     *
+     * @param pos The block position
+     * @return The assumed center of the position
+     * @see #calculateBlockCenter(World, BlockPos)
+     */
+    public static Vec3d getBlockPosCenter(BlockPos pos) {
+        return new Vec3d(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+    }
+
+    /**
+     * Gets the distance from the specified position to the assumed center of the specified block position.
+     *
+     * @param pos The block position
+     * @param x   The x pos
+     * @param y   The y pos
+     * @param z   The z pos
+     * @return The distance from the assumed block center to the position
+     * @see #getBlockPosCenter(BlockPos)
+     */
+    public static double distanceToCenter(BlockPos pos, double x, double y, double z) {
+        Vec3d center = getBlockPosCenter(pos);
+        double xdiff = x - center.x;
+        double ydiff = y - center.y;
+        double zdiff = z - center.z;
+        return Math.sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
+    }
+
+    /**
+     * Gets the distance from the specified entity's position to the assumed
+     * center of the specified block position.
+     *
+     * @param entity The entity
+     * @param pos    The block position
+     * @return The distance from the entity to the block's assumed center
+     * @see #getBlockPosCenter(BlockPos)
+     */
+    public static double entityDistanceToCenter(Entity entity, BlockPos pos) {
+        return distanceToCenter(pos, entity.posX, entity.posY, entity.posZ);
+    }
+
+    /**
+     * Gets the distance from the specified entity's position to the assumed
+     * center of the specified block position, ignoring the Y axis.
+     *
+     * @param entity The entity
+     * @param pos    The block position
+     * @return The horizontal distance from the entity to the block's assumed center
+     * @see #getBlockPosCenter(BlockPos)
+     */
+    public static double entityFlatDistanceToCenter(Entity entity, BlockPos pos) {
+        return distanceToCenter(pos, entity.posX, pos.getY() + 0.5, entity.posZ);
+    }
+}

src/api/java/baritone/api/utils/input/Input.java

@@ -0,0 +1,119 @@
+/*
+ * 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.input;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.GameSettings;
+import net.minecraft.client.settings.KeyBinding;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * An {@link Enum} representing the inputs that control the player's
+ * behavior. This includes moving, interacting with blocks, jumping,
+ * sneaking, and sprinting.
+ */
+public enum Input {
+
+    /**
+     * The move forward input
+     */
+    MOVE_FORWARD(s -> s.keyBindForward),
+
+    /**
+     * The move back input
+     */
+    MOVE_BACK(s -> s.keyBindBack),
+
+    /**
+     * The move left input
+     */
+    MOVE_LEFT(s -> s.keyBindLeft),
+
+    /**
+     * The move right input
+     */
+    MOVE_RIGHT(s -> s.keyBindRight),
+
+    /**
+     * The attack input
+     */
+    CLICK_LEFT(s -> s.keyBindAttack),
+
+    /**
+     * The use item input
+     */
+    CLICK_RIGHT(s -> s.keyBindUseItem),
+
+    /**
+     * The jump input
+     */
+    JUMP(s -> s.keyBindJump),
+
+    /**
+     * The sneak input
+     */
+    SNEAK(s -> s.keyBindSneak),
+
+    /**
+     * The sprint input
+     */
+    SPRINT(s -> s.keyBindSprint);
+
+    /**
+     * Map of {@link KeyBinding} to {@link Input}. Values should be queried through {@link #getInputForBind(KeyBinding)}
+     */
+    private static final Map<KeyBinding, Input> bindToInputMap = new HashMap<>();
+
+    /**
+     * The actual game {@link KeyBinding} being forced.
+     */
+    private final KeyBinding keyBinding;
+
+    Input(Function<GameSettings, KeyBinding> keyBindingMapper) {
+        /*
+
+        Here, a Function is used because referring to a static field in this enum for the game instance,
+        as it was before, wouldn't be possible in an Enum constructor unless the static field was in an
+        interface that this class implemented. (Helper acted as this interface) I didn't feel like making
+        an interface with a game instance field just to not have to do this.
+
+         */
+        this.keyBinding = keyBindingMapper.apply(Minecraft.getMinecraft().gameSettings);
+    }
+
+    /**
+     * @return The actual game {@link KeyBinding} being forced.
+     */
+    public final KeyBinding getKeyBinding() {
+        return this.keyBinding;
+    }
+
+    /**
+     * Finds the {@link Input} constant that is associated with the specified {@link KeyBinding}.
+     *
+     * @param binding The {@link KeyBinding} to find the associated {@link Input} for
+     * @return The {@link Input} associated with the specified {@link KeyBinding}
+     */
+    public static Input getInputForBind(KeyBinding binding) {
+        return bindToInputMap.computeIfAbsent(binding, b -> Arrays.stream(values()).filter(input -> input.keyBinding == b).findFirst().orElse(null));
+    }
+}

src/comms/java/cabaletta/comms/BufferedConnection.java

@@ -0,0 +1,98 @@
+/*
+ * 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 cabaletta.comms;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * Do you not like having a blocking "receiveMessage" thingy?
+ * <p>
+ * Do you prefer just being able to get a list of all messages received since the last tick?
+ * <p>
+ * If so, this class is for you!
+ *
+ * @author leijurv
+ */
+public class BufferedConnection implements IConnection {
+    private final IConnection wrapped;
+    private final LinkedBlockingQueue<iMessage> queue;
+    private volatile transient IOException thrownOnRead;
+
+    public BufferedConnection(IConnection wrapped) {
+        this(wrapped, Integer.MAX_VALUE); // LinkedBlockingQueue accepts this as "no limit"
+    }
+
+    public BufferedConnection(IConnection wrapped, int maxInternalQueueSize) {
+        this.wrapped = wrapped;
+        this.queue = new LinkedBlockingQueue<>();
+        this.thrownOnRead = null;
+        new Thread(() -> {
+            try {
+                while (thrownOnRead == null) {
+                    queue.put(wrapped.receiveMessage());
+                }
+            } catch (IOException e) {
+                thrownOnRead = e;
+            } catch (InterruptedException e) {
+                thrownOnRead = new IOException("Interrupted while enqueueing", e);
+            }
+        }).start();
+    }
+
+    @Override
+    public void sendMessage(iMessage message) throws IOException {
+        wrapped.sendMessage(message);
+    }
+
+    @Override
+    public iMessage receiveMessage() {
+        throw new UnsupportedOperationException("BufferedConnection can only be read from non-blockingly");
+    }
+
+    @Override
+    public void close() {
+        wrapped.close();
+        thrownOnRead = new EOFException("Closed");
+    }
+
+    public List<iMessage> receiveMessagesNonBlocking() throws IOException {
+        ArrayList<iMessage> msgs = new ArrayList<>();
+        queue.drainTo(msgs); // preserves order -- first message received will be first in this arraylist
+        if (msgs.isEmpty() && thrownOnRead != null) {
+            IOException up = new IOException("BufferedConnection wrapped", thrownOnRead);
+            throw up;
+        }
+        return msgs;
+    }
+
+    public void handleAllPendingMessages(IMessageListener listener) throws IOException {
+        receiveMessagesNonBlocking().forEach(msg -> msg.handle(listener));
+    }
+
+    public static BufferedConnection makeBuffered(IConnection conn) {
+        if (conn instanceof BufferedConnection) {
+            return (BufferedConnection) conn;
+        } else {
+            return new BufferedConnection(conn);
+        }
+    }
+}

src/comms/java/cabaletta/comms/ConstructingDeserializer.java

@@ -0,0 +1,54 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package cabaletta.comms;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+public enum ConstructingDeserializer implements MessageDeserializer {
+    INSTANCE;
+    private final List<Class<? extends iMessage>> MSGS;
+
+    ConstructingDeserializer() {
+        MSGS = new ArrayList<>();
+        // imagine doing something in reflect but it's actually concise and you don't need to catch 42069 different exceptions. huh.
+        for (Method m : IMessageListener.class.getDeclaredMethods()) {
+            if (m.getName().equals("handle")) {
+                MSGS.add((Class<? extends iMessage>) m.getParameterTypes()[0]);
+            }
+        }
+    }
+
+    @Override
+    public synchronized iMessage deserialize(DataInputStream in) throws IOException {
+        int type = ((int) in.readByte()) & 0xff;
+        try {
+            return MSGS.get(type).getConstructor(DataInputStream.class).newInstance(in);
+        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException ex) {
+            throw new IOException("Unknown message type " + type, ex);
+        }
+    }
+
+    public byte getHeader(Class<? extends iMessage> klass) {
+        return (byte) MSGS.indexOf(klass);
+    }
+}

src/comms/java/cabaletta/comms/IConnection.java

@@ -0,0 +1,28 @@
+/*
+ * 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 cabaletta.comms;
+
+import java.io.IOException;
+
+public interface IConnection {
+    void sendMessage(iMessage message) throws IOException;
+
+    iMessage receiveMessage() throws IOException;
+
+    void close();
+}

src/comms/java/cabaletta/comms/IMessageListener.java

@@ -0,0 +1,46 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package cabaletta.comms;
+
+import cabaletta.comms.downward.MessageChat;
+import cabaletta.comms.downward.MessageComputationRequest;
+import cabaletta.comms.upward.MessageComputationResponse;
+import cabaletta.comms.upward.MessageStatus;
+
+public interface IMessageListener {
+    default void handle(MessageStatus message) {
+        unhandled(message);
+    }
+
+    default void handle(MessageChat message) {
+        unhandled(message);
+    }
+
+    default void handle(MessageComputationRequest message) {
+        unhandled(message);
+    }
+
+    default void handle(MessageComputationResponse message) {
+        unhandled(message);
+    }
+
+    default void unhandled(iMessage msg) {
+        // can override this to throw UnsupportedOperationException, if you want to make sure you're handling everything
+        // default is to silently ignore messages without handlers
+    }
+}

src/comms/java/cabaletta/comms/MessageDeserializer.java

@@ -0,0 +1,25 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package cabaletta.comms;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+
+public interface MessageDeserializer {
+    iMessage deserialize(DataInputStream in) throws IOException;
+}

src/comms/java/cabaletta/comms/Pipe.java

@@ -0,0 +1,99 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package cabaletta.comms;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * Do you want a socket to localhost without actually making a gross real socket to localhost?
+ */
+public class Pipe<T extends iMessage> {
+    private final LinkedBlockingQueue<Optional<iMessage>> AtoB;
+    private final LinkedBlockingQueue<Optional<iMessage>> BtoA;
+    private final PipedConnection A;
+    private final PipedConnection B;
+    private volatile boolean closed;
+
+    public Pipe() {
+        this.AtoB = new LinkedBlockingQueue<>();
+        this.BtoA = new LinkedBlockingQueue<>();
+        this.A = new PipedConnection(BtoA, AtoB);
+        this.B = new PipedConnection(AtoB, BtoA);
+    }
+
+    public PipedConnection getA() {
+        return A;
+    }
+
+    public PipedConnection getB() {
+        return B;
+    }
+
+    public class PipedConnection implements IConnection {
+        private final LinkedBlockingQueue<Optional<iMessage>> in;
+        private final LinkedBlockingQueue<Optional<iMessage>> out;
+
+        private PipedConnection(LinkedBlockingQueue<Optional<iMessage>> in, LinkedBlockingQueue<Optional<iMessage>> out) {
+            this.in = in;
+            this.out = out;
+        }
+
+        @Override
+        public void sendMessage(iMessage message) throws IOException {
+            if (closed) {
+                throw new EOFException("Closed");
+            }
+            try {
+                out.put(Optional.of(message));
+            } catch (InterruptedException e) {
+                // this can never happen since the LinkedBlockingQueues are not constructed with a maximum capacity, see above
+            }
+        }
+
+        @Override
+        public iMessage receiveMessage() throws IOException {
+            if (closed) {
+                throw new EOFException("Closed");
+            }
+            try {
+                Optional<iMessage> t = in.take();
+                if (!t.isPresent()) {
+                    throw new EOFException("Closed");
+                }
+                return t.get();
+            } catch (InterruptedException e) {
+                // again, cannot happen
+                // but we have to throw something
+                throw new IllegalStateException(e);
+            }
+        }
+
+        @Override
+        public void close() {
+            closed = true;
+            try {
+                AtoB.put(Optional.empty()); // unstick threads
+                BtoA.put(Optional.empty());
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}

src/comms/java/cabaletta/comms/SerializedConnection.java

@@ -0,0 +1,59 @@
+/*
+ * 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 cabaletta.comms;
+
+import java.io.*;
+
+public class SerializedConnection implements IConnection {
+    private final DataInputStream in;
+    private final DataOutputStream out;
+    private final MessageDeserializer deserializer;
+
+    public SerializedConnection(InputStream in, OutputStream out) {
+        this(ConstructingDeserializer.INSTANCE, in, out);
+    }
+
+    public SerializedConnection(MessageDeserializer d, InputStream in, OutputStream out) {
+        this.in = new DataInputStream(in);
+        this.out = new DataOutputStream(out);
+        this.deserializer = d;
+    }
+
+    @Override
+    public synchronized void sendMessage(iMessage message) throws IOException {
+        message.writeHeader(out);
+        message.write(out);
+    }
+
+    @Override
+    public iMessage receiveMessage() throws IOException {
+        return deserializer.deserialize(in);
+    }
+
+    @Override
+    public void close() {
+        try {
+            in.close();
+        } catch (IOException e) {
+        }
+        try {
+            out.close();
+        } catch (IOException e) {
+        }
+    }
+}

src/comms/java/cabaletta/comms/SocketConnection.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 cabaletta.comms;
+
+import java.io.IOException;
+import java.net.Socket;
+
+public class SocketConnection extends SerializedConnection {
+    public SocketConnection(Socket s) throws IOException {
+        super(s.getInputStream(), s.getOutputStream());
+    }
+}

src/comms/java/cabaletta/comms/downward/MessageChat.java

@@ -0,0 +1,48 @@
+/*
+ * 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 cabaletta.comms.downward;
+
+import cabaletta.comms.IMessageListener;
+import cabaletta.comms.iMessage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+public class MessageChat implements iMessage {
+
+    public final String msg;
+
+    public MessageChat(DataInputStream in) throws IOException {
+        this.msg = in.readUTF();
+    }
+
+    public MessageChat(String msg) {
+        this.msg = msg;
+    }
+
+    @Override
+    public void write(DataOutputStream out) throws IOException {
+        out.writeUTF(msg);
+    }
+
+    @Override
+    public void handle(IMessageListener listener) {
+        listener.handle(this);
+    }
+}

src/comms/java/cabaletta/comms/downward/MessageComputationRequest.java

@@ -0,0 +1,62 @@
+/*
+ * 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 cabaletta.comms.downward;
+
+import cabaletta.comms.IMessageListener;
+import cabaletta.comms.iMessage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+public class MessageComputationRequest implements iMessage {
+    public final long computationID;
+    public final int startX;
+    public final int startY;
+    public final int startZ;
+    public final String goal; // TODO find a better way to do this lol
+
+    public MessageComputationRequest(DataInputStream in) throws IOException {
+        this.computationID = in.readLong();
+        this.startX = in.readInt();
+        this.startY = in.readInt();
+        this.startZ = in.readInt();
+        this.goal = in.readUTF();
+    }
+
+    public MessageComputationRequest(long computationID, int startX, int startY, int startZ, String goal) {
+        this.computationID = computationID;
+        this.startX = startX;
+        this.startY = startY;
+        this.startZ = startZ;
+        this.goal = goal;
+    }
+
+    @Override
+    public void write(DataOutputStream out) throws IOException {
+        out.writeLong(computationID);
+        out.writeInt(startX);
+        out.writeInt(startY);
+        out.writeUTF(goal);
+    }
+
+    @Override
+    public void handle(IMessageListener listener) {
+        listener.handle(this);
+    }
+}

src/comms/java/cabaletta/comms/iMessage.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 cabaletta.comms;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * hell yeah
+ * <p>
+ * <p>
+ * dumb android users cant read this file
+ * <p>
+ *
+ * @author leijurv
+ */
+public interface iMessage {
+    void write(DataOutputStream out) throws IOException;
+
+    default void writeHeader(DataOutputStream out) throws IOException {
+        out.writeByte(getHeader());
+    }
+
+    default byte getHeader() {
+        return ConstructingDeserializer.INSTANCE.getHeader(getClass());
+    }
+
+    void handle(IMessageListener listener);
+}

src/comms/java/cabaletta/comms/upward/MessageComputationResponse.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 cabaletta.comms.upward;
+
+import cabaletta.comms.IMessageListener;
+import cabaletta.comms.iMessage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+public class MessageComputationResponse implements iMessage {
+    public final long computationID;
+    public final int pathLength;
+    public final double pathCost;
+    public final boolean endsInGoal;
+    public final int endX;
+    public final int endY;
+    public final int endZ;
+
+    public MessageComputationResponse(DataInputStream in) throws IOException {
+        this.computationID = in.readLong();
+        this.pathLength = in.readInt();
+        this.pathCost = in.readDouble();
+        this.endsInGoal = in.readBoolean();
+        this.endX = in.readInt();
+        this.endY = in.readInt();
+        this.endZ = in.readInt();
+    }
+
+    public MessageComputationResponse(long computationID, int pathLength, double pathCost, boolean endsInGoal, int endX, int endY, int endZ) {
+        this.computationID = computationID;
+        this.pathLength = pathLength;
+        this.pathCost = pathCost;
+        this.endsInGoal = endsInGoal;
+        this.endX = endX;
+        this.endY = endY;
+        this.endZ = endZ;
+    }
+
+    @Override
+    public void write(DataOutputStream out) throws IOException {
+        out.writeLong(computationID);
+        out.writeInt(pathLength);
+        out.writeDouble(pathCost);
+        out.writeBoolean(endsInGoal);
+        out.writeInt(endX);
+        out.writeInt(endY);
+        out.writeInt(endZ);
+    }
+
+    @Override
+    public void handle(IMessageListener listener) {
+        listener.handle(this);
+    }
+}
+

src/comms/java/cabaletta/comms/upward/MessageStatus.java

@@ -0,0 +1,124 @@
+/*
+ * 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 cabaletta.comms.upward;
+
+import cabaletta.comms.IMessageListener;
+import cabaletta.comms.iMessage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+public class MessageStatus implements iMessage {
+
+    public final double x;
+    public final double y;
+    public final double z;
+    public final float yaw;
+    public final float pitch;
+    public final boolean onGround;
+    public final float health;
+    public final float saturation;
+    public final int foodLevel;
+    public final int pathStartX;
+    public final int pathStartY;
+    public final int pathStartZ;
+    public final boolean hasCurrentSegment;
+    public final boolean hasNextSegment;
+    public final boolean calcInProgress;
+    public final double ticksRemainingInCurrent;
+    public final boolean calcFailedLastTick;
+    public final boolean safeToCancel;
+    public final String currentGoal;
+    public final String currentProcess;
+
+    public MessageStatus(DataInputStream in) throws IOException {
+        this.x = in.readDouble();
+        this.y = in.readDouble();
+        this.z = in.readDouble();
+        this.yaw = in.readFloat();
+        this.pitch = in.readFloat();
+        this.onGround = in.readBoolean();
+        this.health = in.readFloat();
+        this.saturation = in.readFloat();
+        this.foodLevel = in.readInt();
+        this.pathStartX = in.readInt();
+        this.pathStartY = in.readInt();
+        this.pathStartZ = in.readInt();
+        this.hasCurrentSegment = in.readBoolean();
+        this.hasNextSegment = in.readBoolean();
+        this.calcInProgress = in.readBoolean();
+        this.ticksRemainingInCurrent = in.readDouble();
+        this.calcFailedLastTick = in.readBoolean();
+        this.safeToCancel = in.readBoolean();
+        this.currentGoal = in.readUTF();
+        this.currentProcess = in.readUTF();
+    }
+
+    public MessageStatus(double x, double y, double z, float yaw, float pitch, boolean onGround, float health, float saturation, int foodLevel, int pathStartX, int pathStartY, int pathStartZ, boolean hasCurrentSegment, boolean hasNextSegment, boolean calcInProgress, double ticksRemainingInCurrent, boolean calcFailedLastTick, boolean safeToCancel, String currentGoal, String currentProcess) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.yaw = yaw;
+        this.pitch = pitch;
+        this.onGround = onGround;
+        this.health = health;
+        this.saturation = saturation;
+        this.foodLevel = foodLevel;
+        this.pathStartX = pathStartX;
+        this.pathStartY = pathStartY;
+        this.pathStartZ = pathStartZ;
+        this.hasCurrentSegment = hasCurrentSegment;
+        this.hasNextSegment = hasNextSegment;
+        this.calcInProgress = calcInProgress;
+        this.ticksRemainingInCurrent = ticksRemainingInCurrent;
+        this.calcFailedLastTick = calcFailedLastTick;
+        this.safeToCancel = safeToCancel;
+        this.currentGoal = currentGoal;
+        this.currentProcess = currentProcess;
+    }
+
+    @Override
+    public void write(DataOutputStream out) throws IOException {
+        out.writeDouble(x);
+        out.writeDouble(y);
+        out.writeDouble(z);
+        out.writeFloat(yaw);
+        out.writeFloat(pitch);
+        out.writeBoolean(onGround);
+        out.writeFloat(health);
+        out.writeFloat(saturation);
+        out.writeInt(foodLevel);
+        out.writeInt(pathStartX);
+        out.writeInt(pathStartY);
+        out.writeInt(pathStartZ);
+        out.writeBoolean(hasCurrentSegment);
+        out.writeBoolean(hasNextSegment);
+        out.writeBoolean(calcInProgress);
+        out.writeDouble(ticksRemainingInCurrent);
+        out.writeBoolean(calcFailedLastTick);
+        out.writeBoolean(safeToCancel);
+        out.writeUTF(currentGoal);
+        out.writeUTF(currentProcess);
+    }
+
+    @Override
+    public void handle(IMessageListener listener) {
+        listener.handle(this);
+    }
+}

src/launch/java/baritone/launch/BaritoneTweaker.java

@@ -17,61 +17,39 @@
 
 package baritone.launch;
 
-import net.minecraft.launchwrapper.ITweaker;
+import io.github.impactdevelopment.simpletweaker.SimpleTweaker;
+import net.minecraft.launchwrapper.Launch;
 import net.minecraft.launchwrapper.LaunchClassLoader;
 import org.spongepowered.asm.launch.MixinBootstrap;
 import org.spongepowered.asm.mixin.MixinEnvironment;
 import org.spongepowered.asm.mixin.Mixins;
 import org.spongepowered.tools.obfuscation.mcp.ObfuscationServiceMCP;
 
-import java.io.File;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @author Brady
- * @since 7/31/2018 9:59 PM
+ * @since 7/31/2018
  */
-public class BaritoneTweaker implements ITweaker {
-
-    List<String> args;
-
-    @Override
-    public void acceptOptions(List<String> args, File gameDir, File assetsDir, String profile) {
-        this.args = new ArrayList<>(args);
-        if (gameDir != null) {
-            addArg("gameDir", gameDir.getAbsolutePath());
-        }
-        if (assetsDir != null) {
-            addArg("assetsDir", assetsDir.getAbsolutePath());
-        }
-        if (profile != null) {
-            addArg("version", profile);
-        }
-    }
+public class BaritoneTweaker extends SimpleTweaker {
 
     @Override
     public void injectIntoClassLoader(LaunchClassLoader classLoader) {
+        super.injectIntoClassLoader(classLoader);
+
         MixinBootstrap.init();
+
+        // noinspection unchecked
+        List<String> tweakClasses = (List<String>) Launch.blackboard.get("TweakClasses");
+
+        String obfuscation = ObfuscationServiceMCP.NOTCH;
+        if (tweakClasses.stream().anyMatch(s -> s.contains("net.minecraftforge.fml.common.launcher"))) {
+            obfuscation = ObfuscationServiceMCP.SEARGE;
+        }
+
         MixinEnvironment.getDefaultEnvironment().setSide(MixinEnvironment.Side.CLIENT);
-        MixinEnvironment.getDefaultEnvironment().setObfuscationContext(ObfuscationServiceMCP.NOTCH);
+        MixinEnvironment.getDefaultEnvironment().setObfuscationContext(obfuscation);
+
         Mixins.addConfiguration("mixins.baritone.json");
     }
-
-    @Override
-    public final String getLaunchTarget() {
-        return "net.minecraft.client.main.Main";
-    }
-
-    @Override
-    public final String[] getLaunchArguments() {
-        return this.args.toArray(new String[0]);
-    }
-
-    private void addArg(String label, String value) {
-        if (!args.contains("--" + label) && value != null) {
-            this.args.add("--" + label);
-            this.args.add(value);
-        }
-    }
 }

src/launch/java/baritone/launch/mixins/MixinAnvilChunkLoader.java

@@ -32,7 +32,9 @@ import java.io.File;
 @Mixin(AnvilChunkLoader.class)
 public class MixinAnvilChunkLoader implements IAnvilChunkLoader {
 
-    @Shadow @Final private File chunkSaveLocation;
+    @Shadow
+    @Final
+    private File chunkSaveLocation;
 
     @Override
     public File getChunkSaveLocation() {

src/launch/java/baritone/launch/mixins/MixinBlockPos.java

@@ -35,6 +35,12 @@ public class MixinBlockPos extends Vec3i {
         super(xIn, yIn, zIn);
     }
 
+    /**
+     * The purpose of this was to ensure a friendly name for when we print raw
+     * block positions to chat in the context of an obfuscated environment.
+     *
+     * @return a string representation of the object.
+     */
     @Override
     @Nonnull
     public String toString() {

src/launch/java/baritone/launch/mixins/MixinChunkProviderClient.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.IChunkProviderClient;
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import net.minecraft.client.multiplayer.ChunkProviderClient;
+import net.minecraft.world.chunk.Chunk;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(ChunkProviderClient.class)
+public class MixinChunkProviderClient implements IChunkProviderClient {
+
+    @Shadow
+    @Final
+    private Long2ObjectMap<Chunk> loadedChunks;
+
+    @Override
+    public Long2ObjectMap<Chunk> loadedChunks() {
+        return this.loadedChunks;
+    }
+}

src/launch/java/baritone/launch/mixins/MixinChunkProviderServer.java

@@ -31,7 +31,9 @@ import org.spongepowered.asm.mixin.Shadow;
 @Mixin(ChunkProviderServer.class)
 public class MixinChunkProviderServer implements IChunkProviderServer {
 
-    @Shadow @Final private IChunkLoader chunkLoader;
+    @Shadow
+    @Final
+    private IChunkLoader chunkLoader;
 
     @Override
     public IChunkLoader getChunkLoader() {

src/launch/java/baritone/launch/mixins/MixinEntity.java

@@ -17,16 +17,19 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
 import baritone.api.event.events.RotationMoveEvent;
-import baritone.api.event.events.type.EventState;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import static org.spongepowered.asm.lib.Opcodes.GETFIELD;
+
 /**
  * @author Brady
  * @since 8/21/2018
@@ -34,23 +37,38 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 @Mixin(Entity.class)
 public class MixinEntity {
 
+    @Shadow
+    public float rotationYaw;
+
+    /**
+     * Event called to override the movement direction when walking
+     */
+    private RotationMoveEvent motionUpdateRotationEvent;
+
     @Inject(
             method = "moveRelative",
             at = @At("HEAD")
     )
     private void preMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
-        Entity _this = (Entity) (Object) this;
-        if (EntityPlayerSP.class.isInstance(_this))
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent((EntityPlayerSP) _this, EventState.PRE, RotationMoveEvent.Type.MOTION_UPDATE));
+        // noinspection ConstantConditions
+        if (EntityPlayerSP.class.isInstance(this)) {
+            this.motionUpdateRotationEvent = new RotationMoveEvent((EntityPlayerSP) (Object) this, RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
+            BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(this.motionUpdateRotationEvent);
+        }
     }
 
-    @Inject(
+    @Redirect(
             method = "moveRelative",
-            at = @At("RETURN")
+            at = @At(
+                    value = "FIELD",
+                    opcode = GETFIELD,
+                    target = "net/minecraft/entity/Entity.rotationYaw:F"
+            )
     )
-    private void postMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
-        Entity _this = (Entity) (Object) this;
-        if (EntityPlayerSP.class.isInstance(_this))
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent((EntityPlayerSP) _this, EventState.POST, RotationMoveEvent.Type.MOTION_UPDATE));
+    private float overrideYaw(Entity self) {
+        if (self instanceof EntityPlayerSP) {
+            return this.motionUpdateRotationEvent.getYaw();
+        }
+        return self.rotationYaw;
     }
 }

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

@@ -17,40 +17,61 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
 import baritone.api.event.events.RotationMoveEvent;
-import baritone.api.event.events.type.EventState;
 import net.minecraft.client.entity.EntityPlayerSP;
+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.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 static org.spongepowered.asm.lib.Opcodes.GETFIELD;
+
 /**
  * @author Brady
  * @since 9/10/2018
  */
 @Mixin(EntityLivingBase.class)
-public class MixinEntityLivingBase {
+public abstract class MixinEntityLivingBase extends Entity {
+
+    /**
+     * Event called to override the movement direction when jumping
+     */
+    private RotationMoveEvent jumpRotationEvent;
+
+    public MixinEntityLivingBase(World worldIn, RotationMoveEvent jumpRotationEvent) {
+        super(worldIn);
+        this.jumpRotationEvent = jumpRotationEvent;
+    }
 
     @Inject(
             method = "jump",
             at = @At("HEAD")
     )
-    private void preJump(CallbackInfo ci) {
-        EntityLivingBase _this = (EntityLivingBase) (Object) this;
-        if (EntityPlayerSP.class.isInstance(_this))
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent((EntityPlayerSP) _this, EventState.PRE, RotationMoveEvent.Type.JUMP));
+    private void preMoveRelative(CallbackInfo ci) {
+        // noinspection ConstantConditions
+        if (EntityPlayerSP.class.isInstance(this)) {
+            this.jumpRotationEvent = new RotationMoveEvent((EntityPlayerSP) (Object) this, RotationMoveEvent.Type.JUMP, this.rotationYaw);
+            BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
+        }
     }
 
-    @Inject(
+    @Redirect(
             method = "jump",
-            at = @At("RETURN")
+            at = @At(
+                    value = "FIELD",
+                    opcode = GETFIELD,
+                    target = "net/minecraft/entity/EntityLivingBase.rotationYaw:F"
+            )
     )
-    private void postJump(CallbackInfo ci) {
-        EntityLivingBase _this = (EntityLivingBase) (Object) this;
-        if (EntityPlayerSP.class.isInstance(_this))
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent((EntityPlayerSP) _this, EventState.POST, RotationMoveEvent.Type.JUMP));
+    private float overrideYaw(EntityLivingBase self) {
+        if (self instanceof EntityPlayerSP) {
+            return this.jumpRotationEvent.getYaw();
+        }
+        return self.rotationYaw;
     }
 }

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

@@ -17,19 +17,22 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.behavior.IPathingBehavior;
 import baritone.api.event.events.ChatEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.type.EventState;
 import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.entity.player.PlayerCapabilities;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 /**
  * @author Brady
- * @since 8/1/2018 5:06 PM
+ * @since 8/1/2018
  */
 @Mixin(EntityPlayerSP.class)
 public class MixinEntityPlayerSP {
@@ -41,7 +44,7 @@ public class MixinEntityPlayerSP {
     )
     private void sendChatMessage(String msg, CallbackInfo ci) {
         ChatEvent event = new ChatEvent((EntityPlayerSP) (Object) this, msg);
-        Baritone.INSTANCE.getGameEventHandler().onSendChatMessage(event);
+        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onSendChatMessage(event);
         if (event.isCancelled()) {
             ci.cancel();
         }
@@ -57,7 +60,7 @@ public class MixinEntityPlayerSP {
             )
     )
     private void onPreUpdate(CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.PRE));
+        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.PRE));
     }
 
     @Inject(
@@ -70,6 +73,18 @@ public class MixinEntityPlayerSP {
             )
     )
     private void onPostUpdate(CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.POST));
+        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.POST));
+    }
+
+    @Redirect(
+            method = "onLivingUpdate",
+            at = @At(
+                    value = "FIELD",
+                    target = "net/minecraft/entity/player/PlayerCapabilities.allowFlying:Z"
+            )
+    )
+    private boolean isAllowFlying(PlayerCapabilities capabilities) {
+        IPathingBehavior pathingBehavior = BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getPathingBehavior();
+        return !pathingBehavior.isPathing() && capabilities.allowFlying;
     }
 }

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

@@ -17,7 +17,8 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.event.events.RenderEvent;
 import net.minecraft.client.renderer.EntityRenderer;
 import org.spongepowered.asm.mixin.Mixin;
@@ -33,10 +34,12 @@ public class MixinEntityRenderer {
             at = @At(
                     value = "INVOKE_STRING",
                     target = "Lnet/minecraft/profiler/Profiler;endStartSection(Ljava/lang/String;)V",
-                    args = { "ldc=hand" }
+                    args = {"ldc=hand"}
             )
     )
     private void renderWorldPass(int pass, float partialTicks, long finishTimeNano, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onRenderPass(new RenderEvent(partialTicks));
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            ibaritone.getGameEventHandler().onRenderPass(new RenderEvent(partialTicks));
+        }
     }
 }

src/launch/java/baritone/launch/mixins/MixinKeyBinding.java

@@ -17,7 +17,7 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
 import net.minecraft.client.settings.KeyBinding;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -26,7 +26,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 /**
  * @author Brady
- * @since 7/31/2018 11:44 PM
+ * @since 7/31/2018
  */
 @Mixin(KeyBinding.class)
 public class MixinKeyBinding {
@@ -37,7 +37,8 @@ public class MixinKeyBinding {
             cancellable = true
     )
     private void isKeyDown(CallbackInfoReturnable<Boolean> cir) {
-        if (Baritone.INSTANCE.getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this)) {
+        // only the primary baritone forces keys
+        if (BaritoneAPI.getProvider().getPrimaryBaritone().getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this)) {
             cir.setReturnValue(true);
         }
     }

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

@@ -18,13 +18,13 @@
 package baritone.launch.mixins;
 
 import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.event.events.BlockInteractEvent;
 import baritone.api.event.events.TickEvent;
 import baritone.api.event.events.WorldEvent;
 import baritone.api.event.events.type.EventState;
-import baritone.behavior.PathingBehavior;
 import baritone.utils.BaritoneAutoTest;
-import baritone.utils.ExampleBaritoneControl;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.gui.GuiScreen;
@@ -44,13 +44,11 @@ import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 /**
  * @author Brady
- * @since 7/31/2018 10:51 PM
+ * @since 7/31/2018
  */
 @Mixin(Minecraft.class)
 public class MixinMinecraft {
 
-    @Shadow
-    private int leftClickCounter;
     @Shadow
     public EntityPlayerSP player;
     @Shadow
@@ -61,8 +59,7 @@ public class MixinMinecraft {
             at = @At("RETURN")
     )
     private void postInit(CallbackInfo ci) {
-        Baritone.INSTANCE.init();
-        ExampleBaritoneControl.INSTANCE.initAndRegister();
+        ((Baritone) BaritoneAPI.getProvider().getPrimaryBaritone()).init();
     }
 
     @Inject(
@@ -88,13 +85,15 @@ public class MixinMinecraft {
             )
     )
     private void runTick(CallbackInfo ci) {
-        Minecraft mc = (Minecraft) (Object) this;
-        Baritone.INSTANCE.getGameEventHandler().onTick(new TickEvent(
-                EventState.PRE,
-                (mc.player != null && mc.world != null)
-                        ? TickEvent.Type.IN
-                        : TickEvent.Type.OUT
-        ));
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+
+            TickEvent.Type type = ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().world() != null
+                    ? TickEvent.Type.IN
+                    : TickEvent.Type.OUT;
+
+            ibaritone.getGameEventHandler().onTick(new TickEvent(EventState.PRE, type));
+        }
+
     }
 
     @Inject(
@@ -102,7 +101,8 @@ public class MixinMinecraft {
             at = @At("HEAD")
     )
     private void runTickKeyboard(CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onProcessKeyBinds();
+        // keyboard input is only the primary baritone
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onProcessKeyBinds();
     }
 
     @Inject(
@@ -115,7 +115,9 @@ public class MixinMinecraft {
             return;
         }
 
-        Baritone.INSTANCE.getGameEventHandler().onWorldEvent(
+        // mc.world changing is only the primary baritone
+
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onWorldEvent(
                 new WorldEvent(
                         world,
                         EventState.PRE
@@ -130,7 +132,8 @@ public class MixinMinecraft {
     private void postLoadWorld(WorldClient world, String loadingMessage, CallbackInfo ci) {
         // still fire event for both null, as that means we've just finished exiting a world
 
-        Baritone.INSTANCE.getGameEventHandler().onWorldEvent(
+        // mc.world changing is only the primary baritone
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onWorldEvent(
                 new WorldEvent(
                         world,
                         EventState.POST
@@ -147,7 +150,8 @@ public class MixinMinecraft {
             )
     )
     private boolean isAllowUserInput(GuiScreen screen) {
-        return (PathingBehavior.INSTANCE.getCurrent() != null && player != null) || screen.allowUserInput;
+        // allow user input is only the primary baritone
+        return (BaritoneAPI.getProvider().getPrimaryBaritone().getPathingBehavior().getCurrent() != null && player != null) || screen.allowUserInput;
     }
 
     @Inject(
@@ -159,7 +163,8 @@ public class MixinMinecraft {
             locals = LocalCapture.CAPTURE_FAILHARD
     )
     private void onBlockBreak(CallbackInfo ci, BlockPos pos) {
-        Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(pos, BlockInteractEvent.Type.BREAK));
+        // clickMouse is only for the main player
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onBlockInteract(new BlockInteractEvent(pos, BlockInteractEvent.Type.BREAK));
     }
 
     @Inject(
@@ -171,6 +176,7 @@ public class MixinMinecraft {
             locals = LocalCapture.CAPTURE_FAILHARD
     )
     private void onBlockUse(CallbackInfo ci, EnumHand var1[], int var2, int var3, EnumHand enumhand, ItemStack itemstack, BlockPos blockpos, int i, EnumActionResult enumactionresult) {
-        Baritone.INSTANCE.getGameEventHandler().onBlockInteract(new BlockInteractEvent(blockpos, BlockInteractEvent.Type.USE));
+        // rightClickMouse is only for the main player
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onBlockInteract(new BlockInteractEvent(blockpos, BlockInteractEvent.Type.USE));
     }
 }

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

@@ -17,7 +17,8 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.event.events.ChunkEvent;
 import baritone.api.event.events.type.EventState;
 import net.minecraft.client.network.NetHandlerPlayClient;
@@ -30,7 +31,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 /**
  * @author Brady
- * @since 8/3/2018 12:54 AM
+ * @since 8/3/2018
  */
 @Mixin(NetHandlerPlayClient.class)
 public class MixinNetHandlerPlayClient {
@@ -43,14 +44,18 @@ public class MixinNetHandlerPlayClient {
             )
     )
     private void preRead(SPacketChunkData packetIn, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onChunkEvent(
-                new ChunkEvent(
-                        EventState.PRE,
-                        ChunkEvent.Type.POPULATE,
-                        packetIn.getChunkX(),
-                        packetIn.getChunkZ()
-                )
-        );
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.PRE,
+                                packetIn.isFullChunk() ? ChunkEvent.Type.POPULATE_FULL : ChunkEvent.Type.POPULATE_PARTIAL,
+                                packetIn.getChunkX(),
+                                packetIn.getChunkZ()
+                        )
+                );
+            }
+        }
     }
 
     @Inject(
@@ -58,14 +63,18 @@ public class MixinNetHandlerPlayClient {
             at = @At("RETURN")
     )
     private void postHandleChunkData(SPacketChunkData packetIn, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onChunkEvent(
-                new ChunkEvent(
-                        EventState.POST,
-                        ChunkEvent.Type.POPULATE,
-                        packetIn.getChunkX(),
-                        packetIn.getChunkZ()
-                )
-        );
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.POST,
+                                packetIn.isFullChunk() ? ChunkEvent.Type.POPULATE_FULL : ChunkEvent.Type.POPULATE_PARTIAL,
+                                packetIn.getChunkX(),
+                                packetIn.getChunkZ()
+                        )
+                );
+            }
+        }
     }
 
     @Inject(
@@ -76,6 +85,10 @@ public class MixinNetHandlerPlayClient {
             )
     )
     private void onPlayerDeath(SPacketCombatEvent packetIn, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onPlayerDeath();
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player().connection == (NetHandlerPlayClient) (Object) this) {
+                ibaritone.getGameEventHandler().onPlayerDeath();
+            }
+        }
     }
 }

src/launch/java/baritone/launch/mixins/MixinNetworkManager.java

@@ -17,7 +17,8 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.event.events.PacketEvent;
 import baritone.api.event.events.type.EventState;
 import io.netty.channel.Channel;
@@ -36,7 +37,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 /**
  * @author Brady
- * @since 8/6/2018 9:30 PM
+ * @since 8/6/2018
  */
 @Mixin(NetworkManager.class)
 public class MixinNetworkManager {
@@ -53,8 +54,14 @@ public class MixinNetworkManager {
             at = @At("HEAD")
     )
     private void preDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>>[] futureListeners, CallbackInfo ci) {
-        if (this.direction == EnumPacketDirection.CLIENTBOUND) {
-            Baritone.INSTANCE.getGameEventHandler().onSendPacket(new PacketEvent((NetworkManager) (Object) this, EventState.PRE, inPacket));
+        if (this.direction != EnumPacketDirection.CLIENTBOUND) {
+            return;
+        }
+
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().player().connection.getNetworkManager() == (NetworkManager) (Object) this) {
+                ibaritone.getGameEventHandler().onSendPacket(new PacketEvent((NetworkManager) (Object) this, EventState.PRE, inPacket));
+            }
         }
     }
 
@@ -63,8 +70,14 @@ public class MixinNetworkManager {
             at = @At("RETURN")
     )
     private void postDispatchPacket(Packet<?> inPacket, final GenericFutureListener<? extends Future<? super Void>>[] futureListeners, CallbackInfo ci) {
-        if (this.direction == EnumPacketDirection.CLIENTBOUND) {
-            Baritone.INSTANCE.getGameEventHandler().onSendPacket(new PacketEvent((NetworkManager) (Object) this, EventState.POST, inPacket));
+        if (this.direction != EnumPacketDirection.CLIENTBOUND) {
+            return;
+        }
+
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().player().connection.getNetworkManager() == (NetworkManager) (Object) this) {
+                ibaritone.getGameEventHandler().onSendPacket(new PacketEvent((NetworkManager) (Object) this, EventState.POST, inPacket));
+            }
         }
     }
 
@@ -76,8 +89,14 @@ public class MixinNetworkManager {
             )
     )
     private void preProcessPacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {
-        if (this.direction == EnumPacketDirection.CLIENTBOUND) {
-            Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent((NetworkManager) (Object) this, EventState.PRE, packet));}
+        if (this.direction != EnumPacketDirection.CLIENTBOUND) {
+            return;
+        }
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().player().connection.getNetworkManager() == (NetworkManager) (Object) this) {
+                ibaritone.getGameEventHandler().onReceivePacket(new PacketEvent((NetworkManager) (Object) this, EventState.PRE, packet));
+            }
+        }
     }
 
     @Inject(
@@ -85,8 +104,13 @@ public class MixinNetworkManager {
             at = @At("RETURN")
     )
     private void postProcessPacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {
-        if (this.channel.isOpen() && this.direction == EnumPacketDirection.CLIENTBOUND) {
-            Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent((NetworkManager) (Object) this, EventState.POST, packet));
+        if (!this.channel.isOpen() || this.direction != EnumPacketDirection.CLIENTBOUND) {
+            return;
+        }
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().player() != null && ibaritone.getPlayerContext().player().connection.getNetworkManager() == (NetworkManager) (Object) this) {
+                ibaritone.getGameEventHandler().onReceivePacket(new PacketEvent((NetworkManager) (Object) this, EventState.POST, packet));
+            }
         }
     }
 }

src/launch/java/baritone/launch/mixins/MixinWorldClient.java

@@ -17,7 +17,8 @@
 
 package baritone.launch.mixins;
 
-import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.event.events.ChunkEvent;
 import baritone.api.event.events.type.EventState;
 import net.minecraft.client.multiplayer.WorldClient;
@@ -28,7 +29,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 /**
  * @author Brady
- * @since 8/2/2018 12:41 AM
+ * @since 8/2/2018
  */
 @Mixin(WorldClient.class)
 public class MixinWorldClient {
@@ -38,14 +39,19 @@ public class MixinWorldClient {
             at = @At("HEAD")
     )
     private void preDoPreChunk(int chunkX, int chunkZ, boolean loadChunk, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onChunkEvent(
-                new ChunkEvent(
-                        EventState.PRE,
-                        loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
-                        chunkX,
-                        chunkZ
-                )
-        );
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().world() == (WorldClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.PRE,
+                                loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
+                                chunkX,
+                                chunkZ
+                        )
+                );
+            }
+        }
+
     }
 
     @Inject(
@@ -53,13 +59,17 @@ public class MixinWorldClient {
             at = @At("RETURN")
     )
     private void postDoPreChunk(int chunkX, int chunkZ, boolean loadChunk, CallbackInfo ci) {
-        Baritone.INSTANCE.getGameEventHandler().onChunkEvent(
-                new ChunkEvent(
-                        EventState.POST,
-                        loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
-                        chunkX,
-                        chunkZ
-                )
-        );
+        for (IBaritone ibaritone : BaritoneAPI.getProvider().getAllBaritones()) {
+            if (ibaritone.getPlayerContext().world() == (WorldClient) (Object) this) {
+                ibaritone.getGameEventHandler().onChunkEvent(
+                        new ChunkEvent(
+                                EventState.POST,
+                                loadChunk ? ChunkEvent.Type.LOAD : ChunkEvent.Type.UNLOAD,
+                                chunkX,
+                                chunkZ
+                        )
+                );
+            }
+        }
     }
 }

src/launch/resources/mixins.baritone.json

@@ -10,6 +10,7 @@
   "client": [
     "MixinAnvilChunkLoader",
     "MixinBlockPos",
+    "MixinChunkProviderClient",
     "MixinChunkProviderServer",
     "MixinEntity",
     "MixinEntityLivingBase",

src/main/java/baritone/Baritone.java

@@ -18,12 +18,22 @@
 package baritone;
 
 import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.Settings;
-import baritone.api.event.listener.IGameEventListener;
+import baritone.api.event.listener.IEventBus;
+import baritone.api.utils.IPlayerContext;
 import baritone.behavior.*;
+import baritone.cache.WorldProvider;
 import baritone.event.GameEventHandler;
+import baritone.process.CustomGoalProcess;
+import baritone.process.FollowProcess;
+import baritone.process.GetToBlockProcess;
+import baritone.process.MineProcess;
 import baritone.utils.BaritoneAutoTest;
+import baritone.utils.ExampleBaritoneControl;
 import baritone.utils.InputOverrideHandler;
+import baritone.utils.PathingControlManager;
+import baritone.utils.player.PrimaryPlayerContext;
 import net.minecraft.client.Minecraft;
 
 import java.io.File;
@@ -38,14 +48,23 @@ import java.util.concurrent.TimeUnit;
 
 /**
  * @author Brady
- * @since 7/31/2018 10:50 PM
+ * @since 7/31/2018
  */
-public enum Baritone {
+public class Baritone implements IBaritone {
 
-    /**
-     * Singleton instance of this class
-     */
-    INSTANCE;
+    private static ThreadPoolExecutor threadPool;
+    private static File dir;
+
+    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) {}
+        }
+    }
 
     /**
      * Whether or not {@link Baritone#init()} has been called yet
@@ -53,97 +72,146 @@ public enum Baritone {
     private boolean initialized;
 
     private GameEventHandler gameEventHandler;
-    private InputOverrideHandler inputOverrideHandler;
-    private Settings settings;
-    private List<Behavior> behaviors;
-    private File dir;
-    private ThreadPoolExecutor threadPool;
 
-    /**
-     * Whether or not Baritone is active
-     */
-    private boolean active;
+    private List<Behavior> behaviors;
+    private ControllerBehavior controllerBehavior;
+    private PathingBehavior pathingBehavior;
+    private LookBehavior lookBehavior;
+    private MemoryBehavior memoryBehavior;
+    private InputOverrideHandler inputOverrideHandler;
+
+    private FollowProcess followProcess;
+    private MineProcess mineProcess;
+    private GetToBlockProcess getToBlockProcess;
+    private CustomGoalProcess customGoalProcess;
+
+    private PathingControlManager pathingControlManager;
+
+    private IPlayerContext playerContext;
+    private WorldProvider worldProvider;
 
     Baritone() {
-        this.gameEventHandler = new GameEventHandler();
+        this.gameEventHandler = new GameEventHandler(this);
     }
 
     public synchronized void init() {
         if (initialized) {
             return;
         }
-        this.threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
-        this.inputOverrideHandler = new InputOverrideHandler();
 
-        // Acquire the "singleton" instance of the settings directly from the API
-        // We might want to change this...
-        this.settings = BaritoneAPI.getSettings();
+        // Define this before behaviors try and get it, or else it will be null and the builds will fail!
+        this.playerContext = PrimaryPlayerContext.INSTANCE;
 
         this.behaviors = new ArrayList<>();
         {
-            registerBehavior(PathingBehavior.INSTANCE);
-            registerBehavior(LookBehavior.INSTANCE);
-            registerBehavior(MemoryBehavior.INSTANCE);
-            registerBehavior(LocationTrackingBehavior.INSTANCE);
-            registerBehavior(FollowBehavior.INSTANCE);
-            registerBehavior(MineBehavior.INSTANCE);
+            // the Behavior constructor calls baritone.registerBehavior(this) so this populates the behaviors arraylist
+            controllerBehavior = new ControllerBehavior(this);
+            pathingBehavior = new PathingBehavior(this);
+            lookBehavior = new LookBehavior(this);
+            memoryBehavior = new MemoryBehavior(this);
+            inputOverrideHandler = new InputOverrideHandler(this);
+            new ExampleBaritoneControl(this);
         }
+
+        this.pathingControlManager = new PathingControlManager(this);
+        {
+            followProcess = new FollowProcess(this);
+            mineProcess = new MineProcess(this);
+            customGoalProcess = new CustomGoalProcess(this); // very high iq
+            getToBlockProcess = new GetToBlockProcess(this);
+        }
+
+        this.worldProvider = new WorldProvider();
+
         if (BaritoneAutoTest.ENABLE_AUTO_TEST) {
-            registerEventListener(BaritoneAutoTest.INSTANCE);
-        }
-        this.dir = new File(Minecraft.getMinecraft().gameDir, "baritone");
-        if (!Files.exists(dir.toPath())) {
-            try {
-                Files.createDirectories(dir.toPath());
-            } catch (IOException ignored) {}
+            this.gameEventHandler.registerEventListener(BaritoneAutoTest.INSTANCE);
         }
 
-        this.active = true;
         this.initialized = true;
     }
 
-    public boolean isInitialized() {
-        return this.initialized;
-    }
-
-    public IGameEventListener getGameEventHandler() {
-        return this.gameEventHandler;
-    }
-
-    public InputOverrideHandler getInputOverrideHandler() {
-        return this.inputOverrideHandler;
-    }
-
     public List<Behavior> getBehaviors() {
         return this.behaviors;
     }
 
-    public Executor getExecutor() {
+    public void registerBehavior(Behavior behavior) {
+        this.behaviors.add(behavior);
+        this.gameEventHandler.registerEventListener(behavior);
+    }
+
+    @Override
+    public PathingControlManager getPathingControlManager() {
+        return this.pathingControlManager;
+    }
+
+    @Override
+    public InputOverrideHandler getInputOverrideHandler() {
+        return this.inputOverrideHandler;
+    }
+
+    public ControllerBehavior getControllerBehavior() {
+        return this.controllerBehavior;
+    }
+
+    @Override
+    public CustomGoalProcess getCustomGoalProcess() { // Iffy
+        return this.customGoalProcess;
+    }
+
+    @Override
+    public GetToBlockProcess getGetToBlockProcess() {  // Iffy
+        return this.getToBlockProcess;
+    }
+
+    @Override
+    public PathingBehavior getPathingBehavior() {
+        return this.pathingBehavior;
+    }
+
+    @Override
+    public MemoryBehavior getMemoryBehavior() {
+        return this.memoryBehavior;
+    }
+
+    @Override
+    public IPlayerContext getPlayerContext() {
+        return this.playerContext;
+    }
+
+    @Override
+    public FollowProcess getFollowProcess() {
+        return this.followProcess;
+    }
+
+    @Override
+    public WorldProvider getWorldProvider() {
+        return this.worldProvider;
+    }
+
+    @Override
+    public IEventBus getGameEventHandler() {
+        return this.gameEventHandler;
+    }
+
+    @Override
+    public LookBehavior getLookBehavior() {
+        return this.lookBehavior;
+    }
+
+    @Override
+    public MineProcess getMineProcess() {
+        return this.mineProcess;
+    }
+
+    public static Executor getExecutor() {
         return threadPool;
     }
 
-    public void registerBehavior(Behavior behavior) {
-        this.behaviors.add(behavior);
-        this.registerEventListener(behavior);
-    }
-
-    public void registerEventListener(IGameEventListener listener) {
-        this.gameEventHandler.registerEventListener(listener);
-    }
-
-    public boolean isActive() {
-        return this.active;
-    }
-
-    public Settings getSettings() {
-        return this.settings;
-    }
-
     public static Settings settings() {
-        return Baritone.INSTANCE.settings; // yolo
+        return BaritoneAPI.getSettings();
     }
 
-    public File getDir() {
-        return this.dir;
+    public static File getDir() {
+        return dir;
     }
 }

src/main/java/baritone/BaritoneProvider.java

@@ -17,58 +17,35 @@
 
 package baritone;
 
+import baritone.api.IBaritone;
 import baritone.api.IBaritoneProvider;
-import baritone.api.behavior.*;
-import baritone.api.cache.IWorldProvider;
 import baritone.api.cache.IWorldScanner;
-import baritone.api.event.listener.IGameEventListener;
-import baritone.behavior.*;
-import baritone.cache.WorldProvider;
 import baritone.cache.WorldScanner;
 
+import java.util.Collections;
+import java.util.List;
+
 /**
  * @author Brady
  * @since 9/29/2018
  */
 public final class BaritoneProvider implements IBaritoneProvider {
 
+    private final Baritone primary = new Baritone();
+
     @Override
-    public IFollowBehavior getFollowBehavior() {
-        return FollowBehavior.INSTANCE;
+    public IBaritone getPrimaryBaritone() {
+        return primary;
     }
 
     @Override
-    public ILookBehavior getLookBehavior() {
-        return LookBehavior.INSTANCE;
-    }
-
-    @Override
-    public IMemoryBehavior getMemoryBehavior() {
-        return MemoryBehavior.INSTANCE;
-    }
-
-    @Override
-    public IMineBehavior getMineBehavior() {
-        return MineBehavior.INSTANCE;
-    }
-
-    @Override
-    public IPathingBehavior getPathingBehavior() {
-        return PathingBehavior.INSTANCE;
-    }
-
-    @Override
-    public IWorldProvider getWorldProvider() {
-        return WorldProvider.INSTANCE;
+    public List<IBaritone> getAllBaritones() {
+        // TODO return a CopyOnWriteArrayList
+        return Collections.singletonList(primary);
     }
 
     @Override
     public IWorldScanner getWorldScanner() {
         return WorldScanner.INSTANCE;
     }
-
-    @Override
-    public void registerEventListener(IGameEventListener listener) {
-        Baritone.INSTANCE.registerEventListener(listener);
-    }
 }

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

@@ -17,54 +17,24 @@
 
 package baritone.behavior;
 
+import baritone.Baritone;
 import baritone.api.behavior.IBehavior;
+import baritone.api.utils.IPlayerContext;
 
 /**
- * A type of game event listener that can be toggled.
+ * A type of game event listener that is given {@link Baritone} instance context.
  *
  * @author Brady
- * @since 8/1/2018 6:29 PM
+ * @since 8/1/2018
  */
 public class Behavior implements IBehavior {
 
-    /**
-     * Whether or not this behavior is enabled
-     */
-    private boolean enabled = true;
+    public final Baritone baritone;
+    public final IPlayerContext ctx;
 
-    /**
-     * Toggles the enabled state of this {@link Behavior}.
-     *
-     * @return The new state.
-     */
-    @Override
-    public final boolean toggle() {
-        return this.setEnabled(!this.isEnabled());
-    }
-
-    /**
-     * Sets the enabled state of this {@link Behavior}.
-     *
-     * @return The new state.
-     */
-    @Override
-    public final boolean setEnabled(boolean enabled) {
-        if (enabled == this.enabled) {
-            return this.enabled;
-        }
-        if (this.enabled = enabled) {
-            this.onEnable();
-        } else {
-            this.onDisable();
-        }
-        return this.enabled;
-    }
-
-    /**
-     * @return Whether or not this {@link Behavior} is active.
-     */
-    @Override
-    public final boolean isEnabled() {
-        return this.enabled;
+    protected Behavior(Baritone baritone) {
+        this.baritone = baritone;
+        this.ctx = baritone.getPlayerContext();
+        baritone.registerBehavior(this);
     }
 }

src/main/java/baritone/behavior/ControllerBehavior.java

@@ -0,0 +1,163 @@
+/*
+ * 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;
+
+import baritone.Baritone;
+import baritone.api.event.events.ChatEvent;
+import baritone.api.event.events.TickEvent;
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.goals.GoalYLevel;
+import baritone.api.process.IBaritoneProcess;
+import baritone.api.utils.BetterBlockPos;
+import baritone.pathing.movement.CalculationContext;
+import baritone.utils.Helper;
+import baritone.utils.pathing.SegmentedCalculator;
+import cabaletta.comms.BufferedConnection;
+import cabaletta.comms.IConnection;
+import cabaletta.comms.IMessageListener;
+import cabaletta.comms.downward.MessageChat;
+import cabaletta.comms.downward.MessageComputationRequest;
+import cabaletta.comms.iMessage;
+import cabaletta.comms.upward.MessageComputationResponse;
+import cabaletta.comms.upward.MessageStatus;
+import net.minecraft.util.math.BlockPos;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class ControllerBehavior extends Behavior implements IMessageListener {
+
+    public ControllerBehavior(Baritone baritone) {
+        super(baritone);
+    }
+
+    private BufferedConnection conn;
+
+    @Override
+    public void onTick(TickEvent event) {
+        if (event.getType() == TickEvent.Type.OUT) {
+            return;
+        }
+        trySend(buildStatus());
+        readAndHandle();
+    }
+
+    public MessageStatus buildStatus() {
+        // TODO report inventory and echest contents
+        // TODO figure out who should remember echest contents when it isn't open, baritone or tenor?
+        BlockPos pathStart = baritone.getPathingBehavior().pathStart();
+        return new MessageStatus(
+                ctx.player().posX,
+                ctx.player().posY,
+                ctx.player().posZ,
+                ctx.player().rotationYaw,
+                ctx.player().rotationPitch,
+                ctx.player().onGround,
+                ctx.player().getHealth(),
+                ctx.player().getFoodStats().getSaturationLevel(),
+                ctx.player().getFoodStats().getFoodLevel(),
+                pathStart.getX(),
+                pathStart.getY(),
+                pathStart.getZ(),
+                baritone.getPathingBehavior().getCurrent() != null,
+                baritone.getPathingBehavior().getNext() != null,
+                baritone.getPathingBehavior().getInProgress().isPresent(),
+                baritone.getPathingBehavior().ticksRemainingInSegment().orElse(0D),
+                baritone.getPathingBehavior().calcFailedLastTick(),
+                baritone.getPathingBehavior().isSafeToCancel(),
+                baritone.getPathingBehavior().getGoal() + "",
+                baritone.getPathingControlManager().mostRecentInControl().map(IBaritoneProcess::displayName).orElse("")
+        );
+    }
+
+    private void readAndHandle() {
+        if (conn == null) {
+            return;
+        }
+        try {
+            conn.handleAllPendingMessages(this);
+        } catch (IOException e) {
+            e.printStackTrace();
+            disconnect();
+        }
+    }
+
+    public boolean trySend(iMessage msg) {
+        if (conn == null) {
+            return false;
+        }
+        try {
+            conn.sendMessage(msg);
+            return true;
+        } catch (IOException e) {
+            e.printStackTrace();
+            disconnect();
+            return false;
+        }
+    }
+
+    public void connectTo(IConnection conn) {
+        disconnect();
+        this.conn = BufferedConnection.makeBuffered(conn);
+    }
+
+    public void disconnect() {
+        if (conn != null) {
+            conn.close();
+        }
+        conn = null;
+    }
+
+    @Override
+    public void handle(MessageChat msg) { // big brain
+        ChatEvent event = new ChatEvent(ctx.player(), msg.msg);
+        baritone.getGameEventHandler().onSendChatMessage(event);
+    }
+
+    @Override
+    public void handle(MessageComputationRequest msg) {
+        BetterBlockPos start = new BetterBlockPos(msg.startX, msg.startY, msg.startZ);
+        // TODO this may require scanning the world for blocks of a certain type, idk how to manage that
+        Goal goal = new GoalYLevel(Integer.parseInt(msg.goal)); // im already winston
+        SegmentedCalculator.calculateSegmentsThreaded(start, goal, new CalculationContext(baritone), path -> {
+            if (!Objects.equals(path.getGoal(), goal)) {
+                throw new IllegalStateException(); // sanity check
+            }
+            try {
+                BetterBlockPos dest = path.getDest();
+                conn.sendMessage(new MessageComputationResponse(msg.computationID, path.length(), path.totalTicks(), path.getGoal().isInGoal(dest), dest.x, dest.y, dest.z));
+            } catch (IOException e) {
+                // nothing we can do about this, we just completed a computation but our tenor connection was closed in the meantime
+                // just discard the path we made for them =((
+                e.printStackTrace(); // and complain =)
+            }
+        }, () -> {
+            try {
+                conn.sendMessage(new MessageComputationResponse(msg.computationID, 0, 0, false, 0, 0, 0));
+            } catch (IOException e) {
+                // same deal
+                e.printStackTrace();
+            }
+        });
+    }
+
+    @Override
+    public void unhandled(iMessage msg) {
+        Helper.HELPER.logDebug("Unhandled message received by ControllerBehavior " + msg);
+    }
+}

src/main/java/baritone/behavior/FollowBehavior.java

@@ -1,79 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.behavior;
-
-import baritone.Baritone;
-import baritone.api.behavior.IFollowBehavior;
-import baritone.api.event.events.TickEvent;
-import baritone.api.pathing.goals.GoalNear;
-import baritone.api.pathing.goals.GoalXZ;
-import baritone.utils.Helper;
-import net.minecraft.entity.Entity;
-import net.minecraft.util.math.BlockPos;
-
-/**
- * Follow an entity
- *
- * @author leijurv
- */
-public final class FollowBehavior extends Behavior implements IFollowBehavior, Helper {
-
-    public static final FollowBehavior INSTANCE = new FollowBehavior();
-
-    private Entity following;
-
-    private FollowBehavior() {}
-
-    @Override
-    public void onTick(TickEvent event) {
-        if (event.getType() == TickEvent.Type.OUT) {
-            following = null;
-            return;
-        }
-        if (following == null) {
-            return;
-        }
-        // lol this is trashy but it works
-        BlockPos pos;
-        if (Baritone.settings().followOffsetDistance.get() == 0) {
-            pos = following.getPosition();
-        } else {
-            GoalXZ g = GoalXZ.fromDirection(following.getPositionVector(), Baritone.settings().followOffsetDirection.get(), Baritone.settings().followOffsetDistance.get());
-            pos = new BlockPos(g.getX(), following.posY, g.getZ());
-        }
-        PathingBehavior.INSTANCE.setGoal(new GoalNear(pos, Baritone.settings().followRadius.get()));
-        PathingBehavior.INSTANCE.revalidateGoal();
-        PathingBehavior.INSTANCE.path();
-    }
-
-    @Override
-    public void follow(Entity entity) {
-        this.following = entity;
-    }
-
-    @Override
-    public Entity following() {
-        return this.following;
-    }
-
-    @Override
-    public void cancel() {
-        PathingBehavior.INSTANCE.cancel();
-        follow(null);
-    }
-}

src/main/java/baritone/behavior/LocationTrackingBehavior.java

@@ -1,53 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.behavior;
-
-import baritone.api.event.events.BlockInteractEvent;
-import baritone.cache.Waypoint;
-import baritone.cache.WorldProvider;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
-import net.minecraft.block.BlockBed;
-
-/**
- * A collection of event methods that are used to interact with Baritone's
- * waypoint system. This class probably needs a better name.
- *
- * @see Waypoint
- *
- * @author Brady
- * @since 8/22/2018
- */
-public final class LocationTrackingBehavior extends Behavior implements Helper {
-
-    public static final LocationTrackingBehavior INSTANCE = new LocationTrackingBehavior();
-
-    private LocationTrackingBehavior() {}
-
-    @Override
-    public void onBlockInteract(BlockInteractEvent event) {
-        if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.getBlock(event.getPos()) instanceof BlockBed) {
-            WorldProvider.INSTANCE.getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("bed", Waypoint.Tag.BED, event.getPos()));
-        }
-    }
-
-    @Override
-    public void onPlayerDeath() {
-        WorldProvider.INSTANCE.getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("death", Waypoint.Tag.DEATH, playerFeet()));
-    }
-}

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

@@ -23,11 +23,8 @@ import baritone.api.behavior.ILookBehavior;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.RotationMoveEvent;
 import baritone.api.utils.Rotation;
-import baritone.utils.Helper;
 
-public final class LookBehavior extends Behavior implements ILookBehavior, Helper {
-
-    public static final LookBehavior INSTANCE = new LookBehavior();
+public final class LookBehavior extends Behavior implements ILookBehavior {
 
     /**
      * Target's values are as follows:
@@ -49,7 +46,9 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
      */
     private float lastYaw;
 
-    private LookBehavior() {}
+    public LookBehavior(Baritone baritone) {
+        super(baritone);
+    }
 
     @Override
     public void updateTarget(Rotation target, boolean force) {
@@ -64,28 +63,29 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
         }
 
         // Whether or not we're going to silently set our angles
-        boolean silent = Baritone.settings().antiCheatCompatibility.get();
+        boolean silent = Baritone.settings().antiCheatCompatibility.get() && !this.force;
 
         switch (event.getState()) {
             case PRE: {
                 if (this.force) {
-                    player().rotationYaw = this.target.getYaw();
-                    float oldPitch = player().rotationPitch;
+                    ctx.player().rotationYaw = this.target.getYaw();
+                    float oldPitch = ctx.player().rotationPitch;
                     float desiredPitch = this.target.getPitch();
-                    player().rotationPitch = desiredPitch;
+                    ctx.player().rotationPitch = desiredPitch;
                     if (desiredPitch == oldPitch) {
                         nudgeToLevel();
                     }
                     this.target = null;
-                } else if (silent) {
-                    this.lastYaw = player().rotationYaw;
-                    player().rotationYaw = this.target.getYaw();
+                }
+                if (silent) {
+                    this.lastYaw = ctx.player().rotationYaw;
+                    ctx.player().rotationYaw = this.target.getYaw();
                 }
                 break;
             }
             case POST: {
-                if (!this.force && silent) {
-                    player().rotationYaw = this.lastYaw;
+                if (silent) {
+                    ctx.player().rotationYaw = this.lastYaw;
                     this.target = null;
                 }
                 break;
@@ -98,31 +98,25 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
     @Override
     public void onPlayerRotationMove(RotationMoveEvent event) {
         if (this.target != null && !this.force) {
-            switch (event.getState()) {
-                case PRE:
-                    this.lastYaw = player().rotationYaw;
-                    player().rotationYaw = this.target.getYaw();
-                    break;
-                case POST:
-                    player().rotationYaw = this.lastYaw;
 
-                    // 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.get() && event.getType() == RotationMoveEvent.Type.MOTION_UPDATE) {
-                        this.target = null;
-                    }
-                    break;
-                default:
-                    break;
+            event.setYaw(this.target.getYaw());
+
+            // 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.get() && event.getType() == RotationMoveEvent.Type.MOTION_UPDATE) {
+                this.target = null;
             }
         }
     }
 
+    /**
+     * Nudges the player's pitch to a regular level. (Between {@code -20} and {@code 10}, increments are by {@code 1})
+     */
     private void nudgeToLevel() {
-        if (player().rotationPitch < -20) {
-            player().rotationPitch++;
-        } else if (player().rotationPitch > 10) {
-            player().rotationPitch--;
+        if (ctx.player().rotationPitch < -20) {
+            ctx.player().rotationPitch++;
+        } else if (ctx.player().rotationPitch > 10) {
+            ctx.player().rotationPitch--;
         }
     }
 }

src/main/java/baritone/behavior/LookBehaviorUtils.java

@@ -1,139 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.behavior;
-
-import baritone.api.utils.Rotation;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
-import baritone.utils.RayTraceUtils;
-import baritone.utils.Utils;
-import net.minecraft.block.BlockFire;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.util.math.*;
-
-import java.util.Optional;
-
-import static baritone.utils.Utils.DEG_TO_RAD;
-
-public final class LookBehaviorUtils implements Helper {
-
-    /**
-     * Offsets from the root block position to the center of each side.
-     */
-    private static final Vec3d[] BLOCK_SIDE_MULTIPLIERS = new Vec3d[]{
-            new Vec3d(0.5, 0, 0.5), // Down
-            new Vec3d(0.5, 1, 0.5), // Up
-            new Vec3d(0.5, 0.5, 0), // North
-            new Vec3d(0.5, 0.5, 1), // South
-            new Vec3d(0, 0.5, 0.5), // West
-            new Vec3d(1, 0.5, 0.5)  // East
-    };
-
-    /**
-     * Calculates a vector given a rotation array
-     *
-     * @param rotation {@link LookBehavior#target}
-     * @return vector of the rotation
-     */
-    public static Vec3d calcVec3dFromRotation(Rotation rotation) {
-        float f = MathHelper.cos(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
-        float f1 = MathHelper.sin(-rotation.getYaw() * (float) DEG_TO_RAD - (float) Math.PI);
-        float f2 = -MathHelper.cos(-rotation.getPitch() * (float) DEG_TO_RAD);
-        float f3 = MathHelper.sin(-rotation.getPitch() * (float) DEG_TO_RAD);
-        return new Vec3d((double) (f1 * f2), (double) f3, (double) (f * f2));
-    }
-
-    public static Optional<Rotation> reachable(BlockPos pos) {
-        if (pos.equals(getSelectedBlock().orElse(null))) {
-            /*
-             * why add 0.0001?
-             * to indicate that we actually have a desired pitch
-             * the way we indicate that the pitch can be whatever and we only care about the yaw
-             * is by setting the desired pitch to the current pitch
-             * setting the desired pitch to the current pitch + 0.0001 means that we do have a desired pitch, it's
-             * just what it currently is
-             */
-            return Optional.of(new Rotation(mc.player.rotationYaw, mc.player.rotationPitch + 0.0001f));
-        }
-        Optional<Rotation> possibleRotation = reachableCenter(pos);
-        //System.out.println("center: " + possibleRotation);
-        if (possibleRotation.isPresent()) {
-            return possibleRotation;
-        }
-
-        IBlockState state = BlockStateInterface.get(pos);
-        AxisAlignedBB aabb = state.getBoundingBox(mc.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(pos, new Vec3d(pos).add(xDiff, yDiff, zDiff));
-            if (possibleRotation.isPresent()) {
-                return possibleRotation;
-            }
-        }
-        return Optional.empty();
-    }
-
-    /**
-     * Checks if coordinate is reachable with the given block-face rotation offset
-     *
-     * @param pos
-     * @param offsetPos
-     * @return
-     */
-    protected static Optional<Rotation> reachableOffset(BlockPos pos, Vec3d offsetPos) {
-        Rotation rotation = Utils.calcRotationFromVec3d(mc.player.getPositionEyes(1.0F), offsetPos);
-        RayTraceResult result = RayTraceUtils.rayTraceTowards(rotation);
-        System.out.println(result);
-        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
-            if (result.getBlockPos().equals(pos)) {
-                return Optional.of(rotation);
-            }
-            if (BlockStateInterface.get(pos).getBlock() instanceof BlockFire) {
-                if (result.getBlockPos().equals(pos.down())) {
-                    return Optional.of(rotation);
-                }
-            }
-        }
-        return Optional.empty();
-    }
-
-    /**
-     * Checks if center of block at coordinate is reachable
-     *
-     * @param pos
-     * @return
-     */
-    protected static Optional<Rotation> reachableCenter(BlockPos pos) {
-        return reachableOffset(pos, Utils.calcCenterFromCoords(pos, mc.world));
-    }
-
-    /**
-     * The currently highlighted block.
-     * Updated once a tick by Minecraft.
-     *
-     * @return the position of the highlighted block
-     */
-    public static Optional<BlockPos> getSelectedBlock() {
-        if (mc.objectMouseOver != null && mc.objectMouseOver.typeOfHit == RayTraceResult.Type.BLOCK) {
-            return Optional.of(mc.objectMouseOver.getBlockPos());
-        }
-        return Optional.empty();
-    }
-}

src/main/java/baritone/behavior/MemoryBehavior.java

@@ -17,14 +17,17 @@
 
 package baritone.behavior;
 
+import baritone.Baritone;
 import baritone.api.behavior.IMemoryBehavior;
 import baritone.api.behavior.memory.IRememberedInventory;
 import baritone.api.cache.IWorldData;
+import baritone.api.event.events.BlockInteractEvent;
 import baritone.api.event.events.PacketEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.type.EventState;
-import baritone.cache.WorldProvider;
-import baritone.utils.Helper;
+import baritone.cache.Waypoint;
+import baritone.utils.BlockStateInterface;
+import net.minecraft.block.BlockBed;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
 import net.minecraft.network.play.client.CPacketCloseWindow;
@@ -39,15 +42,15 @@ import java.util.*;
 
 /**
  * @author Brady
- * @since 8/6/2018 9:47 PM
+ * @since 8/6/2018
  */
-public final class MemoryBehavior extends Behavior implements IMemoryBehavior, Helper {
-
-    public static MemoryBehavior INSTANCE = new MemoryBehavior();
+public final class MemoryBehavior extends Behavior implements IMemoryBehavior {
 
     private final Map<IWorldData, WorldDataContainer> worldDataContainers = new HashMap<>();
 
-    private MemoryBehavior() {}
+    public MemoryBehavior(Baritone baritone) {
+        super(baritone);
+    }
 
     @Override
     public synchronized void onPlayerUpdate(PlayerUpdateEvent event) {
@@ -64,7 +67,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
             if (p instanceof CPacketPlayerTryUseItemOnBlock) {
                 CPacketPlayerTryUseItemOnBlock packet = event.cast();
 
-                TileEntity tileEntity = world().getTileEntity(packet.getPos());
+                TileEntity tileEntity = ctx.world().getTileEntity(packet.getPos());
 
                 // Ensure the TileEntity is a container of some sort
                 if (tileEntity instanceof TileEntityLockable) {
@@ -114,19 +117,31 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
         }
     }
 
+    @Override
+    public void onBlockInteract(BlockInteractEvent event) {
+        if (event.getType() == BlockInteractEvent.Type.USE && BlockStateInterface.getBlock(ctx, event.getPos()) instanceof BlockBed) {
+            baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("bed", Waypoint.Tag.BED, event.getPos()));
+        }
+    }
+
+    @Override
+    public void onPlayerDeath() {
+        baritone.getWorldProvider().getCurrentWorld().getWaypoints().addWaypoint(new Waypoint("death", Waypoint.Tag.DEATH, ctx.playerFeet()));
+    }
+
     private Optional<RememberedInventory> getInventoryFromWindow(int windowId) {
         return this.getCurrentContainer().rememberedInventories.values().stream().filter(i -> i.windowId == windowId).findFirst();
     }
 
     private void updateInventory() {
-        getInventoryFromWindow(player().openContainer.windowId).ifPresent(inventory -> {
+        getInventoryFromWindow(ctx.player().openContainer.windowId).ifPresent(inventory -> {
             inventory.items.clear();
-            inventory.items.addAll(player().openContainer.getInventory().subList(0, inventory.size));
+            inventory.items.addAll(ctx.player().openContainer.getInventory().subList(0, inventory.size));
         });
     }
 
     private WorldDataContainer getCurrentContainer() {
-        return this.worldDataContainers.computeIfAbsent(WorldProvider.INSTANCE.getCurrentWorld(), data -> new WorldDataContainer());
+        return this.worldDataContainers.computeIfAbsent(baritone.getWorldProvider().getCurrentWorld(), data -> new WorldDataContainer());
     }
 
     @Override

src/main/java/baritone/behavior/MineBehavior.java

@@ -1,198 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.behavior;
-
-import baritone.Baritone;
-import baritone.api.behavior.IMineBehavior;
-import baritone.api.event.events.TickEvent;
-import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.goals.GoalBlock;
-import baritone.api.pathing.goals.GoalComposite;
-import baritone.api.pathing.goals.GoalTwoBlocks;
-import baritone.cache.CachedChunk;
-import baritone.cache.ChunkPacker;
-import baritone.cache.WorldProvider;
-import baritone.cache.WorldScanner;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
-import net.minecraft.block.Block;
-import net.minecraft.init.Blocks;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.chunk.EmptyChunk;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-/**
- * Mine blocks of a certain type
- *
- * @author leijurv
- */
-public final class MineBehavior extends Behavior implements IMineBehavior, Helper {
-
-    public static final MineBehavior INSTANCE = new MineBehavior();
-
-    private List<Block> mining;
-    private List<BlockPos> locationsCache;
-    private int quantity;
-
-    private MineBehavior() {}
-
-    @Override
-    public void onTick(TickEvent event) {
-        if (event.getType() == TickEvent.Type.OUT) {
-            cancel();
-            return;
-        }
-        if (mining == null) {
-            return;
-        }
-        if (quantity > 0) {
-            Item item = mining.get(0).getItemDropped(mining.get(0).getDefaultState(), new Random(), 0);
-            int curr = player().inventory.mainInventory.stream().filter(stack -> item.equals(stack.getItem())).mapToInt(ItemStack::getCount).sum();
-            System.out.println("Currently have " + curr + " " + item);
-            if (curr >= quantity) {
-                logDirect("Have " + curr + " " + item.getItemStackDisplayName(new ItemStack(item, 1)));
-                cancel();
-                return;
-            }
-        }
-        int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.get();
-        if (mineGoalUpdateInterval != 0) {
-            if (event.getCount() % mineGoalUpdateInterval == 0) {
-                Baritone.INSTANCE.getExecutor().execute(this::rescan);
-            }
-        }
-        updateGoal();
-        PathingBehavior.INSTANCE.revalidateGoal();
-    }
-
-    private void updateGoal() {
-        if (mining == null) {
-            return;
-        }
-        List<BlockPos> locs = locationsCache;
-        if (!locs.isEmpty()) {
-            locs = prune(new ArrayList<>(locs), mining, 64);
-            PathingBehavior.INSTANCE.setGoal(coalesce(locs));
-            PathingBehavior.INSTANCE.path();
-            locationsCache = locs;
-        }
-    }
-
-    private void rescan() {
-        if (mining == null) {
-            return;
-        }
-        List<BlockPos> locs = scanFor(mining, 64);
-        if (locs.isEmpty()) {
-            logDebug("No locations for " + mining + " known, cancelling");
-            mine(0, (String[]) null);
-            return;
-        }
-        locationsCache = locs;
-    }
-
-    public GoalComposite coalesce(List<BlockPos> locs) {
-        return new GoalComposite(locs.stream().map(loc -> {
-            if (!Baritone.settings().forceInternalMining.get()) {
-                return new GoalTwoBlocks(loc);
-            }
-
-            boolean upwardGoal = locs.contains(loc.up()) || (Baritone.settings().internalMiningAirException.get() && BlockStateInterface.getBlock(loc.up()) == Blocks.AIR);
-            boolean downwardGoal = locs.contains(loc.down()) || (Baritone.settings().internalMiningAirException.get() && BlockStateInterface.getBlock(loc.up()) == Blocks.AIR);
-            if (upwardGoal) {
-                if (downwardGoal) {
-                    return new GoalTwoBlocks(loc);
-                } else {
-                    return new GoalBlock(loc);
-                }
-            } else {
-                if (downwardGoal) {
-                    return new GoalBlock(loc.down());
-                } else {
-                    return new GoalTwoBlocks(loc);
-                }
-            }
-        }).toArray(Goal[]::new));
-    }
-
-    public List<BlockPos> scanFor(List<Block> mining, int max) {
-        List<BlockPos> locs = new ArrayList<>();
-        List<Block> uninteresting = new ArrayList<>();
-        //long b = System.currentTimeMillis();
-        for (Block m : mining) {
-            if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(m)) {
-                locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().getCachedWorld().getLocationsOf(ChunkPacker.blockToString(m), 1, 1));
-            } else {
-                uninteresting.add(m);
-            }
-        }
-        //System.out.println("Scan of cached chunks took " + (System.currentTimeMillis() - b) + "ms");
-        if (locs.isEmpty()) {
-            uninteresting = mining;
-        }
-        if (!uninteresting.isEmpty()) {
-            //long before = System.currentTimeMillis();
-            locs.addAll(WorldScanner.INSTANCE.scanLoadedChunks(uninteresting, max, 10, 26));
-            //System.out.println("Scan of loaded chunks took " + (System.currentTimeMillis() - before) + "ms");
-        }
-        return prune(locs, mining, max);
-    }
-
-    public List<BlockPos> prune(List<BlockPos> locs, List<Block> mining, int max) {
-        BlockPos playerFeet = MineBehavior.INSTANCE.playerFeet();
-        locs.sort(Comparator.comparingDouble(playerFeet::distanceSq));
-
-        // remove any that are within loaded chunks that aren't actually what we want
-        locs.removeAll(locs.stream()
-                .filter(pos -> !(MineBehavior.INSTANCE.world().getChunk(pos) instanceof EmptyChunk))
-                .filter(pos -> !mining.contains(BlockStateInterface.get(pos).getBlock()))
-                .collect(Collectors.toList()));
-        if (locs.size() > max) {
-            return locs.subList(0, max);
-        }
-        return locs;
-    }
-
-    @Override
-    public void mine(int quantity, String... blocks) {
-        this.mining = blocks == null || blocks.length == 0 ? null : Arrays.stream(blocks).map(ChunkPacker::stringToBlock).collect(Collectors.toList());
-        this.quantity = quantity;
-        this.locationsCache = new ArrayList<>();
-        rescan();
-        updateGoal();
-    }
-
-    @Override
-    public void mine(int quantity, Block... blocks) {
-        this.mining = blocks == null || blocks.length == 0 ? null : Arrays.asList(blocks);
-        this.quantity = quantity;
-        this.locationsCache = new ArrayList<>();
-        rescan();
-        updateGoal();
-    }
-
-    @Override
-    public void cancel() {
-        mine(0, (String[]) null);
-        PathingBehavior.INSTANCE.cancel();
-    }
-}