remove action-specific max pending action settings

beanbag44 · beanbag44 · commit 6bcc984ee456 · 2025-12-11T04:21:29.000Z
diff --git a/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt b/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt
@@ -26,8 +26,8 @@ import com.lambda.interaction.managers.breaking.BreakConfig.AnimationMode
 import com.lambda.interaction.managers.breaking.BreakConfig.BreakConfirmationMode
 import com.lambda.interaction.managers.breaking.BreakConfig.BreakMode
 import com.lambda.interaction.managers.breaking.BreakConfig.SwingMode
-import com.lambda.util.BlockUtils.allSigns
 import com.lambda.util.NamedEnum
+import net.minecraft.block.Block
 import java.awt.Color
 
 open class BreakSettings(
@@ -72,12 +72,11 @@ open class BreakSettings(
     // Pending / Post
     override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking").group(baseGroup, Group.General).index()
     override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick").group(baseGroup, Group.General).index()
-    override val maxPendingBreaks by c.setting("Max Pending Breaks", 15, 1..30, 1, "The maximum amount of pending breaks").group(baseGroup, Group.General).index()
 
     // Block
+    override val ignoredBlocks by c.setting("Ignored Blocks", emptySet<Block>(), description = "Blocks that wont be broken").group(baseGroup, Group.General).index()
     override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill").group(baseGroup, Group.General).index()
     override val avoidSupporting by c.setting("Avoid Supporting", true, "Avoids breaking the block supporting the player").group(baseGroup, Group.General).index()
-    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, description = "Blocks that wont be broken").group(baseGroup, Group.General).index()
 
     // Tool
     override val efficientOnly by c.setting("Efficient Tools Only", true, "Only use tools suitable for the given block (will get the item drop)") { swapMode.isEnabled() }.group(baseGroup, Group.General).index()
diff --git a/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt b/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt
@@ -28,12 +28,10 @@ interface BuildConfig : ISettingGroup {
     val stayInRange: Boolean
     val collectDrops: Boolean
     val spleefEntities: Boolean
-    val actionsPerTick: Int
     val maxPendingActions: Int
     val actionTimeout: Int
     val maxBuildDependencies: Int
 
-    val useDefaultReach: Boolean
     val attackReach: Double
     val interactReach: Double
     val scanReach: Double
diff --git a/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt b/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt
@@ -38,24 +38,16 @@ class BuildSettings(
     override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks").group(baseGroup, Group.General).index()
     override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks").group(baseGroup, Group.General).index()
     override val spleefEntities by c.setting("Spleef Entities", false, "Breaks blocks beneath entities blocking placements to get them out of the way").group(baseGroup, Group.General).index()
-    override val actionsPerTick by c.setting("Actions Per Tick", 5, 1..30, 1, "The amount of interactions that can happen per tick").group(baseGroup, Group.General).index()
     override val maxPendingActions by c.setting("Max Pending Actions", 15, 1..30, 1, "The maximum count of pending interactions to allow before pausing future interactions").group(baseGroup, Group.General).index()
     override val actionTimeout by c.setting("Action Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks").group(baseGroup, Group.General).index()
     override val maxBuildDependencies by c.setting("Max Sim Dependencies", 3, 0..10, 1, "Maximum dependency build results").group(baseGroup, Group.General).index()
 
-    override val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges").group(baseGroup, Group.Reach).index()
-    override val attackReach by c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { !useDefaultReach }.group(baseGroup, Group.Reach).index()
-    override val interactReach by c.setting("Interact Reach", DEFAULT_INTERACT_REACH, 1.0..10.0, 0.01, "Maximum block interaction distance") { !useDefaultReach }.group(baseGroup, Group.Reach).index()
-
+    override var attackReach by c.setting("Attack Reach", 3.0, 1.0..7.0, 0.01, "Maximum entity interaction distance").group(baseGroup, Group.Reach).index()
+    override var interactReach by c.setting("Interact Reach", 4.5, 1.0..7.0, 0.01, "Maximum block interaction distance").group(baseGroup, Group.Reach).index()
     override val scanReach: Double get() = max(attackReach, interactReach)
 
     override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible").group(baseGroup, Group.Scan).index()
     override val strictRayCast by c.setting("Strict Raycast", false, "Whether to include the environment to the ray cast context").group(baseGroup, Group.Scan).index()
     override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "") { strictRayCast }.group(baseGroup, Group.Scan).index()
     override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point").group(baseGroup, Group.Scan).index()
-
-    companion object {
-        const val DEFAULT_ATTACK_REACH = 3.0
-        const val DEFAULT_INTERACT_REACH = 4.5
-    }
 }
diff --git a/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt b/src/main/kotlin/com/lambda/config/groups/InteractSettings.kt
@@ -37,7 +37,6 @@ class InteractSettings(
     override val tickStageMask by c.setting("Interaction Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which place actions are performed").group(baseGroup).index()
     override val interactConfirmationMode by c.setting("Interact Confirmation", InteractConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation").group(baseGroup).index()
     override val interactDelay by c.setting("Interact Delay", 0, 0..3, 1, "Tick delay between interacting with another block").group(baseGroup).index()
-	override val maxPendingInteractions by c.setting("Max Pending Interactions", 5, 0..30, 1, "The maximum amount of pending placements").group(baseGroup).index()
     override val interactionsPerTick by c.setting("Interactions Per Tick", 1, 1..30, 1, "Maximum instant block places per tick").group(baseGroup).index()
     override val swing by c.setting("Swing On Interact", true, "Swings the players hand when placing").group(baseGroup).index()
     override val swingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { swing }.group(baseGroup).index()
diff --git a/src/main/kotlin/com/lambda/interaction/managers/PostActionHandler.kt b/src/main/kotlin/com/lambda/interaction/managers/PostActionHandler.kt
@@ -52,7 +52,7 @@ abstract class PostActionHandler<T : ActionInfo> {
     }
 
     fun Automated.setPendingConfigs() {
-        BrokenBlockHandler.pendingActions.setSizeLimit(breakConfig.maxPendingBreaks)
+        BrokenBlockHandler.pendingActions.setSizeLimit(buildConfig.maxPendingActions)
         BrokenBlockHandler.pendingActions.setDecayTime(buildConfig.actionTimeout * 50L)
     }
 }
diff --git a/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakConfig.kt b/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakConfig.kt
@@ -48,7 +48,6 @@ interface BreakConfig : ActionConfig, ISettingGroup {
 
     val breakConfirmation: BreakConfirmationMode
     val breaksPerTick: Int
-    val maxPendingBreaks: Int
 
     val avoidLiquids: Boolean
     val avoidSupporting: Boolean
diff --git a/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt b/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt
@@ -99,7 +99,6 @@ import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
 import kotlin.math.max
-import kotlin.math.min
 
 /**
  * Manager responsible for breaking blocks in the most efficient manner possible. It can be accessed
@@ -412,12 +411,7 @@ object BreakManager : Manager<BreakRequest>(
             }
 
         breaks = newBreaks
-            .take(
-                min(
-                    breakConfig.maxPendingBreaks - pendingBreakCount,
-                    buildConfig.maxPendingActions - request.pendingInteractions.size
-                ).coerceAtLeast(0)
-            )
+            .take(buildConfig.maxPendingActions - request.pendingInteractions.size.coerceAtLeast(0))
             .toMutableList()
 
         logger.debug("${breaks.size} unprocessed breaks")
diff --git a/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractConfig.kt b/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractConfig.kt
@@ -30,7 +30,6 @@ interface InteractConfig : ActionConfig, ISettingGroup {
     val axisRotate get() = rotate && airPlace.isEnabled && axisRotateSetting
     val interactConfirmationMode: InteractConfirmationMode
     val interactDelay: Int
-	val maxPendingInteractions: Int
     val interactionsPerTick: Int
     val swing: Boolean
     val swingType: BuildConfig.SwingType
diff --git a/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractManager.kt b/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractManager.kt
@@ -68,7 +68,6 @@ import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.world.GameMode
-import kotlin.math.min
 
 object InteractManager : Manager<InteractRequest>(
     0,
@@ -209,12 +208,7 @@ object InteractManager : Manager<InteractRequest>(
         potentialPlacements = request.contexts
             .distinctBy { it.blockPos }
             .filter { !isPosBlocked(it.blockPos) }
-            .take(
-                min(
-                    interactConfig.maxPendingInteractions - pendingActions.size,
-                    buildConfig.maxPendingActions - request.pendingInteractions.size
-                ).coerceAtLeast(0)
-            )
+            .take(buildConfig.maxPendingActions - request.pendingInteractions.size.coerceAtLeast(0))
             .toMutableList()
         logger.debug("${potentialPlacements.size} potential placements")
 
diff --git a/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt b/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt
@@ -39,16 +39,22 @@ object FastBreak : Module(
     init {
 		setDefaultAutomationConfig {
 			applyEdits {
-				hideAllGroupsExcept(breakConfig, rotationConfig, hotbarConfig)
+				hideAllGroupsExcept(buildConfig, breakConfig, rotationConfig, hotbarConfig)
 				buildConfig.apply {
-					editTyped(
+					hide(
 						::pathing,
 						::stayInRange,
-						::useDefaultReach,
+						::spleefEntities,
+						::maxBuildDependencies,
+						::collectDrops,
+						::interactReach,
+						::attackReach
+					)
+					::maxBuildDependencies.edit { defaultValue(0) }
+					editTyped(
 						::checkSideVisibility,
 						::strictRayCast
-					) { defaultValue(false) }
-					::actionsPerTick.edit { defaultValue(1) }
+					) { defaultValue(false); hide() }
 					::interactReach.edit { defaultValue(Double.MAX_VALUE) }
 				}
 				breakConfig.apply {
@@ -64,7 +70,6 @@ object FastBreak : Module(
 					) { defaultValue(false); hide() }
 					::breaksPerTick.edit { defaultValue(1); hide() }
 					::tickStageMask.edit { defaultValue(mutableSetOf(TickEvent.Input.Post)); hide() }
-					::maxPendingBreaks.edit { defaultValue(Int.MAX_VALUE); hide() }
 					hide(::sorter, ::unsafeCancels)
 				}
 				hotbarConfig::tickStageMask.edit { defaultValue(mutableSetOf(TickEvent.Input.Post)); hide() }
diff --git a/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt b/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt
@@ -99,7 +99,18 @@ object PacketMine : Module(
     init {
 		setDefaultAutomationConfig {
 			applyEdits {
-				hideAllGroupsExcept(breakConfig, rotationConfig, hotbarConfig)
+				hideAllGroupsExcept(buildConfig, breakConfig, rotationConfig, hotbarConfig)
+                buildConfig.apply {
+                    hide(
+                        ::pathing,
+                        ::stayInRange,
+                        ::spleefEntities,
+                        ::maxBuildDependencies,
+                        ::collectDrops,
+                        ::attackReach
+                    )
+                    ::maxBuildDependencies.edit { defaultValue(0) }
+                }
 				breakConfig.apply {
 					editTyped(
 						::avoidLiquids,
@@ -156,7 +167,7 @@ object PacketMine : Module(
         listen<TickEvent.Input.Post> {
             if (!attackedThisTick) {
                 requestBreakManager((breakPositions + queueSorted.flatten()).toList())
-                if (!breakConfig.rebreak || (rebreakMode != RebreakMode.Auto && rebreakMode != RebreakMode.AutoConstant)) return@listen
+                if (!breakConfig.rebreak || (rebreakMode != RebreakMode.Auto /*&& rebreakMode != RebreakMode.AutoConstant*/)) return@listen
                 val reBreak = rebreakPos ?: return@listen
                 requestBreakManager(listOf(reBreak), true)
             }
@@ -194,7 +205,19 @@ object PacketMine : Module(
 
     private fun SafeContext.requestBreakManager(requestPositions: Collection<BlockPos?>, reBreaking: Boolean = false) {
         if (requestPositions.count { it != null } <= 0) return
-        val breakContexts = breakContexts(requestPositions)
+        val breakContexts = runSafeAutomated {
+            requestPositions
+                .filterNotNull()
+                .associateWith { TargetState.Empty }
+                .simulate()
+                .filterIsInstance<BreakResult.Break>()
+                .let {
+                    if (queueOrder == QueueOrder.Efficient) it.sorted()
+                    else it.sortedBy { ctx -> requestPositions.indexOf(ctx.pos) }
+                }
+                .map { it.context }
+
+        }
         if (!reBreaking) {
             queuePositions.retainAllPositions(breakContexts)
         }
@@ -215,21 +238,6 @@ object PacketMine : Module(
         }
     }
 
-    private fun SafeContext.breakContexts(positions: Collection<BlockPos?>) =
-        runSafeAutomated {
-            positions
-                .filterNotNull()
-                .associateWith { TargetState.Empty }
-                .simulate()
-                .filterIsInstance<BreakResult.Break>()
-                .let {
-                    if (queueOrder == QueueOrder.Efficient) it.sorted()
-                    else it.sortedBy { ctx -> positions.indexOf(ctx.pos) }
-                }
-                .map { it.context }
-
-        }
-
     private fun addBreak(pos: BlockPos) {
         if (breakConfig.doubleBreak && breakPositions[0] != null) {
             breakPositions[1] = breakPositions[0]
@@ -283,7 +291,7 @@ object PacketMine : Module(
         Manual("Manual", "Re-break only when you trigger it explicitly."),
         Auto("Auto", "Automatically re-break when it’s beneficial or required."),
         //ToDo: Implement auto constant rebreak
-        AutoConstant("Auto (Constant)", "Continuously re-break as soon as conditions allow; most aggressive.")
+//        AutoConstant("Auto (Constant)", "Continuously re-break as soon as conditions allow; most aggressive.")
     }
 
     enum class QueueOrder(

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ abstract class PostActionHandler<T : ActionInfo> {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`fun Automated.setPendingConfigs() {`
`55`		`- BrokenBlockHandler.pendingActions.setSizeLimit(breakConfig.maxPendingBreaks)`
	`55`	`+ BrokenBlockHandler.pendingActions.setSizeLimit(buildConfig.maxPendingActions)`
`56`	`56`	`BrokenBlockHandler.pendingActions.setDecayTime(buildConfig.actionTimeout * 50L)`
`57`	`57`	`}`
`58`	`58`	`}`