assumeSafeWalk = new Setting<>(false);
/**
* If true, parkour is allowed to make jumps when standing on blocks at the maximum height, so player feet is y=256
*
- * Defaults to false because this fails on NCP
+ * Defaults to false because this fails on constantiam
*/
- public Setting allowJumpAt256 = new Setting<>(false);
+ public final Setting allowJumpAt256 = new Setting<>(false);
/**
* Allow descending diagonally
@@ -118,12 +118,12 @@ public class Settings {
*
* For a generic "take some risks" mode I'd turn on this one, parkour, and parkour place.
*/
- public Setting allowDiagonalDescend = new Setting<>(false);
+ public final Setting allowDiagonalDescend = new Setting<>(false);
/**
* Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)
*/
- public Setting> acceptableThrowawayItems = new Setting<>(new ArrayList<>(Arrays.asList(
+ public final Setting> acceptableThrowawayItems = new Setting<>(new ArrayList<>(Arrays.asList(
Item.getItemFromBlock(Blocks.DIRT),
Item.getItemFromBlock(Blocks.COBBLESTONE),
Item.getItemFromBlock(Blocks.NETHERRACK)
@@ -132,31 +132,37 @@ public class Settings {
/**
* Enables some more advanced vine features. They're honestly just gimmicks and won't ever be needed in real
* pathing scenarios. And they can cause Baritone to get trapped indefinitely in a strange scenario.
+ *
+ * Never turn this on lol
*/
- public Setting allowVines = new Setting<>(false);
+ public final Setting allowVines = new Setting<>(false);
/**
* Slab behavior is complicated, disable this for higher path reliability. Leave enabled if you have bottom slabs
* everywhere in your base.
*/
- public Setting allowWalkOnBottomSlab = new Setting<>(true);
+ public final Setting allowWalkOnBottomSlab = new Setting<>(true);
/**
* You know what it is
*
* But it's very unreliable and falls off when cornering like all the time so.
+ *
+ * It also overshoots the landing pretty much always (making contact with the next block over), so be careful
*/
- public Setting allowParkour = new Setting<>(false);
+ public final Setting allowParkour = new Setting<>(false);
/**
- * Like parkour, but even more unreliable!
+ * Actually pretty reliable.
+ *
+ * Doesn't make it any more dangerous compared to just normal allowParkour th
*/
- public Setting allowParkourPlace = new Setting<>(false);
+ public final Setting allowParkourPlace = new Setting<>(false);
/**
* For example, if you have Mining Fatigue or Haste, adjust the costs of breaking blocks accordingly.
*/
- public Setting considerPotionEffects = new Setting<>(true);
+ public final Setting considerPotionEffects = new Setting<>(true);
/**
* This is the big A* setting.
@@ -173,131 +179,137 @@ public class Settings {
*
* Finding the optimal path is worth it, so it's the default.
*/
- public Setting costHeuristic = new Setting<>(3.563);
+ public final Setting costHeuristic = new Setting<>(3.563);
// a bunch of obscure internal A* settings that you probably don't want to change
/**
* The maximum number of times it will fetch outside loaded or cached chunks before assuming that
* pathing has reached the end of the known area, and should therefore stop.
*/
- public Setting pathingMaxChunkBorderFetch = new Setting<>(50);
+ public final Setting pathingMaxChunkBorderFetch = new Setting<>(50);
/**
* Set to 1.0 to effectively disable this feature
*
* @see Issue #18
*/
- public Setting backtrackCostFavoringCoefficient = new Setting<>(0.5);
+ public final Setting backtrackCostFavoringCoefficient = new Setting<>(0.5);
/**
* Toggle the following 4 settings
*
- * They have a noticable performance impact, so they default off
+ * They have a noticeable performance impact, so they default off
+ *
+ * Specifically, building up the avoidance map on the main thread before pathing starts actually takes a noticeable
+ * amount of time, especially when there are a lot of mobs around, and your game jitters for like 200ms while doing so
*/
- public Setting avoidance = new Setting<>(false);
+ public final Setting avoidance = new Setting<>(false);
+
/**
* Set to 1.0 to effectively disable this feature
*
* Set below 1.0 to go out of your way to walk near mob spawners
*/
- public Setting mobSpawnerAvoidanceCoefficient = new Setting<>(2.0);
+ public final Setting mobSpawnerAvoidanceCoefficient = new Setting<>(2.0);
- public Setting mobSpawnerAvoidanceRadius = new Setting<>(16);
+ public final Setting mobSpawnerAvoidanceRadius = new Setting<>(16);
/**
* Set to 1.0 to effectively disable this feature
*
* Set below 1.0 to go out of your way to walk near mobs
*/
- public Setting mobAvoidanceCoefficient = new Setting<>(1.5);
+ public final Setting mobAvoidanceCoefficient = new Setting<>(1.5);
- public Setting mobAvoidanceRadius = new Setting<>(8);
+ public final Setting mobAvoidanceRadius = new Setting<>(8);
/**
* When running a goto towards a container block (chest, ender chest, furnace, etc),
* right click and open it once you arrive.
*/
- public Setting rightClickContainerOnArrival = new Setting<>(true);
+ public final Setting rightClickContainerOnArrival = new Setting<>(true);
/**
* When running a goto towards a nether portal block, walk all the way into the portal
* instead of stopping one block before.
*/
- public Setting enterPortal = new Setting<>(true);
+ public final Setting enterPortal = new Setting<>(true);
/**
* Don't repropagate cost improvements below 0.01 ticks. They're all just floating point inaccuracies,
* and there's no point.
*/
- public Setting minimumImprovementRepropagation = new Setting<>(true);
+ public final Setting 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.
+ *
+ * This is much safer to leave off now, and makes pathing more efficient. More explanation in the issue.
*
- * @see Issue #144
+ * @see Issue #114
*/
- public Setting cutoffAtLoadBoundary = new Setting<>(false);
+ public final Setting cutoffAtLoadBoundary = 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
*/
- public Setting maxCostIncrease = new Setting<>(10D);
+ public final Setting maxCostIncrease = new Setting<>(10D);
/**
* Stop 5 movements before anything that made the path COST_INF.
* For example, if lava has spread across the path, don't walk right up to it then recalculate, it might
* still be spreading lol
*/
- public Setting costVerificationLookahead = new Setting<>(5);
+ public final Setting costVerificationLookahead = new Setting<>(5);
/**
* Static cutoff factor. 0.9 means cut off the last 10% of all paths, regardless of chunk load state
*/
- public Setting pathCutoffFactor = new Setting<>(0.9);
+ public final Setting pathCutoffFactor = new Setting<>(0.9);
/**
* Only apply static cutoff for paths of at least this length (in terms of number of movements)
*/
- public Setting pathCutoffMinimumLength = new Setting<>(30);
+ public final Setting pathCutoffMinimumLength = new Setting<>(30);
/**
* Start planning the next path once the remaining movements tick estimates sum up to less than this value
*/
- public Setting planningTickLookAhead = new Setting<>(150);
+ public final Setting planningTickLookAhead = new Setting<>(150);
/**
* Default size of the Long2ObjectOpenHashMap used in pathing
*/
- public Setting pathingMapDefaultSize = new Setting<>(1024);
+ public final Setting pathingMapDefaultSize = new Setting<>(1024);
/**
* Load factor coefficient for the Long2ObjectOpenHashMap used in pathing
*
* Decrease for faster map operations, but higher memory usage
*/
- public Setting pathingMapLoadFactor = new Setting<>(0.75f);
+ public final Setting pathingMapLoadFactor = new Setting<>(0.75f);
/**
* How far are you allowed to fall onto solid ground (without a water bucket)?
* 3 won't deal any damage. But if you just want to get down the mountain quickly and you have
* Feather Falling IV, you might set it a bit higher, like 4 or 5.
*/
- public Setting maxFallHeightNoWater = new Setting<>(3);
+ public final Setting maxFallHeightNoWater = new Setting<>(3);
/**
* How far are you allowed to fall onto solid ground (with a water bucket)?
* It's not that reliable, so I've set it below what would kill an unarmored player (23)
*/
- public Setting maxFallHeightBucket = new Setting<>(20);
+ public final Setting maxFallHeightBucket = new Setting<>(20);
/**
* Is it okay to sprint through a descend followed by a diagonal?
* The player overshoots the landing, but not enough to fall off. And the diagonal ensures that there isn't
* lava or anything that's !canWalkInto in that space, so it's technically safe, just a little sketchy.
*/
- public Setting allowOvershootDiagonalDescend = new Setting<>(true);
+ public final Setting allowOvershootDiagonalDescend = new Setting<>(true);
/**
* If your goal is a GoalBlock in an unloaded chunk, assume it's far enough away that the Y coord
@@ -306,131 +318,133 @@ public class Settings {
* of considering the Y coord. The reasoning is that if your X and Z are 10,000 blocks away,
* your Y coordinate's accuracy doesn't matter at all until you get much much closer.
*/
- public Setting simplifyUnloadedYCoord = new Setting<>(true);
+ public final Setting simplifyUnloadedYCoord = new Setting<>(true);
/**
* If a movement takes this many ticks more than its initial cost estimate, cancel it
*/
- public Setting movementTimeoutTicks = new Setting<>(100);
+ public final Setting movementTimeoutTicks = new Setting<>(100);
/**
* Pathing ends after this amount of time, but only if a path has been found
*
* If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout
*/
- public Setting primaryTimeoutMS = new Setting<>(500L);
+ public final Setting primaryTimeoutMS = new Setting<>(500L);
/**
* Pathing can never take longer than this, even if that means failing to find any path at all
*/
- public Setting failureTimeoutMS = new Setting<>(2000L);
+ public final Setting failureTimeoutMS = new Setting<>(2000L);
/**
* Planning ahead while executing a segment ends after this amount of time, but only if a path has been found
*
* If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout
*/
- public Setting planAheadPrimaryTimeoutMS = new Setting<>(4000L);
+ public final Setting planAheadPrimaryTimeoutMS = new Setting<>(4000L);
/**
* Planning ahead while executing a segment can never take longer than this, even if that means failing to find any path at all
*/
- public Setting planAheadFailureTimeoutMS = new Setting<>(5000L);
+ public final Setting planAheadFailureTimeoutMS = new Setting<>(5000L);
/**
* For debugging, consider nodes much much slower
*/
- public Setting slowPath = new Setting<>(false);
+ public final Setting slowPath = new Setting<>(false);
/**
* Milliseconds between each node
*/
- public Setting slowPathTimeDelayMS = new Setting<>(100L);
+ public final Setting slowPathTimeDelayMS = new Setting<>(100L);
/**
* The alternative timeout number when slowPath is on
*/
- public Setting slowPathTimeoutMS = new Setting<>(40000L);
+ public final Setting slowPathTimeoutMS = new Setting<>(40000L);
/**
* The big one. Download all chunks in simplified 2-bit format and save them for better very-long-distance pathing.
*/
- public Setting chunkCaching = new Setting<>(true);
+ public final Setting chunkCaching = new Setting<>(true);
/**
* On save, delete from RAM any cached regions that are more than 1024 blocks away from the player
*
- * Temporarily disabled, see issue #248
+ * Temporarily disabled
+ *
+ * @see Issue #248
*/
- public Setting pruneRegionsFromRAM = new Setting<>(false);
+ public final Setting pruneRegionsFromRAM = new Setting<>(false);
/**
* Print all the debug messages to chat
*/
- public Setting chatDebug = new Setting<>(true);
+ public final Setting chatDebug = new Setting<>(true);
/**
* Allow chat based control of Baritone. Most likely should be disabled when Baritone is imported for use in
* something else
*/
- public Setting chatControl = new Setting<>(true);
+ public final Setting chatControl = new Setting<>(true);
/**
* A second override over chatControl to force it on
*/
- public Setting removePrefix = new Setting<>(false);
+ public final Setting removePrefix = new Setting<>(false);
/**
* Render the path
*/
- public Setting renderPath = new Setting<>(true);
+ public final Setting renderPath = new Setting<>(true);
/**
* Render the goal
*/
- public Setting renderGoal = new Setting<>(true);
+ public final Setting renderGoal = new Setting<>(true);
/**
* Ignore depth when rendering the goal
*/
- public Setting renderGoalIgnoreDepth = new Setting<>(true);
+ public final Setting renderGoalIgnoreDepth = new Setting<>(true);
/**
* Renders X/Z type Goals with the vanilla beacon beam effect. Combining this with
* {@link #renderGoalIgnoreDepth} will cause strange render clipping.
*/
- public Setting renderGoalXZBeacon = new Setting<>(false);
+ public final Setting renderGoalXZBeacon = new Setting<>(false);
/**
* Ignore depth when rendering the selection boxes (to break, to place, to walk into)
*/
- public Setting renderSelectionBoxesIgnoreDepth = new Setting<>(true);
+ public final Setting renderSelectionBoxesIgnoreDepth = new Setting<>(true);
/**
* Ignore depth when rendering the path
*/
- public Setting renderPathIgnoreDepth = new Setting<>(true);
+ public final Setting renderPathIgnoreDepth = new Setting<>(true);
/**
* Line width of the path when rendered, in pixels
*/
- public Setting pathRenderLineWidthPixels = new Setting<>(5F);
+ public final Setting pathRenderLineWidthPixels = new Setting<>(5F);
/**
* Line width of the goal when rendered, in pixels
*/
- public Setting goalRenderLineWidthPixels = new Setting<>(3F);
+ public final Setting goalRenderLineWidthPixels = new Setting<>(3F);
/**
* Start fading out the path at 20 movements ahead, and stop rendering it entirely 30 movements ahead.
* Improves FPS.
*/
- public Setting fadePath = new Setting<>(false);
+ public final Setting fadePath = new Setting<>(false);
/**
* Move without having to force the client-sided rotations
*/
- public Setting freeLook = new Setting<>(true);
+ public final Setting freeLook = new Setting<>(true);
/**
* Will cause some minor behavioral differences to ensure that Baritone works on anticheats.
@@ -438,12 +452,12 @@ public class Settings {
* At the moment this will silently set the player's rotations when using freeLook so you're not sprinting in
* directions other than forward, which is picken up by more "advanced" anticheats like AAC, but not NCP.
*/
- public Setting antiCheatCompatibility = new Setting<>(true);
+ public final Setting antiCheatCompatibility = new Setting<>(true);
/**
* Exclusively use cached chunks for pathing
*/
- public Setting pathThroughCachedOnly = new Setting<>(false);
+ public final Setting pathThroughCachedOnly = new Setting<>(false);
/**
* 😎
@@ -453,38 +467,33 @@ public class Settings {
/**
* Whether or not to use the "#" command prefix
*/
- public Setting prefix = new Setting<>(false);
-
- /**
- * {@code true}: can mine blocks when in inventory, chat, or tabbed away in ESC menu
- */
- public Setting leftClickWorkaround = new Setting<>(true);
+ public final Setting prefix = new Setting<>(false);
/**
* Don't stop walking forward when you need to break blocks in your way
*/
- public Setting walkWhileBreaking = new Setting<>(true);
+ public final Setting walkWhileBreaking = new Setting<>(true);
/**
- * If we are more than 500 movements into the current path, discard the oldest segments, as they are no longer useful
+ * If we are more than 300 movements into the current path, discard the oldest segments, as they are no longer useful
*/
- public Setting maxPathHistoryLength = new Setting<>(300);
+ public final Setting maxPathHistoryLength = new Setting<>(300);
/**
* If the current path is too long, cut off this many movements from the beginning.
*/
- public Setting pathHistoryCutoffAmount = new Setting<>(50);
+ public final Setting pathHistoryCutoffAmount = new Setting<>(50);
/**
* Rescan for the goal once every 5 ticks.
* Set to 0 to disable.
*/
- public Setting mineGoalUpdateInterval = new Setting<>(5);
+ public final Setting mineGoalUpdateInterval = new Setting<>(5);
/**
* While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
*/
- public Setting mineScanDroppedItems = new Setting<>(true);
+ public final Setting mineScanDroppedItems = new Setting<>(true);
/**
* Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.
@@ -499,54 +508,54 @@ public class Settings {
*
* 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 cancelOnGoalInvalidation = new Setting<>(true);
+ public final Setting cancelOnGoalInvalidation = new Setting<>(true);
/**
* The "axis" command (aka GoalAxis) will go to a axis, or diagonal axis, at this Y level.
*/
- public Setting axisHeight = new Setting<>(120);
+ public final Setting axisHeight = new Setting<>(120);
/**
- * Allow MineBehavior to use X-Ray to see where the ores are. Turn this option off to force it to mine "legit"
+ * Disallow MineBehavior from using X-Ray to see where the ores are. Turn this option on to force it to mine "legit"
* where it will only mine an ore once it can actually see it, so it won't do or know anything that a normal player
- * couldn't. If you don't want it to look like you're X-Raying, turn this off
+ * couldn't. If you don't want it to look like you're X-Raying, turn this on
*/
- public Setting legitMine = new Setting<>(false);
+ public final Setting legitMine = new Setting<>(false);
/**
* What Y level to go to for legit strip mining
*/
- public Setting legitMineYLevel = new Setting<>(11);
+ public final Setting legitMineYLevel = new Setting<>(11);
/**
* When mining block of a certain type, try to mine two at once instead of one.
* If the block above is also a goal block, set GoalBlock instead of GoalTwoBlocks
* If the block below is also a goal block, set GoalBlock to the position one down instead of GoalTwoBlocks
*/
- public Setting forceInternalMining = new Setting<>(true);
+ public final Setting 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 internalMiningAirException = new Setting<>(true);
+ public final Setting internalMiningAirException = new Setting<>(true);
/**
* The actual GoalNear is set this distance away from the entity you're following
*
* For example, set followOffsetDistance to 5 and followRadius to 0 to always stay precisely 5 blocks north of your follow target.
*/
- public Setting followOffsetDistance = new Setting<>(0D);
+ public final Setting followOffsetDistance = new Setting<>(0D);
/**
- * The actual GoalNear is set in this direction from the entity you're following
+ * The actual GoalNear is set in this direction from the entity you're following. This value is in degrees.
*/
- public Setting followOffsetDirection = new Setting<>(0F);
+ public final Setting followOffsetDirection = new Setting<>(0F);
/**
* The radius (for the GoalNear) of how close to your target position you actually have to be
*/
- public Setting followRadius = new Setting<>(3);
+ public final Setting followRadius = new Setting<>(3);
/**
* Cached chunks (regardless of if they're in RAM or saved to disk) expire and are deleted after this number of seconds
@@ -568,54 +577,55 @@ public class Settings {
* has to build up that cache from scratch. But after it's gone through an area just once, the next time will have zero
* backtracking, since the entire area is now known and cached.
*/
- public Setting cachedChunksExpirySeconds = new Setting<>(-1L);
+ public final Setting cachedChunksExpirySeconds = new Setting<>(-1L);
/**
* 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> logger = new Setting<>(Minecraft.getMinecraft().ingameGUI.getChatGUI()::printChatMessage);
+ public final Setting> logger = new Setting<>(Minecraft.getMinecraft().ingameGUI.getChatGUI()::printChatMessage);
/**
* The color of the current path
*/
- public Setting colorCurrentPath = new Setting<>(Color.RED);
+ public final Setting colorCurrentPath = new Setting<>(Color.RED);
/**
* The color of the next path
*/
- public Setting colorNextPath = new Setting<>(Color.MAGENTA);
+ public final Setting colorNextPath = new Setting<>(Color.MAGENTA);
/**
* The color of the blocks to break
*/
- public Setting colorBlocksToBreak = new Setting<>(Color.RED);
+ public final Setting colorBlocksToBreak = new Setting<>(Color.RED);
/**
* The color of the blocks to place
*/
- public Setting colorBlocksToPlace = new Setting<>(Color.GREEN);
+ public final Setting colorBlocksToPlace = new Setting<>(Color.GREEN);
/**
* The color of the blocks to walk into
*/
- public Setting colorBlocksToWalkInto = new Setting<>(Color.MAGENTA);
+ public final Setting colorBlocksToWalkInto = new Setting<>(Color.MAGENTA);
/**
* The color of the best path so far
*/
- public Setting colorBestPathSoFar = new Setting<>(Color.BLUE);
+ public final Setting colorBestPathSoFar = new Setting<>(Color.BLUE);
/**
* The color of the path to the most recent considered node
*/
- public Setting colorMostRecentConsidered = new Setting<>(Color.CYAN);
+ public final Setting colorMostRecentConsidered = new Setting<>(Color.CYAN);
/**
* The color of the goal box
*/
- public Setting colorGoalBox = new Setting<>(Color.GREEN);
+ public final Setting colorGoalBox = new Setting<>(Color.GREEN);
+
/**
* A map of lowercase setting field names to their respective setting
diff --git a/src/api/java/baritone/api/event/events/ChatEvent.java b/src/api/java/baritone/api/event/events/ChatEvent.java
index 5ab9f5bb..d91e87b0 100644
--- a/src/api/java/baritone/api/event/events/ChatEvent.java
+++ b/src/api/java/baritone/api/event/events/ChatEvent.java
@@ -17,22 +17,20 @@
package baritone.api.event.events;
-import baritone.api.event.events.type.ManagedPlayerEvent;
-import net.minecraft.client.entity.EntityPlayerSP;
+import baritone.api.event.events.type.Cancellable;
/**
* @author Brady
* @since 8/1/2018
*/
-public final class ChatEvent extends ManagedPlayerEvent.Cancellable {
+public final class ChatEvent extends Cancellable {
/**
* The message being sent
*/
private final String message;
- public ChatEvent(EntityPlayerSP player, String message) {
- super(player);
+ public ChatEvent(String message) {
this.message = message;
}
diff --git a/src/api/java/baritone/api/event/events/PlayerUpdateEvent.java b/src/api/java/baritone/api/event/events/PlayerUpdateEvent.java
index 99370552..6ac08bdd 100644
--- a/src/api/java/baritone/api/event/events/PlayerUpdateEvent.java
+++ b/src/api/java/baritone/api/event/events/PlayerUpdateEvent.java
@@ -18,22 +18,19 @@
package baritone.api.event.events;
import baritone.api.event.events.type.EventState;
-import baritone.api.event.events.type.ManagedPlayerEvent;
-import net.minecraft.client.entity.EntityPlayerSP;
/**
* @author Brady
* @since 8/21/2018
*/
-public final class PlayerUpdateEvent extends ManagedPlayerEvent {
+public final class PlayerUpdateEvent {
/**
* The state of the event
*/
private final EventState state;
- public PlayerUpdateEvent(EntityPlayerSP player, EventState state) {
- super(player);
+ public PlayerUpdateEvent(EventState state) {
this.state = state;
}
diff --git a/src/api/java/baritone/api/event/events/RotationMoveEvent.java b/src/api/java/baritone/api/event/events/RotationMoveEvent.java
index 790318e0..109061c7 100644
--- a/src/api/java/baritone/api/event/events/RotationMoveEvent.java
+++ b/src/api/java/baritone/api/event/events/RotationMoveEvent.java
@@ -17,8 +17,6 @@
package baritone.api.event.events;
-import baritone.api.event.events.type.ManagedPlayerEvent;
-import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
@@ -26,7 +24,7 @@ import net.minecraft.entity.EntityLivingBase;
* @author Brady
* @since 8/21/2018
*/
-public final class RotationMoveEvent extends ManagedPlayerEvent {
+public final class RotationMoveEvent {
/**
* The type of event
@@ -38,8 +36,7 @@ public final class RotationMoveEvent extends ManagedPlayerEvent {
*/
private float yaw;
- public RotationMoveEvent(EntityPlayerSP player, Type type, float yaw) {
- super(player);
+ public RotationMoveEvent(Type type, float yaw) {
this.type = type;
this.yaw = yaw;
}
diff --git a/src/api/java/baritone/api/event/events/SprintStateEvent.java b/src/api/java/baritone/api/event/events/SprintStateEvent.java
new file mode 100644
index 00000000..60672801
--- /dev/null
+++ b/src/api/java/baritone/api/event/events/SprintStateEvent.java
@@ -0,0 +1,35 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone. If not, see .
+ */
+
+package baritone.api.event.events;
+
+/**
+ * @author Brady
+ * @since 1/18/2019
+ */
+public final class SprintStateEvent {
+
+ private Boolean state;
+
+ public final void setState(boolean state) {
+ this.state = state;
+ }
+
+ public final Boolean getState() {
+ return this.state;
+ }
+}
diff --git a/src/api/java/baritone/api/event/events/type/ManagedPlayerEvent.java b/src/api/java/baritone/api/event/events/type/ManagedPlayerEvent.java
deleted file mode 100644
index a3487a67..00000000
--- a/src/api/java/baritone/api/event/events/type/ManagedPlayerEvent.java
+++ /dev/null
@@ -1,61 +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 .
- */
-
-package baritone.api.event.events.type;
-
-import net.minecraft.client.entity.EntityPlayerSP;
-
-/**
- * An event that has a reference to a locally managed player.
- *
- * @author Brady
- * @since 10/11/2018
- */
-public class ManagedPlayerEvent {
-
- protected final EntityPlayerSP player;
-
- public ManagedPlayerEvent(EntityPlayerSP player) {
- this.player = player;
- }
-
- public final EntityPlayerSP getPlayer() {
- return this.player;
- }
-
- public static class Cancellable extends ManagedPlayerEvent implements ICancellable {
-
- /**
- * Whether or not this event has been cancelled
- */
- private boolean cancelled;
-
- public Cancellable(EntityPlayerSP player) {
- super(player);
- }
-
- @Override
- public final void cancel() {
- this.cancelled = true;
- }
-
- @Override
- public final boolean isCancelled() {
- return this.cancelled;
- }
- }
-}
diff --git a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
index 135c29a7..71045768 100644
--- a/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/AbstractGameEventListener.java
@@ -57,6 +57,9 @@ public interface AbstractGameEventListener extends IGameEventListener {
@Override
default void onPlayerRotationMove(RotationMoveEvent event) {}
+ @Override
+ default void onPlayerSprintState(SprintStateEvent event) {}
+
@Override
default void onBlockInteract(BlockInteractEvent event) {}
diff --git a/src/api/java/baritone/api/event/listener/IGameEventListener.java b/src/api/java/baritone/api/event/listener/IGameEventListener.java
index 0572cbe9..dc471e5f 100644
--- a/src/api/java/baritone/api/event/listener/IGameEventListener.java
+++ b/src/api/java/baritone/api/event/listener/IGameEventListener.java
@@ -109,6 +109,14 @@ public interface IGameEventListener {
*/
void onPlayerRotationMove(RotationMoveEvent event);
+ /**
+ * Called whenever the sprint keybind state is checked in {@link EntityPlayerSP#onLivingUpdate}
+ *
+ * @param event The event
+ * @see EntityPlayerSP#onLivingUpdate()
+ */
+ void onPlayerSprintState(SprintStateEvent event);
+
/**
* Called when the local player interacts with a block, whether it is breaking or opening/placing.
*
diff --git a/src/api/java/baritone/api/pathing/calc/IPathingControlManager.java b/src/api/java/baritone/api/pathing/calc/IPathingControlManager.java
index ffaa18b8..dc729748 100644
--- a/src/api/java/baritone/api/pathing/calc/IPathingControlManager.java
+++ b/src/api/java/baritone/api/pathing/calc/IPathingControlManager.java
@@ -22,10 +22,26 @@ import baritone.api.process.PathingCommand;
import java.util.Optional;
+/**
+ * @author leijurv
+ */
public interface IPathingControlManager {
+
+ /**
+ * Registers a process with this pathing control manager. See {@link IBaritoneProcess} for more details.
+ *
+ * @param process The process
+ * @see IBaritoneProcess
+ */
void registerProcess(IBaritoneProcess process);
+ /**
+ * @return The most recent {@link IBaritoneProcess} that had control
+ */
Optional mostRecentInControl();
+ /**
+ * @return The most recent pathing command executed
+ */
Optional mostRecentCommand();
}
diff --git a/src/api/java/baritone/api/process/IBaritoneProcess.java b/src/api/java/baritone/api/process/IBaritoneProcess.java
index db7588ab..01e833c0 100644
--- a/src/api/java/baritone/api/process/IBaritoneProcess.java
+++ b/src/api/java/baritone/api/process/IBaritoneProcess.java
@@ -17,7 +17,6 @@
package baritone.api.process;
-import baritone.api.IBaritone;
import baritone.api.behavior.IPathingBehavior;
import baritone.api.event.events.PathEvent;
@@ -25,8 +24,10 @@ import baritone.api.event.events.PathEvent;
* A process that can control the PathingBehavior.
*
* Differences between a baritone process and a behavior:
- * Only one baritone process can be active at a time
- * PathingBehavior can only be controlled by a process
+ *
+ * - Only one baritone process can be active at a time
+ * - PathingBehavior can only be controlled by a process
+ *
*
* That's it actually
*
@@ -83,13 +84,6 @@ public interface IBaritoneProcess {
*/
double priority();
- /**
- * Returns which bot this process is associated with. (5000000iq forward thinking)
- *
- * @return The Bot associated with this process
- */
- IBaritone associatedWith();
-
/**
* Returns a user-friendly name for this process. Suitable for a HUD.
*
diff --git a/src/launch/java/baritone/launch/mixins/MixinEntity.java b/src/launch/java/baritone/launch/mixins/MixinEntity.java
index fe498202..83655783 100644
--- a/src/launch/java/baritone/launch/mixins/MixinEntity.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntity.java
@@ -52,7 +52,7 @@ public class MixinEntity {
private void preMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
// noinspection ConstantConditions
if (EntityPlayerSP.class.isInstance(this)) {
- this.motionUpdateRotationEvent = new RotationMoveEvent((EntityPlayerSP) (Object) this, RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
+ this.motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(this.motionUpdateRotationEvent);
}
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java b/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java
index 1a7d298f..c6d76634 100644
--- a/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java
@@ -55,7 +55,7 @@ public abstract class MixinEntityLivingBase extends Entity {
private void preMoveRelative(CallbackInfo ci) {
// noinspection ConstantConditions
if (EntityPlayerSP.class.isInstance(this)) {
- this.jumpRotationEvent = new RotationMoveEvent((EntityPlayerSP) (Object) this, RotationMoveEvent.Type.JUMP, this.rotationYaw);
+ this.jumpRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.JUMP, this.rotationYaw);
BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(this.jumpRotationEvent);
}
}
diff --git a/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java b/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java
index 9c9509f0..bbf92011 100644
--- a/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java
@@ -21,8 +21,11 @@ import baritone.api.BaritoneAPI;
import baritone.api.behavior.IPathingBehavior;
import baritone.api.event.events.ChatEvent;
import baritone.api.event.events.PlayerUpdateEvent;
+import baritone.api.event.events.SprintStateEvent;
import baritone.api.event.events.type.EventState;
+import baritone.behavior.LookBehavior;
import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.settings.KeyBinding;
import net.minecraft.entity.player.PlayerCapabilities;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@@ -43,7 +46,7 @@ public class MixinEntityPlayerSP {
cancellable = true
)
private void sendChatMessage(String msg, CallbackInfo ci) {
- ChatEvent event = new ChatEvent((EntityPlayerSP) (Object) this, msg);
+ ChatEvent event = new ChatEvent(msg);
BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onSendChatMessage(event);
if (event.isCancelled()) {
ci.cancel();
@@ -60,7 +63,7 @@ public class MixinEntityPlayerSP {
)
)
private void onPreUpdate(CallbackInfo ci) {
- BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.PRE));
+ BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.PRE));
}
@Inject(
@@ -73,7 +76,7 @@ public class MixinEntityPlayerSP {
)
)
private void onPostUpdate(CallbackInfo ci) {
- BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent((EntityPlayerSP) (Object) this, EventState.POST));
+ BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerUpdate(new PlayerUpdateEvent(EventState.POST));
}
@Redirect(
@@ -87,4 +90,27 @@ public class MixinEntityPlayerSP {
IPathingBehavior pathingBehavior = BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getPathingBehavior();
return !pathingBehavior.isPathing() && capabilities.allowFlying;
}
+
+ @Redirect(
+ method = "onLivingUpdate",
+ at = @At(
+ value = "INVOKE",
+ target = "net/minecraft/client/settings/KeyBinding.isKeyDown()Z"
+ )
+ )
+ private boolean isKeyDown(KeyBinding keyBinding) {
+ SprintStateEvent event = new SprintStateEvent();
+ BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerSprintState(event);
+ return event.getState() == null ? keyBinding.isKeyDown() : event.getState();
+ }
+
+ @Inject(
+ method = "updateRidden",
+ at = @At(
+ value = "HEAD"
+ )
+ )
+ private void updateRidden(CallbackInfo cb) {
+ ((LookBehavior) BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getLookBehavior()).pig();
+ }
}
diff --git a/src/main/java/baritone/behavior/LookBehavior.java b/src/main/java/baritone/behavior/LookBehavior.java
index 31e76913..c2d0326c 100644
--- a/src/main/java/baritone/behavior/LookBehavior.java
+++ b/src/main/java/baritone/behavior/LookBehavior.java
@@ -95,6 +95,12 @@ public final class LookBehavior extends Behavior implements ILookBehavior {
}
}
+ public void pig() {
+ if (this.target != null) {
+ ctx.player().rotationYaw = this.target.getYaw();
+ }
+ }
+
@Override
public void onPlayerRotationMove(RotationMoveEvent event) {
if (this.target != null && !this.force) {
diff --git a/src/main/java/baritone/behavior/MemoryBehavior.java b/src/main/java/baritone/behavior/MemoryBehavior.java
index 696e107d..d371116c 100644
--- a/src/main/java/baritone/behavior/MemoryBehavior.java
+++ b/src/main/java/baritone/behavior/MemoryBehavior.java
@@ -48,6 +48,8 @@ import java.nio.file.Path;
import java.util.*;
/**
+ * doesn't work for horse inventories :^)
+ *
* @author Brady
* @since 8/6/2018
*/
@@ -107,7 +109,6 @@ public final class MemoryBehavior extends Behavior {
}
if (p instanceof CPacketCloseWindow) {
- updateInventory();
getCurrent().save();
}
}
@@ -142,7 +143,6 @@ public final class MemoryBehavior extends Behavior {
}
if (p instanceof SPacketCloseWindow) {
- updateInventory();
getCurrent().save();
}
}
diff --git a/src/main/java/baritone/behavior/PathingBehavior.java b/src/main/java/baritone/behavior/PathingBehavior.java
index 8c5fb8a4..74cc46ee 100644
--- a/src/main/java/baritone/behavior/PathingBehavior.java
+++ b/src/main/java/baritone/behavior/PathingBehavior.java
@@ -19,10 +19,7 @@ package baritone.behavior;
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.event.events.*;
import baritone.api.pathing.calc.IPath;
import baritone.api.pathing.goals.Goal;
import baritone.api.pathing.goals.GoalXZ;
@@ -39,7 +36,6 @@ import baritone.utils.Helper;
import baritone.utils.PathRenderer;
import baritone.utils.pathing.Favoring;
import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.chunk.EmptyChunk;
import java.util.ArrayList;
import java.util.Comparator;
@@ -98,6 +94,13 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
dispatchEvents();
}
+ @Override
+ public void onPlayerSprintState(SprintStateEvent event) {
+ if (current != null) {
+ event.setState(current.isSprinting());
+ }
+ }
+
private void tickPath() {
if (pauseRequestedLastTick && safeToCancel) {
pauseRequestedLastTick = false;
diff --git a/src/main/java/baritone/cache/WorldProvider.java b/src/main/java/baritone/cache/WorldProvider.java
index 83cf460d..fe2efa4e 100644
--- a/src/main/java/baritone/cache/WorldProvider.java
+++ b/src/main/java/baritone/cache/WorldProvider.java
@@ -24,6 +24,7 @@ import baritone.utils.accessor.IAnvilChunkLoader;
import baritone.utils.accessor.IChunkProviderServer;
import net.minecraft.server.integrated.IntegratedServer;
import net.minecraft.world.WorldServer;
+import org.apache.commons.lang3.SystemUtils;
import java.io.File;
import java.io.FileOutputStream;
@@ -76,7 +77,11 @@ public class WorldProvider implements IWorldProvider, Helper {
directory = new File(directory, "baritone");
readme = directory;
} else { // Otherwise, the server must be remote...
- directory = new File(Baritone.getDir(), mc.getCurrentServerData().serverIP);
+ String folderName = mc.getCurrentServerData().serverIP;
+ if (SystemUtils.IS_OS_WINDOWS) {
+ folderName = folderName.replace(":", "_");
+ }
+ directory = new File(Baritone.getDir(), folderName);
readme = Baritone.getDir();
}
diff --git a/src/main/java/baritone/event/GameEventHandler.java b/src/main/java/baritone/event/GameEventHandler.java
index 55bf21b7..1bf63502 100644
--- a/src/main/java/baritone/event/GameEventHandler.java
+++ b/src/main/java/baritone/event/GameEventHandler.java
@@ -125,6 +125,11 @@ public final class GameEventHandler implements IEventBus, Helper {
listeners.forEach(l -> l.onPlayerRotationMove(event));
}
+ @Override
+ public void onPlayerSprintState(SprintStateEvent event) {
+ listeners.forEach(l -> l.onPlayerSprintState(event));
+ }
+
@Override
public void onBlockInteract(BlockInteractEvent event) {
listeners.forEach(l -> l.onBlockInteract(event));
diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java
index ce78c231..4599637a 100644
--- a/src/main/java/baritone/pathing/movement/Movement.java
+++ b/src/main/java/baritone/pathing/movement/Movement.java
@@ -123,7 +123,7 @@ public abstract class Movement implements IMovement, MovementHelper {
baritone.getLookBehavior().updateTarget(
rotation,
currentState.getTarget().hasToForceRotations()));
-
+ baritone.getInputOverrideHandler().clearAllKeys();
currentState.getInputStates().forEach((input, forced) -> {
baritone.getInputOverrideHandler().setInputForceState(input, forced);
});
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
index d2d2c282..d54ffc51 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -177,13 +177,6 @@ public class MovementDescend extends Movement {
if (MovementHelper.isBottomSlab(ontoBlock)) {
return false; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect
}
- if (context.hasWaterBucket && unprotectedFallHeight <= context.maxFallHeightBucket + 1) {
- res.x = destX;
- res.y = newY + 1;// this is the block we're falling onto, so dest is +1
- res.z = destZ;
- res.cost = tentativeCost + context.placeBlockCost;
- return true;
- }
if (unprotectedFallHeight <= context.maxFallHeightNoWater + 1) {
// fallHeight = 4 means onto.up() is 3 blocks down, which is the max
res.x = destX;
@@ -191,6 +184,13 @@ public class MovementDescend extends Movement {
res.z = destZ;
res.cost = tentativeCost;
return false;
+ }
+ if (context.hasWaterBucket && unprotectedFallHeight <= context.maxFallHeightBucket + 1) {
+ res.x = destX;
+ res.y = newY + 1;// this is the block we're falling onto, so dest is +1
+ res.z = destZ;
+ res.cost = tentativeCost + context.placeBlockCost;
+ return true;
} else {
return false;
}
@@ -235,8 +235,7 @@ public class MovementDescend extends Movement {
if (numTicks++ < 20) {
MovementHelper.moveTowards(ctx, state, fakeDest);
if (fromStart > 1.25) {
- state.setInput(Input.MOVE_FORWARD, false);
- state.setInput(Input.MOVE_BACK, true);
+ state.getTarget().rotation = new Rotation(state.getTarget().rotation.getYaw() + 180F, state.getTarget().rotation.getPitch());
}
} else {
MovementHelper.moveTowards(ctx, state, dest);
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java
index 6442d7d9..a82ad110 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java
@@ -30,6 +30,7 @@ import baritone.pathing.movement.MovementHelper;
import baritone.pathing.movement.MovementState;
import baritone.pathing.movement.MovementState.MovementTarget;
import baritone.utils.pathing.MutableMoveResult;
+import net.minecraft.block.Block;
import net.minecraft.block.BlockLadder;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.InventoryPlayer;
@@ -79,7 +80,8 @@ public class MovementFall extends Movement {
BlockPos playerFeet = ctx.playerFeet();
Rotation toDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest));
Rotation targetRotation = null;
- if (!MovementHelper.isWater(ctx, dest) && willPlaceBucket() && !playerFeet.equals(dest)) {
+ Block destBlock = ctx.world().getBlockState(dest).getBlock();
+ if (destBlock != Blocks.WATER && destBlock != Blocks.FLOWING_WATER && willPlaceBucket() && !playerFeet.equals(dest)) {
if (!InventoryPlayer.isHotbar(ctx.player().inventory.getSlotFor(STACK_BUCKET_WATER)) || ctx.world().provider.isNether()) {
return state.setStatus(MovementStatus.UNREACHABLE);
}
@@ -100,8 +102,8 @@ public class MovementFall extends Movement {
} else {
state.setTarget(new MovementTarget(toDest, false));
}
- if (playerFeet.equals(dest) && (ctx.player().posY - playerFeet.getY() < 0.094 || MovementHelper.isWater(ctx, dest))) { // 0.094 because lilypads
- if (MovementHelper.isWater(ctx, dest)) {
+ if (playerFeet.equals(dest) && (ctx.player().posY - playerFeet.getY() < 0.094 || destBlock == Blocks.WATER)) { // 0.094 because lilypads
+ if (destBlock == Blocks.WATER) { // only match water, not flowing water (which we cannot pick up with a bucket)
if (InventoryPlayer.isHotbar(ctx.player().inventory.getSlotFor(STACK_BUCKET_EMPTY))) {
ctx.player().inventory.currentItem = ctx.player().inventory.getSlotFor(STACK_BUCKET_EMPTY);
if (ctx.player().motionY >= 0) {
@@ -132,7 +134,7 @@ public class MovementFall extends Movement {
double dist = Math.abs(avoid.getX() * (destCenter.x - avoid.getX() / 2.0 - ctx.player().posX)) + Math.abs(avoid.getZ() * (destCenter.z - avoid.getZ() / 2.0 - ctx.player().posZ));
if (dist < 0.6) {
state.setInput(Input.MOVE_FORWARD, true);
- } else {
+ } else if (!ctx.player().onGround) {
state.setInput(Input.SNEAK, false);
}
}
diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java
index cad144aa..6f161cc0 100644
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -79,6 +79,8 @@ public class PathExecutor implements IPathExecutor, Helper {
private PathingBehavior behavior;
private IPlayerContext ctx;
+ private boolean sprintNextTick;
+
public PathExecutor(PathingBehavior behavior, IPath path) {
this.behavior = behavior;
this.ctx = behavior.ctx;
@@ -269,7 +271,10 @@ public class PathExecutor implements IPathExecutor, Helper {
onTick();
return true;
} else {
- sprintIfRequested();
+ sprintNextTick = shouldSprintNextTick();
+ if (!sprintNextTick) {
+ ctx.player().setSprinting(false); // letting go of control doesn't make you stop sprinting actually
+ }
ticksOnCurrent++;
if (ticksOnCurrent > currentMovementOriginalCostEstimate + Baritone.settings().movementTimeoutTicks.get()) {
// only cancel if the total time has exceeded the initial estimate
@@ -371,21 +376,17 @@ public class PathExecutor implements IPathExecutor, Helper {
return true;
}
- private void sprintIfRequested() {
+ private boolean shouldSprintNextTick() {
// first and foremost, if allowSprint is off, or if we don't have enough hunger, don't try and sprint
if (!new CalculationContext(behavior.baritone).canSprint) {
behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
- ctx.player().setSprinting(false);
- return;
+ return false;
}
// if the movement requested sprinting, then we're done
if (behavior.baritone.getInputOverrideHandler().isInputForcedDown(Input.SPRINT)) {
behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
- if (!ctx.player().isSprinting()) {
- ctx.player().setSprinting(true);
- }
- return;
+ return true;
}
// we'll take it from here, no need for minecraft to see we're holding down control and sprint for us
@@ -393,36 +394,32 @@ public class PathExecutor implements IPathExecutor, Helper {
// however, descend doesn't request sprinting, beceause it doesn't know the context of what movement comes after it
IMovement current = path.movements().get(pathPosition);
- if (current instanceof MovementDescend && pathPosition < path.length() - 2) {
+ if (current instanceof MovementDescend) {
if (((MovementDescend) current).safeMode()) {
logDebug("Sprinting would be unsafe");
- ctx.player().setSprinting(false);
- return;
+ return false;
}
- IMovement next = path.movements().get(pathPosition + 1);
- if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
- // a descend then an ascend in the same direction
- if (!ctx.player().isSprinting()) {
- ctx.player().setSprinting(true);
- }
- pathPosition++;
- // okay to skip clearKeys and / or onChangeInPathPosition here since this isn't possible to repeat, since it's asymmetric
- logDebug("Skipping descend to straight ascend");
- return;
- }
- if (canSprintInto(ctx, current, next)) {
- if (ctx.playerFeet().equals(current.getDest())) {
+ if (pathPosition < path.length() - 2) {
+ IMovement next = path.movements().get(pathPosition + 1);
+ if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
+ // a descend then an ascend in the same direction
pathPosition++;
- onChangeInPathPosition();
+ // okay to skip clearKeys and / or onChangeInPathPosition here since this isn't possible to repeat, since it's asymmetric
+ logDebug("Skipping descend to straight ascend");
+ return true;
}
- if (!ctx.player().isSprinting()) {
- ctx.player().setSprinting(true);
+ if (canSprintInto(ctx, current, next)) {
+ if (ctx.playerFeet().equals(current.getDest())) {
+ pathPosition++;
+ onChangeInPathPosition();
+ onTick();
+ }
+ return true;
}
- return;
+ //logDebug("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection()));
}
- //logDebug("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection()));
}
if (current instanceof MovementAscend && pathPosition != 0) {
IMovement prev = path.movements().get(pathPosition - 1);
@@ -430,14 +427,11 @@ public class PathExecutor implements IPathExecutor, Helper {
BlockPos center = current.getSrc().up();
if (ctx.player().posY >= center.getY()) { // playerFeet adds 0.1251 to account for soul sand
behavior.baritone.getInputOverrideHandler().setInputForceState(Input.JUMP, false);
- if (!ctx.player().isSprinting()) {
- ctx.player().setSprinting(true);
- }
- return;
+ return true;
}
}
}
- ctx.player().setSprinting(false);
+ return false;
}
private static boolean canSprintInto(IPlayerContext ctx, IMovement current, IMovement next) {
@@ -532,4 +526,8 @@ public class PathExecutor implements IPathExecutor, Helper {
public Set toWalkInto() {
return Collections.unmodifiableSet(toWalkInto);
}
+
+ public boolean isSprinting() {
+ return sprintNextTick;
+ }
}
diff --git a/src/main/java/baritone/utils/BaritoneProcessHelper.java b/src/main/java/baritone/utils/BaritoneProcessHelper.java
index c5e13619..1a66eaa5 100644
--- a/src/main/java/baritone/utils/BaritoneProcessHelper.java
+++ b/src/main/java/baritone/utils/BaritoneProcessHelper.java
@@ -34,11 +34,6 @@ public abstract class BaritoneProcessHelper implements IBaritoneProcess, Helper
baritone.getPathingControlManager().registerProcess(this);
}
- @Override
- public Baritone associatedWith() {
- return baritone;
- }
-
@Override
public boolean isTemporary() {
return false;
diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java
index f5d054be..1c710bde 100644
--- a/src/main/java/baritone/utils/ExampleBaritoneControl.java
+++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java
@@ -79,6 +79,8 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
"costs - (debug) all movement costs from current location\n" +
"damn - Daniel ";
+ private static final String COMMAND_PREFIX = "#";
+
public ExampleBaritoneControl(Baritone baritone) {
super(baritone);
}
@@ -90,17 +92,20 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
}
String msg = event.getMessage();
if (Baritone.settings().prefix.get()) {
- if (!msg.startsWith("#")) {
- return;
+ if (msg.startsWith(COMMAND_PREFIX)) {
+ if (!runCommand(msg.substring(COMMAND_PREFIX.length()))) {
+ logDirect("Invalid command");
+ }
+ event.cancel(); // always cancel if using prefix
+ }
+ } else {
+ if (runCommand(msg)) {
+ event.cancel();
}
- msg = msg.substring(1);
- }
- if (runCommand(msg)) {
- event.cancel();
}
}
- public boolean runCommand(String msg0) {
+ public boolean runCommand(String msg0) { // you may think this can be private, but impcat calls it from .b =)
String msg = msg0.toLowerCase(Locale.US).trim(); // don't reassign the argument LOL
PathingBehavior pathingBehavior = baritone.getPathingBehavior();
CustomGoalProcess customGoalProcess = baritone.getCustomGoalProcess();
@@ -123,7 +128,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
for (String line : HELP_MSG.split("\n")) {
logDirect(line);
}
- return false;
+ return true;
}
if (msg.contains(" ")) {
String[] data = msg.split(" ");
diff --git a/src/main/java/baritone/utils/PathRenderer.java b/src/main/java/baritone/utils/PathRenderer.java
index deca0951..9f07efdf 100644
--- a/src/main/java/baritone/utils/PathRenderer.java
+++ b/src/main/java/baritone/utils/PathRenderer.java
@@ -216,8 +216,9 @@ public final class PathRenderer implements Helper {
double renderPosX = player.lastTickPosX + (player.posX - player.lastTickPosX) * (double) partialTicks;
double renderPosY = player.lastTickPosY + (player.posY - player.lastTickPosY) * (double) partialTicks;
double renderPosZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * (double) partialTicks;
+ BlockStateInterface bsi = new BlockStateInterface(BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext()); // TODO this assumes same dimension between primary baritone and render view? is this safe?
positions.forEach(pos -> {
- IBlockState state = BlockStateInterface.get(BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext(), pos);
+ IBlockState state = bsi.get0(pos);
AxisAlignedBB toDraw;
if (state.getBlock().equals(Blocks.AIR)) {
toDraw = Blocks.DIRT.getDefaultState().getSelectedBoundingBox(player.world, pos);
diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java
index fa71a6b0..bfa4e251 100644
--- a/src/main/java/baritone/utils/ToolSet.java
+++ b/src/main/java/baritone/utils/ToolSet.java
@@ -135,6 +135,7 @@ public class ToolSet {
* Calculates how long would it take to mine the specified block given the best tool
* in this toolset is used. A negative value is returned if the specified block is unbreakable.
*
+ * @param item the item to mine it with
* @param state the blockstate to be mined
* @return how long it would take in ticks
*/
diff --git a/src/main/java/baritone/utils/player/PrimaryPlayerContext.java b/src/main/java/baritone/utils/player/PrimaryPlayerContext.java
index f0d7ee01..1eefc91f 100644
--- a/src/main/java/baritone/utils/player/PrimaryPlayerContext.java
+++ b/src/main/java/baritone/utils/player/PrimaryPlayerContext.java
@@ -27,7 +27,7 @@ import net.minecraft.util.math.RayTraceResult;
import net.minecraft.world.World;
/**
- * Implementation of {@link IPlayerContext} that provides information about the local player.
+ * Implementation of {@link IPlayerContext} that provides information about the primary player.
*
* @author Brady
* @since 11/12/2018
diff --git a/src/main/java/baritone/utils/player/PrimaryPlayerController.java b/src/main/java/baritone/utils/player/PrimaryPlayerController.java
index 7b998bb5..c0dc8798 100644
--- a/src/main/java/baritone/utils/player/PrimaryPlayerController.java
+++ b/src/main/java/baritone/utils/player/PrimaryPlayerController.java
@@ -27,6 +27,8 @@ import net.minecraft.util.math.BlockPos;
import net.minecraft.world.GameType;
/**
+ * Implementation of {@link IPlayerController} that chains to the primary player controller's methods
+ *
* @author Brady
* @since 12/14/2018
*/