decouple fudge factor from double break to prevent desync when the difference between client and server ticks are close enough to cause a small but critical mismatch in breaking progress

Author: beanbag44

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

@@ -28,12 +28,12 @@ class BreakSettings(
     priority: Priority = 0,
     vis: () -> Boolean = { true }
 ) : BreakConfig(priority) {
-    override val breakMode by c.setting("Break Mode", BreakMode.Packet) { vis() }
+    override val breakMode by c.setting("Break Mode", BreakMode.Packet, visibility = vis)
     override val reBreak by c.setting("ReBreak", true, "Re-breaks blocks after they've been broken once", visibility = vis)
     override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes", visibility = vis)
-    override val breakThreshold by c.setting("Break Threshold", 0.7f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken", visibility = vis)
+    override val breakThreshold by c.setting("Break Threshold", 0.75f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken", visibility = vis)
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once", visibility = vis)
-    override val doubleBreakFudgeFactor by c.setting("Double Break Fudge Factor", 3, 0..3, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break") { doubleBreak && vis() }
+    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)
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks", visibility = vis)
     override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Input.Post, TickEvent.Player.Post), "The sub-tick timing at which break actions can be performed", visibility = vis)
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand", visibility = vis)
@@ -48,7 +48,7 @@ class BreakSettings(
     override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick", visibility = vis)
     override val suitableToolsOnly by c.setting("Suitable Tools Only", false, "Places a restriction to only use tools suitable for the given block", visibility = vis)
     override val avoidLiquids by c.setting("Avoid Liquids", true, "Avoids breaking blocks that would cause liquid to spill", visibility = vis)
-    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() }
+    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", visibility = vis)
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks", visibility = vis)
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks", visibility = vis)
     override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && forceFortunePickaxe }

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

@@ -31,7 +31,7 @@ abstract class BreakConfig(
     abstract val unsafeCancels: Boolean
     abstract val breakThreshold: Float
     abstract val doubleBreak: Boolean
-    abstract val doubleBreakFudgeFactor: Int
+    abstract val fudgeFactor: Int
     abstract val breakDelay: Int
     abstract val breakStageMask: Set<Event>
     abstract val swing: SwingMode

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

@@ -58,6 +58,8 @@ import net.minecraft.entity.ItemEntity
 import net.minecraft.sound.SoundCategory
 import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
+import kotlin.math.ceil
+import kotlin.math.max
 
 object BreakManager : RequestHandler<BreakRequest>(
     0,
@@ -494,6 +496,7 @@ object BreakManager : RequestHandler<BreakRequest>(
      * @see net.minecraft.client.network.ClientPlayerInteractionManager.updateBlockBreakingProgress
      */
     private fun SafeContext.updateBreakProgress(info: BreakInfo): Boolean {
+        val config = info.breakConfig
         info.updatedProgressThisTick = true
         val ctx = info.context
         val hitResult = ctx.result
@@ -503,13 +506,13 @@ object BreakManager : RequestHandler<BreakRequest>(
                 onBlockBreak(info)
                 return true
             }
-            breakCooldown = info.breakConfig.breakDelay
+            breakCooldown = config.breakDelay
             lastPosStarted = ctx.expectedPos
             onBlockBreak(info)
             info.startBreakPacket(world, interaction)
-            val swing = info.breakConfig.swing
+            val swing = config.swing
             if (swing.isEnabled()) {
-                swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+                swingHand(config.swingType, Hand.MAIN_HAND)
             }
             return true
         }
@@ -541,9 +544,9 @@ object BreakManager : RequestHandler<BreakRequest>(
                 info.internalOnCancel()
                 return false
             }
-            val swing = info.breakConfig.swing
+            val swing = config.swing
             if (swing.isEnabled() && swing != BreakConfig.SwingMode.End) {
-                swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+                swingHand(config.swingType, Hand.MAIN_HAND)
             }
             return true
         }
@@ -560,9 +563,16 @@ object BreakManager : RequestHandler<BreakRequest>(
             player,
             world,
             ctx.expectedPos
-        ) * if (info.isSecondary || info.isRedundant) {
-            info.breakingTicks - info.breakConfig.doubleBreakFudgeFactor
-        } else info.breakingTicks
+        ).let { breakDelta ->
+            breakDelta * if (info.isSecondary || info.isRedundant) {
+                info.breakingTicks - config.fudgeFactor
+            } else {
+                val serverBreakTicks = ceil(1.0 / breakDelta).toInt()
+                val clientBreakTicks = ceil(config.breakThreshold / breakDelta).toInt()
+                val diff = serverBreakTicks - clientBreakTicks
+                info.breakingTicks - max(config.fudgeFactor - diff, 0)
+            }
+        }
 
         val overBreakThreshold = progress >= info.getBreakThreshold()
 
@@ -573,7 +583,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             return true
         }
 
-        if (info.breakConfig.sounds) {
+        if (config.sounds) {
             if (info.soundsCooldown % 4.0f == 0.0f) {
                 val blockSoundGroup = blockState.soundGroup
                 mc.soundManager.play(
@@ -590,26 +600,26 @@ object BreakManager : RequestHandler<BreakRequest>(
             info.soundsCooldown++
         }
 
-        if (info.breakConfig.particles) {
+        if (config.particles) {
             mc.particleManager.addBlockBreakingParticles(ctx.expectedPos, hitResult.side)
         }
 
-        if (info.breakConfig.breakingTexture) {
+        if (config.breakingTexture) {
             info.setBreakingTextureStage(player, world)
         }
 
-        val swing = info.breakConfig.swing
+        val swing = config.swing
         if (overBreakThreshold) {
             if (info.isPrimary) {
                 onBlockBreak(info)
                 info.stopBreakPacket(world, interaction)
             } else {
                 onBlockBreak(info)
             }
-            if (swing.isEnabled() && swing != BreakConfig.SwingMode.Start) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
-            breakCooldown = info.breakConfig.breakDelay
+            if (swing.isEnabled() && swing != BreakConfig.SwingMode.Start) swingHand(config.swingType, Hand.MAIN_HAND)
+            breakCooldown = config.breakDelay
         } else {
-            if (swing == BreakConfig.SwingMode.Constant) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+            if (swing == BreakConfig.SwingMode.Constant) swingHand(config.swingType, Hand.MAIN_HAND)
         }
 
         return true