Merge 1.19.4 into 1.20.5

build.gradle

@@ -78,11 +78,9 @@ allprojects {
     }
 
     dependencies {
-        compileOnly "org.spongepowered:mixin:0.8"
-        compileOnly "org.ow2.asm:asm:9.7"
-        // The following line declares the yarn mappings you may select this one as well.
-        // mappings "net.fabricmc:yarn:1.17.1+build.32:v2"
-        //launchImplementation('dev.babbaj:nether-pathfinder:1.3.0')
+        compileOnly "org.spongepowered:mixin:${project.mixin_version}"
+        compileOnly "org.ow2.asm:asm:${project.asm_version}"
+
         implementation "dev.babbaj:nether-pathfinder:${project.nether_pathfinder_version}"
 
         implementation 'com.google.code.findbugs:jsr305:3.0.2'

gradle.properties

@@ -17,3 +17,8 @@ neoforge_version=43-beta
 fabric_version=0.15.11
 
 nether_pathfinder_version=1.4.1
+
+// These dependencies are used for common and tweaker
+// while mod loaders usually ship their own version
+mixin_version=0.8.5
+asm_version=9.7

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

@@ -29,6 +29,9 @@
 import net.minecraft.world.item.Item;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.Mirror;
+import net.minecraft.world.level.block.Rotation;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -1089,6 +1092,28 @@ public final class Settings {
      */
     public final Setting<Boolean> schematicOrientationZ = new Setting<>(false);
 
+    /**
+     * Rotates the schematic before building it.
+     * Possible values are
+     * <ul>
+     *  <li> NONE - No rotation </li>
+     *  <li> CLOCKWISE_90 - Rotate 90° clockwise </li>
+     *  <li> CLOCKWISE_180 - Rotate 180° clockwise </li>
+     *  <li> COUNTERCLOCKWISE_90 - Rotate 270° clockwise </li>
+     * </ul>
+     */
+    public final Setting<Rotation> buildSchematicRotation = new Setting<>(Rotation.NONE);
+
+    /**
+     * Mirrors the schematic before building it.
+     * Possible values are
+     * <ul>
+     *  <li> FRONT_BACK - mirror the schematic along its local x axis </li>
+     *  <li> LEFT_RIGHT - mirror the schematic along its local z axis </li>
+     * </ul>
+     */
+    public final Setting<Mirror> buildSchematicMirror = new Setting<>(Mirror.NONE);
+
     /**
      * The fallback used by the build command when no extension is specified. This may be useful if schematics of a
      * particular format are used often, and the user does not wish to have to specify the extension with every usage.

src/api/java/baritone/api/schematic/MirroredSchematic.java

@@ -0,0 +1,114 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.Mirror;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class MirroredSchematic implements ISchematic {
+
+    private final ISchematic schematic;
+    private final Mirror mirror;
+
+    public MirroredSchematic(ISchematic schematic, Mirror mirror) {
+        this.schematic = schematic;
+        this.mirror = mirror;
+    }
+
+    @Override
+    public boolean inSchematic(int x, int y, int z, BlockState currentState) {
+        return schematic.inSchematic(
+                mirrorX(x, widthX(), mirror),
+                y,
+                mirrorZ(z, lengthZ(), mirror),
+                mirror(currentState, mirror)
+        );
+    }
+
+    @Override
+    public BlockState desiredState(int x, int y, int z, BlockState current, List<BlockState> approxPlaceable) {
+        return mirror(schematic.desiredState(
+                mirrorX(x, widthX(), mirror),
+                y,
+                mirrorZ(z, lengthZ(), mirror),
+                mirror(current, mirror),
+                mirror(approxPlaceable, mirror)
+        ), mirror);
+    }
+
+    @Override
+    public void reset() {
+        schematic.reset();
+    }
+
+    @Override
+    public int widthX() {
+        return schematic.widthX();
+    }
+
+    @Override
+    public int heightY() {
+        return schematic.heightY();
+    }
+
+    @Override
+    public int lengthZ() {
+        return schematic.lengthZ();
+    }
+
+    private static int mirrorX(int x, int sizeX, Mirror mirror) {
+        switch (mirror) {
+            case NONE:
+            case LEFT_RIGHT:
+                return x;
+            case FRONT_BACK:
+                return sizeX - x - 1;
+        }
+        throw new IllegalArgumentException("Unknown mirror");
+    }
+
+    private static int mirrorZ(int z, int sizeZ, Mirror mirror) {
+        switch (mirror) {
+            case NONE:
+            case FRONT_BACK:
+                return z;
+            case LEFT_RIGHT:
+                return sizeZ - z - 1;
+        }
+        throw new IllegalArgumentException("Unknown mirror");
+    }
+
+    private static BlockState mirror(BlockState state, Mirror mirror) {
+        if (state == null) {
+            return null;
+        }
+        return state.mirror(mirror);
+    }
+
+    private static List<BlockState> mirror(List<BlockState> states, Mirror mirror) {
+        if (states == null) {
+            return null;
+        }
+        return states.stream()
+                .map(s -> mirror(s, mirror))
+                .collect(Collectors.toList());
+    }
+}

src/api/java/baritone/api/schematic/RotatedSchematic.java

@@ -0,0 +1,136 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.api.schematic;
+
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.Rotation;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class RotatedSchematic implements ISchematic {
+
+    private final ISchematic schematic;
+    private final Rotation rotation;
+    private final Rotation inverseRotation;
+
+    public RotatedSchematic(ISchematic schematic, Rotation rotation) {
+        this.schematic = schematic;
+        this.rotation = rotation;
+        // I don't think a 14 line switch would improve readability
+        this.inverseRotation = rotation.getRotated(rotation).getRotated(rotation);
+    }
+
+    @Override
+    public boolean inSchematic(int x, int y, int z, BlockState currentState) {
+        return schematic.inSchematic(
+                rotateX(x, z, widthX(), lengthZ(), inverseRotation),
+                y,
+                rotateZ(x, z, widthX(), lengthZ(), inverseRotation),
+                rotate(currentState, inverseRotation)
+        );
+    }
+
+    @Override
+    public BlockState desiredState(int x, int y, int z, BlockState current, List<BlockState> approxPlaceable) {
+        return rotate(schematic.desiredState(
+                rotateX(x, z, widthX(), lengthZ(), inverseRotation),
+                y,
+                rotateZ(x, z, widthX(), lengthZ(), inverseRotation),
+                rotate(current, inverseRotation),
+                rotate(approxPlaceable, inverseRotation)
+        ), rotation);
+    }
+
+    @Override
+    public void reset() {
+        schematic.reset();
+    }
+
+    @Override
+    public int widthX() {
+        return flipsCoordinates(rotation) ? schematic.lengthZ() : schematic.widthX();
+    }
+
+    @Override
+    public int heightY() {
+        return schematic.heightY();
+    }
+
+    @Override
+    public int lengthZ() {
+        return flipsCoordinates(rotation) ? schematic.widthX() : schematic.lengthZ();
+    }
+
+    /**
+     * Wether {@code rotation} swaps the x and z components
+     */
+    private static boolean flipsCoordinates(Rotation rotation) {
+        return rotation == Rotation.CLOCKWISE_90 || rotation == Rotation.COUNTERCLOCKWISE_90;
+    }
+
+    /**
+     * The x component of x,y after applying the rotation
+     */
+    private static int rotateX(int x, int z, int sizeX, int sizeZ, Rotation rotation) {
+        switch (rotation) {
+            case NONE:
+                return x;
+            case CLOCKWISE_90:
+                return sizeZ - z - 1;
+            case CLOCKWISE_180:
+                return sizeX - x - 1;
+            case COUNTERCLOCKWISE_90:
+                return z;
+        }
+        throw new IllegalArgumentException("Unknown rotation");
+    }
+
+    /**
+     * The z component of x,y after applying the rotation
+     */
+    private static int rotateZ(int x, int z, int sizeX, int sizeZ, Rotation rotation) {
+        switch (rotation) {
+            case NONE:
+                return z;
+            case CLOCKWISE_90:
+                return x;
+            case CLOCKWISE_180:
+                return sizeZ - z - 1;
+            case COUNTERCLOCKWISE_90:
+                return sizeX - x - 1;
+        }
+        throw new IllegalArgumentException("Unknown rotation");
+    }
+
+    private static BlockState rotate(BlockState state, Rotation rotation) {
+        if (state == null) {
+            return null;
+        }
+        return state.rotate(rotation);
+    }
+
+    private static List<BlockState> rotate(List<BlockState> states, Rotation rotation) {
+        if (states == null) {
+            return null;
+        }
+        return states.stream()
+                .map(s -> rotate(s, rotation))
+                .collect(Collectors.toList());
+    }
+}

src/api/java/baritone/api/utils/SettingsUtil.java

@@ -27,6 +27,9 @@
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Mirror;
+import net.minecraft.world.level.block.Rotation;
+
 import java.awt.*;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
@@ -220,7 +223,8 @@ private enum Parser implements ISettingParser {
         FLOAT(Float.class, Float::parseFloat),
         LONG(Long.class, Long::parseLong),
         STRING(String.class, String::new),
-        DIRECTION(Direction.class, Direction::byName),
+        MIRROR(Mirror.class, Mirror::valueOf, Mirror::name),
+        ROTATION(Rotation.class, Rotation::valueOf, Rotation::name),
         COLOR(
                 Color.class,
                 str -> new Color(Integer.parseInt(str.split(",")[0]), Integer.parseInt(str.split(",")[1]), Integer.parseInt(str.split(",")[2])),

src/main/java/baritone/behavior/PathingBehavior.java

@@ -265,7 +265,7 @@ public boolean secretInternalSetGoalAndPath(PathingCommand command) {
         if (goal == null) {
             return false;
         }
-        if (goal.isInGoal(ctx.playerFeet()) || goal.isInGoal(expectedSegmentStart)) {
+        if (goal.isInGoal(ctx.playerFeet())) {
             return false;
         }
         synchronized (pathPlanLock) {
@@ -553,7 +553,7 @@ private void findPathInNewThread(final BlockPos start, final boolean talkAboutIt
         });
     }
 
-    private static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
+    private AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal, IPath previous, CalculationContext context) {
         Goal transformed = goal;
         if (Baritone.settings().simplifyUnloadedYCoord.value && goal instanceof IGoalRenderPos) {
             BlockPos pos = ((IGoalRenderPos) goal).getGoalPos();
@@ -562,7 +562,14 @@ private static AbstractNodeCostSearch createPathfinder(BlockPos start, Goal goal
             }
         }
         Favoring favoring = new Favoring(context.getBaritone().getPlayerContext(), previous, context);
-        return new AStarPathFinder(start.getX(), start.getY(), start.getZ(), transformed, favoring, context);
+        BetterBlockPos feet = ctx.playerFeet();
+        var realStart = new BetterBlockPos(start);
+        var sub = feet.subtract(realStart);
+        if (feet.getY() == realStart.getY() && Math.abs(sub.getX()) <= 1 && Math.abs(sub.getZ()) <= 1) {
+            realStart = feet;
+        }
+        return new AStarPathFinder(realStart, start.getX(), start.getY(), start.getZ(), transformed, favoring, context);
+
     }
 
     @Override

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

@@ -34,18 +34,9 @@ public LitematicaCommand(IBaritone baritone) {
 
     @Override
     public void execute(String label, IArgConsumer args) throws CommandException {
-        int schematic = 0;
-        if (args.hasAny()) {
-            args.requireMax(1);
-            if (args.is(Integer.class)) {
-                schematic = args.getAs(Integer.class) - 1;
-            }
-        }
-        try {
-            baritone.getBuilderProcess().buildOpenLitematic(schematic);
-        } catch (IndexOutOfBoundsException e) {
-            logDirect("Pleas provide a valid index.");
-        }
+        args.requireMax(1);
+        int schematic = args.hasAny() ? args.getAs(Integer.class) - 1 : 0;
+        baritone.getBuilderProcess().buildOpenLitematic(schematic);
     }
 
     @Override