make values proportional when switching modes

Author: ghzdude

src/main/java/gregtech/common/covers/detector/CoverDetectorBase.java

@@ -133,12 +133,12 @@ public boolean canConnectRedstone() {
     }
 
     /**
-     * Clamps {@code val} as int between {@code minValue} and {@code maxValue}.
+     * Clamps {@code val} as long between {@code minValue} and {@code maxValue}.
      *
      * @param val      Current value
      * @param minValue Minimum value
      * @param maxValue Maximum value
-     * @return Capped value of either parsed result or {@code fallbackValue}
+     * @return Capped value
      */
     protected final long clamp(long val, long minValue, long maxValue) {
         return Math.min(Math.max(val, minValue), maxValue);
@@ -150,7 +150,7 @@ protected final long clamp(long val, long minValue, long maxValue) {
      * @param val      Current value
      * @param minValue Minimum value
      * @param maxValue Maximum value
-     * @return Capped value of either parsed result or {@code fallbackValue}
+     * @return Capped value
      */
     protected final int clamp(int val, int minValue, int maxValue) {
         return Math.min(Math.max(val, minValue), maxValue);

src/main/java/gregtech/common/covers/detector/CoverDetectorEnergyAdvanced.java

@@ -35,17 +35,19 @@
 
 public class CoverDetectorEnergyAdvanced extends CoverDetectorEnergy implements CoverWithUI {
 
-    private static final long DEFAULT_MIN_EU = 0, DEFAULT_MAX_EU = 2048;
-    private static final int DEFAULT_MIN_PERCENT = 33, DEFAULT_MAX_PERCENT = 66;
-
-    public long minValue = DEFAULT_MIN_EU;
-    public long maxValue = DEFAULT_MAX_EU;
+    private static final byte DEFAULT_MIN_PERCENT = 33, DEFAULT_MAX_PERCENT = 66;
+    private final byte[] percentValues = { DEFAULT_MIN_PERCENT, DEFAULT_MAX_PERCENT };
+    private final long[] euValues;
     private int outputAmount = 0;
     private boolean usePercent = false;
 
     public CoverDetectorEnergyAdvanced(@NotNull CoverDefinition definition, @NotNull CoverableView coverableView,
                                        @NotNull EnumFacing attachedSide) {
         super(definition, coverableView, attachedSide);
+        euValues = new long[] {
+                (long) (getCoverHolderCapacity() * (DEFAULT_MIN_PERCENT / 100f)),
+                (long) (getCoverHolderCapacity() * (DEFAULT_MAX_PERCENT / 100f))
+        };
     }
 
     @Override
@@ -73,14 +75,14 @@ public void update() {
         if (usePercent) {
             if (energyCapacity > 0) {
                 float ratio = (float) storedEnergy / energyCapacity;
-                this.outputAmount = RedstoneUtil.computeLatchedRedstoneBetweenValues(ratio * 100, this.maxValue,
-                        this.minValue, isInverted(), this.outputAmount);
+                this.outputAmount = RedstoneUtil.computeLatchedRedstoneBetweenValues(ratio * 100, this.getMaxValue(),
+                        this.getMinValue(), isInverted(), this.outputAmount);
             } else {
                 this.outputAmount = isInverted() ? 0 : 15;
             }
         } else {
             this.outputAmount = RedstoneUtil.computeLatchedRedstoneBetweenValues(storedEnergy,
-                    this.maxValue, this.minValue, isInverted(), this.outputAmount);
+                    this.getMaxValue(), this.getMinValue(), isInverted(), this.outputAmount);
         }
         setRedstoneSignalOutput(outputAmount);
     }
@@ -138,21 +140,35 @@ private void updateWidget(GTTextFieldWidget w) {
     }
 
     private long getMinValue() {
-        return (minValue);
+        return isUsePercent() ? percentValues[0] : euValues[0];
     }
 
     private long getMaxValue() {
-        return (maxValue);
+        return isUsePercent() ? percentValues[1] : euValues[1];
     }
 
     private void setMinValue(long val) {
-        this.minValue = clamp(val,
-                0, this.maxValue - 1);
+        if (isUsePercent()) {
+            long eu = (long) (getCoverHolderCapacity() * (val / 100f));
+            euValues[0] = clamp(eu, 0, euValues[1] - 1);
+            percentValues[0] = (byte) clamp(val, 0, percentValues[1] - 1);
+        } else {
+            long p = (long) ((float) val / getCoverHolderCapacity() * 100);
+            percentValues[0] = (byte) clamp(p, 0, percentValues[1] - 1);
+            euValues[0] = clamp(val, 0, euValues[1] - 1);
+        }
     }
 
     private void setMaxValue(long val) {
-        this.maxValue = clamp(val,
-                this.minValue + 1, usePercent ? 100 : Long.MAX_VALUE);
+        if (isUsePercent()) {
+            long eu = (long) (getCoverHolderCapacity() * (val / 100f));
+            euValues[1] = clamp(eu, euValues[0] + 1, Integer.MAX_VALUE);
+            percentValues[1] = (byte) clamp(val, percentValues[0] + 1, 100);
+        } else {
+            long p = (long) ((float) val / getCoverHolderCapacity() * 100);
+            percentValues[1] = (byte) clamp(p, percentValues[0] + 1, 100);
+            euValues[1] = clamp(val, euValues[0] + 1, Integer.MAX_VALUE);
+        }
     }
 
     private boolean isUsePercent() {
@@ -161,14 +177,6 @@ private boolean isUsePercent() {
 
     private void setUsePercent(boolean b) {
         this.usePercent = b;
-
-        if (this.usePercent) { // using percent
-            this.minValue = DEFAULT_MIN_PERCENT;
-            this.maxValue = DEFAULT_MAX_PERCENT;
-        } else { // using discrete EU
-            this.minValue = DEFAULT_MIN_EU;
-            this.maxValue = DEFAULT_MAX_EU;
-        }
     }
 
     private String getPostFix() {
@@ -182,19 +190,19 @@ private int getLength() {
     @Override
     public void writeToNBT(@NotNull NBTTagCompound tagCompound) {
         super.writeToNBT(tagCompound);
-        tagCompound.setLong("maxEU", this.maxValue);
-        tagCompound.setLong("minEU", this.minValue);
         tagCompound.setInteger("outputAmount", this.outputAmount);
         tagCompound.setBoolean("usePercent", this.usePercent);
+        tagCompound.setLong("minEU", this.getMinValue());
+        tagCompound.setLong("maxEU", this.getMaxValue());
     }
 
     @Override
     public void readFromNBT(@NotNull NBTTagCompound tagCompound) {
         super.readFromNBT(tagCompound);
-        this.minValue = tagCompound.getLong("minEU");
-        this.maxValue = tagCompound.getLong("maxEU");
         this.outputAmount = tagCompound.getInteger("outputAmount");
         this.usePercent = tagCompound.getBoolean("usePercent");
+        setMinValue(tagCompound.getLong("minEU"));
+        setMaxValue(tagCompound.getLong("maxEU"));
 
         readDeprecatedInvertedKeyFromNBT(tagCompound);
     }
@@ -210,18 +218,18 @@ private void readDeprecatedInvertedKeyFromNBT(@NotNull NBTTagCompound tagCompoun
     @Override
     public void writeInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.writeInitialSyncData(packetBuffer);
-        packetBuffer.writeLong(this.minValue);
-        packetBuffer.writeLong(this.maxValue);
         packetBuffer.writeInt(this.outputAmount);
         packetBuffer.writeBoolean(this.usePercent);
+        packetBuffer.writeLong(this.getMinValue());
+        packetBuffer.writeLong(this.getMaxValue());
     }
 
     @Override
     public void readInitialSyncData(@NotNull PacketBuffer packetBuffer) {
         super.readInitialSyncData(packetBuffer);
-        this.minValue = packetBuffer.readLong();
-        this.maxValue = packetBuffer.readLong();
         this.outputAmount = packetBuffer.readInt();
         this.usePercent = packetBuffer.readBoolean();
+        setMinValue(packetBuffer.readLong());
+        setMaxValue(packetBuffer.readLong());
     }
 }