move rebreak logic into startBreaking function to account for instant breakable blocks too

Author: beanbag44

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

@@ -324,7 +324,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                                 }
                                 return@also
                             }
-                            if (!info.context.requestSwap(info.request, 0)) return@run
+                            if (!info.context.requestSwap(info.request)) return@run
                         }
                     }
                     .asReversed()
@@ -333,28 +333,6 @@ object BreakManager : RequestHandler<BreakRequest>(
                         if (tickStage !in info.breakConfig.breakStageMask) return@forEach
                         if (!rotated && info.isPrimary) return@run
 
-                        if (info.couldReBreak.value == true) 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)
                     }
             }
@@ -657,31 +635,31 @@ 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
         val ctx = info.context
-        val hitResult = ctx.result
-
-        if (gamemode.isCreative && world.worldBorder.contains(ctx.blockPos) && info.breaking) {
-            breakCooldown = config.breakDelay
-            lastPosStarted = ctx.blockPos
-            onBlockBreak(info)
-            info.startBreakPacket(world, interaction)
-            if (config.swing.isEnabled()) {
-                swingHand(config.swingType, Hand.MAIN_HAND)
-            }
-            return true
-        }
 
         if (!info.breaking) {
             if (!startBreaking(info)) {
                 info.nullify()
-                info.request.onCancel?.invoke(info.context.blockPos)
+                info.request.onCancel?.invoke(ctx.blockPos)
                 return false
             }
             val swing = config.swing
-            if (swing.isEnabled() && swing != BreakConfig.SwingMode.End) {
+            if (swing.isEnabled() && (swing != BreakConfig.SwingMode.End || info.isReBreaking)) {
+                swingHand(config.swingType, Hand.MAIN_HAND)
+            }
+            return true
+        }
+
+        info.progressedThisTick = true
+        val hitResult = ctx.result
+
+        if (gamemode.isCreative && world.worldBorder.contains(ctx.blockPos)) {
+            breakCooldown = config.breakDelay
+            lastPosStarted = ctx.blockPos
+            onBlockBreak(info)
+            info.startBreakPacket(world, interaction)
+            if (config.swing.isEnabled()) {
                 swingHand(config.swingType, Hand.MAIN_HAND)
             }
             return true
@@ -690,7 +668,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         val blockState = blockState(ctx.blockPos)
         if (blockState.isEmpty || blockState.isAir) {
             info.nullify()
-            info.request.onCancel?.invoke(info.context.blockPos)
+            info.request.onCancel?.invoke(ctx.blockPos)
             return false
         }
 
@@ -756,6 +734,28 @@ object BreakManager : RequestHandler<BreakRequest>(
     private fun SafeContext.startBreaking(info: BreakInfo): Boolean {
         val ctx = info.context
 
+        if (info.couldReBreak.value == true) 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)
+                }
+
+                primaryBreak?.let { primary ->
+                    updateBreakProgress(primary)
+                }
+                return true
+            }
+            is ReBreakResult.ReBroke -> {
+                info.type = ReBreak
+                info.nullify()
+                info.request.onReBreak?.invoke(ctx.blockPos)
+                return true
+            }
+            else -> {}
+        }
+
         if (player.isBlockBreakingRestricted(world, ctx.blockPos, gamemode)) return false
         if (!world.worldBorder.contains(ctx.blockPos)) return false