Enhance Building with Packetmine and more finegrained material control

common/src/main/java/com/lambda/mixin/MinecraftClientMixin.java

@@ -23,11 +23,20 @@
 import com.lambda.event.events.InventoryEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.module.modules.player.Interact;
+import com.lambda.module.modules.player.PacketMine;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider;
+import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.sound.SoundManager;
 import net.minecraft.util.thread.ThreadExecutor;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.HitResult;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -36,30 +45,55 @@
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(MinecraftClient.class)
+@Mixin(value = MinecraftClient.class, priority = Integer.MAX_VALUE)
 public class MinecraftClientMixin {
     @Shadow
     @Nullable
     public Screen currentScreen;
+    @Shadow
+    @Nullable
+    public HitResult crosshairTarget;
 
-    @Inject(method = "tick", at = @At("HEAD"))
-    void onTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Pre());
+    @WrapMethod(method = "render")
+    void onLoopTick(boolean tick, Operation<Void> original) {
+        EventFlow.post(TickEvent.Render.Pre.INSTANCE);
+        original.call(tick);
+        EventFlow.post(TickEvent.Render.Post.INSTANCE);
     }
 
-    @Inject(method = "tick", at = @At("RETURN"))
-    void onTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Post());
+    @WrapMethod(method = "tick")
+    void onTick(Operation<Void> original) {
+        EventFlow.post(TickEvent.Pre.INSTANCE);
+        original.call();
+        EventFlow.post(TickEvent.Post.INSTANCE);
     }
 
-    @Inject(method = "render", at = @At("HEAD"))
-    void onLoopTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Render.Pre());
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerInteractionManager;tick()V"))
+    void onNetwork(ClientPlayerInteractionManager instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.Network.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.Network.Post.INSTANCE);
     }
 
-    @Inject(method = "render", at = @At("RETURN"))
-    void onLoopTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Render.Post());
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;handleInputEvents()V"))
+    void onInput(MinecraftClient instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.Input.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.Input.Post.INSTANCE);
+    }
+
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;tick()V"))
+    void onWorldRenderer(WorldRenderer instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.WorldRender.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.WorldRender.Post.INSTANCE);
+    }
+
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/sound/SoundManager;tick(Z)V"))
+    void onSound(SoundManager instance, boolean paused, Operation<Void> original) {
+        EventFlow.post(TickEvent.Sound.Pre.INSTANCE);
+        original.call(instance, paused);
+        EventFlow.post(TickEvent.Sound.Post.INSTANCE);
     }
 
     @Inject(at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;)V", shift = At.Shift.AFTER, remap = false), method = "stop")
@@ -91,8 +125,16 @@ private void onScreenRemove(@Nullable Screen screen, CallbackInfo ci) {
         }
     }
 
+    @Redirect(method = "doAttack()Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;swingHand(Lnet/minecraft/util/Hand;)V"))
+    private void redirectHandSwing(ClientPlayerEntity instance, Hand hand) {
+        if (this.crosshairTarget == null) return;
+        if (this.crosshairTarget.getType() != HitResult.Type.BLOCK || PacketMine.INSTANCE.isDisabled()) {
+            instance.swingHand(hand);
+        }
+    }
+
     @Redirect(method = "doItemUse", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerInteractionManager;isBreakingBlock()Z"))
-    boolean injectMultiActon(ClientPlayerInteractionManager instance) {
+    boolean redirectMultiActon(ClientPlayerInteractionManager instance) {
         if (instance == null) return true;
 
         if (Interact.INSTANCE.isEnabled() && Interact.getMultiAction()) return false;

common/src/main/java/com/lambda/mixin/baritone/MixinBaritonePlayerContext.java

@@ -42,7 +42,7 @@ void syncRotationWithBaritone(CallbackInfoReturnable<Rotation> cir) {
 
         RotationManager rm = RotationManager.INSTANCE;
         cir.setReturnValue(new Rotation(
-                (float) rm.getCurrentRotation().getYaw(), (float) rm.getCurrentRotation().getPitch())
+                (float) rm.getActiveRotation().getYaw(), (float) rm.getActiveRotation().getPitch())
         );
     }
 }

common/src/main/java/com/lambda/mixin/entity/ClientPlayInteractionManagerMixin.java

@@ -25,7 +25,6 @@
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.PlayerInventory;
-import net.minecraft.network.packet.c2s.play.UpdateSelectedSlotC2SPacket;
 import net.minecraft.screen.slot.SlotActionType;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;

common/src/main/java/com/lambda/mixin/entity/ClientPlayerEntityMixin.java

@@ -25,6 +25,8 @@
 import com.lambda.interaction.PlayerPacketManager;
 import com.lambda.interaction.request.rotation.RotationManager;
 import com.lambda.module.modules.player.PortalGui;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.DeathScreen;
 import net.minecraft.client.gui.screen.Screen;
@@ -33,7 +35,6 @@
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.entity.MovementType;
 import net.minecraft.entity.damage.DamageSource;
-import net.minecraft.util.Hand;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -85,6 +86,7 @@ void onMove(MovementType movementType, Vec3d movement, CallbackInfo ci) {
     @Redirect(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick(ZF)V"))
     void processMovement(Input input, boolean slowDown, float slowDownFactor) {
         input.tick(slowDown, slowDownFactor);
+        RotationManager.processRotations();
         RotationManager.BaritoneProcessor.processPlayerMovement(input, slowDown, slowDownFactor);
         EventFlow.post(new MovementEvent.InputUpdate(input, slowDown, slowDownFactor));
     }
@@ -129,14 +131,11 @@ void sendBegin(CallbackInfo ci) {
         autoJumpEnabled = Lambda.getMc().options.getAutoJump().getValue();
     }
 
-    @Inject(method = "tick", at = @At(value = "HEAD"))
-    void onTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Player.Pre());
-    }
-
-    @Inject(method = "tick", at = @At(value = "RETURN"))
-    void onTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Player.Post());
+    @WrapMethod(method = "tick")
+    void onTick(Operation<Void> original) {
+        EventFlow.post(TickEvent.Player.Pre.INSTANCE);
+        original.call();
+        EventFlow.post(TickEvent.Player.Post.INSTANCE);
     }
 
     @Redirect(method = "tickNewAi", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;getYaw()F"))
@@ -149,11 +148,6 @@ float fixHeldItemPitch(ClientPlayerEntity instance) {
         return Objects.requireNonNullElse(RotationManager.getHandPitch(), instance.getPitch());
     }
 
-    @Inject(method = "swingHand", at = @At("HEAD"), cancellable = true)
-    void onSwingHandPre(Hand hand, CallbackInfo ci) {
-        if (EventFlow.post(new PlayerEvent.SwingHand(hand)).isCanceled()) ci.cancel();
-    }
-
     @Inject(method = "damage", at = @At("HEAD"), cancellable = true)
     public void damage(DamageSource source, float amount, CallbackInfoReturnable<Boolean> cir) {
         if (EventFlow.post(new PlayerEvent.Damage(source, amount)).isCanceled()) cir.setReturnValue(false);

common/src/main/java/com/lambda/mixin/entity/PlayerInventoryMixin.java

@@ -17,11 +17,15 @@
 
 package com.lambda.mixin.entity;
 
+import net.minecraft.block.BlockState;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.PlayerInventory;
 import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@@ -30,6 +34,8 @@
 
 @Mixin(PlayerInventory.class)
 public class PlayerInventoryMixin {
+    @Shadow @Final public PlayerEntity player;
+
     @Inject(method = "getMainHandStack", at = @At(value = "HEAD"), cancellable = true)
     public void handleSpoofedMainHandStack(CallbackInfoReturnable<ItemStack> cir) {
         PlayerInventory instance = (PlayerInventory) (Object) this;
@@ -44,4 +50,9 @@ public void handleSpoofedMainHandStack(CallbackInfoReturnable<ItemStack> cir) {
                 isValidHotbarIndex(actualSlot) ? instance.main.get(actualSlot) : ItemStack.EMPTY
         );
     }
+
+    @Inject(method = "getBlockBreakingSpeed", at = @At(value = "HEAD"), cancellable = true)
+    public void handleSpoofedBlockBreakingSpeed(BlockState block, CallbackInfoReturnable<Float> cir) {
+        cir.setReturnValue(player.getMainHandStack().getMiningSpeedMultiplier(block));
+    }
 }

common/src/main/java/com/lambda/mixin/render/InGameHudMixin.java

@@ -20,11 +20,16 @@
 import com.lambda.graphics.RenderMain;
 import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.gui.hud.InGameHud;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.item.ItemStack;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import static net.minecraft.entity.player.PlayerInventory.isValidHotbarIndex;
+
 @Mixin(InGameHud.class)
 public class InGameHudMixin {
     /**
@@ -34,4 +39,9 @@ public class InGameHudMixin {
     private void onRender(DrawContext context, float tickDelta, CallbackInfo ci) {
         RenderMain.render2D();
     }
+
+    @Redirect(method = "tick()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/player/PlayerInventory;getMainHandStack()Lnet/minecraft/item/ItemStack;"))
+    private ItemStack onTick(PlayerInventory inventory) {
+        return isValidHotbarIndex(inventory.selectedSlot) ? inventory.main.get(inventory.selectedSlot) : ItemStack.EMPTY;
+    }
 }

common/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt

@@ -48,7 +48,7 @@ object TransferCommand : LambdaCommand(
                         val selection = selectStack(count) {
                             isItem(stack(ctx).value().item)
                         }
-                        containerWithMaterial(selection).forEachIndexed { i, container ->
+                        selection.containerWithMaterial().forEachIndexed { i, container ->
                             builder.suggest("\"${i + 1}. ${container.name}\"", container.description(selection))
                         }
                         builder.buildFuture()

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.config.groups
+
+import com.lambda.config.Configurable
+import com.lambda.event.events.TickEvent
+import com.lambda.interaction.request.Priority
+import com.lambda.interaction.request.breaking.BreakConfig
+import com.lambda.util.BlockUtils.allSigns
+
+class BreakSettings(
+    c: Configurable,
+    priority: Priority = 0,
+    vis: () -> Boolean = { true }
+) : BreakConfig(priority) {
+    override val breakMode by c.setting("Break Mode", BreakMode.Packet, visibility = vis)
+    override val reBreak by c.setting("ReBreak", true, "Re-breaks blocks after they've been broken once", visibility = vis)
+    override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes", visibility = vis)
+    override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken", visibility = vis)
+    override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once", visibility = vis)
+    override val fudgeFactor by c.setting("Fudge Factor", 2, 0..5, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break", visibility = vis)
+    override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks", visibility = vis)
+    override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Input.Post, TickEvent.Player.Post), "The sub-tick timing at which break actions can be performed", visibility = vis)
+    override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand", visibility = vis)
+    override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing != SwingMode.None }
+    override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds", visibility = vis)
+    override val particles by c.setting("Particles", true, "Renders the breaking particles", visibility = vis)
+    override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages", visibility = vis)
+    override val rotateForBreak by c.setting("Rotate For Break", false, "Rotate towards block while breaking", visibility = vis)
+    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken", visibility = vis)
+    override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking", visibility = vis)
+    override val maxPendingBreaks by c.setting("Max Pending Breaks", 15, 1..30, 1, "The maximum amount of pending breaks", visibility = vis)
+    override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick", visibility = vis)
+    override val suitableToolsOnly by c.setting("Suitable Tools Only", false, "Places a restriction to only use tools suitable for the given block", visibility = vis)
+    override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill", visibility = vis)
+    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", visibility = vis)
+    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks", visibility = vis)
+    override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks", visibility = vis)
+    override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && forceFortunePickaxe }
+}

common/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -17,8 +17,6 @@
 
 package com.lambda.config.groups
 
-import net.minecraft.block.Block
-
 interface BuildConfig {
     // General
     val pathing: Boolean
@@ -28,15 +26,14 @@ interface BuildConfig {
     val interactionTimeout: Int
 
     // Breaking
-    val rotateForBreak: Boolean
-    val breakConfirmation: Boolean
-    val breaksPerTick: Int
-    val breakWeakBlocks: Boolean
-    val forceSilkTouch: Boolean
-    val ignoredBlocks: Set<Block>
+    val breaking: BreakSettings
 
     // Placing
-    val rotateForPlace: Boolean
-    val placeConfirmation: Boolean
-    val placementsPerTick: Int
+    val placing: PlaceSettings
+
+    enum class SwingType {
+        Vanilla,
+        Server,
+        Client
+    }
 }