consistent confirmation checks for block updates in the managers

Author: beanbag44

common/src/main/kotlin/com/lambda/interaction/construction/context/InteractionContext.kt

@@ -36,7 +36,7 @@ class InteractionContext(
     override val result: BlockHitResult,
     override val rotation: RotationRequest,
     override var hotbarIndex: Int,
-    override val cachedState: BlockState,
+    override var cachedState: BlockState,
     override val expectedState: BlockState,
 ) : BuildContext() {
     private val baseColor = Color(35, 254, 79, 25)

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

@@ -67,7 +67,6 @@ import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.calcItemBlockBreakingDelta
-import com.lambda.util.BlockUtils.emptyState
 import com.lambda.util.BlockUtils.isEmpty
 import com.lambda.util.BlockUtils.isNotBroken
 import com.lambda.util.BlockUtils.isNotEmpty
@@ -192,8 +191,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                     if (isNotBroken(currentState, event.newState)) {
                         // check to see if its just some small property changes, e.g. redstone ore changing the LIT property
                         if (!currentState.matches(event.newState, ProcessorRegistry.postProcessedProperties))
-                            this@BreakManager.warn("Break at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${info.context.cachedState.emptyState}")
-                        // update the checked state
+                            this@BreakManager.warn("Server updated breaking block at ${event.pos.toShortString()} with a new state: ${event.newState}")
+                        // update the cached state
                         info.context.cachedState = event.newState
                         return@listen
                     }

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

@@ -59,7 +59,7 @@ object BrokenBlockHandler : PostActionHandler<BreakInfo>() {
             if (!info.broken) warn("${info::class.simpleName} at ${info.context.blockPos.toShortString()} timed out")
             else if (!TaskFlowModule.ignoreItemDropWarnings) warn("${info::class.simpleName}'s item drop at ${info.context.blockPos.toShortString()} timed out")
 
-            if (!info.broken && info.breakConfig.breakConfirmation != BreakConfirmationMode.AwaitThenBreak) {
+            if (info.broken && info.breakConfig.breakConfirmation != BreakConfirmationMode.AwaitThenBreak) {
                 world.setBlockState(info.context.blockPos, info.context.cachedState)
             }
         }
@@ -78,8 +78,10 @@ object BrokenBlockHandler : PostActionHandler<BreakInfo>() {
                 // return if the block's not broken
                 if (isNotBroken(currentState, event.newState)) {
                     // return if the state hasn't changed
-                    if (event.newState.matches(currentState, ProcessorRegistry.postProcessedProperties))
+                    if (event.newState.matches(currentState, ProcessorRegistry.postProcessedProperties)) {
+                        pending.context.cachedState = event.newState
                         return@listen
+                    }
 
                     if (!pending.isReBreaking) {
                         this@BrokenBlockHandler.warn("Broken block at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${pending.context.cachedState.emptyState}")

common/src/main/kotlin/com/lambda/interaction/request/interacting/InteractedBlockHandler.kt

@@ -27,9 +27,6 @@ import com.lambda.util.BlockUtils.matches
 import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
-import net.minecraft.block.BlockState
-import net.minecraft.util.Hand
-import net.minecraft.util.math.BlockPos
 
 object InteractedBlockHandler : PostActionHandler<InteractionInfo>() {
     override val pendingActions = LimitedDecayQueue<InteractionInfo>(
@@ -46,24 +43,20 @@ object InteractedBlockHandler : PostActionHandler<InteractionInfo>() {
         listen<WorldEvent.BlockUpdate.Server>(priority = Int.MIN_VALUE) { event ->
             pendingActions
                 .firstOrNull { it.context.blockPos == event.pos }
-                ?.let { info ->
-                    info.stopPending()
+                ?.let { pending ->
+                    pending.stopPending()
 
-                    if (!matchesTargetState(event.pos, info.context.expectedState, event.newState))
+                    if (!pending.context.expectedState.matches(event.newState)) {
+                        this@InteractedBlockHandler.warn("Interacted block at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${pending.context.expectedState}")
                         return@listen
+                    }
 
-                    if (info.interactConfirmationMode == InteractionConfig.InteractConfirmationMode.AwaitThenInteract)
-                        with (info.context) {
-                            cachedState.onUse(world, player, Hand.MAIN_HAND, result)
-                        }
+                    //ToDo: reliable way to recreate the sounds played when interacting with any given block
+//                    if (pending.interactConfirmationMode == InteractionConfig.InteractConfirmationMode.AwaitThenInteract)
+//                        with (pending.context) {
+//                            cachedState.onUse(world, player, Hand.MAIN_HAND, result)
+//                        }
                 }
         }
     }
-
-    private fun matchesTargetState(pos: BlockPos, targetState: BlockState, newState: BlockState) =
-        if (targetState.matches(newState)) true
-        else {
-            this@InteractedBlockHandler.warn("Interaction at ${pos.toShortString()} was rejected with $newState instead of $targetState")
-            false
-        }
 }

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

@@ -20,10 +20,11 @@ package com.lambda.interaction.request.placing
 import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.context.PlaceContext
 import com.lambda.interaction.request.ActionInfo
+import net.minecraft.util.math.BlockPos
 
 data class PlaceInfo(
     override val context: PlaceContext,
     override val pendingInteractionsList: MutableCollection<BuildContext>,
-    val onPlace: () -> Unit,
+    val onPlace: ((BlockPos) -> Unit)?,
     val placeConfig: PlaceConfig
 ) : ActionInfo

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

@@ -316,7 +316,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(
         if (!player.abilities.creativeMode) itemStack.decrement(1)
 
         if (placeConfig.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.None) {
-            request.onPlace()
+            request.onPlace?.invoke(placeContext.blockPos)
         }
 
         return ActionResult.success(world.isClient)

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

@@ -26,14 +26,15 @@ import com.lambda.interaction.request.rotating.RotationConfig
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.matches
+import net.minecraft.util.math.BlockPos
 
 data class PlaceRequest(
     val contexts: Collection<PlaceContext>,
     val build: BuildConfig,
     val rotation: RotationConfig,
     val hotbar: HotbarConfig,
     val pendingInteractions: MutableCollection<BuildContext>,
-    val onPlace: () -> Unit
+    val onPlace: ((BlockPos) -> Unit)? = null
 ) : Request(), PlaceConfig by build.placing {
     override val config = build.placing
     override val done: Boolean

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

@@ -45,21 +45,20 @@ object PlacedBlockHandler : PostActionHandler<PlaceInfo>() {
         listen<WorldEvent.BlockUpdate.Server>(priority = Int.MIN_VALUE) { event ->
             pendingActions
                 .firstOrNull { it.context.blockPos == event.pos }
-                ?.let { info ->
-                    info.stopPending()
+                ?.let { pending ->
+                    pending.stopPending()
 
                     // return if the block wasn't placed properly
-                    if (!event.newState.matches(info.context.expectedState)) {
-                        this@PlacedBlockHandler.warn(
-                            "Place at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${info.context.expectedState}"
-                        )
+                    if (!pending.context.expectedState.matches(event.newState)) {
+                        this@PlacedBlockHandler.warn("Place at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${pending.context.expectedState}")
+                        return@listen
                     }
 
-                    if (info.placeConfig.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
-                        with (info.context) {
+                    if (pending.placeConfig.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.AwaitThenPlace)
+                        with (pending.context) {
                             placeSound(expectedState.block.item as BlockItem, expectedState, blockPos)
                         }
-                    info.onPlace()
+                    pending.onPlace?.invoke(pending.context.blockPos)
                 }
         }
     }