Switch energy system to using long primitives instead of a custom object class (#8159)

---------

Co-authored-by: Sara Freimer <sara@freimer.com>

Author: thiakil

src/api/java/mekanism/api/MekanismAPI.java

@@ -34,7 +34,7 @@ private MekanismAPI() {
     /**
      * The version of the api classes - may not always match the mod's version
      */
-    public static final String API_VERSION = "10.6.4";
+    public static final String API_VERSION = "10.6.6";
     /**
      * Mekanism's Mod ID
      */

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

@@ -8,6 +8,7 @@
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.MapDecoder.Implementation;
 import com.mojang.serialization.MapLike;
+import com.mojang.serialization.codecs.PrimitiveCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import java.util.Optional;
 import java.util.function.Function;
@@ -48,6 +49,69 @@ private SerializerHelper() {
         return Codec.LONG.flatXmap(checker, checker);
     });
 
+    @Deprecated(since = "10.6.6", forRemoval = true)//TODO - 1.22: Remove
+    private static final Codec<Long> LEGACY_CODEC_FLOATING_LONG = new PrimitiveCodec<>() {
+        @Override
+        public <T> DataResult<Long> read(DynamicOps<T> ops, T input) {
+            return ops.getStringValue(input).flatMap(number -> {
+                try {
+                    long value;
+                    int index = number.indexOf('.');
+                    if (index == -1) {
+                        value = Long.parseUnsignedLong(number);
+                    } else {
+                        value = Long.parseUnsignedLong(number, 0, index, 10);
+                    }
+                    if (value < 0) {
+                        //Clamp unsigned to positive.
+                        value = Long.MAX_VALUE;
+                    }
+                    if (value == 0 && index != -1) {
+                        //If we are at zero, see if we should ceil the decimal
+                        if (Long.parseLong(number, index + 1, number.length(), 10) > 0) {
+                            return DataResult.success(1L);
+                        }
+                    }
+                    return DataResult.success(value);
+                } catch (NumberFormatException e) {
+                    return DataResult.error(e::getMessage);
+                }
+            });
+        }
+
+        @Override
+        public <T> T write(DynamicOps<T> ops, Long value) {
+            return ops.createLong(value);
+        }
+
+        @Override
+        public String toString() {
+            return "LegacyFloatingLong";
+        }
+    };
+
+    /**
+     * Long Codec which accepts a number >= 0
+     *
+     * @since 10.6.6
+     * @deprecated Prefer {@link #POSITIVE_LONG_CODEC}. This field just exists for people who want to be able to load legacy data that was stored as a FloatingLong/
+     */
+    @Deprecated(since = "10.6.6", forRemoval = true)//TODO - 1.22: Remove
+    //Note: We use vanilla's withAlternative instead of Neo's as we always want to encode with the non legacy codec
+    public static final Codec<Long> POSITIVE_LONG_CODEC_LEGACY = Codec.withAlternative(POSITIVE_LONG_CODEC, LEGACY_CODEC_FLOATING_LONG);
+
+    /**
+     * Long Codec which accepts a number > 0
+     *
+     * @since 10.6.6
+     * @deprecated Prefer {@link #POSITIVE_LONG_CODEC}. This field just exists for people who want to be able to load legacy data that was stored as a FloatingLong/
+     */
+    @Deprecated(since = "10.6.6", forRemoval = true)//TODO - 1.22: Remove
+    //Note: We use vanilla's withAlternative instead of Neo's as we always want to encode with the non legacy codec
+    public static final Codec<Long> POSITIVE_NONZERO_LONG_CODEC_LEGACY = Codec.withAlternative(POSITIVE_NONZERO_LONG_CODEC,
+          LEGACY_CODEC_FLOATING_LONG.validate(val -> val == 0 ? DataResult.error(() -> "Value must be greater than zero") : DataResult.success(val))
+    );
+
     /**
      * Custom codec to allow serializing an item stack without the upper bounds.
      *

src/api/java/mekanism/api/chemical/gas/attribute/GasAttributes.java

@@ -2,11 +2,11 @@
 
 import java.util.List;
 import java.util.function.IntSupplier;
+import java.util.function.LongSupplier;
 import mekanism.api.MekanismAPI;
 import mekanism.api.chemical.attribute.ChemicalAttribute;
 import mekanism.api.chemical.gas.Gas;
-import mekanism.api.math.FloatingLong;
-import mekanism.api.math.FloatingLongSupplier;
+import mekanism.api.math.MathUtils;
 import mekanism.api.providers.IGasProvider;
 import mekanism.api.radiation.IRadiationManager;
 import mekanism.api.text.APILang;
@@ -116,7 +116,7 @@ public List<Component> addTooltipText(List<Component> list) {
             ITooltipHelper tooltipHelper = ITooltipHelper.INSTANCE;
             list.add(APILang.CHEMICAL_ATTRIBUTE_COOLANT_EFFICIENCY.translateColored(EnumColor.GRAY, EnumColor.INDIGO, tooltipHelper.getPercent(conductivity)));
             list.add(APILang.CHEMICAL_ATTRIBUTE_COOLANT_ENTHALPY.translateColored(EnumColor.GRAY, EnumColor.INDIGO,
-                  tooltipHelper.getEnergyPerMBDisplayShort(FloatingLong.createConst(thermalEnthalpy))));
+                  tooltipHelper.getEnergyPerMBDisplayShort(MathUtils.clampToLong(thermalEnthalpy))));
             return list;
         }
     }
@@ -188,19 +188,21 @@ public Gas getCooledGas() {
     public static class Fuel extends ChemicalAttribute {
 
         private final IntSupplier burnTicks;
-        private final FloatingLongSupplier energyDensity;
+        private final LongSupplier energyDensity;
 
         /**
          * @param burnTicks     The number of ticks one mB of fuel can be burned for before being depleted; must be greater than zero.
          * @param energyDensity The energy density in one mB of fuel; must be greater than zero.
          *
          * @since 10.4.0
          */
-        public Fuel(int burnTicks, FloatingLong energyDensity) {
+        public Fuel(int burnTicks, long energyDensity) {
             if (burnTicks <= 0) {
                 throw new IllegalArgumentException("Fuel attributes must burn for at least one tick! Burn Ticks: " + burnTicks);
-            } else if (energyDensity.isZero()) {
+            } else if (energyDensity <= 0) {
                 throw new IllegalArgumentException("Fuel attributes must have an energy density greater than zero!");
+            } else if (energyDensity / burnTicks == 0L) {
+                throw new IllegalArgumentException("Energy density per tick must be greater than zero! (integer division)");
             }
             this.burnTicks = () -> burnTicks;
             this.energyDensity = () -> energyDensity;
@@ -211,7 +213,7 @@ public Fuel(int burnTicks, FloatingLong energyDensity) {
          *                      zero.
          * @param energyDensity Supplier for the energy density of one mB of fuel. The supplier should return values be greater than zero.
          */
-        public Fuel(IntSupplier burnTicks, FloatingLongSupplier energyDensity) {
+        public Fuel(IntSupplier burnTicks, LongSupplier energyDensity) {
             this.burnTicks = burnTicks;
             this.energyDensity = energyDensity;
         }
@@ -226,17 +228,17 @@ public int getBurnTicks() {
         /**
          * Gets the amount of energy produced per tick of this fuel.
          */
-        public FloatingLong getEnergyPerTick() {
+        public long getEnergyPerTick() {
             int ticks = getBurnTicks();
             //If we have less than one tick, the density is invalid
             if (ticks < 1) {
                 MekanismAPI.logger.warn("Invalid tick count ({}) for Fuel attribute, this number should be at least 1.", ticks);
-                return FloatingLong.ZERO;
+                return 0;
             } else if (ticks == 1) {
                 //Single tick, no division necessary
-                return energyDensity.get();
+                return energyDensity.getAsLong();
             }
-            return energyDensity.get().divide(ticks);
+            return energyDensity.getAsLong() / ticks;
         }
 
         @Override
@@ -245,7 +247,7 @@ public List<Component> addTooltipText(List<Component> list) {
             ITooltipHelper tooltipHelper = ITooltipHelper.INSTANCE;
             list.add(APILang.CHEMICAL_ATTRIBUTE_FUEL_BURN_TICKS.translateColored(EnumColor.GRAY, EnumColor.INDIGO, tooltipHelper.getFormattedNumber(getBurnTicks())));
             list.add(APILang.CHEMICAL_ATTRIBUTE_FUEL_ENERGY_DENSITY.translateColored(EnumColor.GRAY, EnumColor.INDIGO,
-                  tooltipHelper.getEnergyPerMBDisplayShort(energyDensity.get())));
+                  tooltipHelper.getEnergyPerMBDisplayShort(energyDensity.getAsLong())));
             return list;
         }
     }

src/api/java/mekanism/api/container/InContainerGetterLong.java

@@ -0,0 +1,21 @@
+package mekanism.api.container;
+
+import net.minecraft.core.Direction;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Helper to define a generalized way to get the contents of a container.
+ *
+ * @since 10.6.6
+ */
+@FunctionalInterface
+public interface InContainerGetterLong {
+
+    /**
+     * @param container Container index of the container to query.
+     * @param side      The side we are interacting with the handler from (null for internal).
+     *
+     * @return The object stored in the given container.
+     */
+    long getStored(int container, @Nullable Direction side);
+}

src/api/java/mekanism/api/container/LongToLongContainerInteraction.java

@@ -0,0 +1,24 @@
+package mekanism.api.container;
+
+import mekanism.api.Action;
+import net.minecraft.core.Direction;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Helper to define generalized container interactions for use in our batch container utils. Mainly used for chemicals.
+ *
+ * @since 10.6.6
+ */
+@FunctionalInterface
+public interface LongToLongContainerInteraction {
+
+    /**
+     * @param container Container index to interact with
+     * @param amount    Amount being adjusted by the interaction.
+     * @param side      The side we are interacting with the handler from (null for internal).
+     * @param action    The action to perform, either {@link Action#EXECUTE} or {@link Action#SIMULATE}
+     *
+     * @return Result of the interaction (for example the result of an insert or extraction)
+     */
+    long interact(int container, long amount, @Nullable Direction side, Action action);
+}

src/api/java/mekanism/api/datagen/recipe/builder/ElectrolysisRecipeBuilder.java

@@ -3,7 +3,6 @@
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.chemical.gas.GasStack;
 import mekanism.api.datagen.recipe.MekanismRecipeBuilder;
-import mekanism.api.math.FloatingLong;
 import mekanism.api.recipes.ElectrolysisRecipe;
 import mekanism.api.recipes.basic.BasicElectrolysisRecipe;
 import mekanism.api.recipes.ingredients.FluidStackIngredient;
@@ -14,7 +13,7 @@ public class ElectrolysisRecipeBuilder extends MekanismRecipeBuilder<Electrolysi
     private final FluidStackIngredient input;
     private final GasStack leftGasOutput;
     private final GasStack rightGasOutput;
-    private FloatingLong energyMultiplier = FloatingLong.ONE;
+    private long energyMultiplier = 1;
 
     protected ElectrolysisRecipeBuilder(FluidStackIngredient input, GasStack leftGasOutput, GasStack rightGasOutput) {
         this.input = input;
@@ -41,8 +40,8 @@ public static ElectrolysisRecipeBuilder separating(FluidStackIngredient input, G
      *
      * @param multiplier Multiplier to the energy cost in relation to the configured hydrogen separating energy cost. This value must be greater than or equal to one.
      */
-    public ElectrolysisRecipeBuilder energyMultiplier(FloatingLong multiplier) {
-        if (multiplier.smallerThan(FloatingLong.ONE)) {
+    public ElectrolysisRecipeBuilder energyMultiplier(long multiplier) {
+        if (multiplier < 1) {
             throw new IllegalArgumentException("Energy multiplier must be greater than or equal to one");
         }
         this.energyMultiplier = multiplier;

src/api/java/mekanism/api/datagen/recipe/builder/ItemStackToEnergyRecipeBuilder.java

@@ -2,7 +2,6 @@
 
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.datagen.recipe.MekanismRecipeBuilder;
-import mekanism.api.math.FloatingLong;
 import mekanism.api.recipes.ItemStackToEnergyRecipe;
 import mekanism.api.recipes.basic.BasicItemStackToEnergyRecipe;
 import mekanism.api.recipes.ingredients.ItemStackIngredient;
@@ -11,9 +10,9 @@
 public class ItemStackToEnergyRecipeBuilder extends MekanismRecipeBuilder<ItemStackToEnergyRecipeBuilder> {
 
     private final ItemStackIngredient input;
-    private final FloatingLong output;
+    private final long output;
 
-    protected ItemStackToEnergyRecipeBuilder(ItemStackIngredient input, FloatingLong output) {
+    protected ItemStackToEnergyRecipeBuilder(ItemStackIngredient input, long output) {
         this.input = input;
         this.output = output;
     }
@@ -24,8 +23,8 @@ protected ItemStackToEnergyRecipeBuilder(ItemStackIngredient input, FloatingLong
      * @param input  Input.
      * @param output Output.
      */
-    public static ItemStackToEnergyRecipeBuilder energyConversion(ItemStackIngredient input, FloatingLong output) {
-        if (output.isZero()) {
+    public static ItemStackToEnergyRecipeBuilder energyConversion(ItemStackIngredient input, long output) {
+        if (output <= 0L) {
             throw new IllegalArgumentException("This energy conversion recipe requires an energy output greater than zero");
         }
         return new ItemStackToEnergyRecipeBuilder(input, output);

src/api/java/mekanism/api/datagen/recipe/builder/PressurizedReactionRecipeBuilder.java

@@ -3,7 +3,6 @@
 import mekanism.api.annotations.NothingNullByDefault;
 import mekanism.api.chemical.gas.GasStack;
 import mekanism.api.datagen.recipe.MekanismRecipeBuilder;
-import mekanism.api.math.FloatingLong;
 import mekanism.api.recipes.PressurizedReactionRecipe;
 import mekanism.api.recipes.basic.BasicPressurizedReactionRecipe;
 import mekanism.api.recipes.ingredients.GasStackIngredient;
@@ -17,7 +16,7 @@ public class PressurizedReactionRecipeBuilder extends MekanismRecipeBuilder<Pres
     private final ItemStackIngredient inputSolid;
     private final FluidStackIngredient inputFluid;
     private final GasStackIngredient inputGas;
-    private FloatingLong energyRequired = FloatingLong.ZERO;
+    private long energyRequired = 0;
     private final int duration;
     private final ItemStack outputItem;
     private final GasStack outputGas;
@@ -98,7 +97,10 @@ private static void validateDuration(int duration) {
      *
      * @param energyRequired How much "extra" energy this recipe requires, compared to the base energy requirements of the machine performing the recipe.
      */
-    public PressurizedReactionRecipeBuilder energyRequired(FloatingLong energyRequired) {
+    public PressurizedReactionRecipeBuilder energyRequired(long energyRequired) {
+        if (energyRequired < 0) {
+            throw new IllegalArgumentException("This reaction recipe must have a positive or zero energy requirement.");
+        }
         this.energyRequired = energyRequired;
         return this;
     }