looser redundant break handling when considered broken

Author: beanbag44

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

@@ -406,25 +406,29 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun SafeContext.onBlockBreak(info: BreakInfo) {
         info.request.onStop?.invoke(info.context.expectedPos)
-        when (info.breakConfig.breakConfirmation) {
-            BreakConfirmationMode.None -> {
-                destroyBlock(info)
-                info.internalOnBreak()
-                if (!info.callbacksCompleted) {
+        if (info.isRedundant) {
+            info.startPending()
+        } else {
+            when (info.breakConfig.breakConfirmation) {
+                BreakConfirmationMode.None -> {
+                    destroyBlock(info)
+                    info.internalOnBreak()
+                    if (!info.callbacksCompleted) {
+                        info.startPending()
+                    } else {
+                        ReBreakManager.offerReBreak(info)
+                    }
+                }
+                BreakConfirmationMode.BreakThenAwait -> {
+                    destroyBlock(info)
+                    info.startPending()
+                }
+                BreakConfirmationMode.AwaitThenBreak -> {
                     info.startPending()
-                } else {
-                    ReBreakManager.offerReBreak(info)
                 }
             }
-            BreakConfirmationMode.BreakThenAwait -> {
-                destroyBlock(info)
-                info.startPending()
-            }
-            BreakConfirmationMode.AwaitThenBreak -> {
-                info.startPending()
-            }
+            breaksThisTick++
         }
-        breaksThisTick++
         info.nullify()
     }
 
@@ -508,8 +512,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             lastPosStarted = ctx.expectedPos
             onBlockBreak(info)
             info.startBreakPacket(world, interaction)
-            val swing = config.swing
-            if (swing.isEnabled()) {
+            if (config.swing.isEnabled()) {
                 swingHand(config.swingType, Hand.MAIN_HAND)
             }
             return true

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

@@ -88,7 +88,7 @@ object BrokenBlockHandler {
                     return@listen
                 }
 
-                if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak) {
+                if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak || pending.isRedundant) {
                     destroyBlock(pending)
                 }
                 pending.internalOnBreak()

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

@@ -74,7 +74,10 @@ object ReBreakManager {
 
             val breakProgress = context.checkedState.calcBlockBreakingDelta(player, world, context.expectedPos)
             return@runSafe if (info.breakingTicks * breakProgress >= info.breakConfig.breakThreshold) {
-                if (!context.checkedState.isEmpty && !awaitThenBreak)  {
+                if (context.checkedState.isEmpty) {
+                    return@runSafe ReBreakResult.Ignored
+                }
+                if (!awaitThenBreak) {
                     destroyBlock(info)
                 }
                 info.stopBreakPacket(world, interaction)