Update chemical stacks bringing them more in line with modern item and fluid stacks

Author: pupnewfster

src/api/java/mekanism/api/JsonConstants.java

@@ -3,7 +3,7 @@
 /**
  * Class for storing constants that are used in various JSON serializers we have, to reduce the chances of typos
  */
-public class JsonConstants {
+public class JsonConstants {//TODO - 1.20.5: Combine with NBTConstants into a singular SerializationConstants, and then make all the values snake case
 
     private JsonConstants() {
     }

src/api/java/mekanism/api/SerializerHelper.java

@@ -14,20 +14,10 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import mekanism.api.annotations.NothingNullByDefault;
-import mekanism.api.chemical.ChemicalStack;
-import mekanism.api.chemical.ChemicalType;
-import mekanism.api.chemical.ChemicalUtils;
 import net.minecraft.Util;
-import net.minecraft.core.Holder;
-import net.minecraft.core.component.DataComponentPatch;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.util.ExtraCodecs;
-import net.minecraft.world.level.material.Fluid;
-import net.minecraft.world.level.material.Fluids;
-import net.neoforged.neoforge.common.crafting.CraftingHelper;
-import net.neoforged.neoforge.fluids.FluidStack;
 import org.jetbrains.annotations.NotNull;
 
+//TODO - 1.20.5: Update the wiki docs to fix the syntax
 @NothingNullByDefault
 public class SerializerHelper {
 
@@ -50,32 +40,6 @@ private SerializerHelper() {
         return Codec.LONG.flatXmap(checker, checker);
     });
 
-    /**
-     * Fluid Codec which makes extra sure we don't end up with an empty/invalid fluid
-     */
-    private static final Codec<Holder<Fluid>> NON_EMPTY_FLUID_CODEC = BuiltInRegistries.FLUID.holderByNameCodec().validate(holder ->
-          holder.is(Fluids.EMPTY.builtInRegistryHolder()) ? DataResult.error(() -> "Fluid must not be minecraft:empty") : DataResult.success(holder));
-
-    /**
-     * Fluidstack codec to maintain compatibility with our old json
-     */
-    //TODO - 1.20.5: Re-evaluate this and probably switch to just using FluidStack#CODEC even if it changes the key from fluid to id
-    public static final Codec<FluidStack> FLUIDSTACK_CODEC = RecordCodecBuilder.create(instance -> instance.group(
-          NON_EMPTY_FLUID_CODEC.fieldOf(JsonConstants.FLUID).forGetter(FluidStack::getFluidHolder),
-          ExtraCodecs.POSITIVE_INT.fieldOf(JsonConstants.AMOUNT).forGetter(FluidStack::getAmount),
-          DataComponentPatch.CODEC.optionalFieldOf("components", DataComponentPatch.EMPTY).forGetter(stack -> stack.getComponents().asPatch())
-    ).apply(instance, FluidStack::new));
-
-    /**
-     * Codec to get any kind of chemical stack, based on a "chemicalType" field. See also {@link ChemicalType}
-     */
-    public static final Codec<ChemicalStack<?>> BOXED_CHEMICALSTACK_CODEC = ChemicalType.CODEC.dispatch(JsonConstants.CHEMICAL_TYPE, ChemicalType::getTypeFor, type -> switch (type) {
-        case GAS -> ChemicalUtils.GAS_STACK_CODEC;
-        case INFUSION -> ChemicalUtils.INFUSION_STACK_CODEC;
-        case PIGMENT -> ChemicalUtils.PIGMENT_STACK_CODEC;
-        case SLURRY -> ChemicalUtils.SLURRY_STACK_CODEC;
-    });
-
     /**
      * Generate a RecordCodecBuilder which is required only if the 'primary' is present. If this field is present, it will be returned regardless. Does not eat errors
      *

src/api/java/mekanism/api/chemical/BasicChemicalTank.java

@@ -91,7 +91,7 @@ private void setStack(STACK stack, boolean validateStack) {
 
     @Override
     public STACK insert(@NotNull STACK stack, Action action, AutomationType automationType) {
-        if (stack.isEmpty() || !isValid(stack) || !canInsert.test(stack.getType(), automationType)) {
+        if (stack.isEmpty() || !isValid(stack) || !canInsert.test(stack.getChemical(), automationType)) {
             //"Fail quick" if the given stack is empty, or we can never insert the chemical or currently are unable to insert it
             return stack;
         }
@@ -124,7 +124,7 @@ public STACK insert(@NotNull STACK stack, Action action, AutomationType automati
 
     @Override
     public STACK extract(long amount, Action action, AutomationType automationType) {
-        if (isEmpty() || amount < 1 || !canExtract.test(stored.getType(), automationType)) {
+        if (isEmpty() || amount < 1 || !canExtract.test(stored.getChemical(), automationType)) {
             //"Fail quick" if we don't can never extract from this tank, have a chemical stored, or the amount being requested is less than one
             return getEmptyStack();
         }
@@ -145,7 +145,7 @@ public STACK extract(long amount, Action action, AutomationType automationType)
 
     @Override
     public boolean isValid(STACK stack) {
-        return getAttributeValidator().process(stack) && validator.test(stack.getType());
+        return getAttributeValidator().process(stack) && validator.test(stack.getChemical());
     }
 
     /**
@@ -222,7 +222,7 @@ public long getStored() {
      */
     @Override
     public CHEMICAL getType() {
-        return stored.getType();
+        return stored.getChemical();
     }
 
     /**
@@ -242,7 +242,7 @@ public boolean isTypeEqual(STACK other) {
      */
     @Override
     public boolean isTypeEqual(CHEMICAL other) {
-        return stored.isTypeEqual(other);
+        return stored.is(other);
     }
 
     @Override
@@ -271,7 +271,7 @@ public ChemicalAttributeValidator getAttributeValidator() {
     public CompoundTag serializeNBT(HolderLookup.Provider provider) {
         CompoundTag nbt = new CompoundTag();
         if (!isEmpty()) {
-            nbt.put(NBTConstants.STORED, stored.write(new CompoundTag()));
+            nbt.put(NBTConstants.STORED, stored.save(provider));
         }
         return nbt;
     }
@@ -283,7 +283,7 @@ public CompoundTag serializeNBT(HolderLookup.Provider provider) {
      */
     @Override
     public boolean isCompatible(IChemicalTank<CHEMICAL, STACK> other) {
-        return getClass() == other.getClass() && stored.isStackIdentical(((BasicChemicalTank<CHEMICAL, STACK>) other).stored);
+        return getClass() == other.getClass() && stored.equals(other.getStack());
     }
 
     @Override

src/api/java/mekanism/api/chemical/Chemical.java

@@ -1,18 +1,26 @@
 package mekanism.api.chemical;
 
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import io.netty.handler.codec.DecoderException;
+import io.netty.handler.codec.EncoderException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Stream;
+import mekanism.api.JsonConstants;
+import mekanism.api.MekanismAPI;
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.chemical.attribute.ChemicalAttribute;
 import mekanism.api.chemical.attribute.IChemicalAttributeContainer;
 import mekanism.api.chemical.gas.attribute.GasAttributes.Radiation;
 import mekanism.api.providers.IChemicalProvider;
 import mekanism.api.text.TextComponentUtil;
 import net.minecraft.core.Registry;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.chat.Component;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.tags.TagKey;
 import org.jetbrains.annotations.NotNull;
@@ -21,6 +29,67 @@
 @NothingNullByDefault
 public abstract class Chemical<CHEMICAL extends Chemical<CHEMICAL>> implements IChemicalProvider<CHEMICAL>, IChemicalAttributeContainer<CHEMICAL> {
 
+    /**
+     * Codec to get any kind of chemical, based on a "chemicalType" field.
+     *
+     * @see ChemicalType
+     * @see mekanism.api.chemical.merged.BoxedChemical
+     * @since 10.6.0
+     */
+    public static final Codec<Chemical<?>> BOXED_OPTIONAL_CODEC = ChemicalType.CODEC.dispatch(JsonConstants.CHEMICAL_TYPE, ChemicalType::getTypeFor, type -> switch (type) {
+        case GAS -> MekanismAPI.GAS_REGISTRY.byNameCodec().fieldOf(JsonConstants.GAS);
+        case INFUSION -> MekanismAPI.INFUSE_TYPE_REGISTRY.byNameCodec().fieldOf(JsonConstants.INFUSE_TYPE);
+        case PIGMENT -> MekanismAPI.PIGMENT_REGISTRY.byNameCodec().fieldOf(JsonConstants.PIGMENT);
+        case SLURRY -> MekanismAPI.SLURRY_REGISTRY.byNameCodec().fieldOf(JsonConstants.SLURRY);
+    });
+    /**
+     * Codec to get any kind of chemical (that does not accept empty types), based on a "chemicalType" field.
+     *
+     * @see ChemicalType
+     * @see mekanism.api.chemical.merged.BoxedChemical
+     * @since 10.6.0
+     */
+    public static final Codec<Chemical<?>> BOXED_CODEC = BOXED_OPTIONAL_CODEC.validate(chemical -> chemical.isEmptyType() ? DataResult.error(() -> "Chemical must not be mekanism:empty") : DataResult.success(chemical));
+    /**
+     * StreamCodec to get any kind of chemical stack, based on a "chemicalType" field.
+     *
+     * @see ChemicalType
+     * @see mekanism.api.chemical.merged.BoxedChemical
+     * @since 10.6.0
+     */
+    public static final StreamCodec<RegistryFriendlyByteBuf, Chemical<?>> BOXED_OPTIONAL_STREAM_CODEC = ChemicalType.STREAM_CODEC.<RegistryFriendlyByteBuf>cast()
+          .dispatch(ChemicalType::getTypeFor, type -> switch (type) {
+              case GAS -> ByteBufCodecs.registry(MekanismAPI.GAS_REGISTRY_NAME);
+              case INFUSION -> ByteBufCodecs.registry(MekanismAPI.INFUSE_TYPE_REGISTRY_NAME);
+              case PIGMENT -> ByteBufCodecs.registry(MekanismAPI.PIGMENT_REGISTRY_NAME);
+              case SLURRY -> ByteBufCodecs.registry(MekanismAPI.SLURRY_REGISTRY_NAME);
+          });
+    /**
+     * StreamCodec to get any kind of chemical (that does not accept the empty type), based on a "chemicalType" field.
+     *
+     * @see ChemicalType
+     * @see mekanism.api.chemical.merged.BoxedChemical
+     * @since 10.6.0
+     */
+    public static final StreamCodec<RegistryFriendlyByteBuf, Chemical<?>> BOXED_STREAM_CODEC = new StreamCodec<>() {
+        @Override
+        public Chemical<?> decode(RegistryFriendlyByteBuf buf) {
+            Chemical<?> chemical = BOXED_OPTIONAL_STREAM_CODEC.decode(buf);
+            if (chemical.isEmptyType()) {
+                throw new DecoderException("Empty Chemicals are not allowed");
+            }
+            return chemical;
+        }
+
+        @Override
+        public void encode(RegistryFriendlyByteBuf buf, Chemical<?> chemical) {
+            if (chemical.isEmptyType()) {
+                throw new EncoderException("Empty Chemicals are not allowed");
+            }
+            BOXED_OPTIONAL_STREAM_CODEC.encode(buf, chemical);
+        }
+    };
+
     private final Map<Class<? extends ChemicalAttribute>, ChemicalAttribute> attributeMap;
 
     private final ResourceLocation iconLocation;
@@ -116,15 +185,6 @@ public Collection<Class<? extends ChemicalAttribute>> getAttributeTypes() {
         return attributeMap.keySet();
     }
 
-    /**
-     * Writes this Chemical to a defined tag compound.
-     *
-     * @param nbtTags - tag compound to write this Chemical to
-     *
-     * @return the tag compound this Chemical was written to
-     */
-    public abstract CompoundTag write(CompoundTag nbtTags);
-
     /**
      * Gets the default translation key for this chemical.
      */