Elytra in overworld

gradle.properties

@@ -12,7 +12,7 @@ forge_version=45.0.43
 
 fabric_version=0.14.11
 
-nether_pathfinder_version=1.4.1
+nether_pathfinder_version=1.6
 
 // These dependencies are used for common and tweaker
 // while mod loaders usually ship their own version

src/api/java/baritone/api/Settings.java

@@ -1543,6 +1543,26 @@ public final class Settings {
      */
     public final Setting<Boolean> elytraChatSpam = new Setting<>(false);
 
+    /**
+     * May reduce memory usage by using a custom allocator for pathfinding
+     */
+    public final Setting<Boolean> elytraCustomAllocator = new Setting<>(false);
+
+    /**
+     * Allow the pathfinder to attempt flight in tighter spaces, useful in caves but can be dangerous.
+     */
+    public final Setting<Boolean> elytraAllowTightSpaces = new Setting<>(false);
+
+    /**
+     * Allow the pathfinder to fly above y 128 in the nether.
+     */
+    public final Setting<Boolean> elytraAllowAboveRoof = new Setting<>(false);
+
+    /**
+     * Allow the pathfinder to access the baritone cache to improve pathing
+     */
+    public final Setting<Boolean> elytraUseBaritoneCache = new Setting<>(true);
+
     /**
      * A map of lowercase setting field names to their respective setting
      */

src/main/java/baritone/command/defaults/ElytraCommand.java

@@ -71,9 +71,6 @@ public void execute(String label, IArgConsumer args) throws CommandException {
             if (iGoal == null) {
                 throw new CommandInvalidStateException("No goal has been set");
             }
-            if (ctx.world().dimension() != Level.NETHER) {
-                throw new CommandInvalidStateException("Only works in the nether");
-            }
             try {
                 elytra.pathTo(iGoal);
             } catch (IllegalArgumentException ex) {

src/main/java/baritone/process/ElytraProcess.java

@@ -54,6 +54,8 @@
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.levelgen.Heightmap;
 import net.minecraft.world.phys.Vec3;
 
 import java.util.*;
@@ -178,7 +180,7 @@ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
                 Rotation rotation = RotationUtils.calcRotationFromVec3d(from, to, ctx.playerRotations());
                 baritone.getLookBehavior().updateTarget(new Rotation(rotation.getYaw(), 0), false); // this will be overwritten, probably, by behavior tick
 
-                if (ctx.player().position().y < endPos.y - LANDING_COLUMN_HEIGHT) {
+                if (ctx.player().position().y < endPos.y - this.landingColumnHeight) {
                     logDirect("bad landing spot, trying again...");
                     landingSpotIsBad(endPos);
                 }
@@ -189,7 +191,12 @@ public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
             behavior.landingMode = this.state == State.LANDING;
             this.goal = null;
             baritone.getInputOverrideHandler().clearAllKeys();
-            behavior.tick();
+            behavior.context.readLock.lock();
+            try {
+                behavior.tick();
+            } finally {
+                behavior.context.readLock.unlock();
+            }
             return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
         } else if (this.state == State.LANDING) {
             if (ctx.playerMotion().multiply(1, 0, 1).length() > 0.001) {
@@ -322,11 +329,11 @@ public void pathTo(BlockPos destination) {
     }
 
     private void pathTo0(BlockPos destination, boolean appendDestination) {
-        if (ctx.player() == null || ctx.player().level.dimension() != Level.NETHER) {
+        if (ctx.player() == null) {
             return;
         }
         this.onLostControl();
-        this.predictingTerrain = Baritone.settings().elytraPredictTerrain.value;
+        this.predictingTerrain = ctx.player().level.dimension() == Level.NETHER && Baritone.settings().elytraPredictTerrain.value;
         this.behavior = new ElytraBehavior(this.baritone, this, destination, appendDestination);
         if (ctx.world() != null) {
             this.behavior.repackChunks();
@@ -342,6 +349,7 @@ public void pathTo(Goal iGoal) {
         if (iGoal instanceof GoalXZ) {
             GoalXZ goal = (GoalXZ) iGoal;
             x = goal.getX();
+            // ElytraBehavior will automatically change the destination height depending on if we're above or below the roof
             y = 64;
             z = goal.getZ();
         } else if (iGoal instanceof GoalBlock) {
@@ -352,9 +360,18 @@ public void pathTo(Goal iGoal) {
         } else {
             throw new IllegalArgumentException("The goal must be a GoalXZ or GoalBlock");
         }
-        if (y <= 0 || y >= 128) {
-            throw new IllegalArgumentException("The y of the goal is not between 0 and 128");
+
+        int minY = ctx.world().dimensionType().minY();
+        int maxY = (ctx.world().dimension() == Level.NETHER && !Baritone.settings().elytraAllowAboveRoof.value) ? 127 : Math.min(minY + 384, ctx.world().dimensionType().height() + minY);
+        if (y < minY || y >= maxY) {
+            throw new IllegalArgumentException("The goal must have a y value between " + minY + " and " + maxY);
+        }
+
+        int playerY = (int)ctx.player().getY();
+        if (playerY < minY || playerY >= maxY) {
+            throw new IllegalArgumentException("The player must have a y value between " + minY + " and " + maxY);
         }
+
         this.pathTo(new BlockPos(x, y, z));
     }
 
@@ -465,12 +482,20 @@ public double placeBucketCost() {
         }
     }
 
-    private static boolean isInBounds(BlockPos pos) {
-        return pos.getY() >= 0 && pos.getY() < 128;
+    private static boolean isInBounds(Level dim, BlockPos pos) {
+        // TODO: Optionally limit nether to just y=127
+        DimensionType dimType = dim.dimensionType();
+        int minY = dimType.minY();
+        int maxY = Math.min(minY + 384, dimType.height() + minY);
+        return pos.getY() >= minY && pos.getY() < maxY;
     }
 
     private boolean isSafeBlock(Block block) {
-        return block == Blocks.NETHERRACK || block == Blocks.GRAVEL || (block == Blocks.NETHER_BRICKS && Baritone.settings().elytraAllowLandOnNetherFortress.value);
+        return block == Blocks.NETHERRACK || block == Blocks.GRAVEL || block == Blocks.SOUL_SAND || block == Blocks.SOUL_SOIL || (block == Blocks.NETHER_BRICKS && Baritone.settings().elytraAllowLandOnNetherFortress.value)
+                || block == Blocks.STONE || block == Blocks.DEEPSLATE || block == Blocks.GRASS_BLOCK || block == Blocks.SAND || block == Blocks.RED_SAND || block == Blocks.TERRACOTTA
+                || block == Blocks.SNOW || block == Blocks.ICE || block == Blocks.MYCELIUM || block == Blocks.PODZOL
+                || block == Blocks.DARK_OAK_LEAVES || block == Blocks.JUNGLE_LEAVES
+                || block == Blocks.END_STONE || block == Blocks.BEDROCK;
     }
 
     private boolean isSafeBlock(BlockPos pos) {
@@ -520,7 +545,7 @@ private boolean hasAirBubble(BlockPos pos) {
 
     private BetterBlockPos checkLandingSpot(BlockPos pos, LongOpenHashSet checkedSpots) {
         BlockPos.MutableBlockPos mut = new BlockPos.MutableBlockPos(pos.getX(), pos.getY(), pos.getZ());
-        while (mut.getY() >= 0) {
+        while (mut.getY() >= ctx.world().dimensionType().minY()) {
             if (checkedSpots.contains(mut.asLong())) {
                 return null;
             }
@@ -540,21 +565,34 @@ private BetterBlockPos checkLandingSpot(BlockPos pos, LongOpenHashSet checkedSpo
         return null; // void
     }
 
-    private static final int LANDING_COLUMN_HEIGHT = 15;
+    private static final int SHORT_LANDING_COLUMN_HEIGHT = 15;
+    private static final int LONG_LANDING_COLUMN_HEIGHT = 39;
+    private int landingColumnHeight = SHORT_LANDING_COLUMN_HEIGHT;
     private Set<BetterBlockPos> badLandingSpots = new HashSet<>();
 
     private BetterBlockPos findSafeLandingSpot(BetterBlockPos start) {
+        if(ctx.player().getY() > ctx.world().getHeight(Heightmap.Types.MOTION_BLOCKING, start.getX(), start.getZ())) {
+            return findSafeLandingSpot_heightmap(start);
+        } else {
+            return findSafeLandingSpot_underground(start);
+        }
+    }
+
+    private BetterBlockPos findSafeLandingSpot_underground(BetterBlockPos start) {
         Queue<BetterBlockPos> queue = new PriorityQueue<>(Comparator.<BetterBlockPos>comparingInt(pos -> (pos.x - start.x) * (pos.x - start.x) + (pos.z - start.z) * (pos.z - start.z)).thenComparingInt(pos -> -pos.y));
         Set<BetterBlockPos> visited = new HashSet<>();
         LongOpenHashSet checkedPositions = new LongOpenHashSet();
         queue.add(start);
 
         while (!queue.isEmpty()) {
             BetterBlockPos pos = queue.poll();
-            if (ctx.world().isLoaded(pos) && isInBounds(pos) && ctx.world().getBlockState(pos).getBlock() == Blocks.AIR) {
+            if (ctx.world().isLoaded(pos) && isInBounds(ctx.world(), pos) && ctx.world().getBlockState(pos).getBlock() == Blocks.AIR) {
                 BetterBlockPos actualLandingSpot = checkLandingSpot(pos, checkedPositions);
-                if (actualLandingSpot != null && isColumnAir(actualLandingSpot, LANDING_COLUMN_HEIGHT) && hasAirBubble(actualLandingSpot.above(LANDING_COLUMN_HEIGHT)) && !badLandingSpots.contains(actualLandingSpot.above(LANDING_COLUMN_HEIGHT))) {
-                    return actualLandingSpot.above(LANDING_COLUMN_HEIGHT);
+                if(actualLandingSpot != null) {
+                    landingColumnHeight = SHORT_LANDING_COLUMN_HEIGHT;
+                    if (isColumnAir(actualLandingSpot, this.landingColumnHeight) && hasAirBubble(actualLandingSpot.above(this.landingColumnHeight)) && !badLandingSpots.contains(actualLandingSpot.above(this.landingColumnHeight))) {
+                        return actualLandingSpot.above(this.landingColumnHeight);
+                    }
                 }
                 if (visited.add(pos.north())) queue.add(pos.north());
                 if (visited.add(pos.east())) queue.add(pos.east());
@@ -566,4 +604,34 @@ private BetterBlockPos findSafeLandingSpot(BetterBlockPos start) {
         }
         return null;
     }
+
+    private BetterBlockPos findSafeLandingSpot_heightmap(BetterBlockPos start) {
+        Queue<BetterBlockPos> queue = new PriorityQueue<>(Comparator.<BetterBlockPos>comparingInt(pos -> (pos.x - start.x) * (pos.x - start.x) + (pos.z - start.z) * (pos.z - start.z)).thenComparingInt(pos -> -pos.y));
+        Set<BetterBlockPos> visited = new HashSet<>();
+        LongOpenHashSet checkedPositions = new LongOpenHashSet();
+        queue.add(start);
+
+        while (!queue.isEmpty()) {
+            BetterBlockPos qPos = queue.poll();
+            if (!ctx.world().isLoaded(qPos)) continue;
+
+            var height = ctx.world().getHeight(Heightmap.Types.MOTION_BLOCKING, qPos.getX(), qPos.getZ());
+            var pos = new BetterBlockPos(qPos.getX(), height+1, qPos.getZ());
+            if (ctx.world().isLoaded(pos) && isInBounds(ctx.world(), pos) && ctx.world().getBlockState(pos).getBlock() == Blocks.AIR) {
+                BetterBlockPos actualLandingSpot = checkLandingSpot(pos, checkedPositions);
+                if(actualLandingSpot != null) {
+                    landingColumnHeight = ctx.playerFeet().y - actualLandingSpot.y < LONG_LANDING_COLUMN_HEIGHT ? SHORT_LANDING_COLUMN_HEIGHT : LONG_LANDING_COLUMN_HEIGHT;
+                    if (hasAirBubble(actualLandingSpot.above(landingColumnHeight)) && !badLandingSpots.contains(actualLandingSpot.above(landingColumnHeight))) {
+                        return actualLandingSpot.above(landingColumnHeight);
+                    }
+                }
+
+                if (visited.add(pos.north())) queue.add(pos.north());
+                if (visited.add(pos.east())) queue.add(pos.east());
+                if (visited.add(pos.south())) queue.add(pos.south());
+                if (visited.add(pos.west())) queue.add(pos.west());
+            }
+        }
+        return null;
+    }
 }

src/main/java/baritone/process/elytra/BlockStateOctreeInterface.java

@@ -39,16 +39,16 @@ public BlockStateOctreeInterface(final NetherPathfinderContext context) {
     }
 
     public boolean get0(final int x, final int y, final int z) {
-        if ((y | (127 - y)) < 0) {
+        if (y < 0 || y > 383) {
             return false;
         }
         final int chunkX = x >> 4;
         final int chunkZ = z >> 4;
         if (this.chunkPtr == 0 | ((chunkX ^ this.prevChunkX) | (chunkZ ^ this.prevChunkZ)) != 0) {
             this.prevChunkX = chunkX;
             this.prevChunkZ = chunkZ;
-            this.chunkPtr = NetherPathfinder.getOrCreateChunk(this.contextPtr, chunkX, chunkZ);
+            this.chunkPtr = NetherPathfinder.getChunkOrDefault(this.contextPtr, chunkX, chunkZ, true);
         }
-        return Octree.getBlock(this.chunkPtr, x & 0xF, y & 0x7F, z & 0xF);
+        return Octree.getBlock(this.chunkPtr, x & 0xF, y, z & 0xF);
     }
 }