small fixes and improvements

Author: beanbag44

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

@@ -429,13 +429,14 @@ 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)
+                        val minKeepTicks = if (info.swapInfo.longSwap || last.swapInfo.longSwap) 1 else 0
+                        val serverSwapTicks = max(info.breakConfig.serverSwapTicks, last.breakConfig.serverSwapTicks)
                         hotbarRequest = with(info) {
                             HotbarRequest(
                                 context.hotbarIndex,
                                 request.hotbar,
-                                request.hotbar.keepTicks.coerceAtLeast(minSwapTicks),
-                                request.config.serverSwapTicks - 1
+                                request.hotbar.keepTicks.coerceAtLeast(minKeepTicks),
+                                serverSwapTicks - 1
                             ).submit(false)
                         }
                         logger.debug("Submitted hotbar request", hotbarRequest)
@@ -656,16 +657,12 @@ object BreakManager : RequestHandler<BreakRequest>(
         info.progressedThisTick = true
 
         if (!info.breaking) {
-            if (!startBreaking(info)) {
+            return if (startBreaking(info)) true
+            else {
                 info.nullify()
                 info.request.onCancel?.invoke(ctx.blockPos)
-                return false
+                false
             }
-            val swing = config.swing
-            if (swing.isEnabled() && (swing != BreakConfig.SwingMode.End || info.type == Rebreak)) {
-                swingHand(config.swingType, Hand.MAIN_HAND)
-            }
-            return true
         }
 
         if (config.swapMode == BreakConfig.SwapMode.Constant && !swapped) return true
@@ -677,9 +674,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             lastPosStarted = ctx.blockPos
             onBlockBreak(info)
             info.startBreakPacket(world, interaction)
-            if (config.swing.isEnabled()) {
-                swingHand(config.swingType, Hand.MAIN_HAND)
-            }
+            if (config.swing.isEnabled()) swingHand(config.swingType, Hand.MAIN_HAND)
             return true
         }
 
@@ -786,6 +781,8 @@ object BreakManager : RequestHandler<BreakRequest>(
             onBlockBreak(info)
             info.startBreakPacket(world, interaction)
             breakCooldown = info.breakConfig.breakDelay
+            val swing = info.breakConfig.swing
+            if (swing.isEnabled()) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
             return true
         }
         if (info.breaking) return false
@@ -831,6 +828,11 @@ object BreakManager : RequestHandler<BreakRequest>(
             info.stopBreakPacket(world, interaction)
         }
 
+        val swing = info.breakConfig.swing
+        if (swing.isEnabled() && (swing != BreakConfig.SwingMode.End || instantBreakable)) {
+            swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+        }
+
         return true
     }
 

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

@@ -20,23 +20,22 @@ package com.lambda.interaction.request.breaking
 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.Secondary
 import com.lambda.interaction.request.breaking.BreakManager.calcBreakDelta
-import com.lambda.interaction.request.hotbar.HotbarConfig
 import com.lambda.module.modules.client.TaskFlowModule
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.world.BlockView
 
 data class SwapInfo(
     private val type: BreakInfo.BreakType,
-    private val hotbarConfig: HotbarConfig = TaskFlowModule.hotbar,
+    private val breakConfig: BreakConfig = TaskFlowModule.build.breaking,
     val swap: Boolean = false,
-    val minKeepTicks: Int = 0,
+    val longSwap: Boolean = false
 ) : LogContext {
     override fun getLogContextBuilder(): LogContextBuilder.() -> Unit = {
         group("Swap Info") {
             value("Type", type)
             value("Swap", swap)
-            value("Min Keep Ticks", minKeepTicks)
         }
     }
 
@@ -58,32 +57,30 @@ data class SwapInfo(
                 ?: throw IllegalStateException("Rebreak BreakInfo was null when rebreak was considered possible")
             else breakingTicks) + 1 - breakConfig.fudgeFactor
 
-            val minKeepTicks = run {
-                if (type == Primary) {
-                    val swapTickProgress = breakDelta * (breakTicks + request.config.serverSwapTicks - 1).coerceAtLeast(1)
-                    if (swapTickProgress >= threshold && request.config.serverSwapTicks > 0) 1
-                    else 0
-                } else {
+            val swapAtEnd = run {
+                val swapTickProgress = if (type == Primary)
+                    breakDelta * (breakTicks + request.config.serverSwapTicks - 1).coerceAtLeast(1)
+                else {
                     val serverSwapTicks = request.hotbar.swapPause.coerceAtLeast(3)
-                    val swapTickProgress = breakDelta * (breakTicks + serverSwapTicks - 1).coerceAtLeast(1)
-                    if (swapTickProgress >= threshold) 1
-                    else 0
+                    breakDelta * (breakTicks + serverSwapTicks - 1).coerceAtLeast(1)
                 }
+                swapTickProgress >= threshold
             }
 
-            val swapAtEnd = breakDelta * breakTicks >= threshold || minKeepTicks > 0
-
-            val swap = if (rebreakPotential == RebreakHandler.RebreakPotential.Instant)
-                breakConfig.swapMode.isEnabled()
-            else when (breakConfig.swapMode) {
+            val swap = when (breakConfig.swapMode) {
                 BreakConfig.SwapMode.None -> false
                 BreakConfig.SwapMode.Start -> !breaking
                 BreakConfig.SwapMode.End -> swapAtEnd
                 BreakConfig.SwapMode.StartAndEnd -> !breaking || swapAtEnd
                 BreakConfig.SwapMode.Constant -> true
             }
 
-            return SwapInfo(info.type, request.hotbar, swap, minKeepTicks)
+            return SwapInfo(
+                info.type,
+                request.config,
+                swap,
+                breakConfig.serverSwapTicks > 0 || (info.type == Secondary && swapAtEnd)
+            )
         }
     }
 }

src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -195,8 +195,17 @@ object PacketMine : Module(
         breakRequest(
             breakContexts, pendingInteractions, rotation, hotbar, interact, inventory, build,
         ) {
-            onStart { queuePositions.removePos(it); addBreak(it) }
-            onUpdate { queuePositions.removePos(it) }
+            onStart { queuePositions.removePos(it)
+                if (breakPositions.none { pos -> pos == it }) {
+                    addBreak(it)
+                }
+            }
+            onUpdate {
+                queuePositions.removePos(it)
+                if (breakPositions.none { pos -> pos == it }) {
+                    addBreak(it)
+                }
+            }
             onStop { removeBreak(it); breaks++ }
             onCancel { removeBreak(it, true) }
             onReBreakStart { reBreakPos = it }