fixe for when unsafe cancels is disabled, and improvements for reviving abandoned and redundant break infos

beanbag44 · beanbag44 · commit 1f63a8bfc630 · 2025-07-14T20:51:01.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
@@ -40,6 +40,7 @@ data class BreakInfo(
     var updatedProgressThisTick = false
 
     var breaking = false
+    var abandoned = false
     var breakingTicks = 0
     var soundsCooldown = 0.0f
 
@@ -78,13 +79,10 @@ data class BreakInfo(
         request.onCancel?.invoke(context.blockPos)
     }
 
-    fun updateInfo(context: BreakContext, request: BreakRequest) {
+    fun updateInfo(context: BreakContext, request: BreakRequest? = null) {
         updatedThisTick = true
         this.context = context
-        this.request = request
-        if (isRedundant) {
-            type = BreakType.Secondary
-        }
+        request?.let { this.request = it }
     }
 
     fun tickStats() {
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
@@ -30,8 +30,13 @@ import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
 import com.lambda.graphics.renderer.esp.builders.buildFilled
 import com.lambda.graphics.renderer.esp.builders.buildOutline
+import com.lambda.interaction.construction.blueprint.Blueprint.Companion.toStructure
+import com.lambda.interaction.construction.blueprint.StaticBlueprint.Companion.toBlueprint
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.processing.ProcessorRegistry
+import com.lambda.interaction.construction.result.BreakResult
+import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
+import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.ManagerUtils.isPosBlocked
 import com.lambda.interaction.request.PositionBlocking
 import com.lambda.interaction.request.Priority
@@ -126,6 +131,28 @@ object BreakManager : RequestHandler<BreakRequest>(
     override fun load(): String {
         super.load()
 
+        listen<TickEvent.Pre>(priority = Int.MIN_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--
@@ -200,7 +227,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                         world,
                         info.context.blockPos,
                         info.breakConfig,
-                        player.inventory.getStack(info.context.hotbarIndex)
+                        if (!info.isRedundant) player.inventory.getStack(info.context.hotbarIndex) else null
                     )
                     val progress = (info.breakingTicks * breakDelta).let {
                         if (info.isPrimary) it * (2 - info.breakConfig.breakThreshold)
@@ -337,9 +364,17 @@ object BreakManager : RequestHandler<BreakRequest>(
             .filterNotNull()
             .forEach { info ->
                 newBreaks.find { ctx -> ctx.blockPos == info.context.blockPos }?.let { ctx ->
-                    if (!info.updatedThisTick) {
+                    if (!info.updatedThisTick || info.abandoned) {
                         info.updateInfo(ctx, request)
-                        info.request.onUpdate?.invoke(info.context.blockPos)
+                        if (info.isRedundant) {
+                            info.type = BreakType.Secondary
+                            info.request.onStart?.invoke(info.context.blockPos)
+                        } else if (info.abandoned) {
+                            info.abandoned = false
+                            info.request.onStart?.invoke(info.context.blockPos)
+                        } else {
+                            info.request.onUpdate?.invoke(info.context.blockPos)
+                        }
                     }
                     newBreaks.remove(ctx)
                     return@forEach
@@ -530,8 +565,9 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (isPrimary) {
                 if (breaking) abortBreakPacket(world, interaction)
                 nullify()
-            } else if (isSecondary && breakConfig.unsafeCancels) {
-                makeRedundant()
+            } else if (isSecondary) {
+                if (breakConfig.unsafeCancels) makeRedundant()
+                else abandoned = true
             }
 
             internalOnCancel()
@@ -755,7 +791,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         item: ItemStack? = null
     ) = runSafe {
         var delta = calcItemBlockBreakingDelta(player, world, pos, item ?: player.inventory.mainHandStack)
-        // This setting requires some fixes / improvements in the player movement prediction to work properly. Currently, its broken
+        //ToDo: This setting requires some fixes / improvements in the player movement prediction to work properly. Currently, it's broken
         if (config.desyncFix) {
             val nextTickPrediction = buildPlayerPrediction().next()
             if (player.isOnGround && !nextTickPrediction.onGround) {
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt
@@ -18,6 +18,8 @@
 package com.lambda.interaction.request.breaking
 
 import com.lambda.config.groups.BuildConfig
+import com.lambda.config.groups.InteractionConfig
+import com.lambda.config.groups.InventoryConfig
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.request.Request
@@ -34,10 +36,12 @@ annotation class BreakRequestBuilder
 
 data class BreakRequest(
     val contexts: Collection<BreakContext>,
-    val build: BuildConfig,
-    val rotation: RotationConfig,
+    val pendingInteractions: MutableCollection<BuildContext>,
     val hotbar: HotbarConfig,
-    val pendingInteractions: MutableCollection<BuildContext>
+    val rotation: RotationConfig,
+    val inventory: InventoryConfig,
+    val interact: InteractionConfig,
+    val build: BuildConfig
 ) : Request(build.breaking) {
     var onStart: ((BlockPos) -> Unit)? = null
     var onUpdate: ((BlockPos) -> Unit)? = null
@@ -53,12 +57,14 @@ data class BreakRequest(
     @BreakRequestBuilder
     class RequestBuilder(
         contexts: Collection<BreakContext>,
-        build: BuildConfig,
+        pendingInteractions: MutableCollection<BuildContext>,
         rotation: RotationConfig,
         hotbar: HotbarConfig,
-        pendingInteractions: MutableCollection<BuildContext>
+        interact: InteractionConfig,
+        inventory: InventoryConfig,
+        build: BuildConfig
     ) {
-        val request = BreakRequest(contexts, build, rotation, hotbar, pendingInteractions)
+        val request = BreakRequest(contexts, pendingInteractions, hotbar, rotation, inventory, interact, build)
 
         @BreakRequestBuilder
         fun onStart(callback: (BlockPos) -> Unit) {
@@ -103,11 +109,13 @@ data class BreakRequest(
         @BreakRequestBuilder
         fun breakRequest(
             contexts: Collection<BreakContext>,
-            build: BuildConfig,
+            pendingInteractions: MutableCollection<BuildContext>,
             rotation: RotationConfig,
             hotbar: HotbarConfig,
-            pendingInteractions: MutableCollection<BuildContext>,
+            interact: InteractionConfig,
+            inventory: InventoryConfig,
+            build: BuildConfig,
             builder: RequestBuilder.() -> Unit
-        ) = RequestBuilder(contexts, build, rotation, hotbar, pendingInteractions).apply(builder).build()
+        ) = RequestBuilder(contexts, pendingInteractions, rotation, hotbar, interact, inventory, build).apply(builder).build()
     }
 }
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BrokenBlockHandler.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BrokenBlockHandler.kt
@@ -92,7 +92,10 @@ object BrokenBlockHandler {
                     return@listen
                 }
 
-                if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak || pending.isRedundant) {
+                if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak
+                    || pending.isRedundant
+                    || (pending.isReBreaking && !pending.breakConfig.reBreak)
+                    ) {
                     destroyBlock(pending)
                 }
                 pending.internalOnBreak()
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt b/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt
@@ -176,7 +176,9 @@ object PacketMine : Module(
         if (!reBreaking) {
             queuePositions.retainAllPositions(breakContexts)
         }
-        val request = breakRequest(breakContexts, build, rotation, hotbar, pendingInteractions) {
+        val request = breakRequest(
+            breakContexts, pendingInteractions, rotation, hotbar, interact, inventory, build,
+        ) {
             onStart { queuePositions.removePos(it); addBreak(it) }
             onUpdate { queuePositions.removePos(it) }
             onStop { removeBreak(it); breaks++ }
diff --git a/common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt b/common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt
@@ -156,7 +156,9 @@ class BuildTask @Ta5kBuilder constructor(
                                 requestContexts.addAll(breakResults.map { it.context })
                             }
 
-                            val request = breakRequest(requestContexts, build, rotation, hotbar, pendingInteractions) {
+                            val request = breakRequest(
+                                requestContexts, pendingInteractions, rotation, hotbar, interact, inventory, build,
+                            ) {
                                 onStop { breaks++ }
                                 onItemDrop?.let { onItemDrop ->
                                     onItemDrop { onItemDrop(it) }

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,10 @@ object BrokenBlockHandler {`
`92`	`92`	`return@listen`
`93`	`93`	`}`
`94`	`94`
`95`		`- if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak \|\| pending.isRedundant) {`
	`95`	`+ if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak`
	`96`	`+ \|\| pending.isRedundant`
	`97`	`+ \|\| (pending.isReBreaking && !pending.breakConfig.reBreak)`
	`98`	`+ ) {`
`96`	`99`	`destroyBlock(pending)`
`97`	`100`	`}`
`98`	`101`	`pending.internalOnBreak()`