original blockpos for comparison

.idea/copyright/Baritone.xml

@@ -1,7 +1,6 @@
 <component name="CopyrightManager">
   <copyright>
-    <option name="keyword" value="This file is part of Baritone" />
-    <option name="notice" value="This file is part of Baritone.&#10;&#10;Baritone is free software: you can redistribute it and/or modify&#10;it under the terms of the GNU Lesser General Public License as published by&#10;the Free Software Foundation, either version 3 of the License, or&#10;(at your option) any later version.&#10;&#10;Baritone is distributed in the hope that it will be useful,&#10;but WITHOUT ANY WARRANTY; without even the implied warranty of&#10;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the&#10;GNU Lesser General Public License for more details.&#10;&#10;You should have received a copy of the GNU Lesser General Public License&#10;along with Baritone.  If not, see &lt;https://www.gnu.org/licenses/&gt;." />
+    <option name="notice" value="This file is part of Baritone.&#10;&#10;Baritone is free software: you can redistribute it and/or modify&#10;it under the terms of the GNU General Public License as published by&#10;the Free Software Foundation, either version 3 of the License, or&#10;(at your option) any later version.&#10;&#10;Baritone is distributed in the hope that it will be useful,&#10;but WITHOUT ANY WARRANTY; without even the implied warranty of&#10;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the&#10;GNU General Public License for more details.&#10;&#10;You should have received a copy of the GNU General Public License&#10;along with Baritone.  If not, see &lt;https://www.gnu.org/licenses/&gt;." />
     <option name="myName" value="Baritone" />
   </copyright>
 </component>

.travis.yml

@@ -1,30 +1 @@
 language: java
-
-sudo: required
-
-services:
-- docker
-
-install:
-- sudo apt-get update
-- sudo apt-get install jshon
-- 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 cp baritone:/code/dist dist
-- ls dist
-- cat dist/checksums.txt
-
-deploy:
-  provider: releases
-  api_key:
-    secure: YOuiXoJNpB4bW89TQoY2IGXg0tqOKls55YMXsSPU6Mx8WzRu8CjjO/A8KA9nGfNrKM+NucjiKr/h53O2Dp2uyy0i0SLvav/G0MaBMeB1NlPRwFopi6tVPNaoZsvr8NW4BIURhspckYLpOTYWnfmOkIv8q7AxrjUZWPKDlq0dte20UxEqUE6msHJ7U9XlKo/4fX40kvWMfwGI2hTyAtL0cRT1QPsd+uW3OQjAPcQj+jKaWld46V8pBK8g9Qde9mo8HC9NBv97zw1bBF1EFkynW569kElHvaS2Opl2QLGaf66guDbpnqDpGHMhQrDdxsZHJ4RksyITn+8A9UArmbkU35BxKqBeQqOWxod2+M0axdLh1pvX43Q1t9n7RiZBf7GvV8vkXL5Sjf8v6Y4LqkJGhvQkTUwpH+0knwrE761DMCtBC34AiWG70D4u7msmhurkflr9kmRHSj/3lyJ1Q2lkt8L+FOAlQBVs64vXTsfgc6Yge7N0O3UD5hCkrDNoz3BzhNBdCkbdxdKCGip71UZgUNkPy9o3ui8jATNj9ypx3+U8ovqP0XWlJqUZmyeXyNGW9NrLeCkRLTlLnZ/dv6OPONa1oAu4TwF1w5A+TGRFZcZjH/PnZKZDQ1OYQOR6drLKRYdr2unvuf5KUKUGqZ7aYtLGhP0rBvGWddRV7DSmX/s=
-  all_branches: true
-  file_glob: true
-  file:
-  - dist/*
-  skip_cleanup: true
-  on:
-    tags: true
-    repo: cabaletta/baritone

Dockerfile

@@ -1,26 +0,0 @@
-FROM debian:jessie
-
-RUN echo 'deb http://deb.debian.org/debian jessie-backports main' > /etc/apt/sources.list.d/jessie-backports.list
-
-ENV DEBIAN_FRONTEND noninteractive
-
-RUN apt update -y
-
-RUN apt install --target-release jessie-backports \
-          openjdk-8-jdk \
-          ca-certificates-java \
-          --assume-yes
-
-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
-
-ADD . /code
-
-RUN echo "\nrunClient {\nargs \"--width\",\"128\",\"--height\",\"128\"\n}" >> /code/build.gradle
-
-RUN dpkg -i /code/scripts/xvfb_1.16.4-1_amd64.deb
-
-WORKDIR /code
-
-RUN ./gradlew build

IMPACT.md

@@ -1,86 +1,16 @@
 # 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
+Baritone will be in Impact 4.4 with nice integrations with its utility modules, but if you're impatient you can run Baritone on top of Impact 4.3 right now.
 
-## Acquiring a build of Baritone
-There are 3 methods of acquiring a build of Baritone (While it is still in development)
+You can either build Baritone yourself, or download the jar from September 4 from <a href="https://www.dropbox.com/s/imc6xwwpwsh3i0y/baritone-1.0.0.jar?dl=0">here</a>
 
-### Official Build (Not always up to date)
-Download the "official" jar (as of commit <a href="https://github.com/cabaletta/baritone/commit/61cf103df451a5aafa6bfbe5ed089043212f0b42">61cf103</a>,
-built on September 24) from <a href="https://www.dropbox.com/s/imc6xwwpwsh3i0y/baritone-1.0.0.jar?dl=0">here</a>.
+To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu.
 
-### 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``
+Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0.0/baritone-1.0.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0.0` in libraries first.
 
-### 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>.
+Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json` or copy your existing installation and rename the version folder, json, and id in the json.
 
-## 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``
+- Add the Baritone tweak class to line 7 "minecraftArguments" like so: `"minecraftArguments": " ... --tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine",`. You need the Optifine tweaker even though there is no Optifine involved, for reasons I don't quite understand.
+- Add the Baritone library. Insert `{ "name": "cabaletta:baritone:1.0.0" },` between Impact and ClientAPI, which should be between lines 15 and 16.
 
-## 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>.
+Restart the Minecraft launcher, then load Impact 4.3 as normal, and it should now include Baritone.

LICENSE

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

LICENSE.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    Baritone  Copyright (C) 2018  Cabaletta
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,29 +1,14 @@
 # Baritone
 [![Build Status](https://travis-ci.com/cabaletta/baritone.svg?branch=master)](https://travis-ci.com/cabaletta/baritone)
-[![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)
 
-<!---
-Plutie's jenkins is dead right now, so here's the old badge that was used:
-[![Build Status](https://plutiejenkins.leijurv.com/job/baritone/badge/icon)](https://plutiejenkins.leijurv.com/job/baritone/lastSuccessfulBuild/)
---->
+A Minecraft bot. 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.
 
-Unofficial Jenkins: [![Jenkins Status](https://img.shields.io/badge/jenkins-offline-red.svg)]()
+<a href="https://github.com/cabaletta/baritone/blob/master/FEATURES.md">Features</a>
 
-A Minecraft pathfinder bot. 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)
-
-There's also some useful information down below
+<a href="https://github.com/cabaletta/baritone/blob/master/IMPACT.md">Baritone + Impact</a>
 
 # Setup
-
-## IntelliJ's Gradle UI
 - Open the project in IntelliJ as a Gradle project
 - Run the Gradle task `setupDecompWorkspace`
 - Run the Gradle task `genIntellijRuns`
@@ -47,30 +32,26 @@ $ gradlew genIntellijRuns
 ```
 
 # Chat control
-[Defined Here](src/main/java/baritone/utils/ExampleBaritoneControl.java)
+<a href="https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java">Defined here</a>
 
 Quick start example: `thisway 1000` or `goal 70` to set the goal, `path` to actually start pathing. Also try `mine diamond_ore`. `cancel` to cancel.
 
 # API example
 
 ```
-BaritoneAPI.getSettings().allowSprint.value = true;
-BaritoneAPI.getSettings().pathTimeoutMS.value = 2000L;
+Baritone.settings().allowSprint.value = true;
+Baritone.settings().pathTimeoutMS.value = 2000L;
 
-BaritoneAPI.getPathingBehavior().setGoal(new GoalXZ(10000, 20000));
-BaritoneAPI.getPathingBehavior().path();
+PathingBehavior.INSTANCE.setGoal(new GoalXZ(10000, 20000));
+PathingBehavior.INSTANCE.path();
 ```
 
 # FAQ
 
 ## Can I use Baritone as a library in my hacked client?
 
-Sure! (As long as usage is in compliance with the LGPL 3 License)
+Sure! (As long as usage is in compliance with the GPL 3 License)
 
 ## How is it so fast?
 
-Magic. (Hours of [Leijurv](https://github.com/leijurv) enduring excruciating pain)
-
-## Why is it called Baritone?
-
-It's named for FitMC's deep sultry voice. 
+Magic

build.gradle

@@ -2,21 +2,21 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 group 'baritone'
-version '0.0.3'
+version '1.0.0'
 
 buildscript {
     repositories {
@@ -87,5 +87,5 @@ mixin {
 }
 
 jar {
-    from sourceSets.launch.output, sourceSets.api.output
+    from sourceSets.launch.output
 }

proguard.pro

@@ -1,28 +1,29 @@
--injars baritone-0.0.2.jar
+-injars baritone-1.0.0.jar
 -outjars Obfuscated
 
 
 -keepattributes Signature
 -keepattributes *Annotation*
 
--optimizationpasses 5
+-optimizationpasses 20
 -verbose
 
 -allowaccessmodification # anything not kept can be changed from public to private and inlined etc
+-mergeinterfacesaggressively
 -overloadaggressively
 -dontusemixedcaseclassnames
 
-# instead of obfing to a, b, c, obf to baritone.a, baritone.b, baritone.c so as to not conflict with minecraft's obfd classes
+# instead of obfing to a, b, c, obf to baritone.a, baritone.b, baritone.c so as to not conflict with mcp
 -flattenpackagehierarchy
 -repackageclasses 'baritone'
 
 #-keep class baritone.behavior.** { *; }
--keep class baritone.api.** { *; }
+#-keep class baritone.api.** { *; }
 #-keep class baritone.* { *; }
 #-keep class baritone.pathing.goals.** { *; }
 
 # setting names are reflected from field names, so keep field names
--keepclassmembers class baritone.api.Settings {
+-keepclassmembers class baritone.Settings {
     public <fields>;    
 }
 
@@ -30,7 +31,7 @@
 -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 '/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/rt.jar'
 
 -libraryjars 'tempLibraries/1.12.2.jar'
 

scripts/build.sh

@@ -1,24 +0,0 @@
-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 "\-keep class baritone.api" > standalone.pro # standalone doesn't keep baritone api
-wget -nv https://www.dropbox.com/s/zmc2l3jnwdvzvak/tempLibraries.zip?dl=1 # i'm sorry
-mv tempLibraries.zip?dl=1 tempLibraries.zip
-unzip tempLibraries.zip
-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 ..

settings.gradle

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -1,99 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api;
-
-import baritone.api.behavior.*;
-import baritone.api.cache.IWorldProvider;
-
-/**
- * API exposure for various things implemented in Baritone.
- * <p>
- * W.I.P
- *
- * @author Brady
- * @since 9/23/2018
- */
-public class BaritoneAPI {
-
-    // General
-    private static final Settings settings = new Settings();
-    private static IWorldProvider worldProvider;
-
-    // Behaviors
-    private static IFollowBehavior followBehavior;
-    private static ILookBehavior lookBehavior;
-    private static IMemoryBehavior memoryBehavior;
-    private static IMineBehavior mineBehavior;
-    private static IPathingBehavior pathingBehavior;
-
-    public static IFollowBehavior getFollowBehavior() {
-        return followBehavior;
-    }
-
-    public static ILookBehavior getLookBehavior() {
-        return lookBehavior;
-    }
-
-    public static IMemoryBehavior getMemoryBehavior() {
-        return memoryBehavior;
-    }
-
-    public static IMineBehavior getMineBehavior() {
-        return mineBehavior;
-    }
-
-    public static IPathingBehavior getPathingBehavior() {
-        return pathingBehavior;
-    }
-
-    public static Settings getSettings() {
-        return settings;
-    }
-
-    public static IWorldProvider getWorldProvider() {
-        return worldProvider;
-    }
-
-    /**
-     * FOR INTERNAL USE ONLY
-     */
-    public static void registerProviders(
-            IWorldProvider worldProvider
-    ) {
-        BaritoneAPI.worldProvider = worldProvider;
-    }
-
-    /**
-     * FOR INTERNAL USE ONLY
-     */
-    // @formatter:off
-    public static void registerDefaultBehaviors(
-            IFollowBehavior  followBehavior,
-            ILookBehavior    lookBehavior,
-            IMemoryBehavior  memoryBehavior,
-            IMineBehavior    mineBehavior,
-            IPathingBehavior pathingBehavior
-    ) {
-        BaritoneAPI.followBehavior  = followBehavior;
-        BaritoneAPI.lookBehavior    = lookBehavior;
-        BaritoneAPI.memoryBehavior  = memoryBehavior;
-        BaritoneAPI.mineBehavior    = mineBehavior;
-        BaritoneAPI.pathingBehavior = pathingBehavior;
-    }
-    // @formatter:on
-}

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

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

src/api/java/baritone/api/behavior/IFollowBehavior.java

@@ -1,44 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior;
-
-import net.minecraft.entity.Entity;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface IFollowBehavior extends IBehavior {
-
-    /**
-     * Set the follow target to the specified entity;
-     *
-     * @param entity The entity to follow
-     */
-    void follow(Entity entity);
-
-    /**
-     * @return The entity that is currently being followed
-     */
-    Entity following();
-
-    /**
-     * Cancels the follow behavior, this will clear the current follow target.
-     */
-    void cancel();
-}

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

@@ -1,39 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior;
-
-import baritone.api.utils.Rotation;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface ILookBehavior extends IBehavior {
-
-    /**
-     * Updates the current {@link ILookBehavior} target to target
-     * the specified rotations on the next tick. If force is {@code true},
-     * then freeLook will be overriden and angles will be set regardless.
-     * If any sort of block interaction is required, force should be {@code true},
-     * otherwise, it should be {@code false};
-     *
-     * @param rotation The target rotations
-     * @param force Whether or not to "force" the rotations
-     */
-    void updateTarget(Rotation rotation, boolean force);
-}

src/api/java/baritone/api/behavior/IMemoryBehavior.java

@@ -1,36 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior;
-
-import baritone.api.behavior.memory.IRememberedInventory;
-import net.minecraft.util.math.BlockPos;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface IMemoryBehavior extends IBehavior {
-
-    /**
-     * Gets a remembered inventory by its block position.
-     *
-     * @param pos The position of the container block
-     * @return The remembered inventory
-     */
-    IRememberedInventory getInventoryByPos(BlockPos pos);
-}

src/api/java/baritone/api/behavior/IMineBehavior.java

@@ -1,70 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior;
-
-import net.minecraft.block.Block;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface IMineBehavior extends IBehavior {
-
-    /**
-     * Begin to search for and mine the specified blocks until
-     * the number of specified items to get from the blocks that
-     * are mined. This is based on the first target block to mine.
-     *
-     * @param quantity The number of items to get from blocks mined
-     * @param blocks The blocks to mine
-     */
-    void mine(int quantity, String... blocks);
-
-    /**
-     * Begin to search for and mine the specified blocks until
-     * the number of specified items to get from the blocks that
-     * are mined. This is based on the first target block to mine.
-     *
-     * @param quantity The number of items to get from blocks mined
-     * @param blocks The blocks to mine
-     */
-    void mine(int quantity, Block... blocks);
-
-    /**
-     * Begin to search for and mine the specified blocks.
-     *
-     * @param blocks The blocks to mine
-     */
-    default void mine(String... blocks) {
-        this.mine(0, blocks);
-    }
-
-    /**
-     * Begin to search for and mine the specified blocks.
-     *
-     * @param blocks The blocks to mine
-     */
-    default void mine(Block... blocks) {
-        this.mine(0, blocks);
-    }
-
-    /**
-     * Cancels the current mining task
-     */
-    void cancel();
-}

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

@@ -1,68 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior;
-
-import baritone.api.pathing.goals.Goal;
-
-import java.util.Optional;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface IPathingBehavior extends IBehavior {
-
-    /**
-     * Returns the estimated remaining ticks in the current pathing
-     * segment. Given that the return type is an optional, {@link Optional#empty()}
-     * will be returned in the case that there is no current segment being pathed.
-     *
-     * @return The estimated remaining ticks in the current segment.
-     */
-    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.
-     */
-    void cancel();
-}

src/api/java/baritone/api/behavior/memory/IRememberedInventory.java

@@ -1,39 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.behavior.memory;
-
-import net.minecraft.item.ItemStack;
-
-import java.util.List;
-
-/**
- * @author Brady
- * @since 9/23/2018
- */
-public interface IRememberedInventory {
-
-    /**
-     * @return The contents of this inventory
-     */
-    List<ItemStack> getContents();
-
-    /**
-     * @return The number of slots in this inventory
-     */
-    int getSize();
-}

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

@@ -1,49 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-/**
- * @author Brady
- * @since 9/24/2018
- */
-public interface ICachedRegion extends IBlockTypeAccess {
-
-    /**
-     * Returns whether or not the block at the specified X and Z coordinates
-     * is cached in this world. Similar to {@link ICachedWorld#isCached(int, int)},
-     * 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
-     */
-    boolean isCached(int blockX, int blockZ);
-
-    /**
-     * The X coordinate of this region
-     */
-    int getX();
-
-    /**
-     * The Z coordinate of this region
-     */
-    int getZ();
-}

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

@@ -1,82 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.chunk.Chunk;
-
-import java.util.LinkedList;
-
-/**
- * @author Brady
- * @since 9/24/2018
- */
-public interface ICachedWorld {
-
-    /**
-     * Returns the region at the specified region coordinates
-     *
-     * @param regionX The region X coordinate
-     * @param regionZ The region Z coordinate
-     * @return The region located at the specified coordinates
-     */
-    ICachedRegion getRegion(int regionX, int regionZ);
-
-    /**
-     * Queues the specified chunk for packing. This entails reading the contents
-     * of the chunk, then packing the data into the 2-bit format, and storing that
-     * in this cached world.
-     *
-     * @param chunk The chunk to pack and store
-     */
-    void queueForPacking(Chunk chunk);
-
-    /**
-     * Returns whether or not the block at the specified X and Z coordinates
-     * is cached in this world.
-     *
-     * @param blockX The block X coordinate
-     * @param blockZ The block Z coordinate
-     * @return Whether or not the specified XZ location is cached
-     */
-    boolean isCached(int blockX, int blockZ);
-
-    /**
-     * Scans the cached chunks for location of the specified special block. The
-     * 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 maxRegionDistanceSq The maximum region distance, squared
-     * @return The locations found that match the special block
-     */
-    LinkedList<BlockPos> getLocationsOf(String block, int maximum, int maxRegionDistanceSq);
-
-    /**
-     * Reloads all of the cached regions in this world from disk. Anything that is not saved
-     * will be lost. This operation does not execute in a new thread by default.
-     */
-    void reloadAllFromDisk();
-
-    /**
-     * Saves all of the cached regions in this world to disk. This operation does not execute
-     * in a new thread by default.
-     */
-    void save();
-}

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

@@ -1,111 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-import net.minecraft.util.math.BlockPos;
-import org.apache.commons.lang3.ArrayUtils;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * A marker for a position in the world.
- *
- * @author Brady
- * @since 9/24/2018
- */
-public interface IWaypoint {
-
-    /**
-     * @return The label for this waypoint
-     */
-    String getName();
-
-    /**
-     * Returns the tag for this waypoint. The tag is a category
-     * for the waypoint in a sense, it describes the source of
-     * the waypoint.
-     *
-     * @return The waypoint tag
-     */
-    Tag getTag();
-
-    /**
-     * Returns the unix epoch time in milliseconds that this waypoint
-     * was created. This value should only be set once, when the waypoint
-     * is initially created, and not when it is being loaded from file.
-     *
-     * @return The unix epoch milliseconds that this waypoint was created
-     */
-    long getCreationTimestamp();
-
-    /**
-     * Returns the actual block position of this waypoint.
-     *
-     * @return The block position of this waypoint
-     */
-    BlockPos getLocation();
-
-    enum Tag {
-
-        /**
-         * Tag indicating a position explictly marked as a home base
-         */
-        HOME("home", "base"),
-
-        /**
-         * Tag indicating a position that the local player has died at
-         */
-        DEATH("death"),
-
-        /**
-         * Tag indicating a bed position
-         */
-        BED("bed", "spawn"),
-
-        /**
-         * Tag indicating that the waypoint was user-created
-         */
-        USER("user");
-
-        /**
-         * A list of all of the
-         */
-        private static final List<Tag> TAG_LIST = Collections.unmodifiableList(Arrays.asList(Tag.values()));
-
-        /**
-         * The names for the tag, anything that the tag can be referred to as.
-         */
-        private final String[] names;
-
-        Tag(String... names) {
-            this.names = names;
-        }
-
-        /**
-         * Finds a tag from one of the names that could be used to identify said tag.
-         *
-         * @param name The name of the tag
-         * @return The tag, if one is found, otherwise, {@code null}
-         */
-        public static Tag fromString(String name) {
-            return TAG_LIST.stream().filter(tag -> ArrayUtils.contains(tag.names, name.toLowerCase())).findFirst().orElse(null);
-        }
-    }
-}

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

@@ -1,68 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-import java.util.Set;
-
-/**
- * @author Brady
- * @since 9/24/2018
- */
-public interface IWaypointCollection {
-
-    /**
-     * Adds a waypoint to this collection
-     *
-     * @param waypoint The waypoint
-     */
-    void addWaypoint(IWaypoint waypoint);
-
-    /**
-     * Removes a waypoint from this collection
-     *
-     * @param waypoint The waypoint
-     */
-    void removeWaypoint(IWaypoint waypoint);
-
-    /**
-     * Gets the most recently created waypoint by the specified {@link IWaypoint.Tag}
-     *
-     * @param tag The tag
-     * @return The most recently created waypoint with the specified tag
-     */
-    IWaypoint getMostRecentByTag(IWaypoint.Tag tag);
-
-    /**
-     * 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
-     */
-    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
-     */
-    Set<IWaypoint> getAllWaypoints();
-}

src/api/java/baritone/api/cache/IWorldData.java

@@ -1,39 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-/**
- * @author Brady
- * @since 9/24/2018
- */
-public interface IWorldData {
-
-    /**
-     * Returns the cached world for this world. A cached world is a simplified format
-     * of a regular world, intended for use on multiplayer servers where chunks are not
-     * traditionally stored to disk, allowing for long distance pathing with minimal disk usage.
-     */
-    ICachedWorld getCachedWorld();
-
-    /**
-     * Returns the waypoint collection for this world.
-     *
-     * @return The waypoint collection for this world
-     */
-    IWaypointCollection getWaypoints();
-}

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

@@ -1,32 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.cache;
-
-/**
- * @author Brady
- * @since 9/24/2018
- */
-public interface IWorldProvider {
-
-    /**
-     * Returns the data of the currently loaded world
-     *
-     * @return The current world data
-     */
-    IWorldData getCurrentWorld();
-}

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

@@ -1,75 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.event.events;
-
-import baritone.api.event.events.type.EventState;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
-
-/**
- * @author Brady
- * @since 8/21/2018
- */
-public final class RotationMoveEvent {
-
-    /**
-     * The type of event
-     */
-    private final Type type;
-
-    /**
-     * The state of the event
-     */
-    private final EventState state;
-
-    public RotationMoveEvent(EventState state, Type type) {
-        this.state = state;
-        this.type = type;
-    }
-
-    /**
-     * @return The state of the event
-     */
-    public final EventState getState() {
-        return this.state;
-    }
-
-    /**
-     * @return The type of the event
-     */
-    public final Type getType() {
-        return this.type;
-    }
-
-    public enum Type {
-
-        /**
-         * Called when the player's motion is updated.
-         *
-         * @see Entity#moveRelative(float, float, float, float)
-         */
-        MOTION_UPDATE,
-
-        /**
-         * Called when the player jumps.
-         *
-         * @see EntityLivingBase#jump
-         */
-        JUMP
-    }
-}

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

@@ -1,49 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.pathing.goals;
-
-import baritone.api.BaritoneAPI;
-
-public class GoalAxis implements Goal {
-
-    private static final double SQRT_2_OVER_2 = Math.sqrt(2) / 2;
-
-    @Override
-    public boolean isInGoal(int x, int y, int z) {
-        return y == BaritoneAPI.getSettings().axisHeight.get() && (x == 0 || z == 0 || Math.abs(x) == Math.abs(z));
-    }
-
-    @Override
-    public double heuristic(int x0, int y, int z0) {
-        int x = Math.abs(x0);
-        int z = Math.abs(z0);
-
-        int shrt = Math.min(x, z);
-        int lng = Math.max(x, z);
-        int diff = lng - shrt;
-
-        double flatAxisDistance = Math.min(x, Math.min(z, diff * SQRT_2_OVER_2));
-
-        return flatAxisDistance * BaritoneAPI.getSettings().costHeuristic.get() + GoalYLevel.calculate(BaritoneAPI.getSettings().axisHeight.get(), y);
-    }
-
-    @Override
-    public String toString() {
-        return "GoalAxis";
-    }
-}

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

@@ -1,112 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.utils;
-
-/**
- * @author Brady
- * @since 9/25/2018
- */
-public class Rotation {
-
-    /**
-     * The yaw angle of this Rotation
-     */
-    private float yaw;
-
-    /**
-     * The pitch angle of this Rotation
-     */
-    private float pitch;
-
-    public Rotation(float yaw, float pitch) {
-        this.yaw = yaw;
-        this.pitch = pitch;
-    }
-
-    /**
-     * @return The yaw of this rotation
-     */
-    public float getYaw() {
-        return this.yaw;
-    }
-
-    /**
-     * @return The pitch of this rotation
-     */
-    public float getPitch() {
-        return this.pitch;
-    }
-
-    /**
-     * Adds the yaw/pitch of the specified rotations to this
-     * rotation's yaw/pitch, and returns the result.
-     *
-     * @param other Another rotation
-     * @return The result from adding the other rotation to this rotation
-     */
-    public Rotation add(Rotation other) {
-        return new Rotation(
-                this.yaw + other.yaw,
-                this.pitch + other.pitch
-        );
-    }
-
-    /**
-     * Subtracts the yaw/pitch of the specified rotations from this
-     * rotation's yaw/pitch, and returns the result.
-     *
-     * @param other Another rotation
-     * @return The result from subtracting the other rotation from this rotation
-     */
-    public Rotation subtract(Rotation other) {
-        return new Rotation(
-                this.yaw - other.yaw,
-                this.pitch - other.pitch
-        );
-    }
-
-    /**
-     * @return A copy of this rotation with the pitch clamped
-     */
-    public Rotation clamp() {
-        return new Rotation(
-                this.yaw,
-                RotationUtils.clampPitch(this.pitch)
-        );
-    }
-
-    /**
-     * @return A copy of this rotation with the yaw normalized
-     */
-    public Rotation normalize() {
-        return new Rotation(
-                RotationUtils.normalizeYaw(this.yaw),
-                this.pitch
-        );
-    }
-
-    /**
-     * @return A copy of this rotation with the pitch clamped and the yaw normalized
-     */
-    public Rotation normalizeAndClamp() {
-        return new Rotation(
-                RotationUtils.normalizeYaw(this.yaw),
-                RotationUtils.clampPitch(this.pitch)
-        );
-    }
-}

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

@@ -1,54 +0,0 @@
-/*
- * This file is part of Baritone.
- *
- * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Baritone is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package baritone.api.utils;
-
-/**
- * @author Brady
- * @since 9/25/2018
- */
-public final class RotationUtils {
-
-    private RotationUtils() {}
-
-    /**
-     * 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/launch/java/baritone/launch/BaritoneTweaker.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/launch/java/baritone/launch/BaritoneTweakerForge.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/launch/java/baritone/launch/BaritoneTweakerOptifine.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,33 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,33 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,23 +2,23 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.launch.mixins;
 
 import baritone.Baritone;
-import baritone.api.event.events.RotationMoveEvent;
+import baritone.api.event.events.RelativeMoveEvent;
 import baritone.api.event.events.type.EventState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.entity.Entity;
@@ -41,7 +41,7 @@ public class MixinEntity {
     private void preMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
         Entity _this = (Entity) (Object) this;
         if (_this == Minecraft.getMinecraft().player)
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent(EventState.PRE, RotationMoveEvent.Type.MOTION_UPDATE));
+            Baritone.INSTANCE.getGameEventHandler().onPlayerRelativeMove(new RelativeMoveEvent(EventState.PRE));
     }
 
     @Inject(
@@ -51,6 +51,6 @@ public class MixinEntity {
     private void postMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
         Entity _this = (Entity) (Object) this;
         if (_this == Minecraft.getMinecraft().player)
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent(EventState.POST, RotationMoveEvent.Type.MOTION_UPDATE));
+            Baritone.INSTANCE.getGameEventHandler().onPlayerRelativeMove(new RelativeMoveEvent(EventState.POST));
     }
 }

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

@@ -1,57 +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.launch.mixins;
-
-import baritone.Baritone;
-import baritone.api.event.events.RotationMoveEvent;
-import baritone.api.event.events.type.EventState;
-import net.minecraft.client.Minecraft;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
-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.callback.CallbackInfo;
-
-/**
- * @author Brady
- * @since 9/10/2018
- */
-@Mixin(EntityLivingBase.class)
-public class MixinEntityLivingBase {
-
-    @Inject(
-            method = "jump",
-            at = @At("HEAD")
-    )
-    private void preJump(CallbackInfo ci) {
-        Entity _this = (Entity) (Object) this;
-        if (_this == Minecraft.getMinecraft().player)
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent(EventState.PRE, RotationMoveEvent.Type.JUMP));
-    }
-
-    @Inject(
-            method = "jump",
-            at = @At("RETURN")
-    )
-    private void postJump(CallbackInfo ci) {
-        Entity _this = (Entity) (Object) this;
-        if (_this == Minecraft.getMinecraft().player)
-            Baritone.INSTANCE.getGameEventHandler().onPlayerRotationMove(new RotationMoveEvent(EventState.POST, RotationMoveEvent.Type.JUMP));
-    }
-}

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/launch/java/baritone/launch/mixins/MixinGameSettings.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 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.settings.GameSettings;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * @author Brady
+ * @since 8/1/2018 12:28 AM
+ */
+@Mixin(GameSettings.class)
+public class MixinGameSettings {
+
+    @Redirect(
+            method = "isKeyDown",
+            at = @At(
+                    value = "INVOKE",
+                    target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z",
+                    remap = false
+            )
+    )
+    private static boolean isKeyDown(int keyCode) {
+        return Baritone.INSTANCE.getInputOverrideHandler().isKeyDown(keyCode);
+    }
+}

src/launch/java/baritone/launch/mixins/MixinGuiContainer.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * @author Brady
+ * @since 7/31/2018 10:47 PM
+ */
+@Mixin(GuiContainer.class)
+public class MixinGuiContainer {
+
+    @Redirect(
+            method = {
+                    "mouseClicked",
+                    "mouseReleased"
+            },
+            at = @At(
+                    value = "INVOKE",
+                    target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z",
+                    remap = false
+            )
+    )
+    private boolean isKeyDown(int keyCode) {
+        return Baritone.INSTANCE.getInputOverrideHandler().isKeyDown(keyCode);
+    }
+}

src/launch/java/baritone/launch/mixins/MixinGuiScreen.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 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.gui.GuiScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * @author Brady
+ * @since 7/31/2018 10:38 PM
+ */
+@Mixin(GuiScreen.class)
+public class MixinGuiScreen {
+
+    @Redirect(
+            method = {
+                    "isCtrlKeyDown",
+                    "isShiftKeyDown",
+                    "isAltKeyDown"
+            },
+            at = @At(
+                    value = "INVOKE",
+                    target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z",
+                    remap = false
+            )
+    )
+    private static boolean isKeyDown(int keyCode) {
+        return Baritone.INSTANCE.getInputOverrideHandler().isKeyDown(keyCode);
+    }
+}

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -22,7 +22,7 @@ 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.behavior.impl.PathingBehavior;
 import baritone.utils.ExampleBaritoneControl;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
@@ -85,6 +85,18 @@ public class MixinMinecraft {
         ));
     }
 
+    @Redirect(
+            method = "runTickKeyboard",
+            at = @At(
+                    value = "INVOKE",
+                    target = "org/lwjgl/input/Keyboard.isKeyDown(I)Z",
+                    remap = false
+            )
+    )
+    private boolean Keyboard$isKeyDown(int keyCode) {
+        return Baritone.INSTANCE.getInputOverrideHandler().isKeyDown(keyCode);
+    }
+
     @Inject(
             method = "processKeyBinds",
             at = @At("HEAD")

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -24,10 +24,8 @@ import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.GenericFutureListener;
-import net.minecraft.network.EnumPacketDirection;
 import net.minecraft.network.NetworkManager;
 import net.minecraft.network.Packet;
-import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -44,18 +42,12 @@ public class MixinNetworkManager {
     @Shadow
     private Channel channel;
 
-    @Shadow
-    @Final
-    private EnumPacketDirection direction;
-
     @Inject(
             method = "dispatchPacket",
             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(EventState.PRE, inPacket));
-        }
+        Baritone.INSTANCE.getGameEventHandler().onSendPacket(new PacketEvent(EventState.PRE, inPacket));
     }
 
     @Inject(
@@ -63,9 +55,7 @@ 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(EventState.POST, inPacket));
-        }
+        Baritone.INSTANCE.getGameEventHandler().onSendPacket(new PacketEvent(EventState.POST, inPacket));
     }
 
     @Inject(
@@ -76,8 +66,7 @@ public class MixinNetworkManager {
             )
     )
     private void preProcessPacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {
-        if (this.direction == EnumPacketDirection.CLIENTBOUND) {
-            Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent(EventState.PRE, packet));}
+        Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent(EventState.PRE, packet));
     }
 
     @Inject(
@@ -85,7 +74,7 @@ public class MixinNetworkManager {
             at = @At("RETURN")
     )
     private void postProcessPacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {
-        if (this.channel.isOpen() && this.direction == EnumPacketDirection.CLIENTBOUND) {
+        if (this.channel.isOpen()) {
             Baritone.INSTANCE.getGameEventHandler().onReceivePacket(new PacketEvent(EventState.POST, packet));
         }
     }

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/launch/resources/mixins.baritone.json

@@ -12,9 +12,11 @@
     "MixinBlockPos",
     "MixinChunkProviderServer",
     "MixinEntity",
-    "MixinEntityLivingBase",
     "MixinEntityPlayerSP",
     "MixinEntityRenderer",
+    "MixinGameSettings",
+    "MixinGuiContainer",
+    "MixinGuiScreen",
     "MixinKeyBinding",
     "MixinMinecraft",
     "MixinNetHandlerPlayClient",

src/main/java/baritone/Baritone.java

@@ -2,28 +2,24 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone;
 
-import baritone.api.BaritoneAPI;
-import baritone.api.Settings;
-import baritone.api.event.listener.IGameEventListener;
-import baritone.behavior.*;
-import baritone.cache.WorldProvider;
-import baritone.event.GameEventHandler;
-import baritone.utils.BaritoneAutoTest;
+import baritone.api.event.GameEventHandler;
+import baritone.behavior.Behavior;
+import baritone.behavior.impl.*;
 import baritone.utils.InputOverrideHandler;
 import net.minecraft.client.Minecraft;
 
@@ -32,10 +28,6 @@ import java.io.IOException;
 import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.concurrent.SynchronousQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
 /**
@@ -59,8 +51,6 @@ public enum Baritone {
     private Settings settings;
     private List<Behavior> behaviors;
     private File dir;
-    private ThreadPoolExecutor threadPool;
-
 
     /**
      * List of consumers to be called after Baritone has initialized
@@ -80,16 +70,9 @@ public enum Baritone {
         if (initialized) {
             return;
         }
-        this.threadPool = new ThreadPoolExecutor(4, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
         this.gameEventHandler = new GameEventHandler();
         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();
-
-        BaritoneAPI.registerProviders(WorldProvider.INSTANCE);
-
+        this.settings = new Settings();
         this.behaviors = new ArrayList<>();
         {
             registerBehavior(PathingBehavior.INSTANCE);
@@ -98,19 +81,6 @@ public enum Baritone {
             registerBehavior(LocationTrackingBehavior.INSTANCE);
             registerBehavior(FollowBehavior.INSTANCE);
             registerBehavior(MineBehavior.INSTANCE);
-
-            // TODO: Clean this up
-            // Maybe combine this call in someway with the registerBehavior calls?
-            BaritoneAPI.registerDefaultBehaviors(
-                    FollowBehavior.INSTANCE,
-                    LookBehavior.INSTANCE,
-                    MemoryBehavior.INSTANCE,
-                    MineBehavior.INSTANCE,
-                    PathingBehavior.INSTANCE
-            );
-        }
-        if (BaritoneAutoTest.ENABLE_AUTO_TEST && "true".equals(System.getenv("BARITONE_AUTO_TEST"))) {
-            registerEventListener(new BaritoneAutoTest());
         }
         this.dir = new File(Minecraft.getMinecraft().gameDir, "baritone");
         if (!Files.exists(dir.toPath())) {
@@ -125,40 +95,32 @@ public enum Baritone {
         this.onInitConsumers.forEach(consumer -> consumer.accept(this));
     }
 
-    public boolean isInitialized() {
+    public final boolean isInitialized() {
         return this.initialized;
     }
 
-    public IGameEventListener getGameEventHandler() {
+    public final GameEventHandler getGameEventHandler() {
         return this.gameEventHandler;
     }
 
-    public InputOverrideHandler getInputOverrideHandler() {
+    public final InputOverrideHandler getInputOverrideHandler() {
         return this.inputOverrideHandler;
     }
 
-    public List<Behavior> getBehaviors() {
+    public final List<Behavior> getBehaviors() {
         return this.behaviors;
     }
 
-    public Executor getExecutor() {
-        return threadPool;
-    }
-
     public void registerBehavior(Behavior behavior) {
         this.behaviors.add(behavior);
-        this.registerEventListener(behavior);
+        this.gameEventHandler.registerEventListener(behavior);
     }
 
-    public void registerEventListener(IGameEventListener listener) {
-        this.gameEventHandler.registerEventListener(listener);
-    }
-
-    public boolean isActive() {
+    public final boolean isActive() {
         return this.active;
     }
 
-    public Settings getSettings() {
+    public final Settings getSettings() {
         return this.settings;
     }
 
@@ -166,11 +128,11 @@ public enum Baritone {
         return Baritone.INSTANCE.settings; // yolo
     }
 
-    public File getDir() {
+    public final File getDir() {
         return this.dir;
     }
 
-    public void registerInitListener(Consumer<Baritone> runnable) {
+    public final void registerInitListener(Consumer<Baritone> runnable) {
         this.onInitConsumers.add(runnable);
     }
 }

src/main/java/baritone/Settings.java

@@ -2,31 +2,26 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api;
+package baritone;
 
-import net.minecraft.client.Minecraft;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
-import net.minecraft.util.text.ITextComponent;
 
-import java.awt.*;
 import java.lang.reflect.Field;
 import java.util.*;
-import java.util.List;
-import java.util.function.Consumer;
 
 /**
  * Baritone's settings
@@ -34,7 +29,6 @@ import java.util.function.Consumer;
  * @author leijurv
  */
 public class Settings {
-
     /**
      * Allow Baritone to break blocks
      */
@@ -68,20 +62,6 @@ public class Settings {
      */
     public Setting<Boolean> assumeWalkOnWater = new Setting<>(false);
 
-    /**
-     * Assume step functionality; don't jump on an Ascend.
-     */
-    public Setting<Boolean> assumeStep = new Setting<>(false);
-
-    /**
-     * Assume safe walk functionality; don't sneak on a backplace traverse.
-     * <p>
-     * Warning: if you do something janky like sneak-backplace from an ender chest, if this is true
-     * it won't sneak right click, it'll just right click, which means it'll open the chest instead of placing
-     * against it. That's why this defaults to off.
-     */
-    public Setting<Boolean> assumeSafeWalk = new Setting<>(false);
-
     /**
      * Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)
      */
@@ -110,11 +90,6 @@ public class Settings {
      */
     public Setting<Boolean> allowParkour = new Setting<>(false);
 
-    /**
-     * Like parkour, but even more unreliable!
-     */
-    public Setting<Boolean> allowParkourPlace = new Setting<>(false);
-
     /**
      * For example, if you have Mining Fatigue or Haste, adjust the costs of breaking blocks accordingly.
      */
@@ -135,7 +110,7 @@ public class Settings {
      * <p>
      * Finding the optimal path is worth it, so it's the default.
      */
-    public Setting<Double> costHeuristic = new Setting<>(3.5D);
+    public Setting<Double> costHeuristic = this.new <Double>Setting<Double>(3.5D);
 
     // a bunch of obscure internal A* settings that you probably don't want to change
     /**
@@ -145,9 +120,8 @@ public class Settings {
     public Setting<Integer> pathingMaxChunkBorderFetch = new Setting<>(50);
 
     /**
+     * See issue #18
      * Set to 1.0 to effectively disable this feature
-     *
-     * @see <a href="https://github.com/cabaletta/baritone/issues/18">Issue #18</a>
      */
     public Setting<Double> backtrackCostFavoringCoefficient = new Setting<>(0.9);
 
@@ -158,18 +132,17 @@ public class Settings {
     public Setting<Boolean> minimumImprovementRepropagation = new Setting<>(true);
 
     /**
-     * After calculating a path (potentially through cached chunks), artificially cut it off to just the part that is
-     * entirely within currently loaded chunks. Improves path safety because cached chunks are heavily simplified.
-     *
-     * @see <a href="https://github.com/cabaletta/baritone/issues/144">Issue #144</a>
+     * Use a pythagorean metric (as opposed to the more accurate hybrid diagonal / traverse).
+     * You probably don't want this. It roughly triples nodes considered for no real advantage.
      */
-    public Setting<Boolean> cutoffAtLoadBoundary = new Setting<>(false);
+    public Setting<Boolean> pythagoreanMetric = new Setting<>(false);
 
     /**
-     * If a movement's cost increases by more than this amount between calculation and execution (due to changes
-     * in the environment / world), cancel and recalculate
+     * After calculating a path (potentially through cached chunks), artificially cut it off to just the part that is
+     * entirely within currently loaded chunks. Improves path safety because cached chunks are heavily simplified.
+     * See issue #114 for why this is disabled.
      */
-    public Setting<Double> maxCostIncrease = new Setting<>(10D);
+    public Setting<Boolean> cutoffAtLoadBoundary = new Setting<>(false);
 
     /**
      * Stop 5 movements before anything that made the path COST_INF.
@@ -230,12 +203,12 @@ public class Settings {
     /**
      * Pathing can never take longer than this
      */
-    public Setting<Long> pathTimeoutMS = new Setting<>(2000L);
+    public Setting<Number> pathTimeoutMS = new Setting<>(2000L);
 
     /**
      * Planning ahead while executing a segment can never take longer than this
      */
-    public Setting<Long> planAheadTimeoutMS = new Setting<>(4000L);
+    public Setting<Number> planAheadTimeoutMS = new Setting<>(4000L);
 
     /**
      * For debugging, consider nodes much much slower
@@ -245,12 +218,12 @@ public class Settings {
     /**
      * Milliseconds between each node
      */
-    public Setting<Long> slowPathTimeDelayMS = new Setting<>(100L);
+    public Setting<Number> slowPathTimeDelayMS = new Setting<>(100L);
 
     /**
      * The alternative timeout number when slowPath is on
      */
-    public Setting<Long> slowPathTimeoutMS = new Setting<>(40000L);
+    public Setting<Number> slowPathTimeoutMS = new Setting<>(40000L);
 
     /**
      * The big one. Download all chunks in simplified 2-bit format and save them for better very-long-distance pathing.
@@ -322,123 +295,6 @@ public class Settings {
      */
     public Setting<Boolean> prefix = new Setting<>(false);
 
-    /**
-     * {@code true}: can mine blocks when in inventory, chat, or tabbed away in ESC menu
-     * <p>
-     * {@code false}: works on cosmic prisons
-     * <p>
-     * LOL
-     */
-    public Setting<Boolean> leftClickWorkaround = new Setting<>(true);
-
-    /**
-     * Don't stop walking forward when you need to break blocks in your way
-     */
-    public Setting<Boolean> walkWhileBreaking = new Setting<>(true);
-
-    /**
-     * Rescan for the goal once every 5 ticks.
-     * Set to 0 to disable.
-     */
-    public Setting<Integer> mineGoalUpdateInterval = new Setting<>(5);
-
-    /**
-     * Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
-     * <p>
-     * Currently only runs when either MineBehavior or FollowBehavior is active.
-     * <p>
-     * For example, if Baritone is doing "mine iron_ore", the instant it breaks the ore (and it becomes air), that location
-     * is no longer a goal. This means that if this setting is true, it will stop there. If this setting were off, it would
-     * continue with its path, and walk into that location. The tradeoff is if this setting is true, it mines ores much faster
-     * since it doesn't waste any time getting into locations that no longer contain ores, but on the other hand, it misses
-     * some drops, and continues on without ever picking them up.
-     * <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<>(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);
-
-    /**
-     * 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
-     * If the block below is also a goal block, set GoalBlock to the position one down instead of GoalTwoBlocks
-     */
-    public Setting<Boolean> forceInternalMining = new Setting<>(true);
-
-    /**
-     * Modification to the previous setting, only has effect if forceInternalMining is true
-     * If true, only apply the previous setting if the block adjacent to the goal isn't air.
-     */
-    public Setting<Boolean> internalMiningAirException = new Setting<>(true);
-
-    /**
-     * The actual GoalNear is set this distance away from the entity you're following
-     * <p>
-     * For example, set followOffsetDistance to 5 and followRadius to 0 to always stay precisely 5 blocks north of your follow target.
-     */
-    public Setting<Double> followOffsetDistance = new Setting<>(0D);
-
-    /**
-     * The actual GoalNear is set in this direction from the entity you're following
-     */
-    public Setting<Float> followOffsetDirection = new Setting<>(0F);
-
-    /**
-     * The radius (for the GoalNear) of how close to your target position you actually have to be
-     */
-    public Setting<Integer> followRadius = new Setting<>(3);
-
-    /**
-     * The function that is called when Baritone will log to chat. This function can be added to
-     * via {@link Consumer#andThen(Consumer)} or it can completely be overriden via setting
-     * {@link Setting#value};
-     */
-    public Setting<Consumer<ITextComponent>> logger = new Setting<>(Minecraft.getMinecraft().ingameGUI.getChatGUI()::printChatMessage);
-
-    /**
-     * The color of the current path
-     */
-    public Setting<Color> colorCurrentPath = new Setting<>(Color.RED);
-
-    /**
-     * The color of the next path
-     */
-    public Setting<Color> colorNextPath = new Setting<>(Color.MAGENTA);
-
-    /**
-     * The color of the blocks to break
-     */
-    public Setting<Color> colorBlocksToBreak = new Setting<>(Color.RED);
-
-    /**
-     * The color of the blocks to place
-     */
-    public Setting<Color> colorBlocksToPlace = new Setting<>(Color.GREEN);
-
-    /**
-     * The color of the blocks to walk into
-     */
-    public Setting<Color> colorBlocksToWalkInto = new Setting<>(Color.MAGENTA);
-
-    /**
-     * The color of the best path so far
-     */
-    public Setting<Color> colorBestPathSoFar = new Setting<>(Color.BLUE);
-
-    /**
-     * The color of the path to the most recent considered node
-     */
-    public Setting<Color> colorMostRecentConsidered = new Setting<>(Color.CYAN);
-
-    /**
-     * The color of the goal box
-     */
-    public Setting<Color> colorGoalBox = new Setting<>(Color.GREEN);
-
     public final Map<String, Setting<?>> byLowerName;
     public final List<Setting<?>> allSettings;
 
@@ -495,7 +351,7 @@ public class Settings {
                 }
             }
         } catch (IllegalAccessException e) {
-            throw new IllegalStateException(e);
+            throw new RuntimeException(e);
         }
         byLowerName = Collections.unmodifiableMap(tmpByName);
         allSettings = Collections.unmodifiableList(tmpAll);

src/main/java/baritone/api/event/GameEventHandler.java

@@ -2,30 +2,47 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.event;
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.event;
 
 import baritone.Baritone;
 import baritone.api.event.events.*;
 import baritone.api.event.events.type.EventState;
 import baritone.api.event.listener.IGameEventListener;
-import baritone.api.utils.interfaces.Toggleable;
-import baritone.cache.WorldProvider;
+import baritone.chunk.WorldProvider;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
 import baritone.utils.InputOverrideHandler;
+import baritone.utils.interfaces.Toggleable;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.world.chunk.Chunk;
 import org.lwjgl.input.Keyboard;
@@ -109,7 +126,7 @@ public final class GameEventHandler implements IGameEventListener, Helper {
         if (isPostPopulate || isPreUnload) {
             WorldProvider.INSTANCE.ifWorldLoaded(world -> {
                 Chunk chunk = mc.world.getChunk(event.getX(), event.getZ());
-                world.getCachedWorld().queueForPacking(chunk);
+                world.cache.queueForPacking(chunk);
             });
         }
 
@@ -136,11 +153,15 @@ public final class GameEventHandler implements IGameEventListener, Helper {
 
         BlockStateInterface.clearCachedChunk();
 
-        if (event.getState() == EventState.POST) {
-            cache.closeWorld();
-            if (event.getWorld() != null) {
-                cache.initWorld(event.getWorld());
-            }
+        switch (event.getState()) {
+            case PRE:
+                break;
+            case POST:
+                cache.closeWorld();
+                if (event.getWorld() != null) {
+                    cache.initWorld(event.getWorld());
+                }
+                break;
         }
 
         listeners.forEach(l -> {
@@ -169,10 +190,10 @@ public final class GameEventHandler implements IGameEventListener, Helper {
     }
 
     @Override
-    public void onPlayerRotationMove(RotationMoveEvent event) {
+    public void onPlayerRelativeMove(RelativeMoveEvent event) {
         listeners.forEach(l -> {
             if (canDispatch(l)) {
-                l.onPlayerRotationMove(event);
+                l.onPlayerRelativeMove(event);
             }
         });
     }

src/main/java/baritone/api/event/events/BlockInteractEvent.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/main/java/baritone/api/event/events/ItemSlotEvent.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 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.event.events;
+
+import baritone.api.event.listener.IGameEventListener;
+
+/**
+ * Called in some cases where a player's inventory has it's current slot queried.
+ * <p>
+ * @see IGameEventListener#onQueryItemSlotForBlocks()
+ *
+ * @author Brady
+ * @since 8/20/2018
+ */
+public final class ItemSlotEvent {
+
+    /**
+     * The current slot index
+     */
+    private int slot;
+
+    public ItemSlotEvent(int slot) {
+        this.slot = slot;
+    }
+
+    /**
+     * Sets the new slot index that will be used
+     *
+     * @param slot The slot index
+     */
+    public final void setSlot(int slot) {
+        this.slot = slot;
+    }
+
+    /**
+     * @return The current slot index
+     */
+    public final int getSlot() {
+        return this.slot;
+    }
+}

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/main/java/baritone/api/event/events/PathEvent.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -28,6 +28,5 @@ public enum PathEvent {
     AT_GOAL,
     PATH_FINISHED_NEXT_STILL_CALCULATING,
     NEXT_CALC_FAILED,
-    DISCARD_NEXT,
-    CANCELED;
+    DISCARD_NEXT
 }

src/main/java/baritone/api/event/events/PlayerUpdateEvent.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/main/java/baritone/api/event/events/RelativeMoveEvent.java

@@ -0,0 +1,43 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.event.events;
+
+import baritone.api.event.events.type.EventState;
+
+/**
+ * @author Brady
+ * @since 8/21/2018
+ */
+public final class RelativeMoveEvent {
+
+    /**
+     * The state of the event
+     */
+    private final EventState state;
+
+    public RelativeMoveEvent(EventState state) {
+        this.state = state;
+    }
+
+    /**
+     * @return The state of the event
+     */
+    public final EventState getState() {
+        return this.state;
+    }
+}

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -23,22 +23,10 @@ public final class TickEvent {
 
     private final EventState state;
     private final Type type;
-    private final int count;
-
-    private static int overallTickCount;
 
     public TickEvent(EventState state, Type type) {
         this.state = state;
         this.type = type;
-        this.count = incrementCount();
-    }
-
-    private static synchronized int incrementCount() {
-        return overallTickCount++;
-    }
-
-    public int getCount() {
-        return count;
     }
 
     public Type getType() {

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

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

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -31,7 +31,7 @@ public enum EventState {
 
     /**
      * Indicates that whatever movement the event is being
-     * dispatched as a result of has already occurred.
+     * dispatched as a result of has already occured.
      */
     POST
 }

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

@@ -2,16 +2,33 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -58,7 +75,7 @@ public interface AbstractGameEventListener extends IGameEventListener {
     default void onReceivePacket(PacketEvent event) {}
 
     @Override
-    default void onPlayerRotationMove(RotationMoveEvent event) {}
+    default void onPlayerRelativeMove(RelativeMoveEvent event) {}
 
     @Override
     default void onBlockInteract(BlockInteractEvent event) {}

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

@@ -2,16 +2,33 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -26,7 +43,6 @@ import net.minecraft.client.multiplayer.WorldClient;
 import net.minecraft.client.renderer.EntityRenderer;
 import net.minecraft.client.settings.GameSettings;
 import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.network.NetworkManager;
 import net.minecraft.network.Packet;
 import net.minecraft.util.text.ITextComponent;
@@ -92,8 +108,6 @@ public interface IGameEventListener {
      * Runs before a outbound packet is sent
      *
      * @see NetworkManager#dispatchPacket(Packet, GenericFutureListener[])
-     * @see Packet
-     * @see GenericFutureListener
      */
     void onSendPacket(PacketEvent event);
 
@@ -101,19 +115,15 @@ public interface IGameEventListener {
      * Runs before an inbound packet is processed
      *
      * @see NetworkManager#dispatchPacket(Packet, GenericFutureListener[])
-     * @see Packet
-     * @see GenericFutureListener
      */
     void onReceivePacket(PacketEvent event);
 
     /**
      * Run once per game tick from before and after the player's moveRelative method is called
-     * and before and after the player jumps.
      *
      * @see Entity#moveRelative(float, float, float, float)
-     * @see EntityLivingBase#jump()
      */
-    void onPlayerRotationMove(RotationMoveEvent event);
+    void onPlayerRelativeMove(RelativeMoveEvent event);
 
     /**
      * Called when the local player interacts with a block, whether it is breaking or opening/placing.
@@ -127,7 +137,6 @@ public interface IGameEventListener {
      * Called when the local player dies, as indicated by the creation of the {@link GuiGameOver} screen.
      *
      * @see GuiGameOver(ITextComponent)
-     * @see ITextComponent
      */
     void onPlayerDeath();
 

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

@@ -2,30 +2,32 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.behavior;
 
-import baritone.api.behavior.IBehavior;
+import baritone.api.event.listener.AbstractGameEventListener;
+import baritone.utils.Helper;
+import baritone.utils.interfaces.Toggleable;
 
 /**
- * A type of game event listener that can be toggled.
+ * A generic bot behavior.
  *
  * @author Brady
  * @since 8/1/2018 6:29 PM
  */
-public class Behavior implements IBehavior {
+public class Behavior implements AbstractGameEventListener, Toggleable, Helper {
 
     /**
      * Whether or not this behavior is enabled
@@ -39,7 +41,7 @@ public class Behavior implements IBehavior {
      */
     @Override
     public final boolean toggle() {
-        return this.setEnabled(!this.isEnabled());
+        return this.setEnabled(!this.enabled);
     }
 
     /**
@@ -49,17 +51,35 @@ public class Behavior implements IBehavior {
      */
     @Override
     public final boolean setEnabled(boolean enabled) {
-        if (enabled == this.enabled) {
+        boolean newState = getNewState(this.enabled, enabled);
+        if (newState == this.enabled) {
             return this.enabled;
         }
-        if (this.enabled = enabled) {
-            this.onEnable();
+
+        if (this.enabled = newState) {
+            onStart();
         } else {
-            this.onDisable();
+            onCancel();
         }
+
         return this.enabled;
     }
 
+    /**
+     * Function to determine what the new enabled state of this
+     * {@link Behavior} should be given the old state, and the
+     * proposed state. Intended to be overridden by behaviors
+     * that should always be active, given that the bot itself is
+     * active.
+     *
+     * @param oldState      The old state
+     * @param proposedState The proposed state
+     * @return The new  state
+     */
+    public boolean getNewState(boolean oldState, boolean proposedState) {
+        return proposedState;
+    }
+
     /**
      * @return Whether or not this {@link Behavior} is active.
      */
@@ -67,4 +87,14 @@ public class Behavior implements IBehavior {
     public final boolean isEnabled() {
         return this.enabled;
     }
+
+    /**
+     * Called when the state changes from disabled to enabled
+     */
+    public void onStart() {}
+
+    /**
+     * Called when the state changes from enabled to disabled
+     */
+    public void onCancel() {}
 }

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/MineBehavior.java

@@ -1,195 +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.PathEvent;
-import baritone.api.event.events.TickEvent;
-import baritone.api.pathing.goals.Goal;
-import baritone.cache.CachedChunk;
-import baritone.cache.ChunkPacker;
-import baritone.cache.WorldProvider;
-import baritone.cache.WorldScanner;
-import baritone.api.pathing.goals.GoalBlock;
-import baritone.api.pathing.goals.GoalComposite;
-import baritone.api.pathing.goals.GoalTwoBlocks;
-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::updateGoal);
-            }
-        }
-        PathingBehavior.INSTANCE.revalidateGoal();
-    }
-
-    @Override
-    public void onPathEvent(PathEvent event) {
-        updateGoal();
-    }
-
-    private void updateGoal() {
-        if (mining == null) {
-            return;
-        }
-        if (!locationsCache.isEmpty()) {
-            locationsCache = prune(new ArrayList<>(locationsCache), mining, 64);
-            PathingBehavior.INSTANCE.setGoal(coalesce(locationsCache));
-            PathingBehavior.INSTANCE.path();
-        }
-        List<BlockPos> locs = scanFor(mining, 64);
-        if (locs.isEmpty()) {
-            logDebug("No locations for " + mining + " known, cancelling");
-            cancel();
-            return;
-        }
-        locationsCache = locs;
-        PathingBehavior.INSTANCE.setGoal(coalesce(locs));
-        PathingBehavior.INSTANCE.path();
-    }
-
-    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<>();
-        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<>();
-        updateGoal();
-    }
-
-    @Override
-    public void cancel() {
-        mine(0, (String[]) null);
-        PathingBehavior.INSTANCE.cancel();
-    }
-}

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

@@ -0,0 +1,60 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.behavior.impl;
+
+import baritone.api.event.events.TickEvent;
+import baritone.behavior.Behavior;
+import baritone.pathing.goals.GoalNear;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
+
+/**
+ * Follow an entity
+ *
+ * @author leijurv
+ */
+public class FollowBehavior extends Behavior {
+    public static final FollowBehavior INSTANCE = new FollowBehavior();
+
+    private FollowBehavior() {
+    }
+
+    Entity following;
+
+    @Override
+    public void onTick(TickEvent event) {
+        if (event.getType() == TickEvent.Type.OUT) {
+            return;
+        }
+        if (following == null) {
+            return;
+        }
+        // lol this is trashy but it works
+        PathingBehavior.INSTANCE.setGoal(new GoalNear(new BlockPos(following), 3));
+        PathingBehavior.INSTANCE.path();
+    }
+
+    public void follow(Entity follow) {
+        this.following = follow;
+    }
+
+    public void cancel() {
+        PathingBehavior.INSTANCE.cancel();
+        follow(null);
+    }
+}

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

@@ -2,26 +2,26 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.behavior;
+package baritone.behavior.impl;
 
+import baritone.behavior.Behavior;
+import baritone.chunk.Waypoint;
+import baritone.chunk.WorldProvider;
 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;
 
 /**
@@ -33,7 +33,7 @@ import net.minecraft.block.BlockBed;
  * @author Brady
  * @since 8/22/2018
  */
-public final class LocationTrackingBehavior extends Behavior implements Helper {
+public final class LocationTrackingBehavior extends Behavior {
 
     public static final LocationTrackingBehavior INSTANCE = new LocationTrackingBehavior();
 
@@ -42,12 +42,12 @@ public final class LocationTrackingBehavior extends Behavior implements Helper {
     @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()));
+            WorldProvider.INSTANCE.getCurrentWorld().waypoints.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()));
+        WorldProvider.INSTANCE.getCurrentWorld().waypoints.addWaypoint(new Waypoint("death", Waypoint.Tag.DEATH, playerFeet()));
     }
 }

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

@@ -2,33 +2,34 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.behavior;
+package baritone.behavior.impl;
 
 import baritone.Baritone;
-import baritone.api.Settings;
-import baritone.api.behavior.ILookBehavior;
+import baritone.Settings;
 import baritone.api.event.events.PlayerUpdateEvent;
-import baritone.api.event.events.RotationMoveEvent;
-import baritone.api.utils.Rotation;
-import baritone.utils.Helper;
+import baritone.api.event.events.RelativeMoveEvent;
+import baritone.behavior.Behavior;
+import baritone.utils.Rotation;
 
-public final class LookBehavior extends Behavior implements ILookBehavior, Helper {
+public class LookBehavior extends Behavior {
 
     public static final LookBehavior INSTANCE = new LookBehavior();
 
+    private LookBehavior() {}
+
     /**
      * Target's values are as follows:
      * <p>
@@ -49,9 +50,6 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
      */
     private float lastYaw;
 
-    private LookBehavior() {}
-
-    @Override
     public void updateTarget(Rotation target, boolean force) {
         this.target = target;
         this.force = force || !Baritone.settings().freeLook.get();
@@ -69,9 +67,9 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
         switch (event.getState()) {
             case PRE: {
                 if (this.force) {
-                    player().rotationYaw = this.target.getYaw();
+                    player().rotationYaw = this.target.getFirst();
                     float oldPitch = player().rotationPitch;
-                    float desiredPitch = this.target.getPitch();
+                    float desiredPitch = this.target.getSecond();
                     player().rotationPitch = desiredPitch;
                     if (desiredPitch == oldPitch) {
                         nudgeToLevel();
@@ -79,7 +77,7 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
                     this.target = null;
                 } else if (silent) {
                     this.lastYaw = player().rotationYaw;
-                    player().rotationYaw = this.target.getYaw();
+                    player().rotationYaw = this.target.getFirst();
                 }
                 break;
             }
@@ -90,30 +88,25 @@ public final class LookBehavior extends Behavior implements ILookBehavior, Helpe
                 }
                 break;
             }
-            default:
-                break;
         }
     }
 
     @Override
-    public void onPlayerRotationMove(RotationMoveEvent event) {
+    public void onPlayerRelativeMove(RelativeMoveEvent event) {
         if (this.target != null && !this.force) {
             switch (event.getState()) {
                 case PRE:
                     this.lastYaw = player().rotationYaw;
-                    player().rotationYaw = this.target.getYaw();
+                    player().rotationYaw = this.target.getFirst();
                     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) {
+                    if (!Baritone.settings().antiCheatCompatibility.get()) {
                         this.target = null;
                     }
                     break;
-                default:
-                    break;
             }
         }
     }

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

@@ -2,26 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.behavior;
+package baritone.behavior.impl;
 
-import baritone.api.utils.Rotation;
-import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
-import baritone.utils.RayTraceUtils;
-import baritone.utils.Utils;
+import baritone.utils.*;
 import net.minecraft.block.BlockFire;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.*;
@@ -51,10 +47,10 @@ public final class LookBehaviorUtils implements Helper {
      * @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);
+        float f = MathHelper.cos(-rotation.getFirst() * (float) DEG_TO_RAD - (float) Math.PI);
+        float f1 = MathHelper.sin(-rotation.getFirst() * (float) DEG_TO_RAD - (float) Math.PI);
+        float f2 = -MathHelper.cos(-rotation.getSecond() * (float) DEG_TO_RAD);
+        float f3 = MathHelper.sin(-rotation.getSecond() * (float) DEG_TO_RAD);
         return new Vec3d((double) (f1 * f2), (double) f3, (double) (f * f2));
     }
 

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

@@ -1,28 +1,9 @@
-/*
- * 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.impl;
 
-package baritone.behavior;
-
-import baritone.api.behavior.IMemoryBehavior;
-import baritone.api.behavior.memory.IRememberedInventory;
 import baritone.api.event.events.PacketEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.type.EventState;
-import baritone.utils.Helper;
+import baritone.behavior.Behavior;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.Packet;
 import net.minecraft.network.play.client.CPacketCloseWindow;
@@ -39,10 +20,12 @@ import java.util.*;
  * @author Brady
  * @since 8/6/2018 9:47 PM
  */
-public final class MemoryBehavior extends Behavior implements IMemoryBehavior, Helper {
+public class MemoryBehavior extends Behavior {
 
     public static MemoryBehavior INSTANCE = new MemoryBehavior();
 
+    private MemoryBehavior() {}
+
     /**
      * Possible future inventories that we will be able to remember
      */
@@ -53,8 +36,6 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
      */
     private final Map<BlockPos, RememberedInventory> rememberedInventories = new HashMap<>();
 
-    private MemoryBehavior() {}
-
     @Override
     public void onPlayerUpdate(PlayerUpdateEvent event) {
         if (event.getState() == EventState.PRE) {
@@ -66,24 +47,27 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
     public void onSendPacket(PacketEvent event) {
         Packet p = event.getPacket();
 
-        if (event.getState() == EventState.PRE) {
-            if (p instanceof CPacketPlayerTryUseItemOnBlock) {
-                CPacketPlayerTryUseItemOnBlock packet = event.cast();
+        switch (event.getState()) {
+            case PRE: {
+                if (p instanceof CPacketPlayerTryUseItemOnBlock) {
+                    CPacketPlayerTryUseItemOnBlock packet = event.cast();
 
-                TileEntity tileEntity = world().getTileEntity(packet.getPos());
+                    TileEntity tileEntity = world().getTileEntity(packet.getPos());
 
-                // Ensure the TileEntity is a container of some sort
-                if (tileEntity instanceof TileEntityLockable) {
+                    // Ensure the TileEntity is a container of some sort
+                    if (tileEntity instanceof TileEntityLockable) {
 
-                    TileEntityLockable lockable = (TileEntityLockable) tileEntity;
-                    int size = lockable.getSizeInventory();
+                        TileEntityLockable lockable = (TileEntityLockable) tileEntity;
+                        int size = lockable.getSizeInventory();
 
-                    this.futureInventories.add(new FutureInventory(System.nanoTime() / 1000000L, size, lockable.getGuiID(), tileEntity.getPos()));
+                        this.futureInventories.add(new FutureInventory(System.nanoTime() / 1000000L, size, lockable.getGuiID(), tileEntity.getPos()));
+                    }
                 }
-            }
 
-            if (p instanceof CPacketCloseWindow) {
-                updateInventory();
+                if (p instanceof CPacketCloseWindow) {
+                    updateInventory();
+                }
+                break;
             }
         }
     }
@@ -92,28 +76,31 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
     public void onReceivePacket(PacketEvent event) {
         Packet p = event.getPacket();
 
-        if (event.getState() == EventState.PRE) {
-            if (p instanceof SPacketOpenWindow) {
-                SPacketOpenWindow packet = event.cast();
+        switch (event.getState()) {
+            case PRE: {
+                if (p instanceof SPacketOpenWindow) {
+                    SPacketOpenWindow packet = event.cast();
 
-                // Remove any entries that were created over a second ago, this should make up for INSANE latency
-                this.futureInventories.removeIf(i -> System.nanoTime() / 1000000L - i.time > 1000);
+                    // Remove any entries that were created over a second ago, this should make up for INSANE latency
+                    this.futureInventories.removeIf(i -> System.nanoTime() / 1000000L - i.time > 1000);
 
-                this.futureInventories.stream()
-                        .filter(i -> i.type.equals(packet.getGuiId()) && i.slots == packet.getSlotCount())
-                        .findFirst().ifPresent(matched -> {
-                    // Remove the future inventory
-                    this.futureInventories.remove(matched);
+                    this.futureInventories.stream()
+                            .filter(i -> i.type.equals(packet.getGuiId()) && i.slots == packet.getSlotCount())
+                            .findFirst().ifPresent(matched -> {
+                        // Remove the future inventory
+                        this.futureInventories.remove(matched);
 
-                    // Setup the remembered inventory
-                    RememberedInventory inventory = this.rememberedInventories.computeIfAbsent(matched.pos, pos -> new RememberedInventory());
-                    inventory.windowId = packet.getWindowId();
-                    inventory.size = packet.getSlotCount();
-                });
-            }
+                        // Setup the remembered inventory
+                        RememberedInventory inventory = this.rememberedInventories.computeIfAbsent(matched.pos, pos -> new RememberedInventory());
+                        inventory.windowId = packet.getWindowId();
+                        inventory.size = packet.getSlotCount();
+                    });
+                }
 
-            if (p instanceof SPacketCloseWindow) {
-                updateInventory();
+                if (p instanceof SPacketCloseWindow) {
+                    updateInventory();
+                }
+                break;
             }
         }
     }
@@ -129,7 +116,6 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
         });
     }
 
-    @Override
     public final RememberedInventory getInventoryByPos(BlockPos pos) {
         return this.rememberedInventories.get(pos);
     }
@@ -172,7 +158,7 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
      * <p>
      * Associated with a {@link BlockPos} in {@link MemoryBehavior#rememberedInventories}.
      */
-    public static class RememberedInventory implements IRememberedInventory {
+    public static class RememberedInventory {
 
         /**
          * The list of items in the inventory
@@ -193,14 +179,11 @@ public final class MemoryBehavior extends Behavior implements IMemoryBehavior, H
             this.items = new ArrayList<>();
         }
 
-        @Override
-        public final List<ItemStack> getContents() {
+        /**
+         * @return The list of items in the inventory
+         */
+        public final List<ItemStack> getItems() {
             return this.items;
         }
-
-        @Override
-        public final int getSize() {
-            return this.size;
-        }
     }
 }

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

@@ -0,0 +1,111 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.behavior.impl;
+
+import baritone.api.event.events.PathEvent;
+import baritone.behavior.Behavior;
+import baritone.chunk.CachedChunk;
+import baritone.chunk.ChunkPacker;
+import baritone.chunk.WorldProvider;
+import baritone.chunk.WorldScanner;
+import baritone.pathing.goals.Goal;
+import baritone.pathing.goals.GoalComposite;
+import baritone.pathing.goals.GoalTwoBlocks;
+import baritone.utils.BlockStateInterface;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.chunk.EmptyChunk;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Mine blocks of a certain type
+ *
+ * @author leijurv
+ */
+public class MineBehavior extends Behavior {
+    public static final MineBehavior INSTANCE = new MineBehavior();
+
+    private MineBehavior() {
+    }
+
+    List<String> mining;
+
+    @Override
+    public void onPathEvent(PathEvent event) {
+        updateGoal();
+    }
+
+    public void updateGoal() {
+        if (mining == null) {
+            return;
+        }
+        List<BlockPos> locs = scanFor(mining, 64);
+        if (locs.isEmpty()) {
+            displayChatMessageRaw("No locations for " + mining + " known, cancelling");
+            cancel();
+            return;
+        }
+        PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalTwoBlocks::new).toArray(Goal[]::new)));
+        PathingBehavior.INSTANCE.path();
+    }
+
+    public static List<BlockPos> scanFor(List<String> mining, int max) {
+        List<BlockPos> locs = new ArrayList<>();
+        List<String> uninteresting = new ArrayList<>();
+        //long b = System.currentTimeMillis();
+        for (String m : mining) {
+            if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(ChunkPacker.stringToBlock(m))) {
+                locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(m, 1, 1));
+            } else {
+                uninteresting.add(m);
+            }
+        }
+        //System.out.println("Scan of cached chunks took " + (System.currentTimeMillis() - b) + "ms");
+        if (!uninteresting.isEmpty()) {
+            //long before = System.currentTimeMillis();
+            locs.addAll(WorldScanner.INSTANCE.scanLoadedChunks(uninteresting, max));
+            //System.out.println("Scan of loaded chunks took " + (System.currentTimeMillis() - before) + "ms");
+        }
+        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(ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).toLowerCase()))
+                .collect(Collectors.toList()));
+        if (locs.size() > max) {
+            locs = locs.subList(0, max);
+        }
+        return locs;
+    }
+
+    public void mine(String... mining) {
+        this.mining = mining == null || mining.length == 0 ? null : new ArrayList<>(Arrays.asList(mining));
+        updateGoal();
+    }
+
+    public void cancel() {
+        PathingBehavior.INSTANCE.cancel();
+        mine();
+    }
+}

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

@@ -2,55 +2,51 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.behavior;
+package baritone.behavior.impl;
 
 import baritone.Baritone;
-import baritone.api.behavior.IPathingBehavior;
 import baritone.api.event.events.PathEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
 import baritone.api.event.events.RenderEvent;
 import baritone.api.event.events.TickEvent;
-import baritone.api.pathing.goals.Goal;
+import baritone.behavior.Behavior;
 import baritone.pathing.calc.AStarPathFinder;
 import baritone.pathing.calc.AbstractNodeCostSearch;
 import baritone.pathing.calc.IPathFinder;
-import baritone.api.pathing.goals.GoalXZ;
+import baritone.pathing.goals.*;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.path.IPath;
 import baritone.pathing.path.PathExecutor;
-import baritone.utils.BlockBreakHelper;
 import baritone.utils.BlockStateInterface;
-import baritone.utils.Helper;
 import baritone.utils.PathRenderer;
-import baritone.api.utils.interfaces.IGoalRenderPos;
-import baritone.utils.pathing.BetterBlockPos;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.EmptyChunk;
 
-import java.util.Collection;
+import java.awt.*;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
-public final class PathingBehavior extends Behavior implements IPathingBehavior, Helper {
+public class PathingBehavior extends Behavior {
 
     public static final PathingBehavior INSTANCE = new PathingBehavior();
 
+    private PathingBehavior() {
+    }
+
     private PathExecutor current;
     private PathExecutor next;
 
@@ -63,10 +59,8 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
 
     private boolean lastAutoJump;
 
-    private PathingBehavior() {}
-
     private void dispatchPathEvent(PathEvent event) {
-        Baritone.INSTANCE.getExecutor().execute(() -> Baritone.INSTANCE.getGameEventHandler().onPathEvent(event));
+        new Thread(() -> Baritone.INSTANCE.getGameEventHandler().onPathEvent(event)).start();
     }
 
     @Override
@@ -75,7 +69,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
             this.cancel();
             return;
         }
-        mc.playerController.setPlayerCapabilities(mc.player);
         if (current == null) {
             return;
         }
@@ -84,14 +77,14 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
             if (current.failed() || current.finished()) {
                 current = null;
                 if (goal == null || goal.isInGoal(playerFeet())) {
-                    logDebug("All done. At " + goal);
+                    displayChatMessageRaw("All done. At " + goal);
                     dispatchPathEvent(PathEvent.AT_GOAL);
                     next = null;
                     return;
                 }
                 if (next != null && !next.getPath().positions().contains(playerFeet())) {
                     // if the current path failed, we may not actually be on the next one, so make sure
-                    logDebug("Discarding next path as it does not contain current position");
+                    displayChatMessageRaw("Discarding next path as it does not contain current position");
                     // for example if we had a nicely planned ahead path that starts where current ends
                     // that's all fine and good
                     // but if we fail in the middle of current
@@ -101,7 +94,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                     next = null;
                 }
                 if (next != null) {
-                    logDebug("Continuing on to planned next path");
+                    displayChatMessageRaw("Continuing on to planned next path");
                     dispatchPathEvent(PathEvent.CONTINUING_ONTO_PLANNED_NEXT);
                     current = next;
                     next = null;
@@ -125,7 +118,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                 if (next != null) {
                     if (next.getPath().positions().contains(playerFeet())) {
                         // jump directly onto the next path
-                        logDebug("Splicing into planned next path early...");
+                        displayChatMessageRaw("Splicing into planned next path early...");
                         dispatchPathEvent(PathEvent.SPLICING_ONTO_NEXT_EARLY);
                         current = next;
                         next = null;
@@ -148,7 +141,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                 }
                 if (ticksRemainingInSegment().get() < Baritone.settings().planningTickLookAhead.get()) {
                     // and this path has 5 seconds or less left
-                    logDebug("Path almost over. Planning ahead...");
+                    displayChatMessageRaw("Path almost over. Planning ahead...");
                     dispatchPathEvent(PathEvent.NEXT_SEGMENT_CALC_STARTED);
                     findPathInNewThread(current.getPath().getDest(), false, Optional.of(current.getPath()));
                 }
@@ -167,13 +160,10 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                 case POST:
                     mc.gameSettings.autoJump = lastAutoJump;
                     break;
-                default:
-                    break;
             }
         }
     }
 
-    @Override
     public Optional<Double> ticksRemainingInSegment() {
         if (current == null) {
             return Optional.empty();
@@ -181,12 +171,10 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         return Optional.of(current.getPath().ticksRemainingFrom(current.getPosition()));
     }
 
-    @Override
     public void setGoal(Goal goal) {
         this.goal = goal;
     }
 
-    @Override
     public Goal getGoal() {
         return goal;
     }
@@ -199,30 +187,15 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         return next;
     }
 
-    // TODO: Expose this method in the API?
-    // In order to do so, we'd need to move over IPath which has a whole lot of references to other
-    // things that may not need to be exposed necessarily, so we'll need to figure that out.
     public Optional<IPath> getPath() {
         return Optional.ofNullable(current).map(PathExecutor::getPath);
     }
 
-    @Override
-    public boolean isPathing() {
-        return this.current != null;
-    }
-
-    @Override
     public void cancel() {
-        dispatchPathEvent(PathEvent.CANCELED);
         current = null;
         next = null;
         Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys();
         AbstractNodeCostSearch.getCurrentlyRunning().ifPresent(AbstractNodeCostSearch::cancel);
-        BlockBreakHelper.stopBreakingBlock();
-    }
-
-    public void forceCancel() { // NOT exposed on public api
-        isPathCalcInProgress = false;
     }
 
     /**
@@ -230,7 +203,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
      *
      * @return true if this call started path calculation, false if it was already calculating or executing a path
      */
-    @Override
     public boolean path() {
         if (goal == null) {
             return false;
@@ -253,11 +225,8 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         }
     }
 
-    /**
-     * @return The starting {@link BlockPos} for a new path
-     */
-    private BlockPos pathStart() {
-        BetterBlockPos feet = playerFeet();
+    public BlockPos pathStart() {
+        BlockPos feet = playerFeet();
         if (BlockStateInterface.get(feet.down()).getBlock().equals(Blocks.AIR) && MovementHelper.canWalkOn(feet.down().down())) {
             return feet.down();
         }
@@ -277,9 +246,9 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
             }
             isPathCalcInProgress = true;
         }
-        Baritone.INSTANCE.getExecutor().execute(() -> {
+        new Thread(() -> {
             if (talkAboutIt) {
-                logDebug("Starting to search for path from " + start + " to " + goal);
+                displayChatMessageRaw("Starting to search for path from " + start + " to " + goal);
             }
 
             Optional<IPath> path = findPath(start, previous);
@@ -311,16 +280,16 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
 
             if (talkAboutIt && current != null && current.getPath() != null) {
                 if (goal == null || goal.isInGoal(current.getPath().getDest())) {
-                    logDebug("Finished finding a path from " + start + " to " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
+                    displayChatMessageRaw("Finished finding a path from " + start + " to " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
                 } else {
-                    logDebug("Found path segment from " + start + " towards " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
+                    displayChatMessageRaw("Found path segment from " + start + " towards " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
 
                 }
             }
             synchronized (pathCalcLock) {
                 isPathCalcInProgress = false;
             }
-        });
+        }).start();
     }
 
     /**
@@ -332,18 +301,26 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
     private Optional<IPath> findPath(BlockPos start, Optional<IPath> previous) {
         Goal goal = this.goal;
         if (goal == null) {
-            logDebug("no goal");
+            displayChatMessageRaw("no goal");
             return Optional.empty();
         }
         if (Baritone.settings().simplifyUnloadedYCoord.get()) {
             BlockPos pos = null;
-            if (goal instanceof IGoalRenderPos) {
-                pos = ((IGoalRenderPos) goal).getGoalPos();
+            if (goal instanceof GoalBlock) {
+                pos = ((GoalBlock) goal).getGoalPos();
+            }
+            if (goal instanceof GoalTwoBlocks) {
+                pos = ((GoalTwoBlocks) goal).getGoalPos();
+            }
+            if (goal instanceof GoalNear) {
+                pos = ((GoalNear) goal).getGoalPos();
+            }
+            if (goal instanceof GoalGetToBlock) {
+                pos = ((GoalGetToBlock) goal).getGoalPos();
             }
-
             // TODO simplify each individual goal in a GoalComposite
             if (pos != null && world().getChunk(pos) instanceof EmptyChunk) {
-                logDebug("Simplifying " + goal.getClass() + " to GoalXZ due to distance");
+                displayChatMessageRaw("Simplifying " + goal.getClass() + " to GoalXZ due to distance");
                 goal = new GoalXZ(pos.getX(), pos.getZ());
             }
         }
@@ -353,46 +330,29 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         } else {
             timeout = Baritone.settings().planAheadTimeoutMS.<Long>get();
         }
-        Optional<HashSet<Long>> favoredPositions = previous.map(IPath::positions).map(Collection::stream).map(x -> x.map(y -> y.hashCode)).map(x -> x.collect(Collectors.toList())).map(HashSet::new); // <-- okay this is EPIC
         try {
-            IPathFinder pf = new AStarPathFinder(start, goal, favoredPositions);
+            IPathFinder pf = new AStarPathFinder(start, goal, previous.map(IPath::positions));
             return pf.calculate(timeout);
         } catch (Exception e) {
-            logDebug("Pathing exception: " + e);
+            displayChatMessageRaw("Pathing exception: " + e);
             e.printStackTrace();
             return Optional.empty();
         }
     }
 
-    public void revalidateGoal() {
-        if (!Baritone.settings().cancelOnGoalInvalidation.get()) {
-            return;
-        }
-        if (current == null || goal == null) {
-            return;
-        }
-        Goal intended = current.getPath().getGoal();
-        BlockPos end = current.getPath().getDest();
-        if (intended.isInGoal(end) && !goal.isInGoal(end)) {
-            // this path used to end in the goal
-            // but the goal has changed, so there's no reason to continue...
-            cancel();
-        }
-    }
-
     @Override
     public void onRenderPass(RenderEvent event) {
         // System.out.println("Render passing");
         // System.out.println(event.getPartialTicks());
         float partialTicks = event.getPartialTicks();
         if (goal != null && Baritone.settings().renderGoal.value) {
-            PathRenderer.drawLitDankGoalBox(player(), goal, partialTicks, Baritone.settings().colorGoalBox.get());
+            PathRenderer.drawLitDankGoalBox(player(), goal, partialTicks, Color.GREEN);
         }
         if (!Baritone.settings().renderPath.get()) {
             return;
         }
 
-        //long start = System.nanoTime();
+        long start = System.nanoTime();
 
 
         PathExecutor current = this.current; // this should prevent most race conditions?
@@ -403,39 +363,35 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         // Render the current path, if there is one
         if (current != null && current.getPath() != null) {
             int renderBegin = Math.max(current.getPosition() - 3, 0);
-            PathRenderer.drawPath(current.getPath(), renderBegin, player(), partialTicks, Baritone.settings().colorCurrentPath.get(), Baritone.settings().fadePath.get(), 10, 20);
+            PathRenderer.drawPath(current.getPath(), renderBegin, player(), partialTicks, Color.RED, Baritone.settings().fadePath.get(), 10, 20);
         }
         if (next != null && next.getPath() != null) {
-            PathRenderer.drawPath(next.getPath(), 0, player(), partialTicks, Baritone.settings().colorNextPath.get(), Baritone.settings().fadePath.get(), 10, 20);
+            PathRenderer.drawPath(next.getPath(), 0, player(), partialTicks, Color.MAGENTA, Baritone.settings().fadePath.get(), 10, 20);
         }
 
-        //long split = System.nanoTime();
+        long split = System.nanoTime();
         if (current != null) {
-            PathRenderer.drawManySelectionBoxes(player(), current.toBreak(), partialTicks, Baritone.settings().colorBlocksToBreak.get());
-            PathRenderer.drawManySelectionBoxes(player(), current.toPlace(), partialTicks, Baritone.settings().colorBlocksToPlace.get());
-            PathRenderer.drawManySelectionBoxes(player(), current.toWalkInto(), partialTicks, Baritone.settings().colorBlocksToWalkInto.get());
+            PathRenderer.drawManySelectionBoxes(player(), current.toBreak(), partialTicks, Color.RED);
+            PathRenderer.drawManySelectionBoxes(player(), current.toPlace(), partialTicks, Color.GREEN);
+            PathRenderer.drawManySelectionBoxes(player(), current.toWalkInto(), partialTicks, Color.MAGENTA);
         }
 
         // If there is a path calculation currently running, render the path calculation process
         AbstractNodeCostSearch.getCurrentlyRunning().ifPresent(currentlyRunning -> {
             currentlyRunning.bestPathSoFar().ifPresent(p -> {
-                PathRenderer.drawPath(p, 0, player(), partialTicks, Baritone.settings().colorBestPathSoFar.get(), Baritone.settings().fadePath.get(), 10, 20);
+                PathRenderer.drawPath(p, 0, player(), partialTicks, Color.BLUE, Baritone.settings().fadePath.get(), 10, 20);
                 currentlyRunning.pathToMostRecentNodeConsidered().ifPresent(mr -> {
 
-                    PathRenderer.drawPath(mr, 0, player(), partialTicks, Baritone.settings().colorMostRecentConsidered.get(), Baritone.settings().fadePath.get(), 10, 20);
-                    PathRenderer.drawManySelectionBoxes(player(), Collections.singletonList(mr.getDest()), partialTicks, Baritone.settings().colorMostRecentConsidered.get());
+                    PathRenderer.drawPath(mr, 0, player(), partialTicks, Color.CYAN, Baritone.settings().fadePath.get(), 10, 20);
+                    PathRenderer.drawManySelectionBoxes(player(), Collections.singletonList(mr.getDest()), partialTicks, Color.CYAN);
                 });
             });
         });
-        //long end = System.nanoTime();
+        long end = System.nanoTime();
         //System.out.println((end - split) + " " + (split - start));
         // if (end - start > 0) {
         //   System.out.println("Frame took " + (split - start) + " " + (end - split));
         //}
-    }
 
-    @Override
-    public void onDisable() {
-        Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys();
     }
 }

src/main/java/baritone/chunk/CachedChunk.java

@@ -2,23 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
-import baritone.api.cache.IBlockTypeAccess;
-import baritone.utils.Helper;
+import baritone.utils.pathing.IBlockTypeAccess;
 import baritone.utils.pathing.PathingBlockType;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
@@ -31,7 +30,7 @@ import java.util.*;
  * @author Brady
  * @since 8/3/2018 1:04 AM
  */
-public final class CachedChunk implements IBlockTypeAccess, Helper {
+public final class CachedChunk implements IBlockTypeAccess {
 
     public static final Set<Block> BLOCKS_TO_KEEP_TRACK_OF = Collections.unmodifiableSet(new HashSet<Block>() {{
         add(Blocks.DIAMOND_ORE);
@@ -64,8 +63,6 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
         add(Blocks.DRAGON_EGG);
         add(Blocks.JUKEBOX);
         add(Blocks.END_GATEWAY);
-        add(Blocks.WEB);
-        add(Blocks.NETHER_WART);
     }});
 
     /**
@@ -100,13 +97,13 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
     /**
      * The block names of each surface level block for generating an overview
      */
-    private final IBlockState[] overview;
+    private final String[] overview;
 
     private final int[] heightMap;
 
     private final Map<String, List<BlockPos>> specialBlockLocations;
 
-    CachedChunk(int x, int z, BitSet data, IBlockState[] overview, Map<String, List<BlockPos>> specialBlockLocations) {
+    CachedChunk(int x, int z, BitSet data, String[] overview, Map<String, List<BlockPos>> specialBlockLocations) {
         validateSize(data);
 
         this.x = x;
@@ -123,16 +120,14 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
         int internalPos = z << 4 | x;
         if (heightMap[internalPos] == y) {
             // we have this exact block, it's a surface block
+            IBlockState state = ChunkPacker.stringToBlock(overview[internalPos]).getDefaultState();
             /*System.out.println("Saying that " + x + "," + y + "," + z + " is " + state);
             if (!Minecraft.getMinecraft().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock().equals(state.getBlock())) {
                 throw new IllegalStateException("failed " + Minecraft.getMinecraft().world.getBlockState(new BlockPos(x + this.x * 16, y, z + this.z * 16)).getBlock() + " " + state.getBlock() + " " + (x + this.x * 16) + " " + y + " " + (z + this.z * 16));
             }*/
-            return overview[internalPos];
+            return state;
         }
         PathingBlockType type = getType(x, y, z);
-        if (type == PathingBlockType.SOLID && y == 127 && mc.player.dimension == -1) {
-            return Blocks.BEDROCK.getDefaultState();
-        }
         return ChunkPacker.pathingTypeToBlock(type);
     }
 
@@ -157,7 +152,7 @@ public final class CachedChunk implements IBlockTypeAccess, Helper {
         }
     }
 
-    public final IBlockState[] getOverview() {
+    public final String[] getOverview() {
         return overview;
     }
 

src/main/java/baritone/chunk/CachedRegion.java

@@ -2,22 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
-import baritone.api.cache.ICachedRegion;
+import baritone.utils.pathing.IBlockTypeAccess;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
 
@@ -33,8 +33,7 @@ import java.util.zip.GZIPOutputStream;
  * @author Brady
  * @since 8/3/2018 9:35 PM
  */
-public final class CachedRegion implements ICachedRegion {
-
+public final class CachedRegion implements IBlockTypeAccess {
     private static final byte CHUNK_NOT_PRESENT = 0;
     private static final byte CHUNK_PRESENT = 1;
 
@@ -78,7 +77,6 @@ public final class CachedRegion implements ICachedRegion {
         return null;
     }
 
-    @Override
     public final boolean isCached(int x, int z) {
         return chunks[x >> 4][z >> 4] != null;
     }
@@ -102,7 +100,7 @@ public final class CachedRegion implements ICachedRegion {
         return res;
     }
 
-    public final synchronized void updateCachedChunk(int chunkX, int chunkZ, CachedChunk chunk) {
+    final synchronized void updateCachedChunk(int chunkX, int chunkZ, CachedChunk chunk) {
         this.chunks[chunkX][chunkZ] = chunk;
         hasUnsavedChanges = true;
     }
@@ -147,7 +145,7 @@ public final class CachedRegion implements ICachedRegion {
                     for (int x = 0; x < 32; x++) {
                         if (chunks[x][z] != null) {
                             for (int i = 0; i < 256; i++) {
-                                out.writeUTF(ChunkPacker.blockToString(chunks[x][z].getOverview()[i].getBlock()));
+                                out.writeUTF(chunks[x][z].getOverview()[i]);
                             }
                         }
                     }
@@ -217,7 +215,7 @@ public final class CachedRegion implements ICachedRegion {
                                 int regionZ = this.z;
                                 int chunkX = x + 32 * regionX;
                                 int chunkZ = z + 32 * regionZ;
-                                tmpCached[x][z] = new CachedChunk(chunkX, chunkZ, BitSet.valueOf(bytes), new IBlockState[256], location[x][z]);
+                                tmpCached[x][z] = new CachedChunk(chunkX, chunkZ, BitSet.valueOf(bytes), new String[256], location[x][z]);
                                 break;
                             case CHUNK_NOT_PRESENT:
                                 tmpCached[x][z] = null;
@@ -231,7 +229,7 @@ public final class CachedRegion implements ICachedRegion {
                     for (int x = 0; x < 32; x++) {
                         if (tmpCached[x][z] != null) {
                             for (int i = 0; i < 256; i++) {
-                                tmpCached[x][z].getOverview()[i] = ChunkPacker.stringToBlock(in.readUTF()).getDefaultState();
+                                tmpCached[x][z].getOverview()[i] = in.readUTF();
                             }
                         }
                     }
@@ -282,7 +280,6 @@ public final class CachedRegion implements ICachedRegion {
     /**
      * @return The region x coordinate
      */
-    @Override
     public final int getX() {
         return this.x;
     }
@@ -290,7 +287,6 @@ public final class CachedRegion implements ICachedRegion {
     /**
      * @return The region z coordinate
      */
-    @Override
     public final int getZ() {
         return this.z;
     }

src/main/java/baritone/chunk/CachedWorld.java

@@ -2,26 +2,26 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
 import baritone.Baritone;
-import baritone.api.cache.ICachedWorld;
-import baritone.utils.Helper;
+import baritone.utils.pathing.IBlockTypeAccess;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.chunk.Chunk;
 
@@ -37,7 +37,7 @@ import java.util.concurrent.LinkedBlockingQueue;
  * @author Brady
  * @since 8/4/2018 12:02 AM
  */
-public final class CachedWorld implements ICachedWorld, Helper {
+public final class CachedWorld implements IBlockTypeAccess {
 
     /**
      * The maximum number of regions in any direction from (0,0)
@@ -67,8 +67,8 @@ public final class CachedWorld implements ICachedWorld, Helper {
         System.out.println("Cached world directory: " + directory);
         // Insert an invalid region element
         cachedRegions.put(0, null);
-        Baritone.INSTANCE.getExecutor().execute(new PackerThread());
-        Baritone.INSTANCE.getExecutor().execute(() -> {
+        new PackerThread().start();
+        new Thread(() -> {
             try {
                 Thread.sleep(30000);
                 while (true) {
@@ -81,10 +81,9 @@ public final class CachedWorld implements ICachedWorld, Helper {
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-        });
+        }).start();
     }
 
-    @Override
     public final void queueForPacking(Chunk chunk) {
         try {
             toPack.put(chunk);
@@ -94,16 +93,27 @@ public final class CachedWorld implements ICachedWorld, Helper {
     }
 
     @Override
-    public final boolean isCached(int blockX, int blockZ) {
-        CachedRegion region = getRegion(blockX >> 9, blockZ >> 9);
+    public final IBlockState getBlock(int x, int y, int z) {
+        // no point in doing getOrCreate region, if we don't have it we don't have it
+        CachedRegion region = getRegion(x >> 9, z >> 9);
+        if (region == null) {
+            return null;
+        }
+        return region.getBlock(x & 511, y, z & 511);
+    }
+
+    public final boolean isCached(BlockPos pos) {
+        int x = pos.getX();
+        int z = pos.getZ();
+        CachedRegion region = getRegion(x >> 9, z >> 9);
         if (region == null) {
             return false;
         }
-        return region.isCached(blockX & 511, blockZ & 511);
+        return region.isCached(x & 511, z & 511);
     }
 
-    @Override
-    public final LinkedList<BlockPos> getLocationsOf(String block, int maximum, int maxRegionDistanceSq) {
+
+    public final LinkedList<BlockPos> getLocationsOf(String block, int minimum, int maxRegionDistanceSq) {
         LinkedList<BlockPos> res = new LinkedList<>();
         int playerRegionX = playerFeet().getX() >> 9;
         int playerRegionZ = playerFeet().getZ() >> 9;
@@ -120,12 +130,13 @@ public final class CachedWorld implements ICachedWorld, Helper {
                     int regionZ = zoff + playerRegionZ;
                     CachedRegion region = getOrCreateRegion(regionX, regionZ);
                     if (region != null) {
-                        // TODO: 100% verify if this or addAll is faster.
-                        region.getLocationsOf(block).forEach(res::add);
+                        for (BlockPos pos : region.getLocationsOf(block)) {
+                            res.add(pos);
+                        }
                     }
                 }
             }
-            if (res.size() >= maximum) {
+            if (res.size() >= minimum) {
                 return res;
             }
             searchRadius++;
@@ -138,7 +149,6 @@ public final class CachedWorld implements ICachedWorld, Helper {
         region.updateCachedChunk(chunk.x & 31, chunk.z & 31, chunk);
     }
 
-    @Override
     public final void save() {
         if (!Baritone.settings().chunkCaching.get()) {
             System.out.println("Not saving to disk; chunk caching is disabled.");
@@ -158,7 +168,6 @@ public final class CachedWorld implements ICachedWorld, Helper {
         return new ArrayList<>(this.cachedRegions.values());
     }
 
-    @Override
     public final void reloadAllFromDisk() {
         long start = System.nanoTime() / 1000000L;
         allRegions().forEach(region -> {
@@ -170,7 +179,13 @@ public final class CachedWorld implements ICachedWorld, Helper {
         System.out.println("World load took " + (now - start) + "ms");
     }
 
-    @Override
+    /**
+     * Returns the region at the specified region coordinates
+     *
+     * @param regionX The region X coordinate
+     * @param regionZ The region Z coordinate
+     * @return The region located at the specified coordinates
+     */
     public final synchronized CachedRegion getRegion(int regionX, int regionZ) {
         return cachedRegions.get(getRegionID(regionX, regionZ));
     }
@@ -218,10 +233,9 @@ public final class CachedWorld implements ICachedWorld, Helper {
         return regionX <= REGION_MAX && regionX >= -REGION_MAX && regionZ <= REGION_MAX && regionZ >= -REGION_MAX;
     }
 
-    private class PackerThread implements Runnable {
+    private class PackerThread extends Thread {
         public void run() {
             while (true) {
-                // TODO: Add CachedWorld unloading to remove the redundancy of having this
                 LinkedBlockingQueue<Chunk> queue = toPack;
                 if (queue == null) {
                     break;

src/main/java/baritone/chunk/ChunkPacker.java

@@ -2,20 +2,20 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.Helper;
@@ -42,8 +42,24 @@ public final class ChunkPacker implements Helper {
 
     private ChunkPacker() {}
 
+    private static BitSet originalPacker(Chunk chunk) {
+        BitSet bitSet = new BitSet(CachedChunk.SIZE);
+        for (int y = 0; y < 256; y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    int index = CachedChunk.getPositionIndex(x, y, z);
+                    IBlockState state = chunk.getBlockState(x, y, z);
+                    boolean[] bits = getPathingBlockType(state).getBits();
+                    bitSet.set(index, bits[0]);
+                    bitSet.set(index + 1, bits[1]);
+                }
+            }
+        }
+        return bitSet;
+    }
+
     public static CachedChunk pack(Chunk chunk) {
-        //long start = System.nanoTime() / 1000000L;
+        long start = System.nanoTime() / 1000000L;
 
         Map<String, List<BlockPos>> specialBlocks = new HashMap<>();
         BitSet bitSet = new BitSet(CachedChunk.SIZE);
@@ -84,29 +100,32 @@ public final class ChunkPacker implements Helper {
                     }
                 }
             }
+            /*if (!bitSet.equals(originalPacker(chunk))) {
+                throw new IllegalStateException();
+            }*/
         } catch (Exception e) {
             e.printStackTrace();
         }
-        //long end = System.nanoTime() / 1000000L;
+        //System.out.println("Packed special blocks: " + specialBlocks);
+        long end = System.nanoTime() / 1000000L;
         //System.out.println("Chunk packing took " + (end - start) + "ms for " + chunk.x + "," + chunk.z);
-        IBlockState[] blocks = new IBlockState[256];
-
+        String[] blockNames = new String[256];
         for (int z = 0; z < 16; z++) {
-            // @formatter:off
-            https://www.ibm.com/developerworks/library/j-perry-writing-good-java-code/index.html
-            // @formatter:on
+            outerLoop:
             for (int x = 0; x < 16; x++) {
                 for (int y = 255; y >= 0; y--) {
                     int index = CachedChunk.getPositionIndex(x, y, z);
                     if (bitSet.get(index) || bitSet.get(index + 1)) {
-                        blocks[z << 4 | x] = chunk.getBlockState(x, y, z);
-                        continue https;
+                        String name = blockToString(chunk.getBlockState(x, y, z).getBlock());
+                        blockNames[z << 4 | x] = name;
+                        continue outerLoop;
                     }
                 }
-                blocks[z << 4 | x] = Blocks.AIR.getDefaultState();
+                blockNames[z << 4 | x] = "air";
             }
         }
-        return new CachedChunk(chunk.x, chunk.z, bitSet, blocks, specialBlocks);
+        CachedChunk cached = new CachedChunk(chunk.x, chunk.z, bitSet, blockNames, specialBlocks);
+        return cached;
     }
 
     public static String blockToString(Block block) {
@@ -120,7 +139,10 @@ public final class ChunkPacker implements Helper {
     }
 
     public static Block stringToBlock(String name) {
-        return Block.getBlockFromName(name.contains(":") ? name : "minecraft:" + name);
+        if (!name.contains(":")) {
+            name = "minecraft:" + name;
+        }
+        return Block.getBlockFromName(name);
     }
 
     private static PathingBlockType getPathingBlockType(IBlockState state) {
@@ -130,7 +152,7 @@ public final class ChunkPacker implements Helper {
             return PathingBlockType.WATER;
         }
 
-        if (MovementHelper.avoidWalkingInto(block) || block == Blocks.FLOWING_WATER || MovementHelper.isBottomSlab(state)) {
+        if (MovementHelper.avoidWalkingInto(block) || block.equals(Blocks.FLOWING_WATER) || MovementHelper.isBottomSlab(state)) {
             return PathingBlockType.AVOID;
         }
         // We used to do an AABB check here
@@ -144,27 +166,30 @@ public final class ChunkPacker implements Helper {
         return PathingBlockType.SOLID;
     }
 
-    public static IBlockState pathingTypeToBlock(PathingBlockType type) {
-        switch (type) {
-            case AIR:
-                return Blocks.AIR.getDefaultState();
-            case WATER:
-                return Blocks.WATER.getDefaultState();
-            case AVOID:
-                return Blocks.LAVA.getDefaultState();
-            case SOLID:
-                // Dimension solid types
-                switch (mc.player.dimension) {
-                    case -1:
-                        return Blocks.NETHERRACK.getDefaultState();
-                    case 0:
-                    default: // The fallback solid type
-                        return Blocks.STONE.getDefaultState();
-                    case 1:
-                        return Blocks.END_STONE.getDefaultState();
-                }
-            default:
-                return null;
+    static IBlockState pathingTypeToBlock(PathingBlockType type) {
+        if (type != null) {
+            switch (type) {
+                case AIR:
+                    return Blocks.AIR.getDefaultState();
+                case WATER:
+                    return Blocks.WATER.getDefaultState();
+                case AVOID:
+                    return Blocks.LAVA.getDefaultState();
+                case SOLID:
+                    // Dimension solid types
+                    switch (mc.player.dimension) {
+                        case -1:
+                            return Blocks.NETHERRACK.getDefaultState();
+                        case 0:
+                            return Blocks.STONE.getDefaultState();
+                        case 1:
+                            return Blocks.END_STONE.getDefaultState();
+                    }
+
+                    // The fallback solid type
+                    return Blocks.STONE.getDefaultState();
+            }
         }
+        return null;
     }
 }

src/main/java/baritone/chunk/Waypoint.java

@@ -2,97 +2,91 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
-import baritone.api.cache.IWaypoint;
+import com.google.common.collect.ImmutableList;
 import net.minecraft.util.math.BlockPos;
+import org.apache.commons.lang3.ArrayUtils;
 
-import java.util.Date;
+import java.util.*;
 
 /**
- * Basic implementation of {@link IWaypoint}
+ * A single waypoint
  *
  * @author leijurv
  */
-public class Waypoint implements IWaypoint {
+public class Waypoint {
 
-    private final String name;
-    private final Tag tag;
+    public final String name;
+    public final Tag tag;
     private final long creationTimestamp;
-    private final BlockPos location;
+    public final BlockPos location;
 
     public Waypoint(String name, Tag tag, BlockPos location) {
         this(name, tag, location, System.currentTimeMillis());
     }
 
-    /**
-     * Constructor called when a Waypoint is read from disk, adds the creationTimestamp
-     * as a parameter so that it is reserved after a waypoint is wrote to the disk.
-     *
-     * @param name The waypoint name
-     * @param tag The waypoint tag
-     * @param location The waypoint location
-     * @param creationTimestamp When the waypoint was created
-     */
-    Waypoint(String name, Tag tag, BlockPos location, long creationTimestamp) {
+    Waypoint(String name, Tag tag, BlockPos location, long creationTimestamp) { // read from disk
         this.name = name;
         this.tag = tag;
         this.location = location;
         this.creationTimestamp = creationTimestamp;
     }
 
-    @Override
-    public int hashCode() {
-        return name.hashCode() + tag.hashCode() + location.hashCode(); //lol
-    }
-
-    @Override
-    public String getName() {
-        return this.name;
-    }
-
-    @Override
-    public Tag getTag() {
-        return this.tag;
-    }
-
-    @Override
-    public long getCreationTimestamp() {
-        return this.creationTimestamp;
-    }
-
-    @Override
-    public BlockPos getLocation() {
-        return this.location;
-    }
-
-    @Override
-    public String toString() {
-        return name + " " + location.toString() + " " + new Date(creationTimestamp).toString();
-    }
-
     @Override
     public boolean equals(Object o) {
         if (o == null) {
             return false;
         }
-        if (!(o instanceof IWaypoint)) {
+        if (!(o instanceof Waypoint)) {
             return false;
         }
-        IWaypoint w = (IWaypoint) o;
-        return name.equals(w.getName()) && tag == w.getTag() && location.equals(w.getLocation());
+        Waypoint w = (Waypoint) o;
+        return name.equals(w.name) && tag == w.tag && location.equals(w.location);
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode() + tag.hashCode() + location.hashCode(); //lol
+    }
+
+    public long creationTimestamp() {
+        return creationTimestamp;
+    }
+
+    public String toString() {
+        return name + " " + location.toString() + " " + new Date(creationTimestamp).toString();
+    }
+
+    public enum Tag {
+        HOME("home", "base"),
+        DEATH("death"),
+        BED("bed", "spawn"),
+        USER();
+
+        private static final List<Tag> TAG_LIST = ImmutableList.<Tag>builder().add(Tag.values()).build();
+
+        private final String[] names;
+
+        Tag(String... names) {
+            this.names = names;
+        }
+
+        public static Tag fromString(String name) {
+            return TAG_LIST.stream().filter(tag -> ArrayUtils.contains(tag.names, name.toLowerCase())).findFirst().orElse(null);
+        }
     }
 }

src/main/java/baritone/chunk/Waypoints.java

@@ -2,37 +2,34 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
-import baritone.api.cache.IWaypoint;
-import baritone.api.cache.IWaypointCollection;
 import net.minecraft.util.math.BlockPos;
 
 import java.io.*;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.stream.Collectors;
 
 /**
  * Waypoints for a world
  *
  * @author leijurv
  */
-public class Waypoints implements IWaypointCollection {
+public class Waypoints {
 
     /**
      * Magic value to detect invalid waypoint files
@@ -40,7 +37,7 @@ public class Waypoints implements IWaypointCollection {
     private static final long WAYPOINT_MAGIC_VALUE = 121977993584L; // good value
 
     private final Path directory;
-    private final Map<IWaypoint.Tag, Set<IWaypoint>> waypoints;
+    private final Map<Waypoint.Tag, Set<Waypoint>> waypoints;
 
     Waypoints(Path directory) {
         this.directory = directory;
@@ -61,9 +58,9 @@ public class Waypoints implements IWaypointCollection {
     }
 
     private synchronized void load(Waypoint.Tag tag) {
-        this.waypoints.put(tag, new HashSet<>());
+        waypoints.put(tag, new HashSet<>());
 
-        Path fileName = this.directory.resolve(tag.name().toLowerCase() + ".mp4");
+        Path fileName = directory.resolve(tag.name().toLowerCase() + ".mp4");
         if (!Files.exists(fileName)) {
             return;
         }
@@ -85,60 +82,44 @@ public class Waypoints implements IWaypointCollection {
                 int x = in.readInt();
                 int y = in.readInt();
                 int z = in.readInt();
-                this.waypoints.get(tag).add(new Waypoint(name, tag, new BlockPos(x, y, z), creationTimestamp));
+                waypoints.get(tag).add(new Waypoint(name, tag, new BlockPos(x, y, z), creationTimestamp));
             }
         } catch (IOException ignored) {}
     }
 
     private synchronized void save(Waypoint.Tag tag) {
-        Path fileName = this.directory.resolve(tag.name().toLowerCase() + ".mp4");
+        Path fileName = directory.resolve(tag.name().toLowerCase() + ".mp4");
         try (
                 FileOutputStream fileOut = new FileOutputStream(fileName.toFile());
                 BufferedOutputStream bufOut = new BufferedOutputStream(fileOut);
                 DataOutputStream out = new DataOutputStream(bufOut)
         ) {
             out.writeLong(WAYPOINT_MAGIC_VALUE);
-            out.writeLong(this.waypoints.get(tag).size());
-            for (IWaypoint waypoint : this.waypoints.get(tag)) {
-                out.writeUTF(waypoint.getName());
-                out.writeLong(waypoint.getCreationTimestamp());
-                out.writeInt(waypoint.getLocation().getX());
-                out.writeInt(waypoint.getLocation().getY());
-                out.writeInt(waypoint.getLocation().getZ());
+            out.writeLong(waypoints.get(tag).size());
+            for (Waypoint waypoint : waypoints.get(tag)) {
+                out.writeUTF(waypoint.name);
+                out.writeLong(waypoint.creationTimestamp());
+                out.writeInt(waypoint.location.getX());
+                out.writeInt(waypoint.location.getY());
+                out.writeInt(waypoint.location.getZ());
             }
         } catch (IOException ex) {
             ex.printStackTrace();
         }
     }
 
-    @Override
-    public void addWaypoint(IWaypoint waypoint) {
-        // no need to check for duplicate, because it's a Set not a List
-        if (waypoints.get(waypoint.getTag()).add(waypoint)) {
-            save(waypoint.getTag());
-        }
+    public Set<Waypoint> getByTag(Waypoint.Tag tag) {
+        return Collections.unmodifiableSet(waypoints.get(tag));
     }
 
-    @Override
-    public void removeWaypoint(IWaypoint waypoint) {
-        if (waypoints.get(waypoint.getTag()).remove(waypoint)) {
-            save(waypoint.getTag());
-        }
-    }
-
-    @Override
-    public IWaypoint getMostRecentByTag(IWaypoint.Tag tag) {
+    public Waypoint getMostRecentByTag(Waypoint.Tag tag) {
         // Find a waypoint of the given tag which has the greatest timestamp value, indicating the most recent
-        return this.waypoints.get(tag).stream().min(Comparator.comparingLong(w -> -w.getCreationTimestamp())).orElse(null);
+        return this.waypoints.get(tag).stream().min(Comparator.comparingLong(w -> -w.creationTimestamp())).orElse(null);
     }
 
-    @Override
-    public Set<IWaypoint> getByTag(IWaypoint.Tag tag) {
-        return Collections.unmodifiableSet(this.waypoints.get(tag));
-    }
-
-    @Override
-    public Set<IWaypoint> getAllWaypoints() {
-        return this.waypoints.values().stream().flatMap(Collection::stream).collect(Collectors.toSet());
+    public void addWaypoint(Waypoint waypoint) {
+        // no need to check for duplicate, because it's a Set not a List
+        waypoints.get(waypoint.tag).add(waypoint);
+        save(waypoint.tag);
     }
 }

src/main/java/baritone/chunk/WorldData.java

@@ -2,25 +2,20 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
-
-import baritone.Baritone;
-import baritone.api.cache.ICachedWorld;
-import baritone.api.cache.IWaypointCollection;
-import baritone.api.cache.IWorldData;
+package baritone.chunk;
 
 import java.nio.file.Path;
 
@@ -29,10 +24,9 @@ import java.nio.file.Path;
  *
  * @author leijurv
  */
-public class WorldData implements IWorldData {
-
+public class WorldData {
     public final CachedWorld cache;
-    private final Waypoints waypoints;
+    public final Waypoints waypoints;
     //public final MapData map;
     public final Path directory;
 
@@ -43,19 +37,11 @@ public class WorldData implements IWorldData {
     }
 
     void onClose() {
-        Baritone.INSTANCE.getExecutor().execute(() -> {
-            System.out.println("Started saving the world in a new thread");
-            cache.save();
-        });
-    }
-
-    @Override
-    public ICachedWorld getCachedWorld() {
-        return this.cache;
-    }
-
-    @Override
-    public IWaypointCollection getWaypoints() {
-        return this.waypoints;
+        new Thread() {
+            public void run() {
+                System.out.println("Started saving the world in a new thread");
+                cache.save();
+            }
+        }.start();
     }
 }

src/main/java/baritone/chunk/WorldProvider.java

@@ -2,23 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
 import baritone.Baritone;
-import baritone.api.cache.IWorldProvider;
 import baritone.utils.Helper;
 import baritone.utils.accessor.IAnvilChunkLoader;
 import baritone.utils.accessor.IChunkProviderServer;
@@ -39,7 +38,7 @@ import java.util.function.Consumer;
  * @author Brady
  * @since 8/4/2018 11:06 AM
  */
-public enum WorldProvider implements IWorldProvider, Helper {
+public enum WorldProvider implements Helper {
 
     INSTANCE;
 
@@ -47,7 +46,6 @@ public enum WorldProvider implements IWorldProvider, Helper {
 
     private WorldData currentWorld;
 
-    @Override
     public final WorldData getCurrentWorld() {
         return this.currentWorld;
     }

src/main/java/baritone/chunk/WorldScanner.java

@@ -2,20 +2,20 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.cache;
+package baritone.chunk;
 
 import baritone.utils.Helper;
 import net.minecraft.block.Block;
@@ -28,47 +28,34 @@ import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public enum WorldScanner implements Helper {
     INSTANCE;
 
-    /**
-     * Scans the world, up to your render distance, for the specified blocks.
-     *
-     * @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
-     *                        returned, if the value is negative, then this condition doesn't apply.
-     * @param maxSearchRadius The maximum chunk search radius
-     * @return The matching block positions
-     */
-    public List<BlockPos> scanLoadedChunks(List<Block> blocks, int max, int yLevelThreshold, int maxSearchRadius) {
-        if (blocks.contains(null)) {
-            throw new IllegalStateException("Invalid block name should have been caught earlier: " + blocks.toString());
+    public List<BlockPos> scanLoadedChunks(List<String> blockTypes, int max) {
+        List<Block> asBlocks = blockTypes.stream().map(ChunkPacker::stringToBlock).collect(Collectors.toList());
+        if (asBlocks.contains(null)) {
+            throw new IllegalStateException("Invalid block name should have been caught earlier: " + blockTypes.toString());
         }
         LinkedList<BlockPos> res = new LinkedList<>();
-        if (blocks.isEmpty()) {
+        if (asBlocks.isEmpty()) {
             return res;
         }
         ChunkProviderClient chunkProvider = world().getChunkProvider();
 
-        int maxSearchRadiusSq = maxSearchRadius * maxSearchRadius;
         int playerChunkX = playerFeet().getX() >> 4;
         int playerChunkZ = playerFeet().getZ() >> 4;
-        int playerY = playerFeet().getY();
 
         int searchRadiusSq = 0;
-        boolean foundWithinY = false;
         while (true) {
             boolean allUnloaded = true;
-            boolean foundChunks = false;
             for (int xoff = -searchRadiusSq; xoff <= searchRadiusSq; xoff++) {
                 for (int zoff = -searchRadiusSq; zoff <= searchRadiusSq; zoff++) {
                     int distance = xoff * xoff + zoff * zoff;
                     if (distance != searchRadiusSq) {
                         continue;
                     }
-                    foundChunks = true;
                     int chunkX = xoff + playerChunkX;
                     int chunkZ = zoff + playerChunkZ;
                     Chunk chunk = chunkProvider.getLoadedChunk(chunkX, chunkZ);
@@ -92,12 +79,8 @@ public enum WorldScanner implements Helper {
                             for (int z = 0; z < 16; z++) {
                                 for (int x = 0; x < 16; x++) {
                                     IBlockState state = bsc.get(x, y, z);
-                                    if (blocks.contains(state.getBlock())) {
-                                        int yy = yReal | y;
-                                        res.add(new BlockPos(chunkX | x, yy, chunkZ | z));
-                                        if (Math.abs(yy - playerY) < yLevelThreshold) {
-                                            foundWithinY = true;
-                                        }
+                                    if (asBlocks.contains(state.getBlock())) {
+                                        res.add(new BlockPos(chunkX | x, yReal | y, chunkZ | z));
                                     }
                                 }
                             }
@@ -105,10 +88,10 @@ public enum WorldScanner implements Helper {
                     }
                 }
             }
-            if ((allUnloaded && foundChunks)
-                    || (res.size() >= max
-                    && (searchRadiusSq > maxSearchRadiusSq || (searchRadiusSq > 1 && foundWithinY)))
-            ) {
+            if (allUnloaded) {
+                return res;
+            }
+            if (res.size() >= max && searchRadiusSq > 26) {
                 return res;
             }
             searchRadiusSq++;

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

@@ -2,53 +2,61 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.pathing.calc;
 
 import baritone.Baritone;
-import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.movement.ActionCosts;
+import baritone.chunk.CachedWorld;
+import baritone.chunk.WorldProvider;
 import baritone.pathing.calc.openset.BinaryHeapOpenSet;
+import baritone.pathing.goals.Goal;
+import baritone.pathing.movement.ActionCosts;
 import baritone.pathing.movement.CalculationContext;
-import baritone.pathing.movement.Moves;
+import baritone.pathing.movement.Movement;
+import baritone.pathing.movement.MovementHelper;
+import baritone.pathing.movement.movements.*;
 import baritone.pathing.path.IPath;
 import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
-import baritone.utils.pathing.MoveResult;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ChunkProviderClient;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Optional;
+import java.util.Random;
 
 /**
  * The actual A* pathfinding
  *
  * @author leijurv
  */
-public final class AStarPathFinder extends AbstractNodeCostSearch implements Helper {
+public class AStarPathFinder extends AbstractNodeCostSearch implements Helper {
 
-    private final Optional<HashSet<Long>> favoredPositions;
+    private final Optional<HashSet<BlockPos>> favoredPositions;
 
-    public AStarPathFinder(BlockPos start, Goal goal, Optional<HashSet<Long>> favoredPositions) {
+    public AStarPathFinder(BlockPos start, Goal goal, Optional<Collection<BlockPos>> favoredPositions) {
         super(start, goal);
-        this.favoredPositions = favoredPositions;
+        this.favoredPositions = favoredPositions.map(HashSet::new); // <-- okay this is epic
     }
 
     @Override
     protected Optional<IPath> calculate0(long timeout) {
-        startNode = getNodeAtPosition(start.x, start.y, start.z);
+        startNode = getNodeAtPosition(start);
         startNode.cost = 0;
         startNode.combinedCost = startNode.estimatedCostToGoal;
         BinaryHeapOpenSet openSet = new BinaryHeapOpenSet();
@@ -57,16 +65,18 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
         bestSoFar = new PathNode[COEFFICIENTS.length];//keep track of the best node by the metric of (estimatedCostToGoal + cost / COEFFICIENTS[i])
         double[] bestHeuristicSoFar = new double[COEFFICIENTS.length];
         for (int i = 0; i < bestHeuristicSoFar.length; i++) {
-            bestHeuristicSoFar[i] = startNode.estimatedCostToGoal;
-            bestSoFar[i] = startNode;
+            bestHeuristicSoFar[i] = Double.MAX_VALUE;
         }
         CalculationContext calcContext = new CalculationContext();
-        HashSet<Long> favored = favoredPositions.orElse(null);
+        HashSet<BlockPos> favored = favoredPositions.orElse(null);
+        currentlyRunning = this;
+        CachedWorld cachedWorld = Optional.ofNullable(WorldProvider.INSTANCE.getCurrentWorld()).map(w -> w.cache).orElse(null);
+        ChunkProviderClient chunkProvider = Minecraft.getMinecraft().world.getChunkProvider();
         BlockStateInterface.clearCachedChunk();
         long startTime = System.nanoTime() / 1000000L;
         boolean slowPath = Baritone.settings().slowPath.get();
         if (slowPath) {
-            logDebug("slowPath is on, path timeout will be " + Baritone.settings().slowPathTimeoutMS.<Long>get() + "ms instead of " + timeout + "ms");
+            displayChatMessageRaw("slowPath is on, path timeout will be " + Baritone.settings().slowPathTimeoutMS.<Long>get() + "ms instead of " + timeout + "ms");
         }
         long timeoutTime = startTime + (slowPath ? Baritone.settings().slowPathTimeoutMS.<Long>get() : timeout);
         //long lastPrintout = 0;
@@ -77,7 +87,6 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
         int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.get(); // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior
         double favorCoeff = Baritone.settings().backtrackCostFavoringCoefficient.get();
         boolean minimumImprovementRepropagation = Baritone.settings().minimumImprovementRepropagation.get();
-        loopBegin();
         while (!openSet.isEmpty() && numEmptyChunk < pathingMaxChunkBorderFetch && System.nanoTime() / 1000000L - timeoutTime < 0 && !cancelRequested) {
             if (slowPath) {
                 try {
@@ -88,45 +97,50 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
             PathNode currentNode = openSet.removeLowest();
             currentNode.isOpen = false;
             mostRecentConsidered = currentNode;
+            BlockPos currentNodePos = currentNode.pos;
             numNodes++;
-            if (goal.isInGoal(currentNode.x, currentNode.y, currentNode.z)) {
-                logDebug("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, " + numMovementsConsidered + " movements considered");
-                return Optional.of(new Path(startNode, currentNode, numNodes, goal));
+            if (goal.isInGoal(currentNodePos)) {
+                currentlyRunning = null;
+                displayChatMessageRaw("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, " + numMovementsConsidered + " movements considered");
+                return Optional.of(new Path(startNode, currentNode, numNodes));
             }
-            for (Moves moves : Moves.values()) {
-                int newX = currentNode.x + moves.xOffset;
-                int newZ = currentNode.z + moves.zOffset;
-                if (newX >> 4 != currentNode.x >> 4 || newZ >> 4 != currentNode.z >> 4) {
+            Movement[] possibleMovements = getConnectedPositions(currentNodePos, calcContext);//movement that we could take that start at currentNodePos, in random order
+            shuffle(possibleMovements);
+            for (Movement movementToGetToNeighbor : possibleMovements) {
+                if (movementToGetToNeighbor == null) {
+                    continue;
+                }
+                BlockPos dest = movementToGetToNeighbor.getDest();
+                int chunkX = currentNodePos.getX() >> 4;
+                int chunkZ = currentNodePos.getZ() >> 4;
+                if (dest.getX() >> 4 != chunkX || dest.getZ() >> 4 != chunkZ) {
                     // only need to check if the destination is a loaded chunk if it's in a different chunk than the start of the movement
-                    if (!BlockStateInterface.isLoaded(newX, newZ)) {
-                        if (!moves.dynamicXZ) { // only increment the counter if the movement would have gone out of bounds guaranteed
+                    if (chunkProvider.getLoadedChunk(chunkX, chunkZ) == null) {
+                        // see issue #106
+                        if (cachedWorld == null || !cachedWorld.isCached(dest)) {
                             numEmptyChunk++;
+                            continue;
                         }
-                        continue;
                     }
                 }
-                MoveResult res = moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z);
+                // TODO cache cost
+                double actionCost = movementToGetToNeighbor.getCost(calcContext);
                 numMovementsConsidered++;
-                double actionCost = res.cost;
                 if (actionCost >= ActionCosts.COST_INF) {
                     continue;
                 }
-                // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
-                if (!moves.dynamicXZ && (res.destX != newX || res.destZ != newZ)) {
-                    throw new IllegalStateException(moves + " " + res.destX + " " + newX + " " + res.destZ + " " + newZ);
-                }
                 if (actionCost <= 0) {
-                    throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
+                    throw new IllegalStateException(movementToGetToNeighbor.getClass() + " " + movementToGetToNeighbor + " calculated implausible cost " + actionCost);
                 }
-                if (favoring && favored.contains(posHash(res.destX, res.destY, res.destZ))) {
+                if (favoring && favored.contains(dest)) {
                     // see issue #18
                     actionCost *= favorCoeff;
                 }
-                PathNode neighbor = getNodeAtPosition(res.destX, res.destY, res.destZ);
+                PathNode neighbor = getNodeAtPosition(dest);
                 double tentativeCost = currentNode.cost + actionCost;
                 if (tentativeCost < neighbor.cost) {
                     if (tentativeCost < 0) {
-                        throw new IllegalStateException(moves + " overflowed into negative " + actionCost + " " + neighbor.cost + " " + tentativeCost);
+                        throw new IllegalStateException(movementToGetToNeighbor.getClass() + " " + movementToGetToNeighbor + " overflowed into negative " + actionCost + " " + neighbor.cost + " " + tentativeCost);
                     }
                     double improvementBy = neighbor.cost - tentativeCost;
                     // there are floating point errors caused by random combinations of traverse and diagonal over a flat area
@@ -137,13 +151,14 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                         continue;
                     }
                     neighbor.previous = currentNode;
+                    neighbor.previousMovement = movementToGetToNeighbor;
                     neighbor.cost = tentativeCost;
                     neighbor.combinedCost = tentativeCost + neighbor.estimatedCostToGoal;
                     if (neighbor.isOpen) {
                         openSet.update(neighbor);
                     } else {
-                        neighbor.isOpen = true;
                         openSet.insert(neighbor);//dont double count, dont insert into open set if it's already there
+                        neighbor.isOpen = true;
                     }
                     for (int i = 0; i < bestSoFar.length; i++) {
                         double heuristic = neighbor.estimatedCostToGoal + neighbor.cost / COEFFICIENTS[i];
@@ -159,11 +174,11 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
             }
         }
         if (cancelRequested) {
+            currentlyRunning = null;
             return Optional.empty();
         }
         System.out.println(numMovementsConsidered + " movements considered");
         System.out.println("Open set size: " + openSet.size());
-        System.out.println("PathNode map size: " + mapSize());
         System.out.println((int) (numNodes * 1.0 / ((System.nanoTime() / 1000000L - startTime) / 1000F)) + " nodes per second");
         double bestDist = 0;
         for (int i = 0; i < bestSoFar.length; i++) {
@@ -175,18 +190,67 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 bestDist = dist;
             }
             if (dist > MIN_DIST_PATH * MIN_DIST_PATH) { // square the comparison since distFromStartSq is squared
-                logDebug("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, A* cost coefficient " + COEFFICIENTS[i] + ", " + numMovementsConsidered + " movements considered");
+                displayChatMessageRaw("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, A* cost coefficient " + COEFFICIENTS[i] + ", " + numMovementsConsidered + " movements considered");
                 if (COEFFICIENTS[i] >= 3) {
                     System.out.println("Warning: cost coefficient is greater than three! Probably means that");
                     System.out.println("the path I found is pretty terrible (like sneak-bridging for dozens of blocks)");
                     System.out.println("But I'm going to do it anyway, because yolo");
                 }
                 System.out.println("Path goes for " + Math.sqrt(dist) + " blocks");
-                return Optional.of(new Path(startNode, bestSoFar[i], numNodes, goal));
+                currentlyRunning = null;
+                return Optional.of(new Path(startNode, bestSoFar[i], numNodes));
             }
         }
-        logDebug("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + Math.sqrt(bestDist) + " blocks");
-        logDebug("No path found =(");
+        displayChatMessageRaw("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + Math.sqrt(bestDist) + " blocks");
+        displayChatMessageRaw("No path found =(");
+        currentlyRunning = null;
         return Optional.empty();
     }
+
+
+    public static Movement[] getConnectedPositions(BlockPos pos, CalculationContext calcContext) {
+        int x = pos.getX();
+        int y = pos.getY();
+        int z = pos.getZ();
+        BlockPos east = new BlockPos(x + 1, y, z);
+        BlockPos west = new BlockPos(x - 1, y, z);
+        BlockPos south = new BlockPos(x, y, z + 1);
+        BlockPos north = new BlockPos(x, y, z - 1);
+        return new Movement[]{
+                new MovementTraverse(pos, east),
+                new MovementTraverse(pos, west),
+                new MovementTraverse(pos, north),
+                new MovementTraverse(pos, south),
+                new MovementAscend(pos, new BlockPos(x + 1, y + 1, z)),
+                new MovementAscend(pos, new BlockPos(x - 1, y + 1, z)),
+                new MovementAscend(pos, new BlockPos(x, y + 1, z + 1)),
+                new MovementAscend(pos, new BlockPos(x, y + 1, z - 1)),
+                MovementHelper.generateMovementFallOrDescend(pos, east, calcContext),
+                MovementHelper.generateMovementFallOrDescend(pos, west, calcContext),
+                MovementHelper.generateMovementFallOrDescend(pos, north, calcContext),
+                MovementHelper.generateMovementFallOrDescend(pos, south, calcContext),
+                new MovementDownward(pos, new BlockPos(x, y - 1, z)),
+                new MovementDiagonal(pos, EnumFacing.NORTH, EnumFacing.WEST),
+                new MovementDiagonal(pos, EnumFacing.NORTH, EnumFacing.EAST),
+                new MovementDiagonal(pos, EnumFacing.SOUTH, EnumFacing.WEST),
+                new MovementDiagonal(pos, EnumFacing.SOUTH, EnumFacing.EAST),
+                new MovementPillar(pos, new BlockPos(x, y + 1, z)),
+                MovementParkour.calculate(pos, EnumFacing.NORTH),
+                MovementParkour.calculate(pos, EnumFacing.SOUTH),
+                MovementParkour.calculate(pos, EnumFacing.EAST),
+                MovementParkour.calculate(pos, EnumFacing.WEST),
+        };
+    }
+
+    private final Random random = new Random();
+
+    private <T> void shuffle(T[] list) {
+        int len = list.length;
+        for (int i = 0; i < len; i++) {
+            int j = random.nextInt(len);
+            T t = list[j];
+            list[j] = list[i];
+            list[i] = t;
+        }
+    }
 }

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

@@ -2,27 +2,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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.pathing.calc;
 
-import baritone.api.pathing.goals.Goal;
+import baritone.behavior.impl.PathingBehavior;
+import baritone.pathing.goals.Goal;
 import baritone.pathing.path.IPath;
-import baritone.utils.pathing.BetterBlockPos;
-import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import net.minecraft.util.math.BlockPos;
 
+import java.util.HashMap;
 import java.util.Optional;
 
 /**
@@ -35,16 +35,13 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
     /**
      * The currently running search task
      */
-    private static AbstractNodeCostSearch currentlyRunning = null;
+    protected static AbstractNodeCostSearch currentlyRunning = null;
 
-    protected final BetterBlockPos start;
+    protected final BlockPos start;
 
     protected final Goal goal;
 
-    /**
-     * @see <a href="https://github.com/cabaletta/baritone/issues/107">Issue #107</a>
-     */
-    private final Long2ObjectOpenHashMap<PathNode> map;
+    private final HashMap<BlockPos, PathNode> map; // see issue #107
 
     protected PathNode startNode;
 
@@ -69,9 +66,9 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
     protected final static double MIN_DIST_PATH = 5;
 
     AbstractNodeCostSearch(BlockPos start, Goal goal) {
-        this.start = new BetterBlockPos(start.getX(), start.getY(), start.getZ());
+        this.start = new BlockPos(start.getX(), start.getY(), start.getZ());
         this.goal = goal;
-        this.map = new Long2ObjectOpenHashMap<>();
+        this.map = new HashMap<>();
     }
 
     public void cancel() {
@@ -85,24 +82,19 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
         this.cancelRequested = false;
         try {
             Optional<IPath> path = calculate0(timeout);
-            path.ifPresent(IPath::postprocess);
             isFinished = true;
             return path;
-        } finally {
-            // this is run regardless of what exception may or may not be raised by calculate0
+        } catch (Exception e) {
             currentlyRunning = null;
             isFinished = true;
+            if (e instanceof RuntimeException) {
+                throw (RuntimeException) e;
+            } else {
+                throw new RuntimeException(e);
+            }
         }
     }
 
-    /**
-     * Don't set currentlyRunning to this until everything is all ready to go, and we're about to enter the main loop.
-     * For example, bestSoFar is null so bestPathSoFar (which gets bestSoFar[0]) could NPE if we set currentlyRunning before calculate0
-     */
-    protected void loopBegin() {
-        currentlyRunning = this;
-    }
-
     protected abstract Optional<IPath> calculate0(long timeout);
 
     /**
@@ -114,9 +106,9 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      * @return The distance, squared
      */
     protected double getDistFromStartSq(PathNode n) {
-        int xDiff = n.x - start.x;
-        int yDiff = n.y - start.y;
-        int zDiff = n.z - start.z;
+        int xDiff = n.pos.getX() - start.getX();
+        int yDiff = n.pos.getY() - start.getY();
+        int zDiff = n.pos.getZ() - start.getZ();
         return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
     }
 
@@ -125,66 +117,27 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      * for the node mapped to the specified pos. If no node is found,
      * a new node is created.
      *
+     * @param pos The pos to lookup
      * @return The associated node
-     * @see <a href="https://github.com/cabaletta/baritone/issues/107">Issue #107</a>
      */
-    protected PathNode getNodeAtPosition(int x, int y, int z) {
-        long hashCode = posHash(x, y, z);
-        PathNode node = map.get(hashCode);
+    protected PathNode getNodeAtPosition(BlockPos pos) {
+        // see issue #107
+        PathNode node = map.get(pos);
         if (node == null) {
-            node = new PathNode(x, y, z, goal);
-            map.put(hashCode, node);
+            node = new PathNode(pos, goal);
+            map.put(pos, node);
         }
         return node;
     }
 
-    public static long posHash(int x, int y, int z) {
-        /*
-         *   This is the hashcode implementation of Vec3i, the superclass of BlockPos
-         *
-         *   public int hashCode() {
-         *       return (this.getY() + this.getZ() * 31) * 31 + this.getX();
-         *   }
-         *
-         *   That is terrible and has tons of collisions and makes the HashMap terribly inefficient.
-         *
-         *   That's why we grab out the X, Y, Z and calculate our own hashcode
-         */
-        long hash = 3241;
-        hash = 3457689L * hash + x;
-        hash = 8734625L * hash + y;
-        hash = 2873465L * hash + z;
-        return hash;
-    }
-
     public static void forceCancel() {
+        PathingBehavior.INSTANCE.cancel();
         currentlyRunning = null;
     }
 
-    public PathNode mostRecentNodeConsidered() {
-        return mostRecentConsidered;
-    }
-
-    public PathNode bestNodeSoFar() {
-        return bestSoFar[0];
-    }
-
-    public PathNode startNode() {
-        return startNode;
-    }
-
     @Override
     public Optional<IPath> pathToMostRecentNodeConsidered() {
-        try {
-            return Optional.ofNullable(mostRecentConsidered).map(node -> new Path(startNode, node, 0, goal));
-        } catch (IllegalStateException ex) {
-            System.out.println("Unable to construct path to render");
-            return Optional.empty();
-        }
-    }
-
-    protected int mapSize() {
-        return map.size();
+        return Optional.ofNullable(mostRecentConsidered).map(node -> new Path(startNode, node, 0));
     }
 
     @Override
@@ -197,12 +150,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
                 continue;
             }
             if (getDistFromStartSq(bestSoFar[i]) > MIN_DIST_PATH * MIN_DIST_PATH) { // square the comparison since distFromStartSq is squared
-                try {
-                    return Optional.of(new Path(startNode, bestSoFar[i], 0, goal));
-                } catch (IllegalStateException ex) {
-                    System.out.println("Unable to construct path to render");
-                    return Optional.empty();
-                }
+                return Optional.of(new Path(startNode, bestSoFar[i], 0));
             }
         }
         // instead of returning bestSoFar[0], be less misleading

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

@@ -2,22 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.pathing.calc;
 
-import baritone.api.pathing.goals.Goal;
+import baritone.pathing.goals.Goal;
 import baritone.pathing.path.IPath;
 import net.minecraft.util.math.BlockPos;
 

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

@@ -2,26 +2,24 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.pathing.calc;
 
-import baritone.api.pathing.goals.Goal;
 import baritone.pathing.movement.Movement;
-import baritone.pathing.movement.Moves;
 import baritone.pathing.path.IPath;
-import baritone.utils.pathing.BetterBlockPos;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.ArrayList;
@@ -39,40 +37,31 @@ class Path implements IPath {
     /**
      * The start position of this path
      */
-    private final BetterBlockPos start;
+    final BlockPos start;
 
     /**
      * The end position of this path
      */
-    private final BetterBlockPos end;
+    final BlockPos end;
 
     /**
      * The blocks on the path. Guaranteed that path.get(0) equals start and
      * path.get(path.size()-1) equals end
      */
-    private final List<BetterBlockPos> path;
+    final List<BlockPos> path;
 
-    private final List<Movement> movements;
-
-    private final Goal goal;
+    final List<Movement> movements;
 
     private final int numNodes;
 
-    private volatile boolean verified;
-
-    Path(PathNode start, PathNode end, int numNodes, Goal goal) {
-        this.start = new BetterBlockPos(start.x, start.y, start.z);
-        this.end = new BetterBlockPos(end.x, end.y, end.z);
+    Path(PathNode start, PathNode end, int numNodes) {
+        this.start = start.pos;
+        this.end = end.pos;
         this.numNodes = numNodes;
         this.path = new ArrayList<>();
         this.movements = new ArrayList<>();
-        this.goal = goal;
         assemblePath(start, end);
-    }
-
-    @Override
-    public Goal getGoal() {
-        return goal;
+        sanityCheck();
     }
 
     /**
@@ -86,14 +75,14 @@ class Path implements IPath {
             throw new IllegalStateException();
         }
         PathNode current = end;
-        LinkedList<BetterBlockPos> tempPath = new LinkedList<>(); // Repeatedly inserting to the beginning of an arraylist is O(n^2)
+        LinkedList<BlockPos> tempPath = new LinkedList<>(); // Repeatedly inserting to the beginning of an arraylist is O(n^2)
         LinkedList<Movement> tempMovements = new LinkedList<>(); // Instead, do it into a linked list, then convert at the end
         while (!current.equals(start)) {
-            tempPath.addFirst(new BetterBlockPos(current.x, current.y, current.z));
-            tempMovements.addFirst(runBackwards(current.previous, current));
+            tempPath.addFirst(current.pos);
+            tempMovements.addFirst(current.previousMovement);
             current = current.previous;
         }
-        tempPath.addFirst(this.start);
+        tempPath.addFirst(start.pos);
         // Can't directly convert from the PathNode pseudo linked list to an array because we don't know how long it is
         // inserting into a LinkedList<E> keeps track of length, then when we addall (which calls .toArray) it's able
         // to performantly do that conversion since it knows the length.
@@ -101,19 +90,6 @@ class Path implements IPath {
         movements.addAll(tempMovements);
     }
 
-    private static Movement runBackwards(PathNode src0, PathNode dest0) { // TODO this is horrifying
-        BetterBlockPos src = new BetterBlockPos(src0.x, src0.y, src0.z);
-        BetterBlockPos dest = new BetterBlockPos(dest0.x, dest0.y, dest0.z);
-        for (Moves moves : Moves.values()) {
-            Movement move = moves.apply0(src);
-            if (move.getDest().equals(dest)) {
-                return move;
-            }
-        }
-        // leave this as IllegalStateException; it's caught in AbstractNodeCostSearch
-        throw new IllegalStateException("Movement became impossible during calculation " + src + " " + dest + " " + dest.subtract(src));
-    }
-
     /**
      * Performs a series of checks to ensure that the assembly of the path went as expected.
      */
@@ -140,27 +116,13 @@ class Path implements IPath {
         }
     }
 
-    @Override
-    public void postprocess() {
-        if (verified) {
-            throw new IllegalStateException();
-        }
-        verified = true;
-        // more post processing here
-        movements.forEach(Movement::checkLoadedChunk);
-        sanityCheck();
-    }
-
     @Override
     public List<Movement> movements() {
-        if (!verified) {
-            throw new IllegalStateException();
-        }
         return Collections.unmodifiableList(movements);
     }
 
     @Override
-    public List<BetterBlockPos> positions() {
+    public List<BlockPos> positions() {
         return Collections.unmodifiableList(path);
     }
 
@@ -170,12 +132,12 @@ class Path implements IPath {
     }
 
     @Override
-    public BetterBlockPos getSrc() {
+    public BlockPos getSrc() {
         return start;
     }
 
     @Override
-    public BetterBlockPos getDest() {
+    public BlockPos getDest() {
         return end;
     }
 }

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

@@ -2,23 +2,24 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package baritone.pathing.calc;
 
-import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.movement.ActionCosts;
+import baritone.pathing.goals.Goal;
+import baritone.pathing.movement.Movement;
+import net.minecraft.util.math.BlockPos;
 
 /**
  * A node in the path, containing the cost and steps to get to it.
@@ -30,9 +31,12 @@ public final class PathNode {
     /**
      * The position of this node
      */
-    final int x;
-    final int y;
-    final int z;
+    final BlockPos pos;
+
+    /**
+     * The goal it's going towards
+     */
+    final Goal goal;
 
     /**
      * Cached, should always be equal to goal.heuristic(pos)
@@ -57,6 +61,12 @@ public final class PathNode {
      */
     PathNode previous;
 
+    /**
+     * In the graph search, what previous movement (edge) was taken to get to here
+     * Mutable and changed by PathFinder
+     */
+    Movement previousMovement;
+
     /**
      * Is this a member of the open set in A*? (only used during pathfinding)
      * Instead of doing a costly member check in the open set, cache membership in each node individually too.
@@ -68,14 +78,14 @@ public final class PathNode {
      */
     public int heapPosition;
 
-    public PathNode(int x, int y, int z, Goal goal) {
+    public PathNode(BlockPos pos, Goal goal) {
+        this.pos = pos;
         this.previous = null;
-        this.cost = ActionCosts.COST_INF;
-        this.estimatedCostToGoal = goal.heuristic(x, y, z);
+        this.cost = Short.MAX_VALUE;
+        this.goal = goal;
+        this.estimatedCostToGoal = goal.heuristic(pos);
+        this.previousMovement = null;
         this.isOpen = false;
-        this.x = x;
-        this.y = y;
-        this.z = z;
     }
 
     /**
@@ -85,7 +95,7 @@ public final class PathNode {
      */
     @Override
     public int hashCode() {
-        return (int) AbstractNodeCostSearch.posHash(x, y, z);
+        return pos.hashCode() * 7 + 3;
     }
 
     @Override
@@ -97,9 +107,8 @@ public final class PathNode {
         //    return false;
         //}
 
-        final PathNode other = (PathNode) obj;
+        //final PathNode other = (PathNode) obj;
         //return Objects.equals(this.pos, other.pos) && Objects.equals(this.goal, other.goal);
-
-        return x == other.x && y == other.y && z == other.z;
+        return this.pos.equals(((PathNode) obj).pos);
     }
 }

src/main/java/baritone/pathing/calc/openset/BinaryHeapOpenSet.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/main/java/baritone/pathing/calc/openset/IOpenSet.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 

src/main/java/baritone/pathing/calc/openset/LinkedListOpenSet.java

@@ -2,16 +2,16 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
@@ -83,7 +83,7 @@ class LinkedListOpenSet implements IOpenSet {
     }
 
     public static class Node { //wrapper with next
-        private Node nextOpen;
-        private PathNode val;
+        Node nextOpen;
+        PathNode val;
     }
 }

src/main/java/baritone/pathing/goals/Goal.java

@@ -2,21 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
+package baritone.pathing.goals;
 
+import baritone.pathing.movement.ActionCosts;
 import net.minecraft.util.math.BlockPos;
 
 /**
@@ -24,28 +25,22 @@ import net.minecraft.util.math.BlockPos;
  *
  * @author leijurv
  */
-public interface Goal {
+public interface Goal extends ActionCosts {
 
     /**
      * Returns whether or not the specified position
      * meets the requirement for this goal based.
      *
+     * @param pos The position
      * @return Whether or not it satisfies this goal
      */
-    boolean isInGoal(int x, int y, int z);
+    boolean isInGoal(BlockPos pos);
 
     /**
      * Estimate the number of ticks it will take to get to the goal
      *
+     * @param pos The
      * @return The estimate number of ticks to satisfy the goal
      */
-    double heuristic(int x, int y, int z);
-
-    default boolean isInGoal(BlockPos pos) {
-        return isInGoal(pos.getX(), pos.getY(), pos.getZ());
-    }
-
-    default double heuristic(BlockPos pos) {
-        return heuristic(pos.getX(), pos.getY(), pos.getZ());
-    }
+    double heuristic(BlockPos pos);
 }

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

@@ -2,22 +2,22 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
+package baritone.pathing.goals;
 
-import baritone.api.utils.interfaces.IGoalRenderPos;
+import baritone.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
 /**
@@ -53,27 +53,36 @@ public class GoalBlock implements Goal, IGoalRenderPos {
     }
 
     @Override
-    public boolean isInGoal(int x, int y, int z) {
-        return x == this.x && y == this.y && z == this.z;
+    public boolean isInGoal(BlockPos pos) {
+        return pos.getX() == this.x && pos.getY() == this.y && pos.getZ() == this.z;
     }
 
+    /**
+     * The min range value over which to begin considering Y coordinate in the heuristic
+     */
+    private static final double MIN = 20;
+
+    /**
+     * The max range value over which to begin considering Y coordinate in the heuristic
+     */
+    private static final double MAX = 150;
+
     @Override
-    public double heuristic(int x, int y, int z) {
-        int xDiff = x - this.x;
-        int yDiff = y - this.y;
-        int zDiff = z - this.z;
+    public double heuristic(BlockPos pos) {
+        int xDiff = pos.getX() - this.x;
+        int yDiff = pos.getY() - this.y;
+        int zDiff = pos.getZ() - this.z;
         return calculate(xDiff, yDiff, zDiff);
     }
 
     @Override
     public String toString() {
-        return "GoalBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
+        return "Goal{x=" + x + ",y=" + y + ",z=" + z + "}";
     }
 
     /**
      * @return The position of this goal as a {@link BlockPos}
      */
-    @Override
     public BlockPos getGoalPos() {
         return new BlockPos(x, y, z);
     }
@@ -83,7 +92,7 @@ public class GoalBlock implements Goal, IGoalRenderPos {
 
         // if yDiff is 1 that means that pos.getY()-this.y==1 which means that we're 1 block below where we should be
         // therefore going from 0,0,0 to a GoalYLevel of pos.getY()-this.y is accurate
-        heuristic += GoalYLevel.calculate(yDiff, 0);
+        heuristic += new GoalYLevel(yDiff).heuristic(new BlockPos(0, 0, 0));
 
         //use the pythagorean and manhattan mixture from GoalXZ
         heuristic += GoalXZ.calculate(xDiff, zDiff);

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

@@ -2,25 +2,24 @@
  * 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
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
-
-import net.minecraft.util.math.BlockPos;
+package baritone.pathing.goals;
 
 import java.util.Arrays;
 import java.util.Collection;
+import net.minecraft.util.math.BlockPos;
 
 /**
  * A composite of many goals, any one of which satisfies the composite.
@@ -34,7 +33,7 @@ public class GoalComposite implements Goal {
     /**
      * An array of goals that any one of must be satisfied
      */
-    private final Goal[] goals;
+    public final Goal[] goals;
 
     public GoalComposite(Goal... goals) {
         this.goals = goals;
@@ -49,21 +48,15 @@ public class GoalComposite implements Goal {
     }
 
     @Override
-    public boolean isInGoal(int x, int y, int z) {
-        for (Goal goal : goals) {
-            if (goal.isInGoal(x, y, z)) {
-                return true;
-            }
-        }
-        return false;
+    public boolean isInGoal(BlockPos pos) {
+        return Arrays.stream(this.goals).anyMatch(goal -> goal.isInGoal(pos));
     }
 
     @Override
-    public double heuristic(int x, int y, int z) {
+    public double heuristic(BlockPos pos) {
         double min = Double.MAX_VALUE;
         for (Goal g : goals) {
-            // TODO technically this isn't admissible...?
-            min = Math.min(min, g.heuristic(x, y, z)); // whichever is closest
+            min = Math.min(min, g.heuristic(pos)); // whichever is closest
         }
         return min;
     }

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

@@ -2,22 +2,23 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
+package baritone.pathing.goals;
 
-import baritone.api.utils.interfaces.IGoalRenderPos;
+import baritone.utils.interfaces.IGoalRenderPos;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.BlockPos;
 
 
@@ -38,16 +39,15 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
         this.z = pos.getZ();
     }
 
-    @Override
     public BlockPos getGoalPos() {
         return new BlockPos(x, y, z);
     }
 
     @Override
-    public boolean isInGoal(int x, int y, int z) {
-        int xDiff = x - this.x;
-        int yDiff = y - this.y;
-        int zDiff = z - this.z;
+    public boolean isInGoal(BlockPos pos) {
+        int xDiff = pos.getX() - this.x;
+        int yDiff = pos.getY() - this.y;
+        int zDiff = pos.getZ() - this.z;
         if (yDiff < 0) {
             yDiff++;
         }
@@ -55,15 +55,10 @@ public class GoalGetToBlock implements Goal, IGoalRenderPos {
     }
 
     @Override
-    public double heuristic(int x, int y, int z) {
-        int xDiff = x - this.x;
-        int yDiff = y - this.y;
-        int zDiff = z - this.z;
+    public double heuristic(BlockPos pos) {
+        int xDiff = pos.getX() - this.x;
+        int yDiff = pos.getY() - this.y;
+        int zDiff = pos.getZ() - this.z;
         return GoalBlock.calculate(xDiff, yDiff, zDiff);
     }
-
-    @Override
-    public String toString() {
-        return "GoalGetToBlock{x=" + x + ",y=" + y + ",z=" + z + "}";
-    }
 }

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

@@ -2,29 +2,29 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
+package baritone.pathing.goals;
 
-import baritone.api.utils.interfaces.IGoalRenderPos;
+import baritone.utils.interfaces.IGoalRenderPos;
 import net.minecraft.util.math.BlockPos;
 
 public class GoalNear implements Goal, IGoalRenderPos {
-    private final int x;
-    private final int y;
-    private final int z;
-    private final int rangeSq;
+    final int x;
+    final int y;
+    final int z;
+    final int rangeSq;
 
     public GoalNear(BlockPos pos, int range) {
         this.x = pos.getX();
@@ -34,22 +34,21 @@ public class GoalNear implements Goal, IGoalRenderPos {
     }
 
     @Override
-    public boolean isInGoal(int x, int y, int z) {
-        int xDiff = x - this.x;
-        int yDiff = y - this.y;
-        int zDiff = z - this.z;
-        return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff <= rangeSq;
+    public boolean isInGoal(BlockPos pos) {
+        int diffX = x - pos.getX();
+        int diffY = y - pos.getY();
+        int diffZ = z - pos.getZ();
+        return diffX * diffX + diffY * diffY + diffZ * diffZ <= rangeSq;
     }
 
     @Override
-    public double heuristic(int x, int y, int z) {
-        int xDiff = x - this.x;
-        int yDiff = y - this.y;
-        int zDiff = z - this.z;
-        return GoalBlock.calculate(xDiff, yDiff, zDiff);
+    public double heuristic(BlockPos pos) {
+        int diffX = x - pos.getX();
+        int diffY = y - pos.getY();
+        int diffZ = z - pos.getZ();
+        return GoalBlock.calculate(diffX, diffY, diffZ);
     }
 
-    @Override
     public BlockPos getGoalPos() {
         return new BlockPos(x, y, z);
     }

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

@@ -2,35 +2,33 @@
  * This file is part of Baritone.
  *
  * Baritone is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
+ * it under the terms of the GNU 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.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package baritone.api.pathing.goals;
-
-import net.minecraft.util.math.BlockPos;
+package baritone.pathing.goals;
 
 import java.util.Arrays;
+import net.minecraft.util.math.BlockPos;
 
 /**
  * Useful for automated combat (retreating specifically)
- *
  * @author leijurv
  */
 public class GoalRunAway implements Goal {
 
-    private final BlockPos[] from;
+    public final BlockPos[] from;
 
-    private final double distanceSq;
+    final double distanceSq;
 
     public GoalRunAway(double distance, BlockPos... from) {
         if (from.length == 0) {
@@ -41,10 +39,10 @@ public class GoalRunAway implements Goal {
     }
 
     @Override
-    public boolean isInGoal(int x, int y, int z) {
+    public boolean isInGoal(BlockPos pos) {
         for (BlockPos p : from) {
-            int diffX = x - p.getX();
-            int diffZ = z - p.getZ();
+            int diffX = pos.getX() - p.getX();
+            int diffZ = pos.getZ() - p.getZ();
             double distSq = diffX * diffX + diffZ * diffZ;
             if (distSq < distanceSq) {
                 return false;
@@ -54,10 +52,10 @@ public class GoalRunAway implements Goal {
     }
 
     @Override
-    public double heuristic(int x, int y, int z) {//mostly copied from GoalBlock
+    public double heuristic(BlockPos pos) {//mostly copied from GoalBlock
         double min = Double.MAX_VALUE;
         for (BlockPos p : from) {
-            double h = GoalXZ.calculate(p.getX() - x, p.getZ() - z);
+            double h = GoalXZ.calculate(p.getX() - pos.getX(), p.getZ() - pos.getZ());
             if (h < min) {
                 min = h;
             }
@@ -67,6 +65,6 @@ public class GoalRunAway implements Goal {
 
     @Override
     public String toString() {
-        return "GoalRunAwayFrom" + Arrays.asList(from);
+        return "GoalRunAwayFrom[" + Arrays.asList(from) + "]";
     }
 }