remove efficiency ignore checks as they're causing issues. From testing, this fixes the last inconsistency issue with actual breaking

Author: beanbag44

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

@@ -66,6 +66,7 @@ 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.hotbar.HotbarRequest
 import com.lambda.interaction.request.interacting.InteractionManager
 import com.lambda.interaction.request.placing.PlaceManager
 import com.lambda.interaction.request.rotating.RotationRequest
@@ -428,8 +429,16 @@ object BreakManager : RequestHandler<BreakRequest>(
                 infos.firstOrNull()?.let { info ->
                     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))
+                        val hotbarRequest = with(info) {
+                            HotbarRequest(
+                                context.hotbarIndex,
+                                request.hotbar,
+                                request.hotbar.keepTicks.coerceAtLeast(minSwapTicks)
+                            ).submit(false)
+                        }
+                        if (!hotbarRequest.done) {
                             return false
+                        }
                         if (minSwapTicks > 0) {
                             val alreadySwapped = swappedThisTick
                             currentStack = info.swapStack
@@ -513,8 +522,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                 return secondaryBreak
             }
 
-            primaryInfo.stopBreakPacket(world, interaction)
-            primaryInfo.makeSecondary()
+            secondaryBreak = primaryInfo.apply { type = Secondary }
+            secondaryBreak?.stopBreakPacket(world, interaction)
             return@let
         }
 
@@ -615,17 +624,6 @@ object BreakManager : RequestHandler<BreakRequest>(
         swapInfo = getSwapInfo(this, player, world)
     }
 
-    /**
-     * Makes the [BreakInfo] a secondary if not already.
-     */
-    private fun BreakInfo.makeSecondary() {
-        if (secondaryBreak === this) return
-        secondaryBreak = this.apply {
-            type = Secondary
-        }
-        primaryBreak = null
-    }
-
     /**
      * Attempts to cancel the break.
      *
@@ -715,12 +713,8 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         info.breakingTicks++
-        val progress = blockState.calcBreakDelta(
-            player,
-            world,
-            ctx.blockPos,
-            config
-        ) * (info.breakingTicks - config.fudgeFactor)
+        val breakDelta = blockState.calcBreakDelta(player, world, ctx.blockPos, config)
+        val progress = breakDelta * (info.breakingTicks - config.fudgeFactor)
 
         if (config.sounds) {
             if (info.soundsCooldown % 4.0f == 0.0f) {
@@ -748,7 +742,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val swing = config.swing
-        if (progress >= info.getBreakThreshold() && info.swapInfo.canCompleteBreak) {
+        if (progress >= info.getBreakThreshold() && info.swapInfo.validSwap) {
             if (info.type == Primary) {
                 onBlockBreak(info)
                 info.stopBreakPacket(world, interaction)
@@ -821,8 +815,11 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val progress = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
-        info.vanillaInstantBreakable = progress >= 1 && info.swapInfo.canCompleteBreak
-        if (progress >= info.getBreakThreshold() && info.swapInfo.canCompleteBreak) {
+
+        val instantBreakable = progress >= info.getBreakThreshold() && info.swapInfo.validSwap
+        info.vanillaInstantBreakable = progress >= 1 && info.swapInfo.validSwap
+
+        if (instantBreakable) {
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
         } else {
@@ -842,7 +839,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         info.startBreakPacket(world, interaction)
 
-        if (info.type == Secondary || (!info.vanillaInstantBreakable && progress >= info.breakConfig.breakThreshold)) {
+        if (info.type == Secondary || (instantBreakable && !info.vanillaInstantBreakable)) {
             info.stopBreakPacket(world, interaction)
         }
 
@@ -854,10 +851,9 @@ object BreakManager : RequestHandler<BreakRequest>(
         world: BlockView,
         pos: BlockPos,
         config: BreakConfig,
-        item: ItemStack? = null,
-        ignoreEfficiency: Boolean = false
+        item: ItemStack? = null
     ) = runSafe {
-        val delta = calcItemBlockBreakingDelta(player, world, pos, item ?: player.mainHandStack, ignoreEfficiency)
+        val delta = calcItemBlockBreakingDelta(player, world, pos, item ?: player.mainHandStack)
         //ToDo: This setting requires some fixes / improvements in the player movement prediction to work properly. Currently, it's broken
 //        if (config.desyncFix) {
 //            val nextTickPrediction = buildPlayerPrediction().next()

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

@@ -89,7 +89,7 @@ object RebreakHandler {
             val context = reBreak.context
             val breakDelta = context.cachedState.calcBreakDelta(player, world, context.blockPos, reBreak.breakConfig)
             val breakTicks = reBreak.breakingTicks - reBreak.breakConfig.fudgeFactor
-            return@runSafe if (breakTicks * breakDelta >= reBreak.getBreakThreshold() && reBreak.swapInfo.canCompleteBreak) {
+            return@runSafe if (breakTicks * breakDelta >= reBreak.getBreakThreshold() && reBreak.swapInfo.validSwap) {
                 if (reBreak.breakConfig.breakConfirmation != BreakConfig.BreakConfirmationMode.AwaitThenBreak) {
                     destroyBlock(reBreak)
                 }

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

@@ -17,6 +17,7 @@
 
 package com.lambda.interaction.request.breaking
 
+import com.lambda.Lambda.mc
 import com.lambda.interaction.request.breaking.BreakInfo.BreakType.Primary
 import com.lambda.interaction.request.breaking.BreakInfo.BreakType.Rebreak
 import com.lambda.interaction.request.breaking.BreakManager.calcBreakDelta
@@ -27,14 +28,18 @@ import net.minecraft.item.ItemStack
 import net.minecraft.world.BlockView
 
 data class SwapInfo(
-    val type: BreakInfo.BreakType,
-    val breakConfig: BreakConfig = TaskFlowModule.build.breaking,
+    private val type: BreakInfo.BreakType,
+    private val breakConfig: BreakConfig = TaskFlowModule.build.breaking,
     val swap: Boolean = false,
     val minKeepTicks: Int = 0,
 ) {
-    val canCompleteBreak
-        get() = BreakManager.heldTicks >= if (type == Primary || type == Rebreak) breakConfig.serverSwapTicks
-        else breakConfig.serverSwapTicks.coerceAtLeast(3)
+    val validSwap
+        get() = run {
+            val serverSwapTicks = if (type == Primary || type == Rebreak) breakConfig.serverSwapTicks
+            else breakConfig.serverSwapTicks.coerceAtLeast(3)
+
+            (mc.player?.mainHandStack?.heldTicks ?: return false) >= serverSwapTicks
+        }
 
     companion object {
         val EMPTY = SwapInfo(Primary)
@@ -46,8 +51,6 @@ data class SwapInfo(
         ): SwapInfo = with(info) {
             val breakDelta = context.cachedState
                 .calcBreakDelta(player, world, context.blockPos, breakConfig, swapStack)
-            val breakDeltaNoEfficiency = context.cachedState
-                .calcBreakDelta(player, world, context.blockPos, breakConfig, swapStack, ignoreEfficiency = true)
 
             val threshold = getBreakThreshold()
 
@@ -56,16 +59,14 @@ data class SwapInfo(
             else breakingTicks).let {
                 // Plus one as this is calculated before this ticks progress is calculated and the breakingTicks are incremented
                 (it + 1).let {
-                    if (breakDelta >= threshold) it else it - breakConfig.fudgeFactor
+                    if (breakDelta >= threshold || !info.breaking) it else (it - breakConfig.fudgeFactor)
                 }
             }
 
             val minKeepTicks = run {
                 if (type == Primary) {
                     val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks - 1)
-                    val withoutEfficiency = breakDeltaNoEfficiency * breakTicks >= threshold
-                    if (swapTickProgress >= threshold &&
-                        !withoutEfficiency) 1
+                    if (swapTickProgress >= threshold) 1
                     else 0
                 } else {
                     val serverSwapTicks = breakConfig.serverSwapTicks.coerceAtLeast(3)
@@ -91,7 +92,7 @@ data class SwapInfo(
         }
 
         private val ItemStack.heldTicks
-            get() = if (currentStack == this)
+            get() = if (this == currentStack)
                 BreakManager.heldTicks
             else 0
     }

src/main/kotlin/com/lambda/util/BlockUtils.kt

@@ -256,13 +256,12 @@ object BlockUtils {
         player: PlayerEntity,
         world: BlockView,
         blockPos: BlockPos,
-        item: ItemStack,
-        ignoreEfficiency: Boolean = false
+        item: ItemStack
     ): Float {
         val hardness = getHardness(world, blockPos)
         return if (hardness == -1.0f) 0.0f else {
             val harvestMultiplier = if (item.canHarvest(this)) 30 else 100
-            player.getItemBlockBreakingSpeed(this, item, ignoreEfficiency) / hardness / harvestMultiplier
+            player.getItemBlockBreakingSpeed(this, item) / hardness / harvestMultiplier
         }
     }
 
@@ -271,14 +270,13 @@ object BlockUtils {
 
     fun PlayerEntity.getItemBlockBreakingSpeed(
         blockState: BlockState,
-        item: ItemStack,
-        ignoreEfficiency: Boolean = false
+        item: ItemStack
     ): Float {
         var speedMultiplier = item.getMiningSpeedMultiplier(blockState)
         if (speedMultiplier > 1.0f) {
-            val level = if (ignoreEfficiency) 0 else item.getEnchantment(Enchantments.EFFICIENCY)
-            if (level > 0 && !item.isEmpty) {
-                speedMultiplier += (level * level + 1)
+            speedMultiplier += item.getEnchantment(Enchantments.EFFICIENCY).let {
+                if (it > 0) (it * it) + 1
+                else 0
             }
         }
 
@@ -298,6 +296,7 @@ object BlockUtils {
             speedMultiplier *= fatigueMultiplier
         }
 
+        speedMultiplier *= getAttributeValue(EntityAttributes.BLOCK_BREAK_SPEED).toFloat()
         if (isSubmergedIn(FluidTags.WATER)) {
             getAttributeInstance(EntityAttributes.SUBMERGED_MINING_SPEED)?.let { speed ->
                 speedMultiplier *= speed.getValue().toFloat()