move re break checks to the processRequest function and decouple checks for if a break info can be re broken and the act of re breaking

Author: beanbag44

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

@@ -19,6 +19,7 @@ package com.lambda.interaction.request.breaking
 
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.request.ActionInfo
+import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.client.network.ClientPlayerInteractionManager
@@ -41,6 +42,12 @@ data class BreakInfo(
     var progressedThisTick = false
     var serverBreakTicks = 0
 
+    var couldReBreak = lazy {
+        runSafe {
+            ReBreakManager.couldReBreak(this@BreakInfo, player, world)
+        } == true
+    }
+
     var breaking = false
     var abandoned = false
     var breakingTicks = 0
@@ -100,7 +107,9 @@ data class BreakInfo(
         val breakProgress = breakDelta * ((breakingTicks + 1) - breakConfig.fudgeFactor).let {
             if (isSecondary) it + 1 else it
         }
-        return when (breakConfig.swapMode) {
+        return if (couldReBreak.value)
+            breakConfig.swapMode.isEnabled()
+        else when (breakConfig.swapMode) {
             BreakConfig.SwapMode.None -> false
             BreakConfig.SwapMode.Start -> !breaking
             BreakConfig.SwapMode.End -> breakProgress >= getBreakThreshold()

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

@@ -329,6 +329,28 @@ object BreakManager : RequestHandler<BreakRequest>(
                         if (tickStage !in info.breakConfig.breakStageMask) return@forEach
                         if (!rotated && info.isPrimary) return@run
 
+                        if (info.couldReBreak.value) when (val reBreakResult = ReBreakManager.handleUpdate(info.context, info.request)) {
+                            is ReBreakResult.StillBreaking -> {
+                                primaryBreak = reBreakResult.breakInfo.apply {
+                                    type = Primary
+                                    ReBreakManager.clearReBreak()
+                                    request.onStart?.invoke(info.context.blockPos)
+                                }
+
+                                primaryBreak?.let { primary ->
+                                    updateBreakProgress(primary)
+                                }
+                                return@forEach
+                            }
+                            is ReBreakResult.ReBroke -> {
+                                info.type = ReBreak
+                                info.nullify()
+                                info.request.onReBreak?.invoke(info.context.blockPos)
+                                return@forEach
+                            }
+                            else -> {}
+                        }
+
                         updateBreakProgress(info)
                     }
             }
@@ -649,26 +671,6 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         if (!info.breaking) {
-            when (val reBreakResult = ReBreakManager.handleUpdate(info.context, info.request)) {
-                is ReBreakResult.StillBreaking -> {
-                    primaryBreak = reBreakResult.breakInfo.apply {
-                        type = Primary
-                        ReBreakManager.clearReBreak()
-                        request.onStart?.invoke(ctx.blockPos)
-                    }
-
-                    return primaryBreak?.let { primary ->
-                        updateBreakProgress(primary)
-                    } == true
-                }
-                is ReBreakResult.ReBroke -> {
-                    info.type = ReBreak
-                    info.nullify()
-                    info.request.onReBreak?.invoke(info.context.blockPos)
-                    return true
-                }
-                else -> {}
-            }
             if (!startBreaking(info)) {
                 info.nullify()
                 info.request.onCancel?.invoke(info.context.blockPos)

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

@@ -24,9 +24,11 @@ import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.destroyBlock
 import com.lambda.threading.runSafe
-import com.lambda.util.BlockUtils.isEmpty
+import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.player.swingHand
+import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.util.Hand
+import net.minecraft.world.BlockView
 
 object ReBreakManager {
     var reBreak: BreakInfo? = null
@@ -65,35 +67,38 @@ object ReBreakManager {
         reBreak = null
     }
 
+    fun couldReBreak(info: BreakInfo, player: ClientPlayerEntity, world: BlockView) =
+        reBreak?.let { reBreak ->
+            val stack = if (info.breakConfig.swapMode.isEnabled())
+                player.inventory.getStack(info.context.hotbarIndex)
+            else player.mainHandStack
+            val breakDelta = info.context.cachedState.calcItemBlockBreakingDelta(player, world, info.context.blockPos, stack)
+            reBreak.breakConfig.reBreak &&
+                    info.context.blockPos == reBreak.context.blockPos &&
+                    !reBreak.updatedThisTick &&
+                    ((reBreak.breakingTicks - info.breakConfig.fudgeFactor) * breakDelta >= info.breakConfig.breakThreshold)
+        } == true
+
     fun handleUpdate(ctx: BreakContext, breakRequest: BreakRequest) =
         runSafe {
-            val info = reBreak ?: return@runSafe ReBreakResult.Ignored
-
-            if (info.context.blockPos != ctx.blockPos || !info.breakConfig.reBreak) {
-                return@runSafe ReBreakResult.Ignored
-            }
-            if (info.updatedThisTick) return@runSafe ReBreakResult.ReBroke
-            info.updateInfo(ctx, breakRequest)
+            val reBreak = this@ReBreakManager.reBreak ?: return@runSafe ReBreakResult.Ignored
 
-            val context = info.context
+            reBreak.updateInfo(ctx, breakRequest)
 
-            val breakProgress = context.cachedState.calcBlockBreakingDelta(player, world, context.blockPos)
-            return@runSafe if ((info.breakingTicks - info.breakConfig.fudgeFactor) * breakProgress >= info.breakConfig.breakThreshold) {
-                if (context.cachedState.isEmpty) {
-                    return@runSafe ReBreakResult.Ignored
-                }
-                if (info.breakConfig.breakConfirmation != BreakConfig.BreakConfirmationMode.AwaitThenBreak) {
-                    destroyBlock(info)
+            val context = reBreak.context
+            val breakDelta = context.cachedState.calcBlockBreakingDelta(player, world, context.blockPos)
+            return@runSafe if ((reBreak.breakingTicks - reBreak.breakConfig.fudgeFactor) * breakDelta >= reBreak.breakConfig.breakThreshold) {
+                if (reBreak.breakConfig.breakConfirmation != BreakConfig.BreakConfirmationMode.AwaitThenBreak) {
+                    destroyBlock(reBreak)
                 }
-                info.stopBreakPacket(world, interaction)
-                val swing = info.breakConfig.swing
-                if (swing.isEnabled() && swing != BreakConfig.SwingMode.Start) {
-                    swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+                reBreak.stopBreakPacket(world, interaction)
+                if (reBreak.breakConfig.swing.isEnabled()) {
+                    swingHand(reBreak.breakConfig.swingType, Hand.MAIN_HAND)
                 }
                 BreakManager.breaksThisTick++
                 ReBreakResult.ReBroke
             } else {
-                ReBreakResult.StillBreaking(info)
+                ReBreakResult.StillBreaking(reBreak)
             }
         }
 }