SakuraMC/sakura-server/minecraft-patches/features/0009-Replace-explosion-density-cache.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Samsuik <kfian294ma4@gmail.com>
Date: Mon, 22 Apr 2024 23:01:26 +0100
Subject: [PATCH] Replace explosion density cache


diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
index 259faa131f4aec7db565c78c38aa058d20ef3d28..efdf41c42320ac9defd5d0eb206df5aaed012363 100644
--- a/net/minecraft/server/level/ServerLevel.java
+++ b/net/minecraft/server/level/ServerLevel.java
@@ -710,6 +710,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
         this.levelTickScheduler.repeatingTask(this.explosionPositions::clear, 0); // Sakura - client visibility settings
         this.levelTickScheduler.repeatingTask(this.mergeHandler::expire, 200); // Sakura - merge cannon entities
+        this.levelTickScheduler.repeatingTask(this.densityCache::expire, 0); // Sakura - explosion density cache
     }
 
     // Paper start
diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
index 93ff0fdaee21ac493833640b5f620f9bec1a69c8..e807aafed0295d8db7ba0782bb1e462561e9e1ec 100644
--- a/net/minecraft/world/level/Level.java
+++ b/net/minecraft/world/level/Level.java
@@ -834,6 +834,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
     public final me.samsuik.sakura.listener.BlockChangeTracker blockChangeTracker = new me.samsuik.sakura.listener.BlockChangeTracker(this);
     // Sakura end - track block changes and tick scheduler
     public final me.samsuik.sakura.entity.merge.EntityMergeHandler mergeHandler = new me.samsuik.sakura.entity.merge.EntityMergeHandler(); // Sakura - merge cannon entities
+    public final me.samsuik.sakura.explosion.density.BlockDensityCache densityCache = new me.samsuik.sakura.explosion.density.BlockDensityCache(this); // Sakura - optimise explosion density cache
 
     protected Level(
         WritableLevelData levelData,
diff --git a/net/minecraft/world/level/ServerExplosion.java b/net/minecraft/world/level/ServerExplosion.java
index a3e47902098331ce1dfcbb96909e4a8cd5d7da78..39a4f8ffb7c0e61d94c4384c4a3f77550fefe16f 100644
--- a/net/minecraft/world/level/ServerExplosion.java
+++ b/net/minecraft/world/level/ServerExplosion.java
@@ -296,7 +296,12 @@ public class ServerExplosion implements Explosion {
                             Math.fma(dz, diffZ, offZ)
                     );
 
-                    if (!this.clipsAnything(from, source, context, blockCache, blockPos)) {
+                    // Sakura start - replace density cache
+                    final float density = this.level.densityCache.getKnownDensity(from);
+                    if (density != me.samsuik.sakura.explosion.density.BlockDensityCache.UNKNOWN_DENSITY) {
+                        missedRays += (int) density;
+                    } else if (!this.clipsAnything(from, source, context, blockCache, blockPos)) {
+                        // Sakura end - replace density cache
                         ++missedRays;
                     }
                 }
@@ -354,8 +359,16 @@ public class ServerExplosion implements Explosion {
                         double d9 = Mth.lerp(d6, boundingBox.minY, boundingBox.maxY);
                         double d10 = Mth.lerp(d7, boundingBox.minZ, boundingBox.maxZ);
                         Vec3 vec3 = new Vec3(d8 + d3, d9, d10 + d4);
-                        if (entity.level().clip(new ClipContext(vec3, explosionVector, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, entity)).getType()
-                            == HitResult.Type.MISS) {
+                        // Sakura start - replace density cache
+                        final net.minecraft.world.phys.HitResult.Type hitResult;
+                        final float density = entity.level().densityCache.getKnownDensity(vec3);
+                        if (density != me.samsuik.sakura.explosion.density.BlockDensityCache.UNKNOWN_DENSITY) {
+                            hitResult = density != 0.0f ? net.minecraft.world.phys.HitResult.Type.MISS : net.minecraft.world.phys.HitResult.Type.BLOCK;
+                        } else {
+                            hitResult = entity.level().clip(new ClipContext(vec3, explosionVector, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, entity)).getType();
+                        }
+                        if (hitResult == HitResult.Type.MISS) {
+                            // Sakura end - replace density cache
                             i++;
                         }
 
@@ -597,6 +610,11 @@ public class ServerExplosion implements Explosion {
             return;
         }
         // CraftBukkit end
+        // Sakura start - explosion density cache
+        if (!blocks.isEmpty() && !this.level.paperConfig().environment.optimizeExplosions) {
+            this.level.densityCache.invalidate();
+        }
+        // Sakura end - explosion density cache
 
         for (BlockPos blockPos : blocks) {
             // CraftBukkit start - TNTPrimeEvent
@@ -765,14 +783,12 @@ public class ServerExplosion implements Explosion {
 
     // Paper start - Optimize explosions
     protected float getBlockDensity(Vec3 vec3d, Entity entity) {
-        if (!this.level.paperConfig().environment.optimizeExplosions) {
-            return this.getSeenFraction(vec3d, entity, this.directMappedBlockCache, this.mutablePos); // Paper - collision optimisations
-        }
-        CacheKey key = new CacheKey(this, entity.getBoundingBox());
-        Float blockDensity = this.level.explosionDensityCache.get(key);
-        if (blockDensity == null) {
+        // Sakura start - replace density cache
+        float blockDensity = this.level.densityCache.getBlockDensity(vec3d, entity);
+        if (blockDensity == me.samsuik.sakura.explosion.density.BlockDensityCache.UNKNOWN_DENSITY) {
             blockDensity = this.getSeenFraction(vec3d, entity, this.directMappedBlockCache, this.mutablePos); // Paper - collision optimisations
-            this.level.explosionDensityCache.put(key, blockDensity);
+            this.level.densityCache.putDensity(vec3d, entity, blockDensity);
+            // Sakura end - replace density cache
         }
 
         return blockDensity;
diff --git a/net/minecraft/world/level/block/BasePressurePlateBlock.java b/net/minecraft/world/level/block/BasePressurePlateBlock.java
index f9c1c5a7f0602c225d18005e7161384cc1d3c604..a43dfc0ebd28d42d4334021ac7255e496f78c6b7 100644
--- a/net/minecraft/world/level/block/BasePressurePlateBlock.java
+++ b/net/minecraft/world/level/block/BasePressurePlateBlock.java
@@ -107,6 +107,11 @@ public abstract class BasePressurePlateBlock extends Block {
         // CraftBukkit end
         if (currentSignal != signalStrength) {
             BlockState blockState = this.setSignalForState(state, signalStrength);
+            // Sakura start - explosion density cache
+            if (!level.paperConfig().environment.optimizeExplosions) {
+                level.densityCache.invalidate();
+            }
+            // Sakura end - explosion density cache
             level.setBlock(pos, blockState, 2);
             this.updateNeighbours(level, pos);
             level.setBlocksDirty(pos, state, blockState);
diff --git a/net/minecraft/world/level/block/TripWireHookBlock.java b/net/minecraft/world/level/block/TripWireHookBlock.java
index 8a3a8b0fdf9545a41501dc992c6982d9c8ce7b66..5e2576a8b90de8a829c6136cc384f3fe5a49603c 100644
--- a/net/minecraft/world/level/block/TripWireHookBlock.java
+++ b/net/minecraft/world/level/block/TripWireHookBlock.java
@@ -168,6 +168,11 @@ public class TripWireHookBlock extends Block {
                 if (!cancelledReceiverHook) { // always trigger two events even when the first hook current change is cancelled
                 // Paper end - Call BlockRedstoneEvent
                 Direction opposite = direction.getOpposite();
+                // Sakura start - explosion density cache
+                if (!level.paperConfig().environment.optimizeExplosions) {
+                    level.densityCache.invalidate();
+                }
+                // Sakura end - explosion density cache
                 level.setBlock(blockPosx, blockState1.setValue(FACING, opposite), 3);
                 notifyNeighbors(block, level, blockPosx, opposite);
                 emitState(level, blockPosx, flag2, flag3, flag, flag1);
diff --git a/net/minecraft/world/phys/AABB.java b/net/minecraft/world/phys/AABB.java
index f87d0bd3d65155fbc206a0dae8de67a9184436f3..da90795ce9d4589ee9a4b5ab10f3af59c772547b 100644
--- a/net/minecraft/world/phys/AABB.java
+++ b/net/minecraft/world/phys/AABB.java
@@ -19,6 +19,30 @@ public class AABB {
     public final double maxY;
     public final double maxZ;
 
+    // Sakura start - explosion density cache
+    public final boolean containsInclusive(final AABB other) {
+        return this.minX <= other.minX && this.maxX >= other.maxX
+            && this.minY <= other.minY && this.maxY >= other.maxY
+            && this.minZ <= other.minZ && this.maxZ >= other.maxZ;
+    }
+
+    public final boolean containsInclusive(final Vec3 pos) {
+        return this.minX <= pos.x && this.maxX >= pos.x
+            && this.minY <= pos.y && this.maxY >= pos.y
+            && this.minZ <= pos.z && this.maxZ >= pos.z;
+    }
+
+    public final AABB expand(final Vec3 pos) {
+        final double minX = Math.min(this.minX, pos.x);
+        final double minY = Math.min(this.minY, pos.y);
+        final double minZ = Math.min(this.minZ, pos.z);
+        final double maxX = Math.max(this.maxX, pos.x);
+        final double maxY = Math.max(this.maxY, pos.y);
+        final double maxZ = Math.max(this.maxZ, pos.z);
+        return new AABB(minX, minY, minZ, maxX, maxY, maxZ);
+    }
+    // Sakura end - explosion density cache
+
     public AABB(double x1, double y1, double z1, double x2, double y2, double z2) {
         this.minX = Math.min(x1, x2);
         this.minY = Math.min(y1, y2);