Enhance Building with Packetmine and more finegrained material control

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,15 +20,25 @@
 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 {
     @Inject(method = "render", at = @At("TAIL"))
     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,47 @@
+/*
+ * 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.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.Vanilla) { vis() }
+    override val breakThreshold by c.setting("Break Threshold", 1.0f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken") { vis() }
+    override val doubleBreak by c.setting("Double Break", false, "Allows breaking two blocks at once") { vis() }
+    override val breakDelay by c.setting("Break Delay", 5, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
+    override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
+    override val swingType by c.setting("Swing Type", SwingType.Vanilla, "The style of swing")
+    override val sounds by c.setting("Sounds", true, "Plays the breaking sounds") { vis() }
+    override val particles by c.setting("Particles", true, "Renders the breaking particles") { vis() }
+    override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages") { vis() }
+    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() }
+    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() }
+    override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { vis() }
+    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
+    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() }
+    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() }
+    override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { 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,12 +26,7 @@ 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 breakSettings: BreakSettings
 
     // Placing
     val rotateForPlace: Boolean

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

@@ -18,7 +18,7 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
-import com.lambda.util.BlockUtils.allSigns
+import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
 
 class BuildSettings(
     c: Configurable,
@@ -37,17 +37,12 @@ class BuildSettings(
     override val maxPendingInteractions by c.setting("Max Pending Interactions", 1, 1..10, 1, "Dont wait for this many interactions for the server response") { vis() && page == Page.General }
 
     // Breaking
-    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.Break }
-    override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation") { vis() && page == Page.Break }
-    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.Break }
-    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() && page == Page.Break }
-    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() && page == Page.Break }
-    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() && page == Page.Break }
+    override val breakSettings = BreakSettings(c) { page == Page.Break && vis() }
 
     // Placing
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.Place }
     override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.Place }
     override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() && page == Page.Place }
 
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && (page == Page.Place && placeConfirmation || page == Page.Break && breakConfirmation) }
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && (page == Page.Place && placeConfirmation || page == Page.Break && breakSettings.breakConfirmation != BreakConfirmationMode.None) }
 }

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

@@ -17,19 +17,62 @@
 
 package com.lambda.config.groups
 
+import com.lambda.interaction.material.ContainerSelection
+import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
 import com.lambda.interaction.material.StackSelection
+import com.lambda.interaction.material.StackSelection.Companion.selectStack
 import com.lambda.interaction.material.container.MaterialContainer
+import com.lambda.util.item.ItemUtils
 import net.minecraft.block.Block
+import net.minecraft.item.Item
+import net.minecraft.item.Items
+import net.minecraft.item.ToolItem
+import net.minecraft.item.ToolMaterial
+import net.minecraft.item.ToolMaterials
 
 interface InventoryConfig {
     val disposables: Set<Block>
-    val accessEnderChest: Boolean
-
     val swapWithDisposables: Boolean
-
     val providerPriority: Priority
     val storePriority: Priority
 
+    val accessShulkerBoxes: Boolean
+    val accessEnderChest: Boolean
+    val accessChests: Boolean
+    val accessStashes: Boolean
+
+    val containerSelection: ContainerSelection get() = selectContainer {
+        val allowedContainers = mutableSetOf<MaterialContainer.Rank>().apply {
+            addAll(MaterialContainer.Rank.entries)
+            if (!accessShulkerBoxes) remove(MaterialContainer.Rank.SHULKER_BOX)
+            if (!accessEnderChest) remove(MaterialContainer.Rank.ENDER_CHEST)
+            if (!accessChests) remove(MaterialContainer.Rank.CHEST)
+            if (!accessStashes) remove(MaterialContainer.Rank.STASH)
+        }
+        ofAnyType(*allowedContainers.toTypedArray())
+    }
+
+    val useWoodenTools: Boolean
+    val useStoneTools: Boolean
+    val useIronTools: Boolean
+    val useDiamondTools: Boolean
+    val useNetheriteTools: Boolean
+    val useGoldTools: Boolean
+    val useShears: Boolean
+    val useFlintAndSteel: Boolean
+
+    val allowedTools get() = mutableSetOf<Item>().apply {
+        addAll(ItemUtils.tools)
+        if (!useWoodenTools) removeIf { it is ToolItem && it.material == ToolMaterials.WOOD }
+        if (!useStoneTools) removeIf { it is ToolItem && it.material == ToolMaterials.STONE }
+        if (!useIronTools) removeIf { it is ToolItem && it.material == ToolMaterials.IRON }
+        if (!useDiamondTools) removeIf { it is ToolItem && it.material == ToolMaterials.DIAMOND }
+        if (!useNetheriteTools) removeIf { it is ToolItem && it.material == ToolMaterials.NETHERITE }
+        if (!useGoldTools) removeIf { it is ToolItem && it.material == ToolMaterials.GOLD }
+        if (!useShears) removeIf { it == Items.SHEARS }
+        if (!useFlintAndSteel) removeIf { it == Items.FLINT_AND_STEEL }
+    }
+
     enum class Priority {
         WithMinItems,
         WithMaxItems;

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

@@ -24,9 +24,28 @@ class InventorySettings(
     c: Configurable,
     vis: () -> Boolean = { true },
 ) : InventoryConfig {
-    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, "Items that will be ignored when checking for a free slot", vis)
-    override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest", vis)
-    override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones", vis)
-    override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from", vis)
-    override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to", vis)
+    val page by c.setting("Inventory Page", Page.Container, "The page to open when the module is enabled", vis)
+
+    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, "Items that will be included when checking for a free slot / are allowed to be droped when inventory is full") { vis() && page == Page.Container}
+    override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones") { vis() && page == Page.Container}
+    override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from") { vis() && page == Page.Container}
+    override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to") { vis() && page == Page.Container}
+
+    override val accessShulkerBoxes by c.setting("Access Shulker Boxes", true, "Allow access to the player's shulker boxes") { vis() && page == Page.Access}
+    override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest") { vis() && page == Page.Access}
+    override val accessChests by c.setting("Access Chests", false, "Allow access to the player's normal chests") { vis() && page == Page.Access}
+    override val accessStashes by c.setting("Access Stashes", false, "Allow access to the player's stashes") { vis() && page == Page.Access}
+
+    override val useWoodenTools by c.setting("Use Wooden Tools", false, "Use wooden tools to mine blocks") { vis() && page == Page.Tools}
+    override val useStoneTools by c.setting("Use Stone Tools", false, "Use stone tools to mine blocks") { vis() && page == Page.Tools}
+    override val useIronTools by c.setting("Use Iron Tools", false, "Use iron tools to mine blocks") { vis() && page == Page.Tools}
+    override val useDiamondTools by c.setting("Use Diamond Tools", true, "Use diamond tools to mine blocks") { vis() && page == Page.Tools}
+    override val useNetheriteTools by c.setting("Use Netherite Tools", true, "Use netherite tools to mine blocks") { vis() && page == Page.Tools}
+    override val useGoldTools by c.setting("Use Gold Tools", false, "Use gold tools to mine blocks") { vis() && page == Page.Tools}
+    override val useShears by c.setting("Use Shears", true, "Use shears to mine blocks") { vis() && page == Page.Tools}
+    override val useFlintAndSteel by c.setting("Use Flint and Steel", true, "Use flint and steel to mine blocks?") { vis() && page == Page.Tools}
+
+    enum class Page {
+        Container, Access, Tools
+    }
 }

common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt

@@ -23,10 +23,11 @@ import com.lambda.graphics.renderer.esp.DirectionMask
 import com.lambda.graphics.renderer.esp.DirectionMask.exclude
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.rotation.RotationRequest
-import com.lambda.threading.runSafe
 import com.lambda.util.world.raycast.RayCastUtils.distanceTo
 import net.minecraft.block.BlockState
-import net.minecraft.util.Hand
+import net.minecraft.client.network.ClientPlayNetworkHandler
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
+import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
@@ -39,21 +40,12 @@ data class BreakContext(
     override val rotation: RotationRequest,
     override val checkedState: BlockState,
     override val targetState: TargetState,
-    override var hand: Hand,
+    override var hotbarIndex: Int,
     val instantBreak: Boolean,
 ) : BuildContext {
     private val baseColor = Color(222, 0, 0, 25)
     private val sideColor = Color(222, 0, 0, 100)
 
-    override fun interact(swingHand: Boolean) {
-        runSafe {
-            if (interaction.updateBlockBreakingProgress(result.blockPos, result.side)) {
-                if (player.isCreative) interaction.blockBreakingCooldown = 0
-                if (swingHand) player.swingHand(hand)
-            }
-        }
-    }
-
     override val expectedPos: BlockPos
         get() = result.blockPos
 
@@ -78,10 +70,29 @@ data class BreakContext(
         }
     }
 
-    override fun shouldRotate(config: BuildConfig) = config.rotateForBreak
+    override fun shouldRotate(config: BuildConfig) = config.breakSettings.rotateForBreak
 
     override fun SafeContext.buildRenderer() {
         withState(checkedState, expectedPos, baseColor, DirectionMask.ALL.exclude(result.side))
         withState(checkedState, expectedPos, sideColor, result.side)
     }
+
+    fun startBreakPacket(sequence: Int, connection: ClientPlayNetworkHandler) =
+        breakPacket(Action.START_DESTROY_BLOCK, sequence, connection)
+
+    fun stopBreakPacket(sequence: Int, connection: ClientPlayNetworkHandler) =
+        breakPacket(Action.STOP_DESTROY_BLOCK, sequence, connection)
+
+    fun abortBreakPacket(sequence: Int, connection: ClientPlayNetworkHandler) =
+        breakPacket(Action.ABORT_DESTROY_BLOCK, sequence, connection)
+
+    private fun breakPacket(action: Action, sequence: Int, connection: ClientPlayNetworkHandler) =
+        connection.sendPacket(
+            PlayerActionC2SPacket(
+                action,
+                expectedPos,
+                result.side,
+                sequence
+            )
+        )
 }

common/src/main/kotlin/com/lambda/interaction/construction/context/BuildContext.kt

@@ -20,9 +20,10 @@ package com.lambda.interaction.construction.context
 import com.lambda.config.groups.BuildConfig
 import com.lambda.interaction.construction.result.Drawable
 import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.interaction.material.container.MaterialContainer
 import com.lambda.interaction.request.rotation.RotationRequest
 import net.minecraft.block.BlockState
-import net.minecraft.util.Hand
+import net.minecraft.item.ItemStack
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
@@ -35,9 +36,10 @@ interface BuildContext : Comparable<BuildContext>, Drawable {
     val targetState: TargetState
     val expectedPos: BlockPos
     val checkedState: BlockState
-    val hand: Hand
+    val hotbarIndex: Int
     val rotation: RotationRequest
 
-    fun interact(swingHand: Boolean)
     fun shouldRotate(config: BuildConfig): Boolean
+
+    data class LocalizedStack(val container: MaterialContainer, val stack: ItemStack)
 }