Auto place integration (#83)

* Updated needed dependancies

* Added autoplace integration for compact fusion reactors

* Corrected energy hatch type and increased budget for large fusion

* Applied spotless

* Added autoplace integration to precise assembler

* Reverted check for now

* survival build multis

* spotless

* spotless annoyance

* Added structure check from normal compact to gtpp compact

* SC Steam turbine survival

Co-authored-by: BlueWeabo <76872108+BlueWeabo@users.noreply.github.com>

16 files changed, 560 insertions, 179 deletions

diff --git a/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java b/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java
index f011934b66..3cee14c86f 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/CoolantTower.java
@@ -3,16 +3,18 @@ package goodgenerator.blocks.tileEntity;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
 import static gregtech.api.enums.Textures.BlockIcons.*;
-import static gregtech.api.util.GT_StructureUtility.ofFrame;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.*;
 
 import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
 import goodgenerator.util.DescTextLocalization;
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
@@ -24,10 +26,12 @@ import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_Utility;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
-public class CoolantTower extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class CoolantTower extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     protected IStructureDefinition<CoolantTower> multiDefinition = null;
     private final int CASING_INDEX = 1542;
@@ -219,9 +223,11 @@ public class CoolantTower extends GT_MetaTileEntity_TooltipMultiBlockBase_EM imp
                     .addElement('C', ofFrame(Materials.TungstenCarbide))
                     .addElement(
                             'H',
-                            ofChain(
-                                    ofHatchAdder(CoolantTower::addIOFluidToMachineList, CASING_INDEX, 1),
-                                    ofBlockAnyMeta(GregTech_API.sBlockConcretes, 8)))
+                            ofChain(buildHatchAdder(CoolantTower.class)
+                                    .atLeast(GT_HatchElement.InputHatch, GT_HatchElement.OutputHatch)
+                                    .casingIndex(CASING_INDEX)
+                                    .dot(1)
+                                    .buildAndChain(ofBlockAnyMeta(GregTech_API.sBlockConcretes, 8))))
                     .build();
         }
         return multiDefinition;
@@ -362,4 +368,10 @@ public class CoolantTower extends GT_MetaTileEntity_TooltipMultiBlockBase_EM imp
         }
         return new ITexture[] {casingTexturePages[12][6]};
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 5, 11, 0, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
index c7472acfbe..75d131aff3 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java
@@ -4,9 +4,12 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
 import static gregtech.api.enums.GT_Values.V;
 import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
 
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
@@ -14,6 +17,8 @@ import goodgenerator.loader.Loaders;
 import goodgenerator.util.DescTextLocalization;
 import goodgenerator.util.MyRecipeAdder;
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
+import gregtech.api.interfaces.IHatchElement;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
@@ -21,12 +26,13 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_Log;
-import gregtech.api.util.GT_ModHandler;
-import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
-import gregtech.api.util.GT_Utility;
+import gregtech.api.util.*;
 import ic2.core.Ic2Items;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumChatFormatting;
@@ -34,7 +40,8 @@ import net.minecraft.util.StatCollector;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
 
-public class ExtremeHeatExchanger extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class ExtremeHeatExchanger extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     protected IStructureDefinition<ExtremeHeatExchanger> multiDefinition = null;
 
@@ -87,17 +94,35 @@ public class ExtremeHeatExchanger extends GT_MetaTileEntity_TooltipMultiBlockBas
                     .addElement(
                             'B',
                             ofChain(
-                                    ofHatchAdder(ExtremeHeatExchanger::addClassicInputToMachineList, 48, 1),
-                                    ofHatchAdder(ExtremeHeatExchanger::addMaintenanceToMachineList, 48, 1),
+                                    buildHatchAdder(ExtremeHeatExchanger.class)
+                                            .atLeast(GT_HatchElement.InputHatch, GT_HatchElement.Maintenance)
+                                            .casingIndex(48)
+                                            .dot(1)
+                                            .build(),
                                     onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 0))))
                     .addElement(
                             'T',
                             ofChain(
-                                    ofHatchAdder(ExtremeHeatExchanger::addClassicOutputToMachineList, 48, 2),
-                                    ofHatchAdder(ExtremeHeatExchanger::addMaintenanceToMachineList, 48, 2),
+                                    buildHatchAdder(ExtremeHeatExchanger.class)
+                                            .atLeast(GT_HatchElement.OutputHatch, GT_HatchElement.Maintenance)
+                                            .casingIndex(48)
+                                            .dot(1)
+                                            .build(),
                                     onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 0))))
-                    .addElement('F', ofHatchAdder(ExtremeHeatExchanger::addHotFluidInputToMachineList, 48, 3))
-                    .addElement('E', ofHatchAdder(ExtremeHeatExchanger::addColdFluidOutputToMachineList, 48, 4))
+                    .addElement(
+                            'F',
+                            buildHatchAdder(ExtremeHeatExchanger.class)
+                                    .atLeast(EHEHatches.HotInputHatch)
+                                    .casingIndex(48)
+                                    .dot(3)
+                                    .build())
+                    .addElement(
+                            'E',
+                            buildHatchAdder(ExtremeHeatExchanger.class)
+                                    .atLeast(EHEHatches.ColdOutputHatch)
+                                    .casingIndex(48)
+                                    .dot(4)
+                                    .build())
                     .addElement(
                             'C',
                             ofChain(
@@ -331,4 +356,44 @@ public class ExtremeHeatExchanger extends GT_MetaTileEntity_TooltipMultiBlockBas
         }
         return new ITexture[] {casingTexturePages[0][48]};
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 2, 5, 0, elementBudget, source, actor, false, true);
+    }
+
+    private enum EHEHatches implements IHatchElement<ExtremeHeatExchanger> {
+        HotInputHatch(ExtremeHeatExchanger::addHotFluidInputToMachineList, GT_MetaTileEntity_Hatch_Input.class) {
+            @Override
+            public long count(ExtremeHeatExchanger t) {
+                if (t.mHotFluidHatch == null) return 0;
+                return 1;
+            }
+        },
+        ColdOutputHatch(ExtremeHeatExchanger::addColdFluidOutputToMachineList, GT_MetaTileEntity_Hatch_Output.class) {
+            @Override
+            public long count(ExtremeHeatExchanger t) {
+                if (t.mCooledFluidHatch == null) return 0;
+                return 1;
+            }
+        };
+
+        private final List<Class<? extends IMetaTileEntity>> mteClasses;
+        private final IGT_HatchAdder<ExtremeHeatExchanger> adder;
+
+        EHEHatches(IGT_HatchAdder<ExtremeHeatExchanger> adder, Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Collections.unmodifiableList(Arrays.asList(mteClasses));
+            this.adder = adder;
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        public IGT_HatchAdder<? super ExtremeHeatExchanger> adder() {
+            return adder;
+        }
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
index f964303394..80f5757e83 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java
@@ -3,13 +3,15 @@ package goodgenerator.blocks.tileEntity;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
 import static gregtech.api.enums.GT_Values.V;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import com.github.bartimaeusnek.crossmod.tectech.TecTechEnabledMulti;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyTunnel;
 import com.gtnewhorizon.structurelib.StructureLibAPI;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.IStructureElement;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
@@ -17,6 +19,7 @@ import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockB
 import goodgenerator.loader.Loaders;
 import goodgenerator.util.DescTextLocalization;
 import goodgenerator.util.MyRecipeAdder;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
@@ -30,6 +33,7 @@ import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import java.util.List;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.StatCollector;
@@ -37,7 +41,7 @@ import net.minecraft.world.World;
 import net.minecraftforge.fluids.FluidStack;
 
 public class FuelRefineFactory extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
-        implements TecTechEnabledMulti, IConstructable {
+        implements TecTechEnabledMulti, IConstructable, ISurvivalConstructable {
 
     private IStructureDefinition<FuelRefineFactory> multiDefinition = null;
     private int Tier = -1;
@@ -95,9 +99,16 @@ public class FuelRefineFactory extends GT_MetaTileEntity_TooltipMultiBlockBase_E
                     }))
                     .addElement(
                             'X',
-                            ofChain(
-                                    ofHatchAdder(FuelRefineFactory::addToFRFList, 179, Loaders.FRF_Casings, 0),
-                                    ofBlock(Loaders.FRF_Casings, 0)))
+                            buildHatchAdder(FuelRefineFactory.class)
+                                    .atLeast(
+                                            GT_HatchElement.Maintenance,
+                                            GT_HatchElement.InputHatch,
+                                            GT_HatchElement.InputBus,
+                                            GT_HatchElement.OutputHatch,
+                                            HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
+                                    .casingIndex(50)
+                                    .dot(1)
+                                    .buildAndChain(ofBlock(Loaders.FRF_Casings, 0)))
                     .addElement('C', ofBlock(Loaders.FRF_Casings, 0))
                     .addElement('G', ofBlock(Loaders.fieldRestrictingGlass, 0))
                     .addElement(
@@ -358,4 +369,10 @@ public class FuelRefineFactory extends GT_MetaTileEntity_TooltipMultiBlockBase_E
         }
         return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(179)};
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 7, 12, 1, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java
index 6af68c59ea..080bb188bc 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java
@@ -2,11 +2,13 @@ package goodgenerator.blocks.tileEntity;
 
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
@@ -15,6 +17,7 @@ import goodgenerator.items.MyMaterial;
 import goodgenerator.loader.Loaders;
 import goodgenerator.util.DescTextLocalization;
 import goodgenerator.util.ItemRefer;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
@@ -31,6 +34,7 @@ import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
@@ -41,7 +45,8 @@ import thaumcraft.api.aspects.Aspect;
 import thaumcraft.api.aspects.AspectList;
 import thaumcraft.common.config.ConfigBlocks;
 
-public class LargeEssentiaGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class LargeEssentiaGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     private IStructureDefinition<LargeEssentiaGenerator> multiDefinition = null;
     protected int mStableValue = 0;
@@ -218,7 +223,14 @@ public class LargeEssentiaGenerator extends GT_MetaTileEntity_TooltipMultiBlockB
                     .addElement(
                             'X',
                             ofChain(
-                                    ofHatchAdder(LargeEssentiaGenerator::addLargeEssentiaGeneratorList, 1536, 1),
+                                    buildHatchAdder(LargeEssentiaGenerator.class)
+                                            .atLeast(
+                                                    HatchElement.DynamoMulti.or(GT_HatchElement.Dynamo),
+                                                    GT_HatchElement.Maintenance,
+                                                    GT_HatchElement.InputHatch)
+                                            .casingIndex(1536)
+                                            .dot(1)
+                                            .build(),
                                     ofBlock(Loaders.magicCasing, 0),
                                     ofTileAdder(LargeEssentiaGenerator::addEssentiaHatch, Loaders.magicCasing, 0)))
                     .build();
@@ -556,4 +568,10 @@ public class LargeEssentiaGenerator extends GT_MetaTileEntity_TooltipMultiBlockB
         int type = LargeEssentiaEnergyData.getAspectTypeIndex(aspect);
         return type != -1 && (mUpgrade & (1 << type)) != 0;
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 4, 0, 4, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
index 900f527344..0c5b28b2f2 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
@@ -2,17 +2,20 @@ package goodgenerator.blocks.tileEntity;
 
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
 import goodgenerator.crossmod.LoadedList;
 import goodgenerator.loader.Loaders;
 import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.IIconContainer;
 import gregtech.api.interfaces.ITexture;
@@ -25,6 +28,7 @@ import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import java.util.ArrayList;
 import java.util.Map;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
@@ -38,7 +42,8 @@ import thaumcraft.api.visnet.VisNetHandler;
 import thaumcraft.common.config.ConfigBlocks;
 import thaumcraft.common.lib.crafting.ThaumcraftCraftingManager;
 
-public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     private static final IIconContainer textureFontOn =
             new Textures.BlockIcons.CustomIcon("icons/LargeEssentiaSmeltery_On");
@@ -148,16 +153,27 @@ public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBa
                     .addElement(
                             'A',
                             ofChain(
-                                    ofHatchAdder(LargeEssentiaSmeltery::addMaintenanceToMachineList, CASING_INDEX, 1),
-                                    ofHatchAdder(LargeEssentiaSmeltery::addInputToMachineList, CASING_INDEX, 1),
-                                    ofHatchAdder(LargeEssentiaSmeltery::addEnergyHatchToMachineList, CASING_INDEX, 1),
+                                    buildHatchAdder(LargeEssentiaSmeltery.class)
+                                            .atLeast(
+                                                    GT_HatchElement.Maintenance,
+                                                    GT_HatchElement.Energy,
+                                                    GT_HatchElement.InputBus)
+                                            .casingIndex(CASING_INDEX)
+                                            .dot(1)
+                                            .build(),
                                     ofTileAdder(
                                             LargeEssentiaSmeltery::addEssentiaOutputHatchToMachineList,
                                             Loaders.magicCasing,
                                             0),
                                     onElementPass(
                                             LargeEssentiaSmeltery::onCasingFound, ofBlock(Loaders.magicCasing, 0))))
-                    .addElement('B', ofHatchAdder(LargeEssentiaSmeltery::addMufflerToMachineList, CASING_INDEX, 2))
+                    .addElement(
+                            'B',
+                            buildHatchAdder(LargeEssentiaSmeltery.class)
+                                    .atLeast(GT_HatchElement.Muffler)
+                                    .casingIndex(CASING_INDEX)
+                                    .dot(2)
+                                    .build())
                     .build();
         }
         return this.multiDefinition;
@@ -508,4 +524,22 @@ public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBa
     protected void maintenance_EM() {
         super.maintenance_EM();
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        int built = 0;
+        built += survivialBuildPiece(
+                STRUCTURE_PIECE_FIRST, stackSize, 2, 2, 0, elementBudget, source, actor, false, true);
+        int lenght = stackSize.stackSize + 2;
+        if (lenght > MAX_CONFIGURABLE_LENGTH) lenght = MAX_CONFIGURABLE_LENGTH + 2;
+        built += survivialBuildPiece(
+                STRUCTURE_PIECE_LAST, stackSize, 2, 2, lenght + 1, elementBudget - built, source, actor, false, true);
+        while (lenght > 0) {
+            built += survivialBuildPiece(
+                    STRUCTURE_PIECE_LATER, stackSize, 2, 2, lenght, elementBudget - built, source, actor, false, true);
+            lenght--;
+        }
+        return built;
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java
index 2aefa6a5d4..5098c5c5ef 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java
@@ -57,7 +57,7 @@ public class LargeFusionComputer1 extends LargeFusionComputer {
                 .addCasingInfo("LuV Machine Casing", 1664)
                 .addCasingInfo("Ameliorated Superconduct Coil", 560)
                 .addCasingInfo("Naquadah Alloy Frame Boxes", 128)
-                .addCasingInfo("Chrome Reinforced Borosilicate Glass Block", 63)
+                .addCasingInfo("Rhodium-Plated Palladium Reinforced Borosilicate Glass Block", 63)
                 .addEnergyHatch("1-32, Hint block with dot 3", 3)
                 .addInputHatch("2-16, Hint block with dot 1", 1)
                 .addOutputHatch("1-16, Hint block with dot 2", 2)
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java
index ad6ab36a93..40404a3c16 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java
@@ -64,7 +64,7 @@ public class LargeFusionComputer4 extends LargeFusionComputerPP {
                 .addCasingInfo("Fusion Machine Casing MK III", 1664)
                 .addCasingInfo("Compact Fusion Coil MK-II Prototype", 560)
                 .addCasingInfo("Infinity Catalyst Frame Box", 128)
-                .addCasingInfo("Uranium Reinforced Borosilicate Glass Block", 63)
+                .addCasingInfo("Neutronium Reinforced Borosilicate Glass Block", 63)
                 .addEnergyHatch("1-32, Hint block with dot 3", 3)
                 .addInputHatch("2-16, Hint block with dot 1", 1)
                 .addOutputHatch("1-16, Hint block with dot 2", 2)
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java
index 3f7ab9cdc3..5057f6471f 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java
@@ -60,7 +60,7 @@ public class LargeFusionComputer5 extends LargeFusionComputerPP {
                 .addCasingInfo("Fusion Machine Casing MK IV", 1664)
                 .addCasingInfo("Compact Fusion Coil MK-II Finaltype", 560)
                 .addCasingInfo("Infinity Frame Box", 128)
-                .addCasingInfo("Europium Reinforced Borosilicate Glass Block", 63)
+                .addCasingInfo("Cosmic Neutronium Reinforced Borosilicate Glass Block", 63)
                 .addEnergyHatch("1-32, Hint block with dot 3", 3)
                 .addInputHatch("2-16, Hint block with dot 1", 1)
                 .addOutputHatch("1-16, Hint block with dot 2", 2)
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java b/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java
index b1d4518e27..1cfc589372 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java
@@ -3,7 +3,7 @@ package goodgenerator.blocks.tileEntity;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.main.GG_Config_Loader.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import com.github.bartimaeusnek.bartworks.util.Pair;
 import com.github.bartimaeusnek.crossmod.tectech.TecTechEnabledMulti;
@@ -11,6 +11,8 @@ import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_H
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyTunnel;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
@@ -20,6 +22,7 @@ import goodgenerator.util.CrackRecipeAdder;
 import goodgenerator.util.DescTextLocalization;
 import goodgenerator.util.MyRecipeAdder;
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
@@ -34,6 +37,7 @@ import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.EnumChatFormatting;
@@ -41,7 +45,7 @@ import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
 
 public class MultiNqGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
-        implements TecTechEnabledMulti, IConstructable {
+        implements TecTechEnabledMulti, IConstructable, ISurvivalConstructable {
 
     protected IStructureDefinition<MultiNqGenerator> multiDefinition = null;
     protected long leftEnergy = 0;
@@ -122,8 +126,15 @@ public class MultiNqGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                     .addElement(
                             'X',
                             ofChain(
-                                    ofHatchAdder(
-                                            MultiNqGenerator::addToGeneratorList, 44, GregTech_API.sBlockCasings3, 12),
+                                    buildHatchAdder(MultiNqGenerator.class)
+                                            .atLeast(
+                                                    HatchElement.DynamoMulti.or(GT_HatchElement.Dynamo),
+                                                    GT_HatchElement.InputHatch,
+                                                    GT_HatchElement.OutputHatch,
+                                                    GT_HatchElement.Maintenance)
+                                            .casingIndex(44)
+                                            .dot(1)
+                                            .build(),
                                     ofBlock(GregTech_API.sBlockCasings3, 12)))
                     .addElement('A', ofBlock(GregTech_API.sBlockCasings3, 12))
                     .addElement('N', ofBlock(Loaders.radiationProtectionSteelFrame, 0))
@@ -424,4 +435,10 @@ public class MultiNqGenerator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
     public List<GT_MetaTileEntity_Hatch_EnergyMulti> getTecTechEnergyMultis() {
         return new ArrayList<>();
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 3, 7, 0, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java b/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java
index ea3d637a47..a524146fed 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java
@@ -2,10 +2,12 @@ package goodgenerator.blocks.tileEntity;
 
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static goodgenerator.util.StructureHelper.addFrame;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.ofFrame;
 
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator;
@@ -19,8 +21,10 @@ import goodgenerator.util.DescTextLocalization;
 import goodgenerator.util.ItemRefer;
 import goodgenerator.util.MyRecipeAdder;
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IHatchElement;
 import gregtech.api.interfaces.IIconContainer;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
@@ -28,13 +32,11 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
 import gregtech.api.objects.XSTR;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
-import gregtech.api.util.GT_Recipe;
-import gregtech.api.util.GT_Utility;
+import gregtech.api.util.*;
 import ic2.core.Ic2Items;
-import java.util.ArrayList;
-import java.util.Collection;
+import java.util.*;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -42,7 +44,8 @@ import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.util.StatCollector;
 import net.minecraftforge.fluids.FluidStack;
 
-public class NeutronActivator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class NeutronActivator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     protected IStructureDefinition<NeutronActivator> multiDefinition = null;
     protected final ArrayList<NeutronAccelerator> mNeutronAccelerator = new ArrayList<>();
@@ -209,19 +212,31 @@ public class NeutronActivator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                     .addElement(
                             'C',
                             ofChain(
-                                    ofHatchAdder(NeutronActivator::addClassicInputToMachineList, 49, 1),
-                                    onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 1))))
+                                    buildHatchAdder(NeutronActivator.class)
+                                            .atLeast(GT_HatchElement.InputHatch, GT_HatchElement.InputBus)
+                                            .casingIndex(49)
+                                            .dot(1)
+                                            .build(),
+                                    onElementPass(
+                                            NeutronActivator::onCasingFound, ofBlock(GregTech_API.sBlockCasings4, 1))))
                     .addElement('D', ofBlock(GregTech_API.sBlockCasings2, 6))
-                    .addElement('F', addFrame(Materials.Steel))
+                    .addElement('F', ofFrame(Materials.Steel))
                     .addElement('G', ofBlock(Block.getBlockFromItem(Ic2Items.reinforcedGlass.getItem()), 0))
                     .addElement('P', ofBlock(Loaders.speedingPipe, 0))
                     .addElement(
                             'X',
                             ofChain(
-                                    ofHatchAdder(NeutronActivator::addClassicOutputToMachineList, 49, 2),
-                                    ofHatchAdder(NeutronActivator::addMaintenanceToMachineList, 49, 2),
-                                    ofHatchAdder(NeutronActivator::addAcceleratorAndSensor, 49, 2),
-                                    onElementPass(x -> x.casingAmount++, ofBlock(GregTech_API.sBlockCasings4, 1))))
+                                    buildHatchAdder(NeutronActivator.class)
+                                            .atLeast(
+                                                    GT_HatchElement.OutputHatch,
+                                                    GT_HatchElement.OutputBus,
+                                                    NeutronHatchElement.NeutronAccelerator,
+                                                    NeutronHatchElement.NeutronSensor)
+                                            .casingIndex(49)
+                                            .dot(2)
+                                            .build(),
+                                    onElementPass(
+                                            NeutronActivator::onCasingFound, ofBlock(GregTech_API.sBlockCasings4, 1))))
                     .build();
         }
         return multiDefinition;
@@ -406,4 +421,57 @@ public class NeutronActivator extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
         }
         return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(49)};
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+
+        int built = 0;
+        built += survivialBuildPiece(NA_BOTTOM, stackSize, 2, 0, 0, elementBudget, source, actor, false, true);
+        int heights = stackSize.stackSize + 3;
+        built += survivialBuildPiece(
+                NA_TOP, stackSize, 2, heights + 1, 0, elementBudget - built, source, actor, false, true);
+        while (heights > 0) {
+            built += survivialBuildPiece(
+                    NA_MID, stackSize, 2, heights, 0, elementBudget - built, source, actor, false, true);
+            heights--;
+        }
+        return built;
+    }
+
+    protected void onCasingFound() {
+        casingAmount++;
+    }
+
+    private enum NeutronHatchElement implements IHatchElement<NeutronActivator> {
+        NeutronSensor(NeutronActivator::addAcceleratorAndSensor, NeutronSensor.class) {
+            @Override
+            public long count(NeutronActivator t) {
+                return t.mNeutronSensor.size();
+            }
+        },
+        NeutronAccelerator(NeutronActivator::addAcceleratorAndSensor, NeutronAccelerator.class) {
+            @Override
+            public long count(NeutronActivator t) {
+                return t.mNeutronAccelerator.size();
+            }
+        };
+        private final List<Class<? extends IMetaTileEntity>> mteClasses;
+        private final IGT_HatchAdder<NeutronActivator> adder;
+
+        @SafeVarargs
+        NeutronHatchElement(IGT_HatchAdder<NeutronActivator> adder, Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Collections.unmodifiableList(Arrays.asList(mteClasses));
+            this.adder = adder;
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        public IGT_HatchAdder<? super NeutronActivator> adder() {
+            return adder;
+        }
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java b/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java
index 58988a7805..a361f2ba38 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java
@@ -4,15 +4,18 @@ import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.ge
 import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static goodgenerator.util.StructureHelper.addTieredBlock;
+import static gregtech.api.enums.GT_HatchElement.*;
+import static gregtech.api.enums.GT_HatchElement.Muffler;
 import static gregtech.api.util.GT_StructureUtility.ofFrame;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
 
 import com.github.bartimaeusnek.bartworks.util.Pair;
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizon.structurelib.structure.StructureUtility;
 import cpw.mods.fml.common.network.NetworkRegistry;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
 import goodgenerator.loader.Loaders;
@@ -30,19 +33,24 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.*;
 import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_HatchElementBuilder;
 import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import ic2.core.Ic2Items;
 import java.util.ArrayList;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.StatCollector;
 import net.minecraftforge.fluids.FluidStack;
 
-public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK");
     private static final IIconContainer textureFontOn_Glow =
@@ -79,24 +87,42 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                     }))
                     .addElement(
                             'C',
-                            ofChain(
-                                    ofHatchAdder(PreciseAssembler::addToPAssList, 0, 1),
-                                    onElementPass(
+                            GT_HatchElementBuilder.<PreciseAssembler>builder()
+                                    .atLeast(
+                                            InputBus,
+                                            InputHatch,
+                                            OutputHatch,
+                                            OutputBus,
+                                            Maintenance,
+                                            Muffler,
+                                            HatchElement.EnergyMulti.or(Energy))
+                                    .adder(PreciseAssembler::addToPAssList)
+                                    .casingIndex(1539)
+                                    .dot(1)
+                                    .buildAndChain(onElementPass(
                                             x -> x.casingAmount++,
-                                            addTieredBlock(
-                                                    Loaders.preciseUnitCasing,
+                                            StructureUtility.ofBlocksTiered(
+                                                    (block, meta) -> block == Loaders.preciseUnitCasing ? meta : -2,
+                                                    IntStream.range(0, 3)
+                                                            .mapToObj(meta -> org.apache.commons.lang3.tuple.Pair.of(
+                                                                    Loaders.preciseUnitCasing, meta))
+                                                            .collect(Collectors.toList()),
+                                                    -1,
                                                     PreciseAssembler::setCasingTier,
-                                                    PreciseAssembler::getCasingTier,
-                                                    3))))
+                                                    PreciseAssembler::getCasingTier))))
                     .addElement('F', ofFrame(Materials.TungstenSteel))
                     .addElement('G', ofBlock(Block.getBlockFromItem(Ic2Items.reinforcedGlass.getItem()), 0))
                     .addElement(
                             'M',
-                            addTieredBlock(
-                                    GregTech_API.sBlockCasings1,
+                            StructureUtility.ofBlocksTiered(
+                                    (block, meta) -> block == GregTech_API.sBlockCasings1 ? meta : -2,
+                                    IntStream.range(0, 10)
+                                            .mapToObj(meta -> org.apache.commons.lang3.tuple.Pair.of(
+                                                    GregTech_API.sBlockCasings1, meta))
+                                            .collect(Collectors.toList()),
+                                    -1,
                                     PreciseAssembler::setMachineTier,
-                                    PreciseAssembler::getMachineTier,
-                                    10))
+                                    PreciseAssembler::getMachineTier))
                     .build();
         }
         return multiDefinition;
@@ -179,7 +205,7 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
 
     @Override
     public boolean checkRecipe_EM(ItemStack itemStack) {
-        if (casingTier <= 0 || machineTier <= 0) return false;
+        if (casingTier < 0 || machineTier < 0) return false;
         FluidStack[] inputFluids = getStoredFluids().toArray(new FluidStack[0]);
         if (this.mode == 0) {
             for (GT_MetaTileEntity_Hatch_InputBus bus : mInputBusses) {
@@ -191,7 +217,7 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                                 Math.min(getMachineVoltageLimit(), getMaxInputEnergyPA()),
                                 inputFluids,
                                 getStoredItemFromHatch(bus));
-                if (tRecipe != null && tRecipe.mSpecialValue <= casingTier) {
+                if (tRecipe != null && tRecipe.mSpecialValue <= (casingTier + 1)) {
                     this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000);
                     this.mEfficiencyIncrease = 10000;
                     tRecipe.isRecipeInputEqual(true, inputFluids, getStoredItemFromHatch(bus));
@@ -223,7 +249,7 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                     this.mEfficiencyIncrease = 10000;
                     long fullInput = getMaxInputEnergy_EM();
                     int pall = handleParallelRecipe(tRecipe, inputFluids, getStoredItemFromHatch(bus), (int)
-                            Math.min((long) Math.pow(2, 4 + casingTier), fullInput / tRecipe.mEUt));
+                            Math.min((long) Math.pow(2, 4 + (casingTier + 1)), fullInput / tRecipe.mEUt));
                     if (pall <= 0) continue;
                     Pair<ArrayList<FluidStack>, ArrayList<ItemStack>> Outputs = getMultiOutput(tRecipe, pall);
                     long lEUt = (long) tRecipe.mEUt * (long) pall;
@@ -278,9 +304,9 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
     }
 
     public long getMachineVoltageLimit() {
-        if (machineTier <= 0) return 0;
-        if (machineTier >= 10) return GT_Values.V[energyHatchTier];
-        else return GT_Values.V[Math.min(machineTier - 1, energyHatchTier)];
+        if (machineTier < 0) return 0;
+        if (machineTier > 9) return GT_Values.V[energyHatchTier];
+        else return GT_Values.V[Math.min(machineTier, energyHatchTier)];
     }
 
     public ItemStack[] getStoredItemFromHatch(GT_MetaTileEntity_Hatch_InputBus tHatch) {
@@ -342,15 +368,24 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
     }
 
     @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) {
+            return -1;
+        } else {
+            return survivialBuildPiece(mName, stackSize, 4, 4, 0, elementBudget, source, actor, false, true);
+        }
+    }
+
+    @Override
     public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
-        this.machineTier = 0;
+        this.machineTier = -1;
         this.casingAmount = 0;
-        this.casingTier = 0;
+        this.casingTier = -1;
         this.energyHatchTier = 0;
         if (structureCheck_EM(mName, 4, 4, 0)) {
             energyHatchTier = checkEnergyHatchTier();
-            if (casingTier != 0) {
-                reUpdate(1538 + casingTier);
+            if (casingTier >= 0) {
+                reUpdate(1539 + casingTier);
             }
             GoodGenerator.CHANNEL.sendToAllAround(
                     new MessageResetTileTexture(aBaseMetaTileEntity, casingTier),
@@ -361,8 +396,8 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
                             aBaseMetaTileEntity.getZCoord(),
                             16));
             return casingAmount >= 42
-                    && machineTier != 0
-                    && casingTier != 0
+                    && machineTier >= 0
+                    && casingTier >= 0
                     && mMaintenanceHatches.size() == 1
                     && !mMufflerHatches.isEmpty();
         }
@@ -481,21 +516,20 @@ public class PreciseAssembler extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
             byte aColorIndex,
             boolean aActive,
             boolean aRedstone) {
-        int t = 1;
-        if (getCasingTier() != 0) t = getCasingTier();
+        int t = Math.max(getCasingTier(), 0);
         if (aSide == aFacing) {
             if (aActive)
                 return new ITexture[] {
-                    Textures.BlockIcons.getCasingTextureForId(1538 + t),
+                    Textures.BlockIcons.getCasingTextureForId(1539 + t),
                     TextureFactory.of(textureFontOn),
                     TextureFactory.builder().addIcon(textureFontOn_Glow).glow().build()
                 };
             else
                 return new ITexture[] {
-                    Textures.BlockIcons.getCasingTextureForId(1538 + t),
+                    Textures.BlockIcons.getCasingTextureForId(1539 + t),
                     TextureFactory.of(textureFontOff),
                     TextureFactory.builder().addIcon(textureFontOff_Glow).glow().build()
                 };
-        } else return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(1538 + t)};
+        } else return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(1539 + t)};
     }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java b/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java
index e2afb171a2..a5b3dd4158 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java
@@ -4,10 +4,12 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
 import static gregtech.api.enums.Textures.BlockIcons.*;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
@@ -15,6 +17,7 @@ import goodgenerator.crossmod.LoadedList;
 import goodgenerator.loader.Loaders;
 import goodgenerator.util.DescTextLocalization;
 import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
@@ -27,12 +30,14 @@ import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
 
-public class UniversalChemicalFuelEngine extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class UniversalChemicalFuelEngine extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     protected final double DIESEL_EFFICIENCY_COEFFICIENT = 0.04D;
     protected final double GAS_EFFICIENCY_COEFFICIENT = 0.04D;
@@ -118,10 +123,34 @@ public class UniversalChemicalFuelEngine extends GT_MetaTileEntity_TooltipMultiB
                         {"TTWTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT", "TTTTT"}
                     }))
                     .addElement('T', ofBlock(GregTech_API.sBlockCasings4, 2))
-                    .addElement('W', ofHatchAdder(UniversalChemicalFuelEngine::addMaintenance, 50, 1))
-                    .addElement('M', ofHatchAdder(UniversalChemicalFuelEngine::addMuffler, 50, 2))
-                    .addElement('S', ofHatchAdder(UniversalChemicalFuelEngine::addInputHatch, 50, 3))
-                    .addElement('E', ofHatchAdder(UniversalChemicalFuelEngine::addDynamoHatch, 50, 4))
+                    .addElement(
+                            'W',
+                            buildHatchAdder(UniversalChemicalFuelEngine.class)
+                                    .atLeast(GT_HatchElement.Maintenance)
+                                    .casingIndex(50)
+                                    .dot(1)
+                                    .build())
+                    .addElement(
+                            'M',
+                            buildHatchAdder(UniversalChemicalFuelEngine.class)
+                                    .atLeast(GT_HatchElement.Muffler)
+                                    .casingIndex(50)
+                                    .dot(2)
+                                    .build())
+                    .addElement(
+                            'S',
+                            buildHatchAdder(UniversalChemicalFuelEngine.class)
+                                    .atLeast(GT_HatchElement.InputHatch)
+                                    .casingIndex(50)
+                                    .dot(3)
+                                    .build())
+                    .addElement(
+                            'E',
+                            buildHatchAdder(UniversalChemicalFuelEngine.class)
+                                    .atLeast(GT_HatchElement.Dynamo)
+                                    .casingIndex(50)
+                                    .dot(4)
+                                    .build())
                     .addElement('P', ofBlock(GregTech_API.sBlockCasings2, 14))
                     .addElement('C', ofBlock(Loaders.titaniumPlatedCylinder, 0))
                     .addElement('G', ofBlock(GregTech_API.sBlockCasings2, 4))
@@ -361,4 +390,10 @@ public class UniversalChemicalFuelEngine extends GT_MetaTileEntity_TooltipMultiB
     public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
         return new UniversalChemicalFuelEngine(this.mName);
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(mName, stackSize, 2, 2, 0, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java b/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java
index efff821da3..a7395636df 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java
@@ -2,15 +2,12 @@ package goodgenerator.blocks.tileEntity;
 
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
-import static goodgenerator.util.StructureHelper.addFrame;
-import static goodgenerator.util.StructureHelper.addTieredBlock;
 import static gregtech.api.util.GT_StructureUtility.*;
 
-import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
+import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
-import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
-import com.gtnewhorizon.structurelib.structure.IStructureElement;
-import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.*;
 import goodgenerator.blocks.tileEntity.GTMetaTileEntity.YOTTAHatch;
 import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_TooltipMultiBlockBase_EM;
 import goodgenerator.client.GUI.YOTTankGUIClient;
@@ -18,6 +15,7 @@ import goodgenerator.common.container.YOTTankGUIContainer;
 import goodgenerator.loader.Loaders;
 import goodgenerator.util.CharExchanger;
 import goodgenerator.util.DescTextLocalization;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.IIconContainer;
@@ -32,6 +30,7 @@ import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.List;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -40,7 +39,8 @@ import net.minecraft.util.StatCollector;
 import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
 
-public class YottaFluidTank extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public class YottaFluidTank extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK");
     private static final IIconContainer textureFontOn_Glow =
@@ -184,24 +184,42 @@ public class YottaFluidTank extends GT_MetaTileEntity_TooltipMultiBlockBase_EM i
                     .addElement('C', ofBlock(Loaders.yottaFluidTankCasing, 0))
                     .addElement(
                             'G',
-                            addTieredBlock(
-                                    ItemRegistry.bw_realglas, YottaFluidTank::setMeta, YottaFluidTank::getMeta, 14))
+                            withChannel(
+                                    "glass",
+                                    BorosilicateGlass.ofBoroGlass(
+                                            (byte) 0, (byte) 1, Byte.MAX_VALUE, YottaFluidTank::setMeta, te ->
+                                                    (byte) te.getMeta())))
                     .addElement('R', ofChain(cells(10)))
-                    .addElement('F', addFrame(Materials.Steel))
+                    .addElement('F', ofFrame(Materials.Steel))
                     .addElement(
                             'I',
-                            ofHatchAdderOptional(YottaFluidTank::addInput, 1537, 1, Loaders.yottaFluidTankCasing, 0))
+                            ofChain(
+                                    buildHatchAdder(YottaFluidTank.class)
+                                            .atLeast(GT_HatchElement.InputHatch)
+                                            .adder(YottaFluidTank::addInput)
+                                            .casingIndex(1537)
+                                            .dot(1)
+                                            .build(),
+                                    ofBlock(Loaders.yottaFluidTankCasing, 0)))
                     .addElement(
                             'M',
-                            ofHatchAdderOptional(
-                                    YottaFluidTank::addClassicMaintenanceToMachineList,
-                                    1537,
-                                    2,
-                                    Loaders.yottaFluidTankCasing,
-                                    0))
+                            ofChain(
+                                    buildHatchAdder(YottaFluidTank.class)
+                                            .atLeast(GT_HatchElement.Maintenance)
+                                            .casingIndex(1537)
+                                            .dot(2)
+                                            .build(),
+                                    ofBlock(Loaders.yottaFluidTankCasing, 0)))
                     .addElement(
                             'O',
-                            ofHatchAdderOptional(YottaFluidTank::addOutput, 1537, 3, Loaders.yottaFluidTankCasing, 0))
+                            ofChain(
+                                    buildHatchAdder(YottaFluidTank.class)
+                                            .atLeast(GT_HatchElement.OutputHatch)
+                                            .adder(YottaFluidTank::addOutput)
+                                            .casingIndex(1537)
+                                            .dot(1)
+                                            .build(),
+                                    ofBlock(Loaders.yottaFluidTankCasing, 0)))
                     .build();
         }
         return multiDefinition;
@@ -416,4 +434,21 @@ public class YottaFluidTank extends GT_MetaTileEntity_TooltipMultiBlockBase_EM i
                 };
         } else return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(1537)};
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        int built = 0;
+        built += survivialBuildPiece(YOTTANK_BOTTOM, stackSize, 2, 0, 0, elementBudget, source, actor, false, true);
+        int height = stackSize.stackSize;
+        if (height > 15) height = 15;
+        built += survivialBuildPiece(
+                YOTTANK_TOP, stackSize, 2, height + 2, 0, elementBudget - built, source, actor, false, true);
+        while (height > 0) {
+            built += survivialBuildPiece(
+                    YOTTANK_MID, stackSize, 2, height, 0, elementBudget - built, source, actor, false, true);
+            height--;
+        }
+        return built;
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
index 75d2b201e0..2ae630eef7 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java
@@ -5,9 +5,11 @@ package goodgenerator.blocks.tileEntity.base;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
+import static gregtech.api.enums.GT_HatchElement.*;
+import static gregtech.api.util.GT_StructureUtility.*;
 
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.IStructureElementCheckOnly;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
@@ -21,6 +23,7 @@ import gregtech.api.util.GT_Utility;
 import gregtech.common.items.GT_MetaGenerated_Tool_01;
 import java.util.ArrayList;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -30,7 +33,8 @@ import net.minecraft.util.StatCollector;
 import net.minecraftforge.fluids.FluidStack;
 
 public abstract class GT_MetaTileEntity_LargeTurbineBase
-        extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase> {
+        extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase>
+        implements ISurvivalConstructable {
     private static final String STRUCTURE_PIECE_MAIN = "main";
     private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>> STRUCTURE_DEFINITION =
             new ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>>() {
@@ -55,20 +59,12 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase
                                 },
                             }))
                             .addElement('c', lazy(t -> ofBlock(t.getCasingBlock(), t.getCasingMeta())))
-                            .addElement(
-                                    'd',
-                                    lazy(t -> ofHatchAdder(
-                                            GT_MetaTileEntity_LargeTurbineBase::addDynamoToMachineList,
-                                            t.getCasingTextureIndex(),
-                                            1)))
-                            .addElement(
-                                    'h',
-                                    lazy(t -> ofHatchAdderOptional(
-                                            GT_MetaTileEntity_LargeTurbineBase::addToMachineList,
-                                            t.getCasingTextureIndex(),
-                                            2,
-                                            t.getCasingBlock(),
-                                            t.getCasingMeta())))
+                            .addElement('d', lazy(t -> Dynamo.newAny(t.getCasingTextureIndex(), 1)))
+                            .addElement('h', lazy(t -> buildHatchAdder(GT_MetaTileEntity_LargeTurbineBase.class)
+                                    .atLeast(Maintenance, InputHatch, OutputHatch, OutputBus, InputBus, Muffler)
+                                    .casingIndex(t.getCasingTextureIndex())
+                                    .dot(2)
+                                    .buildAndChain(t.getCasingBlock(), t.getCasingMeta())))
                             .addElement('x', (IStructureElementCheckOnly<GT_MetaTileEntity_LargeTurbineBase>)
                                     (aContext, aWorld, aX, aY, aZ) -> {
                                         TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ);
@@ -313,4 +309,10 @@ public abstract class GT_MetaTileEntity_LargeTurbineBase
     public void construct(ItemStack stackSize, boolean hintsOnly) {
         buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 2, 1);
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 2, 1, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
index 5cb63e3afc..b461dfa0dd 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java
@@ -5,13 +5,15 @@ import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.ha
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static gregtech.api.enums.Textures.BlockIcons.*;
 import static gregtech.api.util.GT_StructureUtility.ofFrame;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
 
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.client.GUI.LargeFusionComputerGUIClient;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
@@ -23,10 +25,12 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Outpu
 import gregtech.api.objects.GT_ChunkManager;
 import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_HatchElementBuilder;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
@@ -36,7 +40,8 @@ import net.minecraft.world.ChunkCoordIntPair;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
-public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
+        implements IConstructable, ISurvivalConstructable {
 
     public static final String MAIN_NAME = "largeFusion";
     private boolean isLoadedChunk;
@@ -52,30 +57,24 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
                             .addElement('H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())))
                             .addElement('C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())))
                             .addElement('B', lazy(x -> ofBlock(x.getGlassBlock(), x.getGlassMeta())))
-                            .addElement(
-                                    'I',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputer::addInjector,
-                                            x.textureIndex(),
-                                            1,
-                                            x.getGlassBlock(),
-                                            x.getGlassMeta())))
-                            .addElement(
-                                    'O',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputer::addExtractor,
-                                            x.textureIndex(),
-                                            2,
-                                            x.getGlassBlock(),
-                                            x.getGlassMeta())))
-                            .addElement(
-                                    'E',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputer::addEnergyInjector,
-                                            x.textureIndex(),
-                                            3,
-                                            x.getCasingBlock(),
-                                            x.getCasingMeta())))
+                            .addElement('I', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                                    .atLeast(GT_HatchElement.InputHatch)
+                                    .adder(LargeFusionComputer::addInjector)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(1)
+                                    .buildAndChain(x.getGlassBlock(), x.getGlassMeta())))
+                            .addElement('O', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                                    .atLeast(GT_HatchElement.OutputHatch)
+                                    .adder(LargeFusionComputer::addExtractor)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(2)
+                                    .buildAndChain(x.getGlassBlock(), x.getGlassMeta())))
+                            .addElement('E', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputer>builder()
+                                    .atLeast(HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
+                                    .adder(LargeFusionComputer::addEnergyInjector)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(3)
+                                    .buildAndChain(x.getCasingBlock(), x.getCasingMeta())))
                             .addElement('F', lazy(x -> ofFrame(x.getFrameBox())))
                             .build();
                 }
@@ -135,7 +134,6 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     public int textureIndex() {
         return 53;
     }
-    ;
 
     public abstract ITexture getTextureOverlay();
 
@@ -172,6 +170,25 @@ public abstract class LargeFusionComputer extends GT_MetaTileEntity_TooltipMulti
     }
 
     @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) {
+            return -1;
+        } else {
+            return survivialBuildPiece(
+                    MAIN_NAME,
+                    stackSize,
+                    23,
+                    3,
+                    40,
+                    elementBudget >= 200 ? elementBudget : Math.min(200, elementBudget * 5),
+                    source,
+                    actor,
+                    false,
+                    true);
+        }
+    }
+
+    @Override
     public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) {
             // if machine has stopped, stop chunkloading
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
index aad7991984..aa29b0c35b 100644
--- a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
+++ b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java
@@ -5,13 +5,15 @@ import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.ha
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static gregtech.api.enums.Textures.BlockIcons.*;
 import static gregtech.api.util.GT_StructureUtility.ofFrame;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
 
 import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti;
 import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
 import com.gtnewhorizon.structurelib.structure.StructureDefinition;
 import goodgenerator.client.GUI.LargeFusionComputerGUIClient;
+import gregtech.api.enums.GT_HatchElement;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.Textures;
 import gregtech.api.interfaces.ITexture;
@@ -23,10 +25,12 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Outpu
 import gregtech.api.objects.GT_ChunkManager;
 import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_HatchElementBuilder;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import java.util.ArrayList;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
@@ -37,7 +41,7 @@ import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
 
 public abstract class LargeFusionComputerPP extends GT_MetaTileEntity_TooltipMultiBlockBase_EM
-        implements IConstructable {
+        implements IConstructable, ISurvivalConstructable {
 
     public static final String MAIN_NAME = "largeFusionPP";
     private boolean isLoadedChunk;
@@ -53,30 +57,24 @@ public abstract class LargeFusionComputerPP extends GT_MetaTileEntity_TooltipMul
                             .addElement('H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())))
                             .addElement('C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())))
                             .addElement('B', lazy(x -> ofBlock(x.getGlassBlock(), x.getGlassMeta())))
-                            .addElement(
-                                    'I',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputerPP::addInjector,
-                                            x.textureIndex(),
-                                            1,
-                                            x.getGlassBlock(),
-                                            x.getGlassMeta())))
-                            .addElement(
-                                    'O',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputerPP::addExtractor,
-                                            x.textureIndex(),
-                                            2,
-                                            x.getGlassBlock(),
-                                            x.getGlassMeta())))
-                            .addElement(
-                                    'E',
-                                    lazy(x -> ofHatchAdderOptional(
-                                            LargeFusionComputerPP::addEnergyInjector,
-                                            x.textureIndex(),
-                                            3,
-                                            x.getCasingBlock(),
-                                            x.getCasingMeta())))
+                            .addElement('I', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputerPP>builder()
+                                    .atLeast(GT_HatchElement.InputHatch)
+                                    .adder(LargeFusionComputerPP::addInjector)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(1)
+                                    .buildAndChain(x.getGlassBlock(), x.getGlassMeta())))
+                            .addElement('O', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputerPP>builder()
+                                    .atLeast(GT_HatchElement.OutputHatch)
+                                    .adder(LargeFusionComputerPP::addExtractor)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(2)
+                                    .buildAndChain(x.getGlassBlock(), x.getGlassMeta())))
+                            .addElement('E', lazy(x -> GT_HatchElementBuilder.<LargeFusionComputerPP>builder()
+                                    .atLeast(HatchElement.EnergyMulti.or(GT_HatchElement.Energy))
+                                    .adder(LargeFusionComputerPP::addEnergyInjector)
+                                    .casingIndex(x.textureIndex())
+                                    .dot(3)
+                                    .buildAndChain(x.getCasingBlock(), x.getCasingMeta())))
                             .addElement('F', lazy(x -> ofFrame(x.getFrameBox())))
                             .build();
                 }
@@ -171,6 +169,25 @@ public abstract class LargeFusionComputerPP extends GT_MetaTileEntity_TooltipMul
     }
 
     @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) {
+            return -1;
+        } else {
+            return survivialBuildPiece(
+                    MAIN_NAME,
+                    stackSize,
+                    23,
+                    3,
+                    40,
+                    elementBudget >= 200 ? elementBudget : Math.min(200, elementBudget * 5),
+                    source,
+                    actor,
+                    false,
+                    true);
+        }
+    }
+
+    @Override
     public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) {
             // if machine has stopped, stop chunkloading
@@ -217,7 +234,17 @@ public abstract class LargeFusionComputerPP extends GT_MetaTileEntity_TooltipMul
                 this.mEUStore = aBaseMetaTileEntity.getStoredEU();
                 checkRecipe(mInventory[1]);
             }
-            if (--mUpdate == 0 || --mStartUpCheck == 0) {
+            if (mUpdated) {
+                mUpdate = 50;
+                mUpdated = false;
+            }
+            if (--mUpdate == 0
+                    || --mStartUpCheck == 0
+                    || cyclicUpdate_EM()
+                    || aBaseMetaTileEntity.hasWorkJustBeenEnabled()) {
+                if (mUpdate <= -1000) {
+                    mUpdate = 5000;
+                }
                 checkStructure(true, aBaseMetaTileEntity);
             }
             if (mStartUpCheck < 0) {