Distinct block update event for server updates

Author: Avanatiker

common/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java

@@ -19,10 +19,13 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.EntityEvent;
+import com.lambda.event.events.WorldEvent;
 import com.lambda.module.modules.render.WorldColors;
 import com.lambda.util.math.ColorKt;
+import net.minecraft.block.BlockState;
 import net.minecraft.client.world.ClientWorld;
 import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -57,4 +60,9 @@ private void getSkyColorInject(Vec3d cameraPos, float tickDelta, CallbackInfoRet
             cir.setReturnValue(ColorKt.getVec3d(WorldColors.getSkyColor()));
         }
     }
+
+    @Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)
+    private void handleBlockUpdateInject(BlockPos pos, BlockState newState, int flags, CallbackInfo ci) {
+        if (EventFlow.post(new WorldEvent.BlockUpdate.Server(pos, newState)).isCanceled()) ci.cancel();
+    }
 }

common/src/main/java/com/lambda/mixin/world/WorldMixin.java

@@ -31,6 +31,6 @@
 public abstract class WorldMixin {
     @Inject(method = "onBlockChanged", at = @At("TAIL"))
     void onBlockChanged(BlockPos pos, BlockState oldBlock, BlockState newBlock, CallbackInfo ci) {
-        EventFlow.post(new WorldEvent.BlockChange(pos, oldBlock, newBlock));
+        EventFlow.post(new WorldEvent.BlockUpdateClientSide(pos, oldBlock, newBlock));
     }
 }

common/src/main/kotlin/com/lambda/event/events/WorldEvent.kt

@@ -18,7 +18,12 @@
 package com.lambda.event.events
 
 import com.lambda.event.Event
+import com.lambda.event.callback.Cancellable
+import com.lambda.event.callback.ICancellable
+import com.lambda.threading.runSafe
+import com.lambda.util.BlockUtils.blockState
 import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.shape.VoxelShape
 import net.minecraft.world.chunk.WorldChunk
@@ -41,7 +46,7 @@ sealed class WorldEvent {
      * These events can be used to listen for and respond to changes in the state
      * of chunks within the game world, providing contextual data for the operations.
      */
-    sealed class ChunkEvent : Event {
+    sealed class ChunkEvent {
         /**
          * Event triggering upon chunk loading
          */
@@ -59,17 +64,36 @@ sealed class WorldEvent {
     }
 
     /**
-     * Represents a block state change event within the world.
+     * Represents events related to block updates in the world.
      *
-     * @property pos The position of the block within the world where the change occurred.
-     * @property oldState The block state prior to the change.
-     * @property newState The block state after the change.
+     * This sealed class encapsulates different types of block update events,
+     * distinguishing between client-side state changes and server-side updates.
      */
-    data class BlockChange(
-        val pos: BlockPos,
-        val oldState: BlockState,
-        val newState: BlockState,
-    ) : Event
+    sealed class BlockUpdate {
+        /**
+         * Represents a client side block state change event within the world.
+         *
+         * @property pos The position of the block within the world where the change occurred.
+         * @property oldState The block state prior to the change.
+         * @property newState The block state after the change.
+         */
+        data class Client(
+            val pos: BlockPos,
+            val oldState: BlockState,
+            val newState: BlockState,
+        ) : Event
+
+        /**
+         * Represents a server block update event in the world.
+         *
+         * @property pos The position of the block in the world.
+         * @property newState The new state of the block after the update.
+         */
+        data class Server(
+            val pos: BlockPos,
+            val newState: BlockState,
+        ) : ICancellable by Cancellable()
+    }
 
     /**
      * Represents a collision event in the game world.

common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt

@@ -53,7 +53,7 @@ class ChunkedESP private constructor(
     }
 
     init {
-        listenConcurrently<WorldEvent.BlockChange> { event ->
+        listenConcurrently<WorldEvent.BlockUpdate.Client> { event ->
             world.getWorldChunk(event.pos).renderer.notifyChunks()
         }
 

common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -28,7 +28,6 @@ import com.lambda.graphics.renderer.esp.global.DynamicESP
 import com.lambda.interaction.request.rotation.RotationManager
 import com.lambda.interaction.request.rotation.RotationManager.onRotate
 import com.lambda.interaction.request.rotation.RotationRequest
-import com.lambda.interaction.request.rotation.visibilty.VisibilityChecker.collectHitsFor
 import com.lambda.interaction.request.rotation.visibilty.lookAtBlock
 import com.lambda.module.Module
 import com.lambda.module.modules.client.TaskFlowModule
@@ -515,7 +514,7 @@ object PacketMine : Module(
             }
         }
 
-        listen<WorldEvent.BlockChange> {
+        listen<WorldEvent.BlockUpdate.Client> {
             currentMiningBlock.forEach { ctx ->
                 ctx?.apply {
                     if (it.pos != pos || !isStateBroken(pos.blockState(world), it.newState)) return@forEach

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

@@ -50,10 +50,10 @@ import com.lambda.util.Communication.info
 import com.lambda.util.Formatting.string
 import com.lambda.util.collections.LimitedDecayQueue
 import com.lambda.util.extension.Structure
-import com.lambda.util.world.toFastVec
+import net.minecraft.block.BlockState
 import net.minecraft.network.packet.s2c.play.BlockUpdateS2CPacket
+import net.minecraft.network.packet.s2c.play.ChunkDeltaUpdateS2CPacket
 import net.minecraft.util.math.BlockPos
-import java.util.concurrent.ConcurrentLinkedQueue
 
 class BuildTask @Ta5kBuilder constructor(
     private val blueprint: Blueprint,
@@ -68,7 +68,7 @@ class BuildTask @Ta5kBuilder constructor(
 
     private val pendingInteractions = LimitedDecayQueue<BuildContext>(
         build.maxPendingInteractions, build.interactionTimeout * 50L
-    ) { info("Interaction at ${it.expectedPos.toShortString()} timed out") }
+    ) { info("${it::class.simpleName} at ${it.expectedPos.toShortString()} timed out") }
     private var currentInteraction: BuildContext? = null
 
     private var placements = 0
@@ -106,16 +106,18 @@ class BuildTask @Ta5kBuilder constructor(
                 .plus(pendingInteractions.toList())
 //                .plus(sim.goodPositions())
 
-            val instantResults = results.filterIsInstance<BreakResult.Break>()
-                .filter { it.context.instantBreak }
-                .sorted()
-                .take(build.breaksPerTick)
+            if (build.breaksPerTick > 1) {
+                val instantResults = results.filterIsInstance<BreakResult.Break>()
+                    .filter { it.context.instantBreak }
+                    .sorted()
+                    .take(build.breaksPerTick)
 
-            if (build.breaksPerTick > 1 && instantResults.isNotEmpty()) {
                 instantResults.forEach {
                     it.context.interact(interact.swingHand)
+                    pendingInteractions.add(it.context)
                 }
-                return@listen
+
+                if (instantResults.isNotEmpty()) return@listen
             }
 
             val resultsWithoutPending = results.filterNot { result ->
@@ -186,24 +188,20 @@ class BuildTask @Ta5kBuilder constructor(
             }
         }
 
-        listen<WorldEvent.BlockChange> { event ->
-            val interaction = currentInteraction ?: return@listen
-            if (interaction.expectedPos != event.pos) return@listen
+        listen<WorldEvent.BlockUpdate.Client> { event ->
+            val context = currentInteraction ?: return@listen
+            if (context.expectedPos != event.pos) return@listen
             currentInteraction = null
-            pendingInteractions.add(interaction)
+            pendingInteractions.add(context)
         }
 
-        listen<PacketEvent.Receive.Pre> { event ->
-            val packet = event.packet
-            if (packet !is BlockUpdateS2CPacket) return@listen
-
-            pendingInteractions.firstOrNull { it.expectedPos == packet.pos }?.let {
-                if (it.targetState.matches(packet.state, packet.pos, world)) {
-                    pendingInteractions.remove(it)
-                    when (it) {
-                        is BreakContext -> breaks++
-                        is PlaceContext -> placements++
-                    }
+        listen<WorldEvent.BlockUpdate.Server> { event ->
+            pendingInteractions.firstOrNull { it.expectedPos == event.pos }?.let { context ->
+                if (!context.targetState.matches(event.newState, event.pos, world)) return@let
+                pendingInteractions.remove(context)
+                when (context) {
+                    is BreakContext -> breaks++
+                    is PlaceContext -> placements++
                 }
             }
         }