sequence mode settings and an implementation in the place manager. Also a couple fixes for the hotbar manager

Author: beanbag44

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

@@ -32,6 +32,7 @@ class BreakSettings(
     override val breakThreshold by c.setting("Break Threshold", 1.0f, 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", false, "Allows breaking two blocks at once") { vis() }
     override val breakDelay by c.setting("Break Delay", 5, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
+    override val sequenceMode by c.setting("Break Sequence Mode", BuildConfig.InteractSequenceMode.PostMovement, "The sub-tick timing at which break actions are performed", vis)
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
     override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing != SwingMode.None }
     override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds") { vis() }

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

@@ -36,4 +36,10 @@ interface BuildConfig {
         Server,
         Client
     }
+
+    enum class InteractSequenceMode {
+        TickStart,
+        Vanilla,
+        PostMovement,
+    }
 }

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

@@ -29,6 +29,7 @@ class PlaceSettings(
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces") { vis() }
     override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { vis() && airPlace.isEnabled() }
+    override val sequenceMode by c.setting("Place Sequence Mode", BuildConfig.InteractSequenceMode.PostMovement, "The sub-tick timing at which break actions are performed") { vis() }
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }

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

@@ -30,6 +30,7 @@ abstract class BreakConfig(
     abstract val breakThreshold: Float
     abstract val doubleBreak: Boolean
     abstract val breakDelay: Int
+    abstract val sequenceMode: BuildConfig.InteractSequenceMode
     abstract val swing: SwingMode
     abstract val swingType: BuildConfig.SwingType
     abstract val sounds: Boolean

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

@@ -69,7 +69,6 @@ object HotbarManager : RequestHandler<HotbarRequest>(), Loadable {
         listen<TickEvent.Pre>(priority = Int.MIN_VALUE) {
             preEvent()
 
-            swapsThisTick = 0
             if (swapDelay > 0) swapDelay--
 
             if (requestMap.isNotEmpty()) {
@@ -122,14 +121,14 @@ object HotbarManager : RequestHandler<HotbarRequest>(), Loadable {
             slot: Int,
             keepTicks: Int = request.hotbarConfig.keepTicks
         ): Boolean {
-            request.swapSlot = SlotInfo(slot, keepTicks, request.hotbarConfig.swapDelay)
+            request.swapSlot = SlotInfo(slot, keepTicks, request.hotbarConfig.swapPause)
             if (slot != currentSlotInfo?.slot) {
                 if (swapsThisTick + 1 > maxSwapsThisTick || swapDelay > 0) {
                     return false
                 }
 
                 currentSlotInfo?.let { current ->
-                    if (current.activeRequestAge == 0 && (current.keepTicks > 0 || current.swapPause > 0)) {
+                    if (current.activeRequestAge == 0 && current.keepTicks > 0) {
                         return false
                     }
                 }
@@ -141,7 +140,7 @@ object HotbarManager : RequestHandler<HotbarRequest>(), Loadable {
             }
             currentSlotInfo = request.swapSlot
             mc.interactionManager?.syncSelectedSlot()
-            return true
+            return request.done
         }
 
         @ActionSequence
@@ -152,11 +151,12 @@ object HotbarManager : RequestHandler<HotbarRequest>(), Loadable {
 
     data class SlotInfo(
         val slot: Int,
-        var keepTicks: Int = 3,
-        var swapPause: Int = 0
+        var keepTicks: Int,
+        var swapPause: Int
     ) {
         var activeRequestAge = 0
         var swapPauseAge = 0
+        val swapPaused get() = swapPauseAge < swapPause
     }
 
     override fun preEvent() = UpdateManagerEvent.Hotbar.Pre().post()

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

@@ -29,7 +29,7 @@ class HotbarRequest(
 
     var instantActionsComplete = false
     override val done: Boolean
-        get() = swapSlot?.let { it.slot == HotbarManager.serverSlot && it.swapPauseAge >= it.swapPause } ?: true
+        get() = swapSlot?.let { it.slot == HotbarManager.serverSlot && !it.swapPaused } ?: true
 
     constructor (
         slot: Int,

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceConfig.kt

@@ -31,6 +31,7 @@ abstract class PlaceConfig(
     protected abstract val axisRotateSetting: Boolean
     val axisRotate
         get() = airPlace.isEnabled() && axisRotateSetting
+    abstract val sequenceMode: BuildConfig.InteractSequenceMode
     abstract val placeConfirmationMode: PlaceConfirmationMode
     abstract val maxPendingPlacements: Int
     abstract val placementsPerTick: Int

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt

@@ -18,6 +18,7 @@
 package com.lambda.interaction.request.placing
 
 import com.lambda.Lambda.mc
+import com.lambda.config.groups.BuildConfig
 import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.MovementEvent
@@ -33,6 +34,7 @@ import com.lambda.interaction.request.RequestHandler
 import com.lambda.interaction.request.breaking.BreakManager
 import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
+import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.item
@@ -44,6 +46,7 @@ import com.lambda.util.player.isItemOnCooldown
 import com.lambda.util.player.swingHand
 import net.minecraft.block.BlockState
 import net.minecraft.block.pattern.CachedBlockPosition
+import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.item.BlockItem
 import net.minecraft.item.ItemPlacementContext
 import net.minecraft.item.ItemStack
@@ -68,7 +71,19 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         it.pendingInteractionsList.remove(it.context)
     }
 
-    private var shouldCrouch = false
+    private var potentialPlacements = listOf<PlaceContext>()
+    private var nextPredictedRotation: RotationRequest? = null
+
+    private var hotbarRequest: HotbarRequest? = null
+    private val swappedTo: (Int) -> Boolean = { slot ->
+        hotbarRequest?.let { hotbarRequest ->
+            hotbarRequest.swapSlot?.slot == slot && hotbarRequest.done
+        } ?: false
+    }
+
+    private var shouldSneak = false
+    private val validSneak: (player: ClientPlayerEntity) -> Boolean =
+        { player -> shouldSneak == player.isSneaking }
 
     override val blockedPositions
         get() = pendingPlacements.map { it.context.expectedPos }
@@ -102,11 +117,11 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
 
             currentRequest?.let request@ { request ->
                 if (BreakManager.activeThisTick) return@request
+                val placeConfig = request.buildConfig.placeSettings
 
-                pendingPlacements.setMaxSize(request.buildConfig.placeSettings.maxPendingPlacements)
+                pendingPlacements.setMaxSize(placeConfig.maxPendingPlacements)
                 pendingPlacements.setDecayTime(request.buildConfig.interactionTimeout * 50L)
 
-                val placeConfig = request.buildConfig.placeSettings
                 val isSneaking = player.isSneaking
                 val currentHotbarIndex = HotbarManager.serverSlot
                 val placeContexts = request.placeContexts
@@ -118,50 +133,41 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
 
                 val maxPlacementsThisTick =  (placeConfig.maxPendingPlacements - pendingPlacements.size).coerceAtLeast(0)
                 val takeCount = (placeConfig.placementsPerTick.coerceAtMost(maxPlacementsThisTick))
-
-                val hotbarRequest = HotbarRequest(request.hotbarConfig) {
-                    placeContexts
-                        .take(takeCount)
-                        .forEach { ctx ->
-                            val notSneaking = !player.isSneaking
-                            val swapped = swapTo(ctx.hotbarIndex)
-                            if (placeConfig.rotate) {
-                                val rot = request.rotationConfig.request(ctx.rotation)
-                                if (!rot.done) {
-                                    return@HotbarRequest
-                                }
-                            }
-                            if (ctx.sneak && notSneaking) {
-                                shouldCrouch = true
-                                return@HotbarRequest
-                            }
-                            if (!swapped) {
-                                return@HotbarRequest
-                            }
-
-                            val actionResult = placeBlock(ctx, request, Hand.MAIN_HAND)
-                            if (!actionResult.isAccepted) {
-                                warn("Placement interaction failed with $actionResult")
-                            }
-                            activeThisTick = true
-                        }
-
-                    placeContexts.getOrNull(takeCount)?.rotation?.let { rot ->
-                        request.rotationConfig.request(rot)
+                nextPredictedRotation = if (request.rotationConfig.rotate) placeContexts.getOrNull(takeCount)?.rotation else null
+
+                hotbarRequest = HotbarRequest(request.hotbarConfig) {
+                    potentialPlacements = placeContexts.take(takeCount)
+                    potentialPlacements.forEach { ctx ->
+                        swapTo(ctx.hotbarIndex)
+                        if (request.buildConfig.placeSettings.rotate) request.rotationConfig.request(ctx.rotation)
+                        if (ctx.sneak) shouldSneak = true
+                        if (placeConfig.sequenceMode != BuildConfig.InteractSequenceMode.TickStart) return@HotbarRequest
+                        if (!attemptContextPlace(ctx, request)) return@HotbarRequest
                     }
+                    requestNextPredictedRotation(request)
                     done()
                 }
-                request.hotbarConfig.request(hotbarRequest)
+                hotbarRequest?.let { hotbarRequest ->
+                    request.hotbarConfig.request(hotbarRequest)
+                }
+                if (potentialPlacements.isNotEmpty()) activeThisTick = true
             }
         }
 
-        listen<UpdateManagerEvent.Hotbar.Post>(priority = Int.MIN_VALUE) {
-            postEvent()
+        //ToDo: add mixin for vanilla place timings
+
+        listen<MovementEvent.Player.Post> {
+            currentRequest?.let { request ->
+                if (request.buildConfig.placeSettings.sequenceMode == BuildConfig.InteractSequenceMode.PostMovement) {
+                    handlePlacementContexts(request)
+                    postEvent()
+                }
+            }
         }
 
         listen<MovementEvent.InputUpdate>(priority = Int.MIN_VALUE) {
-            if (shouldCrouch) {
-                shouldCrouch = false
+            if (shouldSneak) {
+                shouldSneak = false
                 it.input.sneaking = true
             }
         }
@@ -186,6 +192,30 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         }
     }
 
+    private fun SafeContext.handlePlacementContexts(request: PlaceRequest): Boolean {
+        potentialPlacements.forEach { ctx ->
+            if (request.buildConfig.placeSettings.rotate) request.rotationConfig.request(ctx.rotation)
+            if (ctx.sneak) shouldSneak = true
+            if (!attemptContextPlace(ctx, request)) return false
+        }
+        requestNextPredictedRotation(request)
+        return true
+    }
+
+    private fun SafeContext.attemptContextPlace(ctx: PlaceContext, request: PlaceRequest): Boolean {
+        if (!swappedTo(ctx.hotbarIndex) || !ctx.rotation.done || !validSneak(player)) return false
+
+        val actionResult = placeBlock(ctx, request, Hand.MAIN_HAND)
+        if (!actionResult.isAccepted) {
+            warn("Placement interaction failed with $actionResult")
+        }
+        return true
+    }
+
+    private fun requestNextPredictedRotation(request: PlaceRequest) {
+        nextPredictedRotation?.let { rot -> request.rotationConfig.request(rot) }
+    }
+
     private fun canPlace(placeContext: PlaceContext) =
         pendingPlacements.none { pending ->
             pending.context.expectedPos == placeContext.expectedPos