properly store setting groups and clean up fast break

beanbag44 · beanbag44 · commit acecf2625a88 · 2025-12-01T18:25:29.000Z
diff --git a/src/main/kotlin/com/lambda/config/SettingGroup.kt b/src/main/kotlin/com/lambda/config/SettingGroup.kt
@@ -21,9 +21,13 @@ interface ISettingGroup {
 	val settings: MutableList<AbstractSetting<*>>
 }
 
-abstract class SettingGroup() : ISettingGroup {
+abstract class SettingGroup(c: Configurable) : ISettingGroup {
     override val settings = mutableListOf<AbstractSetting<*>>()
 
+	init {
+		c.settingGroups.add(this)
+	}
+
     fun <T : Any> AbstractSetting<T>.index(): AbstractSetting<T> {
         settings.add(this)
         return this
diff --git a/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt b/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
@@ -33,7 +33,7 @@ import java.awt.Color
 open class BreakSettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), BreakConfig {
+) : SettingGroup(c), BreakConfig {
     private enum class Group(override val displayName: String) : NamedEnum {
         General("General"),
         Cosmetic("Cosmetic")
diff --git a/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt b/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt
@@ -26,7 +26,7 @@ import kotlin.math.max
 class BuildSettings(
     c: Configurable,
     baseGroup: NamedEnum,
-) : SettingGroup(), BuildConfig {
+) : SettingGroup(c), BuildConfig {
     enum class Group(override val displayName: String) : NamedEnum {
         General("General"),
         Reach("Reach"),
diff --git a/src/main/kotlin/com/lambda/config/groups/EatSettings.kt b/src/main/kotlin/com/lambda/config/groups/EatSettings.kt
@@ -26,7 +26,7 @@ import net.minecraft.item.Items
 class EatSettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), EatConfig {
+) : SettingGroup(c), EatConfig {
     val nutritiousFoodDefaults = listOf(Items.APPLE, Items.BAKED_POTATO, Items.BEEF, Items.BEETROOT, Items.BEETROOT_SOUP, Items.BREAD, Items.CARROT, Items.CHICKEN, Items.CHORUS_FRUIT, Items.COD, Items.COOKED_BEEF, Items.COOKED_CHICKEN, Items.COOKED_COD, Items.COOKED_MUTTON, Items.COOKED_PORKCHOP, Items.COOKED_RABBIT, Items.COOKED_SALMON, Items.COOKIE, Items.DRIED_KELP, Items.ENCHANTED_GOLDEN_APPLE, Items.GOLDEN_APPLE, Items.GOLDEN_CARROT, Items.HONEY_BOTTLE, Items.MELON_SLICE, Items.MUSHROOM_STEW, Items.MUTTON, Items.POISONOUS_POTATO, Items.PORKCHOP, Items.POTATO, Items.PUFFERFISH, Items.PUMPKIN_PIE, Items.RABBIT, Items.RABBIT_STEW, Items.ROTTEN_FLESH, Items.SALMON, Items.SPIDER_EYE, Items.SUSPICIOUS_STEW, Items.SWEET_BERRIES, Items.GLOW_BERRIES, Items.TROPICAL_FISH)
     val resistanceFoodDefaults = listOf(Items.ENCHANTED_GOLDEN_APPLE)
     val regenerationFoodDefaults = listOf(Items.ENCHANTED_GOLDEN_APPLE, Items.GOLDEN_APPLE)
diff --git a/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt b/src/main/kotlin/com/lambda/config/groups/FormatterSettings.kt
@@ -20,34 +20,25 @@ package com.lambda.config.groups
 import com.lambda.config.Configurable
 import com.lambda.config.SettingGroup
 import com.lambda.util.NamedEnum
-import com.lambda.util.math.Vec2d
-import net.minecraft.util.math.Vec2f
-import net.minecraft.util.math.Vec3d
-import net.minecraft.util.math.Vec3i
-import org.joml.Vector3f
-import org.joml.Vector4f
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.ZonedDateTime
 
 class FormatterSettings(
-    owner: Configurable,
-    baseGroup: NamedEnum,
-) : FormatterConfig, SettingGroup() {
-    val localeEnum by owner.setting("Locale", FormatterConfig.Locales.US, "The regional formatting used for numbers").group(baseGroup).index()
+	c: Configurable,
+	baseGroup: NamedEnum,
+) : FormatterConfig, SettingGroup(c) {
+    val localeEnum by c.setting("Locale", FormatterConfig.Locales.US, "The regional formatting used for numbers").group(baseGroup).index()
     override val locale get() = localeEnum.locale
 
-    val sep by owner.setting("Separator", FormatterConfig.TupleSeparator.Comma, "Separator for string serialization of tuple data structures").group(baseGroup).index()
-    val customSep by owner.setting("Custom Separator", "") { sep == FormatterConfig.TupleSeparator.Custom }.group(baseGroup).index()
+    val sep by c.setting("Separator", FormatterConfig.TupleSeparator.Comma, "Separator for string serialization of tuple data structures").group(baseGroup).index()
+    val customSep by c.setting("Custom Separator", "") { sep == FormatterConfig.TupleSeparator.Custom }.group(baseGroup).index()
     override val separator get() = if (sep == FormatterConfig.TupleSeparator.Custom) customSep else sep.separator
 
-    val group by owner.setting("Tuple Prefix", FormatterConfig.TupleGrouping.Parentheses).group(baseGroup).index()
+    val group by c.setting("Tuple Prefix", FormatterConfig.TupleGrouping.Parentheses).group(baseGroup).index()
     override val prefix get() = group.prefix
     override val postfix get() = group.postfix
 
-    val floatingPrecision by owner.setting("Floating Precision", 3, 0..6, 1, "Precision for floating point numbers").group(baseGroup).index()
+    val floatingPrecision by c.setting("Floating Precision", 3, 0..6, 1, "Precision for floating point numbers").group(baseGroup).index()
     override val precision get() = floatingPrecision
 
-    val timeFormat by owner.setting("Time Format", FormatterConfig.Time.IsoDateTime).group(baseGroup).index()
+    val timeFormat by c.setting("Time Format", FormatterConfig.Time.IsoDateTime).group(baseGroup).index()
     override val format get() = timeFormat.format
 }
diff --git a/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt b/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt
@@ -27,7 +27,7 @@ import com.lambda.util.NamedEnum
 class HotbarSettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), HotbarConfig {
+) : SettingGroup(c), HotbarConfig {
     override val keepTicks by c.setting("Keep Ticks", 1, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks").group(baseGroup).index()
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks").group(baseGroup).index()
     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 }.group(baseGroup).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt b/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt
@@ -27,7 +27,7 @@ import com.lambda.util.NamedEnum
 class InteractSettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), InteractConfig {
+) : SettingGroup(c), InteractConfig {
     override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting").group(baseGroup).index()
     override val sorter by c.setting("Interact Sorter", ActionConfig.SortMode.Tool, "The order in which interactions are performed").group(baseGroup).index()
     override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting").group(baseGroup).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt b/src/main/kotlin/com/lambda/config/groups/InventorySettings.kt
@@ -27,7 +27,7 @@ import com.lambda.util.item.ItemUtils
 class InventorySettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), InventoryConfig {
+) : SettingGroup(c), InventoryConfig {
     enum class Group(override val displayName: String) : NamedEnum {
         General("General"),
         Container("Container"),
diff --git a/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt b/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt
@@ -29,7 +29,7 @@ import com.lambda.util.NamedEnum
 class PlaceSettings(
     c: Configurable,
     baseGroup: NamedEnum
-) : SettingGroup(), PlaceConfig {
+) : SettingGroup(c), PlaceConfig {
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing").group(baseGroup).index()
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces").group(baseGroup).index()
     override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { airPlace.isEnabled }.group(baseGroup).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/RotationSettings.kt b/src/main/kotlin/com/lambda/config/groups/RotationSettings.kt
@@ -34,7 +34,7 @@ import kotlin.random.Random
 class RotationSettings(
     c: Configurable,
     baseGroup: NamedEnum,
-) : SettingGroup(), RotationConfig {
+) : SettingGroup(c), RotationConfig {
     override var rotationMode by c.setting("Mode", RotationMode.Sync, "How the player is being rotated on interaction").group(baseGroup).index()
 
     /** How many ticks to keep the rotation before resetting */
diff --git a/src/main/kotlin/com/lambda/config/groups/Targeting.kt b/src/main/kotlin/com/lambda/config/groups/Targeting.kt
@@ -54,7 +54,7 @@ abstract class Targeting(
     baseGroup: NamedEnum,
     private val defaultRange: Double,
     private val maxRange: Double,
-) : SettingGroup(), TargetingConfig {
+) : SettingGroup(c), TargetingConfig {
     /**
      * The range within which entities can be targeted. This value is configurable and constrained
      * between 1.0 and [maxRange].
diff --git a/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt b/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt
@@ -19,36 +19,20 @@ package com.lambda.module.modules.player
 
 import com.lambda.config.AutomationConfig.Companion.setDefaultAutomationConfig
 import com.lambda.config.applyEdits
+import com.lambda.config.groups.BuildConfig
 import com.lambda.event.events.PlayerEvent
+import com.lambda.event.events.TickEvent
 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.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.construction.result.results.BreakResult
+import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
+import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.interaction.request.breaking.BreakRequest.Companion.breakRequest
-import com.lambda.interaction.request.inventory.InventoryConfig
-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.interaction.request.hotbar.HotbarConfig
 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.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 com.lambda.threading.runSafeAutomated
 import java.util.concurrent.ConcurrentLinkedQueue
 
 object FastBreak : Module(
@@ -58,18 +42,28 @@ object FastBreak : Module(
 ) {
     private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
 
+	override val buildConfig = object : BuildConfig by super.buildConfig {
+		override val pathing = false
+		override val stayInRange = false
+		override val interactionsPerTick = 1
+		override val useDefaultReach = false
+		override val interactReach = Double.MAX_VALUE
+		override val checkSideVisibility = false
+		override val strictRayCast = false
+	}
+
     override val breakConfig = object : BreakConfig by super.breakConfig {
         override val rotateForBreak = false
         override val doubleBreak = false
         override val breaksPerTick = 1
-    }
-    override val inventoryConfig = object : InventoryConfig by super.inventoryConfig {
-        override val accessShulkerBoxes = false
-        override val accessEnderChest = false
-        override val accessChests = false
-        override val accessStashes = false
+	    override val tickStageMask = setOf(TickEvent.Input.Post)
+	    override val maxPendingBreaks = Int.MAX_VALUE
     }
 
+	override val hotbarConfig = object : HotbarConfig by super.hotbarConfig {
+		override val tickStageMask = setOf(TickEvent.Input.Post)
+	}
+
     init {
         setDefaultAutomationConfig {
 			applyEdits {
@@ -83,95 +77,32 @@ object FastBreak : Module(
 					hide(
 						::rotateForBreak,
 						::doubleBreak,
-						::breaksPerTick
+						::breaksPerTick,
+						::sorter,
+						::unsafeCancels,
+						::tickStageMask,
+						::maxPendingBreaks
 					)
 				}
-				hideGroups(buildConfig, placeConfig, interactConfig, inventoryConfig, eatConfig)
+				hide(hotbarConfig::tickStageMask)
+				hideAllGroupsExcept(breakConfig, rotationConfig, hotbarConfig)
 			}
         }
 
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
 
-            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.hotbar.indexOf(swapStack),
-                stackSelection,
-                instantBreakable(
-                    state,
-                    pos,
-                    if (breakConfig.swapMode.isEnabled()) swapStack
-                    else player.mainHandStack,
-                    breakConfig.breakThreshold
-                ),
-                state.getOutlineShape(world, pos).boundingBoxes.any { it.contains(player.eyePos) },
-                state,
-                this@FastBreak
-            )
+	        val breakContexts =
+				runSafeAutomated {
+					buildMap { put(event.pos, TargetState.Empty) }
+						.simulate()
+						.filterIsInstance<BreakResult.Break>()
+						.map { it.context }
+						.takeIf { it.isNotEmpty() }
+				} ?: return@listen
 
-            breakRequest(setOf(breakContext), pendingInteractions).submit()
+            breakRequest(breakContexts, pendingInteractions).submit()
         }
     }
 }
