Refactor tool, inventory, and block usage logic.

Unify tool selection logic with new configuration options, improving flexibility for allowed tools and container access. Replace `wrong item` handling with a more robust `wrong item selection` mechanism, enhancing context-aware resolutions. Adjust block-breaking and material-handling processes for cleaner, modular, and efficient code.

Author: Avanatiker

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

@@ -39,6 +39,8 @@ interface BuildConfig {
     val breakConfirmation: BreakConfirmationMode
     val breaksPerTick: Int
     val forceSilkTouch: Boolean
+    val forceFortunePickaxe: Boolean
+    val minFortuneLevel: Int
     val ignoredBlocks: Set<Block>
 
     val breakWeakBlocks: Boolean

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

@@ -38,18 +38,20 @@ class BuildSettings(
 
     // Breaking
     override val breakMode by c.setting("Break Mode", BuildConfig.BreakMode.Vanilla) { vis() && page == Page.Break }
-    override val breakThreshold by c.setting("Break Threshold", 1.0f, 0.1f..1.0f, 0.1f, "The break amount at which the block is considered broken") { vis() && page == Page.Break }
+    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() && page == Page.Break }
     override val doubleBreak by c.setting("Double Break", false, "Allows breaking two blocks at once") { vis() && page == Page.Break }
     override val breakDelay by c.setting("Break Delay", 5, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() && page == Page.Break }
     override val sounds by c.setting("Sounds", true, "Plays the breaking sounds") { vis() && page == Page.Break }
     override val particles by c.setting("Particles", true, "Renders the breaking particles") { vis() && page == Page.Break }
     override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages") { vis() && page == Page.Break }
     override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.Break }
+    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() && page == Page.Break }
     override val breakConfirmation by c.setting("Break Confirmation", BuildConfig.BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { 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 forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { vis() && page == Page.Break }
+    override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && page == Page.Break && forceFortunePickaxe }
 
     // Placing
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.Place }

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

@@ -17,20 +17,61 @@
 
 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 silentSwap: Boolean
+    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,

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

@@ -24,10 +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)
-    override val silentSwap by c.setting("Silent Swap", true, "", 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

@@ -18,6 +18,7 @@
 package com.lambda.interaction.construction.context
 
 import com.lambda.config.groups.BuildConfig
+import com.lambda.config.groups.InventoryConfig
 import com.lambda.context.SafeContext
 import com.lambda.graphics.renderer.esp.DirectionMask
 import com.lambda.graphics.renderer.esp.DirectionMask.exclude
@@ -44,9 +45,10 @@ data class BreakContext(
     override val rotation: RotationRequest,
     override val checkedState: BlockState,
     override val targetState: TargetState,
-    override var slotIndex: Int?,
+    override var hotbarIndex: Int,
     val instantBreak: Boolean,
     val buildConfig: BuildConfig,
+    val inventoryConfig: InventoryConfig
 ) : BuildContext {
     private val baseColor = Color(222, 0, 0, 25)
     private val sideColor = Color(222, 0, 0, 100)

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

@@ -20,8 +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.item.ItemStack
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
@@ -34,8 +36,10 @@ interface BuildContext : Comparable<BuildContext>, Drawable {
     val targetState: TargetState
     val expectedPos: BlockPos
     val checkedState: BlockState
-    val slotIndex: Int?
+    val hotbarIndex: Int
     val rotation: RotationRequest
 
     fun shouldRotate(config: BuildConfig): Boolean
+
+    data class LocalizedStack(val container: MaterialContainer, val stack: ItemStack)
 }

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

@@ -39,7 +39,7 @@ data class PlaceContext(
     override val distance: Double,
     override val expectedState: BlockState,
     override val checkedState: BlockState,
-    override val slotIndex: Int?,
+    override val hotbarIndex: Int,
     override val expectedPos: BlockPos,
     override val targetState: TargetState,
     val sneak: Boolean,

common/src/main/kotlin/com/lambda/interaction/construction/result/BuildResult.kt

@@ -22,14 +22,14 @@ import baritone.api.pathing.goals.GoalNear
 import com.lambda.config.groups.InventoryConfig
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.context.BuildContext
+import com.lambda.interaction.material.StackSelection
 import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.container.ContainerManager.transfer
 import com.lambda.interaction.material.container.MaterialContainer
 import com.lambda.interaction.material.container.containers.MainHandContainer
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.Nameable
 import net.minecraft.block.BlockState
-import net.minecraft.item.Item
 import net.minecraft.item.ItemStack
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
@@ -190,24 +190,23 @@ abstract class BuildResult : ComparableResult<Rank>, Nameable {
 
     /**
      * Player has an inefficient tool equipped.
-     * @param neededItem The best tool for the block state.
+     * @param neededSelection The best tool for the block state.
      */
-    data class WrongItem(
+    data class WrongItemSelection(
         override val blockPos: BlockPos,
         val context: BuildContext,
-        //TODO: probably need to make this a list of items
-        val neededItem: Item,
+        val neededSelection: StackSelection,
         val currentItem: ItemStack,
         val inventory: InventoryConfig
     ) : Drawable, Resolvable, BuildResult() {
-        override val name: String get() = "Wrong item ($currentItem) for ${blockPos.toShortString()} need ${neededItem.name.string}"
+        override val name: String get() = "Wrong item ($currentItem) for ${blockPos.toShortString()} need $neededSelection"
         override val rank = Rank.WRONG_ITEM
         private val color = Color(3, 252, 169, 25)
 
         override val pausesParent get() = true
 
-        override fun resolve() = neededItem.select()
-            .transfer(MainHandContainer, inventory) ?: MaterialContainer.FailureTask("Couldn't find ${neededItem.name.string} anywhere.")
+        override fun resolve() = neededSelection
+            .transfer(MainHandContainer, inventory) ?: MaterialContainer.FailureTask("Couldn't find $neededSelection anywhere.")
 
         override fun SafeContext.buildRenderer() {
             if (blockState(blockPos).isAir) {
@@ -219,7 +218,7 @@ abstract class BuildResult : ComparableResult<Rank>, Nameable {
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {
-                is WrongItem -> context.compareTo(other.context)
+                is WrongItemSelection -> context.compareTo(other.context)
                 else -> super.compareTo(other)
             }
         }
@@ -256,7 +255,7 @@ abstract class BuildResult : ComparableResult<Rank>, Nameable {
 
         override fun compareTo(other: ComparableResult<Rank>): Int {
             return when (other) {
-                is WrongItem -> context.compareTo(other.context)
+                is WrongItemSelection -> context.compareTo(other.context)
                 else -> super.compareTo(other)
             }
         }