allow breaking with any tool with a setting for suitable only

Author: beanbag44

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

@@ -45,6 +45,7 @@ class BreakSettings(
     override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { vis() }
     override val maxPendingBreaks by c.setting("Max Pending Breaks", 15, 1..30, 1, "The maximum amount of pending breaks") { vis() }
     override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { 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 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() }

common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -30,6 +30,7 @@ import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.PlaceResult
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
+import com.lambda.interaction.material.StackSelection
 import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.StackSelection.Companion.selectStack
 import com.lambda.interaction.material.container.ContainerManager.containerWithMaterial
@@ -56,7 +57,6 @@ import com.lambda.util.BlockUtils.instantBreakable
 import com.lambda.util.BlockUtils.vecOf
 import com.lambda.util.Communication.warn
 import com.lambda.util.item.ItemStackUtils.equal
-import com.lambda.util.item.ItemUtils.findBestToolsForBreaking
 import com.lambda.util.math.distSq
 import com.lambda.util.player.SlotUtils.hotbar
 import com.lambda.util.player.copyPlayer
@@ -68,6 +68,7 @@ import net.minecraft.block.pattern.CachedBlockPosition
 import net.minecraft.enchantment.Enchantments
 import net.minecraft.item.BlockItem
 import net.minecraft.item.ItemPlacementContext
+import net.minecraft.item.ItemStack
 import net.minecraft.item.ItemUsageContext
 import net.minecraft.registry.RegistryKeys
 import net.minecraft.util.Hand
@@ -542,45 +543,67 @@ object BuildSimulator {
             return acc
         }
 
-        val bestTools = findBestToolsForBreaking(state, inventory.allowedTools)
-
-        /* there is no good tool for the job */
-        if (bestTools.isEmpty()) {
-            /* The current selected item cant mine the block */
-            Hand.entries.forEach {
-                val stack = player.getStackInHand(it)
-                if (stack.isEmpty) return@forEach
-                if (stack.item.canMine(state, world, pos, player)) return@forEach
-                acc.add(BreakResult.ItemCantMine(pos, state, stack.item, inventory))
-                return acc
+//        val bestTools = findBestToolForBreaking(state, inventory.allowedTools)
+//
+//        /* there is no good tool for the job */
+//        if (bestTools.isEmpty()) {
+//            /* The current selected item cant mine the block */
+//            Hand.entries.forEach {
+//                val stack = player.getStackInHand(it)
+//                if (stack.isEmpty) return@forEach
+//                if (stack.item.canMine(state, world, pos, player)) return@forEach
+//                acc.add(BreakResult.ItemCantMine(pos, state, stack.item, inventory))
+//                return acc
+//            }
+//            // ToDo: Switch to non destroyable item
+//            acc.add(BreakResult.Break(pos, breakContext))
+//            return acc
+//        }
+//
+//        val toolSelection = if (build.breaking.forceSilkTouch) {
+//            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.SILK_TOUCH) }
+//        } else if (build.breaking.forceFortunePickaxe) {
+//            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.FORTUNE, build.breaking.minFortuneLevel) }
+//        } else {
+//            bestTools.select()
+//        }
+//        val silentSwapSelection = selectContainer {
+//            matches(toolSelection) and ofAnyType(MaterialContainer.Rank.HOTBAR)
+//        }
+//	    val fullSelection = selectContainer {
+//			matches(toolSelection) and matches(inventory.containerSelection)
+//	    }
+
+        val stackSelection = selectStack(
+            block = {
+                run {
+                    if (build.breaking.suitableToolsOnly) isSuitableForBreaking(state)
+                    else StackSelection.EVERYTHING
+                } and if (build.breaking.forceSilkTouch) {
+                    hasEnchantment(Enchantments.SILK_TOUCH)
+                } else if (build.breaking.forceFortunePickaxe) {
+                    hasEnchantment(Enchantments.FORTUNE, build.breaking.minFortuneLevel)
+                } else StackSelection.EVERYTHING
+            },
+            sorter = compareByDescending<ItemStack> {
+                it.canDestroy(world.registryManager.get(RegistryKeys.BLOCK), CachedBlockPosition(world, pos, false))
+            }.thenByDescending {
+                state.calcItemBlockBreakingDelta(player, world, pos, it)
             }
-            // ToDo: Switch to non destroyable item
-            acc.add(BreakResult.Break(pos, breakContext))
-            return acc
-        }
+        )
 
-        val toolSelection = if (build.breaking.forceSilkTouch) {
-            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.SILK_TOUCH) }
-        } else if (build.breaking.forceFortunePickaxe) {
-            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.FORTUNE, build.breaking.minFortuneLevel) }
-        } else {
-            bestTools.select()
-        }
         val silentSwapSelection = selectContainer {
-            matches(toolSelection) and ofAnyType(MaterialContainer.Rank.HOTBAR)
+            matches(stackSelection) and ofAnyType(MaterialContainer.Rank.HOTBAR)
         }
-	    val fullSelection = selectContainer {
-			matches(toolSelection) and matches(inventory.containerSelection)
-	    }
 
-        val swapCandidates = toolSelection.containerWithMaterial(inventory, silentSwapSelection)
+        val swapCandidates = stackSelection.containerWithMaterial(inventory, silentSwapSelection)
         if (swapCandidates.isEmpty()) {
-            acc.add(BuildResult.WrongItemSelection(pos, breakContext, toolSelection, player.mainHandStack, inventory))
+            acc.add(BuildResult.WrongItemSelection(pos, breakContext, stackSelection, player.mainHandStack, inventory))
             return acc
         }
 
-        val matchingStacks = swapCandidates.associateWith { it.matchingStacks(toolSelection) }
-        val (container, toolPair) = matchingStacks.mapValues { (_, stacks) ->
+        val matchingStacks = swapCandidates.associateWith { it.matchingStacks(stackSelection) }
+        val (_, toolPair) = matchingStacks.mapValues { (_, stacks) ->
 	        stacks.associateWith { state.calcItemBlockBreakingDelta(player, world, pos, it) }
                 .maxByOrNull { it.value }
                 ?.toPair()

common/src/main/kotlin/com/lambda/interaction/material/StackSelection.kt

@@ -20,6 +20,7 @@ package com.lambda.interaction.material
 import com.lambda.util.BlockUtils.item
 import com.lambda.util.item.ItemStackUtils.shulkerBoxContents
 import net.minecraft.block.Block
+import net.minecraft.block.BlockState
 import net.minecraft.enchantment.Enchantment
 import net.minecraft.enchantment.EnchantmentHelper
 import net.minecraft.item.Item
@@ -32,6 +33,7 @@ import kotlin.reflect.KClass
  */
 class StackSelection {
     var selector: (ItemStack) -> Boolean = { true }
+    var comparator: Comparator<ItemStack>? = null
     var count: Int = DEFAULT_AMOUNT
     var inShulkerBox: Boolean = false
 
@@ -45,28 +47,24 @@ class StackSelection {
     val optimalStack: ItemStack?
         get() = itemStack ?: item?.let { ItemStack(it, count) }
 
-    val filterStack: (ItemStack) -> Boolean
-        get() = { stack ->
-            if (inShulkerBox) {
-                stack.shulkerBoxContents.any { selector(it) }
-            } else {
-                selector(stack)
-            }
-        }
+    fun filterStack(stack: ItemStack) =
+        if (inShulkerBox) stack.shulkerBoxContents.any { selector(it) }
+        else selector(stack)
 
-    val filterSlot: (Slot) -> Boolean
-        get() = { slot ->
-            filterStack(slot.stack)
-        }
+    fun filterSlot(slot: Slot) = filterStack(slot.stack)
 
-    val filterStacks: (List<ItemStack>) -> List<ItemStack>
-        get() = {
-            it.filter(filterStack)
+    fun filterStacks(stacks: List<ItemStack>): List<ItemStack> =
+        stacks.filter(::filterStack).let { filteredStacks ->
+            comparator?.run {
+                filteredStacks.sortedWith(this)
+            } ?: filteredStacks
         }
 
-    val filterSlots: (List<Slot>) -> List<Slot>
-        get() = { slots ->
-            slots.filter { filterSlot(it) }
+    fun filterSlots(slots: List<Slot>): List<Slot> =
+        slots.filter(::filterSlot).let { filteredSlots ->
+            comparator?.run {
+                filteredSlots.sortedWith { slot, slot2 -> compare(slot.stack, slot2.stack) }
+            } ?: filteredSlots
         }
 
     /**
@@ -127,6 +125,9 @@ class StackSelection {
     @StackSelectionDsl
     fun isOneOfStacks(stacks: Collection<ItemStack>): (ItemStack) -> Boolean = { it in stacks }
 
+    @StackSelectionDsl
+    fun isSuitableForBreaking(blockState: BlockState): (ItemStack) -> Boolean = { it.isSuitableFor(blockState) }
+
     /**
      * [isItem] returns a predicate that matches a specific [Item] instance.
      * @param T The instance of [Item] to be matched.
@@ -257,15 +258,28 @@ class StackSelection {
          * @param block The predicate to be used to select the items.
          * @return A [StackSelection] with the given parameters.
          */
+        @StackSelectionDsl
+        fun selectStack(
+            count: Int = DEFAULT_AMOUNT,
+            inShulkerBox: Boolean = false,
+            block: StackSelection.() -> (ItemStack) -> Boolean
+        ) = StackSelection().apply {
+            selector = block()
+            this.count = count
+            this.inShulkerBox = inShulkerBox
+        }
+
         @StackSelectionDsl
         fun selectStack(
             count: Int = DEFAULT_AMOUNT,
             inShulkerBox: Boolean = false,
             block: StackSelection.() -> (ItemStack) -> Boolean,
+            sorter: Comparator<ItemStack>? = null
         ) = StackSelection().apply {
             selector = block()
+            comparator = sorter
             this.count = count
             this.inShulkerBox = inShulkerBox
         }
     }
-}
+}

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt

@@ -42,6 +42,7 @@ abstract class BreakConfig(
     abstract val breakConfirmation: BreakConfirmationMode
     abstract val maxPendingBreaks: Int
     abstract val breaksPerTick: Int
+    abstract val suitableToolsOnly: Boolean
     abstract val breakWeakBlocks: Boolean
     abstract val forceSilkTouch: Boolean
     abstract val forceFortunePickaxe: Boolean