From a93af3404bfa555e087e3e890c6a92801557709f Mon Sep 17 00:00:00 2001 From: Leijurv Date: Fri, 31 Aug 2018 11:51:43 -0700 Subject: [PATCH 01/80] cache chunk in BlockStateInterface, fixes #113 --- .../java/baritone/utils/BlockStateInterface.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/baritone/utils/BlockStateInterface.java b/src/main/java/baritone/utils/BlockStateInterface.java index a1013d7f..f21ddc50 100644 --- a/src/main/java/baritone/utils/BlockStateInterface.java +++ b/src/main/java/baritone/utils/BlockStateInterface.java @@ -30,6 +30,8 @@ import net.minecraft.world.chunk.Chunk; public class BlockStateInterface implements Helper { + private static Chunk prev = null; + public static IBlockState get(BlockPos pos) { // wrappers for chunk caching capability // Invalid vertical position @@ -37,8 +39,18 @@ public class BlockStateInterface implements Helper { return Blocks.AIR.getDefaultState(); if (!Baritone.settings().pathThroughCachedOnly.get()) { + Chunk cached = prev; + // there's great cache locality in block state lookups + // generally it's within each movement + // if it's the same chunk as last time + // we can just skip the mc.world.getChunk lookup + // which is a Long2ObjectOpenHashMap.get + if (cached != null && cached.x == pos.getX() >> 4 && cached.z == pos.getZ() >> 4) { + return cached.getBlockState(pos); + } Chunk chunk = mc.world.getChunk(pos); if (chunk.isLoaded()) { + prev = chunk; return chunk.getBlockState(pos); } } From f10e010e201f7ad572e799733dd3c7353d74567c Mon Sep 17 00:00:00 2001 From: Brady Date: Fri, 31 Aug 2018 16:32:15 -0500 Subject: [PATCH 02/80] GoalNear#toString --- src/main/java/baritone/pathing/goals/GoalNear.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/baritone/pathing/goals/GoalNear.java b/src/main/java/baritone/pathing/goals/GoalNear.java index d19fadf8..2ec6bf1d 100644 --- a/src/main/java/baritone/pathing/goals/GoalNear.java +++ b/src/main/java/baritone/pathing/goals/GoalNear.java @@ -51,4 +51,14 @@ public class GoalNear implements Goal { public BlockPos getGoalPos() { return new BlockPos(x, y, z); } + + @Override + public String toString() { + return "GoalNear{" + + "x=" + x + + ", y=" + y + + ", z=" + z + + ", rangeSq=" + rangeSq + + '}'; + } } From 3f688bc45ecf982cb5cfbddfd6441b662da9d028 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Fri, 31 Aug 2018 14:58:23 -0700 Subject: [PATCH 03/80] spam chat less --- src/main/java/baritone/behavior/impl/PathingBehavior.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index 4b5f1f43..e7c20c61 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -203,6 +203,12 @@ public class PathingBehavior extends Behavior { * @return true if this call started path calculation, false if it was already calculating or executing a path */ public boolean path() { + if (goal == null) { + return false; + } + if (goal.isInGoal(playerFeet())) { + return false; + } synchronized (pathPlanLock) { if (current != null) { return false; From 24c5c5d2381508a1aeeb5dbf1ea635c128b56cb1 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Fri, 31 Aug 2018 15:21:59 -0700 Subject: [PATCH 04/80] instant cancel when more than 3 blocks away --- .../java/baritone/pathing/path/PathExecutor.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 76fcc3c1..4adda1f2 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -25,6 +25,7 @@ import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; import baritone.pathing.movement.movements.MovementDescend; import baritone.pathing.movement.movements.MovementDiagonal; +import baritone.pathing.movement.movements.MovementFall; import baritone.pathing.movement.movements.MovementTraverse; import baritone.utils.BlockStateInterface; import baritone.utils.Helper; @@ -46,6 +47,7 @@ import static baritone.pathing.movement.MovementState.MovementStatus.*; * @author leijurv */ public class PathExecutor implements Helper { + private static final double MAX_MAX_DIST_FROM_PATH = 3; private static final double MAX_DIST_FROM_PATH = 2; private static final double MAX_TICKS_AWAY = 200; // ten seconds. ok to decrease this, but it must be at least 110, see issue #102 private final IPath path; @@ -132,6 +134,17 @@ public class PathExecutor implements Helper { } else { ticksAway = 0; } + if (distanceFromPath > MAX_MAX_DIST_FROM_PATH) { + if (!(path.movements().get(pathPosition) instanceof MovementFall)) { // might be midair + if (pathPosition > 0 || !(path.movements().get(pathPosition - 1) instanceof MovementFall)) { // might have overshot the landing + displayChatMessageRaw("too far from path"); + pathPosition = path.length() + 3; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + failed = true; + return false; + } + } + } //this commented block is literally cursed. /*Out.log(actions.get(pathPosition)); if (pathPosition < actions.size() - 1) {//if there are two ActionBridges in a row and they are at right angles, walk diagonally. This makes it so you walk at 45 degrees along a zigzag path instead of doing inefficient zigging and zagging From 791eb886c0f900e8d423031dd893e18d73f2536b Mon Sep 17 00:00:00 2001 From: Leijurv Date: Fri, 31 Aug 2018 16:50:25 -0700 Subject: [PATCH 05/80] bugfix --- src/main/java/baritone/pathing/path/PathExecutor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 4adda1f2..dcecaeda 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -136,7 +136,7 @@ public class PathExecutor implements Helper { } if (distanceFromPath > MAX_MAX_DIST_FROM_PATH) { if (!(path.movements().get(pathPosition) instanceof MovementFall)) { // might be midair - if (pathPosition > 0 || !(path.movements().get(pathPosition - 1) instanceof MovementFall)) { // might have overshot the landing + if (pathPosition == 0 || !(path.movements().get(pathPosition - 1) instanceof MovementFall)) { // might have overshot the landing displayChatMessageRaw("too far from path"); pathPosition = path.length() + 3; Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); From 3c25e2b685c4160f7c0d4367f6f898487e463ede Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 11:19:42 -0700 Subject: [PATCH 06/80] fix part of oscillation --- src/main/java/baritone/pathing/calc/AStarPathFinder.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java index e5ebe184..a437d67e 100644 --- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java +++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java @@ -169,6 +169,9 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { for (int i = 0; i < bestSoFar.length; i++) { double heuristic = neighbor.estimatedCostToGoal + neighbor.cost / COEFFICIENTS[i]; if (heuristic < bestHeuristicSoFar[i]) { + if (bestHeuristicSoFar[i] - heuristic < 0.01 && minimumImprovementRepropagation) { + continue; + } bestHeuristicSoFar[i] = heuristic; bestSoFar[i] = neighbor; } From 0b892e05cb6b805a78fb096f9b97a43ed730028c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 11:30:02 -0700 Subject: [PATCH 07/80] goto next to block, not in it, fixes #116 --- .../utils/ExampleBaritoneControl.java | 23 ++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 542ea323..58847d3d 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -37,8 +37,10 @@ import baritone.utils.pathing.BetterBlockPos; import net.minecraft.block.Block; import net.minecraft.entity.Entity; import net.minecraft.util.math.BlockPos; +import net.minecraft.world.chunk.EmptyChunk; import java.util.*; +import java.util.stream.Collectors; public class ExampleBaritoneControl extends Behavior { public static ExampleBaritoneControl INSTANCE = new ExampleBaritoneControl(); @@ -221,8 +223,27 @@ public class ExampleBaritoneControl extends Behavior { } Waypoint.Tag tag = Waypoint.Tag.fromString(waypointType); if (tag == null) { - displayChatMessageRaw("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase()); + String mining = waypointType; + //displayChatMessageRaw("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase()); event.cancel(); + List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(mining, 1, 1)); + if (locs.isEmpty()) { + displayChatMessageRaw("No locations for " + mining + " known, cancelling"); + return; + } + BlockPos playerFeet = playerFeet(); + locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); + + // remove any that are within loaded chunks that aren't actually what we want + locs.removeAll(locs.stream() + .filter(pos -> !(world().getChunk(pos) instanceof EmptyChunk)) + .filter(pos -> !ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).equalsIgnoreCase(mining)) + .collect(Collectors.toList())); + if (locs.size() > 30) { + locs = locs.subList(0, 30); + } + PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalGetToBlock::new).toArray(Goal[]::new))); + PathingBehavior.INSTANCE.path(); return; } Waypoint waypoint = WorldProvider.INSTANCE.getCurrentWorld().waypoints.getMostRecentByTag(tag); From e354227635906d3c5a836a76473cf0ef8075d2c6 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 11:31:42 -0700 Subject: [PATCH 08/80] allow goto blocks that end in s --- src/main/java/baritone/utils/ExampleBaritoneControl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 58847d3d..8b262f0a 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -217,7 +217,7 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().startsWith("goto")) { String waypointType = msg.toLowerCase().substring(4).trim(); - if (waypointType.endsWith("s")) { + if (waypointType.endsWith("s") && Waypoint.Tag.fromString(waypointType.substring(0, waypointType.length() - 1)) != null) { // for example, "show deaths" waypointType = waypointType.substring(0, waypointType.length() - 1); } From aca487f97ea2811d2e1fa4d7ca190c4ca9598cbc Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 12:16:55 -0700 Subject: [PATCH 09/80] fix behavior when all have been mined --- src/main/java/baritone/behavior/impl/MineBehavior.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index e59058a8..32f92877 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -55,11 +55,6 @@ public class MineBehavior extends Behavior { return; } List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(mining, 1, 1)); - if (locs.isEmpty()) { - displayChatMessageRaw("No locations for " + mining + " known, cancelling"); - cancel(); - return; - } BlockPos playerFeet = playerFeet(); locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); @@ -71,6 +66,11 @@ public class MineBehavior extends Behavior { if (locs.size() > 30) { locs = locs.subList(0, 30); } + if (locs.isEmpty()) { + displayChatMessageRaw("No locations for " + mining + " known, cancelling"); + cancel(); + return; + } PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalTwoBlocks::new).toArray(Goal[]::new))); PathingBehavior.INSTANCE.path(); } From c0bc7b5ecd1e86d1473fd55f59628ffbaef638a6 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 12:26:55 -0700 Subject: [PATCH 10/80] fix strange issue when exiting and entering the same world --- src/main/java/baritone/api/event/GameEventHandler.java | 3 +++ src/main/java/baritone/utils/BlockStateInterface.java | 6 +++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/api/event/GameEventHandler.java b/src/main/java/baritone/api/event/GameEventHandler.java index 88cd0560..45e86885 100644 --- a/src/main/java/baritone/api/event/GameEventHandler.java +++ b/src/main/java/baritone/api/event/GameEventHandler.java @@ -39,6 +39,7 @@ import baritone.api.event.events.*; import baritone.api.event.events.type.EventState; import baritone.api.event.listener.IGameEventListener; import baritone.chunk.WorldProvider; +import baritone.utils.BlockStateInterface; import baritone.utils.Helper; import baritone.utils.InputOverrideHandler; import baritone.utils.interfaces.Toggleable; @@ -133,6 +134,8 @@ public final class GameEventHandler implements IGameEventListener, Helper { public final void onWorldEvent(WorldEvent event) { WorldProvider cache = WorldProvider.INSTANCE; + BlockStateInterface.clearCachedChunk(); + switch (event.getState()) { case PRE: break; diff --git a/src/main/java/baritone/utils/BlockStateInterface.java b/src/main/java/baritone/utils/BlockStateInterface.java index f21ddc50..cd3ca646 100644 --- a/src/main/java/baritone/utils/BlockStateInterface.java +++ b/src/main/java/baritone/utils/BlockStateInterface.java @@ -31,7 +31,7 @@ import net.minecraft.world.chunk.Chunk; public class BlockStateInterface implements Helper { private static Chunk prev = null; - + public static IBlockState get(BlockPos pos) { // wrappers for chunk caching capability // Invalid vertical position @@ -66,6 +66,10 @@ public class BlockStateInterface implements Helper { return Blocks.AIR.getDefaultState(); } + public static void clearCachedChunk() { + prev = null; + } + public static Block getBlock(BlockPos pos) { return get(pos).getBlock(); } From 76cdad2223b1536c9f7ec86aaabe8403f132bd03 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 12:47:43 -0700 Subject: [PATCH 11/80] properly place on soul sand, fixes #118 --- .../pathing/movement/movements/MovementTraverse.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index b1eac4e9..5c1e35fb 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -206,6 +206,16 @@ public class MovementTraverse extends Movement { return state.setStatus(MovementState.MovementStatus.UNREACHABLE); } state.setInput(InputOverrideHandler.Input.SNEAK, true); + if (BlockStateInterface.get(playerFeet().down()).getBlock().equals(Blocks.SOUL_SAND)) { // see issue #118 + double dist = Math.max(Math.abs(dest.getX() + 0.5 - player().posX), Math.abs(dest.getZ() + 0.5 - player().posZ)); + if (dist < 0.85) { // 0.5 + 0.3 + epsilon + MovementHelper.moveTowards(state, dest); + state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, false); + state.setInput(InputOverrideHandler.Input.MOVE_BACK, true); + return state; + } + } + state.setInput(InputOverrideHandler.Input.MOVE_BACK, false); double faceX = (dest.getX() + against1.getX() + 1.0D) * 0.5D; double faceY = (dest.getY() + against1.getY()) * 0.5D; double faceZ = (dest.getZ() + against1.getZ() + 1.0D) * 0.5D; From 8d46c36269dc21b436f1967b41966ce08fcdd61a Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 13:20:27 -0700 Subject: [PATCH 12/80] you can walk on chests --- src/main/java/baritone/pathing/movement/MovementHelper.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 142f5d98..909c21a7 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -195,6 +195,9 @@ public interface MovementHelper extends ActionCosts, Helper { if (Blocks.FARMLAND.equals(block) || Blocks.GRASS_PATH.equals(block)) { return true; } + if (Blocks.ENDER_CHEST.equals(block) || Blocks.CHEST.equals(block)) { + return true; + } if (block instanceof BlockAir) { return false; } From e705f9808b9e1432466376787896e4a1dca98ff6 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 14:45:57 -0700 Subject: [PATCH 13/80] add force cancel --- .../java/baritone/pathing/calc/AbstractNodeCostSearch.java | 6 ++++++ src/main/java/baritone/utils/ExampleBaritoneControl.java | 7 +++++++ 2 files changed, 13 insertions(+) diff --git a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java index b8f13f1e..2894b989 100644 --- a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java +++ b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java @@ -17,6 +17,7 @@ package baritone.pathing.calc; +import baritone.behavior.impl.PathingBehavior; import baritone.pathing.goals.Goal; import baritone.pathing.path.IPath; import baritone.utils.pathing.BetterBlockPos; @@ -121,6 +122,11 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { return node; } + public static void forceCancel() { + PathingBehavior.INSTANCE.cancel(); + currentlyRunning = null; + } + @Override public Optional pathToMostRecentNodeConsidered() { return Optional.ofNullable(mostRecentConsidered).map(node -> new Path(startNode, node, 0)); diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 8b262f0a..e695ff49 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -28,6 +28,7 @@ import baritone.chunk.ChunkPacker; import baritone.chunk.Waypoint; import baritone.chunk.WorldProvider; import baritone.pathing.calc.AStarPathFinder; +import baritone.pathing.calc.AbstractNodeCostSearch; import baritone.pathing.goals.*; import baritone.pathing.movement.ActionCosts; import baritone.pathing.movement.CalculationContext; @@ -117,6 +118,12 @@ public class ExampleBaritoneControl extends Behavior { displayChatMessageRaw("ok canceled"); return; } + if (msg.toLowerCase().equals("forcecancel")) { + AbstractNodeCostSearch.forceCancel(); + event.cancel(); + displayChatMessageRaw("ok force canceled"); + return; + } if (msg.toLowerCase().equals("invert")) { Goal goal = PathingBehavior.INSTANCE.getGoal(); BlockPos runAwayFrom; From 2e22f1cf54a0dd022547bc0b9614dbc231c96fa1 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sat, 1 Sep 2018 14:47:46 -0700 Subject: [PATCH 14/80] hopefully make currentlyRunning more resilient --- .../pathing/calc/AbstractNodeCostSearch.java | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java index 2894b989..3960a376 100644 --- a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java +++ b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java @@ -81,9 +81,19 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { throw new IllegalStateException("Path Finder is currently in use, and cannot be reused!"); } this.cancelRequested = false; - Optional path = calculate0(); - isFinished = true; - return path; + try { + Optional path = calculate0(); + isFinished = true; + return path; + } catch (Exception e) { + currentlyRunning = null; + isFinished = true; + if (e instanceof RuntimeException) { + throw (RuntimeException) e; + } else { + throw new RuntimeException(e); + } + } } protected abstract Optional calculate0(); From 1f97daf391e9ed70f47f673e5bf437147b70b23c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 07:18:57 -0700 Subject: [PATCH 15/80] clean up the clutter --- .../java/baritone/pathing/calc/AStarPathFinder.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java index a437d67e..0af6f0fe 100644 --- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java +++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java @@ -95,20 +95,13 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { mostRecentConsidered = currentNode; BetterBlockPos currentNodePos = currentNode.pos; numNodes++; - /*if ((lastPrintout + 1000) - System.nanoTime() / 1000000L < 0) {//print once a second - System.out.println("searching... at " + currentNodePos + ", considered " + numNodes + " nodes so far"); - lastPrintout = System.nanoTime() / 1000000L; - }*/ if (goal.isInGoal(currentNodePos)) { currentlyRunning = null; displayChatMessageRaw("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, " + numMovementsConsidered + " movements considered"); return Optional.of(new Path(startNode, currentNode, numNodes)); } - //long constructStart = System.nanoTime(); Movement[] possibleMovements = getConnectedPositions(currentNodePos, calcContext);//movement that we could take that start at currentNodePos, in random order shuffle(possibleMovements); - //long constructEnd = System.nanoTime(); - //System.out.println(constructEnd - constructStart); for (Movement movementToGetToNeighbor : possibleMovements) { if (movementToGetToNeighbor == null) { continue; @@ -126,11 +119,8 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { } } } - //long costStart = System.nanoTime(); // TODO cache cost double actionCost = movementToGetToNeighbor.getCost(calcContext); - //long costEnd = System.nanoTime(); - //System.out.println(movementToGetToNeighbor.getClass() + "" + (costEnd - costStart)); numMovementsConsidered++; if (actionCost >= ActionCosts.COST_INF) { continue; From 3afd8368220c24b80256f357bc9c8db0cadd2b44 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 09:22:51 -0700 Subject: [PATCH 16/80] only offset down if doing so would put us on solid ground --- src/main/java/baritone/behavior/impl/PathingBehavior.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index e7c20c61..075d8d6f 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -27,6 +27,7 @@ import baritone.pathing.calc.AStarPathFinder; import baritone.pathing.calc.AbstractNodeCostSearch; import baritone.pathing.calc.IPathFinder; import baritone.pathing.goals.*; +import baritone.pathing.movement.MovementHelper; import baritone.pathing.path.IPath; import baritone.pathing.path.PathExecutor; import baritone.utils.BlockStateInterface; @@ -226,7 +227,7 @@ public class PathingBehavior extends Behavior { public BlockPos pathStart() { BlockPos feet = playerFeet(); - if (BlockStateInterface.get(feet.down()).getBlock().equals(Blocks.AIR)) { + if (BlockStateInterface.get(feet.down()).getBlock().equals(Blocks.AIR) && MovementHelper.canWalkOn(feet.down().down())) { return feet.down(); } return feet; From 462ccad885941235b65fbbdbb323b782630276ce Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 10:43:34 -0700 Subject: [PATCH 17/80] use initial estimate from calculation phase --- .../baritone/pathing/path/PathExecutor.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index dcecaeda..ce86b4d0 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -217,17 +217,9 @@ public class PathExecutor implements Helper { //displayChatMessageRaw("Recalculating break and place took " + (end - start) + "ms"); } Movement movement = path.movements().get(pathPosition); - double currentCost = movement.recalculateCost(); - if (currentCost >= ActionCosts.COST_INF) { - displayChatMessageRaw("Something has changed in the world and this movement has become impossible. Cancelling."); - pathPosition = path.length() + 3; - failed = true; - Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); - return true; - } if (costEstimateIndex == null || costEstimateIndex != pathPosition) { costEstimateIndex = pathPosition; - currentMovementInitialCostEstimate = currentCost; // do this only once, when the movement starts + currentMovementInitialCostEstimate = movement.getCost(null); // do this only once, when the movement starts for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { if (path.movements().get(pathPosition + i).recalculateCost() >= ActionCosts.COST_INF) { displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); @@ -238,6 +230,14 @@ public class PathExecutor implements Helper { } } } + double currentCost = movement.recalculateCost(); + if (currentCost >= ActionCosts.COST_INF) { + displayChatMessageRaw("Something has changed in the world and this movement has become impossible. Cancelling."); + pathPosition = path.length() + 3; + failed = true; + Baritone.INSTANCE.getInputOverrideHandler().clearAllKeys(); + return true; + } MovementState.MovementStatus movementStatus = movement.update(); if (movementStatus == UNREACHABLE || movementStatus == FAILED) { displayChatMessageRaw("Movement returns status " + movementStatus); From e58c43305cc1cb679f34cb6064a65162ad488f90 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 10:45:07 -0700 Subject: [PATCH 18/80] typo --- FEATURES.md | 15 +++++++++++++++ .../baritone/utils/ExampleBaritoneControl.java | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 FEATURES.md diff --git a/FEATURES.md b/FEATURES.md new file mode 100644 index 00000000..3f90dae2 --- /dev/null +++ b/FEATURES.md @@ -0,0 +1,15 @@ +# Pathing features +- Long distance pathing and splicing. Baritone calculates paths in segments + +# Goals +The pathing goal can be set to any of these options +- GoalBlock - one specific block that the player should stand inside at foot level +- GoalXZ - an X and a Z coordinate, used for long distance pathing +- GoalYLevel - a Y coordinate +- GoalTwoBlocks - a block position that the player should stand in, either at foot or eye level +- GoalGetToBlock - a block position that the player should stand adjacent to, below, or on top of +- GoalNear - a block position that the player should get within a certain radius of, used for following entities + +And finally GoalComposite. GoalComposite is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a GoalComposite of GoalTwoBlock s for every diamond ore location it knows of. + + diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index e695ff49..854950da 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -188,7 +188,7 @@ public class ExampleBaritoneControl extends Behavior { if (msg.toLowerCase().startsWith("mine")) { String blockType = msg.toLowerCase().substring(4).trim(); MineBehavior.INSTANCE.mine(blockType); - displayChatMessageRaw("Started mining blocks of type" + blockType); + displayChatMessageRaw("Started mining blocks of type " + blockType); event.cancel(); return; } From f3bd50dc3658712ff0f21aa3747289c64e2bcd5c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 10:46:54 -0700 Subject: [PATCH 19/80] disable load boundary cutoff by default, fixes #114 --- src/main/java/baritone/Settings.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 79bbec6b..7f386bcb 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -122,8 +122,9 @@ public class Settings { /** * After calculating a path (potentially through cached chunks), artificially cut it off to just the part that is * entirely within currently loaded chunks. Improves path safety because cached chunks are heavily simplified. + * See issue #114 for why this is disabled. */ - public Setting cutoffAtLoadBoundary = new Setting<>(true); + public Setting cutoffAtLoadBoundary = new Setting<>(false); /** * Stop 5 movements before anything that made the path COST_INF. From 17b27af09fbdd935b5beb6ad0adec6bb4cec22c8 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:09:28 -0700 Subject: [PATCH 20/80] more features --- FEATURES.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/FEATURES.md b/FEATURES.md index 3f90dae2..19f3b81d 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -1,5 +1,13 @@ # Pathing features -- Long distance pathing and splicing. Baritone calculates paths in segments +- Long distance pathing and splicing. Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end. +- Chunk caching. Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. +- Block breaking. Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. +- Block placing. Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. +- Falling. Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. +- Vines and ladders. Baritone understands how to climb and descend vines and ladders. +- Fence gates and doors. +- Falling blocks. Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). +- # Goals The pathing goal can be set to any of these options @@ -13,3 +21,5 @@ The pathing goal can be set to any of these options And finally GoalComposite. GoalComposite is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a GoalComposite of GoalTwoBlock s for every diamond ore location it knows of. +# Future features +(things it doesn't have yet) \ No newline at end of file From 262b33f3228b20b0877622cbe1482681aee2cf97 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:14:57 -0700 Subject: [PATCH 21/80] pathing method and upcoming features --- FEATURES.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 19f3b81d..0bf4aca5 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -7,7 +7,14 @@ - Vines and ladders. Baritone understands how to climb and descend vines and ladders. - Fence gates and doors. - Falling blocks. Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). -- + +# Pathing method +Baritone uses a modified version of A*. + +- Incremental cost backoff. Since most of the time Baritone only knows the terrain up to the render distance, it can't calculate a full path to the goal. Therefore it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a write-up that still applies. +- Minimum improvement repropagation. The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get. +- Backtrack cost favoring. While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. + # Goals The pathing goal can be set to any of these options @@ -22,4 +29,9 @@ And finally GoalComposite. GoalComposite is a list of other goals, any one of wh # Future features -(things it doesn't have yet) \ No newline at end of file +(things it doesn't have yet) +- Trapdoors +- Boats +- Horses / pigs +- Sprint jumping in a 1x2 corridor +- Parkour (jumping over gaps of any length) \ No newline at end of file From 1f73fe8c795fe30c68fbf6597cc799d4b19319a2 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:15:43 -0700 Subject: [PATCH 22/80] add link to features --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 2748cb4f..3a174662 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,8 @@ A Minecraft bot. This project is an updated version of [Minebot](https://github.com/leijurv/MineBot/), the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. +Features + # Setup - Open the project in IntelliJ as a Gradle project - Run the Gradle task `setupDecompWorkspace` From 5ed40ff50d1e4e12f28ef9aef98a21c7b1a45f6c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:18:27 -0700 Subject: [PATCH 23/80] better list --- FEATURES.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 0bf4aca5..6437c30f 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -1,29 +1,29 @@ # Pathing features -- Long distance pathing and splicing. Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end. -- Chunk caching. Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. -- Block breaking. Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. -- Block placing. Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. -- Falling. Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. -- Vines and ladders. Baritone understands how to climb and descend vines and ladders. -- Fence gates and doors. -- Falling blocks. Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). +- **Long distance pathing and splicing** Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end. +- **Chunk caching** Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. +- **Block breaking** Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. +- **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. +- **Falling** Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. +- **Vines and ladders** Baritone understands how to climb and descend vines and ladders. +- **Fence gates and doors** +- **Falling blocks** Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). # Pathing method Baritone uses a modified version of A*. -- Incremental cost backoff. Since most of the time Baritone only knows the terrain up to the render distance, it can't calculate a full path to the goal. Therefore it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a write-up that still applies. -- Minimum improvement repropagation. The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get. -- Backtrack cost favoring. While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. +- **Incremental cost backoff** Since most of the time Baritone only knows the terrain up to the render distance, it can't calculate a full path to the goal. Therefore it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a write-up that still applies. In essence, it keeps track of the best node by various increasing coefficients, then picks the node with the least coefficient that goes at least 5 blocks from the starting position. +- **Minimum improvement repropagation** The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get. +- **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. # Goals The pathing goal can be set to any of these options -- GoalBlock - one specific block that the player should stand inside at foot level -- GoalXZ - an X and a Z coordinate, used for long distance pathing -- GoalYLevel - a Y coordinate -- GoalTwoBlocks - a block position that the player should stand in, either at foot or eye level -- GoalGetToBlock - a block position that the player should stand adjacent to, below, or on top of -- GoalNear - a block position that the player should get within a certain radius of, used for following entities +- **GoalBlock** one specific block that the player should stand inside at foot level +- **GoalXZ** an X and a Z coordinate, used for long distance pathing +- **GoalYLevel** a Y coordinate +- **GoalTwoBlocks** a block position that the player should stand in, either at foot or eye level +- **GoalGetToBlock** a block position that the player should stand adjacent to, below, or on top of +- **GoalNear** a block position that the player should get within a certain radius of, used for following entities And finally GoalComposite. GoalComposite is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a GoalComposite of GoalTwoBlock s for every diamond ore location it knows of. From 1cb25e29c71cd6d94d1f1c810111ce2760e2a4ba Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:25:44 -0700 Subject: [PATCH 24/80] add links --- FEATURES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 6437c30f..3ff4c917 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -1,6 +1,6 @@ # Pathing features - **Long distance pathing and splicing** Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end. -- **Chunk caching** Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. +- **Chunk caching** Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. Example - **Block breaking** Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. - **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. - **Falling** Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. @@ -13,7 +13,7 @@ Baritone uses a modified version of A*. - **Incremental cost backoff** Since most of the time Baritone only knows the terrain up to the render distance, it can't calculate a full path to the goal. Therefore it needs to select a segment to execute first (assuming it will calculate the next segment at the end of this one). It uses incremental cost backoff to select the best node by varying metrics, then paths to that node. This is unchanged from MineBot and I made a write-up that still applies. In essence, it keeps track of the best node by various increasing coefficients, then picks the node with the least coefficient that goes at least 5 blocks from the starting position. - **Minimum improvement repropagation** The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get. -- **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. +- **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. Example # Goals From 6389917898c709044e3bad4017c68a9dbaccccfb Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:39:13 -0700 Subject: [PATCH 25/80] more features --- FEATURES.md | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 3ff4c917..681e11a0 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -1,12 +1,13 @@ # Pathing features -- **Long distance pathing and splicing** Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end. -- **Chunk caching** Baritone simplifies chunks to an internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. Example +- **Long distance pathing and splicing** Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end, so that it's moving towards the goal at all times. +- **Chunk caching** Baritone simplifies chunks to a compacted internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. Example - **Block breaking** Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. -- **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. +- **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. The list of acceptable throwaway blocks is also configurable, and is cobble, dirt, or netherrack by default. - **Falling** Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. -- **Vines and ladders** Baritone understands how to climb and descend vines and ladders. +- **Vines and ladders** Baritone understands how to climb and descend vines and ladders. There is experimental support for more advanced maneuvers, like strafing to a different ladder / vine column in midair (off by default, setting named `allowVines`). - **Fence gates and doors** - **Falling blocks** Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). +- **Avoiding dangerous blocks** Obviously, it knows not to walk through fire or on magma, not to corner over lava (that deals some damage), not to break any blocks touching a liquid (it might drown), etc. # Pathing method Baritone uses a modified version of A*. @@ -15,9 +16,12 @@ Baritone uses a modified version of A*. - **Minimum improvement repropagation** The pathfinder ignores alternate routes that provide minimal improvements (less than 0.01 ticks of improvement), because the calculation cost of repropagating this to all connected nodes is much higher than the half-millisecond path time improvement it would get. - **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment slightly, as a tiebreaker. This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. Example +# Configuring Baritone +All the settings and documentation are here. +To change a boolean setting, just say its name in chat (for example saying `allowBreak` toggles whether Baritone will consider breaking blocks). For a numeric setting, say its name then the new value (like `pathTimeoutMS 250`). It's case insensitive. # Goals -The pathing goal can be set to any of these options +The pathing goal can be set to any of these options: - **GoalBlock** one specific block that the player should stand inside at foot level - **GoalXZ** an X and a Z coordinate, used for long distance pathing - **GoalYLevel** a Y coordinate @@ -25,11 +29,11 @@ The pathing goal can be set to any of these options - **GoalGetToBlock** a block position that the player should stand adjacent to, below, or on top of - **GoalNear** a block position that the player should get within a certain radius of, used for following entities -And finally GoalComposite. GoalComposite is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a GoalComposite of GoalTwoBlock s for every diamond ore location it knows of. +And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one of which satisfies the goal. For example, `mine diamond_ore` creates a `GoalComposite` of `GoalTwoBlocks`s for every diamond ore location it knows of. # Future features -(things it doesn't have yet) +(things it doesn't have yet, and things it may not ever have) - Trapdoors - Boats - Horses / pigs From 5caa0542ba84ef5aa7a58cca448810a178667ebc Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 11:48:10 -0700 Subject: [PATCH 26/80] ascend should clear the replaceable block in the way --- .../baritone/pathing/movement/movements/MovementAscend.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index af29a887..a50dfba8 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -150,6 +150,8 @@ public class MovementAscend extends Movement { // After 20 ticks without placement, we might be standing in the way, move back state.setInput(InputOverrideHandler.Input.MOVE_BACK, true); } + } else { + state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); // break whatever replaceable block is in the way } System.out.println("Trying to look at " + anAgainst + ", actually looking at" + selectedBlock); }); From 8d62f754a7a77c53234f9dd94da5b66a4c8bc617 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 12:04:48 -0700 Subject: [PATCH 27/80] crucial performance optimization --- src/main/java/baritone/chunk/ChunkPacker.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 90cdf02a..23908344 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -21,7 +21,6 @@ import baritone.pathing.movement.MovementHelper; import baritone.utils.Helper; import baritone.utils.pathing.PathingBlockType; import net.minecraft.block.Block; -import net.minecraft.block.BlockAir; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; @@ -114,7 +113,7 @@ public final class ChunkPacker implements Helper { // however, this failed in the nether when you were near a nether fortress // because fences check their adjacent blocks in the world for their fence connection status to determine AABB shape // this caused a nullpointerexception when we saved chunks on unload, because they were unable to check their neighbors - if (block instanceof BlockAir) { + if (block == Blocks.AIR) { return PathingBlockType.AIR; } From e8b108fde81c077bfb8a96199c3322804c46773c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 12:06:00 -0700 Subject: [PATCH 28/80] removePrefix --- src/main/java/baritone/Settings.java | 5 +++++ src/main/java/baritone/utils/ExampleBaritoneControl.java | 4 +++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 7f386bcb..d7d23c59 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -218,6 +218,11 @@ public class Settings { */ public Setting chatControl = new Setting<>(true); + /** + * A second override over chatControl to force it on + */ + public Setting removePrefix = new Setting<>(false); + /** * Render the path */ diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 854950da..75a36994 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -57,7 +57,9 @@ public class ExampleBaritoneControl extends Behavior { @Override public void onSendChatMessage(ChatEvent event) { if (!Baritone.settings().chatControl.get()) { - return; + if (!Baritone.settings().removePrefix.get()) { + return; + } } String msg = event.getMessage(); if (Baritone.settings().prefix.get()) { From 115b8553b257f3c98f5644c0bf22b824a7718334 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 2 Sep 2018 14:18:11 -0500 Subject: [PATCH 29/80] Make Baritone initialization listeners consumers --- src/main/java/baritone/Baritone.java | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/main/java/baritone/Baritone.java b/src/main/java/baritone/Baritone.java index bd678dd8..5baacec8 100755 --- a/src/main/java/baritone/Baritone.java +++ b/src/main/java/baritone/Baritone.java @@ -28,6 +28,7 @@ import java.io.IOException; import java.nio.file.Files; import java.util.ArrayList; import java.util.List; +import java.util.function.Consumer; /** * @author Brady @@ -52,9 +53,9 @@ public enum Baritone { private File dir; /** - * List of runnables to be called after Baritone has initialized + * List of consumers to be called after Baritone has initialized */ - private List onInitRunnables; + private List> onInitConsumers; /** * Whether or not Baritone is active @@ -62,7 +63,7 @@ public enum Baritone { private boolean active; Baritone() { - this.onInitRunnables = new ArrayList<>(); + this.onInitConsumers = new ArrayList<>(); } public synchronized void init() { @@ -91,7 +92,7 @@ public enum Baritone { this.active = true; this.initialized = true; - this.onInitRunnables.forEach(Runnable::run); + this.onInitConsumers.forEach(consumer -> consumer.accept(this)); } public final boolean isInitialized() { @@ -131,7 +132,7 @@ public enum Baritone { return this.dir; } - public final void registerInitListener(Runnable runnable) { - this.onInitRunnables.add(runnable); + public final void registerInitListener(Consumer runnable) { + this.onInitConsumers.add(runnable); } } From 0e6d61e90774129646d4168de69b0c2ed41f0e12 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 2 Sep 2018 14:21:34 -0500 Subject: [PATCH 30/80] Consolidate rayTraceTowards into RayTraceUtils, fixes #121 --- .../behavior/impl/LookBehaviorUtils.java | 19 ++----------------- .../java/baritone/utils/RayTraceUtils.java | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/LookBehaviorUtils.java b/src/main/java/baritone/behavior/impl/LookBehaviorUtils.java index fd75c478..91b046e0 100644 --- a/src/main/java/baritone/behavior/impl/LookBehaviorUtils.java +++ b/src/main/java/baritone/behavior/impl/LookBehaviorUtils.java @@ -17,10 +17,7 @@ package baritone.behavior.impl; -import baritone.utils.BlockStateInterface; -import baritone.utils.Helper; -import baritone.utils.Rotation; -import baritone.utils.Utils; +import baritone.utils.*; import net.minecraft.block.BlockFire; import net.minecraft.block.state.IBlockState; import net.minecraft.util.math.*; @@ -87,18 +84,6 @@ public final class LookBehaviorUtils implements Helper { return Optional.empty(); } - private static RayTraceResult rayTraceTowards(Rotation rotation) { - double blockReachDistance = mc.playerController.getBlockReachDistance(); - Vec3d start = mc.player.getPositionEyes(1.0F); - Vec3d direction = calcVec3dFromRotation(rotation); - Vec3d end = start.add( - direction.x * blockReachDistance, - direction.y * blockReachDistance, - direction.z * blockReachDistance - ); - return mc.world.rayTraceBlocks(start, end, false, false, true); - } - /** * Checks if coordinate is reachable with the given block-face rotation offset * @@ -108,7 +93,7 @@ public final class LookBehaviorUtils implements Helper { */ protected static Optional reachableOffset(BlockPos pos, Vec3d offsetPos) { Rotation rotation = Utils.calcRotationFromVec3d(mc.player.getPositionEyes(1.0F), offsetPos); - RayTraceResult result = rayTraceTowards(rotation); + RayTraceResult result = RayTraceUtils.rayTraceTowards(rotation); System.out.println(result); if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) { if (result.getBlockPos().equals(pos)) { diff --git a/src/main/java/baritone/utils/RayTraceUtils.java b/src/main/java/baritone/utils/RayTraceUtils.java index f6547454..123e283d 100644 --- a/src/main/java/baritone/utils/RayTraceUtils.java +++ b/src/main/java/baritone/utils/RayTraceUtils.java @@ -18,6 +18,9 @@ package baritone.utils; import net.minecraft.util.math.RayTraceResult; +import net.minecraft.util.math.Vec3d; + +import static baritone.behavior.impl.LookBehaviorUtils.calcVec3dFromRotation; /** * @author Brady @@ -44,4 +47,16 @@ public final class RayTraceUtils implements Helper { return result; } + + public static RayTraceResult rayTraceTowards(Rotation rotation) { + double blockReachDistance = mc.playerController.getBlockReachDistance(); + Vec3d start = mc.player.getPositionEyes(1.0F); + Vec3d direction = calcVec3dFromRotation(rotation); + Vec3d end = start.add( + direction.x * blockReachDistance, + direction.y * blockReachDistance, + direction.z * blockReachDistance + ); + return mc.world.rayTraceBlocks(start, end, false, false, true); + } } From 639ec3898167a24f538229270809a6a18484d4cc Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 12:55:18 -0700 Subject: [PATCH 31/80] features --- FEATURES.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/FEATURES.md b/FEATURES.md index 681e11a0..0796919c 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -37,5 +37,9 @@ And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one o - Trapdoors - Boats - Horses / pigs +- Slabs (double, top, and bottom) - Sprint jumping in a 1x2 corridor -- Parkour (jumping over gaps of any length) \ No newline at end of file +- Stairs +- Parkour (jumping over gaps of any length) + +See issues for more. \ No newline at end of file From 7ed13bf358384b49f149f29471a86c5406a6992e Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 13:05:06 -0700 Subject: [PATCH 32/80] features --- FEATURES.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 0796919c..8147fc22 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -33,13 +33,17 @@ And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one o # Future features -(things it doesn't have yet, and things it may not ever have) +Things it doesn't have yet - Trapdoors -- Boats -- Horses / pigs - Slabs (double, top, and bottom) - Sprint jumping in a 1x2 corridor - Stairs -- Parkour (jumping over gaps of any length) -See issues for more. \ No newline at end of file +See issues for more. + +Things it may not ever have, from most likely to least likely =( +- Parkour (jumping over gaps of any length) +- Boats +- Pigs +- Horses (2x3 path instead of 1x2) +- Elytra From 9e272824c5b5394b7cb1017d51a28b32b1582459 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 13:34:15 -0700 Subject: [PATCH 33/80] traverse should also break the block in the way --- .../baritone/pathing/movement/movements/MovementTraverse.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index 5c1e35fb..a959455b 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -255,7 +255,7 @@ public class MovementTraverse extends Movement { return state; } // Out.log("Trying to look at " + goalLook + ", actually looking at" + Baritone.whatAreYouLookingAt()); - return state; + return state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true); } else { MovementHelper.moveTowards(state, positionsToBreak[0]); return state; From da5460413c44114a0f68717e2117e84dc387c697 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 13:51:38 -0700 Subject: [PATCH 34/80] segment based timeout, and slowpath warning --- src/main/java/baritone/Settings.java | 7 ++++++- src/main/java/baritone/behavior/impl/PathingBehavior.java | 8 +++++++- src/main/java/baritone/pathing/calc/AStarPathFinder.java | 7 +++++-- .../baritone/pathing/calc/AbstractNodeCostSearch.java | 6 +++--- src/main/java/baritone/pathing/calc/IPathFinder.java | 2 +- 5 files changed, 22 insertions(+), 8 deletions(-) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index d7d23c59..78c2d4b3 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -185,7 +185,12 @@ public class Settings { /** * Pathing can never take longer than this */ - public Setting pathTimeoutMS = new Setting<>(4000L); + public Setting pathTimeoutMS = new Setting<>(2000L); + + /** + * Planning ahead while executing a segment can never take longer than this + */ + public Setting planAheadTimeoutMS = new Setting<>(4000L); /** * For debugging, consider nodes much much slower diff --git a/src/main/java/baritone/behavior/impl/PathingBehavior.java b/src/main/java/baritone/behavior/impl/PathingBehavior.java index 075d8d6f..fa651a87 100644 --- a/src/main/java/baritone/behavior/impl/PathingBehavior.java +++ b/src/main/java/baritone/behavior/impl/PathingBehavior.java @@ -324,9 +324,15 @@ public class PathingBehavior extends Behavior { goal = new GoalXZ(pos.getX(), pos.getZ()); } } + long timeout; + if (current == null) { + timeout = Baritone.settings().pathTimeoutMS.get(); + } else { + timeout = Baritone.settings().planAheadTimeoutMS.get(); + } try { IPathFinder pf = new AStarPathFinder(start, goal, previous.map(IPath::positions)); - return pf.calculate(); + return pf.calculate(timeout); } catch (Exception e) { displayChatMessageRaw("Pathing exception: " + e); e.printStackTrace(); diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java index 0af6f0fe..fa8b5076 100644 --- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java +++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java @@ -55,7 +55,7 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { } @Override - protected Optional calculate0() { + protected Optional calculate0(long timeout) { startNode = getNodeAtPosition(start); startNode.cost = 0; startNode.combinedCost = startNode.estimatedCostToGoal; @@ -74,7 +74,10 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { ChunkProviderClient chunkProvider = Minecraft.getMinecraft().world.getChunkProvider(); long startTime = System.nanoTime() / 1000000L; boolean slowPath = Baritone.settings().slowPath.get(); - long timeoutTime = startTime + (slowPath ? Baritone.settings().slowPathTimeoutMS : Baritone.settings().pathTimeoutMS).get(); + if (slowPath) { + displayChatMessageRaw("slowPath is on, path timeout will be " + Baritone.settings().slowPathTimeoutMS.get() + "ms instead of " + timeout + "ms"); + } + long timeoutTime = startTime + (slowPath ? Baritone.settings().slowPathTimeoutMS.get() : timeout); //long lastPrintout = 0; int numNodes = 0; int numMovementsConsidered = 0; diff --git a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java index 3960a376..5804cb1a 100644 --- a/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java +++ b/src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java @@ -76,13 +76,13 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { cancelRequested = true; } - public synchronized Optional calculate() { + public synchronized Optional calculate(long timeout) { if (isFinished) { throw new IllegalStateException("Path Finder is currently in use, and cannot be reused!"); } this.cancelRequested = false; try { - Optional path = calculate0(); + Optional path = calculate0(timeout); isFinished = true; return path; } catch (Exception e) { @@ -96,7 +96,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { } } - protected abstract Optional calculate0(); + protected abstract Optional calculate0(long timeout); /** * Determines the distance squared from the specified node to the start diff --git a/src/main/java/baritone/pathing/calc/IPathFinder.java b/src/main/java/baritone/pathing/calc/IPathFinder.java index bbcc7bda..dceee65d 100644 --- a/src/main/java/baritone/pathing/calc/IPathFinder.java +++ b/src/main/java/baritone/pathing/calc/IPathFinder.java @@ -39,7 +39,7 @@ public interface IPathFinder { * * @return The final path */ - Optional calculate(); + Optional calculate(long timeout); /** * Intended to be called concurrently with calculatePath from a different thread to tell if it's finished yet From c63ccc3dcb94636ca0c492c74ab56044a0f578a9 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:10:27 -0700 Subject: [PATCH 35/80] can walk through should be cached as air, fixes #124 --- src/main/java/baritone/chunk/ChunkPacker.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 23908344..fef3c0a5 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -21,6 +21,9 @@ import baritone.pathing.movement.MovementHelper; import baritone.utils.Helper; import baritone.utils.pathing.PathingBlockType; import net.minecraft.block.Block; +import net.minecraft.block.BlockDoublePlant; +import net.minecraft.block.BlockFlower; +import net.minecraft.block.BlockTallGrass; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; @@ -113,7 +116,7 @@ public final class ChunkPacker implements Helper { // however, this failed in the nether when you were near a nether fortress // because fences check their adjacent blocks in the world for their fence connection status to determine AABB shape // this caused a nullpointerexception when we saved chunks on unload, because they were unable to check their neighbors - if (block == Blocks.AIR) { + if (block == Blocks.AIR || block instanceof BlockTallGrass || block instanceof BlockDoublePlant || block instanceof BlockFlower) { return PathingBlockType.AIR; } From f75188b24d7f727155afac0bca91faea860b90fe Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:12:33 -0700 Subject: [PATCH 36/80] fix cost cache overwrite in path executor --- src/main/java/baritone/pathing/movement/Movement.java | 4 ++++ src/main/java/baritone/pathing/path/PathExecutor.java | 5 +++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 44c9d5a3..715bfd68 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -100,6 +100,10 @@ public abstract class Movement implements Helper, MovementHelper { return getCost(null); } + public double calculateCostWithoutCaching() { + return calculateCost0(new CalculationContext()); + } + /** * Handles the execution of the latest Movement * State, and offers a Status to the calling class. diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index ce86b4d0..88ca6e30 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -219,9 +219,10 @@ public class PathExecutor implements Helper { Movement movement = path.movements().get(pathPosition); if (costEstimateIndex == null || costEstimateIndex != pathPosition) { costEstimateIndex = pathPosition; - currentMovementInitialCostEstimate = movement.getCost(null); // do this only once, when the movement starts + // 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 + currentMovementInitialCostEstimate = movement.getCost(null); for (int i = 1; i < Baritone.settings().costVerificationLookahead.get() && pathPosition + i < path.length() - 1; i++) { - if (path.movements().get(pathPosition + i).recalculateCost() >= ActionCosts.COST_INF) { + if (path.movements().get(pathPosition + i).calculateCostWithoutCaching() >= ActionCosts.COST_INF) { displayChatMessageRaw("Something has changed in the world and a future movement has become impossible. Cancelling."); pathPosition = path.length() + 3; failed = true; From 8c58dcb41f99f8425ef80cc5524da68c05d2472a Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:13:41 -0700 Subject: [PATCH 37/80] remove unused circle ci config --- .circleci/config.yml | 43 ------------------------------------------- 1 file changed, 43 deletions(-) delete mode 100644 .circleci/config.yml diff --git a/.circleci/config.yml b/.circleci/config.yml deleted file mode 100644 index d9cdd911..00000000 --- a/.circleci/config.yml +++ /dev/null @@ -1,43 +0,0 @@ -# Java Gradle CircleCI 2.0 configuration file -# -# Check https://circleci.com/docs/2.0/language-java/ for more details -# -version: 2 -jobs: - build: - docker: - # specify the version you desire here - - image: circleci/openjdk:8-jdk - - # Specify service dependencies here if necessary - # CircleCI maintains a library of pre-built images - # documented at https://circleci.com/docs/2.0/circleci-images/ - # - image: circleci/postgres:9.4 - - working_directory: ~/repo - - environment: - # Customize the JVM maximum heap limit - JVM_OPTS: -Xmx3200m - TERM: dumb - - steps: - - checkout - - # Download and cache dependencies - - restore_cache: - keys: - - v1-dependencies-{{ checksum "build.gradle" }} - # fallback to using the latest cache if no exact match is found - - v1-dependencies- - - - run: gradle dependencies - - - save_cache: - paths: - - ~/.gradle - key: v1-dependencies-{{ checksum "build.gradle" }} - - # run tests! - - run: gradle test - From 41c03cbf365aa980678b6c01ca719d77aa422bba Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:19:21 -0700 Subject: [PATCH 38/80] update readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3a174662..29771860 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,7 @@ the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. - Select the "Minecraft Client" launch config and run ## Command Line +On Mac OSX and Linux, use `./gradlew` instead of `gradlew`. ``` $ gradlew setupDecompWorkspace $ gradlew --refresh-dependencies From a1aaaef67f4315a400ca4013a22658a3500b3101 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:46:03 -0700 Subject: [PATCH 39/80] include sponge in runtime --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 7dd75be8..bdb3c311 100755 --- a/build.gradle +++ b/build.gradle @@ -65,7 +65,7 @@ repositories { } dependencies { - implementation ('org.spongepowered:mixin:0.7.11-SNAPSHOT') { + runtime implementation('org.spongepowered:mixin:0.7.11-SNAPSHOT') { // Mixin includes a lot of dependencies that are too up-to-date exclude module: 'launchwrapper' exclude module: 'guava' From 7fd0d5799d72e3bb60cdf6e1d7520a7f75aa5f83 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Sun, 2 Sep 2018 14:46:41 -0700 Subject: [PATCH 40/80] travis start --- .travis.yml | 1 + 1 file changed, 1 insertion(+) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 00000000..dff5f3a5 --- /dev/null +++ b/.travis.yml @@ -0,0 +1 @@ +language: java From 12ec7ea990667fdc996da255b82360c67f80ad7b Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 2 Sep 2018 18:01:41 -0500 Subject: [PATCH 41/80] Update README.md --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 29771860..c3dd39ab 100644 --- a/README.md +++ b/README.md @@ -34,10 +34,12 @@ PathingBehavior.INSTANCE.setGoal(new GoalXZ(10000, 20000)); PathingBehavior.INSTANCE.path(); ``` -# Can I use Baritone as a library in my hacked client? +# FAQ + +## Can I use Baritone as a library in my hacked client? Sure! -# How is it so fast? +## How is it so fast? -Magic \ No newline at end of file +Magic From 5dbf1014b313b36d416d5e11f051c0e25131f19c Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 2 Sep 2018 21:28:55 -0500 Subject: [PATCH 42/80] Fix usage of characters that can't be mapped to ascii --- src/main/java/baritone/utils/Helper.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/Helper.java b/src/main/java/baritone/utils/Helper.java index c973b1ca..ffb0f21b 100755 --- a/src/main/java/baritone/utils/Helper.java +++ b/src/main/java/baritone/utils/Helper.java @@ -33,7 +33,13 @@ import net.minecraft.util.text.TextFormatting; */ public interface Helper { - ITextComponent MESSAGE_PREFIX = new TextComponentString("§5[§dBaritone§5]§7"); + ITextComponent MESSAGE_PREFIX = new TextComponentString(String.format( + "%s[%sBaritone%s]%s", + TextFormatting.DARK_PURPLE, + TextFormatting.LIGHT_PURPLE, + TextFormatting.DARK_PURPLE, + TextFormatting.GRAY + )); Minecraft mc = Minecraft.getMinecraft(); From 31a87a8938e5b4fd4a2d71cee7d72a6926b78e04 Mon Sep 17 00:00:00 2001 From: Brady Date: Sun, 2 Sep 2018 23:26:57 -0500 Subject: [PATCH 43/80] Added travis badge to README --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index c3dd39ab..63bc2c8b 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +![](https://travis-ci.com/cabaletta/baritone.svg?branch=master) + # Baritone A Minecraft bot. This project is an updated version of [Minebot](https://github.com/leijurv/MineBot/), the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. From bac07ce1006b9a123bc188d2ad4ce2d685be3bcf Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:15:18 -0700 Subject: [PATCH 44/80] slabs --- src/main/java/baritone/chunk/ChunkPacker.java | 15 ++++---- .../baritone/pathing/movement/Movement.java | 20 +--------- .../pathing/movement/MovementHelper.java | 7 +++- .../movement/movements/MovementAscend.java | 37 +++++++++++++++++-- .../movement/movements/MovementDescend.java | 12 +++--- .../movement/movements/MovementDiagonal.java | 6 ++- .../movement/movements/MovementDownward.java | 5 +-- .../movement/movements/MovementFall.java | 6 +++ .../movement/movements/MovementPillar.java | 18 ++++++--- .../movement/movements/MovementTraverse.java | 9 +++-- src/main/java/baritone/utils/Helper.java | 8 ++-- 11 files changed, 91 insertions(+), 52 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index fef3c0a5..e52f6a54 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -20,10 +20,7 @@ package baritone.chunk; import baritone.pathing.movement.MovementHelper; import baritone.utils.Helper; import baritone.utils.pathing.PathingBlockType; -import net.minecraft.block.Block; -import net.minecraft.block.BlockDoublePlant; -import net.minecraft.block.BlockFlower; -import net.minecraft.block.BlockTallGrass; +import net.minecraft.block.*; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; @@ -50,10 +47,11 @@ public final class ChunkPacker implements Helper { for (int z = 0; z < 16; z++) { for (int x = 0; x < 16; x++) { int index = CachedChunk.getPositionIndex(x, y, z); - Block block = chunk.getBlockState(x, y, z).getBlock(); - boolean[] bits = getPathingBlockType(block).getBits(); + IBlockState state = chunk.getBlockState(x, y, z); + boolean[] bits = getPathingBlockType(state).getBits(); bitSet.set(index, bits[0]); bitSet.set(index + 1, bits[1]); + Block block = state.getBlock(); if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(block)) { String name = blockToString(block); specialBlocks.computeIfAbsent(name, b -> new ArrayList<>()).add(new BlockPos(x, y, z)); @@ -103,13 +101,14 @@ public final class ChunkPacker implements Helper { return Block.getBlockFromName(name); } - private static PathingBlockType getPathingBlockType(Block block) { + private static PathingBlockType getPathingBlockType(IBlockState state) { + Block block = state.getBlock(); if (block.equals(Blocks.WATER)) { // only water source blocks are plausibly usable, flowing water should be avoid return PathingBlockType.WATER; } - if (MovementHelper.avoidWalkingInto(block) || block.equals(Blocks.FLOWING_WATER)) { + if (MovementHelper.avoidWalkingInto(block) || block.equals(Blocks.FLOWING_WATER) || (block instanceof BlockSlab && state.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM)) { return PathingBlockType.AVOID; } // We used to do an AABB check here diff --git a/src/main/java/baritone/pathing/movement/Movement.java b/src/main/java/baritone/pathing/movement/Movement.java index 715bfd68..9d2f5869 100644 --- a/src/main/java/baritone/pathing/movement/Movement.java +++ b/src/main/java/baritone/pathing/movement/Movement.java @@ -21,13 +21,7 @@ import baritone.Baritone; import baritone.behavior.impl.LookBehavior; import baritone.behavior.impl.LookBehaviorUtils; import baritone.pathing.movement.MovementState.MovementStatus; -import baritone.pathing.movement.movements.MovementDownward; -import baritone.pathing.movement.movements.MovementPillar; -import baritone.pathing.movement.movements.MovementTraverse; import baritone.utils.*; -import net.minecraft.block.Block; -import net.minecraft.block.BlockLadder; -import net.minecraft.block.BlockVine; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.RayTraceResult; @@ -78,21 +72,11 @@ public abstract class Movement implements Helper, MovementHelper { if (cost == null) { if (context == null) context = new CalculationContext(); - cost = calculateCost0(context); + cost = calculateCost(context); } return cost; } - private double calculateCost0(CalculationContext context) { - if (!(this instanceof MovementPillar) && !(this instanceof MovementTraverse) && !(this instanceof MovementDownward)) { - Block fromDown = BlockStateInterface.get(src.down()).getBlock(); - if (fromDown instanceof BlockLadder || fromDown instanceof BlockVine) { - return COST_INF; - } - } - return calculateCost(context); - } - protected abstract double calculateCost(CalculationContext context); public double recalculateCost() { @@ -101,7 +85,7 @@ public abstract class Movement implements Helper, MovementHelper { } public double calculateCostWithoutCaching() { - return calculateCost0(new CalculationContext()); + return calculateCost(new CalculationContext()); } /** diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 909c21a7..3b5aa748 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -186,6 +186,9 @@ public interface MovementHelper extends ActionCosts, Helper { */ static boolean canWalkOn(BlockPos pos, IBlockState state) { Block block = state.getBlock(); + if (block == Blocks.AIR) { + return false; + } if (block instanceof BlockLadder || (Baritone.settings().allowVines.get() && block instanceof BlockVine)) { // TODO reconsider this return true; } @@ -198,8 +201,8 @@ public interface MovementHelper extends ActionCosts, Helper { if (Blocks.ENDER_CHEST.equals(block) || Blocks.CHEST.equals(block)) { return true; } - if (block instanceof BlockAir) { - return false; + if (block instanceof BlockSlab) { + return true; } if (BlockStateInterface.isWater(block)) { if (BlockStateInterface.isFlowing(state)) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index a50dfba8..bc94ca48 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -28,6 +28,7 @@ import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; +import net.minecraft.block.BlockSlab; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.init.Blocks; @@ -53,7 +54,31 @@ public class MovementAscend extends Movement { @Override protected double calculateCost(CalculationContext context) { + IBlockState srcDown = BlockStateInterface.get(src.down()); + if (srcDown.getBlock() == Blocks.LADDER || srcDown.getBlock() == Blocks.VINE) { + return COST_INF; + } + // we can jump from soul sand, but not from a bottom slab + // the only thing we can ascend onto from a bottom slab is another bottom slab + boolean jumpingFromBottomSlab = false; + if (srcDown.getBlock() instanceof BlockSlab) { + BlockSlab jumpingFrom = (BlockSlab) srcDown.getBlock(); + if (!jumpingFrom.isDouble()) { + jumpingFromBottomSlab = srcDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM; + } + } IBlockState toPlace = BlockStateInterface.get(positionToPlace); + boolean jumpingToBottomSlab = false; + if (toPlace.getBlock() instanceof BlockSlab) { + BlockSlab jumpingTo = (BlockSlab) toPlace.getBlock(); + if (!jumpingTo.isDouble() && toPlace.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + jumpingToBottomSlab = true; + } else if (jumpingFromBottomSlab) { + return COST_INF; + } + } else if (jumpingFromBottomSlab) { + return COST_INF; + } if (!MovementHelper.canWalkOn(positionToPlace, toPlace)) { if (!context.hasThrowaway()) { return COST_INF; @@ -96,9 +121,11 @@ public class MovementAscend extends Movement { // it's possible srcUp is AIR from the start, and srcUp2 is falling // and in that scenario, when we arrive and break srcUp2, that lets srcUp3 fall on us and suffocate us } - // TODO maybe change behavior if src.down() is soul sand? double walk = WALK_ONE_BLOCK_COST; - if (toPlace.getBlock().equals(Blocks.SOUL_SAND)) { + if (jumpingToBottomSlab && !jumpingFromBottomSlab) { + return walk + getTotalHardnessOfBlocksToBreak(context); // we don't hit space we just walk into the slab + } + if (!jumpingToBottomSlab && toPlace.getBlock().equals(Blocks.SOUL_SAND)) { walk *= WALK_ONE_OVER_SOUL_SAND_COST / WALK_ONE_BLOCK_COST; } // we hit space immediately on entering this action @@ -123,7 +150,8 @@ public class MovementAscend extends Movement { return state.setStatus(MovementStatus.SUCCESS); } - if (!MovementHelper.canWalkOn(positionToPlace)) { + IBlockState jumpingOnto = BlockStateInterface.get(positionToPlace); + if (!MovementHelper.canWalkOn(positionToPlace, jumpingOnto)) { for (int i = 0; i < 4; i++) { BlockPos anAgainst = positionToPlace.offset(HORIZONTALS[i]); if (anAgainst.equals(src)) { @@ -161,6 +189,9 @@ public class MovementAscend extends Movement { return state.setStatus(MovementStatus.UNREACHABLE); } MovementHelper.moveTowards(state, dest); + if (jumpingOnto.getBlock() instanceof BlockSlab && !((BlockSlab) jumpingOnto.getBlock()).isDouble() && jumpingOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM && !(BlockStateInterface.get(src.down()).getBlock() instanceof BlockSlab)) { + return state; // don't jump while walking from a non slab into a bottom slab + } if (headBonkClear()) { return state.setInput(InputOverrideHandler.Input.JUMP, true); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java index 7a07abb1..8ab66af1 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java @@ -25,8 +25,6 @@ import baritone.pathing.movement.MovementState.MovementStatus; import baritone.utils.BlockStateInterface; import baritone.utils.InputOverrideHandler; import net.minecraft.block.Block; -import net.minecraft.block.BlockLadder; -import net.minecraft.block.BlockVine; import net.minecraft.init.Blocks; import net.minecraft.util.math.BlockPos; @@ -44,18 +42,22 @@ public class MovementDescend extends Movement { @Override protected double calculateCost(CalculationContext context) { + Block fromDown = BlockStateInterface.get(src.down()).getBlock(); + if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) { + return COST_INF; + } if (!MovementHelper.canWalkOn(positionToPlace)) { return COST_INF; } Block tmp1 = BlockStateInterface.get(dest).getBlock(); - if (tmp1 instanceof BlockLadder || tmp1 instanceof BlockVine) { + if (tmp1 == Blocks.LADDER || tmp1 == Blocks.VINE) { return COST_INF; } // we walk half the block plus 0.3 to get to the edge, then we walk the other 0.2 while simultaneously falling (math.max because of how it's in parallel) double walk = WALK_OFF_BLOCK_COST; - if (BlockStateInterface.get(src.down()).getBlock().equals(Blocks.SOUL_SAND)) { + if (fromDown == Blocks.SOUL_SAND) { // use this ratio to apply the soul sand speed penalty to our 0.8 block distance - walk *= WALK_ONE_OVER_SOUL_SAND_COST / WALK_ONE_BLOCK_COST; + walk = WALK_ONE_OVER_SOUL_SAND_COST; } return walk + Math.max(FALL_N_BLOCKS_COST[1], CENTER_AFTER_FALL_COST) + getTotalHardnessOfBlocksToBreak(context); } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java index 1ce5537f..2bf8bdf1 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java @@ -75,6 +75,10 @@ public class MovementDiagonal extends Movement { @Override protected double calculateCost(CalculationContext context) { + Block fromDown = BlockStateInterface.get(src.down()).getBlock(); + if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) { + return COST_INF; + } if (!MovementHelper.canWalkThrough(positionsToBreak[4]) || !MovementHelper.canWalkThrough(positionsToBreak[5])) { return COST_INF; } @@ -88,7 +92,7 @@ public class MovementDiagonal extends Movement { if (destWalkOn.getBlock().equals(Blocks.SOUL_SAND)) { multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2; } - if (BlockStateInterface.get(src.down()).getBlock().equals(Blocks.SOUL_SAND)) { + if (fromDown == Blocks.SOUL_SAND) { multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2; } Block cuttingOver1 = BlockStateInterface.get(positionsToBreak[2].down()).getBlock(); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java index ece2c8f5..13555399 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementDownward.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementDownward.java @@ -23,9 +23,8 @@ import baritone.pathing.movement.MovementHelper; import baritone.pathing.movement.MovementState; import baritone.utils.BlockStateInterface; import net.minecraft.block.Block; -import net.minecraft.block.BlockLadder; -import net.minecraft.block.BlockVine; import net.minecraft.block.state.IBlockState; +import net.minecraft.init.Blocks; import net.minecraft.util.math.BlockPos; public class MovementDownward extends Movement { @@ -49,7 +48,7 @@ public class MovementDownward extends Movement { } IBlockState d = BlockStateInterface.get(dest); Block td = d.getBlock(); - boolean ladder = td instanceof BlockLadder || td instanceof BlockVine; + boolean ladder = td == Blocks.LADDER || td == Blocks.VINE; if (ladder) { return LADDER_DOWN_ONE_COST; } else { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index ee019c98..95509574 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -25,7 +25,9 @@ import baritone.pathing.movement.MovementState; import baritone.pathing.movement.MovementState.MovementStatus; import baritone.pathing.movement.MovementState.MovementTarget; import baritone.utils.*; +import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; +import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; @@ -43,6 +45,10 @@ public class MovementFall extends Movement { @Override protected double calculateCost(CalculationContext context) { + Block fromDown = BlockStateInterface.get(src.down()).getBlock(); + if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) { + return COST_INF; + } if (!MovementHelper.canWalkOn(dest.down())) { return COST_INF; } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java index d7ff3016..fecd79ec 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java @@ -47,11 +47,16 @@ public class MovementPillar extends Movement { protected double calculateCost(CalculationContext context) { Block fromDown = BlockStateInterface.get(src).getBlock(); boolean ladder = fromDown instanceof BlockLadder || fromDown instanceof BlockVine; - Block fromDownDown = BlockStateInterface.get(src.down()).getBlock(); + IBlockState fromDownDown = BlockStateInterface.get(src.down()); if (!ladder) { - if (fromDownDown instanceof BlockLadder || fromDownDown instanceof BlockVine) { + if (fromDownDown.getBlock() instanceof BlockLadder || fromDownDown.getBlock() instanceof BlockVine) { return COST_INF; } + if (fromDownDown.getBlock() instanceof BlockSlab) { + if (!((BlockSlab) fromDownDown.getBlock()).isDouble() && fromDownDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + return COST_INF; // can't pillar up from a bottom slab onto a non ladder + } + } } if (!context.hasThrowaway() && !ladder) { return COST_INF; @@ -87,7 +92,7 @@ public class MovementPillar extends Movement { //} } } - if (fromDown instanceof BlockLiquid || fromDownDown instanceof BlockLiquid) {//can't pillar on water or in water + if (fromDown instanceof BlockLiquid || fromDownDown.getBlock() instanceof BlockLiquid) {//can't pillar on water or in water return COST_INF; } if (ladder) { @@ -142,9 +147,12 @@ public class MovementPillar extends Movement { return state.setStatus(MovementState.MovementStatus.UNREACHABLE); } - if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) + if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) { return state.setStatus(MovementState.MovementStatus.SUCCESS); - + } + if (fromDown.getBlock() instanceof BlockSlab && !((BlockSlab) fromDown.getBlock()).isDouble() && fromDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + state.setInput(InputOverrideHandler.Input.JUMP, true); + } /* if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) { Baritone.moveTowardsBlock(from); diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java index a959455b..af0b7b27 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java @@ -85,7 +85,7 @@ public class MovementTraverse extends Movement { return WC + hardness1 + hardness2; } else {//this is a bridge, so we need to place a block Block srcDown = BlockStateInterface.get(src.down()).getBlock(); - if (srcDown instanceof BlockLadder || srcDown instanceof BlockVine) { + if (srcDown == Blocks.LADDER || srcDown == Blocks.VINE) { return COST_INF; } if (destOn.getBlock().equals(Blocks.AIR) || MovementHelper.isReplacable(positionToPlace, destOn)) { @@ -107,8 +107,8 @@ public class MovementTraverse extends Movement { return WC + context.placeBlockCost() + getTotalHardnessOfBlocksToBreak(context); } } - if (Blocks.SOUL_SAND.equals(srcDown)) { - return COST_INF; // can't sneak and backplace against soul sand =/ + if (srcDown == Blocks.SOUL_SAND || (srcDown instanceof BlockSlab && !((BlockSlab) srcDown).isDouble())) { + return COST_INF; // can't sneak and backplace against soul sand or half slabs =/ } WC = WC * SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST;//since we are placing, we are sneaking return WC + context.placeBlockCost() + getTotalHardnessOfBlocksToBreak(context); @@ -206,7 +206,8 @@ public class MovementTraverse extends Movement { return state.setStatus(MovementState.MovementStatus.UNREACHABLE); } state.setInput(InputOverrideHandler.Input.SNEAK, true); - if (BlockStateInterface.get(playerFeet().down()).getBlock().equals(Blocks.SOUL_SAND)) { // see issue #118 + Block standingOn = BlockStateInterface.get(playerFeet().down()).getBlock(); + if (standingOn.equals(Blocks.SOUL_SAND) || standingOn instanceof BlockSlab) { // see issue #118 double dist = Math.max(Math.abs(dest.getX() + 0.5 - player().posX), Math.abs(dest.getZ() + 0.5 - player().posZ)); if (dist < 0.85) { // 0.5 + 0.3 + epsilon MovementHelper.moveTowards(state, dest); diff --git a/src/main/java/baritone/utils/Helper.java b/src/main/java/baritone/utils/Helper.java index c973b1ca..63fc6df7 100755 --- a/src/main/java/baritone/utils/Helper.java +++ b/src/main/java/baritone/utils/Helper.java @@ -18,6 +18,7 @@ package baritone.utils; import baritone.Baritone; +import net.minecraft.block.BlockSlab; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityPlayerSP; import net.minecraft.client.multiplayer.WorldClient; @@ -47,10 +48,11 @@ public interface Helper { default BlockPos playerFeet() { // TODO find a better way to deal with soul sand!!!!! - return new BlockPos(player().posX, player().posY + 0.1251, player().posZ); - /*if (BlockStateInterface.get(feet).getBlock().equals(Blocks.SOUL_SAND) && player().posY > feet.getY() + 0.874999) { + BlockPos feet = new BlockPos(player().posX, player().posY + 0.1251, player().posZ); + if (BlockStateInterface.get(feet).getBlock() instanceof BlockSlab) { return feet.up(); - }*/ + } + return feet; } default Vec3d playerFeetAsVec() { From 16f88aa858c2f7d6a4f2c26f4b6a631be04d1875 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:18:30 -0700 Subject: [PATCH 45/80] setting --- src/main/java/baritone/Settings.java | 6 ++++++ src/main/java/baritone/pathing/movement/MovementHelper.java | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/src/main/java/baritone/Settings.java b/src/main/java/baritone/Settings.java index 78c2d4b3..2e6f0e39 100644 --- a/src/main/java/baritone/Settings.java +++ b/src/main/java/baritone/Settings.java @@ -77,6 +77,12 @@ public class Settings { */ public 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); + /** * This is the big A* setting. * As long as your cost heuristic is an *underestimate*, it's guaranteed to find you the best path. diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 3b5aa748..5561f365 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -202,6 +202,12 @@ public interface MovementHelper extends ActionCosts, Helper { return true; } if (block instanceof BlockSlab) { + if (!Baritone.settings().allowWalkOnBottomSlab.get()) { + if (((BlockSlab) block).isDouble()) { + return true; + } + return state.getValue(BlockSlab.HALF) != BlockSlab.EnumBlockHalf.BOTTOM; + } return true; } if (BlockStateInterface.isWater(block)) { From d328438cf2266097ed3a707af30428073b967b53 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:21:26 -0700 Subject: [PATCH 46/80] no falling onto half slab --- .../pathing/movement/movements/MovementFall.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 95509574..0cb9780a 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -27,6 +27,8 @@ import baritone.pathing.movement.MovementState.MovementTarget; import baritone.utils.*; import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; +import net.minecraft.block.BlockSlab; +import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; @@ -49,9 +51,15 @@ public class MovementFall extends Movement { if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) { return COST_INF; } - if (!MovementHelper.canWalkOn(dest.down())) { + IBlockState fallOnto = BlockStateInterface.get(dest.down()); + if (!MovementHelper.canWalkOn(dest.down(), fallOnto)) { return COST_INF; } + if (fallOnto.getBlock() instanceof BlockSlab) { + if (!((BlockSlab) fallOnto.getBlock()).isDouble() && fallOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + return COST_INF; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect + } + } double placeBucketCost = 0.0; if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > context.maxFallHeightNoWater()) { if (!context.hasWaterBucket()) { From 7473e34602a32324714d3d603007b5d78043e040 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:24:44 -0700 Subject: [PATCH 47/80] check for top or double slab --- .../pathing/movement/movements/MovementAscend.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index bc94ca48..46162806 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -189,8 +189,11 @@ public class MovementAscend extends Movement { return state.setStatus(MovementStatus.UNREACHABLE); } MovementHelper.moveTowards(state, dest); - if (jumpingOnto.getBlock() instanceof BlockSlab && !((BlockSlab) jumpingOnto.getBlock()).isDouble() && jumpingOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM && !(BlockStateInterface.get(src.down()).getBlock() instanceof BlockSlab)) { - return state; // don't jump while walking from a non slab into a bottom slab + if (jumpingOnto.getBlock() instanceof BlockSlab && !((BlockSlab) jumpingOnto.getBlock()).isDouble() && jumpingOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + IBlockState from = BlockStateInterface.get(src.down()); + if (!(from.getBlock() instanceof BlockSlab) || ((BlockSlab) from.getBlock()).isDouble() || from.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.TOP) { + return state; // don't jump while walking from a non double slab into a bottom slab + } } if (headBonkClear()) { From 5151c7770365d3cea12742c25fa471094dc3af2d Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:25:44 -0700 Subject: [PATCH 48/80] Move badge below header --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 63bc2c8b..d69f76e9 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ +# Baritone ![](https://travis-ci.com/cabaletta/baritone.svg?branch=master) -# Baritone A Minecraft bot. This project is an updated version of [Minebot](https://github.com/leijurv/MineBot/), the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. From 4b2f98ccfd16b29c3d431a91d7f68cf029f165e1 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 09:50:26 -0700 Subject: [PATCH 49/80] consolidate and simplify into MovementHelper.isBottomSlab --- src/main/java/baritone/chunk/ChunkPacker.java | 7 +++-- .../pathing/movement/MovementHelper.java | 10 +++++++ .../movement/movements/MovementAscend.java | 29 +++++-------------- .../movement/movements/MovementFall.java | 7 ++--- .../movement/movements/MovementPillar.java | 2 +- 5 files changed, 25 insertions(+), 30 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index e52f6a54..82a36709 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -20,7 +20,10 @@ package baritone.chunk; import baritone.pathing.movement.MovementHelper; import baritone.utils.Helper; import baritone.utils.pathing.PathingBlockType; -import net.minecraft.block.*; +import net.minecraft.block.Block; +import net.minecraft.block.BlockDoublePlant; +import net.minecraft.block.BlockFlower; +import net.minecraft.block.BlockTallGrass; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; @@ -108,7 +111,7 @@ public final class ChunkPacker implements Helper { return PathingBlockType.WATER; } - if (MovementHelper.avoidWalkingInto(block) || block.equals(Blocks.FLOWING_WATER) || (block instanceof BlockSlab && state.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM)) { + if (MovementHelper.avoidWalkingInto(block) || block.equals(Blocks.FLOWING_WATER) || MovementHelper.isBottomSlab(state)) { return PathingBlockType.AVOID; } // We used to do an AABB check here diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 5561f365..3e019745 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -270,6 +270,16 @@ public interface MovementHelper extends ActionCosts, Helper { return 0; // we won't actually mine it, so don't check fallings above } + static boolean isBottomSlab(IBlockState state) { + return state.getBlock() instanceof BlockSlab + && !((BlockSlab) state.getBlock()).isDouble() + && state.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM; + } + + static boolean isBottomSlab(BlockPos pos) { + return isBottomSlab(BlockStateInterface.get(pos)); + } + /** * The entity the player is currently looking at * diff --git a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java index 46162806..d666ff6a 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java @@ -28,7 +28,6 @@ import baritone.utils.InputOverrideHandler; import baritone.utils.Utils; import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; -import net.minecraft.block.BlockSlab; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.init.Blocks; @@ -59,25 +58,12 @@ public class MovementAscend extends Movement { return COST_INF; } // we can jump from soul sand, but not from a bottom slab - // the only thing we can ascend onto from a bottom slab is another bottom slab - boolean jumpingFromBottomSlab = false; - if (srcDown.getBlock() instanceof BlockSlab) { - BlockSlab jumpingFrom = (BlockSlab) srcDown.getBlock(); - if (!jumpingFrom.isDouble()) { - jumpingFromBottomSlab = srcDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM; - } - } + boolean jumpingFromBottomSlab = MovementHelper.isBottomSlab(srcDown); IBlockState toPlace = BlockStateInterface.get(positionToPlace); - boolean jumpingToBottomSlab = false; - if (toPlace.getBlock() instanceof BlockSlab) { - BlockSlab jumpingTo = (BlockSlab) toPlace.getBlock(); - if (!jumpingTo.isDouble() && toPlace.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { - jumpingToBottomSlab = true; - } else if (jumpingFromBottomSlab) { - return COST_INF; - } - } else if (jumpingFromBottomSlab) { - return COST_INF; + boolean jumpingToBottomSlab = MovementHelper.isBottomSlab(toPlace); + + if (jumpingFromBottomSlab && !jumpingToBottomSlab) { + return COST_INF;// the only thing we can ascend onto from a bottom slab is another bottom slab } if (!MovementHelper.canWalkOn(positionToPlace, toPlace)) { if (!context.hasThrowaway()) { @@ -189,9 +175,8 @@ public class MovementAscend extends Movement { return state.setStatus(MovementStatus.UNREACHABLE); } MovementHelper.moveTowards(state, dest); - if (jumpingOnto.getBlock() instanceof BlockSlab && !((BlockSlab) jumpingOnto.getBlock()).isDouble() && jumpingOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { - IBlockState from = BlockStateInterface.get(src.down()); - if (!(from.getBlock() instanceof BlockSlab) || ((BlockSlab) from.getBlock()).isDouble() || from.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.TOP) { + if (MovementHelper.isBottomSlab(jumpingOnto)) { + if (!MovementHelper.isBottomSlab(src.down())) { return state; // don't jump while walking from a non double slab into a bottom slab } } diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index 0cb9780a..e82640d2 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -27,7 +27,6 @@ import baritone.pathing.movement.MovementState.MovementTarget; import baritone.utils.*; import net.minecraft.block.Block; import net.minecraft.block.BlockFalling; -import net.minecraft.block.BlockSlab; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.init.Items; @@ -55,10 +54,8 @@ public class MovementFall extends Movement { if (!MovementHelper.canWalkOn(dest.down(), fallOnto)) { return COST_INF; } - if (fallOnto.getBlock() instanceof BlockSlab) { - if (!((BlockSlab) fallOnto.getBlock()).isDouble() && fallOnto.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { - return COST_INF; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect - } + if (MovementHelper.isBottomSlab(fallOnto)) { + return COST_INF; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect } double placeBucketCost = 0.0; if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > context.maxFallHeightNoWater()) { diff --git a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java index fecd79ec..481553fa 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java @@ -150,7 +150,7 @@ public class MovementPillar extends Movement { if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) { return state.setStatus(MovementState.MovementStatus.SUCCESS); } - if (fromDown.getBlock() instanceof BlockSlab && !((BlockSlab) fromDown.getBlock()).isDouble() && fromDown.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) { + if (MovementHelper.isBottomSlab(src.down())) { state.setInput(InputOverrideHandler.Input.JUMP, true); } /* From c2fc241d893fa2ef592324c5f900375e406cf73e Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 10:04:48 -0700 Subject: [PATCH 50/80] impact integration instructions --- IMPACT.md | 16 ++++++++++++++++ README.md | 2 ++ 2 files changed, 18 insertions(+) create mode 100644 IMPACT.md diff --git a/IMPACT.md b/IMPACT.md new file mode 100644 index 00000000..52934a64 --- /dev/null +++ b/IMPACT.md @@ -0,0 +1,16 @@ +# Integration between Baritone and Impact + +Baritone will be in Impact 4.4 with nice integrations with its hacks, but if you're impatient you can run Baritone on top of Impact 4.3 right now. + +First, clone and setup Baritone (instructions in main README.md). + +Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. + +Then, copy it into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. + +Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json`. + +- Add the Baritone tweak class to line 7 "minecraftArguments" like so: `"minecraftArguments": " ... --tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine",`. You need the Optifine tweaker even though there is no Optifine involved, for reasons I don't quite understand. +- Add the Baritone library. Insert `{ "name": "cabaletta:baritone:1.0" },` between Impact and ClientAPI, which should be between lines 15 and 16. + +Restart the Minecraft launcher, then load Impact 4.3 as normal, and it should now include Baritone. \ No newline at end of file diff --git a/README.md b/README.md index d69f76e9..63d241e4 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. Features +Baritone + Impact + # Setup - Open the project in IntelliJ as a Gradle project - Run the Gradle task `setupDecompWorkspace` From b3b9bb8aa523c8df64b1f0b9d88b5ea023735b0a Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 10:11:42 -0700 Subject: [PATCH 51/80] prebuilt jar --- IMPACT.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/IMPACT.md b/IMPACT.md index 52934a64..29b15aea 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -2,11 +2,11 @@ Baritone will be in Impact 4.4 with nice integrations with its hacks, but if you're impatient you can run Baritone on top of Impact 4.3 right now. -First, clone and setup Baritone (instructions in main README.md). +You can either build Baritone yourself, or download the jar from Septmeber 3 from here -Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. +To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. -Then, copy it into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. +Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json`. From dcfc7a1bd6c10a2e5710f94f2aed94abcbdaf5ff Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 10:13:11 -0700 Subject: [PATCH 52/80] added note --- IMPACT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IMPACT.md b/IMPACT.md index 29b15aea..7e1cc6a4 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -6,7 +6,7 @@ You can either build Baritone yourself, or download the jar from Septmeber 3 fro To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. -Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. +Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. Note the rename from `baritone-1.0.0.jar` to `baritone-1.0.jar`. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json`. From da67c4aca9075f50a431eeb51eb27b19edaad2dd Mon Sep 17 00:00:00 2001 From: Brady Date: Mon, 3 Sep 2018 12:42:00 -0500 Subject: [PATCH 53/80] Make some changes to the Impact installation --- IMPACT.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/IMPACT.md b/IMPACT.md index 7e1cc6a4..b57a0dfe 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -2,15 +2,15 @@ Baritone will be in Impact 4.4 with nice integrations with its hacks, but if you're impatient you can run Baritone on top of Impact 4.3 right now. -You can either build Baritone yourself, or download the jar from Septmeber 3 from here +You can either build Baritone yourself, or download the jar from Steptember 3 from here To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. -Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. Note the rename from `baritone-1.0.0.jar` to `baritone-1.0.jar`. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0/baritone-1.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0` in libraries first. +Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0.0/baritone-1.0.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0.0` in libraries first. Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json`. - Add the Baritone tweak class to line 7 "minecraftArguments" like so: `"minecraftArguments": " ... --tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine",`. You need the Optifine tweaker even though there is no Optifine involved, for reasons I don't quite understand. -- Add the Baritone library. Insert `{ "name": "cabaletta:baritone:1.0" },` between Impact and ClientAPI, which should be between lines 15 and 16. +- Add the Baritone library. Insert `{ "name": "cabaletta:baritone:1.0.0" },` between Impact and ClientAPI, which should be between lines 15 and 16. -Restart the Minecraft launcher, then load Impact 4.3 as normal, and it should now include Baritone. \ No newline at end of file +Restart the Minecraft launcher, then load Impact 4.3 as normal, and it should now include Baritone. From ba7dc46442039fc45d013629bf7b2fb1af95acff Mon Sep 17 00:00:00 2001 From: Brady Date: Mon, 3 Sep 2018 12:43:27 -0500 Subject: [PATCH 54/80] Another Impact install update --- IMPACT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IMPACT.md b/IMPACT.md index b57a0dfe..44a3fc0a 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -8,7 +8,7 @@ To build it yourself, clone and setup Baritone (instructions in main README.md). Copy the jar into place. It should be `build/libs/baritone-1.0.0.jar` in baritone. Copy it to your libraries in your Minecraft install. For example, on Mac I do `cp Documents/baritone/build/libs/baritone-1.0.0.jar Library/Application\ Support/minecraft/libraries/cabaletta/baritone/1.0.0/baritone-1.0.0.jar`. The first time you'll need to make the directory `cabaletta/baritone/1.0.0` in libraries first. -Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json`. +Then, we'll need to modify the Impact launch json. Open `minecraft/versions/1.12.2-Impact_4.3/1.12.2-Impact_4.3.json` or copy your existing installation and rename the version folder, json, and id in the json. - Add the Baritone tweak class to line 7 "minecraftArguments" like so: `"minecraftArguments": " ... --tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine",`. You need the Optifine tweaker even though there is no Optifine involved, for reasons I don't quite understand. - Add the Baritone library. Insert `{ "name": "cabaletta:baritone:1.0.0" },` between Impact and ClientAPI, which should be between lines 15 and 16. From 53d9d3da5e4360fec52a7e625a39f2333a3aaa4f Mon Sep 17 00:00:00 2001 From: Brady Date: Mon, 3 Sep 2018 12:58:21 -0500 Subject: [PATCH 55/80] lol --- IMPACT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IMPACT.md b/IMPACT.md index 44a3fc0a..859a2423 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -2,7 +2,7 @@ Baritone will be in Impact 4.4 with nice integrations with its hacks, but if you're impatient you can run Baritone on top of Impact 4.3 right now. -You can either build Baritone yourself, or download the jar from Steptember 3 from here +You can either build Baritone yourself, or download the jar from September 3 from here To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. From bfd41f94734ddf02f0b52be39ccafae96c4949d4 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 11:27:59 -0700 Subject: [PATCH 56/80] stairs --- src/main/java/baritone/pathing/movement/MovementHelper.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 3e019745..80026c6f 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -210,6 +210,9 @@ public interface MovementHelper extends ActionCosts, Helper { } return true; } + if (block instanceof BlockStairs) { + return true; + } if (BlockStateInterface.isWater(block)) { if (BlockStateInterface.isFlowing(state)) { return false; From 6eb293c97a37f098d67af874e0b428d06d660e8a Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 11:33:02 -0700 Subject: [PATCH 57/80] update documentation --- FEATURES.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 8147fc22..436aefc8 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -5,7 +5,8 @@ - **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. The list of acceptable throwaway blocks is also configurable, and is cobble, dirt, or netherrack by default. - **Falling** Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. - **Vines and ladders** Baritone understands how to climb and descend vines and ladders. There is experimental support for more advanced maneuvers, like strafing to a different ladder / vine column in midair (off by default, setting named `allowVines`). -- **Fence gates and doors** +- **Opening fence gates and doors** +- **Slabs and stairs** - **Falling blocks** Baritone understands the costs of breaking blocks with falling blocks on top, and includes all of their break costs. Additionally, since it avoids breaking any blocks touching a liquid, it won't break the bottom of a gravel stack below a lava lake (anymore). - **Avoiding dangerous blocks** Obviously, it knows not to walk through fire or on magma, not to corner over lava (that deals some damage), not to break any blocks touching a liquid (it might drown), etc. @@ -35,9 +36,7 @@ And finally `GoalComposite`. `GoalComposite` is a list of other goals, any one o # Future features Things it doesn't have yet - Trapdoors -- Slabs (double, top, and bottom) - Sprint jumping in a 1x2 corridor -- Stairs See issues for more. From 4690bcb5ac236f596131d28844fa2b4891ca24d9 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 11:43:06 -0700 Subject: [PATCH 58/80] add example --- FEATURES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FEATURES.md b/FEATURES.md index 8147fc22..d75cca87 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -2,7 +2,7 @@ - **Long distance pathing and splicing** Baritone calculates paths in segments, and precalculates the next segment when the current one is about to end, so that it's moving towards the goal at all times. - **Chunk caching** Baritone simplifies chunks to a compacted internal 2-bit representation (AIR, SOLID, WATER, AVOID) and stores them in RAM for better very-long-distance pathing. There is also an option to save these cached chunks to disk. Example - **Block breaking** Baritone considers breaking blocks as part of its path. It also takes into account your current tool set and hot bar. For example, if you have a Eff V diamond pick, it may choose to mine through a stone barrier, while if you only had a wood pick it might be faster to climb over it. -- **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. The list of acceptable throwaway blocks is also configurable, and is cobble, dirt, or netherrack by default. +- **Block placing** Baritone considers placing blocks as part of its path. This includes sneak-back-placing, pillaring, etc. It has a configurable penalty of placing a block (set to 1 second by default), to conserve its resources. The list of acceptable throwaway blocks is also configurable, and is cobble, dirt, or netherrack by default. Example - **Falling** Baritone will fall up to 3 blocks onto solid ground (configurable, if you have Feather Falling and/or don't mind taking a little damage). If you have a water bucket on your hotbar, it will fall up to 23 blocks and place the bucket beneath it. It will fall an unlimited distance into existing still water. - **Vines and ladders** Baritone understands how to climb and descend vines and ladders. There is experimental support for more advanced maneuvers, like strafing to a different ladder / vine column in midair (off by default, setting named `allowVines`). - **Fence gates and doors** From 574fd05376cbea1b7bf1c46c6fe722813c5ac7ef Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 12:03:49 -0700 Subject: [PATCH 59/80] fix bucket check, fixes #128 --- .../baritone/pathing/movement/movements/MovementFall.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/movements/MovementFall.java b/src/main/java/baritone/pathing/movement/movements/MovementFall.java index ee019c98..7061d2f2 100644 --- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java +++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java @@ -26,6 +26,7 @@ import baritone.pathing.movement.MovementState.MovementStatus; import baritone.pathing.movement.MovementState.MovementTarget; import baritone.utils.*; import net.minecraft.block.BlockFalling; +import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; @@ -96,7 +97,7 @@ public class MovementFall extends Movement { BlockPos playerFeet = playerFeet(); Rotation targetRotation = null; if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > Baritone.settings().maxFallHeightNoWater.get() && !playerFeet.equals(dest)) { - if (!player().inventory.hasItemStack(STACK_BUCKET_WATER) || world().provider.isNether()) { + if (!InventoryPlayer.isHotbar(player().inventory.getSlotFor(STACK_BUCKET_WATER)) || world().provider.isNether()) { state.setStatus(MovementStatus.UNREACHABLE); return state; } @@ -119,7 +120,7 @@ public class MovementFall extends Movement { } if (playerFeet.equals(dest) && (player().posY - playerFeet.getY() < 0.094 // lilypads || BlockStateInterface.isWater(dest))) { - if (BlockStateInterface.isWater(dest) && player().inventory.hasItemStack(STACK_BUCKET_EMPTY)) { + if (BlockStateInterface.isWater(dest) && InventoryPlayer.isHotbar(player().inventory.getSlotFor(STACK_BUCKET_EMPTY))) { player().inventory.currentItem = player().inventory.getSlotFor(STACK_BUCKET_EMPTY); if (player().motionY >= 0) { return state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true); From 53f2ab5901cf143a3b29e869838df51954dba865 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 12:06:58 -0700 Subject: [PATCH 60/80] fix badge link destination --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 63d241e4..b95cc957 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # Baritone -![](https://travis-ci.com/cabaletta/baritone.svg?branch=master) +[![Build Status](https://travis-ci.com/cabaletta/baritone.svg?branch=master)](https://travis-ci.com/cabaletta/baritone) A Minecraft bot. This project is an updated version of [Minebot](https://github.com/leijurv/MineBot/), the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. From dd1a20a04792f0fb1c5d5669fce3bd23142da151 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 16:14:14 -0700 Subject: [PATCH 61/80] final makes things faster --- src/main/java/baritone/utils/pathing/BetterBlockPos.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/utils/pathing/BetterBlockPos.java b/src/main/java/baritone/utils/pathing/BetterBlockPos.java index 6e4fc599..ec8891f4 100644 --- a/src/main/java/baritone/utils/pathing/BetterBlockPos.java +++ b/src/main/java/baritone/utils/pathing/BetterBlockPos.java @@ -26,7 +26,7 @@ import net.minecraft.util.math.Vec3i; * * @author leijurv */ -public class BetterBlockPos extends BlockPos { +public final class BetterBlockPos extends BlockPos { public final int x; public final int y; public final int z; From 07a9829865c47501de76fabac43ffabb7877c2c1 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 16:24:43 -0700 Subject: [PATCH 62/80] accurate debug --- src/main/java/baritone/pathing/calc/AStarPathFinder.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java index fa8b5076..73442998 100644 --- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java +++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java @@ -200,7 +200,7 @@ public class AStarPathFinder extends AbstractNodeCostSearch implements Helper { return Optional.of(new Path(startNode, bestSoFar[i], numNodes)); } } - displayChatMessageRaw("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + bestDist + " blocks"); + displayChatMessageRaw("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + Math.sqrt(bestDist) + " blocks"); displayChatMessageRaw("No path found =("); currentlyRunning = null; return Optional.empty(); From bfafca541fc9b2edadde20215883e428d130e837 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 17:01:04 -0700 Subject: [PATCH 63/80] add proguard --- proguard.pro | 360 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 proguard.pro diff --git a/proguard.pro b/proguard.pro new file mode 100644 index 00000000..7e09a64a --- /dev/null +++ b/proguard.pro @@ -0,0 +1,360 @@ +-injars baritone-1.0.0.jar +-outjars Obfuscated + +-libraryjars '/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/rt.jar' + +-libraryjars 'tempLibraries/1.12.2.jar' + +-libraryjars 'tempLibraries/authlib-1.5.25.jar' +-libraryjars 'tempLibraries/codecjorbis-20101023.jar' +-libraryjars 'tempLibraries/codecwav-20101023.jar' +-libraryjars 'tempLibraries/commons-codec-1.10.jar' +-libraryjars 'tempLibraries/commons-compress-1.8.1.jar' +-libraryjars 'tempLibraries/commons-io-2.5.jar' +-libraryjars 'tempLibraries/commons-lang3-3.5.jar' +-libraryjars 'tempLibraries/commons-logging-1.1.3.jar' +-libraryjars 'tempLibraries/fastutil-7.1.0.jar' +-libraryjars 'tempLibraries/gson-2.8.0.jar' +-libraryjars 'tempLibraries/guava-21.0.jar' +-libraryjars 'tempLibraries/httpclient-4.3.3.jar' +-libraryjars 'tempLibraries/httpcore-4.3.2.jar' +-libraryjars 'tempLibraries/icu4j-core-mojang-51.2.jar' +-libraryjars 'tempLibraries/java-objc-bridge-1.0.0-natives-osx.jar' +-libraryjars 'tempLibraries/java-objc-bridge-1.0.0.jar' +-libraryjars 'tempLibraries/jinput-2.0.5.jar' +-libraryjars 'tempLibraries/jinput-platform-2.0.5-natives-osx.jar' +-libraryjars 'tempLibraries/jna-4.4.0.jar' +-libraryjars 'tempLibraries/jopt-simple-5.0.3.jar' +-libraryjars 'tempLibraries/jsr305-3.0.1-sources.jar' +-libraryjars 'tempLibraries/jsr305-3.0.1.jar' +-libraryjars 'tempLibraries/jutils-1.0.0.jar' +-libraryjars 'tempLibraries/libraryjavasound-20101123.jar' +-libraryjars 'tempLibraries/librarylwjglopenal-20100824.jar' +-libraryjars 'tempLibraries/log4j-api-2.8.1.jar' +-libraryjars 'tempLibraries/log4j-core-2.8.1.jar' +-libraryjars 'tempLibraries/lwjgl-2.9.2-nightly-20140822.jar' +-libraryjars 'tempLibraries/lwjgl-platform-2.9.2-nightly-20140822-natives-osx.jar' +-libraryjars 'tempLibraries/lwjgl_util-2.9.2-nightly-20140822.jar' +-libraryjars 'tempLibraries/netty-all-4.1.9.Final.jar' +-libraryjars 'tempLibraries/oshi-core-1.1.jar' +-libraryjars 'tempLibraries/patchy-1.1.jar' +-libraryjars 'tempLibraries/platform-3.4.0.jar' +-libraryjars 'tempLibraries/realms-1.10.22.jar' +-libraryjars 'tempLibraries/soundsystem-20120107.jar' +-libraryjars 'tempLibraries/text2speech-1.10.3.jar' + +-libraryjars 'tempLibraries/mixin-0.7.8-SNAPSHOT.jar' +-libraryjars 'tempLibraries/launchwrapper-1.12.jar' + +-keepattributes Signature +-keepattributes *Annotation* + +-optimizationpasses 20 +-verbose + +-allowaccessmodification +-mergeinterfacesaggressively +-overloadaggressively +-flattenpackagehierarchy +-repackageclasses +-dontusemixedcaseclassnames + +-overloadaggressively + +-repackageclasses 'baritone' + +-keep class baritone.behavior.** { *; } +-keep class baritone.api.** { *; } +-keep class baritone.* { *; } +-keep class baritone.pathing.goals.** { *; } + +-keep class baritone.launch.** { *; } + +# Keep - Applications. Keep all application classes, along with their 'main' +# methods. +-keepclasseswithmembers public class * { + public static void main(java.lang.String[]); +} + +# Also keep - Enumerations. Keep the special static methods that are required in +# enumeration classes. +-keepclassmembers enum * { + public static **[] values(); + public static ** valueOf(java.lang.String); +} + +# Also keep - Database drivers. Keep all implementations of java.sql.Driver. +-keep class * extends java.sql.Driver + +# Also keep - Swing UI L&F. Keep all extensions of javax.swing.plaf.ComponentUI, +# along with the special 'createUI' method. +-keep class * extends javax.swing.plaf.ComponentUI { + public static javax.swing.plaf.ComponentUI createUI(javax.swing.JComponent); +} + +# Keep names - Native method names. Keep all native class/method names. +-keepclasseswithmembers,includedescriptorclasses,allowshrinking class * { + native ; +} + +# Remove - System method calls. Remove all invocations of System +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.System { + public static long currentTimeMillis(); + static java.lang.Class getCallerClass(); + public static int identityHashCode(java.lang.Object); + public static java.lang.SecurityManager getSecurityManager(); + public static java.util.Properties getProperties(); + public static java.lang.String getProperty(java.lang.String); + public static java.lang.String getenv(java.lang.String); + public static java.lang.String mapLibraryName(java.lang.String); + public static java.lang.String getProperty(java.lang.String,java.lang.String); +} + +# Remove - Math method calls. Remove all invocations of Math +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.Math { + public static double sin(double); + public static double cos(double); + public static double tan(double); + public static double asin(double); + public static double acos(double); + public static double atan(double); + public static double toRadians(double); + public static double toDegrees(double); + public static double exp(double); + public static double log(double); + public static double log10(double); + public static double sqrt(double); + public static double cbrt(double); + public static double IEEEremainder(double,double); + public static double ceil(double); + public static double floor(double); + public static double rint(double); + public static double atan2(double,double); + public static double pow(double,double); + public static int round(float); + public static long round(double); + public static double random(); + public static int abs(int); + public static long abs(long); + public static float abs(float); + public static double abs(double); + public static int max(int,int); + public static long max(long,long); + public static float max(float,float); + public static double max(double,double); + public static int min(int,int); + public static long min(long,long); + public static float min(float,float); + public static double min(double,double); + public static double ulp(double); + public static float ulp(float); + public static double signum(double); + public static float signum(float); + public static double sinh(double); + public static double cosh(double); + public static double tanh(double); + public static double hypot(double,double); + public static double expm1(double); + public static double log1p(double); +} + +# Remove - Number method calls. Remove all invocations of Number +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.* extends java.lang.Number { + public static java.lang.String toString(byte); + public static java.lang.Byte valueOf(byte); + public static byte parseByte(java.lang.String); + public static byte parseByte(java.lang.String,int); + public static java.lang.Byte valueOf(java.lang.String,int); + public static java.lang.Byte valueOf(java.lang.String); + public static java.lang.Byte decode(java.lang.String); + public int compareTo(java.lang.Byte); + public static java.lang.String toString(short); + public static short parseShort(java.lang.String); + public static short parseShort(java.lang.String,int); + public static java.lang.Short valueOf(java.lang.String,int); + public static java.lang.Short valueOf(java.lang.String); + public static java.lang.Short valueOf(short); + public static java.lang.Short decode(java.lang.String); + public static short reverseBytes(short); + public int compareTo(java.lang.Short); + public static java.lang.String toString(int,int); + public static java.lang.String toHexString(int); + public static java.lang.String toOctalString(int); + public static java.lang.String toBinaryString(int); + public static java.lang.String toString(int); + public static int parseInt(java.lang.String,int); + public static int parseInt(java.lang.String); + public static java.lang.Integer valueOf(java.lang.String,int); + public static java.lang.Integer valueOf(java.lang.String); + public static java.lang.Integer valueOf(int); + public static java.lang.Integer getInteger(java.lang.String); + public static java.lang.Integer getInteger(java.lang.String,int); + public static java.lang.Integer getInteger(java.lang.String,java.lang.Integer); + public static java.lang.Integer decode(java.lang.String); + public static int highestOneBit(int); + public static int lowestOneBit(int); + public static int numberOfLeadingZeros(int); + public static int numberOfTrailingZeros(int); + public static int bitCount(int); + public static int rotateLeft(int,int); + public static int rotateRight(int,int); + public static int reverse(int); + public static int signum(int); + public static int reverseBytes(int); + public int compareTo(java.lang.Integer); + public static java.lang.String toString(long,int); + public static java.lang.String toHexString(long); + public static java.lang.String toOctalString(long); + public static java.lang.String toBinaryString(long); + public static java.lang.String toString(long); + public static long parseLong(java.lang.String,int); + public static long parseLong(java.lang.String); + public static java.lang.Long valueOf(java.lang.String,int); + public static java.lang.Long valueOf(java.lang.String); + public static java.lang.Long valueOf(long); + public static java.lang.Long decode(java.lang.String); + public static java.lang.Long getLong(java.lang.String); + public static java.lang.Long getLong(java.lang.String,long); + public static java.lang.Long getLong(java.lang.String,java.lang.Long); + public static long highestOneBit(long); + public static long lowestOneBit(long); + public static int numberOfLeadingZeros(long); + public static int numberOfTrailingZeros(long); + public static int bitCount(long); + public static long rotateLeft(long,int); + public static long rotateRight(long,int); + public static long reverse(long); + public static int signum(long); + public static long reverseBytes(long); + public int compareTo(java.lang.Long); + public static java.lang.String toString(float); + public static java.lang.String toHexString(float); + public static java.lang.Float valueOf(java.lang.String); + public static java.lang.Float valueOf(float); + public static float parseFloat(java.lang.String); + public static boolean isNaN(float); + public static boolean isInfinite(float); + public static int floatToIntBits(float); + public static int floatToRawIntBits(float); + public static float intBitsToFloat(int); + public static int compare(float,float); + public boolean isNaN(); + public boolean isInfinite(); + public int compareTo(java.lang.Float); + public static java.lang.String toString(double); + public static java.lang.String toHexString(double); + public static java.lang.Double valueOf(java.lang.String); + public static java.lang.Double valueOf(double); + public static double parseDouble(java.lang.String); + public static boolean isNaN(double); + public static boolean isInfinite(double); + public static long doubleToLongBits(double); + public static long doubleToRawLongBits(double); + public static double longBitsToDouble(long); + public static int compare(double,double); + public boolean isNaN(); + public boolean isInfinite(); + public int compareTo(java.lang.Double); + public byte byteValue(); + public short shortValue(); + public int intValue(); + public long longValue(); + public float floatValue(); + public double doubleValue(); + public int compareTo(java.lang.Object); + public boolean equals(java.lang.Object); + public int hashCode(); + public java.lang.String toString(); +} + +# Remove - String method calls. Remove all invocations of String +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.String { + public static java.lang.String copyValueOf(char[]); + public static java.lang.String copyValueOf(char[],int,int); + public static java.lang.String valueOf(boolean); + public static java.lang.String valueOf(char); + public static java.lang.String valueOf(char[]); + public static java.lang.String valueOf(char[],int,int); + public static java.lang.String valueOf(double); + public static java.lang.String valueOf(float); + public static java.lang.String valueOf(int); + public static java.lang.String valueOf(java.lang.Object); + public static java.lang.String valueOf(long); + public boolean contentEquals(java.lang.StringBuffer); + public boolean endsWith(java.lang.String); + public boolean equalsIgnoreCase(java.lang.String); + public boolean equals(java.lang.Object); + public boolean matches(java.lang.String); + public boolean regionMatches(boolean,int,java.lang.String,int,int); + public boolean regionMatches(int,java.lang.String,int,int); + public boolean startsWith(java.lang.String); + public boolean startsWith(java.lang.String,int); + public byte[] getBytes(); + public byte[] getBytes(java.lang.String); + public char charAt(int); + public char[] toCharArray(); + public int compareToIgnoreCase(java.lang.String); + public int compareTo(java.lang.Object); + public int compareTo(java.lang.String); + public int hashCode(); + public int indexOf(int); + public int indexOf(int,int); + public int indexOf(java.lang.String); + public int indexOf(java.lang.String,int); + public int lastIndexOf(int); + public int lastIndexOf(int,int); + public int lastIndexOf(java.lang.String); + public int lastIndexOf(java.lang.String,int); + public int length(); + public java.lang.CharSequence subSequence(int,int); + public java.lang.String concat(java.lang.String); + public java.lang.String replaceAll(java.lang.String,java.lang.String); + public java.lang.String replace(char,char); + public java.lang.String replaceFirst(java.lang.String,java.lang.String); + public java.lang.String[] split(java.lang.String); + public java.lang.String[] split(java.lang.String,int); + public java.lang.String substring(int); + public java.lang.String substring(int,int); + public java.lang.String toLowerCase(); + public java.lang.String toLowerCase(java.util.Locale); + public java.lang.String toString(); + public java.lang.String toUpperCase(); + public java.lang.String toUpperCase(java.util.Locale); + public java.lang.String trim(); +} + +# Remove - StringBuffer method calls. Remove all invocations of StringBuffer +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.StringBuffer { + public java.lang.String toString(); + public char charAt(int); + public int capacity(); + public int codePointAt(int); + public int codePointBefore(int); + public int indexOf(java.lang.String,int); + public int lastIndexOf(java.lang.String); + public int lastIndexOf(java.lang.String,int); + public int length(); + public java.lang.String substring(int); + public java.lang.String substring(int,int); +} + +# Remove - StringBuilder method calls. Remove all invocations of StringBuilder +# methods without side effects whose return values are not used. +-assumenosideeffects public class java.lang.StringBuilder { + public java.lang.String toString(); + public char charAt(int); + public int capacity(); + public int codePointAt(int); + public int codePointBefore(int); + public int indexOf(java.lang.String,int); + public int lastIndexOf(java.lang.String); + public int lastIndexOf(java.lang.String,int); + public int length(); + public java.lang.String substring(int); + public java.lang.String substring(int,int); +} From a2f0a1839a870d9e1f4e48de40ab817899ce88c2 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Mon, 3 Sep 2018 20:42:28 -0700 Subject: [PATCH 64/80] fix goal get to block --- .../pathing/goals/GoalGetToBlock.java | 43 ++++++++++------ .../pathing/goals/GoalGetToBlockTest.java | 49 +++++++++++++++++++ 2 files changed, 78 insertions(+), 14 deletions(-) create mode 100644 src/test/java/baritone/pathing/goals/GoalGetToBlockTest.java diff --git a/src/main/java/baritone/pathing/goals/GoalGetToBlock.java b/src/main/java/baritone/pathing/goals/GoalGetToBlock.java index 9c847918..ed927a12 100644 --- a/src/main/java/baritone/pathing/goals/GoalGetToBlock.java +++ b/src/main/java/baritone/pathing/goals/GoalGetToBlock.java @@ -17,32 +17,47 @@ package baritone.pathing.goals; -import net.minecraft.util.EnumFacing; +import baritone.utils.pathing.BetterBlockPos; import net.minecraft.util.math.BlockPos; + /** * Don't get into the block, but get directly adjacent to it. Useful for chests. * * @author avecowa */ -public class GoalGetToBlock extends GoalComposite { +public class GoalGetToBlock implements Goal { - private final BlockPos pos; + private final int x; + private final int y; + private final int z; public GoalGetToBlock(BlockPos pos) { - super(adjacentBlocks(pos)); - this.pos = pos; - } - - private static BlockPos[] adjacentBlocks(BlockPos pos) { - BlockPos[] sides = new BlockPos[6]; - for (int i = 0; i < 6; i++) { - sides[i] = pos.offset(EnumFacing.values()[i]); - } - return sides; + this.x = pos.getX(); + this.y = pos.getY(); + this.z = pos.getZ(); } public BlockPos getGoalPos() { - return pos; + return new BetterBlockPos(x, y, z); + } + + @Override + public boolean isInGoal(BlockPos pos) { + int xDiff = pos.getX() - this.x; + int yDiff = pos.getY() - this.y; + int zDiff = pos.getZ() - this.z; + if (yDiff == -2 && xDiff == 0 && zDiff == 0) { + return true; + } + return Math.abs(xDiff) + Math.abs(yDiff) + Math.abs(zDiff) <= 1; + } + + @Override + public double heuristic(BlockPos pos) { + int xDiff = pos.getX() - this.x; + int yDiff = pos.getY() - this.y; + int zDiff = pos.getZ() - this.z; + return GoalBlock.calculate(xDiff, yDiff, zDiff); } } diff --git a/src/test/java/baritone/pathing/goals/GoalGetToBlockTest.java b/src/test/java/baritone/pathing/goals/GoalGetToBlockTest.java new file mode 100644 index 00000000..3c3905aa --- /dev/null +++ b/src/test/java/baritone/pathing/goals/GoalGetToBlockTest.java @@ -0,0 +1,49 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.pathing.goals; + +import net.minecraft.util.math.BlockPos; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.junit.Assert.assertTrue; + +public class GoalGetToBlockTest { + + @Test + public void isInGoal() { + List acceptableOffsets = new ArrayList<>(Arrays.asList("0,0,0", "0,0,1", "0,0,-1", "1,0,0", "-1,0,0", "0,1,0", "0,-1,0", "0,-2,0")); + for (int x = -10; x <= 10; x++) { + for (int y = -10; y <= 10; y++) { + for (int z = -10; z <= 10; z++) { + boolean inGoal = new GoalGetToBlock(new BlockPos(0, 0, 0)).isInGoal(new BlockPos(x, y, z)); + String repr = x + "," + y + "," + z; + System.out.println(repr + " " + inGoal); + if (inGoal) { + assertTrue(repr, acceptableOffsets.contains(repr)); + acceptableOffsets.remove(repr); + } + } + } + } + assertTrue(acceptableOffsets.toString(), acceptableOffsets.isEmpty()); + } +} \ No newline at end of file From 5cfb270a32f36910d5219c4a2718a29519aa5f60 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 08:48:55 -0700 Subject: [PATCH 65/80] update proguard --- proguard.pro | 51 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 30 insertions(+), 21 deletions(-) diff --git a/proguard.pro b/proguard.pro index 7e09a64a..7f0cfcdc 100644 --- a/proguard.pro +++ b/proguard.pro @@ -1,6 +1,36 @@ -injars baritone-1.0.0.jar -outjars Obfuscated + +-keepattributes Signature +-keepattributes *Annotation* + +-optimizationpasses 20 +-verbose + +-allowaccessmodification # anything not kept can be changed from public to private and inlined etc +-mergeinterfacesaggressively +-overloadaggressively +-dontusemixedcaseclassnames + +# instead of obfing to a, b, c, obf to baritone.a, baritone.b, baritone.c so as to not conflict with mcp +-flattenpackagehierarchy +-repackageclasses 'baritone' + +#-keep class baritone.behavior.** { *; } +#-keep class baritone.api.** { *; } +#-keep class baritone.* { *; } +#-keep class baritone.pathing.goals.** { *; } + +# setting names are reflected from field names, so keep field names +-keepclassmembers class baritone.Settings { + public ; +} + +# need to keep mixin names +-keep class baritone.launch.** { *; } + +# copy all necessary libraries into tempLibraries to build -libraryjars '/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/lib/rt.jar' -libraryjars 'tempLibraries/1.12.2.jar' @@ -46,29 +76,8 @@ -libraryjars 'tempLibraries/mixin-0.7.8-SNAPSHOT.jar' -libraryjars 'tempLibraries/launchwrapper-1.12.jar' --keepattributes Signature --keepattributes *Annotation* --optimizationpasses 20 --verbose --allowaccessmodification --mergeinterfacesaggressively --overloadaggressively --flattenpackagehierarchy --repackageclasses --dontusemixedcaseclassnames - --overloadaggressively - --repackageclasses 'baritone' - --keep class baritone.behavior.** { *; } --keep class baritone.api.** { *; } --keep class baritone.* { *; } --keep class baritone.pathing.goals.** { *; } - --keep class baritone.launch.** { *; } # Keep - Applications. Keep all application classes, along with their 'main' # methods. From 2452a69089af1ae7b04248163c04c3114b2b5bca Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 08:50:42 -0700 Subject: [PATCH 66/80] mine many block types at once --- .../java/baritone/behavior/impl/MineBehavior.java | 14 +++++++++----- .../baritone/utils/ExampleBaritoneControl.java | 4 ++-- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index 32f92877..f34aa480 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -29,6 +29,7 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.world.chunk.EmptyChunk; import java.util.ArrayList; +import java.util.Arrays; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; @@ -44,7 +45,7 @@ public class MineBehavior extends Behavior { private MineBehavior() { } - String mining; + List mining; @Override public void onTick(TickEvent event) { @@ -54,14 +55,17 @@ public class MineBehavior extends Behavior { if (mining == null) { return; } - List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(mining, 1, 1)); + List locs = new ArrayList<>(); + for (String m : mining) { + locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(m, 1, 1)); + } BlockPos playerFeet = playerFeet(); locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); // remove any that are within loaded chunks that aren't actually what we want locs.removeAll(locs.stream() .filter(pos -> !(world().getChunk(pos) instanceof EmptyChunk)) - .filter(pos -> !ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).equalsIgnoreCase(mining)) + .filter(pos -> !mining.contains(ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).toLowerCase())) .collect(Collectors.toList())); if (locs.size() > 30) { locs = locs.subList(0, 30); @@ -75,8 +79,8 @@ public class MineBehavior extends Behavior { PathingBehavior.INSTANCE.path(); } - public void mine(String mining) { - this.mining = mining; + public void mine(String... mining) { + this.mining = new ArrayList<>(Arrays.asList(mining)); } public void cancel() { diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 75a36994..5bc75d3f 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -189,8 +189,8 @@ public class ExampleBaritoneControl extends Behavior { } if (msg.toLowerCase().startsWith("mine")) { String blockType = msg.toLowerCase().substring(4).trim(); - MineBehavior.INSTANCE.mine(blockType); - displayChatMessageRaw("Started mining blocks of type " + blockType); + MineBehavior.INSTANCE.mine(blockType.split(" ")); + displayChatMessageRaw("Started mining blocks of type " + Arrays.toString(blockType.split(" "))); event.cancel(); return; } From f51bcc8b8919709139670f541d96918676eb7a32 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 08:51:58 -0700 Subject: [PATCH 67/80] forgot null check --- src/main/java/baritone/behavior/impl/MineBehavior.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index f34aa480..1e1fdb08 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -80,7 +80,7 @@ public class MineBehavior extends Behavior { } public void mine(String... mining) { - this.mining = new ArrayList<>(Arrays.asList(mining)); + this.mining = mining == null ? null : new ArrayList<>(Arrays.asList(mining)); } public void cancel() { From 438392840b75c5296e8c580e245d33563cbf3ab5 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 08:56:34 -0700 Subject: [PATCH 68/80] possible fix to concurrentmodificationexception on path start --- src/main/java/baritone/Baritone.java | 2 ++ src/main/java/baritone/utils/ToolSet.java | 7 +------ 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/main/java/baritone/Baritone.java b/src/main/java/baritone/Baritone.java index 5baacec8..0b571264 100755 --- a/src/main/java/baritone/Baritone.java +++ b/src/main/java/baritone/Baritone.java @@ -21,6 +21,7 @@ import baritone.api.event.GameEventHandler; import baritone.behavior.Behavior; import baritone.behavior.impl.*; import baritone.utils.InputOverrideHandler; +import baritone.utils.ToolSet; import net.minecraft.client.Minecraft; import java.io.File; @@ -81,6 +82,7 @@ public enum Baritone { registerBehavior(LocationTrackingBehavior.INSTANCE); registerBehavior(FollowBehavior.INSTANCE); registerBehavior(MineBehavior.INSTANCE); + this.gameEventHandler.registerEventListener(ToolSet.INTERNAL_EVENT_LISTENER); } this.dir = new File(Minecraft.getMinecraft().gameDir, "baritone"); if (!Files.exists(dir.toPath())) { diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java index 415d8ebd..ce24b708 100644 --- a/src/main/java/baritone/utils/ToolSet.java +++ b/src/main/java/baritone/utils/ToolSet.java @@ -17,7 +17,6 @@ package baritone.utils; -import baritone.Baritone; import baritone.api.event.events.ItemSlotEvent; import baritone.api.event.listener.AbstractGameEventListener; import net.minecraft.block.Block; @@ -46,11 +45,7 @@ public class ToolSet implements Helper { /** * Instance of the internal event listener used to hook into Baritone's event bus */ - private static final InternalEventListener INTERNAL_EVENT_LISTENER = new InternalEventListener(); - - static { - Baritone.INSTANCE.getGameEventHandler().registerEventListener(INTERNAL_EVENT_LISTENER); - } + public static final InternalEventListener INTERNAL_EVENT_LISTENER = new InternalEventListener(); /** * A list of tools on the hotbar that should be considered. From 424113f052d8612c79db6c03a0b8db65688e5609 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 09:55:56 -0700 Subject: [PATCH 69/80] don't sprint if hunger is too low --- src/main/java/baritone/pathing/path/PathExecutor.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java index 88ca6e30..818f9bbb 100644 --- a/src/main/java/baritone/pathing/path/PathExecutor.java +++ b/src/main/java/baritone/pathing/path/PathExecutor.java @@ -19,10 +19,7 @@ package baritone.pathing.path; import baritone.Baritone; import baritone.api.event.events.TickEvent; -import baritone.pathing.movement.ActionCosts; -import baritone.pathing.movement.Movement; -import baritone.pathing.movement.MovementHelper; -import baritone.pathing.movement.MovementState; +import baritone.pathing.movement.*; import baritone.pathing.movement.movements.MovementDescend; import baritone.pathing.movement.movements.MovementDiagonal; import baritone.pathing.movement.movements.MovementFall; @@ -274,7 +271,7 @@ public class PathExecutor implements Helper { } private void sprintIfRequested() { - if (!Baritone.settings().allowSprint.get()) { + if (!new CalculationContext().canSprint()) { player().setSprinting(false); return; } From ebd4930fe476dcd740e24536a4b8759c680fe3bf Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 09:57:19 -0700 Subject: [PATCH 70/80] fix horrendous typo --- IMPACT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IMPACT.md b/IMPACT.md index 859a2423..95faedc6 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -1,6 +1,6 @@ # Integration between Baritone and Impact -Baritone will be in Impact 4.4 with nice integrations with its hacks, but if you're impatient you can run Baritone on top of Impact 4.3 right now. +Baritone will be in Impact 4.4 with nice integrations with its utility modules, but if you're impatient you can run Baritone on top of Impact 4.3 right now. You can either build Baritone yourself, or download the jar from September 3 from here From 3fd1063e3c43e5fdeaf2028cb5e9af1478dd0f7b Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 10:06:48 -0700 Subject: [PATCH 71/80] cache on block not blockstate --- src/main/java/baritone/utils/ToolSet.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/utils/ToolSet.java b/src/main/java/baritone/utils/ToolSet.java index 415d8ebd..a5684280 100644 --- a/src/main/java/baritone/utils/ToolSet.java +++ b/src/main/java/baritone/utils/ToolSet.java @@ -72,10 +72,10 @@ public class ToolSet implements Helper { private Map slotCache = new HashMap<>(); /** - * A cache mapping a {@link IBlockState} to how long it will take to break + * A cache mapping a {@link Block} to how long it will take to break * with this toolset, given the optimum tool is used. */ - private Map breakStrengthCache = new HashMap<>(); + private Map breakStrengthCache = new HashMap<>(); /** * Create a toolset from the current player's inventory (but don't calculate any hardness values just yet) @@ -146,7 +146,7 @@ public class ToolSet implements Helper { * @return how long it would take in ticks */ public double getStrVsBlock(IBlockState state, BlockPos pos) { - return this.breakStrengthCache.computeIfAbsent(state, s -> calculateStrVsBlock(s, pos)); + return this.breakStrengthCache.computeIfAbsent(state.getBlock(), b -> calculateStrVsBlock(state, pos)); } /** From 288e57d275a90b78ba32f5de61450a15a99cd988 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 13:20:49 -0700 Subject: [PATCH 72/80] fix warning --- src/main/java/baritone/behavior/impl/MineBehavior.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index 1e1fdb08..185cacd2 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -80,11 +80,11 @@ public class MineBehavior extends Behavior { } public void mine(String... mining) { - this.mining = mining == null ? null : new ArrayList<>(Arrays.asList(mining)); + this.mining = mining == null || mining.length == 0 ? null : new ArrayList<>(Arrays.asList(mining)); } public void cancel() { PathingBehavior.INSTANCE.cancel(); - mine(null); + mine(); } } From 9f156e8e2797cd4b4ad94745f0cf1617f868a99c Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 13:23:26 -0700 Subject: [PATCH 73/80] updated dropbox file name and link --- IMPACT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IMPACT.md b/IMPACT.md index 95faedc6..7fa22435 100644 --- a/IMPACT.md +++ b/IMPACT.md @@ -2,7 +2,7 @@ Baritone will be in Impact 4.4 with nice integrations with its utility modules, but if you're impatient you can run Baritone on top of Impact 4.3 right now. -You can either build Baritone yourself, or download the jar from September 3 from here +You can either build Baritone yourself, or download the jar from September 4 from here To build it yourself, clone and setup Baritone (instructions in main README.md). Then, build the jar. From the command line, it's `./gradlew build` (or `gradlew build` on Windows). In IntelliJ, you can just start the `build` task in the Gradle menu. From 0bd3f9f68010861c38cae7af1f2bb650210c707f Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 13:57:56 -0700 Subject: [PATCH 74/80] fix water fall logic --- .../java/baritone/pathing/movement/MovementHelper.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java index 80026c6f..82b20c41 100644 --- a/src/main/java/baritone/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/pathing/movement/MovementHelper.java @@ -214,13 +214,14 @@ public interface MovementHelper extends ActionCosts, Helper { return true; } if (BlockStateInterface.isWater(block)) { - if (BlockStateInterface.isFlowing(state)) { - return false; - } Block up = BlockStateInterface.get(pos.up()).getBlock(); if (up instanceof BlockLilyPad) { return true; } + if (BlockStateInterface.isFlowing(state)) { + // the only scenario in which we can walk on flowing water is if it's under still water with jesus off + return BlockStateInterface.isWater(up) && !Baritone.settings().assumeWalkOnWater.get(); + } // if assumeWalkOnWater is on, we can only walk on water if there isn't water above it // if assumeWalkOnWater is off, we can only walk on water if there is water above it return BlockStateInterface.isWater(up) ^ Baritone.settings().assumeWalkOnWater.get(); From 7cc23bc89bb12e3e718453397cacaa92cb1b7cda Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 15:03:59 -0700 Subject: [PATCH 75/80] scan for uninteresting blocks in loaded chunks, fixes #99 --- .../baritone/behavior/impl/MineBehavior.java | 43 ++++++--- .../java/baritone/chunk/WorldScanner.java | 92 +++++++++++++++++++ .../utils/ExampleBaritoneControl.java | 32 +++---- 3 files changed, 135 insertions(+), 32 deletions(-) create mode 100644 src/main/java/baritone/chunk/WorldScanner.java diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index 185cacd2..bbd1c594 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -19,8 +19,10 @@ package baritone.behavior.impl; import baritone.api.event.events.TickEvent; import baritone.behavior.Behavior; +import baritone.chunk.CachedChunk; import baritone.chunk.ChunkPacker; import baritone.chunk.WorldProvider; +import baritone.chunk.WorldScanner; import baritone.pathing.goals.Goal; import baritone.pathing.goals.GoalComposite; import baritone.pathing.goals.GoalTwoBlocks; @@ -55,21 +57,7 @@ public class MineBehavior extends Behavior { if (mining == null) { return; } - List locs = new ArrayList<>(); - for (String m : mining) { - locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(m, 1, 1)); - } - BlockPos playerFeet = playerFeet(); - locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); - - // remove any that are within loaded chunks that aren't actually what we want - locs.removeAll(locs.stream() - .filter(pos -> !(world().getChunk(pos) instanceof EmptyChunk)) - .filter(pos -> !mining.contains(ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).toLowerCase())) - .collect(Collectors.toList())); - if (locs.size() > 30) { - locs = locs.subList(0, 30); - } + List locs = scanFor(mining, 64); if (locs.isEmpty()) { displayChatMessageRaw("No locations for " + mining + " known, cancelling"); cancel(); @@ -79,6 +67,31 @@ public class MineBehavior extends Behavior { PathingBehavior.INSTANCE.path(); } + public static List scanFor(List mining, int max) { + List locs = new ArrayList<>(); + List uninteresting = new ArrayList<>(); + for (String m : mining) { + if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(ChunkPacker.stringToBlock(m))) { + locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(m, 1, 1)); + } else { + uninteresting.add(m); + } + } + locs.addAll(WorldScanner.INSTANCE.scanLoadedChunks(uninteresting, max)); + BlockPos playerFeet = MineBehavior.INSTANCE.playerFeet(); + locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); + + // remove any that are within loaded chunks that aren't actually what we want + locs.removeAll(locs.stream() + .filter(pos -> !(MineBehavior.INSTANCE.world().getChunk(pos) instanceof EmptyChunk)) + .filter(pos -> !mining.contains(ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).toLowerCase())) + .collect(Collectors.toList())); + if (locs.size() > max) { + locs = locs.subList(0, max); + } + return locs; + } + public void mine(String... mining) { this.mining = mining == null || mining.length == 0 ? null : new ArrayList<>(Arrays.asList(mining)); } diff --git a/src/main/java/baritone/chunk/WorldScanner.java b/src/main/java/baritone/chunk/WorldScanner.java new file mode 100644 index 00000000..62e20944 --- /dev/null +++ b/src/main/java/baritone/chunk/WorldScanner.java @@ -0,0 +1,92 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.chunk; + +import baritone.utils.Helper; +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.multiplayer.ChunkProviderClient; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.chunk.BlockStateContainer; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.storage.ExtendedBlockStorage; + +import java.util.LinkedList; +import java.util.List; +import java.util.stream.Collectors; + +public enum WorldScanner implements Helper { + INSTANCE; + + public List scanLoadedChunks(List blockTypes, int max) { + List asBlocks = blockTypes.stream().map(ChunkPacker::stringToBlock).collect(Collectors.toList()); + if (asBlocks.contains(null)) { + throw new IllegalStateException("Invalid block name should have been caught earlier: " + blockTypes.toString()); + } + LinkedList res = new LinkedList<>(); + ChunkProviderClient chunkProvider = world().getChunkProvider(); + + int playerChunkX = playerFeet().getX() >> 4; + int playerChunkZ = playerFeet().getZ() >> 4; + + int searchRadius = 0; + while (true) { + boolean allUnloaded = true; + for (int xoff = -searchRadius; xoff <= searchRadius; xoff++) { + for (int zoff = -searchRadius; zoff <= searchRadius; zoff++) { + int distance = xoff * xoff + zoff * zoff; + if (distance != searchRadius) { + continue; + } + int chunkX = xoff + playerChunkX; + int chunkZ = zoff + playerChunkZ; + Chunk chunk = chunkProvider.getLoadedChunk(chunkX, chunkZ); + if (chunk == null) { + continue; + } + allUnloaded = false; + ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray(); + for (int y0 = 0; y0 < 16; y0++) { + ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0]; + if (extendedblockstorage == null) { + continue; + } + BlockStateContainer bsc = extendedblockstorage.getData(); + for (int x = 0; x < 16; x++) { + for (int y = 0; y < 16; y++) { + for (int z = 0; z < 16; z++) { + IBlockState state = bsc.get(x, y, z); + if (asBlocks.contains(state.getBlock())) { + res.add(new BlockPos(chunkX * 16 + x, y0 * 16 + y, chunkZ * 16 + z)); + } + } + } + } + } + } + } + if (allUnloaded) { + return res; + } + if (res.size() >= max) { + return res; + } + searchRadius++; + } + } +} diff --git a/src/main/java/baritone/utils/ExampleBaritoneControl.java b/src/main/java/baritone/utils/ExampleBaritoneControl.java index 5bc75d3f..16dabf4f 100644 --- a/src/main/java/baritone/utils/ExampleBaritoneControl.java +++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java @@ -38,10 +38,8 @@ import baritone.utils.pathing.BetterBlockPos; import net.minecraft.block.Block; import net.minecraft.entity.Entity; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.chunk.EmptyChunk; import java.util.*; -import java.util.stream.Collectors; public class ExampleBaritoneControl extends Behavior { public static ExampleBaritoneControl INSTANCE = new ExampleBaritoneControl(); @@ -188,9 +186,16 @@ public class ExampleBaritoneControl extends Behavior { return; } if (msg.toLowerCase().startsWith("mine")) { - String blockType = msg.toLowerCase().substring(4).trim(); - MineBehavior.INSTANCE.mine(blockType.split(" ")); - displayChatMessageRaw("Started mining blocks of type " + Arrays.toString(blockType.split(" "))); + String[] blockTypes = msg.toLowerCase().substring(4).trim().split(" "); + for (String s : blockTypes) { + if (ChunkPacker.stringToBlock(s) == null) { + displayChatMessageRaw(s + " isn't a valid block name"); + event.cancel(); + return; + } + } + MineBehavior.INSTANCE.mine(blockTypes); + displayChatMessageRaw("Started mining blocks of type " + Arrays.toString(blockTypes)); event.cancel(); return; } @@ -235,21 +240,14 @@ public class ExampleBaritoneControl extends Behavior { String mining = waypointType; //displayChatMessageRaw("Not a valid tag. Tags are: " + Arrays.asList(Waypoint.Tag.values()).toString().toLowerCase()); event.cancel(); - List locs = new ArrayList<>(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(mining, 1, 1)); - if (locs.isEmpty()) { + if (ChunkPacker.stringToBlock(mining) == null) { displayChatMessageRaw("No locations for " + mining + " known, cancelling"); return; } - BlockPos playerFeet = playerFeet(); - locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); - - // remove any that are within loaded chunks that aren't actually what we want - locs.removeAll(locs.stream() - .filter(pos -> !(world().getChunk(pos) instanceof EmptyChunk)) - .filter(pos -> !ChunkPacker.blockToString(BlockStateInterface.get(pos).getBlock()).equalsIgnoreCase(mining)) - .collect(Collectors.toList())); - if (locs.size() > 30) { - locs = locs.subList(0, 30); + List locs = MineBehavior.scanFor(Arrays.asList(mining), 64); + if (locs.isEmpty()) { + displayChatMessageRaw("No locations for " + mining + " known, cancelling"); + return; } PathingBehavior.INSTANCE.setGoal(new GoalComposite(locs.stream().map(GoalGetToBlock::new).toArray(Goal[]::new))); PathingBehavior.INSTANCE.path(); From 4f07d655d6b88247c811a14961b8366c63e3f704 Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 15:08:21 -0700 Subject: [PATCH 76/80] don't scan empty --- src/main/java/baritone/behavior/impl/MineBehavior.java | 8 +++++++- src/main/java/baritone/chunk/WorldScanner.java | 3 +++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index bbd1c594..d4b09b7b 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -70,6 +70,7 @@ public class MineBehavior extends Behavior { public static List scanFor(List mining, int max) { List locs = new ArrayList<>(); List uninteresting = new ArrayList<>(); + //long b = System.currentTimeMillis(); for (String m : mining) { if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(ChunkPacker.stringToBlock(m))) { locs.addAll(WorldProvider.INSTANCE.getCurrentWorld().cache.getLocationsOf(m, 1, 1)); @@ -77,7 +78,12 @@ public class MineBehavior extends Behavior { uninteresting.add(m); } } - locs.addAll(WorldScanner.INSTANCE.scanLoadedChunks(uninteresting, max)); + //System.out.println("Scan of cached chunks took " + (System.currentTimeMillis() - b) + "ms"); + if (!uninteresting.isEmpty()) { + //long before = System.currentTimeMillis(); + locs.addAll(WorldScanner.INSTANCE.scanLoadedChunks(uninteresting, max)); + //System.out.println("Scan of loaded chunks took " + (System.currentTimeMillis() - before) + "ms"); + } BlockPos playerFeet = MineBehavior.INSTANCE.playerFeet(); locs.sort(Comparator.comparingDouble(playerFeet::distanceSq)); diff --git a/src/main/java/baritone/chunk/WorldScanner.java b/src/main/java/baritone/chunk/WorldScanner.java index 62e20944..fe3c0ea5 100644 --- a/src/main/java/baritone/chunk/WorldScanner.java +++ b/src/main/java/baritone/chunk/WorldScanner.java @@ -39,6 +39,9 @@ public enum WorldScanner implements Helper { throw new IllegalStateException("Invalid block name should have been caught earlier: " + blockTypes.toString()); } LinkedList res = new LinkedList<>(); + if (asBlocks.isEmpty()) { + return res; + } ChunkProviderClient chunkProvider = world().getChunkProvider(); int playerChunkX = playerFeet().getX() >> 4; From 8c9bb85d4b5982f1962dba52a4388d2a8882b164 Mon Sep 17 00:00:00 2001 From: Brady Date: Tue, 4 Sep 2018 17:18:30 -0500 Subject: [PATCH 77/80] Fully separate dependency on launch package from other packages --- .../java/baritone/chunk/WorldProvider.java | 4 +- .../launch/mixins/MixinAnvilChunkLoader.java | 41 +++++++++++++++++++ .../mixins/MixinChunkProviderServer.java | 40 ++++++++++++++++++ .../accessor/IAnvilChunkLoader.java | 9 +--- .../accessor/IChunkProviderServer.java | 8 +--- src/main/resources/mixins.baritone.json | 7 ++-- 6 files changed, 90 insertions(+), 19 deletions(-) create mode 100644 src/main/java/baritone/launch/mixins/MixinAnvilChunkLoader.java create mode 100644 src/main/java/baritone/launch/mixins/MixinChunkProviderServer.java rename src/main/java/baritone/{launch/mixins => utils}/accessor/IAnvilChunkLoader.java (74%) rename src/main/java/baritone/{launch/mixins => utils}/accessor/IChunkProviderServer.java (76%) diff --git a/src/main/java/baritone/chunk/WorldProvider.java b/src/main/java/baritone/chunk/WorldProvider.java index 709ddff8..275b6ac1 100644 --- a/src/main/java/baritone/chunk/WorldProvider.java +++ b/src/main/java/baritone/chunk/WorldProvider.java @@ -18,8 +18,8 @@ package baritone.chunk; import baritone.Baritone; -import baritone.launch.mixins.accessor.IAnvilChunkLoader; -import baritone.launch.mixins.accessor.IChunkProviderServer; +import baritone.utils.accessor.IAnvilChunkLoader; +import baritone.utils.accessor.IChunkProviderServer; import baritone.utils.Helper; import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.server.integrated.IntegratedServer; diff --git a/src/main/java/baritone/launch/mixins/MixinAnvilChunkLoader.java b/src/main/java/baritone/launch/mixins/MixinAnvilChunkLoader.java new file mode 100644 index 00000000..96f38b87 --- /dev/null +++ b/src/main/java/baritone/launch/mixins/MixinAnvilChunkLoader.java @@ -0,0 +1,41 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.launch.mixins; + +import baritone.utils.accessor.IAnvilChunkLoader; +import net.minecraft.world.chunk.storage.AnvilChunkLoader; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +import java.io.File; + +/** + * @author Brady + * @since 9/4/2018 + */ +@Mixin(AnvilChunkLoader.class) +public class MixinAnvilChunkLoader implements IAnvilChunkLoader { + + @Shadow @Final private File chunkSaveLocation; + + @Override + public File getChunkSaveLocation() { + return this.chunkSaveLocation; + } +} diff --git a/src/main/java/baritone/launch/mixins/MixinChunkProviderServer.java b/src/main/java/baritone/launch/mixins/MixinChunkProviderServer.java new file mode 100644 index 00000000..9a454d01 --- /dev/null +++ b/src/main/java/baritone/launch/mixins/MixinChunkProviderServer.java @@ -0,0 +1,40 @@ +/* + * This file is part of Baritone. + * + * Baritone is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Baritone is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Baritone. If not, see . + */ + +package baritone.launch.mixins; + +import baritone.utils.accessor.IChunkProviderServer; +import net.minecraft.world.chunk.storage.IChunkLoader; +import net.minecraft.world.gen.ChunkProviderServer; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +/** + * @author Brady + * @since 9/4/2018 + */ +@Mixin(ChunkProviderServer.class) +public class MixinChunkProviderServer implements IChunkProviderServer { + + @Shadow @Final private IChunkLoader chunkLoader; + + @Override + public IChunkLoader getChunkLoader() { + return this.chunkLoader; + } +} diff --git a/src/main/java/baritone/launch/mixins/accessor/IAnvilChunkLoader.java b/src/main/java/baritone/utils/accessor/IAnvilChunkLoader.java similarity index 74% rename from src/main/java/baritone/launch/mixins/accessor/IAnvilChunkLoader.java rename to src/main/java/baritone/utils/accessor/IAnvilChunkLoader.java index 3972ff32..900e3fb4 100644 --- a/src/main/java/baritone/launch/mixins/accessor/IAnvilChunkLoader.java +++ b/src/main/java/baritone/utils/accessor/IAnvilChunkLoader.java @@ -15,11 +15,7 @@ * along with Baritone. If not, see . */ -package baritone.launch.mixins.accessor; - -import net.minecraft.world.chunk.storage.AnvilChunkLoader; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.gen.Accessor; +package baritone.utils.accessor; import java.io.File; @@ -27,8 +23,7 @@ import java.io.File; * @author Brady * @since 8/4/2018 11:36 AM */ -@Mixin(AnvilChunkLoader.class) public interface IAnvilChunkLoader { - @Accessor File getChunkSaveLocation(); + File getChunkSaveLocation(); } diff --git a/src/main/java/baritone/launch/mixins/accessor/IChunkProviderServer.java b/src/main/java/baritone/utils/accessor/IChunkProviderServer.java similarity index 76% rename from src/main/java/baritone/launch/mixins/accessor/IChunkProviderServer.java rename to src/main/java/baritone/utils/accessor/IChunkProviderServer.java index 460014fc..bb3dcb5e 100644 --- a/src/main/java/baritone/launch/mixins/accessor/IChunkProviderServer.java +++ b/src/main/java/baritone/utils/accessor/IChunkProviderServer.java @@ -15,19 +15,15 @@ * along with Baritone. If not, see . */ -package baritone.launch.mixins.accessor; +package baritone.utils.accessor; import net.minecraft.world.chunk.storage.IChunkLoader; -import net.minecraft.world.gen.ChunkProviderServer; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.gen.Accessor; /** * @author Brady * @since 8/4/2018 11:33 AM */ -@Mixin(ChunkProviderServer.class) public interface IChunkProviderServer { - @Accessor IChunkLoader getChunkLoader(); + IChunkLoader getChunkLoader(); } diff --git a/src/main/resources/mixins.baritone.json b/src/main/resources/mixins.baritone.json index c0b5d3bb..989c9355 100755 --- a/src/main/resources/mixins.baritone.json +++ b/src/main/resources/mixins.baritone.json @@ -8,7 +8,9 @@ "maxShiftBy": 2 }, "client": [ + "MixinAnvilChunkLoader", "MixinBlockPos", + "MixinChunkProviderServer", "MixinEntity", "MixinEntityPlayerSP", "MixinEntityRenderer", @@ -20,9 +22,6 @@ "MixinMinecraft", "MixinNetHandlerPlayClient", "MixinNetworkManager", - "MixinWorldClient", - - "accessor.IAnvilChunkLoader", - "accessor.IChunkProviderServer" + "MixinWorldClient" ] } \ No newline at end of file From e7d41ba4fc9a95a38a26997e25206351c7d809db Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 15:18:51 -0700 Subject: [PATCH 78/80] optimize chunk packer with extended block storage --- src/main/java/baritone/chunk/ChunkPacker.java | 63 +++++++++++++++---- .../java/baritone/chunk/WorldScanner.java | 5 +- 2 files changed, 55 insertions(+), 13 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 82a36709..4622369c 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -28,7 +28,9 @@ import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; +import net.minecraft.world.chunk.BlockStateContainer; import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.storage.ExtendedBlockStorage; import java.util.*; @@ -40,28 +42,65 @@ public final class ChunkPacker implements Helper { private ChunkPacker() {} + private static BitSet originalPacker(Chunk chunk) { + BitSet bitSet = new BitSet(CachedChunk.SIZE); + for (int y = 0; y < 256; y++) { + for (int z = 0; z < 16; z++) { + for (int x = 0; x < 16; x++) { + int index = CachedChunk.getPositionIndex(x, y, z); + IBlockState state = chunk.getBlockState(x, y, z); + boolean[] bits = getPathingBlockType(state).getBits(); + bitSet.set(index, bits[0]); + bitSet.set(index + 1, bits[1]); + } + } + } + return bitSet; + } + public static CachedChunk pack(Chunk chunk) { long start = System.nanoTime() / 1000000L; Map> specialBlocks = new HashMap<>(); BitSet bitSet = new BitSet(CachedChunk.SIZE); try { - for (int y = 0; y < 256; y++) { - for (int z = 0; z < 16; z++) { - for (int x = 0; x < 16; x++) { - int index = CachedChunk.getPositionIndex(x, y, z); - IBlockState state = chunk.getBlockState(x, y, z); - boolean[] bits = getPathingBlockType(state).getBits(); - bitSet.set(index, bits[0]); - bitSet.set(index + 1, bits[1]); - Block block = state.getBlock(); - if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(block)) { - String name = blockToString(block); - specialBlocks.computeIfAbsent(name, b -> new ArrayList<>()).add(new BlockPos(x, y, z)); + ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray(); + for (int y0 = 0; y0 < 16; y0++) { + ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0]; + if (extendedblockstorage == null) { + // any 16x16x16 area that's all air will have null storage + // for example, in an ocean biome, with air from y=64 to y=256 + // the first 4 extended blocks storages will be full + // and the remaining 12 will be null + + // since the index into the bitset is calculated from the x y and z + // and doesn't function as an append, we can entirely skip the scanning + // since a bitset is initialized to all zero, and air is saved as zeros + continue; + } + BlockStateContainer bsc = extendedblockstorage.getData(); + int yReal = y0 << 4; + for (int x = 0; x < 16; x++) { + for (int y1 = 0; y1 < 16; y1++) { + for (int z = 0; z < 16; z++) { + int y = y1 | yReal; + int index = CachedChunk.getPositionIndex(x, y, z); + IBlockState state = bsc.get(x, y1, z); + boolean[] bits = getPathingBlockType(state).getBits(); + bitSet.set(index, bits[0]); + bitSet.set(index + 1, bits[1]); + Block block = state.getBlock(); + if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(block)) { + String name = blockToString(block); + specialBlocks.computeIfAbsent(name, b -> new ArrayList<>()).add(new BlockPos(x, y, z)); + } } } } } + /*if (!bitSet.equals(originalPacker(chunk))) { + throw new IllegalStateException(); + }*/ } catch (Exception e) { e.printStackTrace(); } diff --git a/src/main/java/baritone/chunk/WorldScanner.java b/src/main/java/baritone/chunk/WorldScanner.java index fe3c0ea5..120d6635 100644 --- a/src/main/java/baritone/chunk/WorldScanner.java +++ b/src/main/java/baritone/chunk/WorldScanner.java @@ -64,18 +64,21 @@ public enum WorldScanner implements Helper { } allUnloaded = false; ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray(); + chunkX = chunkX << 4; + chunkZ = chunkZ << 4; for (int y0 = 0; y0 < 16; y0++) { ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0]; if (extendedblockstorage == null) { continue; } + int yReal = y0 << 4; BlockStateContainer bsc = extendedblockstorage.getData(); for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { for (int z = 0; z < 16; z++) { IBlockState state = bsc.get(x, y, z); if (asBlocks.contains(state.getBlock())) { - res.add(new BlockPos(chunkX * 16 + x, y0 * 16 + y, chunkZ * 16 + z)); + res.add(new BlockPos(chunkX | x, yReal | y, chunkZ | z)); } } } From 69d8bd56fa3c54e7668725c9e507319a6107ceef Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 15:23:54 -0700 Subject: [PATCH 79/80] rearranged loop order --- src/main/java/baritone/chunk/ChunkPacker.java | 10 ++++++---- src/main/java/baritone/chunk/WorldScanner.java | 8 +++++--- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/main/java/baritone/chunk/ChunkPacker.java b/src/main/java/baritone/chunk/ChunkPacker.java index 4622369c..583dddc0 100644 --- a/src/main/java/baritone/chunk/ChunkPacker.java +++ b/src/main/java/baritone/chunk/ChunkPacker.java @@ -80,10 +80,12 @@ public final class ChunkPacker implements Helper { } BlockStateContainer bsc = extendedblockstorage.getData(); int yReal = y0 << 4; - for (int x = 0; x < 16; x++) { - for (int y1 = 0; y1 < 16; y1++) { - for (int z = 0; z < 16; z++) { - int y = y1 | yReal; + // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x; + // for better cache locality, iterate in that order + for (int y1 = 0; y1 < 16; y1++) { + int y = y1 | yReal; + for (int z = 0; z < 16; z++) { + for (int x = 0; x < 16; x++) { int index = CachedChunk.getPositionIndex(x, y, z); IBlockState state = bsc.get(x, y1, z); boolean[] bits = getPathingBlockType(state).getBits(); diff --git a/src/main/java/baritone/chunk/WorldScanner.java b/src/main/java/baritone/chunk/WorldScanner.java index 120d6635..cf4fb117 100644 --- a/src/main/java/baritone/chunk/WorldScanner.java +++ b/src/main/java/baritone/chunk/WorldScanner.java @@ -73,9 +73,11 @@ public enum WorldScanner implements Helper { } int yReal = y0 << 4; BlockStateContainer bsc = extendedblockstorage.getData(); - for (int x = 0; x < 16; x++) { - for (int y = 0; y < 16; y++) { - for (int z = 0; z < 16; z++) { + // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x; + // for better cache locality, iterate in that order + for (int y = 0; y < 16; y++) { + for (int z = 0; z < 16; z++) { + for (int x = 0; x < 16; x++) { IBlockState state = bsc.get(x, y, z); if (asBlocks.contains(state.getBlock())) { res.add(new BlockPos(chunkX | x, yReal | y, chunkZ | z)); From 2bb01fdd208756846ab1b4b3cc2a56db9050b11b Mon Sep 17 00:00:00 2001 From: Leijurv Date: Tue, 4 Sep 2018 15:33:38 -0700 Subject: [PATCH 80/80] decrease scan rate --- .../java/baritone/behavior/impl/MineBehavior.java | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/main/java/baritone/behavior/impl/MineBehavior.java b/src/main/java/baritone/behavior/impl/MineBehavior.java index d4b09b7b..0b4b3b2a 100644 --- a/src/main/java/baritone/behavior/impl/MineBehavior.java +++ b/src/main/java/baritone/behavior/impl/MineBehavior.java @@ -17,7 +17,7 @@ package baritone.behavior.impl; -import baritone.api.event.events.TickEvent; +import baritone.api.event.events.PathEvent; import baritone.behavior.Behavior; import baritone.chunk.CachedChunk; import baritone.chunk.ChunkPacker; @@ -50,10 +50,11 @@ public class MineBehavior extends Behavior { List mining; @Override - public void onTick(TickEvent event) { - if (event.getType() == TickEvent.Type.OUT) { - return; - } + public void onPathEvent(PathEvent event) { + updateGoal(); + } + + public void updateGoal() { if (mining == null) { return; } @@ -100,6 +101,7 @@ public class MineBehavior extends Behavior { public void mine(String... mining) { this.mining = mining == null || mining.length == 0 ? null : new ArrayList<>(Arrays.asList(mining)); + updateGoal(); } public void cancel() {