Added large fluid extractor multi (#2819)

* Added large fluid extractor multi

* ran spotless

* Prevent multi from requesting more than 1A with 1 energy hatch

* Moved boro. glass registration to bartworks

In GT5u dev environments, borosilicate glass wasn't registered
properly. The block was registered, but it wasn't added to
allLevelsReverse since registerGlass() was never called.
This led to getTier() not working properly (it always returned tier=3).

* Changed speed bonuses and added some QoL changes

Added a multiplication EU/t cost to solenoid tiers and buffed solenoid
parallels.
Added an additive EU/t reduction to heating coil tiers.
Fixed the glass structure check.
Updated the multi's tooltip and sensor info data.

* applied spotless

* large fluid extractor code cleanup

* changed mechanics & improved structure messages

* spotless apply

---------

Co-authored-by: Mary Hopson <doyoumined@gmail.com>
Co-authored-by: boubou19 <miisterunknown@gmail.com>
Co-authored-by: Martin Robertz <dream-master@gmx.net>

8 files changed, 553 insertions, 11 deletions

diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java b/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java
index aca6b16330..3d2b33843c 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java
@@ -4,7 +4,6 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAdder;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlocksTiered;
-import static gregtech.api.enums.Mods.BartWorks;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -17,6 +16,7 @@ import net.minecraft.block.Block;
 
 import org.apache.commons.lang3.tuple.Pair;
 
+import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.LinkedHashMultimap;
 import com.google.common.collect.SetMultimap;
@@ -25,7 +25,6 @@ import com.gtnewhorizon.structurelib.structure.IStructureElement;
 
 import cpw.mods.fml.common.Loader;
 import cpw.mods.fml.common.LoaderState;
-import cpw.mods.fml.common.registry.GameRegistry;
 
 /**
  * API for bartworks borosilicate glass.
@@ -38,7 +37,6 @@ import cpw.mods.fml.common.registry.GameRegistry;
  */
 public class BorosilicateGlass {
 
-    private static Block block, block2;
     private static List<Pair<Block, Integer>> representatives;
     private static SetMultimap<Byte, Pair<Block, Integer>> allLevels;
     private static final Table<Block, Integer, Byte> allLevelsReverse = HashBasedTable.create();
@@ -48,17 +46,11 @@ public class BorosilicateGlass {
     }
 
     public static Block getGlassBlock() {
-        if (block == null) {
-            block = GameRegistry.findBlock(BartWorks.ID, "BW_GlasBlocks");
-        }
-        return block;
+        return ItemRegistry.bw_realglas;
     }
 
     public static Block getGlassBlock2() {
-        if (block2 == null) {
-            block2 = GameRegistry.findBlock(BartWorks.ID, "BW_GlasBlocks2");
-        }
-        return block2;
+        return ItemRegistry.bw_realglas;
     }
 
     private static void doRegister(byte level, Block block, int meta,
@@ -111,6 +103,14 @@ public class BorosilicateGlass {
     }
 
     /**
+     * ONLY registers borosilicate glass. Without this, {@link #getTier} won't work properly in environments that don't
+     * have the coremod.
+     */
+    public static void registerBorosilicateGlass() {
+        getAllLevels();
+    }
+
+    /**
      * Register a new block as valid borosilicate glass with given tier (even if it doesn't contain boron at all)
      *
      * Does not support matching by more complex stuff like tile entity!
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java
index a5bd2edc12..86927d9add 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java
@@ -183,6 +183,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.StatCollector;
 
+import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass;
 import com.github.bartimaeusnek.bartworks.MainMod;
 import com.github.bartimaeusnek.bartworks.common.blocks.BW_Blocks;
 import com.github.bartimaeusnek.bartworks.common.blocks.BW_GlasBlocks;
@@ -395,6 +396,8 @@ public class ItemRegistry {
     public static void run() {
         GameRegistry.registerBlock(ItemRegistry.bw_fake_glasses, "BW_FakeGlasBlock");
         GameRegistry.registerBlock(ItemRegistry.bw_fake_glasses2, "BW_FakeGlasBlocks2");
+        BorosilicateGlass.registerBorosilicateGlass();
+
         GameRegistry.registerBlock(ItemRegistry.BW_BLOCKS[2], BW_ItemBlocks.class, "BW_Machinery_Casings");
         GameRegistry.registerItem(ItemRegistry.LEATHER_ROTOR, "BW_LeatherRotor");
         GameRegistry.registerItem(ItemRegistry.WOOL_ROTOR, "BW_WoolRotor");
diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java
index 766525c958..9e4fc04302 100644
--- a/src/main/java/gregtech/api/enums/ItemList.java
+++ b/src/main/java/gregtech/api/enums/ItemList.java
@@ -2103,6 +2103,7 @@ public enum ItemList implements IItemContainer {
     BlockQuarkPipe,
     BlockQuarkReleaseChamber,
     BlockQuarkContainmentCasing,
+    LargeFluidExtractor,
     AcceleratorLV,
     AcceleratorMV,
     AcceleratorHV,
diff --git a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
index 7793a2f6b2..e51be375d1 100644
--- a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
+++ b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java
@@ -625,6 +625,7 @@ public enum MetaTileEntityIDs {
     CRAFTING_INPUT_SLAVE(2716),
     INPUT_HATCH_ME(2717),
     INPUT_BUS_ME(2718),
+    LARGE_FLUID_EXTRACTOR(2730),
     INDUSTRIAL_LASER_ENGRAVER_CONTROLLER(3004),
     INDUSTRIAL_COMPRESSOR_CONTROLLER(3005),
     HIP_COMPRESSOR_CONTROLLER(3006),
diff --git a/src/main/java/gregtech/api/util/GT_StructureUtility.java b/src/main/java/gregtech/api/util/GT_StructureUtility.java
index ad3e4e9876..6bbb3e1223 100644
--- a/src/main/java/gregtech/api/util/GT_StructureUtility.java
+++ b/src/main/java/gregtech/api/util/GT_StructureUtility.java
@@ -47,6 +47,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
 import gregtech.common.blocks.GT_Block_Casings5;
 import gregtech.common.blocks.GT_Block_FrameBox;
+import gregtech.common.blocks.GT_Cyclotron_Coils;
 import gregtech.common.blocks.GT_Item_Machines;
 
 public class GT_StructureUtility {
@@ -490,6 +491,112 @@ public class GT_StructureUtility {
         };
     }
 
+    /**
+     * Assumes all solenoids are accepted.
+     *
+     * @see #ofSolenoidCoil(BiPredicate, Function)
+     */
+    public static <T> IStructureElement<T> ofSolenoidCoil(BiConsumer<T, Byte> aSolenoidTierSetter,
+        Function<T, Byte> aSolenoidTierGetter) {
+        return ofSolenoidCoil((t, l) -> {
+            aSolenoidTierSetter.accept(t, l);
+            return true;
+        }, aSolenoidTierGetter);
+    }
+
+    /**
+     * Solenoid coil structure element.
+     *
+     * @param aSolenoidTierSetter Notify the controller of this new solenoid. Got called exactly once per solenoid.
+     *                            Might be
+     *                            called less times if structure test fails. If the setter returns false then it assumes
+     *                            the solenoid is rejected.
+     * @param aSolenoidTierGetter Get the solenoid voltage tier. Null means no tier recorded yet.
+     */
+    public static <T> IStructureElement<T> ofSolenoidCoil(BiPredicate<T, Byte> aSolenoidTierSetter,
+        Function<T, Byte> aSolenoidTierGetter) {
+        if (aSolenoidTierSetter == null || aSolenoidTierGetter == null) {
+            throw new IllegalArgumentException();
+        }
+        return new IStructureElement<>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                Block block = world.getBlock(x, y, z);
+
+                if (block != GregTech_API.sSolenoidCoilCasings) return false;
+
+                var coils = ((GT_Cyclotron_Coils) GregTech_API.sSolenoidCoilCasings);
+
+                Byte existingLevel = aSolenoidTierGetter.apply(t);
+                byte newLevel = (byte) (coils.getVoltageTier(world.getBlockMetadata(x, y, z)));
+
+                if (existingLevel == null) {
+                    return aSolenoidTierSetter.test(t, newLevel);
+                } else {
+                    return newLevel == existingLevel;
+                }
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                StructureLibAPI
+                    .hintParticle(world, x, y, z, GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger));
+                return true;
+            }
+
+            private int getMetaFromHint(ItemStack trigger) {
+                return Math.min(Math.max(trigger.stackSize - 1, 0), 10);
+            }
+
+            @Override
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return world.setBlock(x, y, z, GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger), 3);
+            }
+
+            @Override
+            public BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger,
+                AutoPlaceEnvironment env) {
+                return BlocksToPlace.create(GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger));
+            }
+
+            @Override
+            public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                IItemSource s, EntityPlayerMP actor, Consumer<IChatComponent> chatter) {
+                return survivalPlaceBlock(
+                    t,
+                    world,
+                    x,
+                    y,
+                    z,
+                    trigger,
+                    AutoPlaceEnvironment.fromLegacy(s, actor, chatter));
+            }
+
+            @Override
+            public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger,
+                AutoPlaceEnvironment env) {
+                Block block = world.getBlock(x, y, z);
+
+                boolean isCoil = block == GregTech_API.sSolenoidCoilCasings
+                    && world.getBlockMetadata(x, y, z) == getMetaFromHint(trigger);
+
+                if (isCoil) return SKIP;
+
+                return StructureUtility.survivalPlaceBlock(
+                    GregTech_API.sSolenoidCoilCasings,
+                    getMetaFromHint(trigger),
+                    world,
+                    x,
+                    y,
+                    z,
+                    env.getSource(),
+                    env.getActor(),
+                    env.getChatter());
+            }
+        };
+    }
+
     @Nonnull
     public static Predicate<ItemStack> filterByMTEClass(List<? extends Class<? extends IMetaTileEntity>> list) {
         return is -> {
diff --git a/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java b/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java
index d918060298..3c4250540c 100644
--- a/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java
+++ b/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java
@@ -118,6 +118,10 @@ public class GT_Cyclotron_Coils extends GT_Block_Casings_Abstract {
         return Textures.BlockIcons.MACHINE_CASING_SOLID_STEEL.getIcon();
     }
 
+    public int getVoltageTier(int meta) {
+        return meta + 2;
+    }
+
     @Override
     public int colorMultiplier(IBlockAccess aWorld, int aX, int aY, int aZ) {
         return aWorld.getBlockMetadata(aX, aY, aZ) > 9 ? super.colorMultiplier(aWorld, aX, aY, aZ)
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java
new file mode 100644
index 0000000000..c1a5bc3458
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java
@@ -0,0 +1,419 @@
+package gregtech.common.tileentities.machines.multi;
+
+import static com.github.bartimaeusnek.bartworks.util.BW_Util.ofGlassTiered;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.withChannel;
+import static gregtech.api.enums.GT_HatchElement.Energy;
+import static gregtech.api.enums.GT_HatchElement.InputBus;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_HatchElement.OutputBus;
+import static gregtech.api.enums.GT_HatchElement.OutputHatch;
+import static gregtech.api.enums.GT_Values.VN;
+import static gregtech.api.enums.Textures.BlockIcons.getCasingTextureForId;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.ofCoil;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
+import static gregtech.api.util.GT_StructureUtility.ofSolenoidCoil;
+import static net.minecraft.util.EnumChatFormatting.RESET;
+import static net.minecraft.util.EnumChatFormatting.YELLOW;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+
+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.math.Alignment;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.HeatingCoilLevel;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+
+public class GT_MetaTileEntity_LargeFluidExtractor
+    extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_LargeFluidExtractor>
+    implements ISurvivalConstructable {
+
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final int CASING_INDEX = 48; // Robust Tungstensteel Machine Casing
+    private static final int BASE_CASING_COUNT = 24 + 24 + 9;
+    private static final int MAX_HATCHES_ALLOWED = 16;
+
+    private static final double BASE_SPEED_BONUS = 1.5;
+    private static final double BASE_EU_MULTIPLIER = 0.8;
+
+    private static final double SPEED_PER_COIL = 0.1;
+    private static final int PARALLELS_PER_SOLENOID = 8;
+    private static final double HEATING_COIL_EU_MULTIPLIER = 0.9;
+
+    // spotless:off
+    private static final IStructureDefinition<GT_MetaTileEntity_LargeFluidExtractor> STRUCTURE_DEFINITION = StructureDefinition
+        .<GT_MetaTileEntity_LargeFluidExtractor>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            transpose(
+                new String[][] {
+                    {"     ", " ccc ", " ccc ", " ccc ", "     "},
+                    {"     ", " f f ", "  s  ", " f f ", "     "},
+                    {"     ", " f f ", "  s  ", " f f ", "     "},
+                    {"     ", " f f ", "  s  ", " f f ", "     "},
+                    {"ccccc", "ccccc", "ccscc", "ccccc", "ccccc"},
+                    {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"},
+                    {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"},
+                    {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"},
+                    {"cc~cc", "ccccc", "ccccc", "ccccc", "ccccc"},
+                }))
+        .addElement('c',
+            buildHatchAdder(GT_MetaTileEntity_LargeFluidExtractor.class)
+                .atLeast(InputBus, OutputBus, OutputHatch, Energy, Maintenance)
+                .casingIndex(CASING_INDEX) // Robust Tungstensteel Machine Casing
+                .dot(1)
+                .buildAndChain(
+                    onElementPass(
+                        GT_MetaTileEntity_LargeFluidExtractor::onCasingAdded,
+                        ofBlock(GregTech_API.sBlockCasings4, 0))) // Robust Tungstensteel Machine Casing
+        )
+        .addElement(
+            'g',
+            withChannel(
+                "glass",
+                ofGlassTiered(
+                    (byte) 1, (byte) 127, (byte) 0,
+                    GT_MetaTileEntity_LargeFluidExtractor::setGlassTier,
+                    GT_MetaTileEntity_LargeFluidExtractor::getGlassTier,
+                    2))
+        )
+        .addElement(
+            'h',
+            withChannel(
+                "coil",
+                ofCoil(
+                    GT_MetaTileEntity_LargeFluidExtractor::setCoilLevel,
+                    GT_MetaTileEntity_LargeFluidExtractor::getCoilLevel))
+        )
+        .addElement(
+            's',
+            withChannel(
+                "solenoid",
+                ofSolenoidCoil(
+                    GT_MetaTileEntity_LargeFluidExtractor::setSolenoidLevel,
+                    GT_MetaTileEntity_LargeFluidExtractor::getSolenoidLevel))
+        )
+        .addElement(
+            'f',
+            ofFrame(Materials.BlackSteel)
+        )
+        .build();
+    // spotless:on
+
+    private byte mGlassTier = 0;
+    @Nullable
+    private HeatingCoilLevel mCoilLevel = null;
+    @Nullable
+    private Byte mSolenoidLevel = null;
+    private int mCasingAmount;
+    private boolean mStructureBadGlassTier = false, mStructureBadCasingCount = false;
+
+    public GT_MetaTileEntity_LargeFluidExtractor(final int aID, final String aName, final String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_LargeFluidExtractor(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IStructureDefinition<GT_MetaTileEntity_LargeFluidExtractor> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    public void clearHatches() {
+        super.clearHatches();
+
+        mCasingAmount = 0;
+        mStructureBadGlassTier = false;
+        mStructureBadCasingCount = false;
+        mGlassTier = 0;
+        mCoilLevel = null;
+        mSolenoidLevel = null;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        if (!checkPiece(STRUCTURE_PIECE_MAIN, 2, 8, 0)) {
+            return false;
+        }
+
+        if (mCasingAmount < (BASE_CASING_COUNT - MAX_HATCHES_ALLOWED)) {
+            mStructureBadCasingCount = true;
+        }
+
+        for (var energyHatch : mEnergyHatches) {
+            if (energyHatch.getBaseMetaTileEntity() == null) {
+                continue;
+            }
+
+            if (mGlassTier < 10 && energyHatch.getTierForStructure() > mGlassTier) {
+                mStructureBadGlassTier = true;
+            }
+        }
+
+        return !mStructureBadGlassTier && !mStructureBadCasingCount;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 8, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 8, 0, elementBudget, env, false, true);
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic();
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        super.setProcessingLogicPower(logic);
+        logic.setAvailableAmperage(mEnergyHatches.size());
+        logic.setEuModifier((float) (getEUMultiplier()));
+        logic.setMaxParallel(getParallels());
+        logic.setSpeedBonus(1.0f / (float) (getSpeedBonus()));
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_LargeFluidExtractor(this.mName);
+    }
+
+    private void onCasingAdded() {
+        mCasingAmount++;
+    }
+
+    private byte getGlassTier() {
+        return mGlassTier;
+    }
+
+    private void setGlassTier(byte tier) {
+        mGlassTier = tier;
+    }
+
+    private HeatingCoilLevel getCoilLevel() {
+        return mCoilLevel;
+    }
+
+    private void setCoilLevel(HeatingCoilLevel level) {
+        mCoilLevel = level;
+    }
+
+    private Byte getSolenoidLevel() {
+        return mSolenoidLevel;
+    }
+
+    private void setSolenoidLevel(byte level) {
+        mSolenoidLevel = level;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean active, boolean redstoneLevel) {
+        if (side == facing) {
+            if (active) {
+                return new ITexture[] { getCasingTextureForId(CASING_INDEX), TextureFactory.builder()
+                    .addIcon(TexturesGtBlock.Overlay_Machine_Controller_Advanced_Active)
+                    .extFacing()
+                    .build() };
+            } else {
+                return new ITexture[] { getCasingTextureForId(CASING_INDEX), TextureFactory.builder()
+                    .addIcon(TexturesGtBlock.Overlay_Machine_Controller_Advanced)
+                    .extFacing()
+                    .build() };
+            }
+        }
+        return new ITexture[] { getCasingTextureForId(CASING_INDEX) };
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+
+        // spotless:off
+        tt.addMachineType("Fluid Extractor")
+            .addInfo("Controller block for the Large Fluid Extractor")
+            .addInfo(String.format(
+                "%d%% faster than single block machines of the same voltage",
+                (int) Math.round((BASE_SPEED_BONUS - 1) * 100)
+            ))
+            .addInfo(String.format(
+                "Only uses %d%% of the EU/t normally required",
+                (int) Math.round(BASE_EU_MULTIPLIER * 100)
+            ))
+            .addInfo(String.format(
+                "Every coil tier gives a +%d%% speed bonus and a %d%% EU/t discount (multiplicative)",
+                (int) Math.round(SPEED_PER_COIL * 100),
+                (int) Math.round((1 - HEATING_COIL_EU_MULTIPLIER) * 100)
+            ))
+            .addInfo(String.format(
+                "Every solenoid tier gives +%d parallels",
+                (int) PARALLELS_PER_SOLENOID
+            ))
+            .addInfo(String.format(
+                "The EU multiplier is %s%.2f * (%.2f ^ Heating Coil Tier)%s, prior to overclocks",
+                EnumChatFormatting.ITALIC,
+                BASE_EU_MULTIPLIER,
+                HEATING_COIL_EU_MULTIPLIER,
+                EnumChatFormatting.GRAY
+            ))
+            .addInfo("The energy hatch tier is limited by the glass tier. UEV glass unlocks all tiers.")
+            .addSeparator()
+            .beginStructureBlock(5, 9, 5, false)
+            .addController("Front Center (Bottom Layer)")
+            .addCasingInfoMin("Robust Tungstensteel Machine Casing", BASE_CASING_COUNT - MAX_HATCHES_ALLOWED, false)
+            .addCasingInfoExactly("Borosilicate Glass (any)", 9 * 4, true)
+            .addCasingInfoExactly("Solenoid Superconducting Coil (any)", 7, true)
+            .addCasingInfoExactly("Heating Coils (any)", 8 * 3, true)
+            .addCasingInfoExactly("Black Steel Frame Box", 3 * 8, false)
+            .addInputBus("Any Robust Tungstensteel Machine Casing", 1)
+            .addOutputBus("Any Robust Tungstensteel Machine Casing", 1)
+            .addOutputHatch("Any Robust Tungstensteel Machine Casing", 1)
+            .addEnergyHatch("Any Robust Tungstensteel Machine Casing", 1)
+            .addMaintenanceHatch("Any Robust Tungstensteel Machine Casing", 1)
+            .toolTipFinisher("GregTech");
+        // spotless:on
+
+        return tt;
+    }
+
+    @Override
+    protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) {
+        super.drawTexts(screenElements, inventorySlot);
+
+        screenElements.widgets(TextWidget.dynamicString(() -> {
+            if (mStructureBadCasingCount) {
+                return String.format(
+                    "%sNot enough casings: need %d, but\nhave %d.%s",
+                    EnumChatFormatting.DARK_RED,
+                    BASE_CASING_COUNT - MAX_HATCHES_ALLOWED,
+                    mCasingAmount,
+                    RESET);
+            }
+
+            if (mStructureBadGlassTier) {
+                int hatchTier = 0;
+
+                for (var hatch : mEnergyHatches) {
+                    if (hatch.mTier > hatchTier) hatchTier = hatch.mTier;
+                }
+
+                return String.format(
+                    "%sEnergy hatch tier (%s) is too high\nfor the glass tier (%s).%s",
+                    EnumChatFormatting.DARK_RED,
+                    VN[hatchTier],
+                    VN[mGlassTier],
+                    RESET);
+            }
+
+            return "";
+        })
+            .setTextAlignment(Alignment.CenterLeft));
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10_000;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return RecipeMaps.fluidExtractionRecipes;
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsSingleRecipeLocking() {
+        return true;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        var data = new ArrayList<String>();
+
+        data.addAll(Arrays.asList(super.getInfoData()));
+
+        data.add(String.format("Max Parallels: %s%d%s", YELLOW, getParallels(), RESET));
+        data.add(String.format("Heating Coil Speed Bonus: +%s%.0f%s %%", YELLOW, getCoilSpeedBonus() * 100, RESET));
+        data.add(String.format("Total Speed Multiplier: %s%.0f%s %%", YELLOW, getSpeedBonus() * 100, RESET));
+        data.add(String.format("Total EU/t Multiplier: %s%.0f%s %%", YELLOW, getEUMultiplier() * 100, RESET));
+
+        return data.toArray(new String[data.size()]);
+    }
+
+    public int getParallels() {
+        return Math.max(1, mSolenoidLevel == null ? 0 : (PARALLELS_PER_SOLENOID * mSolenoidLevel));
+    }
+
+    public float getCoilSpeedBonus() {
+        return (float) ((mCoilLevel == null ? 0 : SPEED_PER_COIL * mCoilLevel.getTier()));
+    }
+
+    public float getSpeedBonus() {
+        return (float) (BASE_SPEED_BONUS + getCoilSpeedBonus());
+    }
+
+    public float getEUMultiplier() {
+        double heatingBonus = (mCoilLevel == null ? 0 : Math.pow(HEATING_COIL_EU_MULTIPLIER, mCoilLevel.getTier()));
+
+        return (float) (BASE_EU_MULTIPLIER * heatingBonus);
+    }
+}
diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java
index 856ddf2f82..e7ad9e9337 100644
--- a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java
+++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java
@@ -1048,6 +1048,7 @@ import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_Titanium;
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_TungstenSteel;
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeChemicalReactor;
+import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeFluidExtractor;
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Gas;
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_GasAdvanced;
 import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_HPSteam;
@@ -1658,6 +1659,12 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC
                 MULTI_AUTOCLAVE_CONTROLLER.ID,
                 "multimachine.autoclave",
                 "Industrial Autoclave").getStackForm(1));
+
+        ItemList.LargeFluidExtractor.set(
+            new GT_MetaTileEntity_LargeFluidExtractor(
+                LARGE_FLUID_EXTRACTOR.ID,
+                "multimachine.fluidextractor",
+                "Large Fluid Extractor").getStackForm(1));
     }
 
     private static void registerSteamMachines() {