Make tests run again

src/generated/resources/data/moderndynamics/recipes/cable/ev_from_mi.json

@@ -1,13 +1,13 @@
 {
+  "result": {
+    "count": 4,
+    "item": "moderndynamics:ev_cable"
+  },
   "ingredients": [
     {
       "item": "modern_industrialization:annealed_copper_cable"
     }
   ],
-  "result": {
-    "item": "moderndynamics:ev_cable",
-    "count": 4
-  },
   "type": "minecraft:crafting_shapeless",
   "neoforge:conditions": [
     {

src/generated/resources/data/moderndynamics/recipes/cable/ev_to_mi.json

@@ -1,17 +1,17 @@
 {
   "type": "minecraft:crafting_shaped",
-  "result": {
-    "item": "modern_industrialization:annealed_copper_cable"
-  },
+  "pattern": [
+    "cc",
+    "cc"
+  ],
   "key": {
     "c": {
       "item": "moderndynamics:ev_cable"
     }
   },
-  "pattern": [
-    "cc",
-    "cc"
-  ],
+  "result": {
+    "item": "modern_industrialization:annealed_copper_cable"
+  },
   "neoforge:conditions": [
     {
       "modid": "modern_industrialization",

src/generated/resources/data/moderndynamics/recipes/cable/hv_from_mi.json

@@ -1,13 +1,13 @@
 {
+  "result": {
+    "count": 4,
+    "item": "moderndynamics:hv_cable"
+  },
   "ingredients": [
     {
       "item": "modern_industrialization:aluminum_cable"
     }
   ],
-  "result": {
-    "item": "moderndynamics:hv_cable",
-    "count": 4
-  },
   "type": "minecraft:crafting_shapeless",
   "neoforge:conditions": [
     {

src/generated/resources/data/moderndynamics/recipes/cable/hv_to_mi.json

@@ -1,17 +1,17 @@
 {
   "type": "minecraft:crafting_shaped",
-  "result": {
-    "item": "modern_industrialization:aluminum_cable"
-  },
+  "pattern": [
+    "cc",
+    "cc"
+  ],
   "key": {
     "c": {
       "item": "moderndynamics:hv_cable"
     }
   },
-  "pattern": [
-    "cc",
-    "cc"
-  ],
+  "result": {
+    "item": "modern_industrialization:aluminum_cable"
+  },
   "neoforge:conditions": [
     {
       "modid": "modern_industrialization",

src/generated/resources/data/moderndynamics/recipes/cable/lv_from_mi.json

@@ -1,13 +1,13 @@
 {
+  "result": {
+    "count": 4,
+    "item": "moderndynamics:lv_cable"
+  },
   "ingredients": [
     {
       "item": "modern_industrialization:tin_cable"
     }
   ],
-  "result": {
-    "item": "moderndynamics:lv_cable",
-    "count": 4
-  },
   "type": "minecraft:crafting_shapeless",
   "neoforge:conditions": [
     {

src/generated/resources/data/moderndynamics/recipes/cable/lv_to_mi.json

@@ -1,17 +1,17 @@
 {
   "type": "minecraft:crafting_shaped",
-  "result": {
-    "item": "modern_industrialization:tin_cable"
-  },
+  "pattern": [
+    "cc",
+    "cc"
+  ],
   "key": {
     "c": {
       "item": "moderndynamics:lv_cable"
     }
   },
-  "pattern": [
-    "cc",
-    "cc"
-  ],
+  "result": {
+    "item": "modern_industrialization:tin_cable"
+  },
   "neoforge:conditions": [
     {
       "modid": "modern_industrialization",

src/generated/resources/data/moderndynamics/recipes/cable/mv_from_mi.json

@@ -1,13 +1,13 @@
 {
+  "result": {
+    "count": 4,
+    "item": "moderndynamics:mv_cable"
+  },
   "ingredients": [
     {
       "item": "modern_industrialization:electrum_cable"
     }
   ],
-  "result": {
-    "item": "moderndynamics:mv_cable",
-    "count": 4
-  },
   "type": "minecraft:crafting_shapeless",
   "neoforge:conditions": [
     {

src/generated/resources/data/moderndynamics/recipes/cable/mv_to_mi.json

@@ -1,17 +1,17 @@
 {
   "type": "minecraft:crafting_shaped",
-  "result": {
-    "item": "modern_industrialization:electrum_cable"
-  },
+  "pattern": [
+    "cc",
+    "cc"
+  ],
   "key": {
     "c": {
       "item": "moderndynamics:mv_cable"
     }
   },
-  "pattern": [
-    "cc",
-    "cc"
-  ],
+  "result": {
+    "item": "modern_industrialization:electrum_cable"
+  },
   "neoforge:conditions": [
     {
       "modid": "modern_industrialization",

src/generated/resources/data/moderndynamics/recipes/cable/superconductor_from_mi.json

@@ -1,13 +1,13 @@
 {
+  "result": {
+    "count": 4,
+    "item": "moderndynamics:superconductor_cable"
+  },
   "ingredients": [
     {
       "item": "modern_industrialization:superconductor_cable"
     }
   ],
-  "result": {
-    "item": "moderndynamics:superconductor_cable",
-    "count": 4
-  },
   "type": "minecraft:crafting_shapeless",
   "neoforge:conditions": [
     {

src/generated/resources/data/moderndynamics/recipes/cable/superconductor_to_mi.json

@@ -1,17 +1,17 @@
 {
   "type": "minecraft:crafting_shaped",
-  "result": {
-    "item": "modern_industrialization:superconductor_cable"
-  },
+  "pattern": [
+    "cc",
+    "cc"
+  ],
   "key": {
     "c": {
       "item": "moderndynamics:superconductor_cable"
     }
   },
-  "pattern": [
-    "cc",
-    "cc"
-  ],
+  "result": {
+    "item": "modern_industrialization:superconductor_cable"
+  },
   "neoforge:conditions": [
     {
       "modid": "modern_industrialization",

src/main/java/dev/technici4n/moderndynamics/util/FluidRenderUtil.java

@@ -10,9 +10,16 @@ private FluidRenderUtil() {
     }
 
     public static TextureAtlasSprite getStillSprite(FluidVariant variant) {
+        if (variant.isBlank()) {
+            return null;
+        }
+
         var renderProps = IClientFluidTypeExtensions.of(variant.getFluid());
         var stack = variant.toStack(1);
         var texture = renderProps.getStillTexture(stack);
+        if (texture == null) {
+            return null;
+        }
 
         var atlas = Minecraft.getInstance().getTextureAtlas(InventoryMenu.BLOCK_ATLAS);
         return atlas.apply(texture);

src/main/java/dev/technici4n/moderndynamics/util/FluidVariant.java

@@ -3,20 +3,35 @@
 import net.minecraft.ChatFormatting;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.material.FlowingFluid;
 import net.minecraft.world.level.material.Fluid;
 import net.minecraft.world.level.material.Fluids;
 import net.neoforged.fml.ModList;
 import net.neoforged.neoforge.fluids.FluidStack;
 import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
-public record FluidVariant(Fluid fluid, @Nullable CompoundTag nbt) {
+public final class FluidVariant {
+    private static final Logger LOG = LoggerFactory.getLogger(FluidVariant.class);
+
+    private final Fluid fluid;
+    private final @Nullable CompoundTag nbt;
+    private final int hashCode;
+
+    private FluidVariant(Fluid fluid, @Nullable CompoundTag nbt) {
+        this.fluid = fluid;
+        this.nbt = nbt != null ? nbt.copy() : null; // defensive copy
+        this.hashCode = Objects.hash(fluid, nbt);
+    }
+
     public FluidVariant(Fluid fluid) {
         this(fluid, null);
     }
@@ -25,28 +40,79 @@ public static FluidVariant blank() {
         return new FluidVariant(Fluids.EMPTY, null);
     }
 
-    public static FluidVariant fromNbt(CompoundTag filterTag) {
-        throw new UnsupportedOperationException();
-    }
-
-    public static FluidVariant fromPacket(FriendlyByteBuf buf) {
-        throw new UnsupportedOperationException();
-    }
-
     public static FluidVariant of(Fluid fluid, @Nullable CompoundTag nbt) {
-        return new FluidVariant(fluid, nbt);
+        Objects.requireNonNull(fluid, "Fluid may not be null.");
+
+        if (!fluid.isSource(fluid.defaultFluidState()) && fluid != Fluids.EMPTY) {
+            // Note: the empty fluid is not still, that's why we check for it specifically.
+
+            if (fluid instanceof FlowingFluid flowable) {
+                // Normalize FlowableFluids to their still variants.
+                fluid = flowable.getSource();
+            } else {
+                // If not a FlowableFluid, we don't know how to convert -> crash.
+                ResourceLocation id = BuiltInRegistries.FLUID.getKey(fluid);
+                throw new IllegalArgumentException("Cannot convert flowing fluid %s (%s) into a still fluid.".formatted(id, fluid));
+            }
+        }
+
+        if (nbt == null || fluid == Fluids.EMPTY) {
+            // Use the cached variant inside the fluid
+            return new FluidVariant(fluid, null); // TODO noTagCache.computeIfAbsent(fluid, f -> new FluidVariant(fluid, null));
+        } else {
+            // TODO explore caching fluid variants for non null tags.
+            return new FluidVariant(fluid, nbt);
+        }
     }
 
     public static FluidVariant of(Fluid fluid) {
         return of(fluid, null);
     }
 
     public static FluidVariant of(FluidStack resource) {
-        return new FluidVariant(resource.getFluid(), resource.getTag() != null ? resource.getTag().copy() : null);
+        return of(resource.getFluid(), resource.getTag());
+    }
+
+    public CompoundTag toNbt() {
+        CompoundTag result = new CompoundTag();
+        result.putString("fluid", BuiltInRegistries.FLUID.getKey(fluid).toString());
+
+        if (nbt != null) {
+            result.put("tag", nbt.copy());
+        }
+
+        return result;
+    }
+
+    public static FluidVariant fromNbt(CompoundTag compound) {
+        try {
+            Fluid fluid = BuiltInRegistries.FLUID.get(new ResourceLocation(compound.getString("fluid")));
+            CompoundTag nbt = compound.contains("tag") ? compound.getCompound("tag") : null;
+            return of(fluid, nbt);
+        } catch (RuntimeException runtimeException) {
+            LOG.debug("Tried to load an invalid FluidVariant from NBT: {}", compound, runtimeException);
+            return FluidVariant.blank();
+        }
     }
 
-    public Tag toNbt() {
-        throw new UnsupportedOperationException();
+    public void toPacket(FriendlyByteBuf buf) {
+        if (isBlank()) {
+            buf.writeBoolean(false);
+        } else {
+            buf.writeBoolean(true);
+            buf.writeVarInt(BuiltInRegistries.FLUID.getId(fluid));
+            buf.writeNbt(nbt);
+        }
+    }
+
+    public static FluidVariant fromPacket(FriendlyByteBuf buf) {
+        if (!buf.readBoolean()) {
+            return FluidVariant.blank();
+        } else {
+            Fluid fluid = BuiltInRegistries.FLUID.byId(buf.readVarInt());
+            CompoundTag nbt = buf.readNbt();
+            return of(fluid, nbt);
+        }
     }
 
     public boolean isBlank() {
@@ -92,4 +158,35 @@ private static String getModName(String modId) {
     public @Nullable CompoundTag getNbt() {
         return nbt != null ? nbt.copy() : null;
     }
+
+    public Fluid fluid() {
+        return fluid;
+    }
+
+    public @Nullable CompoundTag nbt() {
+        return nbt;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (FluidVariant) obj;
+        return hashCode == that.hashCode
+               && Objects.equals(this.fluid, that.fluid)
+               && Objects.equals(this.nbt, that.nbt);
+    }
+
+    @Override
+    public int hashCode() {
+        return hashCode;
+    }
+
+    @Override
+    public String toString() {
+        return "FluidVariant[" +
+               "fluid=" + fluid + ", " +
+               "nbt=" + nbt + ']';
+    }
+
 }