Miko/baritone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into 1.13.2

Browse Source
This commit is contained in:
Leijurv
2019-08-17 16:05:50 -07:00
parent a8226ba4c8 9046eb500b
commit 7c9b812a5b
20 changed files with 137 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/baritone/Baritone.java
View File

@@ -148,12 +148,12 @@ public class Baritone implements IBaritone {
}
@Override
public CustomGoalProcess getCustomGoalProcess() { // Iffy
public CustomGoalProcess getCustomGoalProcess() {
return this.customGoalProcess;
}
@Override
public GetToBlockProcess getGetToBlockProcess() { // Iffy
public GetToBlockProcess getGetToBlockProcess() {
return this.getToBlockProcess;
}

13
src/main/java/baritone/behavior/PathingBehavior.java
View File

@@ -135,7 +135,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
) {
// when it was *just* started, currentBest will be empty so we need to also check calcFrom since that's always present
inProgress.cancel(); // cancellation doesn't dispatch any events
inProgress = null; // this is safe since we hold both locks
}
}
}
@@ -339,7 +338,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
}
// just cancel the current path
public void secretInternalSegmentCancel() {
private void secretInternalSegmentCancel() {
queuePathEvent(PathEvent.CANCELED);
synchronized (pathPlanLock) {
getInProgress().ifPresent(AbstractNodeCostSearch::cancel);
@@ -361,12 +360,6 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
}
}
/*public void secretCursedFunctionDoNotCall(IPath path) {
synchronized (pathPlanLock) {
current = new PathExecutor(this, path);
}
}*/
public CalculationContext secretInternalGetCalculationContext() {
return context;
}
@@ -495,7 +488,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
}
}
if (talkAboutIt && current != null && current.getPath() != null) {
if (goal == null || goal.isInGoal(current.getPath().getDest())) {
if (goal.isInGoal(current.getPath().getDest())) {
logDebug("Finished finding a path from " + start + " to " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
} else {
logDebug("Found path segment from " + start + " towards " + goal + ". " + current.getPath().getNumNodesConsidered() + " nodes considered");
@@ -508,7 +501,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
});
}
public static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
private static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
Goal transformed = goal;
if (Baritone.settings().simplifyUnloadedYCoord.value && goal instanceof IGoalRenderPos) {
BlockPos pos = ((IGoalRenderPos) goal).getGoalPos();

13
src/main/java/baritone/cache/CachedChunk.java vendored
View File

@@ -199,8 +199,17 @@ public final class CachedChunk {
}
}
if (type == PathingBlockType.SOLID && y == 127 && dimension == -1) {
return Blocks.BEDROCK.getDefaultState();
if (type == PathingBlockType.SOLID) {
if (y == 127 && dimension == -1) {
// nether roof is always unbreakable
return Blocks.BEDROCK.getDefaultState();
}
if (y < 5 && dimension == 0) {
// solid blocks below 5 are commonly bedrock
// however, returning bedrock always would be a little yikes
// discourage paths that include breaking blocks below 5 a little more heavily just so that it takes paths breaking what's known to be stone (at 5 or above) instead of what could maybe be bedrock (below 5)
return Blocks.OBSIDIAN.getDefaultState();
}
}
return ChunkPacker.pathingTypeToBlock(type, dimension);
}

3
src/main/java/baritone/pathing/calc/AStarPathFinder.java
View File

@@ -76,6 +76,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
int timeCheckInterval = 1 << 6;
int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.value; // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior
double minimumImprovement = Baritone.settings().minimumImprovementRepropagation.value ? MIN_IMPROVEMENT : 0;
Moves[] allMoves = Moves.values();
while (!openSet.isEmpty() && numEmptyChunk < pathingMaxChunkBorderFetch && !cancelRequested) {
if ((numNodes & (timeCheckInterval - 1)) == 0) { // only call this once every 64 nodes (about half a millisecond)
long now = System.currentTimeMillis(); // since nanoTime is slow on windows (takes many microseconds)
@@ -95,7 +96,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
logDebug("Took " + (System.currentTimeMillis() - startTime) + "ms, " + numMovementsConsidered + " movements considered");
return Optional.of(new Path(startNode, currentNode, numNodes, goal, calcContext));
}
for (Moves moves : Moves.values()) {
for (Moves moves : allMoves) {
int newX = currentNode.x + moves.xOffset;
int newZ = currentNode.z + moves.zOffset;
if ((newX >> 4 != currentNode.x >> 4 || newZ >> 4 != currentNode.z >> 4) && !calcContext.isLoaded(newX, newZ)) {

2
src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java
View File

@@ -127,7 +127,7 @@ public abstract class AbstractNodeCostSearch implements IPathFinder, Helper {
return new PathCalculationResult(PathCalculationResult.Type.SUCCESS_SEGMENT, path);
}
} catch (Exception e) {
Helper.HELPER.logDebug("Pathing exception: " + e);
Helper.HELPER.logDirect("Pathing exception: " + e);
e.printStackTrace();
return new PathCalculationResult(PathCalculationResult.Type.EXCEPTION);
} finally {

28
src/main/java/baritone/pathing/calc/Path.java
View File

@@ -72,28 +72,9 @@ class Path extends PathBase {
this.start = new BetterBlockPos(start.x, start.y, start.z);
this.end = new BetterBlockPos(end.x, end.y, end.z);
this.numNodes = numNodes;
this.path = new ArrayList<>();
this.movements = new ArrayList<>();
this.nodes = new ArrayList<>();
this.goal = goal;
this.context = context;
assemblePath(end);
}
@Override
public Goal getGoal() {
return goal;
}
/**
* Assembles this path given the end node.
*
* @param end The end node
*/
private void assemblePath(PathNode end) {
if (!path.isEmpty() || !movements.isEmpty()) {
throw new IllegalStateException();
}
PathNode current = end;
LinkedList<BetterBlockPos> tempPath = new LinkedList<>();
LinkedList<PathNode> tempNodes = new LinkedList<>();
@@ -107,8 +88,13 @@ class Path extends PathBase {
// Can't directly convert from the PathNode pseudo linked list to an array because we don't know how long it is
// inserting into a LinkedList<E> keeps track of length, then when we addall (which calls .toArray) it's able
// to performantly do that conversion since it knows the length.
path.addAll(tempPath);
nodes.addAll(tempNodes);
this.path = new ArrayList<>(tempPath);
this.nodes = new ArrayList<>(tempNodes);
}
@Override
public Goal getGoal() {
return goal;
}
private boolean assembleMovements() {

2
src/main/java/baritone/pathing/movement/CalculationContext.java
View File

@@ -58,6 +58,7 @@ public class CalculationContext {
public final boolean allowParkour;
public final boolean allowParkourPlace;
public final boolean allowJumpAt256;
public final boolean allowParkourAscend;
public final boolean assumeWalkOnWater;
public final boolean allowDiagonalDescend;
public final boolean allowDownward;
@@ -90,6 +91,7 @@ public class CalculationContext {
this.allowParkour = Baritone.settings().allowParkour.value;
this.allowParkourPlace = Baritone.settings().allowParkourPlace.value;
this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
this.allowParkourAscend = Baritone.settings().allowParkourAscend.value;
this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;
this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.value;
this.allowDownward = Baritone.settings().allowDownward.value;

2
src/main/java/baritone/pathing/movement/MovementHelper.java
View File

@@ -520,7 +520,7 @@ public interface MovementHelper extends ActionCosts, Helper {
return PlaceResult.NO_OPTION;
}
double faceX = (placeAt.getX() + against1.getX() + 1.0D) * 0.5D;
double faceY = (placeAt.getY() + against1.getY() + 1.0D) * 0.5D;
double faceY = (placeAt.getY() + against1.getY() + 0.5D) * 0.5D;
double faceZ = (placeAt.getZ() + against1.getZ() + 1.0D) * 0.5D;
Rotation place = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), new Vec3d(faceX, faceY, faceZ), ctx.playerRotations());
RayTraceResult res = RayTraceUtils.rayTraceTowards(ctx.player(), place, ctx.playerController().getBlockReachDistance());

8
src/main/java/baritone/pathing/movement/Moves.java
View File

@@ -276,7 +276,7 @@ public enum Moves {
}
},
PARKOUR_NORTH(0, 0, -4, true, false) {
PARKOUR_NORTH(0, 0, -4, true, true) {
@Override
public Movement apply0(CalculationContext context, BetterBlockPos src) {
return MovementParkour.cost(context, src, EnumFacing.NORTH);
@@ -288,7 +288,7 @@ public enum Moves {
}
},
PARKOUR_SOUTH(0, 0, +4, true, false) {
PARKOUR_SOUTH(0, 0, +4, true, true) {
@Override
public Movement apply0(CalculationContext context, BetterBlockPos src) {
return MovementParkour.cost(context, src, EnumFacing.SOUTH);
@@ -300,7 +300,7 @@ public enum Moves {
}
},
PARKOUR_EAST(+4, 0, 0, true, false) {
PARKOUR_EAST(+4, 0, 0, true, true) {
@Override
public Movement apply0(CalculationContext context, BetterBlockPos src) {
return MovementParkour.cost(context, src, EnumFacing.EAST);
@@ -312,7 +312,7 @@ public enum Moves {
}
},
PARKOUR_WEST(-4, 0, 0, true, false) {
PARKOUR_WEST(-4, 0, 0, true, true) {
@Override
public Movement apply0(CalculationContext context, BetterBlockPos src) {
return MovementParkour.cost(context, src, EnumFacing.WEST);

66
src/main/java/baritone/pathing/movement/movements/MovementParkour.java
View File

@@ -44,18 +44,20 @@ public class MovementParkour extends Movement {
private final EnumFacing direction;
private final int dist;
private final boolean ascend;
private MovementParkour(IBaritone baritone, BetterBlockPos src, int dist, EnumFacing dir) {
super(baritone, src, src.offset(dir, dist), EMPTY, src.offset(dir, dist).down());
private MovementParkour(IBaritone baritone, BetterBlockPos src, int dist, EnumFacing dir, boolean ascend) {
super(baritone, src, src.offset(dir, dist).up(ascend ? 1 : 0), EMPTY, src.offset(dir, dist).down(ascend ? 0 : 1));
this.direction = dir;
this.dist = dist;
this.ascend = ascend;
}
public static MovementParkour cost(CalculationContext context, BetterBlockPos src, EnumFacing direction) {
MutableMoveResult res = new MutableMoveResult();
cost(context, src.x, src.y, src.z, direction, res);
int dist = Math.abs(res.x - src.x) + Math.abs(res.z - src.z);
return new MovementParkour(context.getBaritone(), src, dist, direction);
return new MovementParkour(context.getBaritone(), src, dist, direction, res.y > src.y);
}
public static void cost(CalculationContext context, int x, int y, int z, EnumFacing dir, MutableMoveResult res) {
@@ -104,19 +106,36 @@ public class MovementParkour extends Movement {
}
}
for (int i = 2; i <= maxJump; i++) {
// TODO perhaps dest.up(3) doesn't need to be fullyPassable, just canWalkThrough, possibly?
for (int y2 = 0; y2 < 4; y2++) {
if (!MovementHelper.fullyPassable(context, x + xDiff * i, y + y2, z + zDiff * i)) {
return;
}
int destX = x + xDiff * i;
int destZ = z + zDiff * i;
if (!MovementHelper.fullyPassable(context, destX, y + 1, destZ)) {
return;
}
IBlockState landingOn = context.bsi.get0(x + xDiff * i, y - 1, z + zDiff * i);
if (!MovementHelper.fullyPassable(context, destX, y + 2, destZ)) {
return;
}
IBlockState destInto = context.bsi.get0(destX, y, destZ);
if (!MovementHelper.fullyPassable(destInto)) {
if (i <= 3 && context.allowParkourAscend && context.canSprint && MovementHelper.canWalkOn(context.bsi, destX, y, destZ, destInto) && checkOvershootSafety(context.bsi, destX + xDiff, y + 1, destZ + zDiff)) {
res.x = destX;
res.y = y + 1;
res.z = destZ;
res.cost = i * SPRINT_ONE_BLOCK_COST + context.jumpPenalty;
}
return;
}
IBlockState landingOn = context.bsi.get0(destX, y - 1, destZ);
// farmland needs to be canwalkon otherwise farm can never work at all, but we want to specifically disallow ending a jumy on farmland haha
if (landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, x + xDiff * i, y - 1, z + zDiff * i, landingOn)) {
res.x = x + xDiff * i;
res.y = y;
res.z = z + zDiff * i;
res.cost = costFromJumpDistance(i) + context.jumpPenalty;
if (landingOn.getBlock() != Blocks.FARMLAND && MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, landingOn)) {
if (checkOvershootSafety(context.bsi, destX + xDiff, y, destZ + zDiff)) {
res.x = destX;
res.y = y;
res.z = destZ;
res.cost = costFromJumpDistance(i) + context.jumpPenalty;
}
return;
}
if (!MovementHelper.fullyPassable(context, destX, y + 3, destZ)) {
return;
}
}
@@ -137,6 +156,9 @@ public class MovementParkour extends Movement {
if (!MovementHelper.isReplacable(destX, y - 1, destZ, toReplace, context.bsi)) {
return;
}
if (!checkOvershootSafety(context.bsi, destX + xDiff, y, destZ + zDiff)) {
return;
}
for (int i = 0; i < 5; i++) {
int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
@@ -154,6 +176,11 @@ public class MovementParkour extends Movement {
}
}
private static boolean checkOvershootSafety(BlockStateInterface bsi, int x, int y, int z) {
// we're going to walk into these two blocks after the landing of the parkour anyway, so make sure they aren't avoidWalkingInto
return !MovementHelper.avoidWalkingInto(bsi.get0(x, y, z)) && !MovementHelper.avoidWalkingInto(bsi.get0(x, y + 1, z));
}
private static double costFromJumpDistance(int dist) {
switch (dist) {
case 2:
@@ -172,7 +199,7 @@ public class MovementParkour extends Movement {
public double calculateCost(CalculationContext context) {
MutableMoveResult res = new MutableMoveResult();
cost(context, src.x, src.y, src.z, direction, res);
if (res.x != dest.x || res.z != dest.z) {
if (res.x != dest.x || res.y != dest.y || res.z != dest.z) {
return COST_INF;
}
return res.cost;
@@ -203,16 +230,12 @@ public class MovementParkour extends Movement {
if (state.getStatus() != MovementStatus.RUNNING) {
return state;
}
if (ctx.player().isHandActive()) {
logDebug("Pausing parkour since hand is active");
return state;
}
if (ctx.playerFeet().y < src.y) {
// we have fallen
logDebug("sorry");
return state.setStatus(MovementStatus.UNREACHABLE);
}
if (dist >= 4) {
if (dist >= 4 || ascend) {
state.setInput(Input.SPRINT, true);
}
MovementHelper.moveTowards(ctx, state, dest);
@@ -232,7 +255,8 @@ public class MovementParkour extends Movement {
// go in the opposite order to check DOWN before all horizontals -- down is preferable because you don't have to look to the side while in midair, which could mess up the trajectory
state.setInput(Input.CLICK_RIGHT, true);
}
if (dist == 3) { // this is a 2 block gap, dest = src + direction * 3
// prevent jumping too late by checking for ascend
if (dist == 3 && !ascend) { // this is a 2 block gap, dest = src + direction * 3
double xDiff = (src.x + 0.5) - ctx.player().posX;
double zDiff = (src.z + 0.5) - ctx.player().posZ;
double distFromStart = Math.max(Math.abs(xDiff), Math.abs(zDiff));

3
src/main/java/baritone/pathing/path/PathExecutor.java
View File

@@ -42,8 +42,7 @@ import java.util.*;
import static baritone.api.pathing.movement.MovementStatus.*;
/**
* Behavior to execute a precomputed path. Does not (yet) deal with path segmentation or stitching
* or cutting (jumping onto the next path if it starts with a backtrack of this path's ending)
* Behavior to execute a precomputed path
*
* @author leijurv
*/

1
src/main/java/baritone/process/BuilderProcess.java
View File

@@ -451,7 +451,6 @@ public final class BuilderProcess extends BaritoneProcessHelper implements IBuil
}
}
Goal goal = assemble(bcc, approxPlacable.subList(0, 9));
if (goal == null) {
goal = assemble(bcc, approxPlacable); // we're far away, so assume that we have our whole inventory to recalculate placable properly

3
src/main/java/baritone/process/ExploreProcess.java
View File

@@ -140,6 +140,9 @@ public final class ExploreProcess extends BaritoneProcessHelper implements IExpl
centers.add(new BlockPos(centerX, 0, centerZ));
}
}
if (dist % 10 == 0) {
count = Math.min(filter.countRemain(), Baritone.settings().exploreChunkSetMinimumSize.value);
}
if (centers.size() >= count) {
return centers.stream().map(pos -> createGoal(pos.getX(), pos.getZ())).toArray(Goal[]::new);
}

5
src/main/java/baritone/utils/PathRenderer.java
View File

@@ -125,9 +125,7 @@ public final class PathRenderer implements Helper {
public static void drawPath(IPath path, int startIndex, Entity player, float partialTicks, Color color, boolean fadeOut, int fadeStart0, int fadeEnd0) {
GlStateManager.enableBlend();
GlStateManager.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
GlStateManager.color4f(color.getColorComponents(null)[0], color.getColorComponents(null)[1], color.getColorComponents(null)[2], 0.4F);
GlStateManager.lineWidth(Baritone.settings().pathRenderLineWidthPixels.value);
GlStateManager.disableLighting();
GlStateManager.disableTexture2D();
GlStateManager.depthMask(false);
if (Baritone.settings().renderPathIgnoreDepth.value) {
@@ -179,6 +177,7 @@ public final class PathRenderer implements Helper {
//GlStateManager.color(0.0f, 0.0f, 0.0f, 0.4f);
GlStateManager.depthMask(true);
GlStateManager.enableTexture2D();
GlStateManager.enableLighting();
GlStateManager.disableBlend();
}