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

Example 1 with CalculationContext

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

the class PathingBehavior method secretInternalSetGoalAndPath.

public boolean secretInternalSetGoalAndPath(PathingCommand command) {
    secretInternalSetGoal(command.goal);
    if (command instanceof PathingCommandContext) {
        context = ((PathingCommandContext) command).desiredCalcContext;
    } else {
        context = new CalculationContext(baritone, true);
    }
    if (goal == null) {
        return false;
    }
    if (goal.isInGoal(ctx.playerFeet()) || goal.isInGoal(expectedSegmentStart)) {
        return false;
    }
    synchronized (pathPlanLock) {
        if (current != null) {
            return false;
        }
        synchronized (pathCalcLock) {
            if (inProgress != null) {
                return false;
            }
            queuePathEvent(PathEvent.CALC_STARTED);
            findPathInNewThread(expectedSegmentStart, true, context);
            return true;
        }
    }
}

Example 2 with CalculationContext

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

the class MovementPillar method updateState.

@Override
public MovementState updateState(MovementState state) {
    super.updateState(state);
    if (state.getStatus() != MovementStatus.RUNNING) {
        return state;
    }
    if (ctx.playerFeet().y < src.y) {
        return state.setStatus(MovementStatus.UNREACHABLE);
    }
    IBlockState fromDown = BlockStateInterface.get(ctx, src);
    if (MovementHelper.isWater(fromDown.getBlock()) && MovementHelper.isWater(ctx, dest)) {
        // stay centered while swimming up a water column
        state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations()), false));
        Vec3d destCenter = VecUtils.getBlockPosCenter(dest);
        if (Math.abs(ctx.player().posX - destCenter.x) > 0.2 || Math.abs(ctx.player().posZ - destCenter.z) > 0.2) {
            state.setInput(Input.MOVE_FORWARD, true);
        }
        if (ctx.playerFeet().equals(dest)) {
            return state.setStatus(MovementStatus.SUCCESS);
        }
        return state;
    }
    boolean ladder = fromDown.getBlock() == Blocks.LADDER || fromDown.getBlock() == Blocks.VINE;
    boolean vine = fromDown.getBlock() == Blocks.VINE;
    Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(positionToPlace), new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));
    if (!ladder) {
        state.setTarget(new MovementState.MovementTarget(new Rotation(ctx.player().rotationYaw, rotation.getPitch()), true));
    }
    boolean blockIsThere = MovementHelper.canWalkOn(ctx, src) || ladder;
    if (ladder) {
        BlockPos against = vine ? getAgainst(new CalculationContext(baritone), src) : src.offset(fromDown.getValue(BlockLadder.FACING).getOpposite());
        if (against == null) {
            logDirect("Unable to climb vines. Consider disabling allowVines.");
            return state.setStatus(MovementStatus.UNREACHABLE);
        }
        if (ctx.playerFeet().equals(against.up()) || ctx.playerFeet().equals(dest)) {
            return state.setStatus(MovementStatus.SUCCESS);
        }
        if (MovementHelper.isBottomSlab(BlockStateInterface.get(ctx, src.down()))) {
            state.setInput(Input.JUMP, true);
        }
        /*
            if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) {
                Baritone.moveTowardsBlock(from);
            }
             */
        MovementHelper.moveTowards(ctx, state, against);
        return state;
    } else {
        // Get ready to place a throwaway block
        if (!((Baritone) baritone).getInventoryBehavior().selectThrowawayForLocation(true, src.x, src.y, src.z)) {
            return state.setStatus(MovementStatus.UNREACHABLE);
        }
        // delay placement by 1 tick for ncp compatibility
        state.setInput(Input.SNEAK, ctx.player().posY > dest.getY() || ctx.player().posY < src.getY() + 0.2D);
        // since (lower down) we only right click once player.isSneaking, and that happens the tick after we request to sneak
        double diffX = ctx.player().posX - (dest.getX() + 0.5);
        double diffZ = ctx.player().posZ - (dest.getZ() + 0.5);
        double dist = Math.sqrt(diffX * diffX + diffZ * diffZ);
        double flatMotion = Math.sqrt(ctx.player().motionX * ctx.player().motionX + ctx.player().motionZ * ctx.player().motionZ);
        if (dist > 0.17) {
            // why 0.17? because it seemed like a good number, that's why
            // [explanation added after baritone port lol] also because it needs to be less than 0.2 because of the 0.3 sneak limit
            // and 0.17 is reasonably less than 0.2
            // If it's been more than forty ticks of trying to jump and we aren't done yet, go forward, maybe we are stuck
            state.setInput(Input.MOVE_FORWARD, true);
            // revise our target to both yaw and pitch if we're going to be moving forward
            state.setTarget(new MovementState.MovementTarget(rotation, true));
        } else if (flatMotion < 0.05) {
            // If our Y coordinate is above our goal, stop jumping
            state.setInput(Input.JUMP, ctx.player().posY < dest.getY());
        }
        if (!blockIsThere) {
            IBlockState frState = BlockStateInterface.get(ctx, src);
            Block fr = frState.getBlock();
            // TODO: Evaluate usage of getMaterial().isReplaceable()
            if (!(fr instanceof BlockAir || frState.getMaterial().isReplaceable())) {
                RotationUtils.reachable(ctx.player(), src, ctx.playerController().getBlockReachDistance()).map(rot -> new MovementState.MovementTarget(rot, true)).ifPresent(state::setTarget);
                // breaking is like 5x slower when you're jumping
                state.setInput(Input.JUMP, false);
                state.setInput(Input.CLICK_LEFT, true);
                blockIsThere = false;
            } else if (ctx.player().isSneaking() && (Objects.equals(src.down(), ctx.objectMouseOver().getBlockPos()) || Objects.equals(src, ctx.objectMouseOver().getBlockPos())) && ctx.player().posY > dest.getY() + 0.1) {
                state.setInput(Input.CLICK_RIGHT, true);
            }
        }
    }
    // If we are at our goal and the block below us is placed
    if (ctx.playerFeet().equals(dest) && blockIsThere) {
        return state.setStatus(MovementStatus.SUCCESS);
    }
    return state;
}

Example 3 with CalculationContext

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

the class GetToBlockProcess method onTick.

@Override
public synchronized PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
    if (knownLocations == null) {
        rescan(new ArrayList<>(), new GetToBlockCalculationContext(false));
    }
    if (knownLocations.isEmpty()) {
        if (Baritone.settings().exploreForBlocks.value && !calcFailed) {
            return new PathingCommand(new GoalRunAway(1, start) {

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

                @Override
                public double heuristic() {
                    return Double.NEGATIVE_INFINITY;
                }
            }, PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH);
        }
        logDirect("No known locations of " + gettingTo + ", canceling GetToBlock");
        if (isSafeToCancel) {
            onLostControl();
        }
        return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
    }
    Goal goal = new GoalComposite(knownLocations.stream().map(this::createGoal).toArray(Goal[]::new));
    if (calcFailed) {
        if (Baritone.settings().blacklistClosestOnFailure.value) {
            logDirect("Unable to find any path to " + gettingTo + ", blacklisting presumably unreachable closest instances...");
            blacklistClosest();
            // gamer moment
            return onTick(false, isSafeToCancel);
        } else {
            logDirect("Unable to find any path to " + gettingTo + ", canceling GetToBlock");
            if (isSafeToCancel) {
                onLostControl();
            }
            return new PathingCommand(goal, PathingCommandType.CANCEL_AND_SET_GOAL);
        }
    }
    int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.value;
    if (mineGoalUpdateInterval != 0 && tickCount++ % mineGoalUpdateInterval == 0) {
        // big brain
        List<BlockPos> current = new ArrayList<>(knownLocations);
        CalculationContext context = new GetToBlockCalculationContext(true);
        Baritone.getExecutor().execute(() -> rescan(current, context));
    }
    if (goal.isInGoal(ctx.playerFeet()) && goal.isInGoal(baritone.getPathingBehavior().pathStart()) && isSafeToCancel) {
        // we're there
        if (rightClickOnArrival(gettingTo.getBlock())) {
            if (rightClick()) {
                onLostControl();
                return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
            }
        } else {
            onLostControl();
            return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
        }
    }
    return new PathingCommand(goal, PathingCommandType.REVALIDATE_GOAL_AND_PATH);
}

Example 4 with CalculationContext

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

the class MineProcess method addNearby.

private void addNearby() {
    List<BlockPos> dropped = droppedItemsScan();
    knownOreLocations.addAll(dropped);
    BlockPos playerFeet = ctx.playerFeet();
    BlockStateInterface bsi = new BlockStateInterface(ctx);
    int searchDist = 10;
    // at least 10 * sqrt(3) with some extra space to account for positioning within the block
    double fakedBlockReachDistance = 20;
    for (int x = playerFeet.getX() - searchDist; x <= playerFeet.getX() + searchDist; x++) {
        for (int y = playerFeet.getY() - searchDist; y <= playerFeet.getY() + searchDist; y++) {
            for (int z = playerFeet.getZ() - searchDist; z <= playerFeet.getZ() + searchDist; z++) {
                // is an x-ray and it'll get caught
                if (filter.has(bsi.get0(x, y, z))) {
                    BlockPos pos = new BlockPos(x, y, z);
                    if ((Baritone.settings().legitMineIncludeDiagonals.value && knownOreLocations.stream().anyMatch(ore -> ore.distanceSq(pos) <= 2)) || RotationUtils.reachable(ctx.player(), pos, fakedBlockReachDistance).isPresent()) {
                        knownOreLocations.add(pos);
                    }
                }
            }
        }
    }
    knownOreLocations = prune(new CalculationContext(baritone), knownOreLocations, filter, ORE_LOCATIONS_COUNT, blacklist, dropped);
}

Example 5 with CalculationContext

use of baritone.pathing.movement.CalculationContext in project Spark-Client by Spark-Client-Development.

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.getValue()) {
            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.getValue() && (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.getValue()) && (!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.getValue()) {
            state.setInput(Input.SNEAK, true);
        }
        switch(p) {
            case READY_TO_PLACE:
                {
                    if (ctx.player().isSneaking() || Baritone.settings().assumeSafeWalk.getValue()) {
                        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
    }
}