update cancels on each stage close with mask checks

beanbag44 · beanbag44 · commit 5e266e326b27 · 2025-07-27T18:19:42.000+01:00
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakInfo.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakInfo.kt
@@ -37,7 +37,7 @@ data class BreakInfo(
     override val pendingInteractionsList get() = request.pendingInteractions
 
     var updatedThisTick = true
-    var updatedProgressThisTick = false
+    var progressedThisTick = false
 
     var breaking = false
     var abandoned = false
@@ -79,11 +79,12 @@ data class BreakInfo(
         updatedThisTick = true
         this.context = context
         request?.let { this.request = it }
+        if (isRedundant) type = BreakType.Secondary
     }
 
     fun tickStats() {
         updatedThisTick = false
-        updatedProgressThisTick = false
+        progressedThisTick = false
     }
 
     fun resetCallbacks() {
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt
@@ -46,13 +46,14 @@ import com.lambda.interaction.request.breaking.BreakManager.breakInfos
 import com.lambda.interaction.request.breaking.BreakManager.breaks
 import com.lambda.interaction.request.breaking.BreakManager.canAccept
 import com.lambda.interaction.request.breaking.BreakManager.cancelBreak
+import com.lambda.interaction.request.breaking.BreakManager.checkForCancels
 import com.lambda.interaction.request.breaking.BreakManager.initNewBreak
 import com.lambda.interaction.request.breaking.BreakManager.instantBreaks
-import com.lambda.interaction.request.breaking.BreakManager.makeRedundant
 import com.lambda.interaction.request.breaking.BreakManager.maxBreaksThisTick
 import com.lambda.interaction.request.breaking.BreakManager.performInstantBreaks
 import com.lambda.interaction.request.breaking.BreakManager.processNewBreaks
 import com.lambda.interaction.request.breaking.BreakManager.processRequest
+import com.lambda.interaction.request.breaking.BreakManager.simulateAbandoned
 import com.lambda.interaction.request.breaking.BreakManager.updateBreakProgress
 import com.lambda.interaction.request.breaking.BreakType.Primary
 import com.lambda.interaction.request.breaking.BreakType.ReBreak
@@ -91,7 +92,8 @@ object BreakManager : RequestHandler<BreakRequest>(
     TickEvent.Input.Pre,
     TickEvent.Input.Post,
     TickEvent.Player.Post,
-    onOpen = { processRequest(activeRequest) }
+    onOpen = { simulateAbandoned(); processRequest(activeRequest) },
+    onClose = { checkForCancels() }
 ), PositionBlocking {
     private var primaryBreak: BreakInfo?
         get() = breakInfos[0]
@@ -134,41 +136,12 @@ object BreakManager : RequestHandler<BreakRequest>(
     override fun load(): String {
         super.load()
 
-        listen<TickEvent.Pre>(priority = Int.MAX_VALUE) {
-            // Cancelled but double breaking so requires break manager to continue the simulation
-            breakInfos
-                .asSequence()
-                .filterNotNull()
-                .filter { it.abandoned && !it.isRedundant }
-                .forEach { info ->
-                    with (info.request) {
-                        info.context.blockPos
-                            .toStructure(TargetState.Empty)
-                            .toBlueprint()
-                            .simulate(player.eyePos, interact, rotation, inventory, build)
-                            .asSequence()
-                            .filterIsInstance<BreakResult.Break>()
-                            .sorted()
-                            .let { sim ->
-                                info.updateInfo(sim.firstOrNull()?.context ?: return@forEach)
-                            }
-                    }
-                }
-        }
-
         listen<TickEvent.Post>(priority = Int.MIN_VALUE) {
             if (breakCooldown > 0) {
                 breakCooldown--
             }
             breakInfos.forEach { info ->
-                info?.apply {
-                    if (isRedundant) updateBreakProgress(this)
-                    else if (!updatedThisTick) {
-                        this.cancelBreak()
-                        return@apply
-                    }
-                    tickStats()
-                }
+                info?.tickStats()
             }
             activeRequest = null
             breaks = mutableListOf()
@@ -305,7 +278,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                     }
                     .asReversed()
                     .forEach { info ->
-                        if (info.updatedProgressThisTick) return@forEach
+                        if (info.progressedThisTick) return@forEach
                         val minKeepTicks = if (info.isSecondary) {
                             val breakDelta = info.context.cachedState.calcBreakDelta(
                                 player,
@@ -334,6 +307,39 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
     }
 
+    private fun SafeContext.simulateAbandoned() {
+        // Cancelled but double breaking so requires break manager to continue the simulation
+        breakInfos
+            .asSequence()
+            .filterNotNull()
+            .filter { it.abandoned && !it.isRedundant }
+            .forEach { info ->
+                with (info.request) {
+                    info.context.blockPos
+                        .toStructure(TargetState.Empty)
+                        .toBlueprint()
+                        .simulate(player.eyePos, interact, rotation, inventory, build)
+                        .asSequence()
+                        .filterIsInstance<BreakResult.Break>()
+                        .sorted()
+                        .let { sim ->
+                            info.updateInfo(sim.firstOrNull()?.context ?: return@forEach)
+                        }
+                }
+            }
+    }
+
+    private fun SafeContext.checkForCancels() {
+        breakInfos
+            .filterNotNull()
+            .asSequence()
+            .filter { !it.updatedThisTick && tickStage in it.breakConfig.breakStageMask }
+            .forEach { info ->
+                if (info.isRedundant && !info.progressedThisTick) updateBreakProgress(info)
+                else info.cancelBreak()
+            }
+    }
+
     /**
      * Filters the requests [BreakContext]s, and iterates over the [breakInfos] collection looking for matches
      * in positions. If a match is found, the [BreakInfo] is updated with the new context. Otherwise, the break is cancelled.
@@ -362,15 +368,13 @@ object BreakManager : RequestHandler<BreakRequest>(
                 newBreaks.find { ctx -> ctx.blockPos == info.context.blockPos }?.let { ctx ->
                     if (!info.updatedThisTick || info.abandoned) {
                         info.updateInfo(ctx, request)
-                        if (info.isRedundant) {
-                            info.type = BreakType.Secondary
+                        if (info.isRedundant)
                             info.request.onStart?.invoke(info.context.blockPos)
-                        } else if (info.abandoned) {
+                        else if (info.abandoned) {
                             info.abandoned = false
                             info.request.onStart?.invoke(info.context.blockPos)
-                        } else {
+                        } else
                             info.request.onUpdate?.invoke(info.context.blockPos)
-                        }
                     }
                     newBreaks.remove(ctx)
                     return@forEach
@@ -552,8 +556,6 @@ object BreakManager : RequestHandler<BreakRequest>(
      *
      * If the user has [BreakConfig.unsafeCancels] enabled, the info is made redundant, and mostly ignored.
      * If not, the break continues.
-     *
-     * @see makeRedundant
      */
     private fun BreakInfo.cancelBreak() =
         runSafe {
@@ -564,7 +566,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                 request.onCancel?.invoke(context.blockPos)
             } else if (isSecondary) {
                 if (breakConfig.unsafeCancels) {
-                    makeRedundant()
+                    type = BreakType.RedundantSecondary
                     setBreakingTextureStage(player, world, -1)
                     request.onCancel?.invoke(context.blockPos)
                 } else {
@@ -578,13 +580,6 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun BreakInfo.nullify() = type.nullify()
 
-    /**
-     * Makes the [BreakInfo] redundant and triggers the [BreakInfo.internalOnCancel] callback
-     */
-    private fun BreakInfo.makeRedundant() {
-        type = BreakType.RedundantSecondary
-    }
-
     /**
      * Nullifies the [BreakInfo] reference in the [breakInfos] array based on the [BreakType]
      */
@@ -603,8 +598,9 @@ object BreakManager : RequestHandler<BreakRequest>(
      * @see net.minecraft.client.network.ClientPlayerInteractionManager.updateBlockBreakingProgress
      */
     private fun SafeContext.updateBreakProgress(info: BreakInfo): Boolean {
+        info.progressedThisTick = true
+
         val config = info.breakConfig
-        info.updatedProgressThisTick = true
         val ctx = info.context
         val hitResult = ctx.result
 
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/hotbar/HotbarManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/hotbar/HotbarManager.kt
@@ -82,7 +82,7 @@ object HotbarManager : RequestHandler<HotbarRequest>(
 
         val sameButLonger = activeRequest?.let { active ->
             request.slot == active.slot && request.keepTicks >= active.keepTicks
-        } ?: false
+        } == true
 
         if (sameButLonger) activeRequest?.let { current ->
             request.swapPauseAge = current.swapPauseAge
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt b/common/src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt
@@ -17,7 +17,6 @@
 
 package com.lambda.module.modules.player
 
-import com.lambda.context.SafeContext
 import com.lambda.event.events.PacketEvent
 import com.lambda.event.events.PlayerEvent
 import com.lambda.event.events.RenderEvent
@@ -28,7 +27,6 @@ import com.lambda.graphics.renderer.esp.builders.buildOutline
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.math.lerp
-import com.lambda.util.math.transform
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
 import net.minecraft.util.math.Box
@@ -61,9 +59,6 @@ object FastBreak : Module(
     private val endOutlineColour by setting("End Outline Colour", Color(0f, 1f, 0f, 0.3f), "The colour used to render the end outline of the box") { page == Page.Render && render && renderSetting != RenderSetting.Fill && outlineColourMode == ColourMode.Dynamic }
     private val outlineWidth by setting("Outline Width", 1f, 0f..3f, 0.1f, "the thickness of the outline") { page == Page.Render && render && renderSetting != RenderSetting.Fill }
 
-
-    private var boxSet = emptySet<Box>()
-
     init {
         listen<PacketEvent.Send.Pre> {
             if (it.packet !is PlayerActionC2SPacket
