Rewrite remaining Fabric platform code in Java

build.gradle.kts

@@ -69,8 +69,8 @@ subprojects {
 
     // Set Java version.
     extensions.configure<JavaPluginExtension> {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
 
     architectury {
@@ -166,13 +166,13 @@ subprojects {
     tasks {
         withType<JavaCompile> {
             options.encoding = "UTF-8"
-            options.release.set(17)
+            options.release.set(21)
         }
 
         withType<KotlinCompile> {
             // Set the Kotlin JVM target to match the Java version
             // for all Kotlin compilation tasks.
-            kotlinOptions.jvmTarget = "17"
+            kotlinOptions.jvmTarget = "21"
 
             kotlinOptions.freeCompilerArgs = listOf(
                 // Compile lambdas to invokedynamic.

common/src/main/java/juuxel/adorn/item/FuelData.java

@@ -0,0 +1,44 @@
+package juuxel.adorn.item;
+
+import juuxel.adorn.block.AdornBlocks;
+import juuxel.adorn.lib.AdornTags;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemConvertible;
+import net.minecraft.item.ItemStack;
+import net.minecraft.registry.tag.TagKey;
+
+import java.util.Set;
+
+public sealed interface FuelData {
+    Set<FuelData> FUEL_DATA = Set.of(
+        // Wooden (300)
+        new ForTag(AdornTags.CHAIRS.item(), 300),
+        new ForTag(AdornTags.DRAWERS.item(), 300),
+        new ForTag(AdornTags.TABLES.item(), 300),
+        new ForTag(AdornTags.BENCHES.item(), 300),
+        new ForTag(AdornTags.WOODEN_POSTS.item(), 300),
+        new ForTag(AdornTags.WOODEN_PLATFORMS.item(), 300),
+        new ForTag(AdornTags.WOODEN_STEPS.item(), 300),
+        new ForTag(AdornTags.WOODEN_SHELVES.item(), 300),
+        new ForItem(AdornBlocks.INSTANCE.getCRATE(), 300),
+        // Woollen (150)
+        new ForTag(AdornTags.SOFAS.item(), 150)
+    );
+
+    int burnTime();
+    boolean matches(ItemStack stack);
+
+    record ForItem(ItemConvertible item, int burnTime) implements FuelData {
+        @Override
+        public boolean matches(ItemStack stack) {
+            return stack.isOf(item.asItem());
+        }
+    }
+
+    record ForTag(TagKey<Item> tag, int burnTime) implements FuelData {
+        @Override
+        public boolean matches(ItemStack stack) {
+            return stack.isIn(tag);
+        }
+    }
+}

common/src/main/kotlin/juuxel/adorn/block/AdornBlocks.kt

@@ -191,6 +191,7 @@ object AdornBlocks : RegistryHelper() {
         CopperPipeBlock(AbstractBlock.Settings.copy(OXIDIZED_COPPER_PIPE))
     }
 
+    @JvmStatic
     fun init() {
     }
 

common/src/main/kotlin/juuxel/adorn/block/variant/BlockVariantSets.kt

@@ -50,12 +50,14 @@ object BlockVariantSets : RegistryHelper() {
         variantSets += variantSet
     }
 
+    @JvmStatic
     fun get(kind: BlockKind): List<Registered<Block>> =
         blocksByKind[kind]
 
     fun get(kind: BlockKind, variant: BlockVariant): Registered<Block>? =
         blocksByKindVariant[kind to variant]
 
+    @JvmStatic
     fun register() {
         val woodVariants = variantSets.flatMap(BlockVariantSet::woodVariants)
         val stoneVariants = variantSets.flatMap(BlockVariantSet::stoneVariants)

common/src/main/kotlin/juuxel/adorn/client/gui/screen/AdornMenuScreens.kt

@@ -4,6 +4,7 @@ import juuxel.adorn.menu.AdornMenus
 import net.minecraft.client.gui.screen.ingame.MenuScreens
 
 object AdornMenuScreens {
+    @JvmStatic
     fun register() {
         MenuScreens.register(AdornMenus.DRAWER, ::DrawerScreen)
         MenuScreens.register(AdornMenus.KITCHEN_CUPBOARD, ::KitchenCupboardScreen)

common/src/main/kotlin/juuxel/adorn/client/gui/screen/BrewerScreen.kt

@@ -61,6 +61,7 @@ class BrewerScreen(menu: BrewerMenu, playerInventory: PlayerInventory, title: Te
         val TEXTURE = AdornCommon.id("textures/gui/brewer.png")
         const val FLUID_AREA_HEIGHT: Int = 59
 
+        @JvmStatic
         fun setFluidFromPacket(client: MinecraftClient, syncId: Int, fluid: FluidVolume) {
             val screen = client.currentScreen
             if (screen is MenuProvider<*>) {

common/src/main/kotlin/juuxel/adorn/config/ConfigManager.kt

@@ -81,6 +81,8 @@ abstract class ConfigManager {
     }
 
     companion object {
+        @JvmStatic
+        @get:JvmName("get")
         val INSTANCE: ConfigManager by lazy { loadService() }
         private val JANKSON = Jankson.builder()
             .registerSerializer(FluidUnit::class.java) { unit, _ -> JsonPrimitive(unit.id) }

common/src/main/kotlin/juuxel/adorn/item/AdornItems.kt

@@ -58,6 +58,7 @@ object AdornItems {
     val COPPER_NUGGET by ITEMS.register("copper_nugget") { ItemWithDescription(Item.Settings()) }
     val WATERING_CAN by ITEMS.register("watering_can") { WateringCanItem(Item.Settings()) }
 
+    @JvmStatic
     fun init() {
     }
 }

common/src/main/kotlin/juuxel/adorn/item/group/AdornItemGroups.kt

@@ -76,6 +76,7 @@ object AdornItemGroups {
             .build()
     }
 
+    @JvmStatic
     fun init() {
         if (ConfigManager.config().client.showItemsInStandardGroups) {
             addToVanillaItemGroups()

common/src/main/kotlin/juuxel/adorn/menu/AdornMenus.kt

@@ -16,6 +16,7 @@ object AdornMenus {
     val TRADING_STATION: MenuType<TradingStationMenu> by MENUS.register("trading_station") { MenuType(::TradingStationMenu, FeatureFlags.VANILLA_FEATURES) }
     val BREWER: MenuType<BrewerMenu> by MENUS.register("brewer") { MenuType(::BrewerMenu, FeatureFlags.VANILLA_FEATURES) }
 
+    @JvmStatic
     fun init() {
     }
 

fabric/src/main/java/juuxel/adorn/Adorn.java

@@ -0,0 +1,67 @@
+package juuxel.adorn;
+
+import juuxel.adorn.block.AdornBlockEntities;
+import juuxel.adorn.block.AdornBlocks;
+import juuxel.adorn.block.variant.BlockVariantSets;
+import juuxel.adorn.client.ClientEvents;
+import juuxel.adorn.client.gui.screen.AdornMenuScreens;
+import juuxel.adorn.compat.Compat;
+import juuxel.adorn.config.ConfigManager;
+import juuxel.adorn.criterion.AdornCriteria;
+import juuxel.adorn.entity.AdornEntities;
+import juuxel.adorn.item.AdornItems;
+import juuxel.adorn.item.group.AdornItemGroups;
+import juuxel.adorn.lib.AdornBlocksFabric;
+import juuxel.adorn.lib.AdornEntitiesFabric;
+import juuxel.adorn.lib.AdornGameRules;
+import juuxel.adorn.lib.AdornItemsFabric;
+import juuxel.adorn.lib.AdornNetworking;
+import juuxel.adorn.lib.AdornSounds;
+import juuxel.adorn.lib.AdornStats;
+import juuxel.adorn.lib.AdornTags;
+import juuxel.adorn.lib.SofaSleeping;
+import juuxel.adorn.loot.AdornLootConditionTypes;
+import juuxel.adorn.loot.AdornLootFunctionTypes;
+import juuxel.adorn.menu.AdornMenus;
+import juuxel.adorn.recipe.AdornRecipes;
+import juuxel.adorn.resources.AdornResources;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+public final class Adorn {
+    public static void init() {
+        ConfigManager.get().init();
+        AdornSounds.init();
+        AdornBlocks.init();
+        AdornBlocksFabric.init();
+        AdornBlockEntities.init();
+        AdornItems.init();
+        AdornItemsFabric.init();
+        AdornItemGroups.init();
+        AdornEntities.init();
+        AdornMenus.init();
+        AdornNetworking.init();
+        AdornTags.init();
+        AdornGameRules.init();
+        AdornStats.init();
+        SofaSleeping.init();
+        AdornCriteria.init();
+        AdornRecipes.init();
+        AdornLootConditionTypes.init();
+        AdornLootFunctionTypes.init();
+        Compat.init();
+        BlockVariantSets.register();
+        AdornBlocksFabric.afterRegister();
+        ConfigManager.get().finalize();
+    }
+
+    @Environment(EnvType.CLIENT)
+    public static void initClient() {
+        AdornBlocksFabric.initClient();
+        AdornEntitiesFabric.initClient();
+        AdornMenuScreens.register();
+        AdornNetworking.initClient();
+        AdornResources.initClient();
+        ClientEvents.init();
+    }
+}

fabric/src/main/java/juuxel/adorn/block/entity/BrewerBlockEntityFabric.java

@@ -0,0 +1,87 @@
+package juuxel.adorn.block.entity;
+
+import com.google.common.base.Predicates;
+import juuxel.adorn.fluid.FluidReference;
+import juuxel.adorn.util.FluidStorageReference;
+import net.fabricmc.fabric.api.transfer.v1.context.ContainerItemContext;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidConstants;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
+import net.fabricmc.fabric.api.transfer.v1.item.InventoryStorage;
+import net.fabricmc.fabric.api.transfer.v1.storage.StorageUtil;
+import net.fabricmc.fabric.api.transfer.v1.storage.base.SingleVariantStorage;
+import net.fabricmc.fabric.api.transfer.v1.transaction.Transaction;
+import net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext;
+import net.minecraft.block.BlockState;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.util.math.BlockPos;
+import org.jetbrains.annotations.Nullable;
+
+public final class BrewerBlockEntityFabric extends BrewerBlockEntity {
+    private static final String NBT_FLUID = "Fluid";
+    private static final String NBT_VOLUME = "Volume";
+
+    private final SingleVariantStorage<FluidVariant> fluidStorage = new SingleVariantStorage<FluidVariant>() {
+        @Override
+        protected long getCapacity(FluidVariant variant) {
+            return FLUID_CAPACITY_IN_BUCKETS * FluidConstants.BUCKET;
+        }
+
+        @Override
+        protected FluidVariant getBlankVariant() {
+            return FluidVariant.blank();
+        }
+
+        @Override
+        protected void onFinalCommit() {
+            markDirty();
+        }
+    };
+
+    private final FluidReference fluidReference = new FluidStorageReference(fluidStorage);
+
+    public BrewerBlockEntityFabric(BlockPos pos, BlockState state) {
+        super(pos, state);
+    }
+
+    public SingleVariantStorage<FluidVariant> getFluidStorage() {
+        return fluidStorage;
+    }
+
+    @Override
+    public FluidReference getFluidReference() {
+        return fluidReference;
+    }
+
+    @Override
+    protected boolean canExtractFluidContainer() {
+        try (var transaction = Transaction.openOuter()) {
+            return extractFluidContainer(transaction) == 0L;
+        }
+    }
+
+    @Override
+    protected void tryExtractFluidContainer() {
+        extractFluidContainer(null);
+    }
+
+    private long extractFluidContainer(@Nullable TransactionContext transaction) {
+        var fluidContainerSlot = InventoryStorage.of(this, null).getSlot(FLUID_CONTAINER_SLOT);
+        var itemStorage = FluidStorage.ITEM.find(getStack(FLUID_CONTAINER_SLOT), ContainerItemContext.ofSingleSlot(fluidContainerSlot));
+        return StorageUtil.move(itemStorage, fluidStorage, Predicates.alwaysTrue(), Long.MAX_VALUE, transaction);
+    }
+
+    @Override
+    protected void writeNbt(NbtCompound nbt) {
+        super.writeNbt(nbt);
+        nbt.put(NBT_FLUID, fluidStorage.variant.toNbt());
+        nbt.putLong(NBT_VOLUME, fluidStorage.amount);
+    }
+
+    @Override
+    public void readNbt(NbtCompound nbt) {
+        super.readNbt(nbt);
+        fluidStorage.variant = FluidVariant.fromNbt(nbt.getCompound(NBT_FLUID));
+        fluidStorage.amount = nbt.getLong(NBT_VOLUME);
+    }
+}