API preparations based on feedback

Author: FalsePattern

build.gradle.kts

@@ -33,16 +33,10 @@ minecraft_fp {
 repositories {
     exclusive(mavenpattern(), "com.falsepattern")
     cursemavenEX()
-    modrinthEX()
 }
 
 dependencies {
     implementationSplit("com.falsepattern:falsepatternlib-mc1.7.10:1.5.9")
     implementationSplit("com.falsepattern:chunkapi-mc1.7.10:0.6.1")
-    compileOnly(deobfCurse("buildcraft-61811:4055732"))
-    devOnlyNonPublishable(deobfCurse("thermal-expansion-69163:2388758"))
-    devOnlyNonPublishable(deobfCurse("thermal-foundation-222880:2388752"))
     compileOnly(deobfCurse("cofhcore-69162:2388750"))
-
-    runtimeOnlyNonPublishable(deobfModrinth("baubles-expanded:2.1.4"))
 }

…d/internal/mixin/hook/FLBlockAccess.java …/mega/fluidlogged/api/FLBlockAccess.javasrc/main/java/mega/fluidlogged/internal/mixin/hook/FLBlockAccess.java renamed to src/main/java/mega/fluidlogged/api/FLBlockAccess.java src/main/java/mega/fluidlogged/internal/mixin/hook/FLBlockAccess.java renamed to src/main/java/mega/fluidlogged/api/FLBlockAccess.java

@@ -20,14 +20,31 @@
  * along with FluidLogged.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package mega.fluidlogged.internal.mixin.hook;
+package mega.fluidlogged.api;
 
 import lombok.val;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
+import net.minecraft.world.ChunkCache;
+import net.minecraft.world.World;
 import net.minecraftforge.fluids.Fluid;
 
+/**
+ * Implemented on {@link net.minecraft.world.World} and {@link net.minecraft.world.ChunkCache} via mixins.
+ */
+@ApiStatus.NonExtendable
 public interface FLBlockAccess {
+    /**
+     * Retrieves the fluid from a fluidlogged block. Null if not fluidlogged. Note that this returns null if the block itself is a fluid block!
+     */
+    @Nullable Fluid fl$getFluid(int x, int y, int z);
+
+    /**
+     * Makes a block fluidlogged with the given fluid. Does NOT verify whether the block can be fluidlogged!
+     * Pass in null to clear.
+     */
+    void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid);
     default boolean fl$isFluidLogged(int x, int y, int z, @Nullable Fluid fluid) {
         val fluidInChunk = fl$getFluid(x, y, z);
         if (fluidInChunk == null)
@@ -36,6 +53,12 @@ public interface FLBlockAccess {
             return true;
         return fluid.equals(fluidInChunk);
     }
-    void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid);
-    @Nullable Fluid fl$getFluid(int x, int y, int z);
+
+    static FLBlockAccess of(World world) {
+        return (FLBlockAccess) world;
+    }
+
+    static FLBlockAccess of(ChunkCache cache) {
+        return (FLBlockAccess) cache;
+    }
 }

src/main/java/mega/fluidlogged/api/FLChunk.java

@@ -0,0 +1,50 @@
+/*
+ * This file is part of FluidLogged.
+ *
+ * Copyright (C) 2025 The MEGA Team, FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice, this permission notice and the word "MEGA"
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * FluidLogged is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, only version 3 of the License.
+ *
+ * FluidLogged is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with FluidLogged.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package mega.fluidlogged.api;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.world.chunk.Chunk;
+import net.minecraftforge.fluids.Fluid;
+
+/**
+ * Implemented on {@link net.minecraft.world.chunk.Chunk} via a mixin.
+ */
+@ApiStatus.NonExtendable
+public interface FLChunk {
+    /**
+     * Retrieves the fluid from a fluidlogged block. Null if not fluidlogged. Note that this returns null if the block itself is a fluid block!
+     */
+    @Nullable Fluid fl$getFluid(int x, int y, int z);
+
+    /**
+     * Makes a block fluidlogged with the given fluid. Does NOT verify whether the block can be fluidlogged!
+     * Pass in null to clear.
+     */
+    void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid);
+
+    static FLChunk of(Chunk chunk) {
+        return (FLChunk) chunk;
+    }
+}

src/main/java/mega/fluidlogged/api/bucket/BucketDriver.java

@@ -23,29 +23,72 @@
 package mega.fluidlogged.api.bucket;
 
 import mega.fluidlogged.internal.bucket.FLBucketDriver;
+import mega.fluidlogged.internal.mixin.hook.FLWorld;
+import mega.fluidlogged.internal.world.FLWorldDriver;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.Fluid;
 
+/**
+ * This is used for implementing custom buckets.
+ * <p>
+ * If a mod's buckets don't work, make sure it fires a FillBucketEvent in its {@link net.minecraft.item.Item#onItemRightClick}. If it uses some sort of custom "bucket" item not
+ * registered in the forge registry, then implement the respective subclasses of this class.
+ * <p>
+ * See {@link mega.fluidlogged.internal.mixin.mixins.common.compat.cofh.ItemBucketMixin} for how to implement an event hook like that.
+ */
 public interface BucketDriver {
+    /**
+     * Used to check the "fullness" of a bucket item
+     */
     @ApiStatus.OverrideOnly
     interface Query extends BucketDriver {
+        /**
+         *
+         * @param bucket A possible bucket item
+         * @return Whether the bucket is filled or empty.
+         * @implSpec Return null if this driver cannot handle the given item.
+         */
         @Nullable BucketState queryState(@NotNull ItemStack bucket);
     }
 
+    /**
+     * Used to fill empty buckets with fluids
+     */
     @ApiStatus.OverrideOnly
     interface Fill extends BucketDriver {
+        /**
+         * Fills the given empty bucket with a fluid
+         * @param fluid The fluid to fill the bucket with
+         * @param bucket The bucket to fill
+         * @return The filled bucket
+         * @implSpec Return null if this driver cannot fill the given bucket.
+         */
         @Nullable ItemStack fillBucket(@NotNull Fluid fluid, @NotNull ItemStack bucket);
     }
 
+    /**
+     * Used to empty out buckets into a fluid + empty bucket pair
+     */
     @ApiStatus.OverrideOnly
     interface Empty extends BucketDriver {
+        /**
+         * Empties a fluid out of the given bucket
+         * @param bucket The bucket to empty out
+         * @return The empty bucket and its fluid
+         * @implSpec Return null if this driver cannot empty the given bucket.
+         */
         @Nullable BucketEmptyResults emptyBucket(@NotNull ItemStack bucket);
     }
 
+    /**
+     * Register the provided driver.
+     * @implSpec The driver must implement at least one of {@link Query}, {@link Fill}, or {@link Empty}, or this method throws an exception.
+     */
     static void register(@NotNull BucketDriver driver) {
         FLBucketDriver.INSTANCE.registerDriver(driver);
     }

…dlogged/internal/mixin/hook/FLChunk.java …a/mega/fluidlogged/api/package-info.javasrc/main/java/mega/fluidlogged/internal/mixin/hook/FLChunk.java renamed to src/main/java/mega/fluidlogged/api/package-info.java src/main/java/mega/fluidlogged/internal/mixin/hook/FLChunk.java renamed to src/main/java/mega/fluidlogged/api/package-info.java

@@ -19,14 +19,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with FluidLogged.  If not, see <https://www.gnu.org/licenses/>.
  */
+@ApiStatus.Experimental
+package mega.fluidlogged.api;
 
-package mega.fluidlogged.internal.mixin.hook;
-
-import org.jetbrains.annotations.Nullable;
-
-import net.minecraftforge.fluids.Fluid;
-
-public interface FLChunk {
-    @Nullable Fluid fl$getFluid(int x, int y, int z);
-    void fl$setFluid(int x, int y, int z, @Nullable Fluid fluid);
-}
+import org.jetbrains.annotations.ApiStatus;

src/main/java/mega/fluidlogged/api/world/WorldDriver.java

@@ -23,15 +23,28 @@
 package mega.fluidlogged.api.world;
 
 import mega.fluidlogged.internal.world.FLWorldDriver;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import net.minecraft.block.Block;
 import net.minecraftforge.fluids.Fluid;
 
 public interface WorldDriver {
+    @ApiStatus.OverrideOnly
     boolean canBeFluidLogged(@NotNull Block block, int meta, @NotNull Fluid fluid);
 
     static void register(@NotNull WorldDriver driver) {
         FLWorldDriver.INSTANCE.registerDriver(driver);
     }
+
+    /**
+     * Check whether a given block can be fluidlogged by a fluid.
+     * @param block The block to check
+     * @param meta The checked block's metadata
+     * @param fluid The fluid that is trying to fluidlog the block
+     * @return true to allow fluidlogging
+     */
+    static boolean getCanBeFluidLogged(@NotNull Block block, int meta, @NotNull Fluid fluid) {
+        return FLWorldDriver.INSTANCE.canBeFluidLogged(block, meta, fluid);
+    }
 }

src/main/java/mega/fluidlogged/internal/FLManager.java

@@ -28,7 +28,7 @@
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import mega.fluidlogged.Tags;
-import mega.fluidlogged.internal.mixin.hook.FLChunk;
+import mega.fluidlogged.api.FLChunk;
 import mega.fluidlogged.internal.mixin.hook.FLPacket;
 import mega.fluidlogged.internal.mixin.hook.FLSubChunk;
 import mega.fluidlogged.internal.mixin.hook.FLWorld;

src/main/java/mega/fluidlogged/internal/FLUtil.java

@@ -23,7 +23,7 @@
 package mega.fluidlogged.internal;
 
 import lombok.val;
-import mega.fluidlogged.internal.mixin.hook.FLBlockAccess;
+import mega.fluidlogged.api.FLBlockAccess;
 import mega.fluidlogged.internal.mixin.hook.FLWorld;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -38,6 +38,7 @@
 import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.entity.player.FillBucketEvent;
 import net.minecraftforge.fluids.BlockFluidClassic;
@@ -137,8 +138,8 @@ public static void simulate(@NotNull World world, int x, int y, int z, @NotNull
         return null;
     }
 
-    public static @Nullable Fluid fromWorldBlock(@NotNull World world, int x, int y, int z, @NotNull Block block) {
-        val meta = world.getBlockMetadata(x, y, z);
+    public static @Nullable Fluid fromChunkBlock(@NotNull Chunk chunk, int x, int y, int z, @NotNull Block block) {
+        val meta = chunk.getBlockMetadata(x, y, z);
         if (meta != 0) {
             return null;
         }

src/main/java/mega/fluidlogged/internal/bucket/FLBucketDriver.java

@@ -27,7 +27,7 @@
 import mega.fluidlogged.api.bucket.BucketEmptyResults;
 import mega.fluidlogged.api.bucket.BucketState;
 import mega.fluidlogged.internal.FLUtil;
-import mega.fluidlogged.internal.mixin.hook.FLBlockAccess;
+import mega.fluidlogged.api.FLBlockAccess;
 import mega.fluidlogged.internal.world.FLWorldDriver;
 
 import net.minecraft.item.ItemStack;

src/main/java/mega/fluidlogged/internal/core/ASMHooks.java

@@ -23,7 +23,7 @@
 package mega.fluidlogged.internal.core;
 
 import lombok.val;
-import mega.fluidlogged.internal.mixin.hook.FLBlockAccess;
+import mega.fluidlogged.api.FLBlockAccess;
 
 import net.minecraft.client.renderer.RenderBlocks;