Merge branch 'master' into feature/taskflow

Avanatiker · Avanatiker · commit 1ce6971af2ad · 2024-06-09T19:47:43.000+02:00
diff --git a/common/src/main/java/com/lambda/mixin/world/ClientChunkManagerMixin.java b/common/src/main/java/com/lambda/mixin/world/ClientChunkManagerMixin.java
@@ -0,0 +1,85 @@
+package com.lambda.mixin.world;
+
+import com.lambda.event.EventFlow;
+import com.lambda.event.events.WorldEvent;
+import net.minecraft.client.world.ClientChunkManager;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.network.packet.s2c.play.ChunkData;
+import net.minecraft.util.math.ChunkPos;
+import net.minecraft.world.chunk.WorldChunk;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+import java.util.function.Consumer;
+
+@Mixin(ClientChunkManager.class)
+public class ClientChunkManagerMixin {
+    @Final
+    @Shadow
+    ClientWorld world;
+
+    @Inject(method = "loadChunkFromPacket", at = @At("TAIL"))
+    private void onChunkLoad(
+            int x,
+            int z,
+            PacketByteBuf packetByteBuf,
+            NbtCompound nbtCompound,
+            Consumer<ChunkData.BlockEntityVisitor> consumer,
+            CallbackInfoReturnable<WorldChunk> info
+    ) {
+        EventFlow.post(new WorldEvent.ChunkEvent.Load(this.world, info.getReturnValue()));
+    }
+
+    @Inject(method = "loadChunkFromPacket", at = @At(value = "NEW", target = "net/minecraft/world/chunk/WorldChunk", shift = At.Shift.BEFORE), locals = LocalCapture.CAPTURE_FAILHARD)
+    private void onChunkUnload(
+            int x,
+            int z,
+            PacketByteBuf buf,
+            NbtCompound tag,
+            Consumer<ChunkData.BlockEntityVisitor> consumer,
+            CallbackInfoReturnable<WorldChunk> info,
+            int index,
+            WorldChunk chunk,
+            ChunkPos chunkPos
+    ) {
+        if (chunk != null) {
+            EventFlow.post(new WorldEvent.ChunkEvent.Unload(this.world, chunk));
+        }
+    }
+
+    @Inject(method = "unload", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/world/ClientChunkManager$ClientChunkMap;compareAndSet(ILnet/minecraft/world/chunk/WorldChunk;Lnet/minecraft/world/chunk/WorldChunk;)Lnet/minecraft/world/chunk/WorldChunk;"), locals = LocalCapture.CAPTURE_FAILHARD)
+    private void onChunkUnload(ChunkPos pos, CallbackInfo ci, int i, WorldChunk chunk) {
+        EventFlow.post(new WorldEvent.ChunkEvent.Unload(this.world, chunk));
+    }
+
+//    @Inject(
+//            method = "updateLoadDistance",
+//            at = @At(
+//                    value = "INVOKE",
+//                    target = "net/minecraft/client/world/ClientChunkManager$ClientChunkMap.isInRadius(II)Z"
+//            ),
+//            locals = LocalCapture.CAPTURE_FAILHARD
+//    )
+//    private void onUpdateLoadDistance(
+//            int loadDistance,
+//            CallbackInfo ci,
+//            int oldRadius,
+//            int newRadius,
+//            ClientChunkManager.ClientChunkMap clientChunkMap,
+//            int k,
+//            WorldChunk oldChunk,
+//            ChunkPos chunkPos
+//    ) {
+//        if (!clientChunkMap.isInRadius(chunkPos.x, chunkPos.z)) {
+//            EventFlow.post(new WorldEvent.ChunkEvent.Unload(this.world, oldChunk));
+//        }
+//    }
+}
diff --git a/common/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java b/common/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java
@@ -2,17 +2,26 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.WorldEvent;
+import net.minecraft.block.BlockState;
 import net.minecraft.client.world.ClientWorld;
 import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ClientWorld.class)
 public class ClientWorldMixin {
+    @Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)
+    private void handleBlockUpdateInject(BlockPos pos, BlockState state, int flags, CallbackInfo ci) {
+        if (EventFlow.post(new WorldEvent.BlockUpdate(pos, state, flags)).isCanceled()) {
+            ci.cancel();
+        }
+    }
+
     @Inject(method = "addEntity", at = @At("HEAD"), cancellable = true)
     private void addEntity(Entity entity, CallbackInfo ci) {
         if (EventFlow.post(new WorldEvent.EntitySpawn(entity)).isCanceled()) ci.cancel();
     }
-}
+}
diff --git a/common/src/main/kotlin/com/lambda/event/events/WorldEvent.kt b/common/src/main/kotlin/com/lambda/event/events/WorldEvent.kt
@@ -3,9 +3,34 @@ package com.lambda.event.events
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
+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.world.chunk.WorldChunk
 
 abstract class WorldEvent : Event {
+    abstract class ChunkEvent : WorldEvent() {
+        abstract val world: ClientWorld
+        abstract val chunk: WorldChunk
+
+        class Load(
+            override val world: ClientWorld,
+            override val chunk: WorldChunk
+        ) : ChunkEvent()
+
+        class Unload(
+            override val world: ClientWorld,
+            override val chunk: WorldChunk
+        ) : ChunkEvent()
+    }
+
+    class BlockUpdate(
+        val pos: BlockPos,
+        val state: BlockState,
+        val flags: Int
+    ) : WorldEvent(), ICancellable by Cancellable()
+
     class EntitySpawn(
         val entity: Entity
     ) : WorldEvent(), ICancellable by Cancellable()
diff --git a/common/src/main/kotlin/com/lambda/module/modules/debug/UpdateTest.kt b/common/src/main/kotlin/com/lambda/module/modules/debug/UpdateTest.kt
@@ -0,0 +1,27 @@
+package com.lambda.module.modules.debug
+
+import com.lambda.event.events.WorldEvent
+import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.Communication.info
+
+object UpdateTest : Module(
+    name = "UpdateTest",
+    description = "A module for testing updates",
+    defaultTags = setOf(ModuleTag.DEBUG)
+) {
+    init {
+        listener<WorldEvent.BlockUpdate> {
+            info("Block update at ${it.pos} with state ${it.state} and flags ${it.flags}")
+        }
+
+        listener<WorldEvent.ChunkEvent.Load> {
+            info("Chunk load at ${it.chunk.pos}")
+        }
+
+        listener<WorldEvent.ChunkEvent.Unload> {
+            info("Chunk unload at ${it.chunk.pos}")
+        }
+    }
+}
diff --git a/common/src/main/kotlin/com/lambda/util/combat/Explosion.kt b/common/src/main/kotlin/com/lambda/util/combat/Explosion.kt
@@ -20,8 +20,8 @@ object Explosion {
      * @param entity The entity to calculate the damage for.
      * @return The damage dealt by the explosion.
      */
-    fun SafeContext.damage(source: Explosion, entity: LivingEntity) =
-        damage(source.position, entity, source.power.toDouble())
+    fun SafeContext.explosionDamage(source: Explosion, entity: LivingEntity) =
+        explosionDamage(source.position, entity, source.power.toDouble())
 
     /**
      * Calculates the damage dealt by an explosion to a living entity.
@@ -30,7 +30,7 @@ object Explosion {
      * @param power The strength of the explosion above 0.
      * @return The damage dealt by the explosion.
      */
-    fun SafeContext.damage(position: Vec3d, entity: LivingEntity, power: Double): Double {
+    fun SafeContext.explosionDamage(position: Vec3d, entity: LivingEntity, power: Double): Double {
         val distance = entity.pos.distanceTo(position)
 
         val impact = (1.0 - distance / (power * 2.0)) *
@@ -49,10 +49,10 @@ object Explosion {
      * @param explosion The explosion to calculate the velocity for.
      * @return The velocity of the entities.
      */
-    fun SafeContext.velocity(explosion: Explosion): Map<LivingEntity, Vec3d> {
+    fun SafeContext.explosionVelocity(explosion: Explosion): Map<LivingEntity, Vec3d> {
         val ref = ArrayList<LivingEntity>()
-        getFastEntities<LivingEntity>(explosion.position, explosion.power * 2.0, ref)
-        return ref.associateWith { entity -> velocity(entity, explosion) }
+        getFastEntities(explosion.position, explosion.power * 2.0, ref)
+        return ref.associateWith { entity -> explosionVelocity(entity, explosion) }
     }
 
     /**
@@ -61,8 +61,8 @@ object Explosion {
      * @param explosion The explosion to calculate the velocity for.
      * @return The velocity of the entity.
      */
-    fun SafeContext.velocity(entity: LivingEntity, explosion: Explosion) =
-        velocity(entity, explosion.position, explosion.power.toDouble())
+    fun SafeContext.explosionVelocity(entity: LivingEntity, explosion: Explosion) =
+        explosionVelocity(entity, explosion.position, explosion.power.toDouble())
 
     /**
      * Calculates the velocity of a living entity affected by an explosion.
@@ -71,7 +71,7 @@ object Explosion {
      * @param power The strength of the explosion.
      * @return The velocity of the entity.
      */
-    fun SafeContext.velocity(entity: LivingEntity, position: Vec3d, power: Double): Vec3d {
+    fun SafeContext.explosionVelocity(entity: LivingEntity, position: Vec3d, power: Double): Vec3d {
         val distance = entity.pos.distanceTo(position)
 
         val size = power * 2.0
@@ -84,7 +84,7 @@ object Explosion {
         return diff.normalize() * vel
     }
 
-    fun SafeContext.destruction(source: Explosion): List<Vec3d> {
+    fun SafeContext.explosionDestruction(source: Explosion): List<Vec3d> {
         val affected = mutableListOf<Vec3d>()
 
         repeat(16) { x ->
diff --git a/common/src/main/kotlin/com/lambda/util/world/WorldUtils.kt b/common/src/main/kotlin/com/lambda/util/world/WorldUtils.kt
@@ -42,18 +42,6 @@ import kotlin.math.ceil
  *
  */
 object WorldUtils {
-    /**
-     * Gets the closest entity of type [T] within a specified range.
-     */
-    inline fun <reified T : Entity> SafeContext.getClosestEntity(
-        type: Class<out T>, // This is a class reference, not an instance of the class.
-        pos: Vec3d,
-        range: Double,
-        predicate: (T) -> Boolean = { true },
-    ): T? {
-        return getClosestEntity(pos, range, predicate)
-    }
-
     /**
      * Gets the closest entity of type [T] within a specified range.
      *
@@ -69,6 +57,7 @@ object WorldUtils {
         pos: Vec3d,
         range: Double,
         predicate: (T) -> Boolean = { true },
+        type: Class<out T> = T::class.java,
     ): T? {
         var closest: T? = null
         var closestDistance = Double.MAX_VALUE
@@ -86,20 +75,6 @@ object WorldUtils {
         return closest
     }
 
-    /**
-     * Gets all entities of type [T] within a specified distance from a position.
-     */
-    inline fun <T : Entity> SafeContext.getFastEntities(
-        type: Class<out T>, // This is a class reference, not an instance of the class.
-        pos: Vec3d,
-        distance: Double,
-        collector: MutableList<Entity>? = null,
-        iterator: (Entity, Int) -> Unit = { _, _ -> },
-        predicate: (Entity) -> Boolean = { true },
-    ) {
-        return getFastEntities(pos, distance, collector, iterator, predicate)
-    }
-
     /**
      * Gets all entities of type [T] within a specified distance from a position.
      *
@@ -134,6 +109,7 @@ object WorldUtils {
         pointer: MutableList<T>? = null,
         iterator: (T, Int) -> Unit = { _, _ -> },
         predicate: (T) -> Boolean = { true },
+        type: Class<out T> = T::class.java,
     ) {
         val chunks = ceil(distance / 16).toInt()
         val sectionX = pos.x.toInt() shr 4
@@ -161,20 +137,6 @@ object WorldUtils {
         }
     }
 
-    /**
-     * Gets all entities of type [T] within a specified distance from a position.
-     */
-    inline fun <reified T : Entity> SafeContext.getEntities(
-        type: Class<out T>, // This is a class reference, not an instance of the class.
-        pos: Vec3d,
-        distance: Double,
-        pointer: MutableList<Entity>? = null,
-        iterator: (Entity, Int) -> Unit = { _, _ -> },
-        predicate: (Entity) -> Boolean = { true },
-    ) {
-        return getEntities(pos, distance, pointer, iterator, predicate)
-    }
-
     /**
      * Gets all entities of type [T] within a specified distance from a position.
      *
@@ -191,6 +153,7 @@ object WorldUtils {
         pointer: MutableList<T>? = null,
         iterator: (T, Int) -> Unit = { _, _ -> },
         predicate: (T) -> Boolean = { true },
+        type: Class<out T> = T::class.java,
     ) {
         world.entities.filterPointer(pointer, iterator) { entity ->
             entity != player &&
diff --git a/common/src/main/resources/lambda.mixins.common.json b/common/src/main/resources/lambda.mixins.common.json
@@ -34,6 +34,7 @@
     "render.ScreenHandlerMixin",
     "render.VertexBufferMixin",
     "render.WorldRendererMixin",
+    "world.ClientChunkManagerMixin",
     "world.ClientWorldMixin"
   ],
   "injectors": {
