Add messages to more exceptions and improve some existing ones

ZacSharp · ZacSharp · commit 921822acd757 · 2025-04-18T00:58:16.000+02:00
diff --git a/src/api/java/baritone/api/pathing/goals/GoalRunAway.java b/src/api/java/baritone/api/pathing/goals/GoalRunAway.java
@@ -44,7 +44,7 @@ public GoalRunAway(double distance, BlockPos... from) {
 
     public GoalRunAway(double distance, Integer maintainY, BlockPos... from) {
         if (from.length == 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("Positions to run away from must not be empty");
         }
         this.from = from;
         this.distanceSq = (int) (distance * distance);
diff --git a/src/main/java/baritone/pathing/calc/AStarPathFinder.java b/src/main/java/baritone/pathing/calc/AStarPathFinder.java
@@ -122,17 +122,25 @@ protected Optional<IPath> calculate0(long primaryTimeout, long failureTimeout) {
                     continue;
                 }
                 if (actionCost <= 0 || Double.isNaN(actionCost)) {
-                    throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
+                    throw new IllegalStateException(String.format(
+                            "%s from %s %s %s calculated implausible cost %s",
+                            moves, currentNode.x, currentNode.y, currentNode.z, actionCost));
                 }
                 // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
                 if (moves.dynamicXZ && !worldBorder.entirelyContains(res.x, res.z)) { // see issue #218
                     continue;
                 }
                 if (!moves.dynamicXZ && (res.x != newX || res.z != newZ)) {
-                    throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
+                    throw new IllegalStateException(String.format(
+                            "%s from %s %s %s ended at x z %s %s instead of %s %s",
+                            moves, currentNode.x, currentNode.y, currentNode.z,
+                            res.x, res.z, newX, newZ));
                 }
                 if (!moves.dynamicY && res.y != currentNode.y + moves.yOffset) {
-                    throw new IllegalStateException(moves + " " + res.y + " " + (currentNode.y + moves.yOffset));
+                    throw new IllegalStateException(String.format(
+                            "%s from %s %s %s ended at y %s instead of %s",
+                            moves, currentNode.x, currentNode.y, currentNode.z,
+                            res.y, (currentNode.y + moves.yOffset)));
                 }
                 long hashCode = BetterBlockPos.longHash(res.x, res.y, res.z);
                 if (isFavoring) {
diff --git a/src/main/java/baritone/pathing/calc/Path.java b/src/main/java/baritone/pathing/calc/Path.java
@@ -112,7 +112,7 @@ public Goal getGoal() {
 
     private boolean assembleMovements() {
         if (path.isEmpty() || !movements.isEmpty()) {
-            throw new IllegalStateException();
+            throw new IllegalStateException("Path must not be empty");
         }
         for (int i = 0; i < path.size() - 1; i++) {
             double cost = nodes.get(i + 1).cost - nodes.get(i).cost;
@@ -145,7 +145,7 @@ private Movement runBackwards(BetterBlockPos src, BetterBlockPos dest, double co
     @Override
     public IPath postProcess() {
         if (verified) {
-            throw new IllegalStateException();
+            throw new IllegalStateException("Path must not be verified twice");
         }
         verified = true;
         boolean failed = assembleMovements();
@@ -154,7 +154,7 @@ public IPath postProcess() {
         if (failed) { // at least one movement became impossible during calculation
             CutoffPath res = new CutoffPath(this, movements().size());
             if (res.movements().size() != movements.size()) {
-                throw new IllegalStateException();
+                throw new IllegalStateException("Path has wrong size after cutoff");
             }
             return res;
         }
@@ -166,7 +166,8 @@ public IPath postProcess() {
     @Override
     public List<IMovement> movements() {
         if (!verified) {
-            throw new IllegalStateException();
+            // edge case note: this is called during verification
+            throw new IllegalStateException("Path not yet verified");
         }
         return Collections.unmodifiableList(movements);
     }
diff --git a/src/main/java/baritone/pathing/calc/PathNode.java b/src/main/java/baritone/pathing/calc/PathNode.java
@@ -68,7 +68,7 @@ public PathNode(int x, int y, int z, Goal goal) {
         this.cost = ActionCosts.COST_INF;
         this.estimatedCostToGoal = goal.heuristic(x, y, z);
         if (Double.isNaN(estimatedCostToGoal)) {
-            throw new IllegalStateException(goal + " calculated implausible heuristic");
+            throw new IllegalStateException(goal + " calculated implausible heuristic NaN at " + x + " " + y + " " + z);
         }
         this.heapPosition = -1;
         this.x = x;
diff --git a/src/main/java/baritone/pathing/calc/openset/BinaryHeapOpenSet.java b/src/main/java/baritone/pathing/calc/openset/BinaryHeapOpenSet.java
@@ -92,7 +92,7 @@ public final boolean isEmpty() {
     @Override
     public final PathNode removeLowest() {
         if (size == 0) {
-            throw new IllegalStateException();
+            throw new IllegalStateException("Cannot remove from empty heap");
         }
         PathNode result = array[1];
         PathNode val = array[size];
diff --git a/src/main/java/baritone/pathing/movement/Moves.java b/src/main/java/baritone/pathing/movement/Moves.java
@@ -347,7 +347,7 @@ public void apply(CalculationContext context, int x, int y, int z, MutableMoveRe
 
     public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {
         if (dynamicXZ || dynamicY) {
-            throw new UnsupportedOperationException();
+            throw new UnsupportedOperationException("Movements with dynamic offset must override `apply`");
         }
         result.x = x + xOffset;
         result.y = y + yOffset;
@@ -356,6 +356,6 @@ public void apply(CalculationContext context, int x, int y, int z, MutableMoveRe
     }
 
     public double cost(CalculationContext context, int x, int y, int z) {
-        throw new UnsupportedOperationException();
+        throw new UnsupportedOperationException("Movements must override `cost` or `apply`");
     }
 }
diff --git a/src/main/java/baritone/pathing/path/PathExecutor.java b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -455,7 +455,9 @@ private boolean shouldSprintNextTick() {
             if (data != null) {
                 BetterBlockPos fallDest = new BetterBlockPos(data.getB());
                 if (!path.positions().contains(fallDest)) {
-                    throw new IllegalStateException();
+                    throw new IllegalStateException(String.format(
+                            "Fall override at %s %s %s returned illegal destination %s %s %s",
+                            current.getSrc(), fallDest));
                 }
                 if (ctx.playerFeet().equals(fallDest)) {
                     pathPosition = path.positions().indexOf(fallDest);
@@ -603,7 +605,9 @@ public PathExecutor trySplice(PathExecutor next) {
         }
         return SplicedPath.trySplice(path, next.path, false).map(path -> {
             if (!path.getDest().equals(next.getPath().getDest())) {
-                throw new IllegalStateException();
+                throw new IllegalStateException(String.format(
+                        "Path has end %s instead of %s after splicing",
+                        path.getDest(), next.getPath().getDest()));
             }
             PathExecutor ret = new PathExecutor(behavior, path);
             ret.pathPosition = pathPosition;
@@ -619,7 +623,9 @@ private PathExecutor cutIfTooLong() {
             int cutoffAmt = Baritone.settings().pathHistoryCutoffAmount.value;
             CutoffPath newPath = new CutoffPath(path, cutoffAmt, path.length() - 1);
             if (!newPath.getDest().equals(path.getDest())) {
-                throw new IllegalStateException();
+                throw new IllegalStateException(String.format(
+                        "Path has end %s instead of %s after trimming its start",
+                        newPath.getDest(), path.getDest()));
             }
             logDebug("Discarding earliest segment movements, length cut from " + path.length() + " to " + newPath.length());
             PathExecutor ret = new PathExecutor(behavior, newPath);
diff --git a/src/main/java/baritone/pathing/path/SplicedPath.java b/src/main/java/baritone/pathing/path/SplicedPath.java
@@ -92,7 +92,7 @@ public static Optional<SplicedPath> trySplice(IPath first, IPath second, boolean
         }
         int positionInSecond = second.positions().indexOf(first.positions().get(firstPositionInSecond));
         if (!allowOverlapCutoff && positionInSecond != 0) {
-            throw new IllegalStateException();
+            throw new IllegalStateException("Paths to be spliced are overlapping incorrectly");
         }
         List<BetterBlockPos> positions = new ArrayList<>();
         List<IMovement> movements = new ArrayList<>();
diff --git a/src/main/java/baritone/process/BuilderProcess.java b/src/main/java/baritone/process/BuilderProcess.java
@@ -442,7 +442,7 @@ private static Vec3[] aabbSideMultipliers(Direction side) {
                 double z = side.getStepZ() == 0 ? 0.5 : (1 + side.getStepZ()) / 2D;
                 return new Vec3[]{new Vec3(x, 0.25, z), new Vec3(x, 0.75, z)};
             default: // null
-                throw new IllegalStateException();
+                throw new IllegalStateException("Unexpected side " + side);
         }
     }
 
diff --git a/src/main/java/baritone/process/CustomGoalProcess.java b/src/main/java/baritone/process/CustomGoalProcess.java
@@ -114,7 +114,7 @@ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
                 }
                 return new PathingCommand(this.goal, PathingCommandType.SET_GOAL_AND_PATH);
             default:
-                throw new IllegalStateException();
+                throw new IllegalStateException("Unexpected state " + this.state);
         }
     }
 
diff --git a/src/main/java/baritone/process/ExploreProcess.java b/src/main/java/baritone/process/ExploreProcess.java
@@ -118,7 +118,9 @@ private Goal[] closestUncachedChunks(BlockPos center, IChunkFilter filter) {
                     int dz = (mult * 2 - 1) * zval; // dz can be either -zval or zval
                     int trueDist = Math.abs(dx) + Math.abs(dz);
                     if (trueDist != dist) {
-                        throw new IllegalStateException();
+                        throw new IllegalStateException(String.format(
+                                "Offset %s %s has distance %s, expected %s",
+                                dx, dz, trueDist, dist));
                     }
                     switch (filter.isAlreadyExplored(chunkX + dx, chunkZ + dz)) {
                         case UNKNOWN:
diff --git a/src/main/java/baritone/utils/BlockStateInterface.java b/src/main/java/baritone/utils/BlockStateInterface.java
@@ -70,7 +70,7 @@ public BlockStateInterface(IPlayerContext ctx, boolean copyLoadedChunks) {
         }
         this.useTheRealWorld = !Baritone.settings().pathThroughCachedOnly.value;
         if (!ctx.minecraft().isSameThread()) {
-            throw new IllegalStateException();
+            throw new IllegalStateException("BlockStateInterface must be constructed on the main thread");
         }
         this.isPassableBlockPos = new BlockPos.MutableBlockPos();
         this.access = new BlockStateInterfaceAccessWrapper(this);
diff --git a/src/main/java/baritone/utils/PathingControlManager.java b/src/main/java/baritone/utils/PathingControlManager.java
@@ -68,7 +68,7 @@ public void cancelEverything() { // called by PathingBehavior on TickEvent Type
         for (IBaritoneProcess proc : processes) {
             proc.onLostControl();
             if (proc.isActive() && !proc.isTemporary()) { // it's okay only for a temporary thing (like combat pause) to maintain control even if you say to cancel
-                throw new IllegalStateException(proc.displayName());
+                throw new IllegalStateException(proc.displayName() + " stayed active after being cancelled");
             }
         }
     }
@@ -121,7 +121,7 @@ public void preTick() {
                 }
                 break;
             default:
-                throw new IllegalStateException();
+                throw new IllegalStateException("Unexpected command type " + command.commandType);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public GoalRunAway(double distance, BlockPos... from) {`
`44`	`44`
`45`	`45`	`public GoalRunAway(double distance, Integer maintainY, BlockPos... from) {`
`46`	`46`	`if (from.length == 0) {`
`47`		`- throw new IllegalArgumentException();`
	`47`	`+ throw new IllegalArgumentException("Positions to run away from must not be empty");`
`48`	`48`	`}`
`49`	`49`	`this.from = from;`
`50`	`50`	`this.distanceSq = (int) (distance * distance);`
Original file line number	Diff line number	Diff line change
`@@ -122,17 +122,25 @@ protected Optional<IPath> calculate0(long primaryTimeout, long failureTimeout) {`
`122`	`122`	`continue;`
`123`	`123`	`}`
`124`	`124`	`if (actionCost <= 0 \|\| Double.isNaN(actionCost)) {`
`125`		`- throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);`
	`125`	`+ throw new IllegalStateException(String.format(`
	`126`	`+ "%s from %s %s %s calculated implausible cost %s",`
	`127`	`+ moves, currentNode.x, currentNode.y, currentNode.z, actionCost));`
`126`	`128`	`}`
`127`	`129`	`// check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation`
`128`	`130`	`if (moves.dynamicXZ && !worldBorder.entirelyContains(res.x, res.z)) { // see issue #218`
`129`	`131`	`continue;`
`130`	`132`	`}`
`131`	`133`	`if (!moves.dynamicXZ && (res.x != newX \|\| res.z != newZ)) {`
`132`		`- throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);`
	`134`	`+ throw new IllegalStateException(String.format(`
	`135`	`+ "%s from %s %s %s ended at x z %s %s instead of %s %s",`
	`136`	`+ moves, currentNode.x, currentNode.y, currentNode.z,`
	`137`	`+ res.x, res.z, newX, newZ));`
`133`	`138`	`}`
`134`	`139`	`if (!moves.dynamicY && res.y != currentNode.y + moves.yOffset) {`
`135`		`- throw new IllegalStateException(moves + " " + res.y + " " + (currentNode.y + moves.yOffset));`
	`140`	`+ throw new IllegalStateException(String.format(`
	`141`	`+ "%s from %s %s %s ended at y %s instead of %s",`
	`142`	`+ moves, currentNode.x, currentNode.y, currentNode.z,`
	`143`	`+ res.y, (currentNode.y + moves.yOffset)));`
`136`	`144`	`}`
`137`	`145`	`long hashCode = BetterBlockPos.longHash(res.x, res.y, res.z);`
`138`	`146`	`if (isFavoring) {`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ public Goal getGoal() {`
`112`	`112`
`113`	`113`	`private boolean assembleMovements() {`
`114`	`114`	`if (path.isEmpty() \|\| !movements.isEmpty()) {`
`115`		`- throw new IllegalStateException();`
	`115`	`+ throw new IllegalStateException("Path must not be empty");`
`116`	`116`	`}`
`117`	`117`	`for (int i = 0; i < path.size() - 1; i++) {`
`118`	`118`	`double cost = nodes.get(i + 1).cost - nodes.get(i).cost;`
`@@ -145,7 +145,7 @@ private Movement runBackwards(BetterBlockPos src, BetterBlockPos dest, double co`
`145`	`145`	`@Override`
`146`	`146`	`public IPath postProcess() {`
`147`	`147`	`if (verified) {`
`148`		`- throw new IllegalStateException();`
	`148`	`+ throw new IllegalStateException("Path must not be verified twice");`
`149`	`149`	`}`
`150`	`150`	`verified = true;`
`151`	`151`	`boolean failed = assembleMovements();`
`@@ -154,7 +154,7 @@ public IPath postProcess() {`
`154`	`154`	`if (failed) { // at least one movement became impossible during calculation`
`155`	`155`	`CutoffPath res = new CutoffPath(this, movements().size());`
`156`	`156`	`if (res.movements().size() != movements.size()) {`
`157`		`- throw new IllegalStateException();`
	`157`	`+ throw new IllegalStateException("Path has wrong size after cutoff");`
`158`	`158`	`}`
`159`	`159`	`return res;`
`160`	`160`	`}`
`@@ -166,7 +166,8 @@ public IPath postProcess() {`
`166`	`166`	`@Override`
`167`	`167`	`public List<IMovement> movements() {`
`168`	`168`	`if (!verified) {`
`169`		`- throw new IllegalStateException();`
	`169`	`+ // edge case note: this is called during verification`
	`170`	`+ throw new IllegalStateException("Path not yet verified");`
`170`	`171`	`}`
`171`	`172`	`return Collections.unmodifiableList(movements);`
`172`	`173`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public PathNode(int x, int y, int z, Goal goal) {`
`68`	`68`	`this.cost = ActionCosts.COST_INF;`
`69`	`69`	`this.estimatedCostToGoal = goal.heuristic(x, y, z);`
`70`	`70`	`if (Double.isNaN(estimatedCostToGoal)) {`
`71`		`- throw new IllegalStateException(goal + " calculated implausible heuristic");`
	`71`	`+ throw new IllegalStateException(goal + " calculated implausible heuristic NaN at " + x + " " + y + " " + z);`
`72`	`72`	`}`
`73`	`73`	`this.heapPosition = -1;`
`74`	`74`	`this.x = x;`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ public final boolean isEmpty() {`
`92`	`92`	`@Override`
`93`	`93`	`public final PathNode removeLowest() {`
`94`	`94`	`if (size == 0) {`
`95`		`- throw new IllegalStateException();`
	`95`	`+ throw new IllegalStateException("Cannot remove from empty heap");`
`96`	`96`	`}`
`97`	`97`	`PathNode result = array[1];`
`98`	`98`	`PathNode val = array[size];`
Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ public void apply(CalculationContext context, int x, int y, int z, MutableMoveRe`
`347`	`347`
`348`	`348`	`public void apply(CalculationContext context, int x, int y, int z, MutableMoveResult result) {`
`349`	`349`	`if (dynamicXZ \|\| dynamicY) {`
`350`		`- throw new UnsupportedOperationException();`
	`350`	+ throw new UnsupportedOperationException("Movements with dynamic offset must override `apply`");
`351`	`351`	`}`
`352`	`352`	`result.x = x + xOffset;`
`353`	`353`	`result.y = y + yOffset;`
`@@ -356,6 +356,6 @@ public void apply(CalculationContext context, int x, int y, int z, MutableMoveRe`
`356`	`356`	`}`
`357`	`357`
`358`	`358`	`public double cost(CalculationContext context, int x, int y, int z) {`
`359`		`- throw new UnsupportedOperationException();`
	`359`	+ throw new UnsupportedOperationException("Movements must override `cost` or `apply`");
`360`	`360`	`}`
`361`	`361`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ public static Optional<SplicedPath> trySplice(IPath first, IPath second, boolean`
`92`	`92`	`}`
`93`	`93`	`int positionInSecond = second.positions().indexOf(first.positions().get(firstPositionInSecond));`
`94`	`94`	`if (!allowOverlapCutoff && positionInSecond != 0) {`
`95`		`- throw new IllegalStateException();`
	`95`	`+ throw new IllegalStateException("Paths to be spliced are overlapping incorrectly");`
`96`	`96`	`}`
`97`	`97`	`List<BetterBlockPos> positions = new ArrayList<>();`
`98`	`98`	`List<IMovement> movements = new ArrayList<>();`
Original file line number	Diff line number	Diff line change
`@@ -442,7 +442,7 @@ private static Vec3[] aabbSideMultipliers(Direction side) {`
`442`	`442`	`double z = side.getStepZ() == 0 ? 0.5 : (1 + side.getStepZ()) / 2D;`
`443`	`443`	`return new Vec3[]{new Vec3(x, 0.25, z), new Vec3(x, 0.75, z)};`
`444`	`444`	`default: // null`
`445`		`- throw new IllegalStateException();`
	`445`	`+ throw new IllegalStateException("Unexpected side " + side);`
`446`	`446`	`}`
`447`	`447`	`}`
`448`	`448`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {`
`114`	`114`	`}`
`115`	`115`	`return new PathingCommand(this.goal, PathingCommandType.SET_GOAL_AND_PATH);`
`116`	`116`	`default:`
`117`		`- throw new IllegalStateException();`
	`117`	`+ throw new IllegalStateException("Unexpected state " + this.state);`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ public BlockStateInterface(IPlayerContext ctx, boolean copyLoadedChunks) {`
`70`	`70`	`}`
`71`	`71`	`this.useTheRealWorld = !Baritone.settings().pathThroughCachedOnly.value;`
`72`	`72`	`if (!ctx.minecraft().isSameThread()) {`
`73`		`- throw new IllegalStateException();`
	`73`	`+ throw new IllegalStateException("BlockStateInterface must be constructed on the main thread");`
`74`	`74`	`}`
`75`	`75`	`this.isPassableBlockPos = new BlockPos.MutableBlockPos();`
`76`	`76`	`this.access = new BlockStateInterfaceAccessWrapper(this);`