Use epsilon to improve scale change check comparisons

Author: pupnewfster

src/generators/java/mekanism/generators/common/content/fission/FissionReactorMultiblockData.java

@@ -210,7 +210,8 @@ public boolean tick(Level world) {
         float coolantScale = MekanismUtils.getScale(prevCoolantScale, fluidCoolantTank);
         float fuelScale = MekanismUtils.getScale(prevFuelScale, fuelTank);
         float steamScale = MekanismUtils.getScale(prevHeatedCoolantScale, heatedCoolantTank), wasteScale = MekanismUtils.getScale(prevWasteScale, wasteTank);
-        if (coolantScale != prevCoolantScale || fuelScale != prevFuelScale || steamScale != prevHeatedCoolantScale || wasteScale != prevWasteScale) {
+        if (MekanismUtils.scaleChanged(coolantScale, prevCoolantScale) || MekanismUtils.scaleChanged(fuelScale, prevFuelScale) ||
+            MekanismUtils.scaleChanged(steamScale, prevHeatedCoolantScale) || MekanismUtils.scaleChanged(wasteScale, prevWasteScale)) {
             needsPacket = true;
             prevCoolantScale = coolantScale;
             prevFuelScale = fuelScale;

src/generators/java/mekanism/generators/common/content/turbine/TurbineMultiblockData.java

@@ -188,7 +188,7 @@ public boolean tick(Level world) {
             needsPacket = true;
         }
         float scale = MekanismUtils.getScale(prevSteamScale, gasTank);
-        if (scale != prevSteamScale) {
+        if (MekanismUtils.scaleChanged(scale, prevSteamScale)) {
             needsPacket = true;
             prevSteamScale = scale;
         }

src/generators/java/mekanism/generators/common/tile/TileEntityBioGenerator.java

@@ -3,8 +3,8 @@
 import mekanism.api.Action;
 import mekanism.api.AutomationType;
 import mekanism.api.IContentsListener;
-import mekanism.api.SerializationConstants;
 import mekanism.api.RelativeSide;
+import mekanism.api.SerializationConstants;
 import mekanism.api.math.FloatingLong;
 import mekanism.common.attachments.containers.ContainerType;
 import mekanism.common.capabilities.fluid.BasicFluidTank;
@@ -78,7 +78,7 @@ protected boolean onUpdateServer() {
             MekanismUtils.logMismatchedStackSize(bioFuelTank.shrinkStack(1, Action.EXECUTE), 1);
             getEnergyContainer().insert(MekanismGeneratorsConfig.generators.bioGeneration.get(), Action.EXECUTE, AutomationType.INTERNAL);
             float fluidScale = MekanismUtils.getScale(lastFluidScale, bioFuelTank);
-            if (fluidScale != lastFluidScale) {
+            if (MekanismUtils.scaleChanged(fluidScale, lastFluidScale)) {
                 lastFluidScale = fluidScale;
                 sendUpdatePacket = true;
             }

src/main/java/mekanism/common/content/boiler/BoilerMultiblockData.java

@@ -197,12 +197,12 @@ public boolean tick(Level world) {
             }
         }
         float waterScale = MekanismUtils.getScale(prevWaterScale, waterTank);
-        if (waterScale != prevWaterScale) {
+        if (MekanismUtils.scaleChanged(waterScale, prevWaterScale)) {
             needsPacket = true;
             prevWaterScale = waterScale;
         }
         float steamScale = MekanismUtils.getScale(prevSteamScale, steamTank);
-        if (steamScale != prevSteamScale) {
+        if (MekanismUtils.scaleChanged(steamScale, prevSteamScale)) {
             needsPacket = true;
             prevSteamScale = steamScale;
         }

src/main/java/mekanism/common/content/evaporation/EvaporationMultiblockData.java

@@ -154,7 +154,7 @@ public boolean tick(Level world) {
         inputInputSlot.fillTank(outputInputSlot);
         recipeCacheLookupMonitor.updateAndProcess();
         float scale = MekanismUtils.getScale(prevScale, inputTank);
-        if (scale != prevScale) {
+        if (!Mth.equal(scale, prevScale)) {
             prevScale = scale;
             needsPacket = true;
         }

src/main/java/mekanism/common/content/tank/TankMultiblockData.java

@@ -95,7 +95,7 @@ public boolean tick(Level world) {
             outputSlot.fillChemicalTank(type);
         }
         float scale = getScale();
-        if (scale != prevScale) {
+        if (MekanismUtils.scaleChanged(scale, prevScale)) {
             prevScale = scale;
             needsPacket = true;
         }

src/main/java/mekanism/common/tile/TileEntityEnergyCube.java

@@ -1,8 +1,8 @@
 package mekanism.common.tile;
 
 import mekanism.api.IContentsListener;
-import mekanism.api.SerializationConstants;
 import mekanism.api.RelativeSide;
+import mekanism.api.SerializationConstants;
 import mekanism.api.providers.IBlockProvider;
 import mekanism.common.attachments.containers.ContainerType;
 import mekanism.common.block.attribute.Attribute;
@@ -98,7 +98,7 @@ protected boolean onUpdateServer() {
         chargeSlot.drainContainer();
         dischargeSlot.fillContainerOrConvert();
         float newScale = MekanismUtils.getScale(prevScale, energyContainer);
-        if (newScale != prevScale) {
+        if (MekanismUtils.scaleChanged(newScale, prevScale)) {
             prevScale = newScale;
             sendUpdatePacket = true;
         }

src/main/java/mekanism/common/tile/TileEntityFluidTank.java

@@ -132,7 +132,7 @@ protected boolean onUpdateServer() {
         }
 
         float scale = MekanismUtils.getScale(prevScale, fluidTank);
-        if (scale != prevScale) {
+        if (MekanismUtils.scaleChanged(scale, prevScale)) {
             if (prevScale == 0 || scale == 0) {
                 //If it was empty and no longer is, or wasn't empty and now is empty we want to recheck the block lighting
                 // as the fluid may have changed and have a light value
@@ -291,14 +291,14 @@ public void handleUpdateTag(@NotNull CompoundTag tag, @NotNull HolderLookup.Prov
         NBTUtils.setFluidStackIfPresent(provider, tag, SerializationConstants.FLUID, fluid -> fluidTank.setStack(fluid));
         NBTUtils.setFluidStackIfPresent(provider, tag, SerializationConstants.VALVE, fluid -> valveFluid = fluid);
         NBTUtils.setFloatIfPresent(tag, SerializationConstants.SCALE, scale -> {
-            if (prevScale != scale) {
+            if (MekanismUtils.scaleChanged(prevScale, scale)) {
                 if (prevScale == 0 || scale == 0) {
                     //If it was empty and no longer is, or wasn't empty and now is empty we want to recheck the block lighting
                     // as the fluid may have changed and have a light value, mark that the client should update the light value
                     updateClientLight = true;
                 }
-                prevScale = scale;
             }
+            prevScale = scale;
         });
     }
 

src/main/java/mekanism/common/tile/machine/TileEntityNutritionalLiquifier.java

@@ -3,8 +3,8 @@
 import java.util.Collections;
 import java.util.List;
 import mekanism.api.IContentsListener;
-import mekanism.api.SerializationConstants;
 import mekanism.api.RelativeSide;
+import mekanism.api.SerializationConstants;
 import mekanism.api.fluid.IExtendedFluidTank;
 import mekanism.api.math.FloatingLong;
 import mekanism.api.recipes.ItemStackToFluidRecipe;
@@ -149,7 +149,7 @@ protected boolean onUpdateServer() {
         containerFillSlot.drainTank(outputSlot);
         recipeCacheLookupMonitor.updateAndProcess();
         float pasteScale = MekanismUtils.getScale(lastPasteScale, fluidTank);
-        if (pasteScale != lastPasteScale) {
+        if (MekanismUtils.scaleChanged(pasteScale, lastPasteScale)) {
             lastPasteScale = pasteScale;
             sendUpdatePacket = true;
         }

src/main/java/mekanism/common/util/MekanismUtils.java

@@ -219,7 +219,6 @@ public static float getScale(float prevScale, long stored, long capacity, boolea
         return getScale(prevScale, capacity == 0 ? 0 : (float) (stored / (double) capacity), empty, stored == capacity);
     }
 
-
     public static float getScale(float prevScale, IEnergyContainer container) {
         float targetScale;
         FloatingLong stored = container.getEnergy();
@@ -252,6 +251,14 @@ public static float getScale(float prevScale, float targetScale, boolean empty,
         return prevScale;
     }
 
+    public static boolean scaleChanged(float scale, float prevScale) {
+        if (Mth.equal(scale, prevScale)) {
+            //If we max out our scale bounds, force an update regardless
+            return scale != prevScale && scale == 0 || scale == 1 || prevScale == 1 || prevScale == 0;
+        }
+        return true;
+    }
+
     public static long getBaseUsage(IUpgradeTile tile, int def) {
         if (tile.supportsUpgrades()) {
             //getGasPerTickMean * required ticks (not rounded)