pending interaction improvements

beanbag44 · beanbag44 · commit 524f33b299f9 · 2025-03-17T02:10:48.000Z
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt b/common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt
@@ -38,7 +38,7 @@ data class BreakContext(
     override val pov: Vec3d,
     override val result: BlockHitResult,
     override val rotation: RotationRequest,
-    override val checkedState: BlockState,
+    override var checkedState: BlockState,
     override val targetState: TargetState,
     override var hotbarIndex: Int,
     var instantBreak: Boolean,
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/verify/TargetState.kt b/common/src/main/kotlin/com/lambda/interaction/construction/verify/TargetState.kt
@@ -19,7 +19,7 @@ package com.lambda.interaction.construction.verify
 
 import com.lambda.interaction.material.container.ContainerManager.findDisposable
 import com.lambda.module.modules.client.TaskFlowModule
-import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.BlockUtils.matches
 import com.lambda.util.StringUtils.capitalize
 import com.lambda.util.item.ItemUtils.block
 import net.minecraft.block.BlockState
@@ -80,9 +80,7 @@ sealed class TargetState(val type: Type) : StateMatcher {
         override fun toString() = "State of $blockState"
 
         override fun matches(state: BlockState, pos: BlockPos, world: ClientWorld) =
-            state.block == blockState.block && state.properties.all {
-                /*it in TaskFlowModule.defaultIgnoreTags ||*/ state[it] == blockState[it]
-            }
+            state.matches(blockState)
 
         override fun getStack(world: ClientWorld, pos: BlockPos): ItemStack =
             blockState.block.getPickStack(world, pos, blockState)
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
@@ -17,6 +17,7 @@
 
 package com.lambda.interaction.request.breaking
 
+import com.lambda.Lambda.mc
 import com.lambda.config.groups.BuildConfig
 import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
@@ -42,6 +43,7 @@ import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
 import com.lambda.util.BlockUtils.fluidState
+import com.lambda.util.BlockUtils.matches
 import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
@@ -70,7 +72,10 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
 
     private val pendingInteractions = LimitedDecayQueue<BreakInfo>(
         TaskFlowModule.build.maxPendingInteractions, TaskFlowModule.build.interactionTimeout * 50L
-    ) { info("${it::class.simpleName} at ${it.context.expectedPos.toShortString()} timed out") }
+    ) {
+        info("${it::class.simpleName} at ${it.context.expectedPos.toShortString()} timed out")
+        mc.world?.setBlockState(it.context.expectedPos, it.context.checkedState)
+    }
 
     override val blockedPositions
         get() = breakingInfos.mapNotNull { it?.context?.expectedPos } + pendingInteractions.map { it.context.expectedPos }
@@ -187,21 +192,36 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             pendingInteractions
                 .firstOrNull { it.context.expectedPos == event.pos }
                 ?.let { pending ->
+                    // return if the state hasn't changed
+                    if (event.newState.matches(pending.context.checkedState))
+                        return@listen
+
                     pendingInteractions.remove(pending)
-                    if (!matchesTargetState(event.pos, pending.context.targetState, event.newState)) return@listen
-                    if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak)
+                    // return if the block's not broken
+                    if (!matchesTargetState(event.pos, pending.context.targetState, event.newState))
+                        return@listen
+
+                    if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak) {
                         destroyBlock(pending)
+                    }
                     pending.onBreak()
+                    return@listen
                 }
-                ?: breakingInfos
-                    .filterNotNull()
-                    .firstOrNull { it.context.expectedPos == event.pos }
-                    ?.let { info ->
-                        if (!matchesTargetState(event.pos, info.context.targetState, event.newState)) return@listen
-                        info.nullify()
-                        destroyBlock(info)
-                        info.onBreak()
+
+            breakingInfos
+                .filterNotNull()
+                .firstOrNull { it.context.expectedPos == event.pos }
+                ?.let { info ->
+                    // if not broken
+                    if (!matchesTargetState(event.pos, info.context.targetState, event.newState)) {
+                        // update the checked state
+                        info.context.checkedState = event.newState
+                        return@listen
                     }
+                    destroyBlock(info)
+                    info.onBreak()
+                    info.nullify()
+                }
         }
 
         //ToDo: drop callback stuff
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
@@ -17,7 +17,7 @@
 
 package com.lambda.interaction.request.placing
 
-import com.lambda.config.groups.BuildConfig
+import com.lambda.Lambda.mc
 import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.MovementEvent
@@ -36,6 +36,8 @@ 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.item
+import com.lambda.util.BlockUtils.matches
 import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
@@ -56,15 +58,17 @@ import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.world.GameMode
-import org.apache.commons.lang3.mutable.MutableObject
 
 object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
-    private val pendingInteractions = LimitedDecayQueue<PlaceInfo>(
+    private val pendingInteractions = LimitedDecayQueue<PlaceRequest>(
         TaskFlowModule.build.maxPendingInteractions, TaskFlowModule.build.interactionTimeout * 50L
-    ) { info("${it::class.simpleName} at ${it.context.expectedPos.toShortString()} timed out") }
+    ) {
+        info("${it::class.simpleName} at ${it.placeContext.expectedPos.toShortString()} timed out")
+        mc.world?.setBlockState(it.placeContext.expectedPos, it.placeContext.checkedState)
+    }
 
     override val blockedPositions
-        get() = pendingInteractions.map { it.context.expectedPos }
+        get() = pendingInteractions.map { it.placeContext.expectedPos }
 
     private var rotation: RotationRequest? = null
     private var validRotation = false
@@ -95,6 +99,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
                     return@listen
 
                 placeBlock(request, Hand.MAIN_HAND)
+                activeThisTick = true
             }
         }
 
@@ -117,8 +122,6 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
                     return@onRotate
                 }
 
-                activeThisTick = true
-
                 rotation = if (request.buildConfig.placeSettings.rotateForPlace)
                     request.rotationConfig.request(request.placeContext.rotation)
                 else null
@@ -139,20 +142,27 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
 
         listen<WorldEvent.BlockUpdate.Server> { event ->
             pendingInteractions
-                .firstOrNull { it.context.expectedPos == event.pos }
-                ?.let { pending ->
-                    pendingInteractions.remove(pending)
-                    if (!matchesTargetState(event.pos, pending.context.targetState, event.newState)) return@listen
-                    if (pending.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
-                        placeSound(pending.item, pending.context.expectedState, pending.context.expectedPos)
-                    pending.onPlace()
+                .firstOrNull { it.placeContext.expectedPos == event.pos }
+                ?.let { request ->
+                    pendingInteractions.remove(request)
+
+                    // return if the block wasn't placed
+                    if (!matchesTargetState(event.pos, request.placeContext.targetState, event.newState))
+                        return@listen
+
+                    if (request.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
+                        with (request.placeContext) {
+                            placeSound(expectedState.block.item as BlockItem, expectedState, expectedPos)
+                        }
+                    request.onPlace()
+                    return@listen
                 }
         }
     }
 
     private fun canPlace(placeContext: PlaceContext) =
         pendingInteractions.none { pending ->
-            pending.context.expectedPos == placeContext.expectedPos
+            pending.placeContext.expectedPos == placeContext.expectedPos
         }
 
     private fun SafeContext.matchesTargetState(pos: BlockPos, targetState: TargetState, newState: BlockState) =
@@ -162,48 +172,35 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             false
         }
 
-    private fun SafeContext.placeBlock(request: PlaceRequest, hand: Hand) {
-        val stackInHand = player.getStackInHand(hand)
-        val item = stackInHand.item as? BlockItem ?: return
-        val stackCountPre = stackInHand.count
-        val actionResult = interactBlock(request.buildConfig.placeSettings, hand, request.placeContext.result)
-
-        if (actionResult.isAccepted) {
-            if (request.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.None)
-                request.onPlace()
-            else {
-                pendingInteractions.add(
-                    PlaceInfo(
-                        request.placeContext,
-                        item,
-                        request.buildConfig,
-                        request.onPlace
-                    )
-                )
-            }
-
-            if (actionResult.shouldSwingHand() && request.buildConfig.placeSettings.swing) {
-                swingHand(request.buildConfig.placeSettings.swingType)
-            }
+    private fun SafeContext.placeBlock(request: PlaceRequest, hand: Hand) =
+        interactBlock(request, request.buildConfig.placeSettings, hand, request.placeContext.result)
 
-            if (!stackInHand.isEmpty && (stackInHand.count != stackCountPre || interaction.hasCreativeInventory())) {
-                mc.gameRenderer.firstPersonRenderer.resetEquipProgress(hand)
-            }
-        } else {
-            warn("Placement interaction failed with $actionResult")
-        }
-    }
-
-    private fun SafeContext.interactBlock(placeConfig: PlaceConfig, hand: Hand, hitResult: BlockHitResult): ActionResult {
+    private fun SafeContext.interactBlock(request: PlaceRequest, placeConfig: PlaceConfig, hand: Hand, hitResult: BlockHitResult) {
         interaction.syncSelectedSlot()
-        if (!world.worldBorder.contains(hitResult.blockPos)) return ActionResult.FAIL
+        if (!world.worldBorder.contains(hitResult.blockPos)) return
 
-        val mutableActionResult = MutableObject<ActionResult>()
         interaction.sendSequencedPacket(world) { sequence: Int ->
-            mutableActionResult.value = interactBlockInternal(placeConfig, hand, hitResult)
+            val stackInHand = player.getStackInHand(hand)
+            val stackCountPre = stackInHand.count
+            val actionResult = interactBlockInternal(placeConfig, hand, hitResult)
+            if (actionResult.isAccepted) {
+                if (request.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.None)
+                    request.onPlace()
+                else
+                    pendingInteractions.add(request)
+
+                if (actionResult.shouldSwingHand() && request.buildConfig.placeSettings.swing) {
+                    swingHand(request.buildConfig.placeSettings.swingType)
+                }
+
+                if (!stackInHand.isEmpty && (stackInHand.count != stackCountPre || interaction.hasCreativeInventory())) {
+                    mc.gameRenderer.firstPersonRenderer.resetEquipProgress(hand)
+                }
+            } else {
+                warn("Placement interaction failed with $actionResult")
+            }
             PlayerInteractBlockC2SPacket(hand, hitResult, sequence)
         }
-        return mutableActionResult.value
     }
 
     private fun SafeContext.interactBlockInternal(
@@ -212,7 +209,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         hitResult: BlockHitResult
     ): ActionResult {
         val itemStack = player.getStackInHand(hand)
-        if (gamemode == GameMode.SPECTATOR) return ActionResult.SUCCESS
+        if (gamemode == GameMode.SPECTATOR) return ActionResult.PASS
 
         // checks if the player should be able to interact with the block for if its something
         // like a furnace or chest where an action would happen
@@ -297,13 +294,6 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         )
     }
 
-    data class PlaceInfo(
-        val context: PlaceContext,
-        val item: BlockItem,
-        val buildConfig: BuildConfig,
-        val onPlace: () -> Unit
-    )
-
     override fun preEvent() = UpdateManagerEvent.Place.Pre().post()
     override fun postEvent() = UpdateManagerEvent.Place.Post().post()
 }
diff --git a/common/src/main/kotlin/com/lambda/util/BlockUtils.kt b/common/src/main/kotlin/com/lambda/util/BlockUtils.kt
@@ -236,6 +236,11 @@ object BlockUtils {
     fun SafeContext.fluidState(pos: BlockPos): FluidState = world.getFluidState(pos)
     fun SafeContext.blockEntity(pos: BlockPos) = world.getBlockEntity(pos)
 
+    fun BlockState.matches(state: BlockState) =
+         this.block == state.block && this.properties.all {
+            /*it in TaskFlowModule.defaultIgnoreTags ||*/ this[it] == state[it]
+        }
+
     fun SafeContext.instantBreakable(blockState: BlockState, blockPos: BlockPos, breakThreshold: Float): Boolean {
         val ticksNeeded = 1 / (blockState.calcBlockBreakingDelta(player, world, blockPos) / breakThreshold)
         return (ticksNeeded <= 1 && ticksNeeded != 0f) || gamemode.isCreative
