Examples with IPath baritone.api.pathing.calc.IPath used on opensource projects

Example 6 with IPath

use of baritone.api.pathing.calc.IPath in project Spark-Client by Spark-Client-Development.

the class PathingBehavior method tickPath.

private void tickPath() {
    pausedThisTick = false;
    if (pauseRequestedLastTick && safeToCancel) {
        pauseRequestedLastTick = false;
        if (unpausedLastTick) {
            baritone.getInputOverrideHandler().clearAllKeys();
            baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
        }
        unpausedLastTick = false;
        pausedThisTick = true;
        return;
    }
    unpausedLastTick = true;
    if (cancelRequested) {
        cancelRequested = false;
        baritone.getInputOverrideHandler().clearAllKeys();
    }
    synchronized (pathPlanLock) {
        synchronized (pathCalcLock) {
            if (inProgress != null) {
                // we are calculating
                // are we calculating the right thing though? 🤔
                BetterBlockPos calcFrom = inProgress.getStart();
                Optional<IPath> currentBest = inProgress.bestPathSoFar();
                if (// if current ends in inProgress's start, then we're ok
                (current == null || !current.getPath().getDest().equals(calcFrom)) && !calcFrom.equals(ctx.playerFeet()) && // if current starts in our playerFeet or pathStart, then we're ok
                !calcFrom.equals(expectedSegmentStart) && // if
                (!currentBest.isPresent() || (!currentBest.get().positions().contains(ctx.playerFeet()) && !currentBest.get().positions().contains(expectedSegmentStart)))) {
                    // when it was *just* started, currentBest will be empty so we need to also check calcFrom since that's always present
                    // cancellation doesn't dispatch any events
                    inProgress.cancel();
                }
            }
        }
        if (current == null) {
            return;
        }
        safeToCancel = current.onTick();
        if (current.failed() || current.finished()) {
            current = null;
            if (goal == null || goal.isInGoal(ctx.playerFeet())) {
                logDebug("All done. At " + goal);
                queuePathEvent(PathEvent.AT_GOAL);
                next = null;
                if (Baritone.settings().disconnectOnArrival.getValue()) {
                    ctx.world().sendQuittingDisconnectingPacket();
                }
                return;
            }
            if (next != null && !next.getPath().positions().contains(ctx.playerFeet()) && !next.getPath().positions().contains(expectedSegmentStart)) {
                // can contain either one
                // if the current path failed, we may not actually be on the next one, so make sure
                logDebug("Discarding next path as it does not contain current position");
                // for example if we had a nicely planned ahead path that starts where current ends
                // that's all fine and good
                // but if we fail in the middle of current
                // we're nowhere close to our planned ahead path
                // so need to discard it sadly.
                queuePathEvent(PathEvent.DISCARD_NEXT);
                next = null;
            }
            if (next != null) {
                logDebug("Continuing on to planned next path");
                queuePathEvent(PathEvent.CONTINUING_ONTO_PLANNED_NEXT);
                current = next;
                next = null;
                // don't waste a tick doing nothing, get started right away
                current.onTick();
                return;
            }
            // at this point, current just ended, but we aren't in the goal and have no plan for the future
            synchronized (pathCalcLock) {
                if (inProgress != null) {
                    queuePathEvent(PathEvent.PATH_FINISHED_NEXT_STILL_CALCULATING);
                    return;
                }
                // we aren't calculating
                queuePathEvent(PathEvent.CALC_STARTED);
                findPathInNewThread(expectedSegmentStart, true, context);
            }
            return;
        }
        // at this point, we know current is in progress
        if (safeToCancel && next != null && next.snipsnapifpossible()) {
            // a movement just ended; jump directly onto the next path
            logDebug("Splicing into planned next path early...");
            queuePathEvent(PathEvent.SPLICING_ONTO_NEXT_EARLY);
            current = next;
            next = null;
            current.onTick();
            return;
        }
        if (Baritone.settings().splicePath.getValue()) {
            current = current.trySplice(next);
        }
        if (next != null && current.getPath().getDest().equals(next.getPath().getDest())) {
            next = null;
        }
        synchronized (pathCalcLock) {
            if (inProgress != null) {
                // if we aren't calculating right now
                return;
            }
            if (next != null) {
                // and we have no plan for what to do next
                return;
            }
            if (goal == null || goal.isInGoal(current.getPath().getDest())) {
                // and this path doesn't get us all the way there
                return;
            }
            if (ticksRemainingInSegment(false).get() < Baritone.settings().planningTickLookahead.getValue()) {
                // and this path has 7.5 seconds or less left
                // don't include the current movement so a very long last movement (e.g. descend) doesn't trip it up
                // if we actually included current, it wouldn't start planning ahead until the last movement was done, if the last movement took more than 7.5 seconds on its own
                logDebug("Path almost over. Planning ahead...");
                queuePathEvent(PathEvent.NEXT_SEGMENT_CALC_STARTED);
                findPathInNewThread(current.getPath().getDest(), false, context);
            }
        }
    }
}

Example 7 with IPath

use of baritone.api.pathing.calc.IPath in project baritone by cabaletta.

the class AbstractNodeCostSearch method bestSoFar.

protected Optional<IPath> bestSoFar(boolean logInfo, int numNodes) {
    if (startNode == null) {
        return Optional.empty();
    }
    double bestDist = 0;
    for (int i = 0; i < COEFFICIENTS.length; i++) {
        if (bestSoFar[i] == null) {
            continue;
        }
        double dist = getDistFromStartSq(bestSoFar[i]);
        if (dist > bestDist) {
            bestDist = dist;
        }
        if (dist > MIN_DIST_PATH * MIN_DIST_PATH) {
            // square the comparison since distFromStartSq is squared
            if (logInfo) {
                if (COEFFICIENTS[i] >= 3) {
                    System.out.println("Warning: cost coefficient is greater than three! Probably means that");
                    System.out.println("the path I found is pretty terrible (like sneak-bridging for dozens of blocks)");
                    System.out.println("But I'm going to do it anyway, because yolo");
                }
                System.out.println("Path goes for " + Math.sqrt(dist) + " blocks");
                logDebug("A* cost coefficient " + COEFFICIENTS[i]);
            }
            return Optional.of(new Path(startNode, bestSoFar[i], numNodes, goal, context));
        }
    }
    // if it actually won't find any path, don't make them think it will by rendering a dark blue that will never actually happen
    if (logInfo) {
        logDebug("Even with a cost coefficient of " + COEFFICIENTS[COEFFICIENTS.length - 1] + ", I couldn't get more than " + Math.sqrt(bestDist) + " blocks");
        logDebug("No path found =(");
        logNotification("No path found =(", true);
    }
    return Optional.empty();
}

Example 8 with IPath

use of baritone.api.pathing.calc.IPath in project baritone by cabaletta.

the class PathingBehavior method tickPath.

private void tickPath() {
    pausedThisTick = false;
    if (pauseRequestedLastTick && safeToCancel) {
        pauseRequestedLastTick = false;
        if (unpausedLastTick) {
            baritone.getInputOverrideHandler().clearAllKeys();
            baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
        }
        unpausedLastTick = false;
        pausedThisTick = true;
        return;
    }
    unpausedLastTick = true;
    if (cancelRequested) {
        cancelRequested = false;
        baritone.getInputOverrideHandler().clearAllKeys();
    }
    synchronized (pathPlanLock) {
        synchronized (pathCalcLock) {
            if (inProgress != null) {
                // we are calculating
                // are we calculating the right thing though? 🤔
                BetterBlockPos calcFrom = inProgress.getStart();
                Optional<IPath> currentBest = inProgress.bestPathSoFar();
                if (// if current ends in inProgress's start, then we're ok
                (current == null || !current.getPath().getDest().equals(calcFrom)) && !calcFrom.equals(ctx.playerFeet()) && // if current starts in our playerFeet or pathStart, then we're ok
                !calcFrom.equals(expectedSegmentStart) && // if
                (!currentBest.isPresent() || (!currentBest.get().positions().contains(ctx.playerFeet()) && !currentBest.get().positions().contains(expectedSegmentStart)))) {
                    // when it was *just* started, currentBest will be empty so we need to also check calcFrom since that's always present
                    // cancellation doesn't dispatch any events
                    inProgress.cancel();
                }
            }
        }
        if (current == null) {
            return;
        }
        safeToCancel = current.onTick();
        if (current.failed() || current.finished()) {
            current = null;
            if (goal == null || goal.isInGoal(ctx.playerFeet())) {
                logDebug("All done. At " + goal);
                queuePathEvent(PathEvent.AT_GOAL);
                next = null;
                if (Baritone.settings().disconnectOnArrival.value) {
                    ctx.world().sendQuittingDisconnectingPacket();
                }
                return;
            }
            if (next != null && !next.getPath().positions().contains(ctx.playerFeet()) && !next.getPath().positions().contains(expectedSegmentStart)) {
                // can contain either one
                // if the current path failed, we may not actually be on the next one, so make sure
                logDebug("Discarding next path as it does not contain current position");
                // for example if we had a nicely planned ahead path that starts where current ends
                // that's all fine and good
                // but if we fail in the middle of current
                // we're nowhere close to our planned ahead path
                // so need to discard it sadly.
                queuePathEvent(PathEvent.DISCARD_NEXT);
                next = null;
            }
            if (next != null) {
                logDebug("Continuing on to planned next path");
                queuePathEvent(PathEvent.CONTINUING_ONTO_PLANNED_NEXT);
                current = next;
                next = null;
                // don't waste a tick doing nothing, get started right away
                current.onTick();
                return;
            }
            // at this point, current just ended, but we aren't in the goal and have no plan for the future
            synchronized (pathCalcLock) {
                if (inProgress != null) {
                    queuePathEvent(PathEvent.PATH_FINISHED_NEXT_STILL_CALCULATING);
                    return;
                }
                // we aren't calculating
                queuePathEvent(PathEvent.CALC_STARTED);
                findPathInNewThread(expectedSegmentStart, true, context);
            }
            return;
        }
        // at this point, we know current is in progress
        if (safeToCancel && next != null && next.snipsnapifpossible()) {
            // a movement just ended; jump directly onto the next path
            logDebug("Splicing into planned next path early...");
            queuePathEvent(PathEvent.SPLICING_ONTO_NEXT_EARLY);
            current = next;
            next = null;
            current.onTick();
            return;
        }
        if (Baritone.settings().splicePath.value) {
            current = current.trySplice(next);
        }
        if (next != null && current.getPath().getDest().equals(next.getPath().getDest())) {
            next = null;
        }
        synchronized (pathCalcLock) {
            if (inProgress != null) {
                // if we aren't calculating right now
                return;
            }
            if (next != null) {
                // and we have no plan for what to do next
                return;
            }
            if (goal == null || goal.isInGoal(current.getPath().getDest())) {
                // and this path doesn't get us all the way there
                return;
            }
            if (ticksRemainingInSegment(false).get() < Baritone.settings().planningTickLookahead.value) {
                // and this path has 7.5 seconds or less left
                // don't include the current movement so a very long last movement (e.g. descend) doesn't trip it up
                // if we actually included current, it wouldn't start planning ahead until the last movement was done, if the last movement took more than 7.5 seconds on its own
                logDebug("Path almost over. Planning ahead...");
                queuePathEvent(PathEvent.NEXT_SEGMENT_CALC_STARTED);
                findPathInNewThread(current.getPath().getDest(), false, context);
            }
        }
    }
}