From d177db5a35ba146876b8540bdb116e36dee06713 Mon Sep 17 00:00:00 2001 From: Brady Date: Mon, 8 Oct 2018 19:57:22 -0500 Subject: [PATCH] IMovement Hey would you look at that --- src/main/java/baritone/pathing/calc/Path.java | 3 +- .../pathing/movement/CalculationContext.java | 18 ++--- .../baritone/pathing/movement/IMovement.java | 67 +++++++++++++++++++ .../baritone/pathing/movement/Movement.java | 31 +++++++-- .../pathing/movement/MovementState.java | 4 -- .../pathing/movement/MovementStatus.java | 27 ++++++++ .../movement/movements/MovementAscend.java | 6 +- .../movement/movements/MovementDescend.java | 2 +- .../movement/movements/MovementDiagonal.java | 9 +-- .../movement/movements/MovementDownward.java | 9 +-- .../movement/movements/MovementFall.java | 2 +- .../movement/movements/MovementParkour.java | 15 ++--- .../movement/movements/MovementPillar.java | 17 ++--- .../movement/movements/MovementTraverse.java | 17 ++--- .../baritone/pathing/path/CutoffPath.java | 6 +- .../java/baritone/pathing/path/IPath.java | 8 +-- .../baritone/pathing/path/PathExecutor.java | 27 +++----- .../utils/ExampleBaritoneControl.java | 4 +- 18 files changed, 179 insertions(+), 93 deletions(-) create mode 100644 src/main/java/baritone/pathing/movement/IMovement.java create mode 100644 src/main/java/baritone/pathing/movement/MovementStatus.java diff --git a/src/main/java/baritone/pathing/calc/Path.java b/src/main/java/baritone/pathing/calc/Path.java index f1a31553..6606cfba 100644 --- a/src/main/java/baritone/pathing/calc/Path.java +++ b/src/main/java/baritone/pathing/calc/Path.java @@ -18,6 +18,7 @@ package baritone.pathing.calc; import baritone.api.pathing.goals.Goal; +import baritone.pathing.movement.IMovement; import baritone.pathing.movement.Movement; import baritone.pathing.movement.Moves; import baritone.pathing.path.IPath; @@ -161,7 +162,7 @@ class Path implements IPath { } @Override - public List movements() { + public List movements() { if (!verified) { throw new IllegalStateException(); } diff --git a/src/main/java/baritone/pathing/movement/CalculationContext.java b/src/main/java/baritone/pathing/movement/CalculationContext.java index 0b40539e..464703ff 100644 --- a/src/main/java/baritone/pathing/movement/CalculationContext.java +++ b/src/main/java/baritone/pathing/movement/CalculationContext.java @@ -17,7 +17,7 @@ package baritone.pathing.movement; -import baritone.Baritone; +import baritone.api.BaritoneAPI; import baritone.api.pathing.movement.ActionCosts; import baritone.utils.Helper; import baritone.utils.ToolSet; @@ -51,20 +51,20 @@ public class CalculationContext implements Helper { public CalculationContext(ToolSet toolSet) { this.toolSet = toolSet; - this.hasThrowaway = Baritone.settings().allowPlace.get() && MovementHelper.throwaway(false); - this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.get() && InventoryPlayer.isHotbar(player().inventory.getSlotFor(STACK_BUCKET_WATER)) && !world().provider.isNether(); - this.canSprint = Baritone.settings().allowSprint.get() && player().getFoodStats().getFoodLevel() > 6; - this.placeBlockCost = Baritone.settings().blockPlacementPenalty.get(); - this.allowBreak = Baritone.settings().allowBreak.get(); - this.maxFallHeightNoWater = Baritone.settings().maxFallHeightNoWater.get(); - this.maxFallHeightBucket = Baritone.settings().maxFallHeightBucket.get(); + this.hasThrowaway = BaritoneAPI.getSettings().allowPlace.get() && MovementHelper.throwaway(false); + this.hasWaterBucket = BaritoneAPI.getSettings().allowWaterBucketFall.get() && InventoryPlayer.isHotbar(player().inventory.getSlotFor(STACK_BUCKET_WATER)) && !world().provider.isNether(); + this.canSprint = BaritoneAPI.getSettings().allowSprint.get() && player().getFoodStats().getFoodLevel() > 6; + this.placeBlockCost = BaritoneAPI.getSettings().blockPlacementPenalty.get(); + this.allowBreak = BaritoneAPI.getSettings().allowBreak.get(); + this.maxFallHeightNoWater = BaritoneAPI.getSettings().maxFallHeightNoWater.get(); + this.maxFallHeightBucket = BaritoneAPI.getSettings().maxFallHeightBucket.get(); int depth = EnchantmentHelper.getDepthStriderModifier(player()); if (depth > 3) { depth = 3; } float mult = depth / 3.0F; this.waterWalkSpeed = ActionCosts.WALK_ONE_IN_WATER_COST * (1 - mult) + ActionCosts.WALK_ONE_BLOCK_COST * mult; - this.breakBlockAdditionalCost = Baritone.settings().blockBreakAdditionalPenalty.get(); + this.breakBlockAdditionalCost = BaritoneAPI.getSettings().blockBreakAdditionalPenalty.get(); // why cache these things here, why not let the movements just get directly from settings? // because if some movements are calculated one way and others are calculated another way, // then you get a wildly inconsistent path that isn't optimal for either scenario. diff --git a/src/main/java/baritone/pathing/movement/IMovement.java b/src/main/java/baritone/pathing/movement/IMovement.java new file mode 100644 index 00000000..83b65019 --- /dev/null +++ b/src/main/java/baritone/pathing/movement/IMovement.java @@ -0,0 +1,67 @@ +/* + * 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.pathing.movement; + +import baritone.utils.pathing.BetterBlockPos; +import net.minecraft.util.math.BlockPos; + +import java.util.List; + +/** + * @author Brady + * @since 10/8/2018 + */ +public interface IMovement { + + double getCost(); + + MovementStatus update(); + + /** + * Resets the current state status to {@link MovementStatus#PREPPING} + */ + void reset(); + + /** + * Resets the cache for special break, place, and walk into blocks + */ + void resetBlockCache(); + + /** + * @return Whether or not it is safe to cancel the current movement state + */ + boolean safeToCancel(); + + double recalculateCost(); + + double calculateCostWithoutCaching(); + + boolean calculatedWhileLoaded(); + + BetterBlockPos getSrc(); + + BetterBlockPos getDest(); + + BlockPos getDirection(); + + List toBreak(); + + List toPlace(); + + List toWalkInto(); +} diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 2b87c1e0..b529873a 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -21,7 +21,6 @@ import baritone.Baritone; import baritone.api.utils.Rotation; import baritone.behavior.LookBehavior; import baritone.behavior.LookBehaviorUtils; -import baritone.pathing.movement.MovementState.MovementStatus; import baritone.utils.*; import baritone.utils.pathing.BetterBlockPos; import net.minecraft.block.BlockLiquid; @@ -36,7 +35,7 @@ import java.util.Optional; import static baritone.utils.InputOverrideHandler.Input; -public abstract class Movement implements Helper, MovementHelper { +public abstract class Movement implements IMovement, Helper, MovementHelper { protected static final EnumFacing[] HORIZONTALS = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST}; @@ -64,7 +63,7 @@ public abstract class Movement implements Helper, MovementHelper { public List toPlaceCached = null; public List toWalkIntoCached = null; - private Boolean calculatedWhileLoaded; + private boolean calculatedWhileLoaded; protected Movement(BetterBlockPos src, BetterBlockPos dest, BetterBlockPos[] toBreak, BetterBlockPos toPlace) { this.src = src; @@ -77,24 +76,27 @@ public abstract class Movement implements Helper, MovementHelper { this(src, dest, toBreak, null); } - public double getCost(CalculationContext context) { + @Override + public double getCost() { if (cost == null) { - cost = calculateCost(context != null ? context : new CalculationContext()); + cost = calculateCost(new CalculationContext()); } return cost; } protected abstract double calculateCost(CalculationContext context); + @Override public double recalculateCost() { cost = null; - return getCost(null); + return getCost(); } protected void override(double cost) { this.cost = cost; } + @Override public double calculateCostWithoutCaching() { return calculateCost(new CalculationContext()); } @@ -105,6 +107,7 @@ public abstract class Movement implements Helper, MovementHelper { * * @return Status */ + @Override public MovementStatus update() { player().capabilities.allowFlying = false; MovementState latestState = updateState(currentState); @@ -187,6 +190,7 @@ public abstract class Movement implements Helper, MovementHelper { return true; } + @Override public boolean safeToCancel() { return safeToCancel(currentState); } @@ -201,10 +205,12 @@ public abstract class Movement implements Helper, MovementHelper { && currentState.getStatus() != MovementStatus.WAITING); } + @Override public BetterBlockPos getSrc() { return src; } + @Override public BetterBlockPos getDest() { return dest; } @@ -223,6 +229,7 @@ public abstract class Movement implements Helper, MovementHelper { currentState.setStatus(MovementStatus.CANCELED); } + @Override public void reset() { currentState = new MovementState().setStatus(MovementStatus.PREPPING); } @@ -247,6 +254,7 @@ public abstract class Movement implements Helper, MovementHelper { return state; } + @Override public BlockPos getDirection() { return getDest().subtract(getSrc()); } @@ -255,10 +263,19 @@ public abstract class Movement implements Helper, MovementHelper { calculatedWhileLoaded = !(world().getChunk(getDest()) instanceof EmptyChunk); } + @Override public boolean calculatedWhileLoaded() { return calculatedWhileLoaded; } + @Override + public void resetBlockCache() { + toBreakCached = null; + toPlaceCached = null; + toWalkIntoCached = null; + } + + @Override public List toBreak() { if (toBreakCached != null) { return toBreakCached; @@ -273,6 +290,7 @@ public abstract class Movement implements Helper, MovementHelper { return result; } + @Override public List toPlace() { if (toPlaceCached != null) { return toPlaceCached; @@ -285,6 +303,7 @@ public abstract class Movement implements Helper, MovementHelper { return result; } + @Override public List toWalkInto() { // overridden by movementdiagonal if (toWalkIntoCached == null) { toWalkIntoCached = new ArrayList<>(); diff --git a/src/main/java/baritone/pathing/movement/MovementState.java b/src/main/java/baritone/pathing/movement/MovementState.java index 6d0262e6..acf223d4 100644 --- a/src/main/java/baritone/pathing/movement/MovementState.java +++ b/src/main/java/baritone/pathing/movement/MovementState.java @@ -72,10 +72,6 @@ public class MovementState { return this.inputState; } - public enum MovementStatus { - PREPPING, WAITING, RUNNING, SUCCESS, UNREACHABLE, FAILED, CANCELED - } - public static class MovementTarget { /** diff --git a/src/main/java/baritone/pathing/movement/MovementStatus.java b/src/main/java/baritone/pathing/movement/MovementStatus.java new file mode 100644 index 00000000..4b4b92c3 --- /dev/null +++ b/src/main/java/baritone/pathing/movement/MovementStatus.java @@ -0,0 +1,27 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Baritone. If not, see . + */ + +package baritone.pathing.movement; + +/** + * @author Brady + * @since 10/8/2018 + */ +public enum MovementStatus { + + PREPPING, WAITING, RUNNING, SUCCESS, UNREACHABLE, FAILED, CANCELED +} diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index b5e21eea..9ad42d99 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -19,11 +19,7 @@ package baritone.pathing.movement.movements; import baritone.Baritone; import baritone.behavior.LookBehaviorUtils; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; -import baritone.pathing.movement.MovementState.MovementStatus; +import baritone.pathing.movement.*; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java index 3bba5f1d..227a6b89 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java @@ -22,7 +22,7 @@ import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; -import baritone.pathing.movement.MovementState.MovementStatus; +import baritone.pathing.movement.MovementStatus; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.pathing.BetterBlockPos; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index 58027a8d..b8ef01c3 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -17,10 +17,7 @@ package baritone.pathing.movement.movements; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.pathing.BetterBlockPos; @@ -140,12 +137,12 @@ public class MovementDiagonal extends Movement { @Override public MovementState updateState(MovementState state) { super.updateState(state); - if (state.getStatus() != MovementState.MovementStatus.RUNNING) { + if (state.getStatus() != MovementStatus.RUNNING) { return state; } if (playerFeet().equals(dest)) { - state.setStatus(MovementState.MovementStatus.SUCCESS); + state.setStatus(MovementStatus.SUCCESS); return state; } if (!BlockStateInterface.isLiquid(playerFeet())) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java index 148dc3b3..d808d993 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java @@ -17,10 +17,7 @@ package baritone.pathing.movement.movements; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.utils.BlockStateInterface; import baritone.utils.pathing.BetterBlockPos; import net.minecraft.block.Block; @@ -64,12 +61,12 @@ public class MovementDownward extends Movement { @Override public MovementState updateState(MovementState state) { super.updateState(state); - if (state.getStatus() != MovementState.MovementStatus.RUNNING) { + if (state.getStatus() != MovementStatus.RUNNING) { return state; } if (playerFeet().equals(dest)) { - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } double diffX = player().posX - (dest.getX() + 0.5); double diffZ = player().posZ - (dest.getZ() + 0.5); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index f901c61f..3ce2848f 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -23,7 +23,7 @@ import baritone.pathing.movement.CalculationContext; import baritone.pathing.movement.Movement; import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; -import baritone.pathing.movement.MovementState.MovementStatus; +import baritone.pathing.movement.MovementStatus; import baritone.pathing.movement.MovementState.MovementTarget; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java index e128bb3c..7ecb4c04 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java @@ -20,10 +20,7 @@ package baritone.pathing.movement.movements; import baritone.Baritone; import baritone.api.utils.Rotation; import baritone.behavior.LookBehaviorUtils; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.utils.*; import baritone.utils.pathing.BetterBlockPos; import baritone.utils.pathing.MutableMoveResult; @@ -168,13 +165,13 @@ public class MovementParkour extends Movement { // once this movement is instantiated, the state is default to PREPPING // but once it's ticked for the first time it changes to RUNNING // since we don't really know anything about momentum, it suffices to say Parkour can only be canceled on the 0th tick - return state.getStatus() != MovementState.MovementStatus.RUNNING; + return state.getStatus() != MovementStatus.RUNNING; } @Override public MovementState updateState(MovementState state) { super.updateState(state); - if (state.getStatus() != MovementState.MovementStatus.RUNNING) { + if (state.getStatus() != MovementStatus.RUNNING) { return state; } if (dist >= 4) { @@ -186,10 +183,10 @@ public class MovementParkour extends Movement { if (d == Blocks.VINE || d == Blocks.LADDER) { // it physically hurt me to add support for parkour jumping onto a vine // but i did it anyway - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } if (player().posY - playerFeet().getY() < 0.094) { // lilypads - state.setStatus(MovementState.MovementStatus.SUCCESS); + state.setStatus(MovementStatus.SUCCESS); } } else if (!playerFeet().equals(src)) { if (playerFeet().equals(src.offset(direction)) || player().posY - playerFeet().getY() > 0.0001) { @@ -203,7 +200,7 @@ public class MovementParkour extends Movement { } if (MovementHelper.canPlaceAgainst(against1)) { if (!MovementHelper.throwaway(true)) {//get ready to place a throwaway block - return state.setStatus(MovementState.MovementStatus.UNREACHABLE); + return state.setStatus(MovementStatus.UNREACHABLE); } double faceX = (dest.getX() + against1.getX() + 1.0D) * 0.5D; double faceY = (dest.getY() + against1.getY()) * 0.5D; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java index be524185..7680fb43 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java @@ -18,10 +18,7 @@ package baritone.pathing.movement.movements; import baritone.api.utils.Rotation; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; @@ -148,7 +145,7 @@ public class MovementPillar extends Movement { @Override public MovementState updateState(MovementState state) { super.updateState(state); - if (state.getStatus() != MovementState.MovementStatus.RUNNING) { + if (state.getStatus() != MovementStatus.RUNNING) { return state; } @@ -161,7 +158,7 @@ public class MovementPillar extends Movement { state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, true); } if (playerFeet().equals(dest)) { - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } return state; } @@ -178,11 +175,11 @@ public class MovementPillar extends Movement { BlockPos against = vine ? getAgainst(src) : src.offset(fromDown.getValue(BlockLadder.FACING).getOpposite()); if (against == null) { logDebug("Unable to climb vines"); - return state.setStatus(MovementState.MovementStatus.UNREACHABLE); + return state.setStatus(MovementStatus.UNREACHABLE); } if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) { - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } if (MovementHelper.isBottomSlab(src.down())) { state.setInput(InputOverrideHandler.Input.JUMP, true); @@ -198,7 +195,7 @@ public class MovementPillar extends Movement { } else { // Get ready to place a throwaway block if (!MovementHelper.throwaway(true)) { - return state.setStatus(MovementState.MovementStatus.UNREACHABLE); + return state.setStatus(MovementStatus.UNREACHABLE); } numTicks++; @@ -233,7 +230,7 @@ public class MovementPillar extends Movement { // If we are at our goal and the block below us is placed if (playerFeet().equals(dest) && blockIsThere) { - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } return state; diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index 7c4ba237..00000ac4 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -20,10 +20,7 @@ package baritone.pathing.movement.movements; import baritone.Baritone; import baritone.api.utils.Rotation; import baritone.behavior.LookBehaviorUtils; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; @@ -144,13 +141,13 @@ public class MovementTraverse extends Movement { @Override public MovementState updateState(MovementState state) { super.updateState(state); - if (state.getStatus() != MovementState.MovementStatus.RUNNING) { + if (state.getStatus() != MovementStatus.RUNNING) { // if the setting is enabled if (!Baritone.settings().walkWhileBreaking.get()) { return state; } // and if we're prepping (aka mining the block in front) - if (state.getStatus() != MovementState.MovementStatus.PREPPING) { + if (state.getStatus() != MovementStatus.PREPPING) { return state; } // and if it's fine to walk into the blocks in front @@ -225,7 +222,7 @@ public class MovementTraverse extends Movement { if (isTheBridgeBlockThere) { if (playerFeet().equals(dest)) { - return state.setStatus(MovementState.MovementStatus.SUCCESS); + return state.setStatus(MovementStatus.SUCCESS); } if (wasTheBridgeBlockAlwaysThere && !BlockStateInterface.isLiquid(playerFeet())) { state.setInput(InputOverrideHandler.Input.SPRINT, true); @@ -248,7 +245,7 @@ public class MovementTraverse extends Movement { if (MovementHelper.canPlaceAgainst(against1)) { if (!MovementHelper.throwaway(true)) { // get ready to place a throwaway block logDebug("bb pls get me some blocks. dirt or cobble"); - return state.setStatus(MovementState.MovementStatus.UNREACHABLE); + return state.setStatus(MovementStatus.UNREACHABLE); } if (!Baritone.settings().assumeSafeWalk.get()) { state.setInput(InputOverrideHandler.Input.SNEAK, true); @@ -287,7 +284,7 @@ public class MovementTraverse extends Movement { // Out.log(from + " " + to + " " + faceX + "," + faceY + "," + faceZ + " " + whereAmI); if (!MovementHelper.throwaway(true)) {// get ready to place a throwaway block logDebug("bb pls get me some blocks. dirt or cobble"); - return state.setStatus(MovementState.MovementStatus.UNREACHABLE); + return state.setStatus(MovementStatus.UNREACHABLE); } double faceX = (dest.getX() + src.getX() + 1.0D) * 0.5D; double faceY = (dest.getY() + src.getY() - 1.0D) * 0.5D; @@ -324,7 +321,7 @@ public class MovementTraverse extends Movement { // if we're in the process of breaking blocks before walking forwards // or if this isn't a sneak place (the block is already there) // then it's safe to cancel this - return state.getStatus() != MovementState.MovementStatus.RUNNING || MovementHelper.canWalkOn(dest.down()); + return state.getStatus() != MovementStatus.RUNNING || MovementHelper.canWalkOn(dest.down()); } @Override diff --git a/src/main/java/baritone/pathing/path/CutoffPath.java b/src/main/java/baritone/pathing/path/CutoffPath.java index e517452e..916b6c52 100644 --- a/src/main/java/baritone/pathing/path/CutoffPath.java +++ b/src/main/java/baritone/pathing/path/CutoffPath.java @@ -18,7 +18,7 @@ package baritone.pathing.path; import baritone.api.pathing.goals.Goal; -import baritone.pathing.movement.Movement; +import baritone.pathing.movement.IMovement; import baritone.utils.pathing.BetterBlockPos; import java.util.Collections; @@ -28,7 +28,7 @@ public class CutoffPath implements IPath { private final List path; - private final List movements; + private final List movements; private final int numNodes; @@ -47,7 +47,7 @@ public class CutoffPath implements IPath { } @Override - public List movements() { + public List movements() { return Collections.unmodifiableList(movements); } diff --git a/src/main/java/baritone/pathing/path/IPath.java b/src/main/java/baritone/pathing/path/IPath.java index 5741c440..afc1bce3 100644 --- a/src/main/java/baritone/pathing/path/IPath.java +++ b/src/main/java/baritone/pathing/path/IPath.java @@ -19,7 +19,7 @@ package baritone.pathing.path; import baritone.api.BaritoneAPI; import baritone.api.pathing.goals.Goal; -import baritone.pathing.movement.Movement; +import baritone.pathing.movement.IMovement; import baritone.utils.Utils; import baritone.utils.pathing.BetterBlockPos; import net.minecraft.client.Minecraft; @@ -40,7 +40,7 @@ public interface IPath { * movements.get(i).getDest() should equal positions.get(i+1) * movements.size() should equal positions.size()-1 */ - List movements(); + List movements(); /** * All positions along the way. @@ -86,7 +86,7 @@ public interface IPath { /** * Where does this path start */ - default BlockPos getSrc() { + default BetterBlockPos getSrc() { return positions().get(0); } @@ -102,7 +102,7 @@ public interface IPath { double sum = 0; //this is fast because we aren't requesting recalculation, it's just cached for (int i = pathPosition; i < movements().size(); i++) { - sum += movements().get(i).getCost(null); + sum += movements().get(i).getCost(); } return sum; } diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 4afd8b76..a60b4a29 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -21,10 +21,7 @@ import baritone.Baritone; import baritone.api.event.events.TickEvent; import baritone.api.pathing.movement.ActionCosts; import baritone.pathing.calc.AbstractNodeCostSearch; -import baritone.pathing.movement.CalculationContext; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.pathing.movement.movements.*; import baritone.utils.*; import baritone.utils.pathing.BetterBlockPos; @@ -34,7 +31,7 @@ import net.minecraft.util.math.BlockPos; import java.util.*; -import static baritone.pathing.movement.MovementState.MovementStatus.*; +import static baritone.pathing.movement.MovementStatus.*; /** * Behavior to execute a precomputed path. Does not (yet) deal with path segmentation or stitching @@ -182,13 +179,11 @@ public class PathExecutor implements Helper { if (i < 0 || i >= path.movements().size()) { continue; } - Movement m = path.movements().get(i); + IMovement m = path.movements().get(i); HashSet prevBreak = new HashSet<>(m.toBreak()); HashSet prevPlace = new HashSet<>(m.toPlace()); HashSet prevWalkInto = new HashSet<>(m.toWalkInto()); - m.toBreakCached = null; - m.toPlaceCached = null; - m.toWalkIntoCached = null; + m.resetBlockCache(); if (!prevBreak.equals(new HashSet<>(m.toBreak()))) { recalcBP = true; } @@ -217,12 +212,12 @@ public class PathExecutor implements Helper { if (end - start > 0) { System.out.println("Recalculating break and place took " + (end - start) + "ms"); }*/ - Movement movement = path.movements().get(pathPosition); + IMovement movement = path.movements().get(pathPosition); boolean canCancel = movement.safeToCancel(); if (costEstimateIndex == null || costEstimateIndex != pathPosition) { costEstimateIndex = pathPosition; // do this only once, when the movement starts, and deliberately get the cost as cached when this path was calculated, not the cost as it is right now - currentMovementOriginalCostEstimate = movement.getCost(null); + currentMovementOriginalCostEstimate = movement.getCost(); for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { if (path.movements().get(pathPosition + i).calculateCostWithoutCaching() >= ActionCosts.COST_INF && canCancel) { logDebug("Something has changed in the world and a future movement has become impossible. Cancelling."); @@ -246,7 +241,7 @@ public class PathExecutor implements Helper { logDebug("Pausing since current best path is a backtrack"); return true; } - MovementState.MovementStatus movementStatus = movement.update(); + MovementStatus movementStatus = movement.update(); if (movementStatus == UNREACHABLE || movementStatus == FAILED) { logDebug("Movement returns status " + movementStatus); cancel(); @@ -346,7 +341,7 @@ public class PathExecutor implements Helper { Baritone.INSTANCE.getInputOverrideHandler().setInputForceState(InputOverrideHandler.Input.SPRINT,false); // however, descend doesn't request sprinting, beceause it doesn't know the context of what movement comes after it - Movement current = path.movements().get(pathPosition); + IMovement current = path.movements().get(pathPosition); if (current instanceof MovementDescend && pathPosition < path.length() - 2) { // (dest - src) + dest is offset 1 more in the same direction @@ -361,7 +356,7 @@ public class PathExecutor implements Helper { } } - Movement next = path.movements().get(pathPosition + 1); + 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 (!player().isSprinting()) { @@ -385,7 +380,7 @@ public class PathExecutor implements Helper { //logDebug("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection())); } if (current instanceof MovementAscend && pathPosition != 0) { - Movement prev = path.movements().get(pathPosition - 1); + IMovement prev = path.movements().get(pathPosition - 1); if (prev instanceof MovementDescend && prev.getDirection().up().equals(current.getDirection().down())) { BlockPos center = current.getSrc().up(); if (player().posY >= center.getY()) { // playerFeet adds 0.1251 to account for soul sand @@ -400,7 +395,7 @@ public class PathExecutor implements Helper { player().setSprinting(false); } - private static boolean canSprintInto(Movement current, Movement next) { + private static boolean canSprintInto(IMovement current, IMovement next) { if (next instanceof MovementDescend) { if (next.getDirection().equals(current.getDirection())) { return true; diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index cca6e3a2..fd733d7f 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -467,10 +467,10 @@ public class ExampleBaritoneControl extends Behavior implements Helper { while (moves.contains(null)) { moves.remove(null); } - moves.sort(Comparator.comparingDouble(movement -> movement.getCost(new CalculationContext()))); + moves.sort(Comparator.comparingDouble(Movement::getCost)); for (Movement move : moves) { String[] parts = move.getClass().toString().split("\\."); - double cost = move.getCost(new CalculationContext()); + double cost = move.getCost(); String strCost = cost + ""; if (cost >= ActionCosts.COST_INF) { strCost = "IMPOSSIBLE";