simple packet mine as a wrapper for the break manager

Author: beanbag44

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

@@ -23,10 +23,14 @@
 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 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.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;
@@ -41,6 +45,10 @@ public class MinecraftClientMixin {
     @Nullable
     public Screen currentScreen;
 
+    @Shadow @Nullable public HitResult crosshairTarget;
+
+    @Shadow @Nullable public ClientPlayerEntity player;
+
     @Inject(method = "tick", at = @At("HEAD"))
     void onTickPre(CallbackInfo ci) {
         EventFlow.post(new TickEvent.Pre());
@@ -90,8 +98,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 || this.player != null) return;
+        if (this.crosshairTarget.getType() != HitResult.Type.BLOCK || PacketMine.INSTANCE.isDisabled()) {
+            this.player.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/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -0,0 +1,88 @@
+/*
+ * 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.module.modules.player
+
+import com.lambda.config.groups.BuildSettings
+import com.lambda.config.groups.HotbarSettings
+import com.lambda.config.groups.InteractionSettings
+import com.lambda.config.groups.InventorySettings
+import com.lambda.config.groups.RotationSettings
+import com.lambda.event.events.PlayerEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.interaction.construction.blueprint.Blueprint.Companion.toStructure
+import com.lambda.interaction.construction.blueprint.StaticBlueprint.Companion.toBlueprint
+import com.lambda.interaction.construction.context.BuildContext
+import com.lambda.interaction.construction.result.BreakResult
+import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
+import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.interaction.request.breaking.BreakRequest
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.world.raycast.InteractionMask
+import java.util.concurrent.ConcurrentLinkedQueue
+
+object PacketMine : Module(
+    "Packet Mine",
+    "automatically breaks blocks, and does it faster",
+    setOf(ModuleTag.PLAYER)
+) {
+    private val page by setting("Page", Page.Build)
+
+    private val build = BuildSettings(this) { page == Page.Build }
+    private val rotation = RotationSettings(this) { page == Page.Rotation }
+    private val interact = InteractionSettings(this, InteractionMask.Block) { page == Page.Interaction }
+    private val inventory = InventorySettings(this) { page == Page.Inventory }
+    private val hotbar = HotbarSettings(this) { page == Page.Hotbar }
+
+    private val pendingInteractionsList = ConcurrentLinkedQueue<BuildContext>()
+
+    private var breaks = 0
+    private var itemDrops = 0
+
+    init {
+        listen<PlayerEvent.Attack.Block> { event ->
+            event.cancel()
+
+            val blockState = blockState(event.pos)
+            val buildResult = event.pos
+                .toStructure(TargetState.State(blockState.fluidState.blockState))
+                .toBlueprint()
+                .simulate(
+                    player.eyePos,
+                    interact = interact,
+                    rotation = rotation,
+                    inventory = inventory,
+                    build = build
+                )
+                .minOrNull() ?: return@listen
+
+            if (buildResult !is BreakResult.Break) return@listen
+            val request = BreakRequest(
+                listOf(buildResult.context), build, rotation, interact, inventory, hotbar,
+                pendingInteractionsList = pendingInteractionsList,
+                onBreak = { breaks++ }
+            ) { _ -> itemDrops++ }
+            build.breakSettings.request(request)
+        }
+    }
+
+    enum class Page {
+        Build, Rotation, Interaction, Inventory, Hotbar
+    }
+}