moved request updates in break manager to on tick to remove needless tick delay if rotations are already complete or disabled, and improved general request handling logic

Author: beanbag44

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

@@ -40,7 +40,7 @@ class BreakSettings(
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() }
     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", 5, 1..30, 1, "The maximum amount of pending breaks") { vis() }
-    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
+    override val instantBreaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { 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/request/breaking/BreakConfig.kt

@@ -37,7 +37,7 @@ abstract class BreakConfig(
     abstract val rotateForBreak: Boolean
     abstract val breakConfirmation: BreakConfirmationMode
     abstract val maxPendingBreaks: Int
-    abstract val breaksPerTick: Int
+    abstract val instantBreaksPerTick: Int
     abstract val breakWeakBlocks: Boolean
     abstract val forceSilkTouch: Boolean
     abstract val forceFortunePickaxe: Boolean

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

@@ -37,9 +37,6 @@ import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
 import com.lambda.interaction.request.breaking.BreakConfig.BreakMode
 import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
-import com.lambda.interaction.request.placing.PlaceManager
-import com.lambda.interaction.request.rotation.RotationManager.onRotate
-import com.lambda.interaction.request.rotation.RotationManager.onRotatePost
 import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.util.BlockUtils.blockState
@@ -87,7 +84,8 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         get() = breakingInfos.mapNotNull { it?.context?.expectedPos } + pendingBreaks.map { it.context.expectedPos }
 
     private var rotation: RotationRequest? = null
-    private var validRotation = false
+    private val validRotation
+        get() = rotation?.done ?: true
 
     private var blockBreakingCooldown = 0
 
@@ -111,62 +109,43 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
 
     init {
         listen<TickEvent.Pre>(priority = Int.MIN_VALUE + 1) {
-            if (isOnBreakCooldown()) {
-                blockBreakingCooldown--
-                return@listen
-            }
-            if (PlaceManager.activeThisTick()) return@listen
-
-            currentRequest?.let request@ { request ->
-                if (instantBreaks.isEmpty()) return@request
-
-                instantBreaks
-                    .sortedBy { HotbarManager.serverSlot == it.hotbarIndex }
-                    .forEach { ctx ->
-                        val breakInfo = handleRequestContext(ctx, request) ?: return@request
-                        if (!breakInfo.requestHotbarSwap()) return@forEach
-                        updateBlockBreakingProgress(breakInfo)
-                        activeThisTick = true
-                    }
-                instantBreaks = emptyList()
-            }
-
-            if (!validRotation) return@listen
-
-            // Reversed so that the breaking order feels natural to the user as the primary break has to
-            // be started after the secondary
-            breakingInfos
-                .filterNotNull()
-                .reversed()
-                .forEach { info ->
-                    if (!info.requestHotbarSwap()) return@forEach
-                    updateBlockBreakingProgress(info)
-                    activeThisTick = true
-                }
-        }
-
-        onRotate(priority = Int.MIN_VALUE) {
             preEvent()
 
-            if (!updateRequest()) {
-                requestRotate()
-                return@onRotate
-            }
+            if (updateRequest()) currentRequest?.let request@ { request ->
+                if (isOnBreakCooldown()) {
+                    blockBreakingCooldown--
+                    return@request
+                }
 
-            currentRequest?.let request@ { request ->
                 val breakConfig = request.buildConfig.breakSettings
-                val takeCount = breakConfig.maxPendingBreaks - (breakingInfos.count { it != null } + pendingBreaks.size)
-                if (takeCount <= 0) return@request
+                val maxBreaksThisTick = breakConfig.maxPendingBreaks - (breakingInfos.count { it != null } + pendingBreaks.size)
+                if (maxBreaksThisTick <= 0) return@request
+
                 val validContexts = request.contexts
                     .filter { ctx -> canAccept(ctx) }
                     .sortedBy { it.instantBreak }
-                    .take(takeCount)
+                    .take(maxBreaksThisTick)
 
                 instantBreaks = validContexts
-                    .take(breakConfig.breaksPerTick)
+                    .take(breakConfig.instantBreaksPerTick)
                     .filter { it.instantBreak }
+                    .sortedBy { it.hotbarIndex == HotbarManager.serverSlot }
 
-                if (instantBreaks.isNotEmpty()) return@request
+                if (instantBreaks.isNotEmpty()) {
+                    instantBreaks.forEach { ctx ->
+                        if (ctx.hotbarIndex != HotbarManager.serverSlot) {
+                            if (!request.hotbarConfig.request(HotbarRequest(ctx.hotbarIndex)).done) return@request
+                        }
+                        val breakInfo = handleRequestContext(ctx, request) ?: return@request
+                        updateBlockBreakingProgress(breakInfo)
+                        activeThisTick = true
+                    }
+                    if (instantBreaks.size == breakConfig.instantBreaksPerTick) {
+                        instantBreaks = emptyList()
+                        return@request
+                    }
+                    instantBreaks = emptyList()
+                }
 
                 validContexts
                     .filter { it.instantBreak.not() }
@@ -176,11 +155,19 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             }
 
             requestRotate()
-        }
+            if (!validRotation) return@listen
 
-        onRotatePost(priority = Int.MIN_VALUE) {
-            validRotation = rotation?.done ?: true
-            postEvent()
+            // ToDo: dynamically update hotbarIndex as contexts are persistent and don't get updated by new requests each tick
+            // Reversed so that the breaking order feels natural to the user as the primary break has to
+            // be started after the secondary
+            breakingInfos
+                .filterNotNull()
+                .reversed()
+                .forEach { info ->
+                    if (!info.requestHotbarSwap()) return@forEach
+                    updateBlockBreakingProgress(info)
+                    activeThisTick = true
+                }
         }
 
         listen<WorldEvent.BlockUpdate.Server> { event ->
@@ -282,7 +269,8 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         primaryBreakingInfo?.let { primaryInfo ->
             if (!primaryInfo.breakConfig.doubleBreak
                 || primaryInfo.startedWithSecondary
-                || secondaryBreakingInfo != null) {
+                || secondaryBreakingInfo != null
+                || requestCtx.hotbarIndex != primaryInfo.context.hotbarIndex) {
                 return null
             }
 

common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -142,9 +142,9 @@ class BuildTask @Ta5kBuilder constructor(
                             val breakResults = resultsNotBlocked
                                 .filterIsInstance<BreakResult.Break>()
 
-                            if (build.breakSettings.breaksPerTick > 1) {
+                            if (build.breakSettings.instantBreaksPerTick > 1) {
                                 val takeCount = build.breakSettings
-                                    .breaksPerTick
+                                    .instantBreaksPerTick
                                     .coerceAtMost(emptyPendingInteractionSlots)
                                 val instantBreakResults = breakResults
                                     .filter { it.context.instantBreak }