better held item checks

Author: beanbag44

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

@@ -48,7 +48,6 @@ data class BreakInfo(
     var shouldSwap by OneSetPerTick(value = false, throwOnLimitBreach = true)
     var swapStack: ItemStack by OneSetPerTick(ItemStack.EMPTY, true)
     var minSwapTicks by OneSetPerTick(0, true)
-    var serverBreakTicks = 0
 
     // BreakInfo Specific
     var updatedThisTick by OneSetPerTick(false, resetAfterTick = true).apply { set(true) }
@@ -115,8 +114,7 @@ data class BreakInfo(
     }
 
     fun shouldSwap(player: ClientPlayerEntity, world: BlockView): Boolean {
-        val item = player.inventory.getStack(context.hotbarIndex)
-        val breakDelta = context.cachedState.calcItemBlockBreakingDelta(player, world, context.blockPos, item)
+        val breakDelta = context.cachedState.calcItemBlockBreakingDelta(player, world, context.blockPos, swapStack)
         val breakProgress = breakDelta * (breakingTicks + 1)
         return if (couldReBreak == RebreakManager.RebreakPotential.Instant)
             breakConfig.swapMode.isEnabled()
@@ -140,7 +138,7 @@ data class BreakInfo(
     private fun getBreakTextureProgress(player: PlayerEntity, world: ClientWorld): Int {
         val swapMode = breakConfig.swapMode
         val item =
-            if (swapMode.isEnabled() && swapMode != BreakConfig.SwapMode.Start) player.inventory.getStack(context.hotbarIndex) else player.mainHandStack
+            if (swapMode.isEnabled() && swapMode != BreakConfig.SwapMode.Start) swapStack else player.mainHandStack
         val breakDelta = context.cachedState.calcItemBlockBreakingDelta(player, world, context.blockPos, item)
         val progress = (breakDelta * breakingTicks) / (getBreakThreshold() + (breakDelta * breakConfig.fudgeFactor))
         return if (progress > 0.0f) (progress * 10.0f).toInt().coerceAtMost(9) else -1

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

@@ -139,10 +139,11 @@ object BreakManager : RequestHandler<BreakRequest>(
     private val rotated get() = rotationRequest?.done != false
 
     var swappedThisTick = false
+    var heldTicks = 0
     var swappedStack: ItemStack = ItemStack.EMPTY
         set(value) {
             if (value != field)
-                breakInfos.forEach { it?.serverBreakTicks = 0 }
+                heldTicks = 0
             swappedThisTick = true
             field = value
         }
@@ -174,6 +175,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (!swappedThisTick) {
                 swappedStack = player.mainHandStack
             } else swappedThisTick = false
+            heldTicks++
             if (breakCooldown > 0) {
                 breakCooldown--
             }
@@ -229,9 +231,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         listen<RenderEvent.StaticESP> { event ->
             val activeStack = breakInfos
                 .filterNotNull()
-                .firstOrNull()?.let { info ->
-                    player.inventory.getStack(info.context.hotbarIndex)
-                } ?: return@listen
+                .firstOrNull()?.swapStack ?: return@listen
 
             breakInfos
                 .filterNotNull()
@@ -413,20 +413,18 @@ object BreakManager : RequestHandler<BreakRequest>(
                         rotation.submit(false)
                     }
 
-                if (activeInfos.isEmpty()) {
-                    swappedStack = player.mainHandStack
-                    return true
-                }
+                if (activeInfos.isEmpty()) return true
+
+                infos.forEach { it.updatePreProcessing(player, world) }
+
+                if (swappedThisTick) return true
 
-                infos.forEach {
-                    it.updatePreProcessing(player, world)
-                }
                 infos.firstOrNull()?.let { info ->
                     infos.firstOrNull { it.shouldSwap && it.shouldProgress }?.let { last ->
-                        if (!info.context.requestSwap(info.request, max(info.minSwapTicks, last.minSwapTicks)))
+                        val minSwapTicks = max(info.minSwapTicks, last.minSwapTicks)
+                        if (!info.context.requestSwap(info.request, minSwapTicks))
                             return false
-                        swappedStack = info.swapStack
-                        if (info.minSwapTicks > 0) info.serverBreakTicks++
+                        if (minSwapTicks > 0) swappedStack = info.swapStack
                     }
                 }
             }
@@ -602,11 +600,11 @@ object BreakManager : RequestHandler<BreakRequest>(
         if (updatedPreProcessingThisTick) return
         updatedPreProcessingThisTick = true
 
+        swapStack = player.inventory.getStack(context.hotbarIndex)
         couldReBreak = RebreakManager.couldRebreak(this, player, world)
         shouldSwap = shouldSwap(player, world)
 
         val cachedState = context.cachedState
-        swapStack = player.inventory.getStack(context.hotbarIndex)
 
         val breakTicks = (breakingTicks + 1 - breakConfig.fudgeFactor).coerceAtLeast(1)
         val breakAmount = cachedState.calcBreakDelta(
@@ -770,7 +768,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val swing = config.swing
-        if (overBreakThreshold && (info.serverBreakTicks >= info.breakConfig.fudgeFactor || info.minSwapTicks < 1)) {
+        if (overBreakThreshold && heldTicks + 1 >= info.breakConfig.fudgeFactor) {
             if (info.type == Primary) {
                 onBlockBreak(info)
                 info.stopBreakPacket(world, interaction)
@@ -844,7 +842,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         val breakDelta = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
         info.vanillaInstantBreakable = breakDelta >= 1
-        if (notEmpty && (breakDelta >= info.getBreakThreshold() && (info.serverBreakTicks >= info.breakConfig.fudgeFactor || info.minSwapTicks < 1))) {
+        if (notEmpty && breakDelta >= info.getBreakThreshold() && heldTicks + 1 >= info.breakConfig.fudgeFactor) {
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
         } else {

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

@@ -67,7 +67,7 @@ object RebreakManager {
     fun couldRebreak(info: BreakInfo, player: ClientPlayerEntity, world: BlockView) =
         rebreak?.let { reBreak ->
             val stack = if (info.breakConfig.swapMode.isEnabled())
-                player.inventory.getStack(info.context.hotbarIndex)
+                info.swapStack
             else player.mainHandStack
             val breakDelta = info.context.cachedState.calcItemBlockBreakingDelta(player, world, info.context.blockPos, stack)
             val possible = reBreak.breakConfig.rebreak &&