Fix of Overflow Valve & New features (#3040)

Co-authored-by: Martin Robertz <dream-master@gmx.net>

3 files changed, 395 insertions, 204 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java
deleted file mode 100644
index f93b371aa3..0000000000
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java
+++ /dev/null
@@ -1,198 +0,0 @@
-package gtPlusPlus.xmod.gregtech.common.covers;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.Fluid;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidHandler;
-
-import com.gtnewhorizons.modularui.api.screen.ModularWindow;
-import com.gtnewhorizons.modularui.common.widget.TextWidget;
-
-import gregtech.api.gui.modularui.CoverUIBuildContext;
-import gregtech.api.interfaces.tileentity.ICoverable;
-import gregtech.api.util.CoverBehavior;
-import gregtech.api.util.GTUtility;
-import gregtech.api.util.ISerializableObject;
-import gregtech.common.gui.modularui.widget.CoverDataControllerWidget;
-import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget;
-
-public class CoverOverflow extends CoverBehavior {
-
-    public final int mTransferRate;
-    public final int mInitialTransferRate;
-    public final int mMaxTransferRate;
-
-    public CoverOverflow(int aTransferRate) {
-        this.mTransferRate = aTransferRate * 1000 / 10;
-        this.mInitialTransferRate = aTransferRate;
-        this.mMaxTransferRate = aTransferRate * 1000;
-    }
-
-    public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable,
-        ICoverable aTileEntity, long aTimer) {
-        if (aCoverVariable == 0) {
-            return aCoverVariable;
-        }
-        if ((aTileEntity instanceof IFluidHandler)) {
-            // Logger.INFO("Trying to Void via Overflow.");
-            IFluidHandler tTank1;
-            ForgeDirection directionFrom;
-            directionFrom = ForgeDirection.UNKNOWN;
-            tTank1 = (IFluidHandler) aTileEntity;
-            if (tTank1 != null) {
-                FluidStack aTankStack = tTank1.getTankInfo(directionFrom)[0].fluid;
-                if (aTankStack != null) {
-                    // Logger.INFO("Found Fluid inside self - "+aTankStack.getLocalizedName()+", overflow point set at
-                    // "+aCoverVariable+"L and we have "+aTankStack.amount+"L inside.");
-                    if (aTankStack.amount > aCoverVariable) {
-                        int aAmountToDrain = aTankStack.amount - aCoverVariable;
-                        // Logger.INFO("There is "+aAmountToDrain+" more fluid in the tank than we would like.");
-                        if (aAmountToDrain > 0) {
-                            FluidStack tLiquid = tTank1.drain(directionFrom, Math.abs(aAmountToDrain), true);
-                            if (tLiquid != null) {
-                                // Logger.INFO("Drained "+aAmountToDrain+"L.");
-                            }
-                        }
-                    }
-                } else {
-                    // Logger.INFO("Could not simulate drain on self.");
-                }
-            }
-        }
-        return aCoverVariable;
-    }
-
-    public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
-        EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) {
-            aCoverVariable += (mMaxTransferRate * (aPlayer.isSneaking() ? 0.1f : 0.01f));
-        } else {
-            aCoverVariable -= (mMaxTransferRate * (aPlayer.isSneaking() ? 0.1f : 0.01f));
-        }
-        if (aCoverVariable > mMaxTransferRate) {
-            aCoverVariable = mInitialTransferRate;
-        }
-        if (aCoverVariable <= 0) {
-            aCoverVariable = mMaxTransferRate;
-        }
-        GTUtility.sendChatToPlayer(
-            aPlayer,
-            GTUtility.trans("322", "Overflow point: ") + aCoverVariable + GTUtility.trans("323", "L"));
-        return aCoverVariable;
-    }
-
-    public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity,
-        EntityPlayer aPlayer, float aX, float aY, float aZ) {
-        boolean aShift = aPlayer.isSneaking();
-        int aAmount = aShift ? 128 : 8;
-        if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) {
-            aCoverVariable += aAmount;
-        } else {
-            aCoverVariable -= aAmount;
-        }
-        if (aCoverVariable > mMaxTransferRate) {
-            aCoverVariable = mInitialTransferRate;
-        }
-        if (aCoverVariable <= 0) {
-            aCoverVariable = mMaxTransferRate;
-        }
-        GTUtility.sendChatToPlayer(
-            aPlayer,
-            GTUtility.trans("322", "Overflow point: ") + aCoverVariable + GTUtility.trans("323", "L"));
-        aTileEntity.setCoverDataAtSide(side, new ISerializableObject.LegacyCoverData(aCoverVariable));
-        return true;
-    }
-
-    public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot,
-        ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot,
-        ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
-        ICoverable aTileEntity) {
-        return false;
-    }
-
-    public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid,
-        ICoverable aTileEntity) {
-        return true;
-    }
-
-    public boolean alwaysLookConnected(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return true;
-    }
-
-    public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) {
-        return 5;
-    }
-
-    // GUI
-
-    @Override
-    public boolean hasCoverGUI() {
-        return true;
-    }
-
-    @Override
-    public ModularWindow createWindow(CoverUIBuildContext buildContext) {
-        return new OverflowUIFactory(buildContext).createWindow();
-    }
-
-    private class OverflowUIFactory extends UIFactory {
-
-        private static final int startX = 10;
-        private static final int startY = 25;
-        private static final int spaceX = 18;
-        private static final int spaceY = 18;
-
-        public OverflowUIFactory(CoverUIBuildContext buildContext) {
-            super(buildContext);
-        }
-
-        @SuppressWarnings("PointlessArithmeticExpression")
-        @Override
-        protected void addUIWidgets(ModularWindow.Builder builder) {
-            AtomicBoolean warn = new AtomicBoolean(false);
-
-            builder
-                .widget(
-                    new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflow.this)
-                        .addFollower(
-                            new CoverDataFollowerNumericWidget<>(),
-                            coverData -> (double) convert(coverData),
-                            (coverData, state) -> new ISerializableObject.LegacyCoverData(state.intValue()),
-                            widget -> widget.setBounds(0, mMaxTransferRate)
-                                .setScrollValues(1000, 144, 100000)
-                                .setFocusOnGuiOpen(true)
-                                .setPos(startX + spaceX * 0, startY + spaceY * 1 + 8)
-                                .setSize(spaceX * 4 - 3, 12)))
-                .widget(
-                    new TextWidget(GTUtility.trans("322", "Overflow point: ")).setDefaultColor(COLOR_TEXT_GRAY.get())
-                        .setPos(startX, 4 + startY + spaceY * 0 + 8));
-        }
-    }
-}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java
new file mode 100644
index 0000000000..fb1c58bd62
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java
@@ -0,0 +1,389 @@
+package gtPlusPlus.xmod.gregtech.common.covers;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.gui.modularui.CoverUIBuildContext;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.metatileentity.CommonMetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEBasicTank;
+import gregtech.api.metatileentity.implementations.MTEFluid;
+import gregtech.api.util.CoverBehaviorBase;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.ISerializableObject;
+import gregtech.common.gui.modularui.widget.CoverDataControllerWidget;
+import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget;
+import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget;
+import io.netty.buffer.ByteBuf;
+
+public class CoverOverflowValve extends CoverBehaviorBase<CoverOverflowValve.OverflowValveData> {
+
+    private final int minOverflowPoint = 0;
+    private final int maxOverflowPoint;
+
+    public CoverOverflowValve(int maxOverflowPoint) {
+        super(OverflowValveData.class);
+        this.maxOverflowPoint = maxOverflowPoint;
+    }
+
+    @Override
+    public OverflowValveData createDataObject() {
+        return new OverflowValveData(0, 0, false, true);
+    }
+
+    @Override
+    public OverflowValveData createDataObject(int aLegacyData) {
+        return new OverflowValveData(aLegacyData, maxOverflowPoint / 10, false, true);
+    }
+
+    private FluidStack doOverflowThing(FluidStack fluid, OverflowValveData data) {
+        if (fluid != null && fluid.amount > data.overflowPoint)
+            fluid.amount = Math.max(fluid.amount - data.voidingRate, data.overflowPoint);
+        return fluid;
+    }
+
+    private void doOverflowThings(FluidStack[] fluids, OverflowValveData data) {
+        for (FluidStack fluid : fluids) doOverflowThing(fluid, data);
+    }
+
+    @Override
+    protected OverflowValveData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID,
+        OverflowValveData data, ICoverable aTileEntity, long aTimer) {
+        if (data == null) return new OverflowValveData(0, 0, false, true);
+
+        if (data.voidingRate == 0 || data.voidingRate > data.overflowPoint) return data;
+
+        if (aTileEntity instanceof CommonMetaTileEntity common) {
+            IMetaTileEntity tile = common.getMetaTileEntity();
+            if (tile instanceof MTEBasicTank fluidTank) {
+                fluidTank.setDrainableStack(doOverflowThing(fluidTank.getDrainableStack(), data));
+                return data;
+            } else if (tile instanceof MTEFluid fluidPipe && fluidPipe.isConnectedAtSide(side)) {
+                doOverflowThings(fluidPipe.mFluids, data);
+                return data;
+            }
+        }
+
+        return data;
+    }
+
+    // Overrides methods
+
+    @Override
+    protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected int getTickRateImpl(ForgeDirection side, int aCoverID, OverflowValveData data, ICoverable aTileEntity) {
+        return 5;
+    }
+
+    @Override
+    protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, int aSlot,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, int aSlot,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return data.canFluidOutput;
+    }
+
+    @Override
+    protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, Fluid aFluid,
+        ICoverable aTileEntity) {
+        return data.canFluidInput;
+    }
+
+    @Override
+    protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity) {
+        return true;
+    }
+
+    @Override
+    protected OverflowValveData onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) {
+            data.overflowPoint += (int) (maxOverflowPoint * (aPlayer.isSneaking() ? 0.1f : 0.01f));
+        } else {
+            data.overflowPoint -= (int) (maxOverflowPoint * (aPlayer.isSneaking() ? 0.1f : 0.01f));
+        }
+
+        if (data.overflowPoint > maxOverflowPoint) data.overflowPoint = minOverflowPoint;
+        if (data.overflowPoint <= minOverflowPoint) data.overflowPoint = maxOverflowPoint;
+
+        GTUtility.sendChatToPlayer(
+            aPlayer,
+            StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point") + data.overflowPoint
+                + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second"));
+        return data;
+    }
+
+    @Override
+    protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, OverflowValveData data,
+        ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        boolean aShift = aPlayer.isSneaking();
+        int aAmount = aShift ? 128 : 8;
+        if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) {
+            data.overflowPoint += aAmount;
+        } else {
+            data.overflowPoint -= aAmount;
+        }
+
+        if (data.overflowPoint > maxOverflowPoint) data.overflowPoint = minOverflowPoint;
+        if (data.overflowPoint <= minOverflowPoint) data.overflowPoint = maxOverflowPoint;
+
+        GTUtility.sendChatToPlayer(
+            aPlayer,
+            StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point") + data.overflowPoint
+                + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second"));
+        aTileEntity.setCoverDataAtSide(side, data);
+        return true;
+    }
+
+    // GUI
+
+    @Override
+    public boolean hasCoverGUI() {
+        return true;
+    }
+
+    @Override
+    public ModularWindow createWindow(CoverUIBuildContext buildContext) {
+        return new OverflowUIFactory(buildContext).createWindow();
+    }
+
+    private final class OverflowUIFactory extends UIFactory {
+
+        // width and height of text input for "Overflow Point" and "Voiding Rate"
+        private static final int width = 73;
+        private static final int height = 12;
+
+        public OverflowUIFactory(CoverUIBuildContext buildContext) {
+            super(buildContext);
+        }
+
+        @Override
+        protected void addUIWidgets(ModularWindow.Builder builder) {
+            builder
+                .widget(
+                    new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point"))
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(57, 35))
+                .widget(
+                    new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second"))
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(77, 35))
+                .widget(
+                    new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflowValve.this)
+                        .addFollower(
+                            new CoverDataFollowerNumericWidget<>(),
+                            coverData -> (double) coverData.overflowPoint,
+                            (coverData, state) -> {
+                                coverData.overflowPoint = state.intValue();
+                                return coverData;
+                            },
+                            widget -> widget.setBounds(minOverflowPoint, maxOverflowPoint)
+                                .setScrollValues(1000, 144, 100000)
+                                .setFocusOnGuiOpen(true)
+                                .setPos(57, 45)
+                                .setSize(width, height)))
+                .widget(
+                    new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_voiding_rate"))
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(63, 77))
+                .widget(
+                    new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_update"))
+                        .setDefaultColor(COLOR_TEXT_GRAY.get())
+                        .setPos(77, 35))
+                .widget(
+                    new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflowValve.this)
+                        .addFollower(
+                            new CoverDataFollowerNumericWidget<>(),
+                            coverData -> (double) coverData.voidingRate,
+                            (coverData, state) -> {
+                                coverData.voidingRate = Math.min(state.intValue(), coverData.overflowPoint);
+                                return coverData;
+                            },
+                            widget -> widget.setBounds(minOverflowPoint, maxOverflowPoint)
+                                .setScrollValues(1000, 144, 100000)
+                                .setFocusOnGuiOpen(true)
+                                .setPos(57, 87)
+                                .setSize(width, height)))
+                .widget(
+                    new CoverDataControllerWidget.CoverDataIndexedControllerWidget_ToggleButtons<>(
+                        this::getCoverData,
+                        this::setCoverData,
+                        CoverOverflowValve.this,
+                        this::getClickable,
+                        this::updateData)
+                            .addToggleButton(
+                                0,
+                                CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_ALLOW_INPUT)
+                                    .addTooltip(
+                                        StatCollector
+                                            .translateToLocal("GTPP.gui.text.cover_overflow_valve_allow_fluid_input"))
+                                    .setPos(21, 69))
+                            .addToggleButton(
+                                1,
+                                CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_BLOCK_INPUT)
+                                    .addTooltip(
+                                        StatCollector
+                                            .translateToLocal("GTPP.gui.text.cover_overflow_valve_block_fluid_input"))
+                                    .setPos(12, 69))
+                            .addToggleButton(
+                                2,
+                                CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_ALLOW_OUTPUT)
+                                    .addTooltip(
+                                        StatCollector
+                                            .translateToLocal("GTPP.gui.text.cover_overflow_valve_allow_fluid_output"))
+                                    .setPos(21, 86))
+                            .addToggleButton(
+                                3,
+                                CoverDataFollowerToggleButtonWidget.ofDisableable(),
+                                widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_BLOCK_OUTPUT)
+                                    .addTooltip(
+                                        StatCollector
+                                            .translateToLocal("GTPP.gui.text.cover_overflow_valve_block_fluid_output"))
+                                    .setPos(12, 86)));
+        }
+
+        private boolean getClickable(int id, OverflowValveData data) {
+            return switch (id) {
+                case 0 -> data.canFluidInput;
+                case 1 -> !data.canFluidInput;
+                case 2 -> data.canFluidOutput;
+                case 3 -> !data.canFluidOutput;
+                default -> throw new IllegalStateException("Wrong button id: " + id);
+            };
+        }
+
+        private OverflowValveData updateData(int id, OverflowValveData data) {
+            return switch (id) {
+                case 0 -> {
+                    data.canFluidInput = true;
+                    yield data;
+                }
+                case 1 -> {
+                    data.canFluidInput = false;
+                    yield data;
+                }
+                case 2 -> {
+                    data.canFluidOutput = true;
+                    yield data;
+                }
+                case 3 -> {
+                    data.canFluidOutput = false;
+                    yield data;
+                }
+                default -> throw new IllegalStateException("Wrong button id: " + id);
+            };
+        }
+    }
+
+    public static class OverflowValveData implements ISerializableObject {
+
+        private int overflowPoint;
+        private int voidingRate;
+        private boolean canFluidInput;
+        private boolean canFluidOutput;
+
+        public OverflowValveData(int overflowPoint, int voidingRate, boolean canFluidInput, boolean canFluidOutput) {
+            this.overflowPoint = overflowPoint;
+            this.voidingRate = voidingRate;
+            this.canFluidInput = canFluidInput;
+            this.canFluidOutput = canFluidOutput;
+        }
+
+        @Override
+        @NotNull
+        public ISerializableObject copy() {
+            return new OverflowValveData(overflowPoint, voidingRate, canFluidInput, canFluidOutput);
+        }
+
+        @Override
+        @NotNull
+        public NBTBase saveDataToNBT() {
+            NBTTagCompound tag = new NBTTagCompound();
+            tag.setInteger("overflowPoint", overflowPoint);
+            tag.setInteger("voidingRate", voidingRate);
+            tag.setBoolean("canFluidInput", canFluidInput);
+            tag.setBoolean("canFluidOutput", canFluidOutput);
+            return tag;
+        }
+
+        @Override
+        public void writeToByteBuf(ByteBuf aBuf) {
+            aBuf.writeInt(overflowPoint)
+                .writeInt(voidingRate)
+                .writeBoolean(canFluidInput)
+                .writeBoolean(canFluidOutput);
+        }
+
+        @Override
+        public void loadDataFromNBT(NBTBase aNBT) {
+            if (aNBT instanceof NBTTagCompound tag) {
+                overflowPoint = tag.getInteger("overflowPoint");
+                voidingRate = tag.getInteger("voidingRate");
+                canFluidInput = tag.getBoolean("canFluidInput");
+                canFluidOutput = tag.getBoolean("canFluidOutput");
+            }
+        }
+
+        @Override
+        @NotNull
+        public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, @Nullable EntityPlayerMP aPlayer) {
+            overflowPoint = aBuf.readInt();
+            voidingRate = aBuf.readInt();
+            canFluidInput = aBuf.readBoolean();
+            canFluidOutput = aBuf.readBoolean();
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
index a787e4c4ce..d4c54bc66f 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java
@@ -56,7 +56,7 @@ import gtPlusPlus.core.util.math.MathUtils;
 import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
 import gtPlusPlus.xmod.gregtech.api.items.GTMetaItemX32;
 import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
-import gtPlusPlus.xmod.gregtech.common.covers.CoverOverflow;
+import gtPlusPlus.xmod.gregtech.common.covers.CoverOverflowValve;
 
 public class MetaGeneratedGregtechItems extends GTMetaItemX32 {
 
@@ -373,31 +373,31 @@ public class MetaGeneratedGregtechItems extends GTMetaItemX32 {
             new GTMultiTexture(
                 Textures.BlockIcons.MACHINE_CASINGS[4][0],
                 new GTRenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
-            new CoverOverflow(64));
+            new CoverOverflowValve(64_000));
         GregTechAPI.registerCover(
             GregtechItemList.Cover_Overflow_MV.get(1L),
             new GTMultiTexture(
                 Textures.BlockIcons.MACHINE_CASINGS[5][0],
                 new GTRenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
-            new CoverOverflow(512));
+            new CoverOverflowValve(512_000));
         GregTechAPI.registerCover(
             GregtechItemList.Cover_Overflow_HV.get(1L),
             new GTMultiTexture(
                 Textures.BlockIcons.MACHINE_CASINGS[5][0],
                 new GTRenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
-            new CoverOverflow(4096));
+            new CoverOverflowValve(4_096_000));
         GregTechAPI.registerCover(
             GregtechItemList.Cover_Overflow_EV.get(1L),
             new GTMultiTexture(
                 Textures.BlockIcons.MACHINE_CASINGS[8][0],
                 new GTRenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
-            new CoverOverflow(32768));
+            new CoverOverflowValve(32_768_000));
         GregTechAPI.registerCover(
             GregtechItemList.Cover_Overflow_IV.get(1L),
             new GTMultiTexture(
                 Textures.BlockIcons.MACHINE_CASINGS[8][0],
                 new GTRenderedTexture(TexturesGtBlock.Overlay_Overflow_Valve)),
-            new CoverOverflow(262144));
+            new CoverOverflowValve(262_144_000));
     }
 
 }