cleanup and added a rotation prediction for the next place context to prevent tick delay between placing blocks

Author: beanbag44

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

@@ -29,8 +29,6 @@ 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 axisRotate
-        get() = airPlace.isEnabled() && axisRotateSetting
     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/BreakManager.kt

@@ -41,7 +41,6 @@ import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
 import com.lambda.interaction.request.breaking.BreakConfig.BreakMode
 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.calcItemBlockBreakingDelta
@@ -88,10 +87,6 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
     override val blockedPositions
         get() = breakingInfos.mapNotNull { it?.context?.expectedPos } + pendingBreaks.map { it.context.expectedPos }
 
-    private var rotation: RotationRequest? = null
-    private val validRotation
-        get() = rotation?.done ?: true
-
     private var blockBreakingCooldown = 0
 
     fun Any.onBreak(
@@ -160,11 +155,19 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                     }
             }
 
-            requestRotate()
-            if (!validRotation) {
-                postEvent()
-                return@listen
-            }
+            breakingInfos
+                .firstOrNull { it?.breakConfig?.rotateForBreak == true }
+                ?.let { info ->
+                    // If the simulation cant find a valid rotation to break the block, the existing break context stays and the keep ticks deplete until
+                    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
@@ -262,16 +265,6 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             false
         }
 
-    private fun requestRotate() {
-        rotation = breakingInfos
-            .firstOrNull { it?.breakConfig?.rotateForBreak == true }
-            ?.let { info ->
-                // If the simulation cant find a valid rotation to break the block, the existing break context stays and the keep ticks deplete until
-                if (info.context.rotation.keepTicks <= 0) null
-                else info.rotationConfig.request(info.context.rotation)
-            }
-    }
-
     private fun handleRequestContext(
         requestCtx: BreakContext,
         request: BreakRequest

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

@@ -25,9 +25,12 @@ abstract class PlaceConfig(
     priority: Priority
 ) : RequestConfig<PlaceRequest>(priority) {
     abstract val rotateForPlace: Boolean
+    val rotate
+        get() = rotateForPlace || axisRotate
     abstract val airPlace: AirPlaceMode
     protected abstract val axisRotateSetting: Boolean
-    abstract val axisRotate: Boolean
+    val axisRotate
+        get() = airPlace.isEnabled() && axisRotateSetting
     abstract val placeConfirmationMode: PlaceConfirmationMode
     abstract val maxPendingPlacements: Int
     abstract val placementsPerTick: Int

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

@@ -111,9 +111,6 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
                 pendingPlacements.setDecayTime(request.buildConfig.interactionTimeout * 50L)
 
                 val placeConfig = request.buildConfig.placeSettings
-
-                val maxPlacementsThisTick =  (placeConfig.maxPendingPlacements - pendingPlacements.size).coerceAtLeast(0)
-                val takeCount = (placeConfig.placementsPerTick.coerceAtMost(maxPlacementsThisTick))
                 val isSneaking = player.isSneaking
                 val currentHotbarIndex = HotbarManager.serverSlot
                 val placeContexts = request.placeContexts
@@ -122,33 +119,42 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
                         compareByDescending<PlaceContext> { it.hotbarIndex == currentHotbarIndex }
                             .thenByDescending { it.sneak == isSneaking }
                     )
-                    .take(takeCount)
 
-                placeContexts.forEach { ctx ->
-                    val notSneaking = !player.isSneaking
-                    val hotbarRequest = request.hotbarConfig.request(HotbarRequest(ctx.hotbarIndex))
-                    if (ctx.sneak && notSneaking) {
-                        shouldCrouch = true
-                        postEvent()
-                        return@listen
-                    }
-                    if ((placeConfig.rotateForPlace || placeConfig.axisRotate)) {
-                        rotation = request.rotationConfig.request(ctx.rotation)
-                        if (!ctx.rotation.target.verify()) {
+                val maxPlacementsThisTick =  (placeConfig.maxPendingPlacements - pendingPlacements.size).coerceAtLeast(0)
+                val takeCount = (placeConfig.placementsPerTick.coerceAtMost(maxPlacementsThisTick))
+                val nextRotationPrediction = placeContexts.getOrNull(takeCount)?.rotation
+
+                placeContexts
+                    .take(takeCount)
+                    .forEach { ctx ->
+                        val notSneaking = !player.isSneaking
+                        val hotbarRequest = request.hotbarConfig.request(HotbarRequest(ctx.hotbarIndex))
+                        if (placeConfig.rotate) {
+                            val rot = request.rotationConfig.request(ctx.rotation)
+                            if (!rot.done) {
+                                postEvent()
+                                return@listen
+                            }
+                        }
+                        if (ctx.sneak && notSneaking) {
+                            shouldCrouch = true
+                            postEvent()
+                            return@listen
+                        }
+                        if (!hotbarRequest.done) {
                             postEvent()
                             return@listen
                         }
-                    }
-                    if (!hotbarRequest.done) {
-                        postEvent()
-                        return@listen
-                    }
 
-                    val actionResult = placeBlock(ctx, request, Hand.MAIN_HAND)
-                    if (!actionResult.isAccepted) {
-                        warn("Placement interaction failed with $actionResult")
+                        val actionResult = placeBlock(ctx, request, Hand.MAIN_HAND)
+                        if (!actionResult.isAccepted) {
+                            warn("Placement interaction failed with $actionResult")
+                        }
+                        activeThisTick = true
                     }
-                    activeThisTick = true
+
+                nextRotationPrediction?.let { rot ->
+                    request.rotationConfig.request(rot)
                 }
             }
 

common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -172,13 +172,10 @@ class BuildTask @Ta5kBuilder constructor(
                             return@listen
                         }
                         is PlaceResult.Place -> {
-                            val takeCount = build.placeSettings
-                                .placementsPerTick
-                                .coerceAtMost(emptyPendingInteractionSlots)
                             val placeResults = resultsNotBlocked
                                 .filterIsInstance<PlaceResult.Place>()
                                 .distinctBy { it.blockPos }
-                                .take(takeCount)
+                                .take(emptyPendingInteractionSlots)
 
                             build.placeSettings.request(
                                 PlaceRequest(