use calcItemBlockBreakingProgress when checking min keep ticks and slight hotbar manager rework

Author: beanbag44

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

@@ -33,7 +33,7 @@ class BreakSettings(
     override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { vis() }
     override val breakThreshold by c.setting("Break Threshold", 0.7f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken") { vis() }
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() }
-    override val doubleBreakFudgeFactor by c.setting("Double Break Fudge Factor", 1, 0..3, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break") { doubleBreak && vis() }
+    override val doubleBreakFudgeFactor by c.setting("Double Break Fudge Factor", 3, 0..3, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break") { doubleBreak && vis() }
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks") { vis() }
     override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Input.Post, TickEvent.Player.Post), "The sub-tick timing at which break actions can be performed", vis)
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }

common/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt

@@ -31,5 +31,5 @@ class HotbarSettings(
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks", vis)
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 && vis() }
     override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
-    override val sequenceStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Player.Post), "The sub-tick timing at which hotbar actions are performed", vis)
+    override val sequenceStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Input.Pre, TickEvent.Input.Post), "The sub-tick timing at which hotbar actions are performed", vis)
 }

common/src/main/kotlin/com/lambda/config/groups/InteractionSettings.kt

@@ -55,7 +55,7 @@ class InteractionSettings(
     }
 
     // Point scan
-    override val strictRayCast by c.setting("Strict Raycast", true, "Whether to include the environment to the ray cast context", vis)
+    override val strictRayCast by c.setting("Strict Raycast", false, "Whether to include the environment to the ray cast context", vis)
     override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible", vis)
     override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", vis)
     override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", vis)

common/src/main/kotlin/com/lambda/interaction/request/RequestHandler.kt

@@ -62,6 +62,7 @@ abstract class RequestHandler<R : Request>(
 
         listen<TickEvent.Post>(Int.MIN_VALUE) {
             activeThisTick = false
+            queuedRequest = null
         }
 
         return super.load()

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

@@ -47,6 +47,7 @@ import com.lambda.interaction.request.placing.PlaceManager
 import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.Communication.warn
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.gamemode
@@ -227,7 +228,12 @@ object BreakManager : RequestHandler<BreakRequest>(
                     .forEach { info ->
                         if (info.updatedProgressThisTick) return@forEach
                         val minKeepTicks = if (info.isSecondary) {
-                            val breakDelta = info.context.checkedState.calcBlockBreakingDelta(player, world, info.context.expectedPos)
+                            val breakDelta = info.context.checkedState.calcItemBlockBreakingDelta(
+                                player,
+                                world,
+                                info.context.expectedPos,
+                                player.inventory.getStack(info.context.hotbarIndex)
+                            )
                             val breakAmount = breakDelta * (info.breakingTicks + 1)
                             if (breakAmount >= 1.0f) 1 else 0
                         } else 0

common/src/main/kotlin/com/lambda/interaction/request/hotbar/HotbarManager.kt

@@ -58,14 +58,6 @@ object HotbarManager : RequestHandler<HotbarRequest>(
     override fun load(): String {
         super.load()
 
-        listen<TickEvent.Pre>(priority = Int.MAX_VALUE) {
-            activeRequest?.let { activeInfo ->
-                if (activeInfo.keepTicks <= 0) {
-                    activeRequest = null
-                }
-            }
-        }
-
         listen<TickEvent.Post>(priority = Int.MIN_VALUE) {
             swapsThisTick = 0
             if (swapDelay > 0) swapDelay--
@@ -90,18 +82,29 @@ object HotbarManager : RequestHandler<HotbarRequest>(
 
         if (tickStage !in config.sequenceStageMask) return
 
-        if (request.slot != activeRequest?.slot) {
-            if (swapsThisTick + 1 > maxSwapsThisTick || swapDelay > 0) return
+        val sameButLonger = activeRequest?.let { active ->
+            request.slot == active.slot && request.keepTicks >= active.keepTicks
+        } ?: false
+
+        if (sameButLonger) activeRequest?.let { current ->
+            request.swapPauseAge = current.swapPauseAge
+        } else run swap@ {
+            if (request.slot != activeRequest?.slot) {
+                if (swapsThisTick + 1 > maxSwapsThisTick || swapDelay > 0) return
+
+                activeRequest?.let { current ->
+                    if (current.swappedThisTick && current.keeping) return
+                }
+
+                swapsThisTick++
+                swapDelay = config.swapDelay
+                return@swap
+            }
 
             activeRequest?.let { current ->
+                request.swapPauseAge = current.swapPauseAge
                 if (current.swappedThisTick && current.keeping) return
             }
-
-            swapsThisTick++
-            swapDelay = config.swapDelay
-        } else activeRequest?.let { current ->
-            request.swapPauseAge = current.swapPauseAge
-            if (current.swappedThisTick && current.keeping) return
         }
 
         activeRequest = request
@@ -111,12 +114,11 @@ object HotbarManager : RequestHandler<HotbarRequest>(
 
     private fun SafeContext.checkResetSwap() {
         activeRequest?.let { activeInfo ->
-            if (activeInfo.keepTicks > 0) return
-
-            if (tickStage in activeInfo.hotbar.sequenceStageMask) {
+            val canStopSwap = swapsThisTick < maxSwapsThisTick
+            if (activeInfo.keepTicks <= 0 && tickStage in activeInfo.hotbar.sequenceStageMask && canStopSwap) {
+                activeRequest = null
                 interaction.syncSelectedSlot()
             }
-            activeRequest = null
         }
     }
 

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

@@ -85,13 +85,6 @@ object PacketMine : Module(
             attackedThisTick = false
         }
 
-        //ToDo: run on every tick stage
-        listen<TickEvent.Pre> {
-            if (!breakConfig.reBreak || (reBreakMode != ReBreakMode.Auto && reBreakMode != ReBreakMode.AutoConstant)) return@listen
-            val reBreak = reBreakPos ?: return@listen
-            requestBreakManager(listOf(reBreak), true)
-        }
-
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
@@ -124,7 +117,12 @@ object PacketMine : Module(
         }
 
         listen<TickEvent.Input.Post> {
-            if (!attackedThisTick) requestBreakManager((breakPositions + queueSorted).toList())
+            if (!attackedThisTick) {
+                requestBreakManager((breakPositions + queueSorted).toList())
+                if (!breakConfig.reBreak || (reBreakMode != ReBreakMode.Auto && reBreakMode != ReBreakMode.AutoConstant)) return@listen
+                val reBreak = reBreakPos ?: return@listen
+                requestBreakManager(listOf(reBreak), true)
+            }
         }
 
         onDisable {

common/src/main/kotlin/com/lambda/threading/Threading.kt

@@ -42,7 +42,7 @@ import java.util.concurrent.CompletableFuture
  * @return The result of the block execution if the context is safe, null otherwise.
  */
 inline fun <T> runSafe(block: SafeContext.() -> T) =
-    ClientContext().toSafe()?.let { block(it) }
+    ClientContext().toSafe()?.run(block)
 
 /**
  * This function is used to execute a block of code on a new thread running asynchronously to the game thread.