efficient tools only setting for blocks that could be broken faster with tools. They will only allow those tools

Author: beanbag44

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

@@ -79,6 +79,7 @@ class BreakSettings(
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, description = "Blocks that wont be broken", visibility = vis).group(baseGroup, Group.General)
 
     // Tool
+    override val efficientOnly by c.setting("Efficient Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val suitableToolsOnly by c.setting("Suitable Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)

src/main/kotlin/com/lambda/interaction/construction/processing/ProcessorRegistry.kt

@@ -23,10 +23,11 @@ import com.lambda.util.reflections.getInstances
 import net.minecraft.block.BlockState
 import net.minecraft.state.property.Properties
 import net.minecraft.util.math.BlockPos
+import java.util.*
 
 object ProcessorRegistry : Loadable {
     private val processors = getInstances<PlacementProcessor>()
-    private val processorCache = mutableMapOf<BlockState, PreProcessingInfo?>()
+    private val processorCache = Collections.synchronizedMap<BlockState, PreProcessingInfo?>(mutableMapOf())
 
     val postProcessedProperties = setOf(
         Properties.EXTENDED,

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakChecker.kt

@@ -33,19 +33,19 @@ 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.EVERYTHING
-import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.interaction.material.StackSelection.Companion.selectStack
 import com.lambda.interaction.material.container.ContainerManager.containerWithMaterial
 import com.lambda.interaction.material.container.MaterialContainer
+import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.rotating.RotationManager
 import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.interaction.request.rotating.visibilty.lookAt
 import com.lambda.interaction.request.rotating.visibilty.lookAtBlock
-import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.BlockUtils.instantBreakable
 import com.lambda.util.BlockUtils.isEmpty
+import com.lambda.util.item.ItemStackUtils.inventoryIndex
 import com.lambda.util.item.ItemStackUtils.inventoryIndexOrSelected
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
 import net.minecraft.block.BlockState
@@ -71,40 +71,6 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
     : SimChecker<BreakResult>(), Dependable,
     ISimInfo by simInfo
 {
-    val stackSelection: StackSelection by lazy {
-        runSafe {
-            selectStack(
-                count = 0,
-                sorter = compareByDescending<ItemStack> {
-                    it.canBreak(CachedBlockPosition(world, pos, false))
-                }.thenByDescending {
-                    state.calcItemBlockBreakingDelta(pos, it)
-                }
-            ) {
-                EVERYTHING
-                    .andIf(breakConfig.suitableToolsOnly) {
-                        isSuitableForBreaking(state)
-                    }.andIf(breakConfig.forceSilkTouch) {
-                        hasEnchantment(Enchantments.SILK_TOUCH)
-                    }.andIf(breakConfig.forceFortunePickaxe) {
-                        hasEnchantment(Enchantments.FORTUNE)
-                    }.andIf(!breakConfig.useWoodenTools) {
-                        hasTag(WOODEN_TOOL_MATERIALS).not()
-                    }.andIf(!breakConfig.useStoneTools) {
-                        hasTag(STONE_TOOL_MATERIALS).not()
-                    }.andIf(!breakConfig.useIronTools) {
-                        hasTag(IRON_TOOL_MATERIALS).not()
-                    }.andIf(!breakConfig.useDiamondTools) {
-                        hasTag(DIAMOND_TOOL_MATERIALS).not()
-                    }.andIf(!breakConfig.useGoldTools) {
-                        hasTag(GOLD_TOOL_MATERIALS).not()
-                    }.andIf(!breakConfig.useNetheriteTools) {
-                        hasTag(NETHERITE_TOOL_MATERIALS).not()
-                    }
-            }
-        } ?: EVERYTHING.select()
-    }
-
     override fun asDependent(buildResult: BuildResult) =
         BreakResult.Dependency(pos, buildResult)
 
@@ -134,7 +100,7 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
 
         if (breakConfig.avoidLiquids && affectsFluids()) return true
 
-        val swapStack = getSwapStack() ?: return true
+        val (swapStack, stackSelection) = getSwapStack() ?: return true
         val instant = instantBreakable(
             state, pos,
             if (breakConfig.swapMode.isEnabled()) swapStack else player.mainHandStack,
@@ -181,35 +147,67 @@ class BreakChecker @SimCheckerDsl private constructor(simInfo: SimInfo)
         return true
     }
 
-    private fun AutomatedSafeContext.getSwapStack(): ItemStack? {
+    private fun AutomatedSafeContext.getSwapStack(): Pair<ItemStack, StackSelection>? {
+        val stackSelection = selectStack(
+            count = 0,
+            sorter = compareByDescending<ItemStack> {
+                it.canBreak(CachedBlockPosition(world, pos, false))
+            }.thenByDescending {
+                state.calcItemBlockBreakingDelta(pos, it)
+            }.thenByDescending {
+                it.inventoryIndex == HotbarManager.serverSlot
+            }
+        ) {
+            EVERYTHING
+                .andIf(breakConfig.efficientOnly) {
+                    isEfficientForBreaking(state)
+                }.andIf(breakConfig.suitableToolsOnly) {
+                    isSuitableForBreaking(state)
+                }.andIf(breakConfig.forceSilkTouch) {
+                    hasEnchantment(Enchantments.SILK_TOUCH)
+                }.andIf(breakConfig.forceFortunePickaxe) {
+                    hasEnchantment(Enchantments.FORTUNE)
+                }.andIf(!breakConfig.useWoodenTools) {
+                    hasTag(WOODEN_TOOL_MATERIALS).not()
+                }.andIf(!breakConfig.useStoneTools) {
+                    hasTag(STONE_TOOL_MATERIALS).not()
+                }.andIf(!breakConfig.useIronTools) {
+                    hasTag(IRON_TOOL_MATERIALS).not()
+                }.andIf(!breakConfig.useDiamondTools) {
+                    hasTag(DIAMOND_TOOL_MATERIALS).not()
+                }.andIf(!breakConfig.useGoldTools) {
+                    hasTag(GOLD_TOOL_MATERIALS).not()
+                }.andIf(!breakConfig.useNetheriteTools) {
+                    hasTag(NETHERITE_TOOL_MATERIALS).not()
+                }
+        }
+
         val silentSwapSelection = selectContainer {
             ofAnyType(MaterialContainer.Rank.HOTBAR)
         }
 
-        val swapCandidates = stackSelection.containerWithMaterial(silentSwapSelection)
+        val swapCandidates = stackSelection
+            .containerWithMaterial(silentSwapSelection)
+            .map { it.matchingStacks(stackSelection) }
+            .flatten()
         if (swapCandidates.isEmpty()) {
             result(GenericResult.WrongItemSelection(pos, stackSelection, player.mainHandStack))
             return null
         }
 
-        return swapCandidates
-            .map { it.matchingStacks(stackSelection) }
-            .asSequence()
-            .flatten()
-            .let { containerStacks ->
-                var bestStack = ItemStack.EMPTY
-                var bestBreakDelta = -1f
-                containerStacks.forEach { stack ->
-                    val breakDelta = state.calcItemBlockBreakingDelta(pos, stack)
-                    if (breakDelta > bestBreakDelta ||
-                        (stack == player.mainHandStack && breakDelta >= bestBreakDelta)
-                    ) {
-                        bestBreakDelta = breakDelta
-                        bestStack = stack
-                    }
-                }
-                bestStack
+        var bestStack = ItemStack.EMPTY
+        var bestBreakDelta = -1f
+        swapCandidates.forEach { stack ->
+            val breakDelta = state.calcItemBlockBreakingDelta(pos, stack)
+            if (breakDelta > bestBreakDelta ||
+                (stack == player.mainHandStack && breakDelta >= bestBreakDelta)
+            ) {
+                bestBreakDelta = breakDelta
+                bestStack = stack
             }
+        }
+        return if (bestBreakDelta == -1f) null
+        else Pair(bestStack, stackSelection)
     }
 
     private suspend fun AutomatedSafeContext.affectsFluids(): Boolean {

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

@@ -20,6 +20,7 @@ package com.lambda.interaction.material
 import com.lambda.interaction.material.StackSelection.Companion.StackSelectionDsl
 import com.lambda.util.EnchantmentUtils.getEnchantment
 import com.lambda.util.item.ItemStackUtils.shulkerBoxContents
+import com.lambda.util.item.ItemUtils
 import net.minecraft.block.Block
 import net.minecraft.block.BlockState
 import net.minecraft.component.ComponentType
@@ -31,6 +32,7 @@ import net.minecraft.item.consume.UseAction
 import net.minecraft.registry.RegistryKey
 import net.minecraft.registry.tag.TagKey
 import net.minecraft.screen.slot.Slot
+import java.util.*
 import kotlin.reflect.KClass
 
 /**
@@ -159,6 +161,14 @@ class StackSelection {
      */
     fun isOneOfStacks(stacks: Collection<ItemStack>): (ItemStack) -> Boolean = stacks::contains
 
+    fun isEfficientForBreaking(blockState: BlockState): (ItemStack) -> Boolean = { itemStack ->
+        val hasEfficientTool = efficientToolCache.getOrPut(blockState) {
+            ItemUtils.tools.any { it.getMiningSpeed(it.defaultStack, blockState) > 1f }
+        }
+        if (hasEfficientTool) itemStack.item.getMiningSpeed(itemStack, blockState) > 1f
+        else false
+    }
+
     fun isSuitableForBreaking(blockState: BlockState): (ItemStack) -> Boolean = { it.isSuitableFor(blockState) }
 
     fun hasTag(tag: TagKey<Item>): (ItemStack) -> Boolean = { it.isIn(tag) }
@@ -275,6 +285,8 @@ class StackSelection {
         val NOTHING: (ItemStack) -> Boolean = { false }
         val NO_COMPARE: Comparator<ItemStack> = Comparator { _, _ -> 0 }
 
+        val efficientToolCache: MutableMap<BlockState, Boolean> = Collections.synchronizedMap<BlockState, Boolean>(mutableMapOf())
+
         @StackSelectionDsl
         fun Item.select() = selectStack { isItem(this@select) }
 

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

@@ -57,6 +57,7 @@ interface BreakConfig : RequestConfig {
     val avoidSupporting: Boolean
     val ignoredBlocks: Set<Block>
 
+    val efficientOnly: Boolean
     val suitableToolsOnly: Boolean
     val forceSilkTouch: Boolean
     val forceFortunePickaxe: Boolean

src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt

@@ -66,6 +66,7 @@ object FastBreak : Module(
         editTyped(
             ::avoidLiquids,
             ::avoidSupporting,
+            ::efficientOnly,
             ::suitableToolsOnly,
             ::rotateForBreak,
             ::doubleBreak

src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -79,7 +79,12 @@ object PacketMine : Module(
     private val endColor by setting("End Color", Color(255, 0, 0, 60).brighter(), "The color of the end (farthest from breaking) of the queue") { renderQueue && dynamicColor }.group(Group.Break, BreakSettings.Group.Cosmetic)
 
     override val breakConfig = BreakSettings(this, Group.Break).apply {
-        editTyped(::avoidLiquids, ::avoidSupporting, ::suitableToolsOnly) { defaultValue(false) }
+        editTyped(
+            ::avoidLiquids,
+            ::avoidSupporting,
+            ::efficientOnly,
+            ::suitableToolsOnly
+        ) { defaultValue(false) }
         ::swing.edit { defaultValue(BreakConfig.SwingMode.Start) }
 
         ::rebreak.insert(::rebreakMode, SettingGroup.InsertMode.Below)