Waterline rework (#2577)

* Add barebones PurificationPlant class

* Make simple 3x3 structure to form purification plant

* Add base purification unit class and dummy sifter unit MTE

* Make sifter unit form

* Fix accidental wildcard import

* Implement basic linking of units to controller using data stick

* Make linking more robust, save bidirectional links, add scanner output

* add linking range, error message and unregister old controller when re-linking

* Add link status of purification units to waila body

* Disable maintenance issues on purification plant units

* spotless

* Check structure of linked purification units in main controller

* Remove all star imports

* Small refactor to avoid updating status from main controller

* spotless

* Attempt to document current code

* Convert some comments to javadoc

* Implement basic processing cycle, sync it with linked purification units

* Make water purification plant drain power

* Calculate power drain from active units and remove controller power drain

* spotless

* Add very barebones recipemap

* Fix recipemap name in lang file

* spotless

* Fix purification unit recipemap name

* spotless

* more sane amount of max fluid outputs

* add some item outputs to sifter unit

* Very simple recipe processing, may be buggy

* spotless

* Implement recipe failure

* Implement void protection for purification units

* spotless

* buff item output odds slightly

* Add WIP grade 1 structure

* spotless

* Store base success chance in recipe metadata and display it in NEI

* Fill sifter plant with water

* Add comment

* Allow construction sifter unit in survival

* Implement water boost

* Fix water boost allowing output chance to go over 100%

* Implement failed recipes outputting lower tier water

* Fix typo

* Fix deformed purification unit still drawing power

* Slightly refactor recipe check so base class can read result

* Create empty ModularUI container for purification plant

* The great gui struggle part 1

* More gui struggles, we have a button now

* Adjust button text and size

* gui wars: the rise of the sync

* gui wars: a new hope

* fix the sync

* is pengu old enough to know exceeder?

* Fix being able to link the same unit multiple times

* Sync status string to client

* Sign sifter with my name

* Show status somewhat properly

* Adjust sifter base chance and structure

* Fully implement sifter unit

* More tooltip refactoring

* Add structure info to sifter tooltip.

* nitpicking tooltips

* Adding sound to Purification Plant Main Unit.

* fix star imports

* Add basic coagulator unit, add recipemap for it

* Write coagulator tooltip

* comma nitpicking

* more tooltip work

* small refactor to purification plant controller

* start work on custom recipemap frontend

* Fully implement coagulator

* Update structure requirements in tooltips

* Move controller text in structure tooltips to be consistent

* fix NPE on world load

* Add base ph adjustment unit MTE

* Add info to main controller and energy hatch check

* Fixing tooltip of Main Controller & Energy/Exotic Hatch check.

* Create full pH adjustment structure

* disallow any voiding on purification unit

* Small custom RecipeMap frontend for ph adjustment

* Generate random initial pH value

* Implement inserting NaOH and HCl to adjust pH

* Add easter egg

* Implement pH sensor hatch

* Properly consume HCl and round pH value to 2 digits

* Write ph adjustment unit tooltip

* Tooltip nitpicking

* Try to fix some structurelib hints

* More trying to fix hints

* Add industrial strength concrete casing block

* Add water loop sound to the game

* Document random initial pH in tooltip

* Add glass material base

* Fix spotless formatting in Textures docs because I cannot take it anymore

* Add glass texture

* Try adding transparent glass

* Transparent glass working

* Create pH resistant glass and update pH structure to use it

* Create full structure for main purification plant

* Create custom water purification casing block

* Properly balance ferrous wastewater reprocessing and reduce input by a factor 10

* Add pH factor to NEI tooltip and fix coagulator structure

* Structure tooltip for Purification Plant base

* Add GT_Block_Glass2 and properly set maxMeta

* Add Tinted Industrial Glass blocks

* Fix BlockCasing9 not showing custom tooltip

* Register tinted glass as EV glass

* Add sterile water plant casing and revert tooltip change

* Mention required water in sifter tooltip

* Add more textures and casings

* Add more textures, sounds and add structure info for pH adjustment

* Rename sifter unit to clarifier

* Rename coagulation unit to flocculation unit

* Add activated carbon line

* Fix unintended activated carbon recipe

* Add activated carbon filter

* Add polyaluminium chloride + solution

* Add new custom textures by @BlueHero233

* Wip recipe page with new background for flocculation

* Fix flocculation background image mostly

* Finally aligned the slots

* angery mumbles

* Finish flocculation recipe page

* All the recipe pages!

* Add new reworked textures

* Fix ph adjustment being t3 instead of t4

* Fix invisible casing

* apply chembalance to polyaluminium chloride properly

* Fix ferrous wastewater -> flocculation waste liquid

* Move flocculation to grade 3

* create ozonation unit with placeholder blocks

* add new blocks for ozonation with placeholder textures

* Add water to ozonation structure

* Create ozone gas material

* Add ozone recipe

* Add textures for ozone unit

* Add sound loop for ozonation

* fix

* implement ozonation mechanics

* Finalize ozonation tooltip

* Create dummy plasma heater multi

* Update textures for plasma heater

* Add grade 5 recipemap

* Add hatches to plasma heater multi

* Add basic plasma heating unit variables

* Implement plasma heating unit mechanics

* Add plasma heater tooltip

* Add structure info to plasma heater tooltip

* fix ozonation tooltip, add frontend

* Fix positioning on ozonation tooltip and fix plasma heater crash

* Add UV treatment MTE and structure without textures

* Revert accidental addition of debug dependencies

* Add initial version of uv unit textures

* update naquadria casing, add water color gradient

* Some minor cleanup and added docs

* Create lens housing bus

* Add lens bus to UV treatment unit

* Add lens indicator hatch

* Merge GT_MetaGeneratedItem_03.java

* Add lens indicator hatch

* Add the lens cycle, uv treatment recipe map and fix eut of flocculation recipe

* Implement lens swapping mechanic

* Clean up first lens swap

* Fix uv recipemap lang and move lens cycle to recipe

* Write uv treatment tooltip

* Add sounds for uv and plasma steps

* Create empty degasifier class

* Create temporary debug structure for degasifier

* set temp casing index for degasifier

* create degasifier control hatch

* create slightly less temporary but still temporary structure for degasifier

* Start impl of degasifier

* fix fluid consumption and nbt loading of degasifier

* Degasifier implementation should work now

* Rename and reformat some things and start work on degasser tooltiop

* give last bit much lower chance of being on to avoid cheesing

* Finish degasifier tooltip

* Integrate some deleno lore

* hopefully fix all moved casing meta ids after merge

* Create finalized degasser structure

* Integrate more deleno lore

* Add even more lore

* Create placeholder particle catalysts and fetch particle items from gt++

* Fix wrong casing and recipemap localization

* Create parallel config menu

* refactor purification recipecheck slightly

* implement parallel amount on water i/o and power

* add tooltip info about parallel config

* fix text

* update block names in structure tooltips

* create structure tooltip for degasser

* create textureless quark catalyst items

* add the purple glass

* fix lore typos

* fix some casing indices

* remove concrete floor from water plant and reword tooltip

* fix main plant structure and add placeholder structure for t8 step

* fix structurecheck for main plant and add random catalyst generation for t8

* implement basic mechanics for particle extractor (wip)

* Create plasma heater frontend

* implement final mechanics and bugfixes for particle extractor

* add recipes for re-aligning quark catalysts

* add simple recipes for catalyst alignment

* initial replacement of purified water in engraver recipes

* add purified water to all wafer cutting recipes

* fix purified water amounts

* buff quark cyclotron recipe again

* extract t8 unit casings into their own icons

* Write initial tooltip for t8 module

* add purified water to mask recipes

* Add recipe comparator to show low tier purified water recipes first

* add min casing check to waterline multis

* buff ozone production

* update t8 structure

* make purified water optional again for naq wafers

* Fix blockrenderer for purification plant

* fix nei previews

* fix nei

* really fix nei this time

* add t8 lore

* fix hatch recipe locking blocking automation on some steps

* try to solve weirdness with grade 3 recipe

* fix issues with recipecheck

* fix missing null check

* make ph sensor use a strict inequality check

* fix min casings on t5

* significantly nerf purified water usage for beamline masks

* disable void protection for waterline

* small adjustments to t6 unit

* more small adjustments to t6 unit to prevent easy automation cheese

* fix degasser redstone output and missing return statement

* remove water QFT catalyst recipes

---------

Co-authored-by: Tianyou Mei <meitianyou94@gmail.com>
Co-authored-by: OlliedeLeeuw <ollie.riemersma@xs4all.nl>
Co-authored-by: Ollie_de_Leeuw <154506304+OlliedeLeeuw@users.noreply.github.com>
Co-authored-by: Martin Robertz <dream-master@gmx.net>

19 files changed, 6401 insertions, 0 deletions

diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java
new file mode 100644
index 0000000000..3d49f05dca
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java
@@ -0,0 +1,122 @@
+package gregtech.common.tileentities.machines.multi.purification;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+
+public class GT_MetaTileEntity_Hatch_DegasifierControlHatch extends GT_MetaTileEntity_Hatch {
+
+    private byte outputStrength = 0;
+
+    private static final IIconContainer textureFont = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR;
+    private static final IIconContainer textureFont_Glow = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR_GLOW;
+
+    public GT_MetaTileEntity_Hatch_DegasifierControlHatch(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "Outputs a control signal for the Degasser Purification Unit");
+    }
+
+    public GT_MetaTileEntity_Hatch_DegasifierControlHatch(String aName, int aTier, String[] aDescription,
+        ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean allowGeneralRedstoneOutput() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection Side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {
+        getBaseMetaTileEntity().setActive(true);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_Hatch_DegasifierControlHatch(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { "Can be installed in the Degasser Purification Unit.",
+            "Outputs Redstone Signal Strength based on the current control signal." };
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        outputStrength = aNBT.getByte("mOutputStrength");
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setByte("mOutputStrength", outputStrength);
+        super.saveNBTData(aNBT);
+    }
+
+    // Pass zero signal to disable output
+    public void updateOutputSignal(byte signal) {
+        outputStrength = signal;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (outputStrength > 0) {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setStrongOutputRedstoneSignal(side, outputStrength);
+            }
+        } else {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setStrongOutputRedstoneSignal(side, (byte) 0);
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), TextureFactory.builder()
+            .addIcon(textureFont_Glow)
+            .glow()
+            .build() };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont) };
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java
new file mode 100644
index 0000000000..bd025e0e69
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java
@@ -0,0 +1,52 @@
+package gregtech.common.tileentities.machines.multi.purification;
+
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
+import gregtech.client.GT_TooltipHandler;
+
+public class GT_MetaTileEntity_LensHousing extends GT_MetaTileEntity_Hatch_InputBus {
+
+    public GT_MetaTileEntity_LensHousing(int id, String name, String nameRegional) {
+        super(
+            id,
+            name,
+            nameRegional,
+            GT_TooltipHandler.Tier.UV.ordinal(),
+            1,
+            new String[] { "Holds a lens for UV laser focusing." });
+    }
+
+    public GT_MetaTileEntity_LensHousing(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+    }
+
+    @Override
+    public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_LensHousing(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return 1;
+    }
+
+    @Override
+    public int getCircuitSlot() {
+        return -1;
+    }
+
+    @Override
+    public boolean allowSelectCircuit() {
+        return false;
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        getBaseMetaTileEntity().add1by1Slot(builder);
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java
new file mode 100644
index 0000000000..c017025d42
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java
@@ -0,0 +1,117 @@
+package gregtech.common.tileentities.machines.multi.purification;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+
+public class GT_MetaTileEntity_LensIndicator extends GT_MetaTileEntity_Hatch {
+
+    private boolean isOn = false;
+
+    private static final IIconContainer textureFont = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR;
+    private static final IIconContainer textureFont_Glow = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR_GLOW;
+
+    public GT_MetaTileEntity_LensIndicator(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "Indicates required lens swaps.");
+    }
+
+    public GT_MetaTileEntity_LensIndicator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return false;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return true;
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+    public boolean allowGeneralRedstoneOutput() {
+        return true;
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection Side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+        ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public void initDefaultModes(NBTTagCompound aNBT) {
+        getBaseMetaTileEntity().setActive(true);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[] { "Can be installed in the UV Treatment Purification Unit.",
+            "Outputs Redstone Signal when a lens swap is requested." };
+    }
+
+    /**
+     * Updates redstone output strength based on the pH of the multiblock.
+     */
+    public void updateRedstoneOutput(boolean enabled) {
+        isOn = enabled;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (isOn) {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 15);
+            }
+        } else {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 0);
+            }
+        }
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_LensIndicator(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), TextureFactory.builder()
+            .addIcon(textureFont_Glow)
+            .glow()
+            .build() };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont) };
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java
new file mode 100644
index 0000000000..42bfd06d7a
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java
@@ -0,0 +1,740 @@
+package gregtech.common.tileentities.machines.multi.purification;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
+import static gregtech.api.enums.GT_HatchElement.Energy;
+import static gregtech.api.enums.GT_HatchElement.ExoticEnergy;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_Values.AuthorNotAPenguin;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_GLOW;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+import static gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitBase.WATER_BOOST_BONUS_CHANCE;
+import static gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitBase.WATER_BOOST_NEEDED_FLUID;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.google.common.collect.ImmutableList;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.drawable.shapes.Rectangle;
+import com.gtnewhorizons.modularui.api.forge.ItemStackHandler;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.math.Size;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.api.widget.Widget;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedRow;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.Scrollable;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_StructureUtility;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.shutdown.ShutDownReasonRegistry;
+import gregtech.common.gui.modularui.widget.ShutDownReasonSyncer;
+import gregtech.common.gui.modularui.widget.TextButtonWidget;
+
+public class GT_MetaTileEntity_PurificationPlant
+    extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_PurificationPlant>
+    implements ISurvivalConstructable {
+
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final String STRUCTURE_PIECE_MAIN_SURVIVAL = "main_survival";
+
+    /**
+     * Maximum distance in each axis between the purification plant main controller and the controller blocks of the
+     * purification plant units.
+     */
+    public static final int MAX_UNIT_DISTANCE = 32;
+
+    /**
+     * Time in ticks for a full processing cycle to complete.
+     */
+    public static final int CYCLE_TIME_TICKS = 120 * SECONDS;
+
+    /**
+     * Stores all purification units linked to this controller.
+     * Normally all units in this list should be valid and unique, if not then there is a bug where they are not being
+     * unlinked properly on block destruction/relinking.
+     */
+    private final List<LinkedPurificationUnit> mLinkedUnits = new ArrayList<>();
+
+    private static final IStructureDefinition<GT_MetaTileEntity_PurificationPlant> STRUCTURE_DEFINITION = StructureDefinition
+        .<GT_MetaTileEntity_PurificationPlant>builder()
+        .addShape(STRUCTURE_PIECE_MAIN, PurificationPlantStructureString.STRUCTURE_STRING)
+        // Create an identical structure for survival autobuild, with water replaced with air
+        .addShape(
+            STRUCTURE_PIECE_MAIN_SURVIVAL,
+            Arrays.stream(PurificationPlantStructureString.STRUCTURE_STRING)
+                .map(
+                    sa -> Arrays.stream(sa)
+                        .map(s -> s.replaceAll("F", " "))
+                        .toArray(String[]::new))
+                .toArray(String[][]::new))
+        // Superplasticizer-treated high strength concrete
+        .addElement('A', ofBlock(GregTech_API.sBlockCasings9, 3))
+        // Sterile Water Plant Casing
+        .addElement('B', ofBlock(GregTech_API.sBlockCasings9, 4))
+        // Reinforced Sterile Water Plant Casing
+        .addElement('C', ofBlock(GregTech_API.sBlockCasings9, 5))
+        // Tinted Industrial Glass
+        .addElement('D', ofBlockAnyMeta(GregTech_API.sBlockTintedGlass, 0))
+        .addElement('F', ofBlock(Blocks.water, 0))
+        .addElement('G', ofFrame(Materials.Tungsten))
+        // Hatch space
+        .addElement(
+            'H',
+            ofChain(
+                lazy(
+                    t -> GT_StructureUtility.<GT_MetaTileEntity_PurificationPlant>buildHatchAdder()
+                        .atLeastList(t.getAllowedHatches())
+                        .dot(1)
+                        .casingIndex(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings9, 4))
+                        .build()),
+                ofBlock(GregTech_API.sBlockCasings9, 4)))
+        .build();
+
+    public GT_MetaTileEntity_PurificationPlant(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_PurificationPlant(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 3, 6, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        int built = survivialBuildPiece(STRUCTURE_PIECE_MAIN_SURVIVAL, stackSize, 3, 6, 0, elementBudget, env, true);
+        if (built == -1) {
+            GT_Utility.sendChatToPlayer(
+                env.getActor(),
+                EnumChatFormatting.GREEN + "Auto placing done ! Now go place the water yourself !");
+            return 0;
+        }
+        return built;
+    }
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_PurificationPlant> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Purification Plant")
+            .addInfo("Main controller block for the Water Purification Plant.")
+            .addInfo(
+                "Freely place " + EnumChatFormatting.YELLOW
+                    + "Purification Units "
+                    + EnumChatFormatting.GRAY
+                    + "within "
+                    + EnumChatFormatting.RED
+                    + MAX_UNIT_DISTANCE
+                    + EnumChatFormatting.GRAY
+                    + " blocks along each axis.")
+            .addInfo("Left click this controller with a data stick, then right click a purification unit to link.")
+            .addInfo("Supplies power to linked purification units. This multiblock accepts TecTech energy hatches.")
+            .addSeparator()
+            .addInfo(
+                "Works in fixed time processing cycles of " + EnumChatFormatting.RED
+                    + CYCLE_TIME_TICKS / SECONDS
+                    + EnumChatFormatting.GRAY
+                    + " seconds.")
+            .addInfo("All linked units follow this cycle.")
+            .addSeparator()
+            .addInfo("Every recipe has a base chance of success. Success rate can be boosted")
+            .addInfo("by using a portion of the target output as a secondary input.")
+            .addInfo(
+                EnumChatFormatting.RED + GT_Utility.formatNumbers(WATER_BOOST_NEEDED_FLUID * 100)
+                    + "%"
+                    + EnumChatFormatting.GRAY
+                    + " of output yield will be consumed in exchange for an")
+            .addInfo(
+                "additive " + EnumChatFormatting.RED
+                    + GT_Utility.formatNumbers(WATER_BOOST_BONUS_CHANCE * 100)
+                    + "%"
+                    + EnumChatFormatting.GRAY
+                    + " increase to success.")
+            .addInfo(
+                "On recipe failure, each purification unit has a " + EnumChatFormatting.RED
+                    + "50%"
+                    + EnumChatFormatting.GRAY
+                    + " chance")
+            .addInfo("to return water of the same quality as the input or lower.")
+            .addSeparator()
+            .addInfo("Every purification unit has a configuration window to configure maximum parallel amount.")
+            .addInfo(
+                "This will only scale purified water I/O and power usage. Other catalysts and outputs are unchanged.")
+            .addSeparator()
+            .addInfo(
+                EnumChatFormatting.AQUA + ""
+                    + EnumChatFormatting.ITALIC
+                    + "Contaminants and ionized particles in water can cause significant imperfections in delicate")
+            .addInfo(
+                EnumChatFormatting.AQUA + ""
+                    + EnumChatFormatting.ITALIC
+                    + "processes related to the cutting and engraving of silicon wafers and chips. It is crucial that")
+            .addInfo(
+                EnumChatFormatting.AQUA + ""
+