Add Large Essentia Smeltery (#38)

* Add Large Essentia Smeltery

* Add info data

* Add Essentia Output Hatch (ME)

* fix node power

* Bug fix

* Solve the problems mentioned

* Undo wrong changes

4 files changed, 854 insertions, 9 deletions

diff --git a/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java b/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java
index b33dbffdec..0d4352e4f9 100644
--- a/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java
+++ b/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java
@@ -1,6 +1,8 @@
 package goodgenerator.blocks.regularBlock;
 
 import goodgenerator.blocks.tileEntity.EssentiaHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch;
+import goodgenerator.blocks.tileEntity.EssentiaOutputHatch_ME;
 import goodgenerator.main.GoodGenerator;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
@@ -138,9 +140,16 @@ public class TEBlock extends BlockContainer {
 
     @Override
     public TileEntity createTileEntity(World world, int meta) {
-        if (index == 1)
-            return new EssentiaHatch();
-        return null;
+        switch (index) {
+            case 1:
+                return new EssentiaHatch();
+            case 2:
+                return new EssentiaOutputHatch();
+            case 3:
+                return new EssentiaOutputHatch_ME();
+            default:
+                return null;
+        }
     }
 
     @Override
@@ -159,17 +168,23 @@ public class TEBlock extends BlockContainer {
                             ((EssentiaHatch) tile).setLockedAspect(tLocked);
                             GT_Utility.sendChatToPlayer(player, String.format(StatCollector.translateToLocal("essentiahatch.chat.0"), tLocked.getLocalizedDescription()));
                         }
-                    }
-                    else {
+                    } else {
                         ((EssentiaHatch) tile).setLockedAspect(null);
                         GT_Utility.sendChatToPlayer(player, StatCollector.translateToLocal("essentiahatch.chat.1"));
                     }
                     world.markBlockForUpdate(x, y, z);
                     return true;
-                }
-                else return false;
-            }
-            else return false;
+                } else return false;
+            } else if (index == 2) {
+                if (tile instanceof EssentiaOutputHatch) {
+                    ItemStack tItemStack = player.getHeldItem();
+                    if (tItemStack == null) {
+                        ((EssentiaOutputHatch) tile).clear();
+                        GT_Utility.sendChatToPlayer(player, StatCollector.translateToLocal("essentiaoutputhatch.chat.0"));
+                    }
+                    return true;
+                } else return false;
+            } else return false;
         }
     }
 
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java
new file mode 100644
index 0000000000..77d8004446
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch.java
@@ -0,0 +1,179 @@
+package goodgenerator.blocks.tileEntity;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraftforge.common.util.ForgeDirection;
+import thaumcraft.api.TileThaumcraft;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.aspects.IAspectContainer;
+import thaumcraft.api.aspects.IEssentiaTransport;
+
+import java.util.Map;
+
+public class EssentiaOutputHatch extends TileThaumcraft implements IAspectContainer, IEssentiaTransport {
+
+    public static final int CAPACITY = 256;
+    protected AspectList mAspects = new AspectList();
+
+    public void clear() {
+        this.mAspects.aspects.clear();
+    }
+
+    @Override
+    public void markDirty() {
+        super.markDirty();
+        if (this.worldObj.isRemote) return;
+        this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound nbttagcompound) {
+        super.readFromNBT(nbttagcompound);
+        this.mAspects.aspects.clear();
+        NBTTagList tlist = nbttagcompound.getTagList("Aspects", 69);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key")) mAspects.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound nbttagcompound) {
+        super.writeToNBT(nbttagcompound);
+        Aspect[] aspectA = this.mAspects.getAspects();
+        NBTTagList nbtTagList = new NBTTagList();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", this.mAspects.getAmount(aspect));
+                nbtTagList.appendTag(f);
+            }
+        }
+        nbttagcompound.setTag("Aspects", nbtTagList);
+    }
+
+    private int remainingCapacity() {
+        return CAPACITY - this.getEssentiaAmount(null);
+    }
+
+    @Override
+    public AspectList getAspects() {
+        return this.mAspects;
+    }
+
+    @Override
+    public void setAspects(AspectList aspectList) {
+        for (Map.Entry<Aspect, Integer> entry : aspectList.aspects.entrySet()) {
+            this.addEssentia(entry.getKey(), entry.getValue(), null);
+        }
+    }
+
+    @Override
+    public boolean doesContainerAccept(Aspect var1) {
+        return true;
+    }
+
+    @Override
+    public int addToContainer(Aspect aspect, int amount) {
+        int remaining = 0;
+        if (amount > this.remainingCapacity()) {
+            remaining = amount - this.remainingCapacity();
+            this.mAspects.add(aspect, this.remainingCapacity());
+        } else this.mAspects.add(aspect, amount);
+        this.markDirty();
+        return remaining;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int amount) {
+        if (this.mAspects != null && this.mAspects.getAmount(aspect) >= amount) {
+            this.mAspects.remove(aspect, amount);
+            this.markDirty();
+            return true;
+        } else return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspects) {
+        return true;
+    }
+
+    @Override
+    public boolean doesContainerContainAmount(Aspect aspect, int amount) {
+        return this.mAspects.getAmount(aspect) >= amount;
+    }
+
+    @Override
+    public boolean doesContainerContain(AspectList aspectList) {
+        for (Map.Entry<Aspect, Integer> entry : aspectList.aspects.entrySet()) {
+            if (this.mAspects.getAmount(entry.getKey()) < entry.getValue()) return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int containerContains(Aspect aspect) {
+        return this.mAspects.getAmount(aspect);
+    }
+
+    @Override
+    public boolean isConnectable(ForgeDirection var1) {
+        return true;
+    }
+
+    @Override
+    public boolean canInputFrom(ForgeDirection var1) {
+        return false;
+    }
+
+    @Override
+    public boolean canOutputTo(ForgeDirection var1) {
+        return true;
+    }
+
+    @Override
+    public void setSuction(Aspect var1, int var2) {
+    }
+
+    @Override
+    public Aspect getSuctionType(ForgeDirection var1) {
+        return null;
+    }
+
+    @Override
+    public int getSuctionAmount(ForgeDirection var1) {
+        return 0;
+    }
+
+    @Override
+    public int takeEssentia(Aspect aspect, int amount, ForgeDirection var3) {
+        return this.takeFromContainer(aspect, amount) ? amount : 0;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection direction) {
+        return amount - addToContainer(aspect, amount);
+    }
+
+    @Override
+    public Aspect getEssentiaType(ForgeDirection var1) {
+        return this.mAspects.size() > 0 ? this.mAspects.getAspects()[0] : null;
+    }
+
+    @Override
+    public int getEssentiaAmount(ForgeDirection var1) {
+        return this.mAspects.visSize();
+    }
+
+    @Override
+    public int getMinimumSuction() {
+        return 0;
+    }
+
+    @Override
+    public boolean renderExtendedTube() {
+        return true;
+    }
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java
new file mode 100644
index 0000000000..8f2c4c920f
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaOutputHatch_ME.java
@@ -0,0 +1,172 @@
+package goodgenerator.blocks.tileEntity;
+
+import appeng.api.config.Actionable;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.TileEvent;
+import appeng.tile.events.TileEventType;
+import cpw.mods.fml.common.Optional;
+import goodgenerator.util.ItemRefer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumicenergistics.api.grid.IEssentiaGrid;
+import thaumicenergistics.api.grid.IMEEssentiaMonitor;
+
+import java.util.Map;
+
+
+@Optional.InterfaceList(value = {
+    @Optional.Interface(iface = "appeng.api.networking.security.IActionHost", modid = "appliedenergistics2", striprefs = true),
+    @Optional.Interface(iface = "appeng.me.helpers.IGridProxyable", modid = "appliedenergistics2", striprefs = true),})
+public class EssentiaOutputHatch_ME extends EssentiaOutputHatch implements IActionHost, IGridProxyable {
+
+    private AENetworkProxy gridProxy = null;
+    private IMEEssentiaMonitor monitor = null;
+    private MachineSource asMachineSource = new MachineSource(this);
+
+    @Override
+    public void updateEntity() {
+        getProxy();
+        super.updateEntity();
+    }
+
+    @Override
+    public void invalidate() {
+        super.invalidate();
+        this.invalidateAE();
+    }
+
+    @Override
+    public void onChunkUnload() {
+        super.onChunkUnload();
+        this.onChunkUnloadAE();
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_READ)
+    @Optional.Method(modid = "appliedenergistics2")
+    public void readFromNBT_AENetwork(final NBTTagCompound data) {
+        AENetworkProxy gp = getProxy();
+        if (gp != null)
+            getProxy().readFromNBT(data);
+    }
+
+    @TileEvent(TileEventType.WORLD_NBT_WRITE)
+    @Optional.Method(modid = "appliedenergistics2")
+    public void writeToNBT_AENetwork(final NBTTagCompound data) {
+        AENetworkProxy gp = getProxy();
+        if (gp != null)
+            gp.writeToNBT(data);
+    }
+
+    @Optional.Method(modid = "appliedenergistics2")
+    void onChunkUnloadAE() {
+        AENetworkProxy gp = getProxy();
+        if (gp != null)
+            gp.onChunkUnload();
+    }
+
+    @Optional.Method(modid = "appliedenergistics2")
+    void invalidateAE() {
+        AENetworkProxy gp = getProxy();
+        if (gp != null)
+            gp.invalidate();
+    }
+
+    @Optional.Method(modid = "appliedenergistics2")
+    public IGridNode getGridNode(ForgeDirection forgeDirection) {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public void gridChanged() {
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public AECableType getCableConnectionType(ForgeDirection forgeDirection) {
+        return AECableType.SMART;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public void securityBreak() {
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public AENetworkProxy getProxy() {
+        if (gridProxy == null) {
+            gridProxy = new AENetworkProxy(this, "proxy", ItemRefer.Essentia_Output_Hatch_ME.get(1), true);
+            gridProxy.onReady();
+            gridProxy.setFlags(GridFlags.REQUIRE_CHANNEL);
+        }
+        return this.gridProxy;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public DimensionalCoord getLocation() {
+        return new DimensionalCoord(this.worldObj, this.xCoord, this.yCoord, this.zCoord);
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public IGridNode getActionableNode() {
+        AENetworkProxy gp = getProxy();
+        return gp != null ? gp.getNode() : null;
+    }
+
+    @Override
+    public boolean takeFromContainer(AspectList aspects) {
+        return false;
+    }
+
+    @Override
+    public boolean takeFromContainer(Aspect aspect, int amount) {
+        return false;
+    }
+
+    @Override
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection side) {
+        return this.addEssentia(aspect, amount, side, Actionable.MODULATE);
+    }
+
+    public int addEssentia(Aspect aspect, int amount, ForgeDirection side, Actionable mode) {
+        long rejectedAmount = amount;
+        if (this.getEssentiaMonitor()) {
+            rejectedAmount = this.monitor.injectEssentia(aspect, amount, mode, this.getMachineSource(), true);
+        }
+
+        long acceptedAmount = (long) amount - rejectedAmount;
+        return (int) acceptedAmount;
+    }
+
+    protected boolean getEssentiaMonitor() {
+        IMEEssentiaMonitor essentiaMonitor = null;
+        IGrid grid = null;
+        IGridNode node = this.getProxy().getNode();
+
+        if (node != null) {
+            grid = node.getGrid();
+            if (grid != null) essentiaMonitor = grid.getCache(IEssentiaGrid.class);
+        }
+        this.monitor = essentiaMonitor;
+        return (this.monitor != null);
+    }
+
+    public MachineSource getMachineSource() {
+        return this.asMachineSource;
+    }
+
+}
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
new file mode 100644
index 0000000000..b3b89e1d4a
--- /dev/null
+++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaSmeltery.java
@@ -0,0 +1,479 @@
+package goodgenerator.blocks.tileEntity;
+
+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.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.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.*;
+import gregtech.api.objects.XSTR;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockAir;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.visnet.VisNetHandler;
+import thaumcraft.common.config.ConfigBlocks;
+import thaumcraft.common.lib.crafting.ThaumcraftCraftingManager;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+
+public class LargeEssentiaSmeltery extends GT_MetaTileEntity_TooltipMultiBlockBase_EM implements IConstructable {
+
+    private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("icons/LargeEssentiaSmeltery_On");
+    private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon("icons/LargeEssentiaSmeltery_On_GLOW");
+    private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon("icons/LargeEssentiaSmeltery_Off");
+    private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon("icons/LargeEssentiaSmeltery_Off_GLOW");
+    private static final String STRUCTURE_PIECE_FIRST = "first";
+    private static final String STRUCTURE_PIECE_LATER = "later";
+    private static final String STRUCTURE_PIECE_LAST = "last";
+    private static final int CASING_INDEX = 1536;
+    private static final int MAX_STRUCTURE_LENGTH = 8;
+    private static final int DEFAULT_STRUCTURE_LENGTH = 3;
+    private static final int MAX_CONFIGURABLE_LENGTH = MAX_STRUCTURE_LENGTH - DEFAULT_STRUCTURE_LENGTH;
+
+    private static final int RECIPE_DURATION = 32;
+    private static final int RECIPE_EUT = 480;
+    private static final float NODE_COST_MULTIPLIER = 1.15f;
+
+    public AspectList mOutputAspects = new AspectList();
+    protected int mCasing = 0;
+    protected double mParallel = 0;
+    protected int nodePower = 0;
+    protected int nodePurificationEfficiency = 0;
+    protected int nodeIncrease = 0;
+
+    private IStructureDefinition<LargeEssentiaSmeltery> multiDefinition = null;
+    private ArrayList<EssentiaOutputHatch> mEssentiaOutputHatches = new ArrayList<>();
+    private int pTier = 0;
+    private XSTR xstr = new XSTR();
+
+    public LargeEssentiaSmeltery(String name) {
+        super(name);
+    }
+
+    public LargeEssentiaSmeltery(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean hintsOnly) {
+        structureBuild_EM(STRUCTURE_PIECE_FIRST, 2, 2, 0, itemStack, hintsOnly);
+        //default
+        structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -1, itemStack, hintsOnly);
+        structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -2, itemStack, hintsOnly);
+        int len = itemStack.stackSize;
+        if (len > MAX_CONFIGURABLE_LENGTH) len = MAX_CONFIGURABLE_LENGTH;
+        structureBuild_EM(STRUCTURE_PIECE_LAST, 2, 2, -len - 3, itemStack, hintsOnly);
+        while (len > 0) {
+            structureBuild_EM(STRUCTURE_PIECE_LATER, 2, 2, -len - 2, itemStack, hintsOnly);
+            len--;
+        }
+    }
+
+    @Override
+    protected boolean checkMachine_EM(IGregTechTileEntity iGregTechTileEntity, ItemStack itemStack) {
+        this.mCasing = 0;
+        this.mParallel = 0;
+        this.pTier = 0;
+        this.nodePower = 0;
+        this.nodePurificationEfficiency = 0;
+        this.nodeIncrease = 0;
+        this.mEssentiaOutputHatches.clear();
+
+        if (!structureCheck_EM(STRUCTURE_PIECE_FIRST, 2, 2, 0)) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -1)) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -2)) return false;
+        int len = 2;
+        while (structureCheck_EM(STRUCTURE_PIECE_LATER, 2, 2, -len - 1)) len++;
+        if (len > MAX_STRUCTURE_LENGTH - 1 || len < DEFAULT_STRUCTURE_LENGTH) return false;
+        if (!structureCheck_EM(STRUCTURE_PIECE_LAST, 2, 2, -len - 1)) return false;
+        if (this.mCasing >= 24 &&
+            this.mMaintenanceHatches.size() == 1 &&
+            this.mInputBusses.size() >= 1 &&
+            this.mEssentiaOutputHatches.size() >= 1) {
+            this.mParallel = Math.floor(this.mParallel += 1 << this.pTier);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public IStructureDefinition<? extends GT_MetaTileEntity_MultiblockBase_EM> getStructure_EM() {
+        if (this.multiDefinition == null) {
+            this.multiDefinition = StructureDefinition
+                .<LargeEssentiaSmeltery>builder()
+                .addShape("first", transpose(new String[][]{{"  A  "}, {" AAA "}, {"AA~AA"}, {" AAA "}, {"  A  "}}))
+                .addShape("later", transpose(new String[][]{{" ABA "}, {"AECEA"}, {"D---D"}, {"AEFEA"}, {" AAA "}}))
+                .addShape("last", transpose(new String[][]{{"  A  "}, {" AAA "}, {"AAAAA"}, {" AAA "}, {"  A  "}}))
+                .addElement('C', ofBlock(Loaders.essentiaFilterCasing, 0))
+                .addElement('D', ofBlock(ConfigBlocks.blockCosmeticOpaque, 2))
+                .addElement('F', LoadedList.THAUMIC_BASES ? ofBlock(Block.getBlockFromName("thaumicbases:advAlchFurnace"), 0) : ofBlock(ConfigBlocks.blockStoneDevice, 0))
+                .addElement('E', ofChain(
+                    onElementPass(x -> x.onEssentiaCellFound(0),
+                        ofBlock(Loaders.essentiaCell, 0)),
+                    onElementPass(x -> x.onEssentiaCellFound(1),
+                        ofBlock(Loaders.essentiaCell, 1)),
+                    onElementPass(x -> x.onEssentiaCellFound(2),
+                        ofBlock(Loaders.essentiaCell, 2)),
+                    onElementPass(x -> x.onEssentiaCellFound(3),
+                        ofBlock(Loaders.essentiaCell, 3))))
+                .addElement('A', ofChain(
+                    ofHatchAdder(LargeEssentiaSmeltery::addMaintenanceToMachineList, CASING_INDEX, 1),
+                    ofHatchAdder(LargeEssentiaSmeltery::addInputToMachineList, CASING_INDEX, 1),
+                    ofHatchAdder(LargeEssentiaSmeltery::addEnergyHatchToMachineList, CASING_INDEX, 1),
+                    ofTileAdder(LargeEssentiaSmeltery::addEssentiaOutputHatchToMachineList, Loaders.magicCasing, 0),
+                    onElementPass(LargeEssentiaSmeltery::onCasingFound, ofBlock(Loaders.magicCasing, 0))))
+                .addElement('B', ofHatchAdder(LargeEssentiaSmeltery::addMufflerToMachineList, CASING_INDEX, 2))
+                .build();
+        }
+        return this.multiDefinition;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Essentia Smeltery")
+            .addInfo("Controller block for the Large Essentia Smeltery")
+            .addInfo("Necessary evil.")
+            .addInfo("Advanced Essentia smelting technology.")
+            .addInfo("Max parallel dictated by structure size and Essentia Diffusion Cell tier")
+            .addInfo("Energy Hatch tier: HV+")
+            .addInfo("You can find more information about this machine in the Thaumonomicon.")
+            .addPollutionAmount(getPollutionPerSecond(null))
+            .addInfo("The structure is too complex!")
+            .addInfo(BLUE_PRINT_INFO)
+            .addSeparator()
+            .addController("Front center")
+            .addCasingInfo("Magic Casing", 24)
+            .addMaintenanceHatch("Hint block with dot 1")
+            .addInputBus("Hint block with dot 1")
+            .addInputHatch("Hint block with dot 1")
+            .addEnergyHatch("Hint block with dot 1")
+            .addOtherStructurePart("Essentia Output Hatch", "Hint block with dot 1")
+            .addMufflerHatch("Hint block with dot 2")
+            .toolTipFinisher("Good Generator");
+        return tt;
+    }
+
+    @Override
+    public String[] getStructureDescription(ItemStack itemStack) {
+        return DescTextLocalization.addText("LargeEssentiaSmeltery.hint", 8);
+    }
+
+    @Override
+    public String[] getInfoData() {
+        String[] info = super.getInfoData();
+        info[8] = "Node Power: " + EnumChatFormatting.RED + this.nodePower + EnumChatFormatting.RESET + " Purification Efficiency: " + EnumChatFormatting.AQUA + this.nodePurificationEfficiency + "%" + EnumChatFormatting.RESET + " Speed Up: " + EnumChatFormatting.GRAY + this.nodeIncrease + "%" + EnumChatFormatting.RESET;
+        return info;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            if (aActive) return new ITexture[]{
+                Textures.BlockIcons.getCasingTextureForId(CASING_INDEX),
+                TextureFactory.of(textureFontOn),
+                TextureFactory.builder().addIcon(textureFontOn_Glow).glow().build()
+            };
+            else return new ITexture[]{
+                Textures.BlockIcons.getCasingTextureForId(CASING_INDEX),
+                TextureFactory.of(textureFontOff),
+                TextureFactory.builder().addIcon(textureFontOff_Glow).glow().build()
+            };
+        }
+        return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(CASING_INDEX)};
+    }
+
+    protected void onCasingFound() {
+        this.mCasing++;
+    }
+
+    protected void onEssentiaCellFound(int tier) {
+        this.mParallel += (1 << tier) * 0.25f;
+        this.pTier = Math.max(this.pTier, tier);
+    }
+
+    private boolean addEnergyHatchToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null) {
+            return false;
+        } else {
+            IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity == null) {
+                return false;
+            } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+                if (((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity).mTier < 3) return false;
+                ((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+            } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+                ((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+                return this.eEnergyMulti.add(((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity));
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private boolean addEssentiaOutputHatchToMachineList(TileEntity aTileEntity) {
+        if (aTileEntity instanceof EssentiaOutputHatch) {
+            return this.mEssentiaOutputHatches.add((EssentiaOutputHatch) aTileEntity);
+        }
+        return false;
+    }
+
+    @Override
+    protected void runMachine(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (!this.isFullPower()) return;
+        super.runMachine(aBaseMetaTileEntity, aTick);
+    }
+
+    @Override
+    public boolean checkRecipe_EM(ItemStack aStack) {
+        if (!isFullPower()) return false;
+
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+//        ArrayList<FluidStack> tFluidList = getStoredFluids();
+
+        if (tInputList.size() == 0) return false;
+
+        int p = (int) this.mParallel;
+        for (int i = tInputList.size() - 1; i >= 0; i--) {
+            ItemStack itemStack = tInputList.get(i);
+            int stackSize = itemStack.stackSize;
+            int sur = p - stackSize;
+
+            if (sur > 0) {
+                p -= stackSize;
+                this.mOutputAspects.add(getEssentia(itemStack, stackSize));
+                if (!depleteInput(itemStack)) itemStack.stackSize = 0;
+            } else if (sur == 0) {
+                this.mOutputAspects.add(getEssentia(itemStack, stackSize));
+                if (!depleteInput(itemStack)) itemStack.stackSize = 0;
+                break;
+            } else {
+                this.mOutputAspects.add(getEssentia(itemStack, p));
+                itemStack.stackSize -= p;
+                break;
+            }
+        }
+
+        this.mEfficiency = 10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000;
+        this.mEfficiencyIncrease = 10000;
+
+        final World WORLD = this.getBaseMetaTileEntity().getWorld();
+        int x = this.getBaseMetaTileEntity().getXCoord();
+        int y = this.getBaseMetaTileEntity().getYCoord();
+        int z = this.getBaseMetaTileEntity().getZCoord();
+
+        this.drainNodePower(WORLD, x, y, z);
+        this.nodePower -= expectedPower();
+
+        calculatePerfectOverclockedNessMulti(RECIPE_EUT, (int) Math.ceil(this.mOutputAspects.visSize() * RECIPE_DURATION * (1 - this.nodeIncrease * 0.005)), 1, Math.min(Integer.MAX_VALUE, getMaxInputEnergy_EM()));
+
+        this.updateSlots();
+        if (this.mEUt > 0) this.mEUt = -this.mEUt;
+        return true;
+    }
+
+    private AspectList getEssentia(ItemStack itemStack, int amount) {
+        AspectList aspectList = new AspectList();
+        AspectList aspects = ThaumcraftCraftingManager.getObjectTags(itemStack);
+        if (aspects != null && aspects.size() != 0 && aspects.getAspects()[0] != null) {
+            for (int i = 0; i < amount; i++) aspectList.add(aspects);
+        } else aspectList.add(Aspect.ENTROPY, amount);
+        return aspectList;
+    }
+
+    private void fillEssentiaOutputHatch() {
+        for (EssentiaOutputHatch outputHatch : this.mEssentiaOutputHatches) {
+            for (Map.Entry<Aspect, Integer> entry : this.mOutputAspects.aspects.entrySet()) {
+                Aspect aspect = entry.getKey();
+                int amount = entry.getValue();
+                this.mOutputAspects.remove(aspect, outputHatch.addEssentia(aspect, amount, null));
+            }
+        }
+        this.mOutputAspects.aspects.clear();
+    }
+
+    private int expectedPower() {
+        return (int) (Math.pow(this.getMaxEnergyInputTier_EM(), 2) * NODE_COST_MULTIPLIER);
+    }
+
+    private boolean isFullPower() {
+        return this.nodePower > expectedPower();
+    }
+
+    private void generateFluxGas(World world, int x, int y, int z) {
+        world.setBlock(x, y, z, ConfigBlocks.blockFluxGas, 8, 3);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setDouble("mParallel", this.mParallel);
+        aNBT.setDouble("nodePower", this.nodePower);
+        aNBT.setDouble("nodePurificationEfficiency", this.nodePurificationEfficiency);
+        aNBT.setDouble("nodeIncrease", this.nodeIncrease);
+
+        Aspect[] aspectA = this.mOutputAspects.getAspects();
+        NBTTagList nbtTagList = new NBTTagList();
+        for (Aspect aspect : aspectA) {
+            if (aspect != null) {
+                NBTTagCompound f = new NBTTagCompound();
+                f.setString("key", aspect.getTag());
+                f.setInteger("amount", this.mOutputAspects.getAmount(aspect));
+                nbtTagList.appendTag(f);
+            }
+        }
+        aNBT.setTag("Aspects", nbtTagList);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        this.mParallel = aNBT.getDouble("mParallel");
+        this.nodePower = aNBT.getInteger("nodePower");
+        this.nodePurificationEfficiency = aNBT.getInteger("nodePurificationEfficiency");
+        this.nodeIncrease = aNBT.getInteger("nodeIncrease");
+
+        this.mOutputAspects.aspects.clear();
+        NBTTagList tlist = aNBT.getTagList("Aspects", 69);
+        for (int j = 0; j < tlist.tagCount(); ++j) {
+            NBTTagCompound rs = tlist.getCompoundTagAt(j);
+            if (rs.hasKey("key"))
+                this.mOutputAspects.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount"));
+        }
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    protected void addClassicOutputs_EM() {
+        super.addClassicOutputs_EM();
+        fillEssentiaOutputHatch();
+    }
+
+    @Override
+    public void stopMachine() {
+        super.stopMachine();
+        this.mOutputAspects.aspects.clear();
+    }
+
+    private void drainNodePower(World world, int x, int y, int z) {
+        int power = this.expectedPower();
+        if (this.nodePower < power * 10) {
+            this.nodePower += VisNetHandler.drainVis(world, x, y, z, Aspect.WATER, power);
+            this.nodePower += VisNetHandler.drainVis(world, x, y, z, Aspect.FIRE, power);
+        }
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        if (aTick % 5 == 0 && this.mMachine) {
+            final World WORLD = this.getBaseMetaTileEntity().getWorld();
+            int x = this.getBaseMetaTileEntity().getXCoord();
+            int y = this.getBaseMetaTileEntity().getYCoord();
+            int z = this.getBaseMetaTileEntity().getZCoord();
+
+            this.drainNodePower(WORLD, x, y, z);
+
+            this.nodePurificationEfficiency = Math.max(0, this.nodePurificationEfficiency - 1);
+            if (this.nodePurificationEfficiency < 100) {
+                this.nodePurificationEfficiency = (int) Math.min(100, this.nodePurificationEfficiency + Math.ceil(VisNetHandler.drainVis(WORLD, x, y, z, Aspect.ORDER, 100) * 0.05));
+            }
+
+            this.nodeIncrease = Math.min(100, VisNetHandler.drainVis(WORLD, x, y, z, Aspect.ENTROPY, 125));
+        }
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack aStack) {
+        this.nodePurificationEfficiency = Math.max(0, this.nodePurificationEfficiency - 5);
+        if (xstr.nextInt(20) == 0) {
+            if (xstr.nextInt(100) < Math.max(100 - this.nodePurificationEfficiency, 0)) {
+                final World WORLD = this.getBaseMetaTileEntity().getWorld();
+                GT_MetaTileEntity_Hatch_Muffler mufflerHatch = this.mMufflerHatches.get(xstr.next(this.mMufflerHatches.size()));
+                int x = mufflerHatch.getBaseMetaTileEntity().getXCoord();
+                int y = mufflerHatch.getBaseMetaTileEntity().getYCoord();
+                int z = mufflerHatch.getBaseMetaTileEntity().getZCoord();
+
+                ForgeDirection facing = ForgeDirection.getOrientation(mufflerHatch.getBaseMetaTileEntity().getFrontFacing());
+                switch (facing) {
+                    case SOUTH:
+                        z += 1;
+                        break;
+                    case NORTH:
+                        z -= 1;
+                        break;
+                    case WEST:
+                        x -= 1;
+                        break;
+                    case EAST:
+                        x += 1;
+                        break;
+                    default:
+                        y += 1;
+                }
+                if (WORLD.getBlock(x, y, z) instanceof BlockAir) generateFluxGas(WORLD, x, y, z);
+            }
+        }
+        return super.onRunningTick(aStack);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public int getPollutionPerSecond(ItemStack aStack) {
+        return 22 * (100 - this.nodePurificationEfficiency);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack itemStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack itemStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack itemStack) {
+        return false;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new LargeEssentiaSmeltery(this.mName);
+    }
+
+    @Override
+    protected void maintenance_EM() {
+        super.maintenance_EM();
+    }
+
+}