From 9f5d9bceaaa2fd7c761313a648ce1b8157080c23 Mon Sep 17 00:00:00 2001
From: ads123ads <33590926+ads123ads@users.noreply.github.com>
Date: Tue, 15 Oct 2019 15:34:22 +0530
Subject: [PATCH 01/20] The grammar mistakes were corrected

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 90173889d..0891e127c 100644
--- a/README.md
+++ b/README.md
@@ -31,14 +31,14 @@ A Minecraft pathfinder bot.
 
 Baritone is the pathfinding system used in [Impact](https://impactclient.net/) since 4.4. There's a [showcase video](https://www.youtube.com/watch?v=yI8hgW_m6dQ) made by @Adovin#3153 on Baritone's integration into Impact. [Here's](https://www.youtube.com/watch?v=StquF69-_wI) a video I made showing off what it can do.
 
-The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* forge api jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
+The easiest way to install Baritone is to install [Impact](https://impactclient.net/), which comes with Baritone. The second easiest way (for 1.12.2 only) is to install the v1.2.* forge API jar from [releases](https://github.com/cabaletta/baritone/releases). Otherwise, see [Installation & setup](SETUP.md). Once Baritone is installed, look [here](USAGE.md) for instructions on how to use it.
 
 For 1.14.4, [click here](https://www.dropbox.com/s/rkml3hjokd3qv0m/1.14.4-Baritone.zip?dl=1). Or [with optifine](https://github.com/cabaletta/baritone/issues/797).
 
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8.9, rebuilt for 1.12.2 and 1.13.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).
 
-Have committed at least once a day from Aug 1 2018 to Aug 1 2019.
+Have committed at least once a day from Aug 1, 2018, to Aug 1, 2019.
 
 1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2
 
@@ -62,7 +62,7 @@ The API is heavily documented, you can find the Javadocs for the latest release
 Please note that usage of anything located outside of the ``baritone.api`` package is not supported by the API release
 jar.
 
-Below is an example of basic usage for changing some settings, and then pathing to a X/Z goal.
+Below is an example of basic usage for changing some settings, and then pathing to an X/Z goal.
 
 ```
 BaritoneAPI.getSettings().allowSprint.value = true;
@@ -75,7 +75,7 @@ BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAnd
 
 ## Can I use Baritone as a library in my custom utility client?
 
-That's what it's for, sure! (As long as usage is in compliance with the LGPL 3.0 License)
+That's what it's for, sure! (As long as usage complies with the LGPL 3.0 License)
 
 ## How is it so fast?
 

From 0fba32853b61891ee9608bad4553c0dad9c6ec03 Mon Sep 17 00:00:00 2001
From: Conner Vercellino <connervercellino@gmail.com>
Date: Wed, 20 Nov 2019 12:26:37 -0800
Subject: [PATCH 02/20] Create .gitmessage

---
 .gitmessage | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 .gitmessage

diff --git a/.gitmessage b/.gitmessage
new file mode 100644
index 000000000..259d0702f
--- /dev/null
+++ b/.gitmessage
@@ -0,0 +1,31 @@
+<emoji> <title> (<ticket>)
+
+# 📝 Update README.md (WD-1234)
+# ✅ Add unit test for inputs (WD-1234)
+
+# <emoji> can be:
+# 🎨 :art: when improving structure of the code
+# ⚡️ :zap: when improving performance
+# 🔥 :fire: when removing code or files
+# ✨ :sparkles: when introducing new features
+# 🚧 :construction: when work in progress
+# 🔨 :hammer: when refactoring code
+# 📝 :memo: when writing docs
+# 💄 :lipstick: when updating the UI and style files
+# 📈 :chart_with_upwards_trend: when adding analytics or tracking code
+# 🌐 :globe_with_meridians: when adding internationalization and localization
+# ✏️ :pencil2: when fixing typos
+# 🚚 :truck: when moving or renaming files
+# ✅ :white_check_mark: when adding tests
+
+# 👌 :ok_hand: when updating code due to code review changes
+# 🐛 :bug: when fixing a bug
+# 🚑 :ambulance: when doing a critical hotfix
+# 🚨 :rotating_light: when removing linter warnings
+
+# 🔀 :twisted_rightwards_arrows: when merging branches
+# ⬆️ :arrow_up: when upgrading dependencies
+# ⬇️ :arrow_down: when downgrading dependencies
+# 🔧 :wrench: when changing configuration files
+# 🔖 :bookmark: when releasing / version tagging
+# 💚 :green_heart: when fixing the CI build

From 4c79701d22633d9626eb9185ddbb904803099b5a Mon Sep 17 00:00:00 2001
From: aUniqueUser <ds458@pm.me>
Date: Sat, 29 Feb 2020 11:28:18 -0500
Subject: [PATCH 03/20] Make desktop notifications more useful

---
 src/api/java/baritone/api/Settings.java       | 27 ++++++++++++++++++-
 .../java/baritone/process/BuilderProcess.java |  4 +++
 .../baritone/process/CustomGoalProcess.java   |  4 +++
 .../java/baritone/process/ExploreProcess.java |  7 +++++
 .../java/baritone/process/FarmProcess.java    |  4 +++
 .../java/baritone/process/MineProcess.java    |  4 +++
 6 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 1bbde3b2b..5fd6b64c5 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -1047,10 +1047,35 @@ public final class Settings {
     public final Setting<Boolean> renderSelectionCorners = new Setting<>(true);
 
     /**
-     * Desktop Notifications
+     * Desktop notifications
      */
     public final Setting<Boolean> desktopNotifications = new Setting<>(false);
 
+    /**
+     * Desktop notification on path complete
+     */
+    public final Setting<Boolean> notificationOnPathComplete = new Setting<>(true);
+
+    /**
+     * Desktop notification on farm fail
+     */
+    public final Setting<Boolean> notificationOnFarmFail = new Setting<>(true);
+
+    /**
+     * Desktop notification on build finished
+     */
+    public final Setting<Boolean> notificationOnBuildFinished = new Setting<>(true);
+
+    /**
+     * Desktop notification on explore finished
+     */
+    public final Setting<Boolean> notificationOnExploreFinished = new Setting<>(true);
+
+    /**
+     * Desktop notification on mine fail
+     */
+    public final Setting<Boolean> notificationOnMineFail = new Setting<>(true);
+
     /**
      * A map of lowercase setting field names to their respective setting
      */
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
index 5af434923..4d57a3478 100644
--- a/src/main/java/baritone/process/BuilderProcess.java
+++ b/src/main/java/baritone/process/BuilderProcess.java
@@ -39,6 +39,7 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
+import baritone.utils.NotificationHelper;
 import baritone.utils.PathingCommandContext;
 import baritone.utils.schematic.MapArtSchematic;
 import baritone.utils.schematic.SchematicSystem;
@@ -406,6 +407,9 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
             numRepeats++;
             if (repeat.equals(new Vec3i(0, 0, 0)) || (max != -1 && numRepeats >= max)) {
                 logDirect("Done building");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnBuildFinished.value) {
+                    NotificationHelper.notify("Done building", false);
+                }
                 onLostControl();
                 return null;
             }
diff --git a/src/main/java/baritone/process/CustomGoalProcess.java b/src/main/java/baritone/process/CustomGoalProcess.java
index b45c7d6f9..f925bec79 100644
--- a/src/main/java/baritone/process/CustomGoalProcess.java
+++ b/src/main/java/baritone/process/CustomGoalProcess.java
@@ -23,6 +23,7 @@ import baritone.api.process.ICustomGoalProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 
 /**
  * As set by ExampleBaritoneControl or something idk
@@ -93,6 +94,9 @@ public final class CustomGoalProcess extends BaritoneProcessHelper implements IC
                     if (Baritone.settings().disconnectOnArrival.value) {
                         ctx.world().sendQuittingDisconnectingPacket();
                     }
+                    if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnPathComplete.value) {
+                        NotificationHelper.notify("Pathing complete", false);
+                    }
                     return new PathingCommand(this.goal, PathingCommandType.CANCEL_AND_SET_GOAL);
                 }
                 return new PathingCommand(this.goal, PathingCommandType.SET_GOAL_AND_PATH);
diff --git a/src/main/java/baritone/process/ExploreProcess.java b/src/main/java/baritone/process/ExploreProcess.java
index 220ae3b12..c42ece0e5 100644
--- a/src/main/java/baritone/process/ExploreProcess.java
+++ b/src/main/java/baritone/process/ExploreProcess.java
@@ -29,6 +29,7 @@ import baritone.api.process.PathingCommandType;
 import baritone.api.utils.MyChunkPos;
 import baritone.cache.CachedWorld;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
@@ -83,12 +84,18 @@ public final class ExploreProcess extends BaritoneProcessHelper implements IExpl
     public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
         if (calcFailed) {
             logDirect("Failed");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnExploreFinished.value) {
+                NotificationHelper.notify("Exploration failed", true);
+            }
             onLostControl();
             return null;
         }
         IChunkFilter filter = calcFilter();
         if (!Baritone.settings().disableCompletionCheck.value && filter.countRemain() == 0) {
             logDirect("Explored all chunks");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnExploreFinished.value) {
+                NotificationHelper.notify("Explored all chunks", false);
+            }
             onLostControl();
             return null;
         }
diff --git a/src/main/java/baritone/process/FarmProcess.java b/src/main/java/baritone/process/FarmProcess.java
index a91fda60c..407157b37 100644
--- a/src/main/java/baritone/process/FarmProcess.java
+++ b/src/main/java/baritone/process/FarmProcess.java
@@ -31,6 +31,7 @@ import baritone.api.utils.input.Input;
 import baritone.cache.WorldScanner;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
+import baritone.utils.NotificationHelper;
 import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
@@ -257,6 +258,9 @@ public final class FarmProcess extends BaritoneProcessHelper implements IFarmPro
 
         if (calcFailed) {
             logDirect("Farm failed");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnFarmFail.value) {
+                NotificationHelper.notify("Farm failed", true);
+            }
             onLostControl();
             return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
         }
diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index a76121b8d..b44709e3e 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -30,6 +30,7 @@ import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.MovementHelper;
 import baritone.utils.BaritoneProcessHelper;
 import baritone.utils.BlockStateInterface;
+import baritone.utils.NotificationHelper;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockAir;
 import net.minecraft.block.BlockFalling;
@@ -221,6 +222,9 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         locs.addAll(dropped);
         if (locs.isEmpty()) {
             logDirect("No locations for " + filter + " known, cancelling");
+            if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                NotificationHelper.notify("No locations for " + filter + " known, cancelling", true);
+            }
             cancel();
             return;
         }

From 0434e1c5d3cb73364c5ce8fe93725f16c939ab00 Mon Sep 17 00:00:00 2001
From: aUniqueUser <ds458@pm.me>
Date: Sat, 29 Feb 2020 12:24:06 -0500
Subject: [PATCH 04/20] Add more entries to MineProcess

---
 src/main/java/baritone/process/MineProcess.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/main/java/baritone/process/MineProcess.java b/src/main/java/baritone/process/MineProcess.java
index b44709e3e..6e8ba245b 100644
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -89,10 +89,16 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         if (calcFailed) {
             if (!knownOreLocations.isEmpty() && Baritone.settings().blacklistClosestOnFailure.value) {
                 logDirect("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                    NotificationHelper.notify("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...", true);
+                }
                 knownOreLocations.stream().min(Comparator.comparingDouble(ctx.player()::getDistanceSq)).ifPresent(blacklist::add);
                 knownOreLocations.removeIf(blacklist::contains);
             } else {
                 logDirect("Unable to find any path to " + filter + ", canceling mine");
+                if (Baritone.settings().desktopNotifications.value && Baritone.settings().notificationOnMineFail.value) {
+                    NotificationHelper.notify("Unable to find any path to " + filter + ", canceling mine", true);
+                }
                 cancel();
                 return null;
             }

From c32652394ebc28dfad00bc0a92977fa915fbac4f Mon Sep 17 00:00:00 2001
From: Babbaj <babbaj45@gmail.com>
Date: Sun, 12 Apr 2020 03:01:24 -0400
Subject: [PATCH 05/20] Annotation for proguard -keep

---
 scripts/proguard.pro                          |  7 +++++++
 src/main/java/baritone/KeepName.java          | 21 +++++++++++++++++++
 .../command/defaults/FollowCommand.java       |  3 +++
 3 files changed, 31 insertions(+)
 create mode 100644 src/main/java/baritone/KeepName.java

diff --git a/scripts/proguard.pro b/scripts/proguard.pro
index 52b843ddf..af920a590 100644
--- a/scripts/proguard.pro
+++ b/scripts/proguard.pro
@@ -23,6 +23,13 @@
 
 -keep class baritone.api.utils.MyChunkPos { *; } # even in standalone we need to keep this for gson reflect
 
+# Keep any class or member annotated with @KeepName so we dont have to put everything in the script
+-keep,allowobfuscation @interface baritone.KeepName
+-keep @baritone.KeepName class *
+-keepclassmembers class * {
+    @baritone.KeepName *;
+}
+
 # setting names are reflected from field names, so keep field names
 -keepclassmembers class baritone.api.Settings {
     public <fields>;    
diff --git a/src/main/java/baritone/KeepName.java b/src/main/java/baritone/KeepName.java
new file mode 100644
index 000000000..20f08e7b8
--- /dev/null
+++ b/src/main/java/baritone/KeepName.java
@@ -0,0 +1,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
+ * 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;
+
+// Annotation for classes and class members that should not be renamed by proguard
+public @interface KeepName { }
diff --git a/src/main/java/baritone/command/defaults/FollowCommand.java b/src/main/java/baritone/command/defaults/FollowCommand.java
index 755fc5350..c63470204 100644
--- a/src/main/java/baritone/command/defaults/FollowCommand.java
+++ b/src/main/java/baritone/command/defaults/FollowCommand.java
@@ -17,6 +17,7 @@
 
 package baritone.command.defaults;
 
+import baritone.KeepName;
 import baritone.api.IBaritone;
 import baritone.api.command.Command;
 import baritone.api.command.datatypes.EntityClassById;
@@ -130,6 +131,7 @@ public class FollowCommand extends Command {
         );
     }
 
+    @KeepName
     private enum FollowGroup {
         ENTITIES(EntityLiving.class::isInstance),
         PLAYERS(EntityPlayer.class::isInstance); /* ,
@@ -142,6 +144,7 @@ public class FollowCommand extends Command {
         }
     }
 
+    @KeepName
     private enum FollowList {
         ENTITY(EntityClassById.INSTANCE),
         PLAYER(NearbyPlayer.INSTANCE);

From ff3234fcdd0dcb0ff6dce5a5989ea504830a5604 Mon Sep 17 00:00:00 2001
From: ByteZ1337 <cr33pycode@gmail.com>
Date: Mon, 13 Apr 2020 20:39:56 +0200
Subject: [PATCH 06/20] Fixed Typo

Fixed Typo in the Long Description of the Goto Command
---
 src/main/java/baritone/command/defaults/GotoCommand.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/command/defaults/GotoCommand.java b/src/main/java/baritone/command/defaults/GotoCommand.java
index 28e768296..a6fe4e22b 100644
--- a/src/main/java/baritone/command/defaults/GotoCommand.java
+++ b/src/main/java/baritone/command/defaults/GotoCommand.java
@@ -72,7 +72,7 @@ public class GotoCommand extends Command {
     @Override
     public List<String> getLongDesc() {
         return Arrays.asList(
-                "The got command tells Baritone to head towards a given goal or block.",
+                "The goto command tells Baritone to head towards a given goal or block.",
                 "",
                 "Wherever a coordinate is expected, you can use ~ just like in regular Minecraft commands. Or, you can just use regular numbers.",
                 "",

From 6603e8b11e0b5453433183f164b05bd3edb6cfae Mon Sep 17 00:00:00 2001
From: CorruptedSeal <68251040+CorruptedSeal@users.noreply.github.com>
Date: Thu, 16 Jul 2020 03:45:23 -0600
Subject: [PATCH 07/20] Update ExecutionControlCommands.java

---
 .../baritone/command/defaults/ExecutionControlCommands.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/baritone/command/defaults/ExecutionControlCommands.java b/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
index 4a04b9e09..1b024c3b8 100644
--- a/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
+++ b/src/main/java/baritone/command/defaults/ExecutionControlCommands.java
@@ -79,7 +79,7 @@ public class ExecutionControlCommands {
                     }
                 }
         );
-        pauseCommand = new Command(baritone, "pause") {
+        pauseCommand = new Command(baritone, "pause", "p") {
             @Override
             public void execute(String label, IArgConsumer args) throws CommandException {
                 args.requireMax(0);
@@ -112,7 +112,7 @@ public class ExecutionControlCommands {
                 );
             }
         };
-        resumeCommand = new Command(baritone, "resume") {
+        resumeCommand = new Command(baritone, "resume", "r") {
             @Override
             public void execute(String label, IArgConsumer args) throws CommandException {
                 args.requireMax(0);
@@ -171,7 +171,7 @@ public class ExecutionControlCommands {
                 );
             }
         };
-        cancelCommand = new Command(baritone, "cancel", "stop") {
+        cancelCommand = new Command(baritone, "cancel", "c", "stop") {
             @Override
             public void execute(String label, IArgConsumer args) throws CommandException {
                 args.requireMax(0);

From 2ddc2c3660d591d42e39a935bb46c27e924ee22a Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Thu, 13 Aug 2020 22:36:34 +0200
Subject: [PATCH 08/20] Add auto tool settings because 2 lines of code lols

---
 src/api/java/baritone/api/Settings.java   | 5 +++++
 src/main/java/baritone/utils/ToolSet.java | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 3da1d21b7..c03b0b72e 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -61,6 +61,11 @@ public final class Settings {
      */
     public final Setting<Boolean> allowInventory = new Setting<>(false);
 
+    /**
+     * Allow player to decide if to use auto tool or not
+     */
+    public final Setting<Boolean> autoTool = new Setting<>(true);
+
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
      * because we want to generally conserve blocks which might be limited.
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index b6446b30d..017843022 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -127,7 +127,7 @@ public class ToolSet {
                 }
             }
         }
-        return best;
+        return Baritone.settings().autoTool.value? best : player.inventory.currentItem;
     }
 
     /**

From 2b6fe188ed15a658141bd670c476b8ab5e84f874 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Thu, 13 Aug 2020 22:47:40 +0200
Subject: [PATCH 09/20] Why calculate stuff that isnt needed...

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 4 +++-
 src/main/java/baritone/utils/ToolSet.java                   | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 1a3faf57b..7dae4ceac 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -432,7 +432,9 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        if(Baritone.settings().autoTool.value){
+            ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        }
     }
 
     static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 017843022..b6446b30d 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -127,7 +127,7 @@ public class ToolSet {
                 }
             }
         }
-        return Baritone.settings().autoTool.value? best : player.inventory.currentItem;
+        return best;
     }
 
     /**

From 2ed3e10833bd08cdd4993af3387fa909a2aff742 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Thu, 13 Aug 2020 23:20:30 +0200
Subject: [PATCH 10/20] And we try this again, because wtf??

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 7dae4ceac..7ae57ae46 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -432,7 +432,7 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        if(Baritone.settings().autoTool.value){
+        if (Baritone.settings().autoTool.value) {
             ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
         }
     }

From f8872e1cd450cbf205974d6dc9db1e1c6b8d676e Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 10:14:02 +0200
Subject: [PATCH 11/20] Everything can be traced back to getBestSlot();

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 4 +---
 src/main/java/baritone/utils/ToolSet.java                   | 6 ++++++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 7ae57ae46..1a3faf57b 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -432,9 +432,7 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        if (Baritone.settings().autoTool.value) {
-            ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
-        }
+        ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
     }
 
     static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index b6446b30d..101a42947 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -18,6 +18,7 @@
 package baritone.utils;
 
 import baritone.Baritone;
+import baritone.command.argparser.DefaultArgParsers;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.entity.EntityPlayerSP;
@@ -102,6 +103,11 @@ public class ToolSet {
      * @return An int containing the index in the tools array that worked best
      */
     public int getBestSlot(Block b, boolean preferSilkTouch) {
+        // Make all depending calculation respect auto tool value without doing unecessary calculations...
+        if (Baritone.settings().autoTool.value) {
+            return player.inventory.currentItem;
+        }
+
         int best = 0;
         double highestSpeed = Double.NEGATIVE_INFINITY;
         int lowestCost = Integer.MIN_VALUE;

From 49db52673a1dfd60828ecbb6e6a01e330610dd34 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 10:25:51 +0200
Subject: [PATCH 12/20] Lol

---
 src/main/java/baritone/utils/ToolSet.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 101a42947..c6161f071 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -18,7 +18,6 @@
 package baritone.utils;
 
 import baritone.Baritone;
-import baritone.command.argparser.DefaultArgParsers;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.entity.EntityPlayerSP;

From e0ff16e2dd8366f9c7e94003a3de6dc997115d4b Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 10:34:21 +0200
Subject: [PATCH 13/20] Nice brainfart

---
 src/main/java/baritone/utils/ToolSet.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index c6161f071..cd347d201 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -103,7 +103,7 @@ public class ToolSet {
      */
     public int getBestSlot(Block b, boolean preferSilkTouch) {
         // Make all depending calculation respect auto tool value without doing unecessary calculations...
-        if (Baritone.settings().autoTool.value) {
+        if (!Baritone.settings().autoTool.value) {
             return player.inventory.currentItem;
         }
 

From 19355cb4f252489356e91a37bfac877055247ae3 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 10:58:15 +0200
Subject: [PATCH 14/20] Added AutoToolMovement bypass setting for special usage
 cases, should not be used it not actually necessary

---
 src/api/java/baritone/api/Settings.java                   | 8 ++++++++
 .../java/baritone/pathing/movement/MovementHelper.java    | 4 +++-
 src/main/java/baritone/utils/ToolSet.java                 | 2 +-
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index c03b0b72e..5b0d58edc 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -66,6 +66,14 @@ public final class Settings {
      */
     public final Setting<Boolean> autoTool = new Setting<>(true);
 
+    /**
+     * Should movement cost calculation ignore the cost of breaking blocks with current slot?
+     * Only use this if actually necessary, make sure to put this back to original state (false), or it
+     * will mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
+     * problems occurs)
+     */
+    public final Setting<Boolean> ignoreAutoToolMovementCost = new Setting<>(false);
+
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
      * because we want to generally conserve blocks which might be limited.
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 1a3faf57b..7ae57ae46 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -432,7 +432,9 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        if (Baritone.settings().autoTool.value) {
+            ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
+        }
     }
 
     static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index cd347d201..2d8a1a2ae 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -103,7 +103,7 @@ public class ToolSet {
      */
     public int getBestSlot(Block b, boolean preferSilkTouch) {
         // Make all depending calculation respect auto tool value without doing unecessary calculations...
-        if (!Baritone.settings().autoTool.value) {
+        if (!Baritone.settings().ignoreAutoToolMovementCost.value) {
             return player.inventory.currentItem;
         }
 

From 94ac15a8fcc5fff7b08f1337a66c3ec3fd7158d7 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 17:06:41 +0200
Subject: [PATCH 15/20] KEK False != True :clown:

---
 src/main/java/baritone/utils/ToolSet.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 2d8a1a2ae..e3eb56f57 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -103,7 +103,7 @@ public class ToolSet {
      */
     public int getBestSlot(Block b, boolean preferSilkTouch) {
         // Make all depending calculation respect auto tool value without doing unecessary calculations...
-        if (!Baritone.settings().ignoreAutoToolMovementCost.value) {
+        if (Baritone.settings().ignoreAutoToolMovementCost.value) {
             return player.inventory.currentItem;
         }
 

From 88e2fba447ed82abd23760dad1540010567c9300 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 17:11:31 +0200
Subject: [PATCH 16/20] Ok, Im actually retarded

---
 src/main/java/baritone/utils/ToolSet.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index e3eb56f57..2d8a1a2ae 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -103,7 +103,7 @@ public class ToolSet {
      */
     public int getBestSlot(Block b, boolean preferSilkTouch) {
         // Make all depending calculation respect auto tool value without doing unecessary calculations...
-        if (Baritone.settings().ignoreAutoToolMovementCost.value) {
+        if (!Baritone.settings().ignoreAutoToolMovementCost.value) {
             return player.inventory.currentItem;
         }
 

From ac55de63e9a8665770d0e80316793d28f2bf914a Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 17:55:10 +0200
Subject: [PATCH 17/20] Maybe dont have ignore cost calculation override auto
 tool?

---
 src/api/java/baritone/api/Settings.java   | 2 +-
 src/main/java/baritone/utils/ToolSet.java | 9 +++++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 5b0d58edc..0776d2b3f 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -69,7 +69,7 @@ public final class Settings {
     /**
      * Should movement cost calculation ignore the cost of breaking blocks with current slot?
      * Only use this if actually necessary, make sure to put this back to original state (false), or it
-     * will mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
+     * migth mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
      * problems occurs)
      */
     public final Setting<Boolean> ignoreAutoToolMovementCost = new Setting<>(false);
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 2d8a1a2ae..0f791cb73 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -101,9 +101,14 @@ public class ToolSet {
      * @param b the blockstate to be mined
      * @return An int containing the index in the tools array that worked best
      */
+
     public int getBestSlot(Block b, boolean preferSilkTouch) {
+        return getBestSlot(b, preferSilkTouch, false);
+    }
+
+    public int getBestSlot(Block b, boolean preferSilkTouch, boolean pathingCalculation) {
         // Make all depending calculation respect auto tool value without doing unecessary calculations...
-        if (!Baritone.settings().ignoreAutoToolMovementCost.value) {
+        if (!Baritone.settings().ignoreAutoToolMovementCost.value && pathingCalculation) {
             return player.inventory.currentItem;
         }
 
@@ -142,7 +147,7 @@ public class ToolSet {
      * @return A double containing the destruction ticks with the best tool
      */
     private double getBestDestructionTime(Block b) {
-        ItemStack stack = player.inventory.getStackInSlot(getBestSlot(b, false));
+        ItemStack stack = player.inventory.getStackInSlot(getBestSlot(b, false, true));
         return calculateSpeedVsBlock(stack, b.getDefaultState()) * avoidanceMultiplier(b);
     }
 

From 2eba22031a524215993da1f57a5bf7c5385e0a13 Mon Sep 17 00:00:00 2001
From: RealIndrit <jia@twinflower.net>
Date: Fri, 14 Aug 2020 22:47:39 +0200
Subject: [PATCH 18/20] Maybe dont have ignore cost calculation override auto
 tool?

---
 src/api/java/baritone/api/Settings.java   | 6 ++++--
 src/main/java/baritone/utils/ToolSet.java | 9 +++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index 0776d2b3f..15c9ba35e 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -67,9 +67,11 @@ public final class Settings {
     public final Setting<Boolean> autoTool = new Setting<>(true);
 
     /**
-     * Should movement cost calculation ignore the cost of breaking blocks with current slot?
+     * Should movement cost calculation ignore the cost of breaking blocks with current slot, and assume best possible
+     * item in the hotbar?
+     *
      * Only use this if actually necessary, make sure to put this back to original state (false), or it
-     * migth mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
+     * might mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
      * problems occurs)
      */
     public final Setting<Boolean> ignoreAutoToolMovementCost = new Setting<>(false);
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index 0f791cb73..b903bdf38 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -96,7 +96,8 @@ public class ToolSet {
     }
 
     /**
-     * Calculate which tool on the hotbar is best for mining
+     * Calculate which tool on the hotbar is best for mining, depending on an override setting,
+     * related to auto tool movement cost, it will either return current selected slot, or the best slot.
      *
      * @param b the blockstate to be mined
      * @return An int containing the index in the tools array that worked best
@@ -107,7 +108,11 @@ public class ToolSet {
     }
 
     public int getBestSlot(Block b, boolean preferSilkTouch, boolean pathingCalculation) {
-        // Make all depending calculation respect auto tool value without doing unecessary calculations...
+
+        /*
+        If we actually want know what efficiency our held item has instead of the best one
+        possible, this lets us make pathing depending on the actual tool used (if auto tool is disabled)
+        */
         if (!Baritone.settings().ignoreAutoToolMovementCost.value && pathingCalculation) {
             return player.inventory.currentItem;
         }

From 98516235574282d213f62107e261cc8a55f2e7f2 Mon Sep 17 00:00:00 2001
From: Leijurv <leijurv@gmail.com>
Date: Mon, 17 Aug 2020 16:03:04 -0700
Subject: [PATCH 19/20] anti-indrit-cringe

---
 src/api/java/baritone/api/Settings.java          | 16 +++++++---------
 .../pathing/movement/MovementHelper.java         |  2 +-
 src/main/java/baritone/utils/ToolSet.java        |  4 ++--
 3 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index b48bf55fb..5dfcef6ae 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -62,19 +62,17 @@ public final class Settings {
     public final Setting<Boolean> allowInventory = new Setting<>(false);
 
     /**
-     * Allow player to decide if to use auto tool or not
+     * Disable baritone's auto-tool at runtime, but still assume that another mod will provide auto tool functionality
+     * <p>
+     * Specifically, path calculation will still assume that an auto tool wil run at execution time, even though
+     * Baritone itself will not do that.
      */
-    public final Setting<Boolean> autoTool = new Setting<>(true);
+    public final Setting<Boolean> assumeExternalAutoTool = new Setting<>(false);
 
     /**
-     * Should movement cost calculation ignore the cost of breaking blocks with current slot, and assume best possible
-     * item in the hotbar?
-     *
-     * Only use this if actually necessary, make sure to put this back to original state (false), or it
-     * might mess up pathing in some combinations with auto tool setting. (just fall back to original settings if any
-     * problems occurs)
+     * If this setting is on, no auto tool will occur at all, not at calculation time nor execution time
      */
-    public final Setting<Boolean> ignoreAutoToolMovementCost = new Setting<>(false);
+    public final Setting<Boolean> disableAutoTool = new Setting<>(false);
 
     /**
      * It doesn't actually take twenty ticks to place a block, this cost is so high
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 7ae57ae46..7165303c4 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -432,7 +432,7 @@ public interface MovementHelper extends ActionCosts, Helper {
      * @param ts  previously calculated ToolSet
      */
     static void switchToBestToolFor(IPlayerContext ctx, IBlockState b, ToolSet ts, boolean preferSilkTouch) {
-        if (Baritone.settings().autoTool.value) {
+        if (!Baritone.settings().disableAutoTool.value && !Baritone.settings().assumeExternalAutoTool.value) {
             ctx.player().inventory.currentItem = ts.getBestSlot(b.getBlock(), preferSilkTouch);
         }
     }
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index b903bdf38..aa8819cef 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -111,9 +111,9 @@ public class ToolSet {
 
         /*
         If we actually want know what efficiency our held item has instead of the best one
-        possible, this lets us make pathing depending on the actual tool used (if auto tool is disabled)
+        possible, this lets us make pathing depend on the actual tool to be used (if auto tool is disabled)
         */
-        if (!Baritone.settings().ignoreAutoToolMovementCost.value && pathingCalculation) {
+        if (Baritone.settings().disableAutoTool.value && pathingCalculation) {
             return player.inventory.currentItem;
         }
 

From 02e7886e77364a7249c1d310ee9f730dda96abbd Mon Sep 17 00:00:00 2001
From: Leijurv <leijurv@gmail.com>
Date: Mon, 17 Aug 2020 16:15:56 -0700
Subject: [PATCH 20/20] properly set isSafeToCancel in MovementDiagonal, fixes
 #1788

---
 .../pathing/movement/movements/MovementDiagonal.java      | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
index 450144c0d..2631af840 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -56,6 +56,14 @@ public class MovementDiagonal extends Movement {
         super(baritone, start, end, new BetterBlockPos[]{dir1, dir1.up(), dir2, dir2.up(), end, end.up()});
     }
 
+    @Override
+    protected boolean safeToCancel(MovementState state) {
+        return ctx.playerFeet().equals(src) || ((
+                MovementHelper.canWalkOn(ctx, new BlockPos(src.x, src.y - 1, dest.z))
+        ) &&
+                MovementHelper.canWalkOn(ctx, new BlockPos(dest.x, src.y - 1, src.z)));
+    }
+
     @Override
     public double calculateCost(CalculationContext context) {
         MutableMoveResult result = new MutableMoveResult();