allow multiple block placements in one tick

beanbag44 · beanbag44 · commit c2244a1210e1 · 2025-03-31T02:54:20.000+01:00
diff --git a/common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt b/common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt
@@ -33,7 +33,7 @@ class PlaceSettings(
         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("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }
+    override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }
     override val swing by c.setting("Swing", true, "Swings the players hand when placing") { vis() }
     override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }
     override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds") { vis() }
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt
@@ -35,6 +35,7 @@ import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestHandler
 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.placing.PlaceManager
 import com.lambda.interaction.request.rotation.RotationManager.onRotate
@@ -119,12 +120,14 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             currentRequest?.let request@ { request ->
                 if (instantBreaks.isEmpty()) return@request
 
-                instantBreaks.forEach { ctx ->
-                    val breakInfo = handleRequestContext(ctx, request) ?: return@request
-                    if (!breakInfo.requestHotbarSwap()) return@forEach
-                    updateBlockBreakingProgress(breakInfo)
-                    activeThisTick = true
-                }
+                instantBreaks
+                    .sortedBy { HotbarManager.serverSlot == it.hotbarIndex }
+                    .forEach { ctx ->
+                        val breakInfo = handleRequestContext(ctx, request) ?: return@request
+                        if (!breakInfo.requestHotbarSwap()) return@forEach
+                        updateBlockBreakingProgress(breakInfo)
+                        activeThisTick = true
+                    }
                 instantBreaks = emptyList()
             }
 
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt
@@ -29,7 +29,7 @@ import com.lambda.util.BlockUtils.blockState
 import net.minecraft.entity.ItemEntity
 
 data class BreakRequest(
-    val contexts: List<BreakContext>,
+    val contexts: Collection<BreakContext>,
     val buildConfig: BuildConfig,
     val rotationConfig: RotationConfig,
     val hotbarConfig: HotbarConfig,
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt
@@ -25,16 +25,16 @@ 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
+import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.context.PlaceContext
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.PositionBlocking
 import com.lambda.interaction.request.Priority
 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.RotationManager.onRotate
-import com.lambda.interaction.request.rotation.RotationManager.onRotatePost
-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
@@ -62,19 +62,18 @@ import net.minecraft.util.math.Direction
 import net.minecraft.world.GameMode
 
 object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
-    private val pendingPlacements = LimitedDecayQueue<PlaceRequest>(
+    private val pendingPlacements = LimitedDecayQueue<PlaceInfo>(
         TaskFlowModule.build.maxPendingInteractions, TaskFlowModule.build.interactionTimeout * 50L
     ) {
-        info("${it::class.simpleName} at ${it.placeContext.expectedPos.toShortString()} timed out")
-        mc.world?.setBlockState(it.placeContext.expectedPos, it.placeContext.checkedState)
-        it.pendingInteractionsList.remove(it.placeContext)
+        info("${it::class.simpleName} at ${it.context.expectedPos.toShortString()} timed out")
+        mc.world?.setBlockState(it.context.expectedPos, it.context.checkedState)
+        it.pendingInteractionsList.remove(it.context)
     }
 
-    override val blockedPositions
-        get() = pendingPlacements.map { it.placeContext.expectedPos }
+    private var placeContexts = emptyList<PlaceContext>()
 
-    private var rotation: RotationRequest? = null
-    private var validRotation = false
+    override val blockedPositions
+        get() = pendingPlacements.map { it.context.expectedPos }
 
     fun Any.onPlace(
         alwaysListen: Boolean = false,
@@ -95,23 +94,27 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
     init {
         listen<TickEvent.Pre>(priority = Int.MIN_VALUE) {
             currentRequest?.let { request ->
-                val notSneaking = !player.isSneaking
-                val hotbarRequest = request.hotbarConfig.request(HotbarRequest(request.placeContext.hotbarIndex))
-                if ((request.placeContext.sneak && notSneaking) || !hotbarRequest.done || !validRotation)
-                    return@listen
-
-                val actionResult = placeBlock(request, Hand.MAIN_HAND)
-                if (!actionResult.isAccepted) {
-                    warn("Placement interaction failed with $actionResult")
-                }
-                activeThisTick = true
+                placeContexts
+                    .forEach { ctx ->
+                        val notSneaking = !player.isSneaking
+                        val hotbarRequest = request.hotbarConfig.request(HotbarRequest(ctx.hotbarIndex))
+                        if ((ctx.sneak && notSneaking) || !hotbarRequest.done || !ctx.rotation.done)
+                            return@listen
+
+                        val actionResult = placeBlock(ctx, request, Hand.MAIN_HAND)
+                        if (!actionResult.isAccepted) {
+                            warn("Placement interaction failed with $actionResult")
+                        }
+                        activeThisTick = true
+                    }
+                placeContexts = emptyList()
             }
         }
 
         onRotate(priority = Int.MIN_VALUE) {
             preEvent()
 
-            if (!updateRequest { request -> canPlace(request.value.placeContext) }) {
+            if (!updateRequest()) {
                 postEvent()
                 return@onRotate
             }
@@ -122,53 +125,56 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             }
 
             currentRequest?.let request@ { request ->
-                if (pendingPlacements.size >= request.buildConfig.placeSettings.maxPendingPlacements) {
-                    postEvent()
-                    return@onRotate
-                }
+                pendingPlacements.setMaxSize(request.buildConfig.placeSettings.maxPendingPlacements)
+                pendingPlacements.setDecayTime(request.buildConfig.interactionTimeout * 50L)
 
                 val placeConfig = request.buildConfig.placeSettings
-                rotation = if (placeConfig.rotateForPlace || placeConfig.axisRotate)
-                    request.rotationConfig.request(request.placeContext.rotation)
-                else null
 
-                pendingPlacements.setMaxSize(request.buildConfig.placeSettings.maxPendingPlacements)
-                pendingPlacements.setDecayTime(request.buildConfig.interactionTimeout * 50L)
+                val maxPlacementsThisTick =  (placeConfig.maxPendingPlacements - pendingPlacements.size).coerceAtLeast(0)
+                val takeCount = (placeConfig.placementsPerTick.coerceAtMost(maxPlacementsThisTick))
+                val isSneaking = player.isSneaking
+                val currentHotbarIndex = HotbarManager.serverSlot
+                placeContexts = request.placeContexts
+                    .filter { canPlace(it) }
+                    .sortedBy { isSneaking == it.sneak && currentHotbarIndex == it.hotbarIndex }
+                    .take(takeCount)
+
+                request.placeContexts.firstOrNull()?.let { ctx ->
+                    if (placeConfig.rotateForPlace || placeConfig.axisRotate)
+                        request.rotationConfig.request(ctx.rotation)
+                }
             }
-        }
 
-        onRotatePost(priority = Int.MIN_VALUE) {
-            validRotation = rotation?.done ?: true
             postEvent()
         }
 
         listen<MovementEvent.InputUpdate> {
-            if (currentRequest?.placeContext?.sneak == true) it.input.sneaking = true
+            if (placeContexts.firstOrNull()?.sneak == true) it.input.sneaking = true
         }
 
         listen<WorldEvent.BlockUpdate.Server> { event ->
             pendingPlacements
-                .firstOrNull { it.placeContext.expectedPos == event.pos }
-                ?.let { request ->
-                    removePendingPlace(request)
+                .firstOrNull { it.context.expectedPos == event.pos }
+                ?.let { info ->
+                    removePendingPlace(info)
 
                     // return if the block wasn't placed
-                    if (!matchesTargetState(event.pos, request.placeContext.targetState, event.newState))
+                    if (!matchesTargetState(event.pos, info.context.targetState, event.newState))
                         return@listen
 
-                    if (request.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
-                        with (request.placeContext) {
+                    if (info.placeConfig.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
+                        with (info.context) {
                             placeSound(expectedState.block.item as BlockItem, expectedState, expectedPos)
                         }
-                    request.onPlace()
+                    info.onPlace()
                     return@listen
                 }
         }
     }
 
     private fun canPlace(placeContext: PlaceContext) =
         pendingPlacements.none { pending ->
-            pending.placeContext.expectedPos == placeContext.expectedPos
+            pending.context.expectedPos == placeContext.expectedPos
         }
 
     private fun SafeContext.matchesTargetState(pos: BlockPos, targetState: TargetState, newState: BlockState) =
@@ -178,15 +184,16 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             false
         }
 
-    private fun SafeContext.placeBlock(request: PlaceRequest, hand: Hand): ActionResult {
+    private fun SafeContext.placeBlock(placeContext: PlaceContext, request: PlaceRequest, hand: Hand): ActionResult {
         interaction.syncSelectedSlot()
-        val hitResult = request.placeContext.result
+        val hitResult = placeContext.result
         if (!world.worldBorder.contains(hitResult.blockPos)) return ActionResult.FAIL
         if (gamemode == GameMode.SPECTATOR) return ActionResult.PASS
-        return interactBlockInternal(request, request.buildConfig.placeSettings, hand, hitResult)
+        return interactBlockInternal(placeContext, request, request.buildConfig.placeSettings, hand, hitResult)
     }
 
     private fun SafeContext.interactBlockInternal(
+        placeContext: PlaceContext,
         request: PlaceRequest,
         placeConfig: PlaceConfig,
         hand: Hand,
@@ -212,17 +219,18 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             val itemUsageContext = ItemUsageContext(player, hand, hitResult)
             return if (gamemode.isCreative) {
                 val i = itemStack.count
-                useOnBlock(request, hand, hitResult, placeConfig, itemStack, itemUsageContext)
+                useOnBlock(placeContext, request, hand, hitResult, placeConfig, itemStack, itemUsageContext)
                     .also {
                         itemStack.count = i
                     }
             } else
-                useOnBlock(request, hand, hitResult, placeConfig, itemStack, itemUsageContext)
+                useOnBlock(placeContext, request, hand, hitResult, placeConfig, itemStack, itemUsageContext)
         }
         return ActionResult.PASS
     }
 
     private fun SafeContext.useOnBlock(
+        placeContext: PlaceContext,
         request: PlaceRequest,
         hand: Hand,
         hitResult: BlockHitResult,
@@ -238,10 +246,11 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
 
         val item = (itemStack.item as? BlockItem) ?: return ActionResult.PASS
 
-        return place(request, hand, hitResult, placeConfig, item, ItemPlacementContext(context))
+        return place(placeContext, request, hand, hitResult, placeConfig, item, ItemPlacementContext(context))
     }
 
     private fun SafeContext.place(
+        placeContext: PlaceContext,
         request: PlaceRequest,
         hand: Hand,
         hitResult: BlockHitResult,
@@ -258,10 +267,12 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         val stackInHand = player.getStackInHand(hand)
         val stackCountPre = stackInHand.count
         if (placeConfig.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None) {
-            addPendingPlace(request)
+            addPendingPlace(
+                PlaceInfo(placeContext, request.onPlace, request.pendingInteractionsList, placeConfig)
+            )
         }
 
-        if (request.buildConfig.placeSettings.airPlace == PlaceConfig.AirPlaceMode.Grim) {
+        if (placeConfig.airPlace == PlaceConfig.AirPlaceMode.Grim) {
             val placeHand = if (hand == Hand.MAIN_HAND) Hand.OFF_HAND else Hand.MAIN_HAND
             airPlaceOffhandSwap()
             sendPlacePacket(placeHand, hitResult)
@@ -270,8 +281,8 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             sendPlacePacket(hand, hitResult)
         }
 
-        if (request.buildConfig.placeSettings.swing) {
-            swingHand(request.buildConfig.placeSettings.swingType, hand)
+        if (placeConfig.swing) {
+            swingHand(placeConfig.swingType, hand)
 
             if (!stackInHand.isEmpty && (stackInHand.count != stackCountPre || interaction.hasCreativeInventory())) {
                 mc.gameRenderer.firstPersonRenderer.resetEquipProgress(hand)
@@ -332,16 +343,23 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         )
     }
 
-    private fun addPendingPlace(request: PlaceRequest) {
-        pendingPlacements.add(request)
-        request.pendingInteractionsList.add(request.placeContext)
+    private fun addPendingPlace(info: PlaceInfo) {
+        pendingPlacements.add(info)
+        info.pendingInteractionsList.add(info.context)
     }
 
-    private fun removePendingPlace(request: PlaceRequest) {
-        pendingPlacements.remove(request)
-        request.pendingInteractionsList.remove(request.placeContext)
+    private fun removePendingPlace(info: PlaceInfo) {
+        pendingPlacements.remove(info)
+        info.pendingInteractionsList.remove(info.context)
     }
 
+    private data class PlaceInfo(
+        val context: PlaceContext,
+        val onPlace: () -> Unit,
+        val pendingInteractionsList: MutableCollection<BuildContext>,
+        val placeConfig: PlaceConfig
+    )
+
     override fun preEvent() = UpdateManagerEvent.Place.Pre().post()
     override fun postEvent() = UpdateManagerEvent.Place.Post().post()
 }
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceRequest.kt b/common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceRequest.kt
@@ -29,7 +29,7 @@ import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 
 data class PlaceRequest(
-    val placeContext: PlaceContext,
+    val placeContexts: Collection<PlaceContext>,
     val buildConfig: BuildConfig,
     val rotationConfig: RotationConfig,
     val hotbarConfig: HotbarConfig,
@@ -40,6 +40,6 @@ data class PlaceRequest(
 ) : Request(prio) {
     override val done: Boolean
         get() = runSafe {
-            placeContext.targetState.matches(blockState(placeContext.expectedPos), placeContext.expectedPos, world)
+            placeContexts.all { it.targetState.matches(blockState(it.expectedPos), it.expectedPos, world) }
         } == true
 }
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/rotation/RotationManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/rotation/RotationManager.kt
@@ -21,7 +21,12 @@ import com.lambda.Lambda
 import com.lambda.context.SafeContext
 import com.lambda.core.Loadable
 import com.lambda.event.EventFlow.post
-import com.lambda.event.events.*
+import com.lambda.event.events.ConnectionEvent
+import com.lambda.event.events.PacketEvent
+import com.lambda.event.events.PlayerPacketEvent
+import com.lambda.event.events.RotationEvent
+import com.lambda.event.events.TickEvent
+import com.lambda.event.events.UpdateManagerEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
 import com.lambda.interaction.request.Priority
diff --git a/common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt b/common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt
