Examples with CalculationContext baritone.pathing.movement.CalculationContext used on opensource projects

Example 16 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project baritone by cabaletta.

the class MovementTraverse method updateState.

@Override
public MovementState updateState(MovementState state) {
    super.updateState(state);
    IBlockState pb0 = BlockStateInterface.get(ctx, positionsToBreak[0]);
    IBlockState pb1 = BlockStateInterface.get(ctx, positionsToBreak[1]);
    if (state.getStatus() != MovementStatus.RUNNING) {
        // if the setting is enabled
        if (!Baritone.settings().walkWhileBreaking.value) {
            return state;
        }
        // and if we're prepping (aka mining the block in front)
        if (state.getStatus() != MovementStatus.PREPPING) {
            return state;
        }
        // and if it's fine to walk into the blocks in front
        if (MovementHelper.avoidWalkingInto(pb0.getBlock())) {
            return state;
        }
        if (MovementHelper.avoidWalkingInto(pb1.getBlock())) {
            return state;
        }
        // and we aren't already pressed up against the block
        double dist = Math.max(Math.abs(ctx.player().posX - (dest.getX() + 0.5D)), Math.abs(ctx.player().posZ - (dest.getZ() + 0.5D)));
        if (dist < 0.83) {
            return state;
        }
        if (!state.getTarget().getRotation().isPresent()) {
            // this can happen rarely when the server lags and doesn't send the falling sand entity until you've already walked through the block and are now mining the next one
            return state;
        }
        // combine the yaw to the center of the destination, and the pitch to the specific block we're trying to break
        // it's safe to do this since the two blocks we break (in a traverse) are right on top of each other and so will have the same yaw
        float yawToDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), dest), ctx.playerRotations()).getYaw();
        float pitchToBreak = state.getTarget().getRotation().get().getPitch();
        if ((pb0.isFullCube() || pb0.getBlock() instanceof BlockAir && (pb1.isFullCube() || pb1.getBlock() instanceof BlockAir))) {
            // in the meantime, before we're right up against the block, we can break efficiently at this angle
            pitchToBreak = 26;
        }
        return state.setTarget(new MovementState.MovementTarget(new Rotation(yawToDest, pitchToBreak), true)).setInput(Input.MOVE_FORWARD, true).setInput(Input.SPRINT, true);
    }
    // sneak may have been set to true in the PREPPING state while mining an adjacent block
    state.setInput(Input.SNEAK, false);
    Block fd = BlockStateInterface.get(ctx, src.down()).getBlock();
    boolean ladder = fd == Blocks.LADDER || fd == Blocks.VINE;
    if (pb0.getBlock() instanceof BlockDoor || pb1.getBlock() instanceof BlockDoor) {
        boolean notPassable = pb0.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, src, dest) || pb1.getBlock() instanceof BlockDoor && !MovementHelper.isDoorPassable(ctx, dest, src);
        boolean canOpen = !(Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()));
        if (notPassable && canOpen) {
            return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), positionsToBreak[0]), ctx.playerRotations()), true)).setInput(Input.CLICK_RIGHT, true);
        }
    }
    if (pb0.getBlock() instanceof BlockFenceGate || pb1.getBlock() instanceof BlockFenceGate) {
        BlockPos blocked = !MovementHelper.isGatePassable(ctx, positionsToBreak[0], src.up()) ? positionsToBreak[0] : !MovementHelper.isGatePassable(ctx, positionsToBreak[1], src) ? positionsToBreak[1] : null;
        if (blocked != null) {
            Optional<Rotation> rotation = RotationUtils.reachable(ctx, blocked);
            if (rotation.isPresent()) {
                return state.setTarget(new MovementState.MovementTarget(rotation.get(), true)).setInput(Input.CLICK_RIGHT, true);
            }
        }
    }
    boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(ctx, positionToPlace) || ladder;
    BlockPos feet = ctx.playerFeet();
    if (feet.getY() != dest.getY() && !ladder) {
        logDebug("Wrong Y coordinate");
        if (feet.getY() < dest.getY()) {
            return state.setInput(Input.JUMP, true);
        }
        return state;
    }
    if (isTheBridgeBlockThere) {
        if (feet.equals(dest)) {
            return state.setStatus(MovementStatus.SUCCESS);
        }
        if (Baritone.settings().overshootTraverse.value && (feet.equals(dest.add(getDirection())) || feet.equals(dest.add(getDirection()).add(getDirection())))) {
            return state.setStatus(MovementStatus.SUCCESS);
        }
        Block low = BlockStateInterface.get(ctx, src).getBlock();
        Block high = BlockStateInterface.get(ctx, src.up()).getBlock();
        if (ctx.player().posY > src.y + 0.1D && !ctx.player().onGround && (low == Blocks.VINE || low == Blocks.LADDER || high == Blocks.VINE || high == Blocks.LADDER)) {
            // wait until we're on the ground
            return state;
        }
        BlockPos into = dest.subtract(src).add(dest);
        Block intoBelow = BlockStateInterface.get(ctx, into).getBlock();
        Block intoAbove = BlockStateInterface.get(ctx, into.up()).getBlock();
        if (wasTheBridgeBlockAlwaysThere && (!MovementHelper.isLiquid(ctx, feet) || Baritone.settings().sprintInWater.value) && (!MovementHelper.avoidWalkingInto(intoBelow) || MovementHelper.isWater(intoBelow)) && !MovementHelper.avoidWalkingInto(intoAbove)) {
            state.setInput(Input.SPRINT, true);
        }
        IBlockState destDown = BlockStateInterface.get(ctx, dest.down());
        BlockPos against = positionsToBreak[0];
        if (feet.getY() != dest.getY() && ladder && (destDown.getBlock() == Blocks.VINE || destDown.getBlock() == Blocks.LADDER)) {
            against = destDown.getBlock() == Blocks.VINE ? MovementPillar.getAgainst(new CalculationContext(baritone), dest.down()) : dest.offset(destDown.getValue(BlockLadder.FACING).getOpposite());
            if (against == null) {
                logDirect("Unable to climb vines. Consider disabling allowVines.");
                return state.setStatus(MovementStatus.UNREACHABLE);
            }
        }
        MovementHelper.moveTowards(ctx, state, against);
        return state;
    } else {
        wasTheBridgeBlockAlwaysThere = false;
        Block standingOn = BlockStateInterface.get(ctx, feet.down()).getBlock();
        if (standingOn.equals(Blocks.SOUL_SAND) || standingOn instanceof BlockSlab) {
            // see issue #118
            double dist = Math.max(Math.abs(dest.getX() + 0.5 - ctx.player().posX), Math.abs(dest.getZ() + 0.5 - ctx.player().posZ));
            if (dist < 0.85) {
                // 0.5 + 0.3 + epsilon
                MovementHelper.moveTowards(ctx, state, dest);
                return state.setInput(Input.MOVE_FORWARD, false).setInput(Input.MOVE_BACK, true);
            }
        }
        double dist1 = Math.max(Math.abs(ctx.player().posX - (dest.getX() + 0.5D)), Math.abs(ctx.player().posZ - (dest.getZ() + 0.5D)));
        PlaceResult p = MovementHelper.attemptToPlaceABlock(state, baritone, dest.down(), false, true);
        if ((p == PlaceResult.READY_TO_PLACE || dist1 < 0.6) && !Baritone.settings().assumeSafeWalk.value) {
            state.setInput(Input.SNEAK, true);
        }
        switch(p) {
            case READY_TO_PLACE:
                {
                    if (ctx.player().isSneaking() || Baritone.settings().assumeSafeWalk.value) {
                        state.setInput(Input.CLICK_RIGHT, true);
                    }
                    return state;
                }
            case ATTEMPTING:
                {
                    if (dist1 > 0.83) {
                        // might need to go forward a bit
                        float yaw = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations()).getYaw();
                        if (Math.abs(state.getTarget().rotation.getYaw() - yaw) < 0.1) {
                            // but only if our attempted place is straight ahead
                            return state.setInput(Input.MOVE_FORWARD, true);
                        }
                    } else if (ctx.playerRotations().isReallyCloseTo(state.getTarget().rotation)) {
                        // well i guess theres something in the way
                        return state.setInput(Input.CLICK_LEFT, true);
                    }
                    return state;
                }
            default:
                break;
        }
        if (feet.equals(dest)) {
            // If we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of
            // Out.log(from + " " + to + " " + faceX + "," + faceY + "," + faceZ + " " + whereAmI);
            double faceX = (dest.getX() + src.getX() + 1.0D) * 0.5D;
            double faceY = (dest.getY() + src.getY() - 1.0D) * 0.5D;
            double faceZ = (dest.getZ() + src.getZ() + 1.0D) * 0.5D;
            // faceX, faceY, faceZ is the middle of the face between from and to
            // this is the block we were just standing on, and the one we want to place against
            BlockPos goalLook = src.down();
            Rotation backToFace = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), new Vec3d(faceX, faceY, faceZ), ctx.playerRotations());
            float pitch = backToFace.getPitch();
            double dist2 = Math.max(Math.abs(ctx.player().posX - faceX), Math.abs(ctx.player().posZ - faceZ));
            if (dist2 < 0.29) {
                // see issue #208
                float yaw = RotationUtils.calcRotationFromVec3d(VecUtils.getBlockPosCenter(dest), ctx.playerHead(), ctx.playerRotations()).getYaw();
                state.setTarget(new MovementState.MovementTarget(new Rotation(yaw, pitch), true));
                state.setInput(Input.MOVE_BACK, true);
            } else {
                state.setTarget(new MovementState.MovementTarget(backToFace, true));
            }
            if (ctx.isLookingAt(goalLook)) {
                // wait to right click until we are able to place
                return state.setInput(Input.CLICK_RIGHT, true);
            }
            // Out.log("Trying to look at " + goalLook + ", actually looking at" + Baritone.whatAreYouLookingAt());
            if (ctx.playerRotations().isReallyCloseTo(state.getTarget().rotation)) {
                state.setInput(Input.CLICK_LEFT, true);
            }
            return state;
        }
        MovementHelper.moveTowards(ctx, state, positionsToBreak[0]);
        return state;
    // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
    }
}

Example 17 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project baritone by cabaletta.

the class PathExecutor method shouldSprintNextTick.

private boolean shouldSprintNextTick() {
    boolean requested = behavior.baritone.getInputOverrideHandler().isInputForcedDown(Input.SPRINT);
    // we'll take it from here, no need for minecraft to see we're holding down control and sprint for us
    behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
    // first and foremost, if allowSprint is off, or if we don't have enough hunger, don't try and sprint
    if (!new CalculationContext(behavior.baritone).canSprint) {
        return false;
    }
    IMovement current = path.movements().get(pathPosition);
    // traverse requests sprinting, so we need to do this check first
    if (current instanceof MovementTraverse && pathPosition < path.length() - 3) {
        IMovement next = path.movements().get(pathPosition + 1);
        if (next instanceof MovementAscend && sprintableAscend(ctx, (MovementTraverse) current, (MovementAscend) next, path.movements().get(pathPosition + 2))) {
            if (skipNow(ctx, current)) {
                logDebug("Skipping traverse to straight ascend");
                pathPosition++;
                onChangeInPathPosition();
                onTick();
                behavior.baritone.getInputOverrideHandler().setInputForceState(Input.JUMP, true);
                return true;
            } else {
                logDebug("Too far to the side to safely sprint ascend");
            }
        }
    }
    // if the movement requested sprinting, then we're done
    if (requested) {
        return true;
    }
    // however, descend and ascend don't request sprinting, because they don't know the context of what movement comes after it
    if (current instanceof MovementDescend) {
        if (((MovementDescend) current).safeMode() && !((MovementDescend) current).skipToAscend()) {
            logDebug("Sprinting would be unsafe");
            return false;
        }
        if (pathPosition < path.length() - 2) {
            IMovement next = path.movements().get(pathPosition + 1);
            if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
                // a descend then an ascend in the same direction
                pathPosition++;
                onChangeInPathPosition();
                onTick();
                // okay to skip clearKeys and / or onChangeInPathPosition here since this isn't possible to repeat, since it's asymmetric
                logDebug("Skipping descend to straight ascend");
                return true;
            }
            if (canSprintFromDescendInto(ctx, current, next)) {
                if (ctx.playerFeet().equals(current.getDest())) {
                    pathPosition++;
                    onChangeInPathPosition();
                    onTick();
                }
                return true;
            }
        // logDebug("Turning off sprinting " + movement + " " + next + " " + movement.getDirection() + " " + next.getDirection().down() + " " + next.getDirection().down().equals(movement.getDirection()));
        }
    }
    if (current instanceof MovementAscend && pathPosition != 0) {
        IMovement prev = path.movements().get(pathPosition - 1);
        if (prev instanceof MovementDescend && prev.getDirection().up().equals(current.getDirection().down())) {
            BlockPos center = current.getSrc().up();
            // 0.07 is to account for farmland
            if (ctx.player().posY >= center.getY() - 0.07) {
                behavior.baritone.getInputOverrideHandler().setInputForceState(Input.JUMP, false);
                return true;
            }
        }
        if (pathPosition < path.length() - 2 && prev instanceof MovementTraverse && sprintableAscend(ctx, (MovementTraverse) prev, (MovementAscend) current, path.movements().get(pathPosition + 1))) {
            return true;
        }
    }
    if (current instanceof MovementFall) {
        Tuple<Vec3d, BlockPos> data = overrideFall((MovementFall) current);
        if (data != null) {
            BetterBlockPos fallDest = new BetterBlockPos(data.getSecond());
            if (!path.positions().contains(fallDest)) {
                throw new IllegalStateException();
            }
            if (ctx.playerFeet().equals(fallDest)) {
                pathPosition = path.positions().indexOf(fallDest);
                onChangeInPathPosition();
                onTick();
                return true;
            }
            clearKeys();
            behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getFirst(), ctx.playerRotations()), false);
            behavior.baritone.getInputOverrideHandler().setInputForceState(Input.MOVE_FORWARD, true);
            return true;
        }
    }
    return false;
}

Example 18 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project baritone by cabaletta.

the class MovementFall method willPlaceBucket.

private boolean willPlaceBucket() {
    CalculationContext context = new CalculationContext(baritone);
    MutableMoveResult result = new MutableMoveResult();
    return MovementDescend.dynamicFallCost(context, src.x, src.y, src.z, dest.x, dest.z, 0, context.get(dest.x, src.y - 2, dest.z), result);
}

Example 19 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project baritone by cabaletta.

the class MineProcess method updateGoal.

private PathingCommand updateGoal() {
    boolean legit = Baritone.settings().legitMine.value;
    List<BlockPos> locs = knownOreLocations;
    if (!locs.isEmpty()) {
        CalculationContext context = new CalculationContext(baritone);
        List<BlockPos> locs2 = prune(context, new ArrayList<>(locs), filter, ORE_LOCATIONS_COUNT, blacklist, droppedItemsScan());
        // can't reassign locs, gotta make a new var locs2, because we use it in a lambda right here, and variables you use in a lambda must be effectively final
        Goal goal = new GoalComposite(locs2.stream().map(loc -> coalesce(loc, locs2, context)).toArray(Goal[]::new));
        knownOreLocations = locs2;
        return new PathingCommand(goal, legit ? PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH : PathingCommandType.REVALIDATE_GOAL_AND_PATH);
    }
    // we don't know any ore locations at the moment
    if (!legit && !Baritone.settings().exploreForBlocks.value) {
        return null;
    }
    // only when we should explore for blocks or are in legit mode we do this
    int y = Baritone.settings().legitMineYLevel.value;
    if (branchPoint == null) {
        /*if (!baritone.getPathingBehavior().isPathing() && playerFeet().y == y) {
                // cool, path is over and we are at desired y
                branchPoint = playerFeet();
                branchPointRunaway = null;
            } else {
                return new GoalYLevel(y);
            }*/
        branchPoint = ctx.playerFeet();
    }
    // TODO also, see if the GoalRunAway with maintain Y at 11 works even from the surface
    if (branchPointRunaway == null) {
        branchPointRunaway = new GoalRunAway(1, y, branchPoint) {

            @Override
            public boolean isInGoal(int x, int y, int z) {
                return false;
            }

            @Override
            public double heuristic() {
                return Double.NEGATIVE_INFINITY;
            }
        };
    }
    return new PathingCommand(branchPointRunaway, PathingCommandType.REVALIDATE_GOAL_AND_PATH);
}

Example 20 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project baritone by cabaletta.

the class MineProcess method onTick.

@Override
public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
    if (desiredQuantity > 0) {
        int curr = ctx.player().inventory.mainInventory.stream().filter(stack -> filter.has(stack)).mapToInt(ItemStack::getCount).sum();
        System.out.println("Currently have " + curr + " valid items");
        if (curr >= desiredQuantity) {
            logDirect("Have " + curr + " valid items");
            cancel();
            return null;
        }
    }
    if (calcFailed) {
        if (!knownOreLocations.isEmpty() && Baritone.settings().blacklistClosestOnFailure.value) {
            logDirect("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...");
            if (Baritone.settings().notificationOnMineFail.value) {
                logNotification("Unable to find any path to " + filter + ", blacklisting presumably unreachable closest instance...", true);
            }
            knownOreLocations.stream().min(Comparator.comparingDouble(ctx.player()::getDistanceSq)).ifPresent(blacklist::add);
            knownOreLocations.removeIf(blacklist::contains);
        } else {
            logDirect("Unable to find any path to " + filter + ", canceling mine");
            if (Baritone.settings().notificationOnMineFail.value) {
                logNotification("Unable to find any path to " + filter + ", canceling mine", true);
            }
            cancel();
            return null;
        }
    }
    if (!Baritone.settings().allowBreak.value) {
        logDirect("Unable to mine when allowBreak is false!");
        cancel();
        return null;
    }
    updateLoucaSystem();
    int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.value;
    List<BlockPos> curr = new ArrayList<>(knownOreLocations);
    if (mineGoalUpdateInterval != 0 && tickCount++ % mineGoalUpdateInterval == 0) {
        // big brain
        CalculationContext context = new CalculationContext(baritone, true);
        Baritone.getExecutor().execute(() -> rescan(curr, context));
    }
    if (Baritone.settings().legitMine.value) {
        addNearby();
    }
    Optional<BlockPos> shaft = curr.stream().filter(pos -> pos.getX() == ctx.playerFeet().getX() && pos.getZ() == ctx.playerFeet().getZ()).filter(pos -> pos.getY() >= ctx.playerFeet().getY()).filter(// after breaking a block, it takes mineGoalUpdateInterval ticks for it to actually update this list =(
    pos -> !(BlockStateInterface.get(ctx, pos).getBlock() instanceof BlockAir)).min(Comparator.comparingDouble(ctx.player()::getDistanceSq));
    baritone.getInputOverrideHandler().clearAllKeys();
    if (shaft.isPresent() && ctx.player().onGround) {
        BlockPos pos = shaft.get();
        IBlockState state = baritone.bsi.get0(pos);
        if (!MovementHelper.avoidBreaking(baritone.bsi, pos.getX(), pos.getY(), pos.getZ(), state)) {
            Optional<Rotation> rot = RotationUtils.reachable(ctx, pos);
            if (rot.isPresent() && isSafeToCancel) {
                baritone.getLookBehavior().updateTarget(rot.get(), true);
                MovementHelper.switchToBestToolFor(ctx, ctx.world().getBlockState(pos));
                if (ctx.isLookingAt(pos) || ctx.playerRotations().isReallyCloseTo(rot.get())) {
                    baritone.getInputOverrideHandler().setInputForceState(Input.CLICK_LEFT, true);
                }
                return new PathingCommand(null, PathingCommandType.REQUEST_PAUSE);
            }
        }
    }
    PathingCommand command = updateGoal();
    if (command == null) {
        // none in range
        // maybe say something in chat? (ahem impact)
        cancel();
        return null;
    }
    return command;
}