rely on hotbar settings for server swap

Author: beanbag44

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

@@ -51,7 +51,6 @@ 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", 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", 2, 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", " tick(s)", visibility = vis).group(groupPath, Group.General)
 

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

@@ -35,7 +35,6 @@ interface BreakConfig : RequestConfig {
 
     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/BreakManager.kt

@@ -143,18 +143,12 @@ object BreakManager : RequestHandler<BreakRequest>(
 
     private var activeRequest: BreakRequest? = null
 
+    private var hotbarRequest: HotbarRequest? = null
+    val swapped get() = hotbarRequest?.done != false
+
     private var rotationRequest: RotationRequest? = null
     private val rotated get() = rotationRequest?.done != false
 
-    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 instantBreaksThisTick = 0
     private var maxInstantBreaksThisTick = 0
@@ -178,11 +172,6 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         listen<TickEvent.Post>(priority = Int.MIN_VALUE) {
-            if (!swappedThisTick) {
-                currentStack = player.mainHandStack
-                heldTicks++
-            }
-            swappedThisTick = false
             if (breakCooldown > 0) {
                 breakCooldown--
             }
@@ -332,21 +321,18 @@ object BreakManager : RequestHandler<BreakRequest>(
 
             // Reversed so that the breaking order feels natural to the user as the primary break is always the
             // last break to be started
-            noProgression = if (handlePreProcessing()) {
+            handlePreProcessing()
+            noProgression =
                 activeInfos
                     .filter { it.updatedThisTick && it.shouldProgress }
                     .asReversed()
                     .run {
-                        if (isEmpty()) {
-                            true
-                        } else {
-                            forEach { info ->
-                                updateBreakProgress(info)
-                            }
+                        if (isEmpty()) true
+                        else {
+                            forEach { updateBreakProgress(it) }
                             false
                         }
                     }
-            } else true
 
             if (noNew && noProgression) break
         }
@@ -426,7 +412,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         return blockState.isNotEmpty && hardness != 600f && hardness != -1f
     }
 
-    private fun SafeContext.handlePreProcessing(): Boolean {
+    private fun SafeContext.handlePreProcessing() {
         activeInfos
             .filter { it.updatedThisTick }
             .let { infos ->
@@ -437,35 +423,30 @@ object BreakManager : RequestHandler<BreakRequest>(
                         rotation.submit(false)
                     }
 
-                if (activeInfos.isEmpty()) return true
+                if (activeInfos.isEmpty()) return
 
                 infos.forEach { it.updatePreProcessing(player, world) }
 
                 infos.firstOrNull()?.let { info ->
                     infos.lastOrNull { it.swapInfo.swap && it.shouldProgress }?.let { last ->
                         val minSwapTicks = max(info.swapInfo.minKeepTicks, last.swapInfo.minKeepTicks)
-                        val hotbarRequest = with(info) {
+                        hotbarRequest = with(info) {
                             HotbarRequest(
                                 context.hotbarIndex,
                                 request.hotbar,
-                                request.hotbar.keepTicks.coerceAtLeast(minSwapTicks)
+                                request.hotbar.keepTicks.coerceAtLeast(minSwapTicks),
+                                request.hotbar.swapPause - 1
                             ).submit(false)
                         }
                         logger.debug("Submitted hotbar request", hotbarRequest)
-                        if (!hotbarRequest.done) {
-                            logger.warning("Hotbar request failed", hotbarRequest)
-                            return false
-                        }
-                        if (minSwapTicks > 0) {
-                            val alreadySwapped = swappedThisTick
-                            currentStack = info.swapStack
-                            if (!alreadySwapped) heldTicks++
-                        }
+                        return
                     }
                 }
             }
 
-        return true
+        hotbarRequest = null
+
+        return
     }
 
     /**
@@ -687,6 +668,8 @@ object BreakManager : RequestHandler<BreakRequest>(
             return true
         }
 
+        if (config.swapMode == BreakConfig.SwapMode.Constant && !swapped) return true
+
         val hitResult = ctx.result
 
         if (gamemode.isCreative && world.worldBorder.contains(ctx.blockPos)) {
@@ -739,7 +722,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val swing = config.swing
-        if (progress >= info.getBreakThreshold() && info.swapInfo.validSwap) {
+        if (progress >= info.getBreakThreshold() && swapped) {
             logger.success("Breaking", info)
             if (info.type == Primary) {
                 onBlockBreak(info)
@@ -778,7 +761,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                     }
 
                     primaryBreak?.let { primary ->
-                        if (!handlePreProcessing()) return false
+                        handlePreProcessing()
                         updateBreakProgress(primary)
                     }
                     return true
@@ -817,11 +800,12 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         val progress = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
 
-        val instantBreakable = progress >= info.getBreakThreshold() && info.swapInfo.validSwap
-        info.vanillaInstantBreakable = progress >= 1 && info.swapInfo.validSwap
+        if (!swapped) return true
 
+        val instantBreakable = progress >= info.getBreakThreshold() && swapped
         if (instantBreakable) {
             logger.success("Instant breaking", info)
+            info.vanillaInstantBreakable = progress >= 1 && swapped
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
             instantBreaksThisTick++

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.validSwap) {
+            return@runSafe if (breakTicks * breakDelta >= reBreak.getBreakThreshold() && BreakManager.swapped) {
                 if (reBreak.breakConfig.breakConfirmation != BreakConfig.BreakConfirmationMode.AwaitThenBreak) {
                     destroyBlock(reBreak)
                 }

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

@@ -17,38 +17,26 @@
 
 package com.lambda.interaction.request.breaking
 
-import com.lambda.Lambda.mc
 import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 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
-import com.lambda.interaction.request.breaking.BreakManager.currentStack
+import com.lambda.interaction.request.hotbar.HotbarConfig
 import com.lambda.module.modules.client.TaskFlowModule
 import net.minecraft.client.network.ClientPlayerEntity
-import net.minecraft.item.ItemStack
 import net.minecraft.world.BlockView
 
 data class SwapInfo(
     private val type: BreakInfo.BreakType,
-    private val breakConfig: BreakConfig = TaskFlowModule.build.breaking,
+    private val hotbarConfig: HotbarConfig = TaskFlowModule.hotbar,
     val swap: Boolean = false,
     val minKeepTicks: Int = 0,
 ) : LogContext {
-    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
-        }
-
     override fun getLogContextBuilder(): LogContextBuilder.() -> Unit = {
         group("Swap Info") {
             value("Type", type)
             value("Swap", swap)
             value("Min Keep Ticks", minKeepTicks)
-            value("Valid Swap", validSwap)
         }
     }
 
@@ -72,11 +60,11 @@ data class SwapInfo(
 
             val minKeepTicks = run {
                 if (type == Primary) {
-                    val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks - 1).coerceAtLeast(1)
-                    if (swapTickProgress >= threshold) 1
+                    val swapTickProgress = breakDelta * (breakTicks + request.hotbar.swapPause - 1).coerceAtLeast(1)
+                    if (swapTickProgress >= threshold && request.hotbar.swapPause > 0) 1
                     else 0
                 } else {
-                    val serverSwapTicks = breakConfig.serverSwapTicks.coerceAtLeast(3)
+                    val serverSwapTicks = request.hotbar.swapPause.coerceAtLeast(3)
                     val swapTickProgress = breakDelta * (breakTicks + serverSwapTicks - 1).coerceAtLeast(1)
                     if (swapTickProgress >= threshold) 1
                     else 0
@@ -95,12 +83,7 @@ data class SwapInfo(
                 BreakConfig.SwapMode.Constant -> true
             }
 
-            return SwapInfo(info.type, breakConfig, swap, minKeepTicks)
+            return SwapInfo(info.type, request.hotbar, swap, minKeepTicks)
         }
-
-        private val ItemStack.heldTicks
-            get() = if (this == currentStack)
-                BreakManager.heldTicks
-            else 0
     }
 }