autoplace integration (#1117)

14 files changed, 571 insertions, 300 deletions

diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java
index 674b674b1c..09b30d2a34 100644
--- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.machines.multi;
 
+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 cpw.mods.fml.common.registry.GameRegistry;
@@ -10,83 +12,90 @@ import gregtech.api.enums.SoundResource;
 import gregtech.api.enums.Textures;
 import gregtech.api.enums.Textures.BlockIcons;
 import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.IHatchElement;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_DataAccess;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_MultiInput;
 import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_AssemblyLineUtils;
-import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
-import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.*;
 import gregtech.api.util.GT_Recipe.GT_Recipe_AssemblyLine;
-import gregtech.api.util.GT_Utility;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
-import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
-import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta;
-import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
-import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 import static gregtech.GT_Mod.GT_FML_LOGGER;
+import static gregtech.api.enums.GT_HatchElement.*;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_GLOW;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
-import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
 
-public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_AssemblyLine> {
+public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_AssemblyLine> implements ISurvivalConstructable {
 
     public ArrayList<GT_MetaTileEntity_Hatch_DataAccess> mDataAccessHatches = new ArrayList<>();
     private static final String STRUCTURE_PIECE_FIRST = "first";
-    private static final String STRUCTURE_PIECE_SECOND = "second";
     private static final String STRUCTURE_PIECE_LATER = "later";
+    private static final String STRUCTURE_PIECE_LAST = "last";
     private static final IStructureDefinition<GT_MetaTileEntity_AssemblyLine> STRUCTURE_DEFINITION = StructureDefinition.<GT_MetaTileEntity_AssemblyLine>builder()
-            .addShape(STRUCTURE_PIECE_FIRST, transpose(new String[][]{
-                    {" ", "e", " "},
-                    {"~", "l", "G"},
-                    {"g", "m", "g"},
-                    {"b", "i", "b"},
-            }))
-            .addShape(STRUCTURE_PIECE_SECOND, transpose(new String[][]{
-                    {" ", "e", " "},
-                    {"d", "l", "d"},
-                    {"g", "m", "g"},
-                    {"b", "I", "b"},
-            }))
-            .addShape(STRUCTURE_PIECE_LATER, transpose(new String[][]{
-                    {" ", "e", " "},
-                    {"d", "l", "d"},
-                    {"g", "m", "g"},
-                    {"b", "I", "b"},
-            }))
-            .addElement('G', ofBlock(GregTech_API.sBlockCasings3, 10)) // grate machine casing
-            .addElement('l', ofBlock(GregTech_API.sBlockCasings2, 9)) // assembler machine casing
-            .addElement('m', ofBlock(GregTech_API.sBlockCasings2, 5)) // assembling line casing
-            .addElement('g', ofBlockAnyMeta(GameRegistry.findBlock("IC2", "blockAlloyGlass")))
-            .addElement('e', ofHatchAdderOptional(GT_MetaTileEntity_AssemblyLine::addEnergyInputToMachineList, 16, 1, GregTech_API.sBlockCasings2, 0))
-            .addElement('d', ofHatchAdderOptional(GT_MetaTileEntity_AssemblyLine::addDataAccessToMachineList, 42, 2, GregTech_API.sBlockCasings3, 10))
-            .addElement('b', ofChain(
-                    ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addMaintenanceToMachineList, 16, 3),
-                    ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addInputHatchToMachineList, 16, 3),
-                    ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addOutputToMachineList, 16,4),
-                    ofBlock(GregTech_API.sBlockCasings2, 0)
-            ))
-            .addElement('I', ofChain(
-                    // all blocks nearby use solid steel casing, so let's use the texture of that
-                    ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addInputToMachineList, 16, 4),
-                    ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addOutputToMachineList, 16,4)
-            ))
-            .addElement('i', ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addInputToMachineList, 16, 5))
-            .build();
+        .addShape(STRUCTURE_PIECE_FIRST, transpose(new String[][]{
+            {" ", "e", " "},
+            {"~", "l", "G"},
+            {"g", "m", "g"},
+            {"b", "i", "b"},
+        }))
+        .addShape(STRUCTURE_PIECE_LATER, transpose(new String[][]{
+            {" ", "e", " "},
+            {"d", "l", "d"},
+            {"g", "m", "g"},
+            {"b", "I", "b"},
+        }))
+        .addShape(STRUCTURE_PIECE_LAST, transpose(new String[][]{
+            {" ", "e", " "},
+            {"d", "l", "d"},
+            {"g", "m", "g"},
+            {"o", "i", "b"},
+        }))
+        .addElement('G', ofBlock(GregTech_API.sBlockCasings3, 10)) // grate machine casing
+        .addElement('l', ofBlock(GregTech_API.sBlockCasings2, 9)) // assembler machine casing
+        .addElement('m', ofBlock(GregTech_API.sBlockCasings2, 5)) // assembling line casing
+        .addElement('g', ofBlockUnlocalizedName("IC2", "blockAlloyGlass", 0, true))
+        .addElement('e', ofChain(
+            Energy.newAny(16, 1),
+            ofBlock(GregTech_API.sBlockCasings2, 0)
+        ))
+        .addElement('d', ofChain(
+            DataHatchElement.DataAccess.newAny(42, 2),
+            ofBlock(GregTech_API.sBlockCasings3, 10)
+        ))
+        .addElement('b', buildHatchAdder(GT_MetaTileEntity_AssemblyLine.class)
+            .atLeast(InputHatch, InputHatch, InputHatch, InputHatch, Maintenance)
+            .casingIndex(16).dot(3)
+            .buildAndChain(
+                ofBlock(GregTech_API.sBlockCasings2, 0),
+                ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addOutputToMachineList, 16, 4)
+            )
+        )
+        .addElement('I', ofChain(
+            // all blocks nearby use solid steel casing, so let's use the texture of that
+            InputBus.newAny(16, 5),
+            ofHatchAdder(GT_MetaTileEntity_AssemblyLine::addOutputToMachineList, 16, 4)
+        ))
+        .addElement('i', InputBus.newAny(16, 5))
+        .addElement('o', OutputBus.newAny(16, 4))
+        .build();
 
     public GT_MetaTileEntity_AssemblyLine(int aID, String aName, String aNameRegional) {
         super(aID, aName, aNameRegional);
@@ -105,26 +114,26 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
     protected GT_Multiblock_Tooltip_Builder createTooltip() {
         final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
         tt.addMachineType("Assembling Line")
-                .addInfo("Controller block for the Assembling Line")
-                .addInfo("Used to make complex machine parts (LuV+)")
-                .addInfo("Does not make Assembler items")
-                .addSeparator()
-                .beginVariableStructureBlock(5, 16, 4, 4, 3, 3, false)//?
-                .addStructureInfo("From Bottom to Top, Left to Right")
-                .addStructureInfo("Layer 1 - Solid Steel Machine Casing, Input Bus (last can be Output Bus), Solid Steel Machine Casing")
-                .addStructureInfo("Layer 2 - Reinforced Glass, Assembling Line Casing, Reinforced Glass")
-                .addStructureInfo("Layer 3 - Grate Machine Casing, Assembler Machine Casing, Grate Machine Casing")
-                .addStructureInfo("Layer 4 - Empty, Solid Steel Machine Casing, Empty")
-                .addStructureInfo("Up to 16 repeating slices, each one allows for 1 more item in recipes")
-
-                .addController("Either Grate on layer 3 of the first slice")
-                .addEnergyHatch("Any layer 4 casing", 1)
-                .addMaintenanceHatch("Any layer 1 casing", 3)
-                .addInputBus("As specified on layer 1", 4, 5)
-                .addInputHatch("Any layer 1 casing", 3)
-                .addOutputBus("Replaces Input Bus on final slice or on any solid steel casing on layer 1", 4)
-                .addOtherStructurePart("Data Access Hatch", "Optional, next to controller", 2)
-                .toolTipFinisher("Gregtech");
+            .addInfo("Controller block for the Assembling Line")
+            .addInfo("Used to make complex machine parts (LuV+)")
+            .addInfo("Does not make Assembler items")
+            .addSeparator()
+            .beginVariableStructureBlock(5, 16, 4, 4, 3, 3, false)//?
+            .addStructureInfo("From Bottom to Top, Left to Right")
+            .addStructureInfo("Layer 1 - Solid Steel Machine Casing, Input Bus (last can be Output Bus), Solid Steel Machine Casing")
+            .addStructureInfo("Layer 2 - Reinforced Glass, Assembling Line Casing, Reinforced Glass")
+            .addStructureInfo("Layer 3 - Grate Machine Casing, Assembler Machine Casing, Grate Machine Casing")
+            .addStructureInfo("Layer 4 - Empty, Solid Steel Machine Casing, Empty")
+            .addStructureInfo("Up to 16 repeating slices, each one allows for 1 more item in recipes")
+
+            .addController("Either Grate on layer 3 of the first slice")
+            .addEnergyHatch("Any layer 4 casing", 1)
+            .addMaintenanceHatch("Any layer 1 casing", 3)
+            .addInputBus("As specified on layer 1", 4, 5)
+            .addInputHatch("Any layer 1 casing", 3)
+            .addOutputBus("Replaces Input Bus on final slice or on any solid steel casing on layer 1", 4)
+            .addOtherStructurePart("Data Access Hatch", "Optional, next to controller", 2)
+            .toolTipFinisher("Gregtech");
         return tt;
     }
 
@@ -133,13 +142,13 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
         if (aSide == aFacing) {
             if (aActive)
                 return new ITexture[]{
-                        BlockIcons.casingTexturePages[0][16],
-                        TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE).extFacing().build(),
-                        TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW).extFacing().glow().build()};
-            return new ITexture[]{
                     BlockIcons.casingTexturePages[0][16],
-                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE).extFacing().build(),
-                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_GLOW).extFacing().glow().build()};
+                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE).extFacing().build(),
+                    TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW).extFacing().glow().build()};
+            return new ITexture[]{
+                BlockIcons.casingTexturePages[0][16],
+                TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE).extFacing().build(),
+                TextureFactory.builder().addIcon(OVERLAY_FRONT_ASSEMBLY_LINE_GLOW).extFacing().glow().build()};
         }
         return new ITexture[]{Textures.BlockIcons.casingTexturePages[0][16]};
     }
@@ -162,14 +171,14 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
     @Override
     public boolean checkRecipe(ItemStack aStack) {
         if (GT_Values.D1) {
-        	GT_FML_LOGGER.info("Start ALine recipe check");
+            GT_FML_LOGGER.info("Start ALine recipe check");
         }
         ArrayList<ItemStack> tDataStickList = getDataItems(2);
         if (tDataStickList.isEmpty()) {
-        	return false;
+            return false;
         }
         if (GT_Values.D1) {
-        	GT_FML_LOGGER.info("Stick accepted, " + tDataStickList.size() + " Data Sticks found");
+            GT_FML_LOGGER.info("Stick accepted, " + tDataStickList.size() + " Data Sticks found");
         }
 
         int[] tStack = null;
@@ -179,13 +188,13 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
 
         nextDataStick:
         for (ItemStack tDataStick : tDataStickList) {
-        	GT_AssemblyLineUtils.LookupResult tLookupResult = GT_AssemblyLineUtils.findAssemblyLineRecipeFromDataStick(tDataStick, false);
+            GT_AssemblyLineUtils.LookupResult tLookupResult = GT_AssemblyLineUtils.findAssemblyLineRecipeFromDataStick(tDataStick, false);
 
             if (tLookupResult.getType() == GT_AssemblyLineUtils.LookupResultType.INVALID_STICK)
                 continue;
 
             GT_Recipe_AssemblyLine tRecipe = tLookupResult.getRecipe();
-        	// Check if the recipe on the data stick is the current recipe for it's given output, if not we update it and continue to next.
+            // Check if the recipe on the data stick is the current recipe for it's given output, if not we update it and continue to next.
             if (tLookupResult.getType() != GT_AssemblyLineUtils.LookupResultType.VALID_STACK_AND_VALID_HASH) {
                 tRecipe = GT_AssemblyLineUtils.processDataStick(tDataStick);
                 if (tRecipe == null) {
@@ -193,11 +202,11 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
                 }
             }
 
-        	// So here we check against the recipe found on the data stick.
-        	// If we run into missing buses/hatches or bad inputs, we go to the next data stick.
-        	// This check only happens if we have a valid up to date data stick.
+            // So here we check against the recipe found on the data stick.
+            // If we run into missing buses/hatches or bad inputs, we go to the next data stick.
+            // This check only happens if we have a valid up to date data stick.
 
-        	// Check Inputs allign
+            // Check Inputs allign
             int aItemCount = tRecipe.mInputs.length;
             tStack = new int[aItemCount];
             for (int i = 0; i < aItemCount; i++) {
@@ -216,14 +225,13 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
             }
 
             // Check Fluid Inputs allign
-        	int aFluidCount = tRecipe.mFluidInputs.length;
+            int aFluidCount = tRecipe.mFluidInputs.length;
             tFluids = new int[aFluidCount];
             tFluidSlot = new int[aFluidCount];
-            for (int i = 0; i < aFluidCount; i++){
+            for (int i = 0; i < aFluidCount; i++) {
                 if (mInputHatches.get(i) == null) {
                     continue nextDataStick;
-                }
-                else {
+                }else {
                     if (mInputHatches.get(i) instanceof GT_MetaTileEntity_Hatch_MultiInput) {
                         GT_MetaTileEntity_Hatch_MultiInput tMultiHatch = (GT_MetaTileEntity_Hatch_MultiInput) mInputHatches.get(i);
                         if (!tMultiHatch.hasFluid(tRecipe.mFluidInputs[i]) || tMultiHatch.getFluidAmount(tRecipe.mFluidInputs[i]) < tRecipe.mFluidInputs[i].amount) {
@@ -245,33 +253,33 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
                 }
             }
 
-        	if (GT_Values.D1) {
-        		GT_FML_LOGGER.info("Check overclock");
-        	}
-        	calculateOverclockedNessMulti(tRecipe.mEUt, tRecipe.mDuration, 1, getMaxInputVoltage());
-        	//In case recipe is too OP for that machine
-        	if (mMaxProgresstime == Integer.MAX_VALUE - 1 && mEUt == Integer.MAX_VALUE - 1) {
-        		if (GT_Values.D1) {
-        			GT_FML_LOGGER.info("Recipe too OP");
-        		}
-        		continue;
-        	}
-        	if (GT_Values.D1) {
-        		GT_FML_LOGGER.info("Find available recipe");
-        	}
-            mOutputItems = new ItemStack[] {tRecipe.mOutput};
+            if (GT_Values.D1) {
+                GT_FML_LOGGER.info("Check overclock");
+            }
+            calculateOverclockedNessMulti(tRecipe.mEUt, tRecipe.mDuration, 1, getMaxInputVoltage());
+            //In case recipe is too OP for that machine
+            if (mMaxProgresstime == Integer.MAX_VALUE - 1 && mEUt == Integer.MAX_VALUE - 1) {
+                if (GT_Values.D1) {
+                    GT_FML_LOGGER.info("Recipe too OP");
+                }
+                continue;
+            }
+            if (GT_Values.D1) {
+                GT_FML_LOGGER.info("Find available recipe");
+            }
+            mOutputItems = new ItemStack[]{tRecipe.mOutput};
             foundRecipe = true;
-        	break ;
+            break;
         }
 
         // Best not to run this recipe.
         if (!foundRecipe || tStack.length <= 0) {
-        	return false;
+            return false;
         }
 
 
         if (GT_Values.D1) {
-        	GT_FML_LOGGER.info("All checked start consuming inputs");
+            GT_FML_LOGGER.info("All checked start consuming inputs");
         }
         for (int i = 0; i < tStack.length; i++) {
             ItemStack stackInSlot = mInputBusses.get(i).getStackInSlot(0);
@@ -294,13 +302,13 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
         }
 
         if (this.mEUt > 0) {
-        	this.mEUt = -this.mEUt;
+            this.mEUt = -this.mEUt;
         }
         this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
         this.mEfficiencyIncrease = 10000;
         updateSlots();
         if (GT_Values.D1) {
-        	GT_FML_LOGGER.info("Recipe successful");
+            GT_FML_LOGGER.info("Recipe successful");
         }
         return true;
     }
@@ -324,7 +332,7 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
 
     @Override
     public boolean onRunningTick(ItemStack aStack) {
-        for(GT_MetaTileEntity_Hatch_DataAccess hatch_dataAccess:mDataAccessHatches){
+        for (GT_MetaTileEntity_Hatch_DataAccess hatch_dataAccess : mDataAccessHatches) {
             hatch_dataAccess.setActive(true);
         }
         return super.onRunningTick(aStack);
@@ -353,10 +361,9 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
 
     private boolean checkMachine(boolean leftToRight) {
         for (int i = 1; i < 16; i++) {
-            if (!checkPiece(i == 1 ? STRUCTURE_PIECE_SECOND : STRUCTURE_PIECE_LATER, leftToRight ? -i : i, 1, 0))
+            if (!checkPiece(STRUCTURE_PIECE_LATER, leftToRight ? -i : i, 1, 0))
                 return false;
             if (!mOutputBusses.isEmpty())
-
                 return !mEnergyHatches.isEmpty() && mMaintenanceHatches.size() == 1 && mDataAccessHatches.size() <= 1;
         }
         return false;
@@ -365,7 +372,7 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
     /**
      * @param state using bitmask, 1 for IntegratedCircuit, 2 for DataStick, 4 for DataOrb
      */
-    private boolean isCorrectDataItem(ItemStack aStack, int state){
+    private boolean isCorrectDataItem(ItemStack aStack, int state) {
         if ((state & 1) != 0 && ItemList.Circuit_Integrated.isStackEqual(aStack, true, true)) return true;
         if ((state & 2) != 0 && ItemList.Tool_DataStick.isStackEqual(aStack, false, true)) return true;
         return (state & 4) != 0 && ItemList.Tool_DataOrb.isStackEqual(aStack, false, true);
@@ -383,7 +390,7 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
             if (isValidMetaTileEntity(tHatch)) {
                 for (int i = 0; i < tHatch.getBaseMetaTileEntity().getSizeInventory(); i++) {
                     if (tHatch.getBaseMetaTileEntity().getStackInSlot(i) != null
-                            && isCorrectDataItem(tHatch.getBaseMetaTileEntity().getStackInSlot(i), state))
+                        && isCorrectDataItem(tHatch.getBaseMetaTileEntity().getStackInSlot(i), state))
                         rList.add(tHatch.getBaseMetaTileEntity().getStackInSlot(i));
                 }
             }
@@ -402,18 +409,6 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
         return false;
     }
 
-    private boolean addInputHatchToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
-        if (aTileEntity == null) return false;
-        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
-        if (aMetaTileEntity == null) return false;
-        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) {
-            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
-            ((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity).mRecipeMap = getRecipeMap();
-            return mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity);
-        }
-        return false;
-    }
-
     @Override
     public int getMaxEfficiency(ItemStack aStack) {
         return 10000;
@@ -434,7 +429,39 @@ public class GT_MetaTileEntity_AssemblyLine extends GT_MetaTileEntity_EnhancedMu
         buildPiece(STRUCTURE_PIECE_FIRST, stackSize, hintsOnly, 0, 1, 0);
         int tLength = Math.min(stackSize.stackSize + 1, 16);
         for (int i = 1; i < tLength; i++) {
-            buildPiece(i == 1 ? STRUCTURE_PIECE_SECOND : STRUCTURE_PIECE_LATER, stackSize, hintsOnly, -i, 1, 0);
+            buildPiece(STRUCTURE_PIECE_LATER, stackSize, hintsOnly, -i, 1, 0);
+        }
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        int build = survivialBuildPiece(STRUCTURE_PIECE_FIRST, stackSize, 0, 1, 0, elementBudget, source, actor, false, true);
+        if (build >= 0) return build;
+        int tLength = Math.min(stackSize.stackSize + 1, 16);
+        for (int i = 1; i < tLength - 1; i++) {
+            build = survivialBuildPiece(STRUCTURE_PIECE_LATER, stackSize, -i, 1, 0, elementBudget, source, actor, false, true);
+            if (build >= 0) return build;
+        }
+        return survivialBuildPiece(STRUCTURE_PIECE_LAST, stackSize, 1 - tLength, 1, 0, elementBudget, source, actor, false);
+    }
+
+    private enum DataHatchElement implements IHatchElement<GT_MetaTileEntity_AssemblyLine> {
+        DataAccess;
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return Collections.singletonList(GT_MetaTileEntity_Hatch_DataAccess.class);
+        }
+
+        @Override
+        public IGT_HatchAdder<GT_MetaTileEntity_AssemblyLine> adder() {
+            return GT_MetaTileEntity_AssemblyLine::addDataAccessToMachineList;
+        }
+
+        @Override
+        public long count(GT_MetaTileEntity_AssemblyLine t) {
+            return t.mDataAccessHatches.size();
         }
     }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DieselEngine.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DieselEngine.java
index 90750eb2b5..29997c5452 100644
--- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DieselEngine.java
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DieselEngine.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.machines.multi;
 
+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 gregtech.GT_Mod;
@@ -17,6 +19,7 @@ import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 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;
@@ -29,15 +32,20 @@ import java.util.ArrayList;
 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.enums.GT_HatchElement.Dynamo;
+import static gregtech.api.enums.GT_HatchElement.InputHatch;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_HatchElement.Muffler;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional;
 
-public class GT_MetaTileEntity_DieselEngine extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_DieselEngine> {
+public class GT_MetaTileEntity_DieselEngine extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_DieselEngine> implements ISurvivalConstructable {
     private static final String STRUCTURE_PIECE_MAIN = "main";
     private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_DieselEngine>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<GT_MetaTileEntity_DieselEngine>>() {
         @Override
@@ -51,8 +59,14 @@ public class GT_MetaTileEntity_DieselEngine extends GT_MetaTileEntity_EnhancedMu
                     .addElement('i', lazy(t -> ofBlock(t.getIntakeBlock(), t.getIntakeMeta())))
                     .addElement('c', lazy(t -> ofBlock(t.getCasingBlock(), t.getCasingMeta())))
                     .addElement('g', lazy(t -> ofBlock(t.getGearboxBlock(), t.getGearboxMeta())))
-                    .addElement('d', lazy(t -> ofHatchAdder(GT_MetaTileEntity_DieselEngine::addDynamoToMachineList, t.getCasingTextureIndex(), 2)))
-                    .addElement('h', lazy(t -> ofHatchAdderOptional(GT_MetaTileEntity_DieselEngine::addToMachineList, t.getCasingTextureIndex(), 1, t.getCasingBlock(), t.getCasingMeta())))
+                    .addElement('d', lazy(t -> Dynamo.newAny(t.getCasingTextureIndex(), 2)))
+                    .addElement('h', lazy(t ->
+                            buildHatchAdder(GT_MetaTileEntity_DieselEngine.class)
+                                .atLeast(InputHatch, InputHatch, InputHatch, Muffler, Maintenance)
+                                .casingIndex(t.getCasingTextureIndex())
+                                .dot(1)
+                                .buildAndChain(t.getCasingBlock(), t.getCasingMeta())
+                    ))
                     .build();
         }
     };
@@ -328,4 +342,10 @@ public class GT_MetaTileEntity_DieselEngine extends GT_MetaTileEntity_EnhancedMu
     public void construct(ItemStack stackSize, boolean hintsOnly) {
         buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 1, 1, 1);
     }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 1, 1, 1, elementBudget, source, actor, false, true);
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java
index 862f5186b3..16bc02eeec 100644
--- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java
@@ -1,12 +1,15 @@
 package gregtech.common.tileentities.machines.multi;
 
 import com.gtnewhorizon.structurelib.alignment.IAlignmentLimits;
+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 gregtech.api.GregTech_API;
 import gregtech.api.enums.Textures;
 import gregtech.api.enums.Textures.BlockIcons;
 import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.IHatchElement;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
@@ -16,6 +19,7 @@ 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 net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
@@ -28,57 +32,73 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.GT_HatchElement.*;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_ACTIVE_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_GLOW;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
 import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
 
-public class GT_MetaTileEntity_DistillationTower extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_DistillationTower> {
+public class GT_MetaTileEntity_DistillationTower extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_DistillationTower> implements ISurvivalConstructable {
     protected static final int CASING_INDEX = 49;
     protected static final String STRUCTURE_PIECE_BASE = "base";
     protected static final String STRUCTURE_PIECE_LAYER = "layer";
     protected static final String STRUCTURE_PIECE_LAYER_HINT = "layerHint";
     protected static final String STRUCTURE_PIECE_TOP_HINT = "topHint";
-    private static final IStructureDefinition<GT_MetaTileEntity_DistillationTower> STRUCTURE_DEFINITION = StructureDefinition.<GT_MetaTileEntity_DistillationTower>builder()
+    private static final IStructureDefinition<GT_MetaTileEntity_DistillationTower> STRUCTURE_DEFINITION;
+
+    static {
+        IHatchElement<GT_MetaTileEntity_DistillationTower> layeredOutputHatch = OutputHatch
+            .withCount(GT_MetaTileEntity_DistillationTower::getCurrentLayerOutputHatchCount)
+            .withAdder(GT_MetaTileEntity_DistillationTower::addLayerOutputHatch);
+        STRUCTURE_DEFINITION = StructureDefinition.<GT_MetaTileEntity_DistillationTower>builder()
             .addShape(STRUCTURE_PIECE_BASE, transpose(new String[][]{
-                    {"b~b", "bbb", "bbb"},
+                {"b~b", "bbb", "bbb"},
             }))
             .addShape(STRUCTURE_PIECE_LAYER, transpose(new String[][]{
-                    {"lll", "lcl", "lll"}
+                {"lll", "lcl", "lll"}
             }))
             .addShape(STRUCTURE_PIECE_LAYER_HINT, transpose(new String[][]{
-                    {"lll", "l-l", "lll"}
+                {"lll", "l-l", "lll"}
             }))
             .addShape(STRUCTURE_PIECE_TOP_HINT, transpose(new String[][]{
-                    {"lll", "lCl", "lll"}
+                {"lll", "lll", "lll"}
             }))
             .addElement('b', ofChain(
-                    ofHatchAdder(GT_MetaTileEntity_DistillationTower::addEnergyInputToMachineList, CASING_INDEX, 1),
-                    ofHatchAdder(GT_MetaTileEntity_DistillationTower::addOutputToMachineList, CASING_INDEX, 1),
-                    ofHatchAdder(GT_MetaTileEntity_DistillationTower::addInputToMachineList, CASING_INDEX, 1),
-                    ofHatchAdder(GT_MetaTileEntity_DistillationTower::addMaintenanceToMachineList, CASING_INDEX, 1),
-                    onElementPass(GT_MetaTileEntity_DistillationTower::onCasingFound, ofBlock(GregTech_API.sBlockCasings4, 1))
+                buildHatchAdder(GT_MetaTileEntity_DistillationTower.class)
+                    .atLeast(Energy, OutputBus, InputHatch, InputBus, Maintenance)
+                    .casingIndex(CASING_INDEX)
+                    .dot(1)
+                    .build(),
+                onElementP