Fixup some code

Author: IceTank

v1_21_4/src/main/java/me/aleksilassila/litematica/printer/v1_21_4/config/PrinterConfig.java

@@ -36,7 +36,6 @@ public static PrinterConfig getInstance() {
     public static final ConfigBoolean ROTATE_PLAYER = new ConfigBoolean("printerRotatePlayer", false, "Rotate the player to face the block to place.");
     public static final ConfigBoolean PRINTER_GRIM_ROTATION = new ConfigBoolean("printerGrimRotate", true, "Allows you to place blocks anywhere while walking or using baritone.");
     public static final ConfigBoolean STOP_ON_MOVEMENT = new ConfigBoolean("printerStopOnMovement", false, "Stop the printer if the player velocity is to high.");
-    public static final ConfigBoolean CARPET_MODE = new ConfigBoolean("printerCarpetMode", true, "Carpet mode. Checks more points on blocks for placement viability. This might be needed for very strict raycast anti cheat checks. Does nothing when raycast is disabled.");
     public static final ConfigInteger INVENTORY_DELAY = new ConfigInteger("printerInventoryDelay", 10, 0, 100, "The delay between each inventory action. 0 = no delay.");
     public static final ConfigOptionList PRINTER_INVENTORY_MANAGEMENT_MODE = new ConfigOptionList("printerInventoryManagementMode", InventoryManagementModeEnum.LEAST_USED, "Inventory management mode. Rolling = cycle through the hotbar, Least Used = use the least used slot in the hotbar.");
     public static final ConfigBoolean RAYCAST = new ConfigBoolean("printerRaycast", false, "Raycast the block to place to check if it is obstructed by another block. Most anti cheat don't check for this.");
@@ -73,7 +72,6 @@ public ImmutableList<IConfigBase> getOptions() {
         list.add(ROTATE_PLAYER);
         list.add(PRINTER_GRIM_ROTATION);
         list.add(STOP_ON_MOVEMENT);
-        list.add(CARPET_MODE);
         list.add(INVENTORY_DELAY);
         list.add(PRINTER_INVENTORY_MANAGEMENT_MODE);
         list.add(RAYCAST);

v1_21_4/src/main/java/me/aleksilassila/litematica/printer/v1_21_4/guides/placement/FacingBlockGuide.java

@@ -5,7 +5,6 @@
 import net.minecraft.block.enums.BlockHalf;
 import net.minecraft.state.property.Properties;
 import net.minecraft.util.math.Direction;
-import net.minecraft.util.math.Vec3d;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -32,18 +31,6 @@ protected List<Direction> getPossibleSides() {
         return Arrays.stream(Direction.values()).toList();
     }
 
-    protected Vec3d[] getPossibleHitVecs() {
-        Vec3d[] parentVecs = super.getPossibleHitVecs();
-        Block block = state.targetState.getBlock();
-        if (!(block instanceof StairsBlock)) {
-            return parentVecs;
-        }
-
-        Direction half = getRequiredHalf(state);
-
-        return Arrays.stream(parentVecs).filter(vec -> half == Direction.DOWN ? vec.y <= 0 : vec.y > 0).toArray(Vec3d[]::new);
-    }
-
     @Override
     public boolean skipOtherGuides() {
         return true;

v1_21_4/src/main/java/me/aleksilassila/litematica/printer/v1_21_4/guides/placement/GeneralPlacementGuide.java

@@ -34,17 +34,6 @@
  * for player state depending on the block being placed.
  */
 public class GeneralPlacementGuide extends PlacementGuide {
-    protected static Vec3d[] hitVecsToTry = new Vec3d[]{
-            new Vec3d(-0.25, -0.25, -0.25),
-            new Vec3d(+0.25, -0.25, -0.25),
-            new Vec3d(-0.25, +0.25, -0.25),
-            new Vec3d(-0.25, -0.25, +0.25),
-            new Vec3d(+0.25, +0.25, -0.25),
-            new Vec3d(-0.25, +0.25, +0.25),
-            new Vec3d(+0.25, -0.25, +0.25),
-            new Vec3d(+0.25, +0.25, +0.25)
-    };
-
     protected static Vec3d[] extendedHitVecs = new Vec3d[]{
             new Vec3d(-0.25, -0.25, -0.25),
             new Vec3d(+0.25, -0.25, -0.25),
@@ -122,7 +111,7 @@ private Optional<Direction> getValidSide(SchematicBlockState state) {
     }
 
     protected Vec3d[] getPossibleHitVecs() {
-        return PrinterConfig.CARPET_MODE.getBooleanValue() ? extendedHitVecs : hitVecsToTry;
+        return extendedHitVecs;
     }
 
     private List<Direction> getValidSides(SchematicBlockState state) {
@@ -170,7 +159,7 @@ public boolean canExecute(ClientPlayerEntity player) {
     @Override
     public @Nullable PrinterPlacementContext getPlacementContext(ClientPlayerEntity player) {
         if (PrinterConfig.PRINTER_AIRPLACE.getBooleanValue()) {
-            return getContextByRotation(player);
+            return getAirplaceContext(player);
         } else {
             return getContextByStrictLook(player);
         }
@@ -281,16 +270,16 @@ public PrinterPlacementContext getContextByStrictLook(ClientPlayerEntity player)
     }
 
     protected static Direction[] directionsToTry = new Direction[]{
+            Direction.UP,
+            Direction.DOWN,
             Direction.NORTH,
             Direction.SOUTH,
             Direction.EAST,
-            Direction.WEST,
-            Direction.UP,
-            Direction.DOWN
+            Direction.WEST
     };
 
     @Nullable
-    public PrinterPlacementContext getContextByRotation(ClientPlayerEntity player) {
+    public PrinterPlacementContext getAirplaceContext(ClientPlayerEntity player) {
         if (contextCache != null && !LitematicaMixinMod.DEBUG) return contextCache;
 
         ItemStack requiredItem = getRequiredItem(player).stream().findFirst().orElse(ItemStack.EMPTY);
@@ -305,27 +294,24 @@ public PrinterPlacementContext getContextByRotation(ClientPlayerEntity player) {
         // We'll brute force: sides (including horizontal) + hit positions inside the target block volume
         // to emulate realistic clicks that yield correct orientation for special blocks (hoppers, froglights, basalt, slabs).
 
-        // Candidate sides to emulate a supporting face. For airplace we pretend there is a block on that side.
-        Direction[] candidateSides = new Direction[]{
-                Direction.UP, Direction.DOWN,
-                Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST
-        };
-
-        // Hit offsets inside block relative to its min corner (0..1). Include lower y (<0.5) for bottom slabs, and center variations.
-        double[] ySamples = new double[]{0.25, 0.5, 0.75};
-        double[] xzSamples = new double[]{0.25, 0.5, 0.75};
-
         // First quick attempt: original center (UP side) (fast path)
         {
             BlockHitResult hr = new BlockHitResult(Vec3d.ofCenter(state.blockPos), Direction.UP, state.blockPos, true);
             PrinterPlacementContext quick = new PrinterPlacementContext(player, hr, requiredItem, slot, null, false);
             BlockState res = getRequiredItemAsBlock(player).orElse(targetState.getBlock()).getPlacementState(quick);
             if (res != null && correctObserverPlacement(targetState, res) && statesEqual(res, targetState)) {
-                contextCache = quick; quick.isAirPlace = true; return quick; }
+                contextCache = quick;
+                quick.isAirPlace = true;
+                return quick;
+            }
         }
 
+        // Hit offsets inside block relative to its min corner (0..1). Include lower y (<0.5) for bottom slabs, and center variations.
+        double[] ySamples = new double[]{0.25, 0.5, 0.75};
+        double[] xzSamples = new double[]{0.25, 0.5, 0.75};
+
         for (Direction lookDirection : directionsToTry) {
-            for (Direction side : candidateSides) {
+            for (Direction side : getPossibleSides()) {
                 // Neighbor position (imaginary supporting block). For DOWN side we offset below, etc.
                 BlockPos neighborPos = state.blockPos.offset(side);
 
@@ -338,22 +324,24 @@ public PrinterPlacementContext getContextByRotation(ClientPlayerEntity player) {
                             Vec3d hitVec = Vec3d.of(state.blockPos).add(sample);
 
                             // Ensure the hitVec lies on the correct face for the side: project coordinate component to face plane center
-                            switch (side) {
-                                case UP: hitVec = new Vec3d(hitVec.x, state.blockPos.getY() + 1 - 1e-4, hitVec.z); break;
-                                case DOWN: hitVec = new Vec3d(hitVec.x, state.blockPos.getY() + 1e-4, hitVec.z); break;
-                                case NORTH: hitVec = new Vec3d(hitVec.x, hitVec.y, state.blockPos.getZ() + 1e-4); break;
-                                case SOUTH: hitVec = new Vec3d(hitVec.x, hitVec.y, state.blockPos.getZ() + 1 - 1e-4); break;
-                                case WEST: hitVec = new Vec3d(state.blockPos.getX() + 1e-4, hitVec.y, hitVec.z); break;
-                                case EAST: hitVec = new Vec3d(state.blockPos.getX() + 1 - 1e-4, hitVec.y, hitVec.z); break;
-                            }
+                            hitVec = switch (side) {
+                                case UP -> new Vec3d(hitVec.x, state.blockPos.getY() + 1 - 1e-4, hitVec.z);
+                                case DOWN -> new Vec3d(hitVec.x, state.blockPos.getY() + 1e-4, hitVec.z);
+                                case NORTH -> new Vec3d(hitVec.x, hitVec.y, state.blockPos.getZ() + 1e-4);
+                                case SOUTH -> new Vec3d(hitVec.x, hitVec.y, state.blockPos.getZ() + 1 - 1e-4);
+                                case WEST -> new Vec3d(state.blockPos.getX() + 1e-4, hitVec.y, hitVec.z);
+                                case EAST -> new Vec3d(state.blockPos.getX() + 1 - 1e-4, hitVec.y, hitVec.z);
+                            };
 
                             BlockHitResult hitResult = new BlockHitResult(hitVec, side.getOpposite(), neighborPos, false);
                             PrinterPlacementContext context = new PrinterPlacementContext(player, hitResult, requiredItem, slot, lookDirection, false);
                             BlockState result = getRequiredItemAsBlock(player)
                                     .orElse(targetState.getBlock())
                                     .getPlacementState(context);
                             if (result != null && correctObserverPlacement(targetState, result) && statesEqual(result, targetState)) {
-                                contextCache = context; context.isAirPlace = true; return context;
+                                contextCache = context;
+                                context.isAirPlace = true;
+                                return context;
                             }
                         }
                     }

v1_21_4/src/main/java/me/aleksilassila/litematica/printer/v1_21_4/guides/placement/TorchGuide.java

@@ -1,20 +1,17 @@
 package me.aleksilassila.litematica.printer.v1_21_4.guides.placement;
 
 import me.aleksilassila.litematica.printer.v1_21_4.SchematicBlockState;
-import me.aleksilassila.litematica.printer.v1_21_4.config.PrinterConfig;
 import net.minecraft.block.Block;
-import net.minecraft.block.BlockState;
 import net.minecraft.block.HorizontalFacingBlock;
 import net.minecraft.block.WallMountedBlock;
-import net.minecraft.state.property.Properties;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.util.math.Direction;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
-public class TorchGuide extends GuesserGuide {
+public class TorchGuide extends PropertySpecificGuesserGuide {
     public TorchGuide(SchematicBlockState state) {
         super(state);
     }
@@ -34,19 +31,4 @@ protected List<Direction> getPossibleSides() {
     protected Optional<Block> getRequiredItemAsBlock(ClientPlayerEntity player) {
         return Optional.of(state.targetState.getBlock());
     }
-
-    @Override
-    protected boolean statesEqual(BlockState state1, BlockState state2) {
-        // Redstone torches use LIT which can be false if powered; ignore it to allow placement
-        if (PrinterConfig.PRINTER_IGNORE_ROTATION.getBooleanValue()) {
-            var rotationProps = PropertySpecificGuesserGuide.rotationProperties;
-            // Merge rotation props with LIT
-            net.minecraft.state.property.Property<?>[] merged = new net.minecraft.state.property.Property<?>[rotationProps.length + 1];
-            System.arraycopy(rotationProps, 0, merged, 0, rotationProps.length);
-            merged[rotationProps.length] = Properties.LIT;
-            return statesEqualIgnoreProperties(state1, state2, merged);
-        } else {
-            return statesEqualIgnoreProperties(state1, state2, Properties.LIT);
-        }
-    }
 }

v1_21_4/src/main/java/me/aleksilassila/litematica/printer/v1_21_4/implementation/actions/AirPlaceAction.java

@@ -2,7 +2,6 @@
 
 import me.aleksilassila.litematica.printer.v1_21_4.LitematicaMixinMod;
 import me.aleksilassila.litematica.printer.v1_21_4.actions.InteractAction;
-import me.aleksilassila.litematica.printer.v1_21_4.config.PrinterConfig;
 import me.aleksilassila.litematica.printer.v1_21_4.implementation.PrinterPlacementContext;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.FluidBlock;
@@ -21,7 +20,6 @@
 import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
-import net.minecraft.util.math.Vec3d;
 
 public class AirPlaceAction extends InteractAction {
     private final MinecraftClient mc = MinecraftClient.getInstance();
@@ -33,18 +31,15 @@ public AirPlaceAction(PrinterPlacementContext context) {
     protected ActionResult interact(MinecraftClient client, ClientPlayerEntity player, Hand hand, BlockHitResult hitResult) {
         BlockPos pos = hitResult.isInsideBlock() ? hitResult.getBlockPos() : hitResult.getBlockPos().offset(hitResult.getSide());
         BlockState currentState = mc.world.getBlockState(pos);
-        
+
         // Allow placement in air or in fluids when REPLACE_FLUIDS_SOURCE_BLOCKS is enabled
-        boolean canPlace = currentState.isAir() || 
-                          (LitematicaMixinMod.REPLACE_FLUIDS_SOURCE_BLOCKS.getBooleanValue() && 
+        boolean canPlace = currentState.isAir() ||
+                          (LitematicaMixinMod.REPLACE_FLUIDS_SOURCE_BLOCKS.getBooleanValue() &&
                            currentState.getBlock() instanceof FluidBlock);
-        
+
         if (!canPlace) {
-            if (PrinterConfig.PRINTER_DEBUG_LOG.getBooleanValue()) 
-                System.out.println("InteractActionImpl.interact: block is not air and fluid replacement is disabled");
             return ActionResult.FAIL;
         }
-        if (PrinterConfig.PRINTER_DEBUG_LOG.getBooleanValue()) System.out.println("InteractActionImpl.interact: attempting to air place block");
         airPlace(pos);
         return ActionResult.PASS;
     }
@@ -60,17 +55,8 @@ private void airPlace(BlockPos pos) {
         connection.sendPacket(new PlayerActionC2SPacket(PlayerActionC2SPacket.Action.SWAP_ITEM_WITH_OFFHAND, BlockPos.ORIGIN, Direction.DOWN));
 
         Hand hand = Hand.OFF_HAND;
-        // Build a synthetic hit result anchored on the target block position (inside-block) but preserving
-        // the sampled side & hit vector for orientation. This avoids accidentally clicking a real neighbor
-        // and placing a block one block ahead (issue seen with hoppers & slabs).
-        BlockHitResult original = this.context.hitResult;
-        BlockHitResult placeHit;
-        if (original != null) {
-            placeHit = new BlockHitResult(original.getPos(), original.getSide(), pos, true);
-        } else {
-            placeHit = new BlockHitResult(Vec3d.ofCenter(pos), Direction.DOWN, pos, true);
-        }
-        interactionManager.interactBlock(mc.player, hand, placeHit);
+        BlockHitResult blockHitResult = new BlockHitResult(this.context.hitResult.getPos(), this.context.hitResult.getSide(), pos, true);
+        interactionManager.interactBlock(mc.player, hand, blockHitResult);
         mc.player.swingHand(Hand.MAIN_HAND, false);
         connection.sendPacket(new HandSwingC2SPacket(hand));
         connection.sendPacket(new PlayerActionC2SPacket(PlayerActionC2SPacket.Action.SWAP_ITEM_WITH_OFFHAND, BlockPos.ORIGIN, Direction.DOWN));