move almost all swap data and logic into the SwapInfo class, and add new serverSwap setting.

this seems to be on par with 1.20.4 consistency but there are improvements to be made regarding  speed

Author: beanbag44

src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -50,9 +50,10 @@ class BreakSettings(
 
     // Fixes / Delays
     override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken", visibility = vis).group(groupPath, Group.General)
-    override val fudgeFactor by c.setting("Fudge Factor", 2, 0..5, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break", visibility = vis).group(groupPath, Group.General)
+    override val fudgeFactor by c.setting("Fudge Factor", 1, 0..5, 1, "The number of ticks to add to the break time, usually to account for server lag", visibility = vis).group(groupPath, Group.General)
+    override val serverSwapTicks by c.setting("Server Swap", 1, 0..5, 1, "The number of ticks to give the server time to recognize the player attributes on the swapped item", " tick(s)", visibility = vis).group(groupPath, Group.General)
 //    override val desyncFix by c.setting("Desync Fix", false, "Predicts if the players breaking will be slowed next tick as block break packets are processed using the players next position") { vis() && page == Page.General }
-    override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks", visibility = vis).group(groupPath, Group.General)
+    override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " tick(s)", visibility = vis).group(groupPath, Group.General)
 
     // Timing
     override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post, TickEvent.Player.Post), description = "The sub-tick timing at which break actions can be performed", visibility = vis).group(groupPath, Group.General)

src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt

@@ -28,13 +28,14 @@ import java.awt.Color
 interface BreakConfig : RequestConfig {
     val breakMode: BreakMode
     val sorter: SortMode
-    val breakThreshold: Float
     val rebreak: Boolean
 
     val doubleBreak: Boolean
     val unsafeCancels: Boolean
 
+    val breakThreshold: Float
     val fudgeFactor: Int
+    val serverSwapTicks: Int
     //ToDo: Needs a more advanced player simulation implementation to predict the next ticks onGround / submerged status
 //    abstract val desyncFix: Boolean
     val breakDelay: Int

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.interaction.request.breaking.BreakInfo.BreakType.Primary
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.Describable
 import com.lambda.util.NamedEnum
@@ -31,7 +32,6 @@ import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.item.ItemStack
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
-import net.minecraft.world.BlockView
 
 data class BreakInfo(
     override var context: BreakContext,
@@ -44,10 +44,9 @@ data class BreakInfo(
 
     // Pre Processing
     var shouldProgress = false
-    var couldReBreak by OneSetPerTick(value = RebreakManager.RebreakPotential.None, throwOnLimitBreach = true)
-    var shouldSwap by OneSetPerTick(value = false, throwOnLimitBreach = true)
+    var rebreakPotential by OneSetPerTick(value = RebreakManager.RebreakPotential.None, throwOnLimitBreach = true)
+    var swapInfo by OneSetPerTick(value = SwapInfo.EMPTY, throwOnLimitBreach = true)
     var swapStack: ItemStack by OneSetPerTick(ItemStack.EMPTY, true)
-    var minSwapTicks by OneSetPerTick(0, true)
 
     // BreakInfo Specific
     var updatedThisTick by OneSetPerTick(false, resetAfterTick = true).apply { set(true) }
@@ -60,7 +59,7 @@ data class BreakInfo(
     var breakingTicks by OneSetPerTick(0, true)
     var soundsCooldown by OneSetPerTick(0f, true)
     var vanillaInstantBreakable = false
-    val rebreakable get() = !vanillaInstantBreakable && type == BreakType.Primary
+    val rebreakable get() = !vanillaInstantBreakable && type == Primary
 
     enum class BreakType(
         override val displayName: String,
@@ -70,12 +69,6 @@ data class BreakInfo(
         Secondary("Secondary", "A second block broken at the same time (when double‑break is enabled)."),
         RedundantSecondary("Redundant Secondary", "A previously started secondary break that’s now ignored/monitored only (no new actions)."),
         Rebreak("Rebreak", "A previously broken block which new breaks in the same position can compound progression on. Often rebreaking instantly.");
-
-        fun getBreakThreshold(breakConfig: BreakConfig) =
-            when (this) {
-                Primary -> breakConfig.breakThreshold
-                else -> 1.0f
-            }
     }
 
     // Post Processing
@@ -113,20 +106,6 @@ data class BreakInfo(
         item = null
     }
 
-    fun shouldSwap(player: ClientPlayerEntity, world: BlockView): Boolean {
-        val breakDelta = context.cachedState.calcItemBlockBreakingDelta(player, world, context.blockPos, swapStack)
-        val breakProgress = breakDelta * (breakingTicks + 1)
-        return if (couldReBreak == RebreakManager.RebreakPotential.Instant)
-            breakConfig.swapMode.isEnabled()
-        else when (breakConfig.swapMode) {
-            BreakConfig.SwapMode.None -> false
-            BreakConfig.SwapMode.Start -> !breaking
-            BreakConfig.SwapMode.End -> breakProgress >= getBreakThreshold()
-            BreakConfig.SwapMode.StartAndEnd -> !breaking || breakProgress >= getBreakThreshold()
-            BreakConfig.SwapMode.Constant -> true
-        }
-    }
-
     fun setBreakingTextureStage(
         player: ClientPlayerEntity,
         world: ClientWorld,
@@ -144,7 +123,11 @@ data class BreakInfo(
         return if (progress > 0.0f) (progress * 10.0f).toInt().coerceAtMost(9) else -1
     }
 
-    fun getBreakThreshold() = type.getBreakThreshold(breakConfig)
+    fun getBreakThreshold() =
+        when (type) {
+            Primary -> breakConfig.breakThreshold
+            else -> 1.0f
+        }
 
     fun startBreakPacket(world: ClientWorld, interaction: ClientPlayerInteractionManager) =
         breakPacket(Action.START_DESTROY_BLOCK, world, interaction)

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

@@ -64,6 +64,7 @@ import com.lambda.interaction.request.breaking.BrokenBlockHandler.destroyBlock
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.pendingActions
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.setPendingConfigs
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.startPending
+import com.lambda.interaction.request.breaking.SwapInfo.Companion.getSwapInfo
 import com.lambda.interaction.request.interacting.InteractionManager
 import com.lambda.interaction.request.placing.PlaceManager
 import com.lambda.interaction.request.rotating.RotationRequest
@@ -137,15 +138,15 @@ object BreakManager : RequestHandler<BreakRequest>(
     private var rotationRequest: RotationRequest? = null
     private val rotated get() = rotationRequest?.done != false
 
-    var swappedThisTick = false
-    var heldTicks = 0
-    var swappedStack: ItemStack = ItemStack.EMPTY
+    var currentStack: ItemStack = ItemStack.EMPTY
         set(value) {
             if (value != field)
                 heldTicks = 0
             swappedThisTick = true
             field = value
         }
+    var heldTicks = 0
+    var swappedThisTick = false
     private var breakCooldown = 0
     var breaksThisTick = 0
     private var maxBreaksThisTick = 0
@@ -172,7 +173,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         listen<TickEvent.Post>(priority = Int.MIN_VALUE) {
             if (!swappedThisTick) {
-                swappedStack = player.mainHandStack
+                currentStack = player.mainHandStack
             }
             swappedThisTick = false
             heldTicks++
@@ -416,12 +417,12 @@ object BreakManager : RequestHandler<BreakRequest>(
                 infos.forEach { it.updatePreProcessing(player, world) }
 
                 infos.firstOrNull()?.let { info ->
-                    infos.lastOrNull { it.shouldSwap && it.shouldProgress }?.let { last ->
-                        val minSwapTicks = max(info.minSwapTicks, last.minSwapTicks)
+                    infos.lastOrNull { it.swapInfo.swap && it.shouldProgress }?.let { last ->
+                        val minSwapTicks = max(info.swapInfo.minKeepTicks, last.swapInfo.minKeepTicks)
                         if (!info.context.requestSwap(info.request, minSwapTicks))
                             return false
                         if (minSwapTicks > 0)
-                            swappedStack = info.swapStack
+                            currentStack = info.swapStack
                     }
                 }
             }
@@ -598,31 +599,8 @@ object BreakManager : RequestHandler<BreakRequest>(
         updatedPreProcessingThisTick = true
 
         swapStack = player.inventory.getStack(context.hotbarIndex)
-        couldReBreak = RebreakManager.couldRebreak(this, player, world)
-        shouldSwap = shouldSwap(player, world)
-
-        val cachedState = context.cachedState
-
-        val breakTicks = (breakingTicks + 1 - breakConfig.fudgeFactor).coerceAtLeast(1)
-        val breakAmount = cachedState.calcBreakDelta(
-            player,
-            world,
-            context.blockPos,
-            breakConfig,
-            swapStack
-        ) * breakTicks
-        val breakAmountNoEfficiency = cachedState.calcBreakDelta(
-            player,
-            world,
-            context.blockPos,
-            breakConfig,
-            swapStack,
-            ignoreEfficiency = true
-        ) * breakTicks
-
-        minSwapTicks = if ((breakAmount >= getBreakThreshold() || couldReBreak == RebreakManager.RebreakPotential.Instant) &&
-            (breakAmountNoEfficiency < getBreakThreshold() || type == Secondary)) 1
-        else 0
+        rebreakPotential = RebreakManager.getRebreakPotential(this, player, world)
+        swapInfo = getSwapInfo(this, player, world)
     }
 
     /**
@@ -732,8 +710,6 @@ object BreakManager : RequestHandler<BreakRequest>(
             config
         ) * (info.breakingTicks - config.fudgeFactor)
 
-        val overBreakThreshold = progress >= info.getBreakThreshold()
-
         if (config.sounds) {
             if (info.soundsCooldown % 4.0f == 0.0f) {
                 val blockSoundGroup = blockState.soundGroup
@@ -760,7 +736,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val swing = config.swing
-        if (overBreakThreshold && heldTicks + 1 >= info.breakConfig.fudgeFactor) {
+        if (progress >= info.getBreakThreshold() && info.swapInfo.canCompleteBreak) {
             if (info.type == Primary) {
                 onBlockBreak(info)
                 info.stopBreakPacket(world, interaction)
@@ -786,7 +762,7 @@ object BreakManager : RequestHandler<BreakRequest>(
     private fun SafeContext.startBreaking(info: BreakInfo): Boolean {
         val ctx = info.context
 
-        if (info.couldReBreak.isPossible()) {
+        if (info.rebreakPotential.isPossible()) {
             when (val rebreakResult = RebreakManager.handleUpdate(info.context, info.request)) {
                 is RebreakResult.StillBreaking -> {
                     primaryBreak = rebreakResult.breakInfo.apply {
@@ -827,14 +803,13 @@ object BreakManager : RequestHandler<BreakRequest>(
         lastPosStarted = ctx.blockPos
 
         val blockState = blockState(ctx.blockPos)
-        val notEmpty = blockState.isNotEmpty
-        if (notEmpty && info.breakingTicks == 0) {
+        if (info.breakingTicks == 0) {
             blockState.onBlockBreakStart(world, ctx.blockPos, player)
         }
 
-        val breakDelta = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
-        info.vanillaInstantBreakable = breakDelta >= 1
-        if (notEmpty && breakDelta >= info.getBreakThreshold() && heldTicks + 1 >= info.breakConfig.fudgeFactor) {
+        val progress = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
+        info.vanillaInstantBreakable = progress >= 1 && info.swapInfo.canCompleteBreak
+        if (progress >= info.getBreakThreshold() && info.swapInfo.canCompleteBreak) {
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
         } else {
@@ -854,7 +829,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         info.startBreakPacket(world, interaction)
 
-        if (info.type == Secondary || (!info.vanillaInstantBreakable && breakDelta >= info.breakConfig.breakThreshold)) {
+        if (info.type == Secondary || (!info.vanillaInstantBreakable && progress >= info.breakConfig.breakThreshold)) {
             info.stopBreakPacket(world, interaction)
         }
 

src/main/kotlin/com/lambda/interaction/request/breaking/RebreakManager.kt

@@ -64,7 +64,7 @@ object RebreakManager {
         rebreak = null
     }
 
-    fun couldRebreak(info: BreakInfo, player: ClientPlayerEntity, world: BlockView) =
+    fun getRebreakPotential(info: BreakInfo, player: ClientPlayerEntity, world: BlockView) =
         rebreak?.let { reBreak ->
             val stack = if (info.breakConfig.swapMode.isEnabled())
                 info.swapStack
@@ -109,6 +109,6 @@ object RebreakManager {
         PartialProgress,
         None;
 
-        fun isPossible() = this == Instant || this == PartialProgress
+        fun isPossible() = this != None
     }
 }

src/main/kotlin/com/lambda/interaction/request/breaking/SwapInfo.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.interaction.request.breaking
+
+import com.lambda.interaction.request.breaking.BreakInfo.BreakType.Primary
+import com.lambda.interaction.request.breaking.BreakManager.currentStack
+import com.lambda.module.modules.client.TaskFlowModule
+import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
+import net.minecraft.client.network.ClientPlayerEntity
+import net.minecraft.item.ItemStack
+import net.minecraft.world.BlockView
+
+data class SwapInfo(
+    val breakConfig: BreakConfig = TaskFlowModule.build.breaking,
+    val swap: Boolean = false,
+    val minKeepTicks: Int = 0,
+) {
+    val canCompleteBreak
+        get() = BreakManager.heldTicks >= breakConfig.serverSwapTicks
+
+    companion object {
+        val EMPTY = SwapInfo()
+
+        fun getSwapInfo(
+            info: BreakInfo,
+            player: ClientPlayerEntity,
+            world: BlockView
+        ): SwapInfo = with(info) {
+            val breakDelta = context.cachedState
+                .calcItemBlockBreakingDelta(player, world, context.blockPos, swapStack)
+            val breakDeltaNoEfficiency = context.cachedState
+                .calcItemBlockBreakingDelta(player, world, context.blockPos, swapStack, ignoreEfficiency = true)
+            val breakTicks = (if (rebreakPotential.isPossible()) RebreakManager.rebreak?.breakingTicks
+                ?: throw IllegalStateException("Rebreak was null when rebreak was considered possible")
+            else breakingTicks).let {
+                // Plus one as this is calculated before this ticks progress is calculated and the breakingTicks are incremented
+                (it + 1) - breakConfig.fudgeFactor
+            }
+            val threshold = getBreakThreshold()
+
+            val minKeepTicks = run {
+                val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks)
+                val withinPrimarySwapRange = swapTickProgress >= threshold
+                if (type == Primary) {
+                    val withoutEfficiency = breakDeltaNoEfficiency * breakTicks >= threshold
+                    if (withinPrimarySwapRange && !withoutEfficiency && swapStack.heldTicks < breakConfig.serverSwapTicks) 1
+                    else 0
+                } else {
+                    val withinSecondarySwapRange = withinPrimarySwapRange ||
+                            (breakDelta * breakTicks >= threshold && breakDelta * (breakTicks - 1) < threshold)
+                    if (withinSecondarySwapRange) 1 else 0
+                }
+            }
+
+            val swapAtEnd = breakDelta * breakTicks >= threshold || minKeepTicks > 0
+
+            val swap = if (rebreakPotential == RebreakManager.RebreakPotential.Instant)
+                breakConfig.swapMode.isEnabled()
+            else when (breakConfig.swapMode) {
+                BreakConfig.SwapMode.None -> false
+                BreakConfig.SwapMode.Start -> !breaking
+                BreakConfig.SwapMode.End -> swapAtEnd
+                BreakConfig.SwapMode.StartAndEnd -> !breaking || swapAtEnd
+                BreakConfig.SwapMode.Constant -> true
+            }
+
+            return SwapInfo(breakConfig, swap, minKeepTicks)
+        }
+
+        private val ItemStack.heldTicks
+            get() = if (currentStack == this)
+                BreakManager.heldTicks
+            else 0
+    }
+}