clean up setting groups in modules

Author: beanbag44

src/main/kotlin/com/lambda/config/AbstractSetting.kt

@@ -96,7 +96,7 @@ import kotlin.reflect.KProperty
  */
 abstract class AbstractSetting<T : Any>(
     override var name: String,
-    internal val defaultValue: T,
+    internal var defaultValue: T,
     val type: Type,
     override var description: String,
     var visibility: () -> Boolean,

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

@@ -41,7 +41,7 @@ class BreakSettings(
 
     // General
     override val breakMode by c.setting("Break Mode", BreakMode.Packet, visibility = vis).group(baseGroup, Group.General)
-    override val sorter by c.setting("Sorter", SortMode.Closest, "The order in which breaks are performed", visibility = vis).group(baseGroup, Group.General)
+    override val sorter by c.setting("Sorter", SortMode.Tool, "The order in which breaks are performed", visibility = vis).group(baseGroup, Group.General)
     override val rebreak by c.setting("Rebreak", true, "Re-breaks blocks after they've been broken once", visibility = vis).group(baseGroup, Group.General)
 
     // Double break
@@ -80,16 +80,16 @@ 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 suitableToolsOnly by c.setting("Suitable Tools Only", true, "Only use tools suitable for the given block (will get the item drop)", visibility = vis).group(baseGroup, Group.General)
-    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && forceFortunePickaxe }.group(baseGroup, Group.General)
-    override val useWoodenTools by c.setting("Use Wooden Tools", true, "Use wooden tools when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val useStoneTools by c.setting("Use Stone Tools", true, "Use stone tools when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val useIronTools by c.setting("Use Iron Tools", true, "Use iron tools when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val useDiamondTools by c.setting("Use Diamond Tools", true, "Use diamond tools when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val useGoldTools by c.setting("Use Gold Tools", true, "Use gold tools when breaking blocks", visibility = vis).group(baseGroup, Group.General)
-    override val useNetheriteTools by c.setting("Use Netherite Tools", true, "Use netherite tools when breaking blocks", visibility = vis).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)
+    override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && swapMode.isEnabled() && forceFortunePickaxe }.group(baseGroup, Group.General)
+    override val useWoodenTools by c.setting("Use Wooden Tools", true, "Use wooden tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
+    override val useStoneTools by c.setting("Use Stone Tools", true, "Use stone tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
+    override val useIronTools by c.setting("Use Iron Tools", true, "Use iron tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
+    override val useDiamondTools by c.setting("Use Diamond Tools", true, "Use diamond tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
+    override val useGoldTools by c.setting("Use Gold Tools", true, "Use gold tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
+    override val useNetheriteTools by c.setting("Use Netherite Tools", true, "Use netherite tools when breaking blocks") { vis() && swapMode.isEnabled() }.group(baseGroup, Group.General)
 
     // Cosmetics
     override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds", visibility = vis).group(baseGroup, Group.Cosmetic)

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

@@ -39,7 +39,7 @@ class BuildSettings(
     override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis).group(*baseGroup, Group.General)
     override val interactionsPerTick by c.setting("Interactions Per Tick", 5, 1..30, 1, "The amount of interactions that can happen per tick", visibility = vis).group(*baseGroup, Group.General)
     override val maxPendingInteractions by c.setting("Max Pending Interactions", 15, 1..30, 1, "The maximum count of pending interactions to allow before pausing future interactions", visibility = vis).group(*baseGroup, Group.General)
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks", visibility = vis).group(Group.General)
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks", visibility = vis).group(*baseGroup, Group.General)
 
     override val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", vis).group(*baseGroup, Group.Reach)
     override val attackReach by c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach }.group(*baseGroup, Group.Reach)

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

@@ -27,7 +27,7 @@ class HotbarSettings(
     baseGroup: NamedEnum,
     vis: () -> Boolean = { true }
 ) : HotbarConfig, SettingGroup(c, c.settings.size) {
-    override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", visibility = vis).group(baseGroup)
+    override val keepTicks by c.setting("Keep Ticks", 1, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", visibility = vis).group(baseGroup)
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks", visibility = vis).group(baseGroup)
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 && vis() }.group(baseGroup)
     override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", visibility = vis).group(baseGroup)

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

@@ -23,15 +23,15 @@ import com.lambda.util.NamedEnum
 import kotlin.reflect.KProperty0
 import kotlin.reflect.jvm.isAccessible
 
+private val KProperty0<*>.delegate
+    get() = try {
+        apply { isAccessible = true }.getDelegate()
+    } catch (e: Exception) {
+        throw IllegalStateException("Could not access delegate for property $name", e)
+    }
+
 @Suppress("unchecked_cast")
 abstract class SettingGroup(val c: Configurable, val startIndex: Int) {
-    private val KProperty0<*>.delegate
-        get() = try {
-            apply { isAccessible = true }.getDelegate()
-        } catch (e: Exception) {
-            throw IllegalStateException("Could not access delegate for property $name", e)
-        }
-
     @DslMarker
     annotation class SettingEditorDsl
 
@@ -48,7 +48,7 @@ abstract class SettingGroup(val c: Configurable, val startIndex: Int) {
     }
 
     @SettingEditorDsl
-    internal inline fun <T : Any> editSettings(vararg settings: KProperty0<T>, edits: TypedEditBuilder<T>.() -> Unit) {
+    internal inline fun <T : Any> editTypedSettings(vararg settings: KProperty0<T>, edits: TypedEditBuilder<T>.() -> Unit) {
         TypedEditBuilder((settings.map { it.delegate } as List<AbstractSetting<T>>), c)
             .apply(edits)
     }
@@ -85,7 +85,10 @@ abstract class SettingGroup(val c: Configurable, val startIndex: Int) {
     ) : BasicEditBuilder(settings) {
         @SettingEditorDsl
         fun defaultValue(value: T) {
-            settings.forEach { it.value = value }
+            settings.forEach {
+                it.defaultValue = value
+                it.value = value
+            }
         }
     }
 
@@ -104,20 +107,26 @@ abstract class SettingGroup(val c: Configurable, val startIndex: Int) {
         }
 
         @SettingEditorDsl
-        fun insertSetting(insert: AbstractSetting<*>, at: AbstractSetting<*>, insertMode: InsertMode) {
-            val index = c.settings.indexOf(at)
-            c.settings.add(if (insertMode == InsertMode.Below) index + 1 else index, insert)
+        fun insert(insert: KProperty0<*>, insertMode: InsertMode) {
+            val index = c.settings.indexOf(setting)
+            val delegate = insert.delegate as AbstractSetting<*>
+            c.settings.remove(delegate)
+            c.settings.add(if (insertMode == InsertMode.Above) index - 1 else index, delegate)
         }
 
         @SettingEditorDsl
-        fun insertSettings(vararg inserts: AbstractSetting<*>, at: AbstractSetting<*>, insertMode: InsertMode) {
-            val index = c.settings.indexOf(at)
-            c.settings.addAll(if (insertMode == InsertMode.Below) index + 1 else index, inserts.toList())
+        fun insert(vararg inserts: KProperty0<*>, insertMode: InsertMode) {
+            val index = c.settings.indexOf(setting)
+            inserts.forEach { c.settings.remove(it.delegate as AbstractSetting<*>) }
+            c.settings.addAll(
+                if (insertMode == InsertMode.Above) index - 1 else index,
+                inserts.map { it.delegate } as List<AbstractSetting<*>>
+            )
         }
+    }
 
-        enum class InsertMode {
-            Above,
-            Below
-        }
+    enum class InsertMode {
+        Above,
+        Below
     }
 }

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

@@ -17,21 +17,37 @@
 
 package com.lambda.module.modules.player
 
-import com.lambda.config.groups.BuildSettings
+import com.lambda.config.groups.BreakSettings
+import com.lambda.config.groups.HotbarSettings
+import com.lambda.config.groups.InventorySettings
 import com.lambda.event.events.PlayerEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.BuildContext
-import com.lambda.interaction.material.StackSelection.Companion.select
+import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
+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.breaking.BreakRequest
 import com.lambda.interaction.request.rotating.Rotation.Companion.rotation
 import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.interaction.request.rotating.visibilty.lookAt
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
+import com.lambda.util.BlockUtils.instantBreakable
 import com.lambda.util.NamedEnum
-import net.minecraft.util.Hand
+import com.lambda.util.player.SlotUtils.hotbar
+import net.minecraft.block.pattern.CachedBlockPosition
+import net.minecraft.enchantment.Enchantments
+import net.minecraft.item.ItemStack
+import net.minecraft.registry.tag.ItemTags.DIAMOND_TOOL_MATERIALS
+import net.minecraft.registry.tag.ItemTags.GOLD_TOOL_MATERIALS
+import net.minecraft.registry.tag.ItemTags.IRON_TOOL_MATERIALS
+import net.minecraft.registry.tag.ItemTags.NETHERITE_TOOL_MATERIALS
+import net.minecraft.registry.tag.ItemTags.STONE_TOOL_MATERIALS
+import net.minecraft.registry.tag.ItemTags.WOODEN_TOOL_MATERIALS
 import net.minecraft.util.hit.BlockHitResult
 import java.util.concurrent.ConcurrentLinkedQueue
 
@@ -41,29 +57,122 @@ object FastBreak : Module(
     tag = ModuleTag.PLAYER,
 ) {
     private enum class Group(override val displayName: String) : NamedEnum {
-        Build("Build")
+        Break("Break"),
+        Inventory("Inventory"),
+        Hotbar("Hotbar")
     }
 
-    override val buildConfig = BuildSettings(this, Group.Build)
+    override val breakConfig = BreakSettings(this, Group.Break).apply {
+        editTypedSettings(
+            ::avoidLiquids,
+            ::avoidSupporting,
+            ::suitableToolsOnly,
+            ::rotateForBreak,
+            ::doubleBreak
+        ) { defaultValue(false) }
+        editSetting(::breaksPerTick) { defaultValue(1) }
+        editSetting(::breakWeakBlocks) { defaultValue(true) }
+        hide(
+            ::sorter,
+            ::doubleBreak,
+            ::unsafeCancels,
+            ::rotateForBreak,
+            ::breaksPerTick,
+            ::breakWeakBlocks
+        )
+    }
+    override val inventoryConfig = InventorySettings(this, Group.Inventory).apply {
+        editTypedSettings(
+            ::accessShulkerBoxes,
+            ::accessEnderChest,
+            ::accessChests,
+            ::accessStashes
+        ) {
+            defaultValue(false)
+            visibility { false }
+        }
+    }
+    override val hotbarConfig = HotbarSettings(this, Group.Hotbar)
 
     private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
 
     init {
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
-            player.swingHand(Hand.MAIN_HAND)
 
             val hitResult = mc.crosshairTarget as? BlockHitResult ?: return@listen
             val pos = event.pos
             val state = blockState(pos)
 
+            //ToDo: Copied this swap logic from the build sim. Needs reworking when we rework the build sim. Probably need to
+            // adjust the build sim to accept partial simulations. For example, ignoring hit scanning in this situation
+            val silentSwapSelection = selectContainer {
+                ofAnyType(MaterialContainer.Rank.HOTBAR)
+            }
+
+            val stackSelection = selectStack(
+                sorter = compareByDescending<ItemStack> {
+                    it.canBreak(CachedBlockPosition(world, pos, false))
+                }.thenByDescending {
+                    state.calcItemBlockBreakingDelta(pos, it)
+                }
+            ) {
+                isTool() and if (breakConfig.suitableToolsOnly) {
+                    isSuitableForBreaking(state)
+                } else any() and if (breakConfig.forceSilkTouch) {
+                    hasEnchantment(Enchantments.SILK_TOUCH)
+                } else any() and if (breakConfig.forceFortunePickaxe) {
+                    hasEnchantment(Enchantments.FORTUNE)
+                } else any() and if (!breakConfig.useWoodenTools) {
+                    hasTag(WOODEN_TOOL_MATERIALS).not()
+                } else any() and if (!breakConfig.useStoneTools) {
+                    hasTag(STONE_TOOL_MATERIALS).not()
+                } else any() and if (!breakConfig.useIronTools) {
+                    hasTag(IRON_TOOL_MATERIALS).not()
+                } else any() and if (!breakConfig.useDiamondTools) {
+                    hasTag(DIAMOND_TOOL_MATERIALS).not()
+                } else any() and if (!breakConfig.useGoldTools) {
+                    hasTag(GOLD_TOOL_MATERIALS).not()
+                } else any() and if (!breakConfig.useNetheriteTools) {
+                    hasTag(NETHERITE_TOOL_MATERIALS).not()
+                } else any()
+            }
+
+            val swapCandidates = stackSelection.containerWithMaterial(silentSwapSelection)
+            if (swapCandidates.isEmpty()) return@listen
+
+            val swapStack = 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
+                }
+
             val breakContext = BreakContext(
                 hitResult,
                 RotationRequest(lookAt(player.rotation), this@FastBreak),
-                player.inventory.selectedSlot,
-                player.mainHandStack.select(),
-                state.calcBlockBreakingDelta(player, world, pos) >= breakConfig.breakThreshold,
+                player.hotbar.indexOf(swapStack),
+                stackSelection,
+                instantBreakable(
+                    state,
+                    pos,
+                    if (breakConfig.swapMode.isEnabled()) swapStack
+                    else player.mainHandStack,
+                    breakConfig.breakThreshold
+                ),
                 state,
                 breakConfig.sorter
             )