fixed time dilations

king progress
beams

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/AntarchyFabricContent.java

@@ -321,7 +321,21 @@ public final class AntarchyFabricContent {
                 AntarchyFabricSounds.QUEEN_BEAM_SHOOT,
                 AntarchyFabricSounds.QUEEN_BEAM_START,
                 AntarchyFabricSounds.QUEEN_BEAM_LOOP,
-                AntarchyFabricSounds.QUEEN_BEAM_END
+                AntarchyFabricSounds.QUEEN_BEAM_END,
+                AntarchyFabricSounds.KING_STOMP,
+                AntarchyFabricSounds.KING_ROAR,
+                AntarchyFabricSounds.KING_WING_FLAP,
+                AntarchyFabricSounds.KING_FLY_LOOP,
+                AntarchyFabricSounds.PRINCE_IDLE,
+                AntarchyFabricSounds.PRINCE_BITE,
+                AntarchyFabricSounds.PRINCE_SHOOT,
+                AntarchyFabricSounds.PRINCE_FLY,
+                AntarchyFabricSounds.PRINCE_STEP,
+                AntarchyFabricSounds.PRINCESS_IDLE,
+                AntarchyFabricSounds.PRINCESS_BITE,
+                AntarchyFabricSounds.PRINCESS_SHOOT,
+                AntarchyFabricSounds.PRINCESS_FLY,
+                AntarchyFabricSounds.PRINCESS_STEP
         );
 
         AntarchyObjects.setOctopusBomb(AntarchyFabricEntities.OCTOPUS_BOMB);
@@ -334,6 +348,7 @@ public final class AntarchyFabricContent {
         AntarchyObjects.setVortex(AntarchyFabricEntities.VORTEX);
         AntarchyObjects.setWindVortex(() -> AntarchyFabricEntities.WIND_VORTEX.get());
         AntarchyObjects.setTimeDilationField(() -> AntarchyFabricEntities.TIME_DILATION_FIELD.get());
+        AntarchyObjects.setRoyalBlackHole(() -> AntarchyFabricEntities.ROYAL_BLACK_HOLE.get());
         AntarchyObjects.setVortexChargeProjectile(() -> AntarchyFabricEntities.VORTEX_CHARGE_PROJECTILE.get());
         AntarchyObjects.setPrince(() -> AntarchyFabricEntities.PRINCE.get());
         AntarchyObjects.setPrincess(() -> AntarchyFabricEntities.PRINCESS.get());
@@ -516,6 +531,9 @@ public final class AntarchyFabricContent {
         com.craisinlord.antarchy.content.time.TimeDilationApi.setSyncDispatcher(
                 com.craisinlord.antarchy.fabric.network.AntarchyFabricTimeDilationNetworking::syncRate
         );
+        com.craisinlord.antarchy.content.time.TimeDilationApi.setFieldSyncDispatcher(
+                com.craisinlord.antarchy.fabric.network.AntarchyFabricTimeDilationNetworking::syncFields
+        );
         AntarchyFabricEvents.register();
 
         if (isSupportedInfinityLoaded()) {

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/AntarchyFabricEvents.java

@@ -19,6 +19,7 @@ import com.craisinlord.antarchy.content.horde.CavarynHordeManager;
 import com.craisinlord.antarchy.content.portal.PermanentPortalManager;
 import com.craisinlord.antarchy.content.command.CavarynCommand;
 import com.craisinlord.antarchy.content.command.CaterpillarCommand;
+import com.craisinlord.antarchy.content.command.DimensionalTearCommand;
 import com.craisinlord.antarchy.content.command.GravityCommand;
 import com.craisinlord.antarchy.content.time.TimeDilationCommand;
 import com.craisinlord.antarchy.content.time.TimeDilationManager;
@@ -65,10 +66,19 @@ public final class AntarchyFabricEvents {
     }
 
     public static void register() {
+        net.fabricmc.fabric.api.networking.v1.EntityTrackingEvents.START_TRACKING.register((trackedEntity, player) -> {
+            if (trackedEntity instanceof com.craisinlord.antarchy.content.time.TimeDilationEntityAccess access
+                    && player instanceof ServerPlayer serverPlayer) {
+                com.craisinlord.antarchy.fabric.network.AntarchyFabricTimeDilationNetworking.syncRateToPlayer(
+                        serverPlayer, trackedEntity, access.antarchy$getTimeDilationRate()
+                );
+            }
+        });
         CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
             CavarynCommand.register(dispatcher);
             GravityCommand.register(dispatcher);
             CaterpillarCommand.register(dispatcher);
+            DimensionalTearCommand.register(dispatcher);
             TimeDilationCommand.register(dispatcher);
         });
 

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/client/AntarchyFabricClientBootstrap.java

@@ -146,6 +146,7 @@ public final class AntarchyFabricClientBootstrap {
         EntityRendererRegistry.register(AntarchyFabricEntities.VORTEX_CHARGE_PROJECTILE.get(), ThrownItemRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricEntities.WIND_VORTEX.get(), WindVortexRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricEntities.TIME_DILATION_FIELD.get(), TimeDilationFieldRenderer::new);
+        EntityRendererRegistry.register(AntarchyFabricEntities.ROYAL_BLACK_HOLE.get(), net.minecraft.client.renderer.entity.NoopRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricEntities.CRITTER_CAGE_PROJECTILE.get(), ThrownItemRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricEntities.WORM_HOOK_PROJECTILE.get(), ThrownItemRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricEntities.HUSH_PROJECTILE.get(), HushProjectileRenderer::new);

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/client/AntarchyKeyBindings.java

@@ -17,13 +17,6 @@ public final class AntarchyKeyBindings {
             CATEGORY
     );
 
-    public static final KeyMapping DORRIE_CHARGE_JUMP = new KeyMapping(
-            "key.antarchy.dorrie_charge_jump",
-            InputConstants.Type.KEYSYM,
-            GLFW.GLFW_KEY_LEFT_CONTROL,
-            CATEGORY
-    );
-
     public static final KeyMapping MOUNT_SPECIAL = new KeyMapping(
             "key.antarchy.mount_special",
             InputConstants.Type.KEYSYM,
@@ -55,7 +48,6 @@ public final class AntarchyKeyBindings {
 
     public static void register() {
         KeyBindingHelper.registerKeyBinding(BRUTALFLY_FLAP);
-        KeyBindingHelper.registerKeyBinding(DORRIE_CHARGE_JUMP);
         KeyBindingHelper.registerKeyBinding(MOUNT_SPECIAL);
         KeyBindingHelper.registerKeyBinding(MOUNT_FLIGHT_TOGGLE);
         KeyBindingHelper.registerKeyBinding(TIGERS_EYE_CAMOUFLAGE);
@@ -66,10 +58,6 @@ public final class AntarchyKeyBindings {
         return Minecraft.getInstance().screen == null && BRUTALFLY_FLAP.isDown();
     }
 
-    public static boolean isDorrieChargeJumpPressed() {
-        return Minecraft.getInstance().screen == null && DORRIE_CHARGE_JUMP.isDown();
-    }
-
     public static boolean isMountSpecialPressed() {
         return Minecraft.getInstance().screen == null && MOUNT_SPECIAL.isDown();
     }

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/client/DorrieJumpClientHandler.java

@@ -35,7 +35,7 @@ public final class DorrieJumpClientHandler {
         }
 
         // Left ctrl → charge jump.
-        boolean pressingCharge = AntarchyKeyBindings.isDorrieChargeJumpPressed();
+        boolean pressingCharge = AntarchyKeyBindings.isMountSpecialPressed();
         if (pressingCharge != wasPressingCharge) {
             ClientPlayNetworking.send(new DorrieChargeJumpPayload(pressingCharge));
             if (!pressingCharge && player.getVehicle() instanceof DorrieEntity dorrie) {

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/mixin/AntiwaterItemEntityMixin.java

@@ -1,10 +1,7 @@
 package com.craisinlord.antarchy.fabric.mixin;
 
-import com.craisinlord.antarchy.content.fluid.AntarchyFluidChecks;
 import com.craisinlord.antarchy.fabric.util.CustomFluidPhysicsChecks;
-import net.minecraft.core.BlockPos;
 import net.minecraft.world.entity.item.ItemEntity;
-import net.minecraft.world.level.material.FluidState;
 import net.minecraft.world.phys.Vec3;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -16,7 +13,7 @@ public abstract class AntiwaterItemEntityMixin {
     @Inject(method = "tick", at = @At("TAIL"))
     private void antarchy$applyAntiwaterItemMovement(CallbackInfo ci) {
         ItemEntity entity = (ItemEntity) (Object) this;
-        if (!antarchy$isTouchingAntiwater(entity)) {
+        if (!CustomFluidPhysicsChecks.isTouchingAntiwater(entity)) {
             return;
         }
 
@@ -29,22 +26,4 @@ public abstract class AntiwaterItemEntityMixin {
                 motion.z * 0.99D + push.z
         );
     }
-
-    private boolean antarchy$isTouchingAntiwater(ItemEntity entity) {
-        BlockPos min = BlockPos.containing(entity.getBoundingBox().minX, entity.getBoundingBox().minY, entity.getBoundingBox().minZ);
-        BlockPos max = BlockPos.containing(entity.getBoundingBox().maxX, entity.getBoundingBox().maxY, entity.getBoundingBox().maxZ);
-        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
-        for (int x = min.getX(); x <= max.getX(); x++) {
-            for (int y = min.getY(); y <= max.getY(); y++) {
-                for (int z = min.getZ(); z <= max.getZ(); z++) {
-                    cursor.set(x, y, z);
-                    FluidState fluidState = entity.level().getFluidState(cursor);
-                    if (AntarchyFluidChecks.isAntiwater(fluidState)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
 }

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/mixin/AntiwaterLivingEntityMixin.java

@@ -1,17 +1,13 @@
 package com.craisinlord.antarchy.fabric.mixin;
 
 import com.craisinlord.antarchy.content.AntarchyObjects;
-import com.craisinlord.antarchy.content.fluid.AntarchyFluidChecks;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityDirection;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityRotationUtil;
 import com.craisinlord.antarchy.fabric.util.CustomFluidPhysicsChecks;
-import net.minecraft.core.BlockPos;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.entity.MoverType;
 import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.material.FluidState;
-import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.Vec3;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -23,7 +19,7 @@ public abstract class AntiwaterLivingEntityMixin {
     @Inject(method = "travel", at = @At("HEAD"), cancellable = true)
     private void antarchy$moveInAntiwater(Vec3 travelVector, CallbackInfo ci) {
         LivingEntity entity = (LivingEntity) (Object) this;
-        if (!antarchy$isTouchingAntiwaterLocal(entity)) {
+        if (!CustomFluidPhysicsChecks.isTouchingAntiwater(entity)) {
             return;
         }
 
@@ -88,23 +84,4 @@ public abstract class AntiwaterLivingEntityMixin {
 
         return AntarchyGravityDirection.UP;
     }
-
-    private boolean antarchy$isTouchingAntiwaterLocal(LivingEntity entity) {
-        AABB box = entity.getBoundingBox().inflate(0.05D);
-        BlockPos min = BlockPos.containing(box.minX, box.minY, box.minZ);
-        BlockPos max = BlockPos.containing(box.maxX, box.maxY, box.maxZ);
-        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
-        for (int x = min.getX(); x <= max.getX(); x++) {
-            for (int y = min.getY(); y <= max.getY(); y++) {
-                for (int z = min.getZ(); z <= max.getZ(); z++) {
-                    cursor.set(x, y, z);
-                    FluidState fluidState = entity.level().getFluidState(cursor);
-                    if (AntarchyFluidChecks.isAntiwater(fluidState)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
 }

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/network/AntarchyFabricTimeDilationNetworking.java

@@ -1,12 +1,16 @@
 package com.craisinlord.antarchy.fabric.network;
 
 import com.craisinlord.antarchy.content.network.TimeDilationRatePayload;
+import com.craisinlord.antarchy.content.network.TimeDilationFieldsPayload;
 import com.craisinlord.antarchy.content.time.TimeDilationApi;
+import com.craisinlord.antarchy.content.time.TimeDilationFieldSnapshot;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
 import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
+import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
+import java.util.List;
 
 public final class AntarchyFabricTimeDilationNetworking {
     private AntarchyFabricTimeDilationNetworking() {
@@ -14,24 +18,35 @@ public final class AntarchyFabricTimeDilationNetworking {
 
     public static void registerPayloadTypes() {
         PayloadTypeRegistry.playS2C().register(TimeDilationRatePayload.TYPE, TimeDilationRatePayload.STREAM_CODEC);
+        PayloadTypeRegistry.playS2C().register(TimeDilationFieldsPayload.TYPE, TimeDilationFieldsPayload.STREAM_CODEC);
     }
 
     public static void registerClientReceiver() {
         ClientPlayNetworking.registerGlobalReceiver(TimeDilationRatePayload.TYPE, (payload, context) ->
                 context.client().execute(() -> handleRate(context.player(), payload)));
+        ClientPlayNetworking.registerGlobalReceiver(TimeDilationFieldsPayload.TYPE, (payload, context) ->
+                context.client().execute(() -> com.craisinlord.antarchy.content.client.ClientTimeDilationTicker.applyFields(payload.fields())));
     }
 
-    public static void syncRate(ServerPlayer player, double rate) {
-        ServerPlayNetworking.send(player, new TimeDilationRatePayload(player.getId(), rate));
+    public static void syncRate(Entity entity, double rate) {
+        TimeDilationRatePayload payload = new TimeDilationRatePayload(entity.getUUID(), rate);
+        for (ServerPlayer player : PlayerLookup.tracking(entity)) {
+            ServerPlayNetworking.send(player, payload);
+        }
+        if (entity instanceof ServerPlayer player) {
+            ServerPlayNetworking.send(player, payload);
+        }
+    }
+
+    public static void syncRateToPlayer(ServerPlayer player, Entity entity, double rate) {
+        ServerPlayNetworking.send(player, new TimeDilationRatePayload(entity.getUUID(), rate));
+    }
+
+    public static void syncFields(ServerPlayer player, List<TimeDilationFieldSnapshot> fields) {
+        ServerPlayNetworking.send(player, new TimeDilationFieldsPayload(fields));
     }
 
     private static void handleRate(Entity contextPlayer, TimeDilationRatePayload payload) {
-        Entity entity = contextPlayer.level().getEntity(payload.entityId());
-        if (entity == null && contextPlayer.getId() == payload.entityId()) {
-            entity = contextPlayer;
-        }
-        if (entity != null) {
-            TimeDilationApi.applySyncedRate(entity, payload.rate());
-        }
+        TimeDilationApi.applySyncedRate(payload.entityUuid(), payload.rate());
     }
 }

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/registry/AntarchyFabricEntities.java

@@ -475,6 +475,14 @@ public final class AntarchyFabricEntities {
                     .fireImmune()
                     .build("time_dilation_field"));
 
+    public static final DeferredHolder<EntityType<?>, EntityType<com.craisinlord.antarchy.content.entity.royal.RoyalBlackHoleEntity>> ROYAL_BLACK_HOLE = ENTITY_TYPES.register("royal_black_hole",
+            () -> EntityType.Builder.<com.craisinlord.antarchy.content.entity.royal.RoyalBlackHoleEntity>of(com.craisinlord.antarchy.content.entity.royal.RoyalBlackHoleEntity::new, MobCategory.MISC)
+                    .sized(1.0F, 1.0F)
+                    .clientTrackingRange(16)
+                    .updateInterval(2)
+                    .fireImmune()
+                    .build("royal_black_hole"));
+
 
     public static final DeferredHolder<EntityType<?>, EntityType<LucidBoltEntity>> LUCID_BOLT = ENTITY_TYPES.register("lucid_bolt",
             () -> EntityType.Builder.<LucidBoltEntity>of(LucidBoltEntity::new, MobCategory.MISC)

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/registry/AntarchyFabricSounds.java

@@ -556,6 +556,17 @@ public final class AntarchyFabricSounds {
     public static final DeferredHolder<SoundEvent, SoundEvent> QUEEN_BLACK_HOLE_SHOOT = registerSoundEvent("queen_black_hole_shoot");
     public static final DeferredHolder<SoundEvent, SoundEvent> QUEEN_CAST_SHOOT = registerSoundEvent("queen_cast_shoot");
 
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCE_IDLE = registerSoundEvent("prince_idle");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCE_BITE = registerSoundEvent("prince_bite");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCE_SHOOT = registerSoundEvent("prince_shoot");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCE_FLY = registerSoundEvent("prince_fly");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCE_STEP = registerSoundEvent("prince_step");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCESS_IDLE = registerSoundEvent("princess_idle");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCESS_BITE = registerSoundEvent("princess_bite");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCESS_SHOOT = registerSoundEvent("princess_shoot");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCESS_FLY = registerSoundEvent("princess_fly");
+    public static final DeferredHolder<SoundEvent, SoundEvent> PRINCESS_STEP = registerSoundEvent("princess_step");
+
 
 
 

fabric-1.21.1/src/main/java/com/craisinlord/antarchy/fabric/util/CustomFluidPhysicsChecks.java

@@ -2,45 +2,45 @@ package com.craisinlord.antarchy.fabric.util;
 
 import com.craisinlord.antarchy.content.fluid.AntarchyFluidChecks;
 import net.minecraft.core.BlockPos;
+import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
 import net.minecraft.world.level.material.FluidState;
 import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.Vec3;
 
+import java.util.function.Predicate;
+
 public final class CustomFluidPhysicsChecks {
     private CustomFluidPhysicsChecks() {
     }
 
     public static boolean isTouchingAntiwater(Entity entity) {
-        AABB box = entity.getBoundingBox().inflate(0.05D);
-        BlockPos min = BlockPos.containing(box.minX, box.minY, box.minZ);
-        BlockPos max = BlockPos.containing(box.maxX, box.maxY, box.maxZ);
-        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
-        for (int x = min.getX(); x <= max.getX(); x++) {
-            for (int y = min.getY(); y <= max.getY(); y++) {
-                for (int z = min.getZ(); z <= max.getZ(); z++) {
-                    cursor.set(x, y, z);
-                    FluidState fluidState = entity.level().getFluidState(cursor);
-                    if (AntarchyFluidChecks.isAntiwater(fluidState)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
+        return isTouching(entity, AntarchyFluidChecks::isAntiwater);
     }
 
     public static boolean isTouchingWaterlikeFluid(Entity entity) {
-        AABB box = entity.getBoundingBox().inflate(0.05D);
-        BlockPos min = BlockPos.containing(box.minX, box.minY, box.minZ);
-        BlockPos max = BlockPos.containing(box.maxX, box.maxY, box.maxZ);
+        return isTouching(entity, AntarchyFluidChecks::usesWaterLikePhysics);
+    }
+
+    public static Vec3 getAntiwaterFlow(Entity entity) {
+        return getAverageFlow(entity, AntarchyFluidChecks::isAntiwater);
+    }
+
+    public static Vec3 getWaterlikeFlow(Entity entity) {
+        return getAverageFlow(entity, AntarchyFluidChecks::usesWaterLikePhysics);
+    }
+
+    private static boolean isTouching(Entity entity, Predicate<FluidState> matches) {
+        AABB box = entity.getBoundingBox().deflate(0.001D);
+        Level level = entity.level();
         BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
-        for (int x = min.getX(); x <= max.getX(); x++) {
-            for (int y = min.getY(); y <= max.getY(); y++) {
-                for (int z = min.getZ(); z <= max.getZ(); z++) {
+        for (int x = Mth.floor(box.minX); x < Mth.ceil(box.maxX); x++) {
+            for (int y = Mth.floor(box.minY); y < Mth.ceil(box.maxY); y++) {
+                for (int z = Mth.floor(box.minZ); z < Mth.ceil(box.maxZ); z++) {
                     cursor.set(x, y, z);
-                    FluidState fluidState = entity.level().getFluidState(cursor);
-                    if (AntarchyFluidChecks.usesWaterLikePhysics(fluidState)) {
+                    FluidState fluidState = level.getFluidState(cursor);
+                    if (matches.test(fluidState) && y + fluidState.getHeight(level, cursor) >= box.minY) {
                         return true;
                     }
                 }
@@ -49,43 +49,31 @@ public final class CustomFluidPhysicsChecks {
         return false;
     }
 
-    public static Vec3 getAntiwaterFlow(Entity entity) {
-        return getAverageFlow(entity, true);
-    }
-
-    public static Vec3 getWaterlikeFlow(Entity entity) {
-        return getAverageFlow(entity, false);
-    }
-
-    private static Vec3 getAverageFlow(Entity entity, boolean antiwater) {
-        AABB box = entity.getBoundingBox().inflate(0.05D);
-        BlockPos min = BlockPos.containing(box.minX, box.minY, box.minZ);
-        BlockPos max = BlockPos.containing(box.maxX, box.maxY, box.maxZ);
+    private static Vec3 getAverageFlow(Entity entity, Predicate<FluidState> matches) {
+        AABB box = entity.getBoundingBox().deflate(0.001D);
+        Level level = entity.level();
         BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
         Vec3 totalFlow = Vec3.ZERO;
-        int matches = 0;
-        for (int x = min.getX(); x <= max.getX(); x++) {
-            for (int y = min.getY(); y <= max.getY(); y++) {
-                for (int z = min.getZ(); z <= max.getZ(); z++) {
+        int count = 0;
+        for (int x = Mth.floor(box.minX); x < Mth.ceil(box.maxX); x++) {
+            for (int y = Mth.floor(box.minY); y < Mth.ceil(box.maxY); y++) {
+                for (int z = Mth.floor(box.minZ); z < Mth.ceil(box.maxZ); z++) {
                     cursor.set(x, y, z);
-                    FluidState fluidState = entity.level().getFluidState(cursor);
-                    boolean matchesFluid = antiwater
-                            ? AntarchyFluidChecks.isAntiwater(fluidState)
-                            : AntarchyFluidChecks.usesWaterLikePhysics(fluidState);
-                    if (!matchesFluid) {
+                    FluidState fluidState = level.getFluidState(cursor);
+                    if (!matches.test(fluidState) || y + fluidState.getHeight(level, cursor) < box.minY) {
                         continue;
                     }
 
-                    totalFlow = totalFlow.add(fluidState.getFlow(entity.level(), cursor));
-                    matches++;
+                    totalFlow = totalFlow.add(fluidState.getFlow(level, cursor));
+                    count++;
                 }
             }
         }
 
-        if (matches == 0 || totalFlow.lengthSqr() < 1.0E-6D) {
+        if (count == 0 || totalFlow.lengthSqr() < 1.0E-6D) {
             return Vec3.ZERO;
         }
 
-        return totalFlow.scale(1.0D / matches);
+        return totalFlow.scale(1.0D / count);
     }
 }