rewrote HotbarManager to allow for multiple swaps per tick

- added swapDelay, and swapsPerTick settings

Author: beanbag44

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

@@ -27,5 +27,7 @@ class HotbarSettings(
     vis: () -> Boolean = { true }
 ) : HotbarConfig(priority) {
     override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", vis)
-    override var switchPause by c.setting("Switch Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
+    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 var swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
 }

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

@@ -29,7 +29,7 @@ import java.util.concurrent.ConcurrentHashMap
  */
 abstract class RequestHandler<R : Request> {
 
-    private val requestMap = ConcurrentHashMap<RequestConfig<R>, R>()
+    protected val requestMap = ConcurrentHashMap<RequestConfig<R>, R>()
 
     /**
      * Represents if the handler performed any external actions within this tick

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

@@ -23,7 +23,6 @@ import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.ConnectionEvent
 import com.lambda.event.events.EntityEvent
-import com.lambda.event.events.TickEvent
 import com.lambda.event.events.UpdateManagerEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
@@ -113,94 +112,100 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
     }
 
     init {
-        listen<TickEvent.Pre>(priority = Int.MIN_VALUE + 1) {
+        listen<UpdateManagerEvent.Hotbar.Pre> {
             preEvent()
 
             pendingBreaks.cleanUp()
             updateRequest()
-            if (isOnBreakCooldown()) {
-                blockBreakingCooldown--
-            } else if (currentRequest == null) {
-                breakingInfos.forEach { it?.cancelBreak(player, world, interaction) }
-            } else currentRequest?.let request@ { request ->
-                val breakConfig = request.buildConfig.breakSettings
-
-                val validNewContexts = request.contexts
-                    .filter { ctx -> canAccept(ctx) }
-                    .sortedWith(
-                        compareByDescending<BreakContext> { it.instantBreak }
-                            .thenByDescending { it.hotbarIndex == HotbarManager.serverSlot }
-                    ).toMutableList()
+            val request = currentRequest ?: breakingInfos.filterNotNull().firstOrNull()?.request ?: return@listen
+
+            val hotbarRequest = HotbarRequest(request.hotbarConfig) {
+                if (isOnBreakCooldown()) {
+                    blockBreakingCooldown--
+                } else if (currentRequest == null) {
+                    breakingInfos.forEach { it?.cancelBreak(player, world, interaction) }
+                } else currentRequest?.let request@ { currentRequest ->
+                    val breakConfig = currentRequest.buildConfig.breakSettings
+                    val validNewContexts = currentRequest.contexts
+                        .filter { ctx -> canAccept(ctx) }
+                        .sortedWith(
+                            compareByDescending<BreakContext> { it.instantBreak }
+                                .thenByDescending { it.hotbarIndex == HotbarManager.serverSlot }
+                        ).toMutableList()
+
+                    breakingInfos
+                        .filterNotNull()
+                        .forEach { info ->
+                            validNewContexts.find {
+                                ctx -> ctx.expectedPos == info.context.expectedPos
+                            }?.let { ctx ->
+                                info.updateInfo(ctx, currentRequest)
+                                validNewContexts.remove(ctx)
+                                return@forEach
+                            }
+
+                            info.cancelBreak(player, world, interaction)
+                        }
+                    if (atMaxBreakingInfos(currentRequest.buildConfig.breakSettings)) return@request
+
+                    val maxBreaksThisTick = breakConfig.maxPendingBreaks - (breakingInfos.count { it != null } + pendingBreaks.size)
+                    if (maxBreaksThisTick <= 0) return@request
+                    val instantBreaks = validNewContexts
+                        .take(breakConfig.instantBreaksPerTick.coerceAtMost(maxBreaksThisTick))
+                        .filter { it.instantBreak }
+
+                    if (instantBreaks.isNotEmpty()) {
+                        instantBreaks.forEach { ctx ->
+                            if (ctx.hotbarIndex != HotbarManager.serverSlot) {
+                                if (!swapTo(ctx.hotbarIndex)) return@request
+                            }
+                            val breakInfo = handleRequestContext(ctx, currentRequest) ?: return@request
+                            currentRequest.onAccept?.invoke(ctx.expectedPos)
+                            updateBlockBreakingProgress(breakInfo)
+                            activeThisTick = true
+                        }
+                        if (instantBreaks.size == breakConfig.instantBreaksPerTick) return@request
+                    }
 
-                breakingInfos
-                    .filterNotNull()
-                    .forEach { info ->
-                        validNewContexts.find {
-                            ctx -> ctx.expectedPos == info.context.expectedPos
-                        }?.let { ctx ->
-                            info.updateInfo(ctx, request)
-                            validNewContexts.remove(ctx)
-                            return@forEach
+                    validNewContexts
+                        .filter { !it.instantBreak }
+                        .forEach { ctx ->
+                            handleRequestContext(ctx, currentRequest) ?: return@request
+                            currentRequest.onAccept?.invoke(ctx.expectedPos)
+                            if (atMaxBreakingInfos(currentRequest.buildConfig.breakSettings)) return@request
                         }
+                }
 
-                        info.cancelBreak(player, world, interaction)
+                breakingInfos
+                    .firstOrNull { it?.breakConfig?.rotateForBreak == true && !it.redundant }
+                    ?.let { info ->
+                        // If the simulation cant find a valid rotation to the block,
+                        // the existing break context stays and the keep ticks deplete until rotations stop
+                        if (info.context.rotation.keepTicks <= 0) null
+                        else info.rotationConfig.request(info.context.rotation)
                     }
-                if (atMaxBreakingInfos(request.buildConfig.breakSettings)) return@request
-
-                val maxBreaksThisTick = breakConfig.maxPendingBreaks - (breakingInfos.count { it != null } + pendingBreaks.size)
-                if (maxBreaksThisTick <= 0) return@request
-                val instantBreaks = validNewContexts
-                    .take(breakConfig.instantBreaksPerTick.coerceAtMost(maxBreaksThisTick))
-                    .filter { it.instantBreak }
-
-                if (instantBreaks.isNotEmpty()) {
-                    instantBreaks.forEach { ctx ->
-                        if (ctx.hotbarIndex != HotbarManager.serverSlot) {
-                            if (!request.hotbarConfig.request(HotbarRequest(ctx.hotbarIndex)).done) return@request
+                    ?.let { rot ->
+                        if (!rot.done) {
+                            return@HotbarRequest
                         }
-                        val breakInfo = handleRequestContext(ctx, request) ?: return@request
-                        request.onAccept?.invoke(ctx.expectedPos)
-                        updateBlockBreakingProgress(breakInfo)
-                        activeThisTick = true
                     }
-                    if (instantBreaks.size == breakConfig.instantBreaksPerTick) return@request
-                }
 
-                validNewContexts
-                    .filter { !it.instantBreak }
-                    .forEach { ctx ->
-                        handleRequestContext(ctx, request) ?: return@request
-                        request.onAccept?.invoke(ctx.expectedPos)
-                        if (atMaxBreakingInfos(request.buildConfig.breakSettings)) return@request
+                // Reversed so that the breaking order feels natural to the user as the primary break has to
+                // be started after the secondary
+                breakingInfos
+                    .filterNotNull()
+                    .reversed()
+                    .forEach { info ->
+                        if (!info.redundant && !swapTo(info.context.hotbarIndex)) return@HotbarRequest
+                        updateBlockBreakingProgress(info)
+                        if (!info.redundant) activeThisTick = true
                     }
+                done()
             }
+            request.hotbarConfig.request(hotbarRequest)
+        }
 
-            breakingInfos
-                .firstOrNull { it?.breakConfig?.rotateForBreak == true && !it.redundant }
-                ?.let { info ->
-                    // If the simulation cant find a valid rotation to the block,
-                    // the existing break context stays and the keep ticks deplete until rotations stop
-                    if (info.context.rotation.keepTicks <= 0) null
-                    else info.rotationConfig.request(info.context.rotation)
-                }
-                ?.let { rot ->
-                    if (!rot.done) {
-                        postEvent()
-                        return@listen
-                    }
-                }
-
-            // Reversed so that the breaking order feels natural to the user as the primary break has to
-            // be started after the secondary
-            breakingInfos
-                .filterNotNull()
-                .reversed()
-                .forEach { info ->
-                    if (!info.redundant && !info.requestHotbarSwap()) return@forEach
-                    updateBlockBreakingProgress(info)
-                    if (!info.redundant) activeThisTick = true
-                }
-
+        listen<UpdateManagerEvent.Hotbar.Post> {
             postEvent()
         }
 
@@ -345,7 +350,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             setBreakCooldown(info.breakConfig.breakDelay)
             interaction.sendSequencedPacket(world) { sequence ->
                 onBlockBreak(info)
-                PlayerActionC2SPacket(PlayerActionC2SPacket.Action.START_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
+                PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
             }
             val swing = info.breakConfig.swing
             if (swing.isEnabled()) {
@@ -419,7 +424,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             if (info.type == BreakType.Primary) {
                 interaction.sendSequencedPacket(world) { sequence ->
                     onBlockBreak(info)
-                    PlayerActionC2SPacket(PlayerActionC2SPacket.Action.STOP_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
+                    PlayerActionC2SPacket(Action.STOP_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
                 }
             } else {
                 onBlockBreak(info)
@@ -442,7 +447,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         if (gamemode.isCreative) {
             interaction.sendSequencedPacket(world) { sequence: Int ->
                 onBlockBreak(info)
-                PlayerActionC2SPacket(PlayerActionC2SPacket.Action.START_DESTROY_BLOCK, ctx.expectedPos, ctx.result.side, sequence)
+                PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, ctx.expectedPos, ctx.result.side, sequence)
             }
             setBreakCooldown(info.breakConfig.breakDelay)
             return true
@@ -591,9 +596,6 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             }
         }
 
-        fun requestHotbarSwap() =
-            request.hotbarConfig.request(HotbarRequest(context.hotbarIndex)).done
-
         fun setBreakingTextureStage(
             player: ClientPlayerEntity,
             world: ClientWorld,

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

@@ -34,12 +34,24 @@ abstract class HotbarConfig(
      */
     abstract val keepTicks: Int
 
+    /**
+     * The delay, in ticks, between swapping hotbar selections
+     */
+    abstract val swapDelay: Int
+
+    /**
+     * The amount of hotbar selection swaps that can happen per tick
+     *
+     * Only makes a difference if swapDelay is set to 0
+     */
+    abstract val swapsPerTick: Int
+
     /**
      * The delay in ticks to pause actions after switching to the slot.
      *
      * Affects the validity state of the request
      */
-    abstract var switchPause: Int
+    abstract var swapPause: Int
 
     /**
      * Registers a hotbar request with the HotbarManager.