efficiency check for minKeepTicks

Author: beanbag44

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

@@ -310,15 +310,27 @@ object BreakManager : RequestHandler<BreakRequest>(
                     .asReversed()
                     .also {
                         it.firstOrNull { it.shouldSwap(player, world) }?.let { info ->
-                            val breakDelta = info.context.cachedState.calcBreakDelta(
+                            val cachedState = info.context.cachedState
+                            val swapStack = player.inventory.getStack(info.context.hotbarIndex)
+
+                            val breakAmount = cachedState.calcBreakDelta(
+                                player,
+                                world,
+                                info.context.blockPos,
+                                info.breakConfig,
+                                swapStack
+                            ) * info.breakingTicks
+                            val breakAmountNoEfficiency = cachedState.calcBreakDelta(
                                 player,
                                 world,
                                 info.context.blockPos,
                                 info.breakConfig,
-                                player.inventory.getStack(info.context.hotbarIndex)
-                            )
-                            val breakAmount = breakDelta * info.breakingTicks
-                            val minKeepTicks = if (breakAmount >= info.getBreakThreshold() &&
+                                swapStack,
+                                ignoreEfficiency = true
+                            ) * info.breakingTicks
+
+                            val minKeepTicks = if ((breakAmount >= info.getBreakThreshold() || info.couldReBreak.value == true) &&
+                                breakAmountNoEfficiency < info.getBreakThreshold() &&
                                 info.serverBreakTicks < info.breakConfig.fudgeFactor)
                             {
                                 1
@@ -334,8 +346,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                         }
                     }
                     .forEach { info ->
-                        if (!info.shouldProgress) return@forEach
-                        updateBreakProgress(info)
+                        if (info.shouldProgress)
+                            updateBreakProgress(info)
                     }
             }
         }
@@ -815,9 +827,10 @@ object BreakManager : RequestHandler<BreakRequest>(
         world: BlockView,
         pos: BlockPos,
         config: BreakConfig,
-        item: ItemStack? = null
+        item: ItemStack? = null,
+        ignoreEfficiency: Boolean = false
     ) = runSafe {
-        val delta = calcItemBlockBreakingDelta(player, world, pos, item ?: player.mainHandStack)
+        val delta = calcItemBlockBreakingDelta(player, world, pos, item ?: player.mainHandStack, ignoreEfficiency)
         //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/util/BlockUtils.kt

@@ -247,22 +247,23 @@ object BlockUtils {
         player: PlayerEntity,
         world: BlockView,
         blockPos: BlockPos,
-        item: ItemStack
+        item: ItemStack,
+        ignoreEfficiency: Boolean = false
     ): 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) / hardness / harvestMultiplier
+            player.getItemBlockBreakingSpeed(this, item, ignoreEfficiency) / hardness / harvestMultiplier
         }
     }
 
     fun ItemStack.canHarvest(blockState: BlockState) =
         !blockState.isToolRequired || isSuitableFor(blockState)
 
-    fun PlayerEntity.getItemBlockBreakingSpeed(blockState: BlockState, item: ItemStack): Float {
+    fun PlayerEntity.getItemBlockBreakingSpeed(blockState: BlockState, item: ItemStack, ignoreEfficiency: Boolean = false): Float {
         var speedMultiplier = item.getMiningSpeedMultiplier(blockState)
         if (speedMultiplier > 1.0f) {
-            val level = item.getEnchantment(Enchantments.EFFICIENCY)
+            val level = if (ignoreEfficiency) 0 else item.getEnchantment(Enchantments.EFFICIENCY)
             if (level > 0 && !item.isEmpty) {
                 speedMultiplier += (level * level + 1)
             }