diff --git a/src/main/java/baritone/bot/pathing/calc/AbstractNodeCostSearch.java b/src/main/java/baritone/bot/pathing/calc/AbstractNodeCostSearch.java index cd7365bf..6abb36e0 100644 --- a/src/main/java/baritone/bot/pathing/calc/AbstractNodeCostSearch.java +++ b/src/main/java/baritone/bot/pathing/calc/AbstractNodeCostSearch.java @@ -4,19 +4,29 @@ import baritone.bot.pathing.goals.Goal; import net.minecraft.util.math.BlockPos; import java.util.HashMap; +import java.util.Map; public abstract class AbstractNodeCostSearch implements IPathFinder { - //TODO this shouldn't be necessary!! + /** + * The currently running search task + * + * TODO: This shouldn't be necessary, investigate old purpose of this field and determine necessity. + */ public static AbstractNodeCostSearch currentlyRunning = null; - protected final BlockPos start; + protected final Goal goal; - protected final HashMap map; + + protected final Map map; + protected PathNode startNode; + protected PathNode mostRecentConsidered; + protected PathNode[] bestSoFar; + private volatile boolean isFinished; /** @@ -37,38 +47,58 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { this.map = new HashMap<>(); } - public synchronized IPath calculatePath() { + public synchronized IPath calculate() { if (isFinished) { - throw new IllegalStateException("Unable to re-use path finder"); + throw new IllegalStateException("Path Finder is currently in use! Wait until complete to reuse!"); } - IPath path = calculate(); + IPath path = calculate0(); isFinished = true; return path; } - protected abstract IPath calculate(); + protected abstract IPath calculate0(); - protected double distFromStart(PathNode n) { + /** + * Determines the distance squared from the specified node to the start + * node. Intended for use in distance comparison, rather than anything that + * considers the real distance value, hence the "sq". + * + * @see AbstractNodeCostSearch#getDistFromStart(PathNode) + * + * @param n A node + * @return The distance, squared + */ + protected double getDistFromStartSq(PathNode n) { int xDiff = n.pos.getX() - start.getX(); int yDiff = n.pos.getY() - start.getY(); int zDiff = n.pos.getZ() - start.getZ(); - return Math.sqrt(xDiff * xDiff + yDiff * yDiff + zDiff * zDiff); + return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff; } + /** + * Determines the distance from the specified node to this the node. + * + * @param n A node + * @return The distance + */ + protected double getDistFromStart(PathNode n) { + return Math.sqrt(getDistFromStartSq(n)); + } + + /** + * Attempts to search the {@link BlockPos} to {@link PathNode} map + * for the node mapped to the specified pos. If no node is found, + * a new node is created. + * + * @param pos The pos to lookup + * @return The associated node + */ protected PathNode getNodeAtPosition(BlockPos pos) { - //technically I think this could be map.computeIfAbsent(pos, pos -> new PathNode(pos, goal)) - //but this is so core to the pathfinder that I'm wary of the lambda performance, hmmm - PathNode alr = map.get(pos); - if (alr == null) { - PathNode node = new PathNode(pos, goal); - map.put(pos, node); - return node; - } - return alr; + return map.computeIfAbsent(pos, p -> new PathNode(p, goal)); } @Override - public Path bestPathSoFar() { + public IPath bestPathSoFar() { if (startNode == null || bestSoFar[0] == null) { return null; } @@ -76,7 +106,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder { } @Override - public Path pathToMostRecentNodeConsidered() { + public IPath pathToMostRecentNodeConsidered() { return mostRecentConsidered == null ? null : new Path(startNode, mostRecentConsidered, goal); } diff --git a/src/main/java/baritone/bot/pathing/calc/IPath.java b/src/main/java/baritone/bot/pathing/calc/IPath.java index 7464c9f2..4d745d5e 100644 --- a/src/main/java/baritone/bot/pathing/calc/IPath.java +++ b/src/main/java/baritone/bot/pathing/calc/IPath.java @@ -87,7 +87,7 @@ public interface IPath { * * @return an unordered collection of positions */ - Collection getBlocksToMine(); + Collection getBlocksToBreak(); /** * For rendering purposes, what blocks should be highlighted in green diff --git a/src/main/java/baritone/bot/pathing/calc/IPathFinder.java b/src/main/java/baritone/bot/pathing/calc/IPathFinder.java index 2e366850..63fa8a3c 100644 --- a/src/main/java/baritone/bot/pathing/calc/IPathFinder.java +++ b/src/main/java/baritone/bot/pathing/calc/IPathFinder.java @@ -4,6 +4,7 @@ import baritone.bot.pathing.goals.Goal; import net.minecraft.util.math.BlockPos; public interface IPathFinder { + BlockPos getStart(); Goal getGoal(); @@ -11,21 +12,21 @@ public interface IPathFinder { /** * Calculate the path in full. Will take several seconds. * - * @return the final path + * @return The final path */ - IPath calculatePath(); + IPath calculate(); /** * Intended to be called concurrently with calculatePath from a different thread to tell if it's finished yet * - * @return + * @return Whether or not this finder is finished */ boolean isFinished(); /** * Called for path rendering. Returns a path to the most recent node popped from the open set and considered. * - * @return the temporary path + * @return The temporary path */ IPath pathToMostRecentNodeConsidered(); @@ -35,8 +36,7 @@ public interface IPathFinder { * That's almost always a safe assumption, but in the case of a nearly impossible path, it still works by providing * a theoretically plausible but practically unlikely path) * - * @return the temporary path + * @return The temporary path */ IPath bestPathSoFar(); - } diff --git a/src/main/java/baritone/bot/pathing/calc/Path.java b/src/main/java/baritone/bot/pathing/calc/Path.java index 5388889a..ace92acf 100644 --- a/src/main/java/baritone/bot/pathing/calc/Path.java +++ b/src/main/java/baritone/bot/pathing/calc/Path.java @@ -14,10 +14,19 @@ import java.util.stream.Collectors; */ class Path implements IPath { + /** + * The start position of this path + */ public final BlockPos start; + /** + * The end position of this path + */ public final BlockPos end; + /** + * The goal that this path is attempting to accomplish + */ public final Goal goal; /** @@ -38,6 +47,12 @@ class Path implements IPath { sanityCheck(); } + /** + * Assembles this path given the start and end nodes. + * + * @param start The start node + * @param end The end node + */ private void assemblePath(PathNode start, PathNode end) { if (!path.isEmpty() || !movements.isEmpty()) { throw new IllegalStateException(); @@ -95,7 +110,7 @@ class Path implements IPath { } @Override - public Collection getBlocksToMine() { + public Collection getBlocksToBreak() { return movements.stream().map(move -> move.positionsToBreak).flatMap(Arrays::stream).collect(Collectors.toCollection(HashSet::new)); } diff --git a/src/main/java/baritone/bot/pathing/movement/ActionCosts.java b/src/main/java/baritone/bot/pathing/movement/ActionCosts.java index ff407ffb..d2c24160 100644 --- a/src/main/java/baritone/bot/pathing/movement/ActionCosts.java +++ b/src/main/java/baritone/bot/pathing/movement/ActionCosts.java @@ -1,6 +1,7 @@ package baritone.bot.pathing.movement; public interface ActionCosts { + /** * These costs are measured roughly in ticks btw * Blocks/Tick: 0.2806167m / tick diff --git a/src/main/java/baritone/bot/pathing/movement/Movement.java b/src/main/java/baritone/bot/pathing/movement/Movement.java index a7021207..a833e2b2 100644 --- a/src/main/java/baritone/bot/pathing/movement/Movement.java +++ b/src/main/java/baritone/bot/pathing/movement/Movement.java @@ -15,18 +15,21 @@ import java.util.Optional; public abstract class Movement implements AbstractGameEventListener, Helper, MovementHelper { protected MovementState currentState; + protected final BlockPos src; + protected final BlockPos dest; + /** * The positions that need to be broken before this movement can ensue */ public final BlockPos[] positionsToBreak; + /** * The positions where we need to place a block before this movement can ensue */ public final BlockPos[] positionsToPlace; - protected Movement(BlockPos src, BlockPos dest, BlockPos[] toBreak, BlockPos[] toPlace) { this.src = src; this.dest = dest; diff --git a/src/main/java/baritone/bot/pathing/movement/MovementHelper.java b/src/main/java/baritone/bot/pathing/movement/MovementHelper.java index 6c119b64..8de9b2f1 100644 --- a/src/main/java/baritone/bot/pathing/movement/MovementHelper.java +++ b/src/main/java/baritone/bot/pathing/movement/MovementHelper.java @@ -14,28 +14,46 @@ import net.minecraft.util.math.BlockPos; * @author leijurv */ public interface MovementHelper extends ActionCosts { - Block waterFlowing = Block.getBlockById(8); - Block waterStill = Block.getBlockById(9); - Block lavaFlowing = Block.getBlockById(10); - Block lavaStill = Block.getBlockById(11); + + Block waterFlowing = Blocks.FLOWING_WATER; + Block waterStill = Blocks.WATER; + Block lavaFlowing = Blocks.FLOWING_LAVA; + Block lavaStill = Blocks.LAVA; /** - * Is this block water? Includes both still and flowing + * Returns whether or not the specified block is + * water, regardless of whether or not it is flowing. * - * @param b - * @return + * @param b The block + * @return Whether or not the block is water */ static boolean isWater(Block b) { return waterFlowing.equals(b) || waterStill.equals(b); } + /** + * Returns whether or not the block at the specified pos is + * water, regardless of whether or not it is flowing. + * + * @param bp The block pos + * @return Whether or not the block is water + */ static boolean isWater(BlockPos bp) { return isWater(BlockStateInterface.get(bp).getBlock()); } + /** + * Returns whether or not the specified block is any sort of liquid. + * + * @param b The block + * @return Whether or not the block is a liquid + */ static boolean isLiquid(Block b) { return b instanceof BlockLiquid; - //return b != null && (waterFlowing.equals(b) || waterStill.equals(b) || lavaFlowing.equals(b) || lavaStill.equals(b)); + } + + static boolean isLiquid(BlockPos p) { + return isLiquid(BlockStateInterface.get(p).getBlock()); } static boolean isFlowing(IBlockState state) { @@ -48,10 +66,6 @@ public interface MovementHelper extends ActionCosts { return lavaFlowing.equals(b) || lavaStill.equals(b); } - static boolean isLiquid(BlockPos p) { - return isLiquid(BlockStateInterface.get(p).getBlock()); - } - static boolean avoidBreaking(BlockPos pos) { Block b = BlockStateInterface.get(pos).getBlock(); Block below = BlockStateInterface.get(new BlockPos(pos.getX(), pos.getY() - 1, pos.getZ())).getBlock();