Merge in KekzTech with history

git-subtree-dir: kekztech
git-subtree-mainline: 9bdc1ec39b62c303d6bb295f2cfc565b85c7db77
git-subtree-split: 609aae0684909d782d087ebbb26933866b8f04d1

37 files changed, 5527 insertions, 0 deletions

diff --git a/kekztech/src/main/java/common/Blocks.java b/kekztech/src/main/java/common/Blocks.java
new file mode 100644
index 0000000000..4003e8e9e4
--- /dev/null
+++ b/kekztech/src/main/java/common/Blocks.java
@@ -0,0 +1,59 @@
+package common;
+
+import net.minecraft.block.Block;
+
+import common.blocks.Block_GDCUnit;
+import common.blocks.Block_IchorJar;
+import common.blocks.Block_LapotronicEnergyUnit;
+import common.blocks.Block_LargeHexPlate;
+import common.blocks.Block_TFFTStorageField;
+import common.blocks.Block_ThaumiumReinforcedJar;
+import common.blocks.Block_YSZUnit;
+
+import kekztech.KekzCore;
+
+public class Blocks {
+
+    public static Block yszUnit;
+    public static Block gdcUnit;
+    public static Block tfftStorageField;
+    public static Block jarThaumiumReinforced;
+    public static Block jarIchor;
+    public static Block lscLapotronicEnergyUnit;
+
+    public static Block largeHexPlate;
+
+    public static void preInit() {
+        KekzCore.LOGGER.info("Registering blocks...");
+
+        registerBlocks_SOFC();
+        registerBlocks_TFFT();
+        registerBlocks_Jars();
+        registerBlocks_LSC();
+        registerBlocks_Cosmetics();
+
+        KekzCore.LOGGER.info("Finished registering blocks");
+    }
+
+    private static void registerBlocks_SOFC() {
+        yszUnit = Block_YSZUnit.registerBlock();
+        gdcUnit = Block_GDCUnit.registerBlock();
+    }
+
+    private static void registerBlocks_TFFT() {
+        tfftStorageField = Block_TFFTStorageField.registerBlock();
+    }
+
+    private static void registerBlocks_Jars() {
+        jarThaumiumReinforced = Block_ThaumiumReinforcedJar.registerBlock();
+        jarIchor = Block_IchorJar.registerBlock();
+    }
+
+    private static void registerBlocks_LSC() {
+        lscLapotronicEnergyUnit = Block_LapotronicEnergyUnit.registerBlock();
+    }
+
+    private static void registerBlocks_Cosmetics() {
+        largeHexPlate = Block_LargeHexPlate.registerBlock();
+    }
+}
diff --git a/kekztech/src/main/java/common/CommonProxy.java b/kekztech/src/main/java/common/CommonProxy.java
new file mode 100644
index 0000000000..777a8af268
--- /dev/null
+++ b/kekztech/src/main/java/common/CommonProxy.java
@@ -0,0 +1,42 @@
+package common;
+
+import common.items.ErrorItem;
+import common.items.MetaItem_CraftingComponent;
+import common.tileentities.GTMTE_TFFTHatch;
+
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import kekztech.Items;
+
+public class CommonProxy {
+
+    public void preInit(final FMLPreInitializationEvent e) {
+        // Items
+        ErrorItem.getInstance()
+            .registerItem();
+        MetaItem_CraftingComponent.getInstance()
+            .registerItem();
+        Items.registerOreDictNames();
+        // Blocks
+        Blocks.preInit();
+        // TileEntities
+        TileEntities.preInit();
+        // TC Research
+        Researches.preInit();
+    }
+
+    public void init(final FMLInitializationEvent e) {
+        // GregTech Meta TileEntities
+        TileEntities.init();
+    }
+
+    public void postInit(final FMLPostInitializationEvent e) {
+        // Recipes
+        Recipes.postInit();
+        // Research
+        Researches.postInit();
+
+        GTMTE_TFFTHatch.registerAEIntegration();
+    }
+}
diff --git a/kekztech/src/main/java/common/Recipes.java b/kekztech/src/main/java/common/Recipes.java
new file mode 100644
index 0000000000..2560e8dc37
--- /dev/null
+++ b/kekztech/src/main/java/common/Recipes.java
@@ -0,0 +1,141 @@
+package common;
+
+import static gregtech.api.enums.Mods.ThaumicTinkerer;
+
+import java.util.HashMap;
+
+import net.minecraft.item.ItemStack;
+
+import common.recipeLoaders.AlloySmelter;
+import common.recipeLoaders.Assembler;
+import common.recipeLoaders.AssemblyLine;
+import common.recipeLoaders.ChemicalReactor;
+import common.recipeLoaders.Crafting;
+import common.recipeLoaders.FormingPress;
+import common.recipeLoaders.Mixer;
+import common.recipeLoaders.ResearchableAssemblyLine;
+import common.recipeLoaders.Unpackager;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import kekztech.KekzCore;
+import thaumcraft.api.ItemApi;
+import thaumcraft.api.ThaumcraftApi;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.crafting.InfusionRecipe;
+
+public class Recipes {
+
+    public static final HashMap<String, InfusionRecipe> infusionRecipes = new HashMap<>();
+
+    public static void postInit() {
+        KekzCore.LOGGER.info("Registering recipes...");
+
+        new AlloySmelter().run();
+        new Assembler().run();
+        new AssemblyLine().run();
+        new ChemicalReactor().run();
+        new Crafting().run();
+        new FormingPress().run();
+        new Mixer().run();
+        new ResearchableAssemblyLine().run();
+        new Unpackager().run();
+
+        registerRecipes_Jars();
+
+        KekzCore.LOGGER.info("Finished registering recipes");
+    }
+
+    private static void registerRecipes_Jars() {
+
+        // Thaumium Reinforced Jar
+        final ItemStack[] recipe_jarthaumiumreinforced = {
+            GameRegistry.makeItemStack("Thaumcraft:ItemResource", 15, 1, null),
+            GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1),
+            GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane), };
+        final AspectList aspects_jarthaumiumreinforced = new AspectList().add(Aspect.ARMOR, 64)
+            .add(Aspect.ORDER, 32)
+            .add(Aspect.WATER, 32)
+            .add(Aspect.GREED, 16)
+            .add(Aspect.VOID, 16)
+            .add(Aspect.AIR, 8);
+        infusionRecipes.put(
+            "THAUMIUMREINFORCEDJAR",
+            ThaumcraftApi.addInfusionCraftingRecipe(
+                "THAUMIUMREINFORCEDJAR",
+                new ItemStack(Blocks.jarThaumiumReinforced, 1, 0),
+                5,
+                aspects_jarthaumiumreinforced,
+                ItemApi.getBlock("blockJar", 0),
+                recipe_jarthaumiumreinforced));
+        // Thaumium Reinforced Void Jar
+        final ItemStack[] recipe_voidjarupgrade = {
+            GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Obsidian, 1),
+            GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blaze, 1),
+            GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnderEye, 1), ItemApi.getItem("itemNugget", 5) };
+        final AspectList aspects_voidjarupgrade = new AspectList().add(Aspect.VOID, 14)
+            .add(Aspect.MAGIC, 14)
+            .add(Aspect.ENTROPY, 14)
+            .add(Aspect.WATER, 14);
+        infusionRecipes.put(
+            "THAUMIUMREINFORCEDVOIDJAR",
+            ThaumcraftApi.addInfusionCraftingRecipe(
+                "THAUMIUMREINFORCEDJAR",
+                new ItemStack(Blocks.jarThaumiumReinforced, 1, 3),
+                2,
+                aspects_voidjarupgrade,
+                new ItemStack(Blocks.jarThaumiumReinforced, 1, 0),
+                recipe_voidjarupgrade));
+
+        final ItemStack[] recipe_jarichor = { GT_ModHandler.getModItem(ThaumicTinkerer.ID, "kamiResource", 1, 0),
+            GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmiridium, 1),
+            GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.gemExquisite, Materials.Diamond, 1),
+            GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane),
+            GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmiridium, 1),
+            GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1),
+            new ItemStack(net.minecraft.init.Blocks.glass_pane), };
+        final AspectList aspects_jarichor = new AspectList().add(Aspect.ARMOR, 256)
+            .add(Aspect.ELDRITCH, 128)
+            .add(Aspect.ORDER, 128)
+            .add(Aspect.WATER, 128)
+            .add(Aspect.GREED, 64)
+            .add(Aspect.VOID, 64)
+            .add(Aspect.AIR, 32);
+        infusionRecipes.put(
+            "ICHORJAR",
+            ThaumcraftApi.addInfusionCraftingRecipe(
+                "ICHORJAR",
+                new ItemStack(Blocks.jarIchor, 1, 0),
+                15,
+                aspects_jarichor,
+                ItemApi.getBlock("blockJar", 0),
+                recipe_jarichor));
+        // Ichor Void Jar
+        infusionRecipes.put(
+            "ICHORVOIDJAR",
+            ThaumcraftApi.addInfusionCraftingRecipe(
+                "ICHORJAR",
+                new ItemStack(Blocks.jarIchor, 1, 3),
+                5,
+                aspects_voidjarupgrade,
+                new ItemStack(Blocks.jarIchor, 1, 0),
+                recipe_voidjarupgrade));
+    }
+
+}
diff --git a/kekztech/src/main/java/common/Researches.java b/kekztech/src/main/java/common/Researches.java
new file mode 100644
index 0000000000..0ebe161da4
--- /dev/null
+++ b/kekztech/src/main/java/common/Researches.java
@@ -0,0 +1,71 @@
+package common;
+
+import net.minecraft.item.ItemStack;
+
+import kekztech.KekzCore;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.api.research.ResearchItem;
+import thaumcraft.api.research.ResearchPage;
+import thaumic.tinkerer.common.research.KamiResearchItem;
+
+public class Researches {
+
+    public static final String THAUMIUMREINFORCEDJAR = "THAUMIUMREINFORCEDJAR";
+    public static final String ICHORJAR = "ICHORJAR";
+
+    public static void preInit() {
+        // Blacklist these researches from being a requirement to unlock TTKami
+        KekzCore.LOGGER.info("Blacklisting research " + THAUMIUMREINFORCEDJAR + " from /iskamiunlocked");
+        KamiResearchItem.Blacklist.add(ICHORJAR);
+        KekzCore.LOGGER.info("Blacklisting research" + ICHORJAR + "from /iskamiunlocked");
+        KamiResearchItem.Blacklist.add(ICHORJAR);
+    }
+
+    public static void postInit() {
+        final AspectList aspects_jarthaumiumreinforced = new AspectList().add(Aspect.ARMOR, 3)
+            .add(Aspect.WATER, 3)
+            .add(Aspect.GREED, 3)
+            .add(Aspect.VOID, 3);
+        @SuppressWarnings("unused")
+        final ResearchItem jar_thaumiumreinforced = new ResearchItem(
+            "THAUMIUMREINFORCEDJAR",
+            "ALCHEMY",
+            aspects_jarthaumiumreinforced,
+            3,
+            -4,
+            2,
+            new ItemStack(Blocks.jarThaumiumReinforced, 1))
+                .setPages(
+                    new ResearchPage("kekztech.research_page.THAUMIUMREINFORCEDJAR.0"),
+                    new ResearchPage(Recipes.infusionRecipes.get("THAUMIUMREINFORCEDJAR")),
+                    new ResearchPage(Recipes.infusionRecipes.get("THAUMIUMREINFORCEDVOIDJAR")),
+                    new ResearchPage("kekztech.research_page.THAUMIUMREINFORCEDJAR.1"))
+                .setConcealed()
+                .setParents("JARLABEL")
+                .registerResearchItem();
+
+        final AspectList aspects_jarichor = new AspectList().add(Aspect.ARMOR, 3)
+            .add(Aspect.ELDRITCH, 3)
+            .add(Aspect.WATER, 3)
+            .add(Aspect.GREED, 5)
+            .add(Aspect.VOID, 5);
+        @SuppressWarnings("unused")
+        final ResearchItem jar_ichor = new ResearchItem(
+            "ICHORJAR",
+            "ALCHEMY",
+            aspects_jarichor,
+            2,
+            -5,
+            3,
+            new ItemStack(Blocks.jarIchor, 1))
+                .setPages(
+                    new ResearchPage("kekztech.research_page.ICHORJAR.0"),
+                    new ResearchPage(Recipes.infusionRecipes.get("ICHORJAR")),
+                    new ResearchPage(Recipes.infusionRecipes.get("ICHORVOIDJAR")))
+                .setConcealed()
+                .setParents("THAUMIUMREINFORCEDJAR")
+                .setParentsHidden("ICHOR")
+                .registerResearchItem();
+    }
+}
diff --git a/kekztech/src/main/java/common/TileEntities.java b/kekztech/src/main/java/common/TileEntities.java
new file mode 100644
index 0000000000..31246ac5d8
--- /dev/null
+++ b/kekztech/src/main/java/common/TileEntities.java
@@ -0,0 +1,43 @@
+package common;
+
+import common.tileentities.GTMTE_LapotronicSuperCapacitor;
+import common.tileentities.GTMTE_SOFuelCellMK1;
+import common.tileentities.GTMTE_SOFuelCellMK2;
+import common.tileentities.GTMTE_TFFT;
+import common.tileentities.GTMTE_TFFTHatch;
+import common.tileentities.TE_IchorJar;
+import common.tileentities.TE_IchorVoidJar;
+import common.tileentities.TE_ThaumiumReinforcedJar;
+import common.tileentities.TE_ThaumiumReinforcedVoidJar;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class TileEntities {
+
+    // Multiblock controllers
+    public static GTMTE_SOFuelCellMK1 sofc1;
+    public static GTMTE_SOFuelCellMK2 sofc2;
+    public static GTMTE_TFFT tfft;
+    public static GTMTE_LapotronicSuperCapacitor lsc;
+
+    // Singleblocks
+    public static GTMTE_TFFTHatch tfftHatch;
+
+    public static void preInit() {
+        GameRegistry.registerTileEntity(TE_ThaumiumReinforcedJar.class, "kekztech_thaumiumreinforcedjar");
+        GameRegistry.registerTileEntity(TE_ThaumiumReinforcedVoidJar.class, "kekztech_thaumiumreinforcedvoidjar");
+        GameRegistry.registerTileEntity(TE_IchorJar.class, "kekztech_ichorjar");
+        GameRegistry.registerTileEntity(TE_IchorVoidJar.class, "kekztech_ichorvoidjar");
+    }
+
+    public static void init() {
+        // Multiblock controllers
+        sofc1 = new GTMTE_SOFuelCellMK1(13101, "multimachine.fuelcellmk1", "Solid-Oxide Fuel Cell Mk I");
+        sofc2 = new GTMTE_SOFuelCellMK2(13102, "multimachine.fuelcellmk2", "Solid-Oxide Fuel Cell Mk II");
+        tfft = new GTMTE_TFFT(13104, "multimachine.tfft", "T.F.F.T");
+        lsc = new GTMTE_LapotronicSuperCapacitor(13106, "multimachine.supercapacitor", "Lapotronic Supercapacitor");
+
+        // Singleblocks
+        tfftHatch = new GTMTE_TFFTHatch(13109, "machine.tffthatch", "T.F.F.T Multi I/O Hatch");
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java b/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java
new file mode 100644
index 0000000000..ef61327dd7
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java
@@ -0,0 +1,57 @@
+package common.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import gregtech.api.GregTech_API;
+
+/**
+ * Any blocks that are used as structure parts for GregTech multi machines have to inherit from this class. Otherwise
+ * the checkMachine() method that verifies a machine's structure won't be called correctly.
+ */
+public abstract class BaseGTUpdateableBlock extends Block {
+
+    protected BaseGTUpdateableBlock(Material material) {
+        super(material);
+        GregTech_API.registerMachineBlock(this, -1);
+        super.setHarvestLevel("wrench", 2);
+    }
+
+    @Override
+    public int damageDropped(int meta) {
+        return meta;
+    }
+
+    @Override
+    public boolean canBeReplacedByLeaves(IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public boolean canEntityDestroy(IBlockAccess world, int x, int y, int z, Entity entity) {
+        return false;
+    }
+
+    @Override
+    public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+        return false;
+    }
+
+    @Override
+    public void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+
+    @Override
+    public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) {
+        if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+            GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_GDCUnit.java b/kekztech/src/main/java/common/blocks/Block_GDCUnit.java
new file mode 100644
index 0000000000..27bc95759d
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_GDCUnit.java
@@ -0,0 +1,29 @@
+package common.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import kekztech.KekzCore;
+
+public class Block_GDCUnit extends BaseGTUpdateableBlock {
+
+    private static final Block_GDCUnit instance = new Block_GDCUnit();
+
+    private Block_GDCUnit() {
+        super(Material.iron);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_gdcceramicelectrolyteunit_block";
+        instance.setBlockName(blockName);
+        instance.setCreativeTab(CreativeTabs.tabMisc);
+        instance.setBlockTextureName(KekzCore.MODID + ":" + "GDCCeramicElectrolyteUnit");
+        instance.setHardness(5.0f);
+        instance.setResistance(6.0f);
+        GameRegistry.registerBlock(instance, blockName);
+
+        return instance;
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_IchorJar.java b/kekztech/src/main/java/common/blocks/Block_IchorJar.java
new file mode 100644
index 0000000000..a82f9862f0
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_IchorJar.java
@@ -0,0 +1,230 @@
+package common.blocks;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.World;
+
+import common.itemBlocks.IB_IchorJar;
+import common.tileentities.TE_IchorJar;
+import common.tileentities.TE_IchorVoidJar;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.common.blocks.BlockJar;
+import thaumcraft.common.config.ConfigBlocks;
+import thaumcraft.common.config.ConfigItems;
+import thaumcraft.common.items.ItemEssence;
+import thaumcraft.common.tiles.TileJarFillable;
+
+public class Block_IchorJar extends BlockJar {
+
+    private static final Block_IchorJar INSTANCE = new Block_IchorJar();
+
+    private Block_IchorJar() {
+        super();
+
+        super.setHardness(12.0F);
+        super.setResistance(3.0f);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_ichorjar_block";
+        INSTANCE.setBlockName(blockName);
+        INSTANCE.setHarvestLevel("pickaxe", 3);
+        GameRegistry.registerBlock(INSTANCE, IB_IchorJar.class, blockName);
+
+        return INSTANCE;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister ir) {
+        super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow");
+        super.iconJarSide = ir.registerIcon("kekztech:ichor_jar_side");
+        super.iconJarTop = ir.registerIcon("kekztech:ichor_jar_top");
+        super.iconJarTopVoid = ir.registerIcon("kekztech:ichor_jar_top_void");
+        super.iconJarSideVoid = ir.registerIcon("kekztech:ichor_jar_side_void");
+        super.iconJarBottom = ir.registerIcon("kekztech:ichor_jar_bottom");
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings({ "unchecked" })
+    public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) {
+        par3List.add(new ItemStack(par1, 1, 0)); // Normal jar
+        par3List.add(new ItemStack(par1, 1, 3)); // Void jar
+    }
+
+    @Override
+    public TileEntity createTileEntity(World world, int meta) {
+        if (meta == 3) {
+            return new TE_IchorVoidJar();
+        } else {
+            return new TE_IchorJar();
+        }
+    }
+
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float f1, float f2,
+        float f3) {
+        // Call parent method to handle jar emptying, labels stuff etc
+        super.onBlockActivated(world, x, y, z, player, side, f1, f2, f3);
+        // Interact with Essentia Phials if the player holds one
+        final ItemStack heldItem = player.getHeldItem();
+        if (heldItem != null && heldItem.getItem() == ConfigItems.itemEssence) {
+            final TileEntity te = world.getTileEntity(x, y, z);
+            if (te instanceof TE_IchorJar) {
+                return dealWithPhial(world, player, x, y, z);
+            } else if (te instanceof TE_IchorVoidJar) {
+                return dealWithPhial(world, player, x, y, z);
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Handle compatibility with Essentia Phials
+     *
+     * @param world  Pass through from onBlockActivated()
+     * @param player Pass through from onBlockActivated()
+     * @param x      Pass through from onBlockActivated()
+     * @param y      Pass through from onBlockActivated()
+     * @param z      Pass through from onBlockActivated()
+     * @return Not sure tbh
+     */
+    private boolean dealWithPhial(World world, EntityPlayer player, int x, int y, int z) {
+        final TileJarFillable jarTE = (TileJarFillable) world.getTileEntity(x, y, z);
+        final ItemStack heldItem = player.getHeldItem();
+        // Check whether to fill or to drain the phial
+        if (heldItem.getItemDamage() == 0) {
+            if (jarTE.amount >= 8) {
+                if (world.isRemote) {
+                    player.swingItem();
+                    return false;
+                }
+
+                final Aspect jarAspect = Aspect.getAspect(jarTE.aspect.getTag());
+                if (jarTE.takeFromContainer(jarAspect, 8)) {
+                    // Take an empty phial from the player's inventory
+                    heldItem.stackSize--;
+                    // Fill a new phial
+                    final ItemStack filledPhial = new ItemStack(ConfigItems.itemEssence, 1, 1);
+                    final AspectList phialContent = new AspectList().add(jarAspect, 8);
+                    ((ItemEssence) ConfigItems.itemEssence).setAspects(filledPhial, phialContent);
+                    // Drop on ground if there's no inventory space
+                    if (!player.inventory.addItemStackToInventory(filledPhial)) {
+                        world.spawnEntityInWorld(
+                            new EntityItem(world, (float) x + 0.5F, (float) y + 0.5F, (float) z + 0.5F, filledPhial));
+                    }
+
+                    world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F);
+                    player.inventoryContainer.detectAndSendChanges();
+                    return true;
+                }
+            }
+        } else {
+            final AspectList phialContent = ((ItemEssence) ConfigItems.itemEssence).getAspects(heldItem);
+            if (phialContent != null && phialContent.size() == 1) {
+                final Aspect phialAspect = phialContent.getAspects()[0];
+                if (jarTE.amount + 8 <= jarTE.maxAmount && jarTE.doesContainerAccept(phialAspect)) {
+                    if (world.isRemote) {
+                        player.swingItem();
+                        return false;
+                    }
+
+                    if (jarTE.addToContainer(phialAspect, 8) == 0) {
+                        world.markBlockForUpdate(x, y, z);
+                        jarTE.markDirty();
+                        heldItem.stackSize--;
+                        // Drop on ground if there's no inventory space
+                        if (!player.inventory.addItemStackToInventory(new ItemStack(ConfigItems.itemEssence, 1, 0))) {
+                            world.spawnEntityInWorld(
+                                new EntityItem(
+                                    world,
+                                    (float) x + 0.5F,
+                                    (float) y + 0.5F,
+                                    (float) z + 0.5F,
+                                    new ItemStack(ConfigItems.itemEssence, 1, 0)));
+                        }
+
+                        world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F);
+                        player.inventoryContainer.detectAndSendChanges();
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public void breakBlock(World world, int x, int y, int z, Block par5, int par6) {
+        final TileEntity te = world.getTileEntity(x, y, z);
+        if (te instanceof TE_IchorJar) {
+            final TE_IchorJar ite = (TE_IchorJar) te;
+            breakBlockWarpy(world, x, y, z, ite.amount, 200, 6.0F);
+        } else if (te instanceof TE_IchorVoidJar) {
+            final TE_IchorVoidJar ite = (TE_IchorVoidJar) te;
+            breakBlockWarpy(world, x, y, z, ite.amount, 200, 6.0F);
+        }
+        super.breakBlock(world, x, y, z, par5, par6);
+    }
+
+    private void breakBlockWarpy(World world, int x, int y, int z, int fillAmount, int iterations,
+        float explosionStrength) {
+        if (fillAmount > 0) {
+            // Create a decent explosion in the center of the block (TNT has strength 4.0F)
+            world.createExplosion(null, x + 0.5D, y + 0.5D, z + 0.5D, explosionStrength, false);
+
+            // Place a lot of Flux in the area
+            final int limit = fillAmount / 16;
+            int created = 0;
+            for (int i = 0; i < iterations; i++) {
+                final int xf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                final int yf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                final int zf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                if (world.isAirBlock(xf, yf, zf)) {
+                    if (yf > y) {
+                        world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGas, 8, 3);
+                    } else {
+                        world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGoo, 8, 3);
+                    }
+
+                    if (created++ > limit) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int meta, int fortune) {
+        return new ArrayList<>(Collections.singleton(new ItemStack(this, 1, (meta == 3) ? 3 : 0)));
+    }
+
+    @Override
+    public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5,
+        EntityPlayer par6EntityPlayer) {}
+
+    @Override
+    public boolean canDropFromExplosion(Explosion e) {
+        return false;
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java b/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java
new file mode 100644
index 0000000000..653c99216b
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java
@@ -0,0 +1,173 @@
+package common.blocks;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+
+import common.itemBlocks.IB_LapotronicEnergyUnit;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Utility;
+
+public class Block_LapotronicEnergyUnit extends BaseGTUpdateableBlock {
+
+    private static final Block_LapotronicEnergyUnit INSTANCE = new Block_LapotronicEnergyUnit();
+
+    public enum IconBaseSide implements IIconContainer {
+
+        INSTANCE;
+
+        @Override
+        public IIcon getIcon() {
+            return Block_LapotronicEnergyUnit.INSTANCE.iconBaseSide;
+        }
+
+        @Override
+        public IIcon getOverlayIcon() {
+            return null;
+        }
+
+        @Override
+        public ResourceLocation getTextureFile() {
+            return TextureMap.locationBlocksTexture;
+        }
+    }
+
+    static {
+        // technically, this page is owned by me, glee8e, however, I'm kind enough to spare 1 for kekztech since
+        // this is basically abandon ware by now.
+        GT_Utility.addTexturePage((byte) 42);
+        Textures.BlockIcons.setCasingTexture((byte) 42, (byte) 127, TextureFactory.of(IconBaseSide.INSTANCE));
+    }
+
+    private IIcon iconBaseSide;
+    private IIcon iconBaseTop;
+
+    private IIcon iconLapoEmptySide;
+    private IIcon iconLapoEmptyTop;
+    private IIcon iconLapoEVSide;
+    private IIcon iconLapoEVTop;
+    private IIcon iconLapoIVSide;
+    private IIcon iconLapoIVTop;
+    private IIcon iconLapoLuVSide;
+    private IIcon iconLapoLuVTop;
+    private IIcon iconLapoZPMSide;
+    private IIcon iconLapoZPMTop;
+    private IIcon iconLapoUVSide;
+    private IIcon iconLapoUVTop;
+    private IIcon iconUltimateSide;
+    private IIcon iconUltimateTop;
+    private IIcon iconUltimateExtremeSide;
+    private IIcon iconUltimateExtremeTop;
+    private IIcon iconUltimateInsaneSide;
+    private IIcon iconUltimateInsaneTop;
+    private IIcon iconUltimateMegaSide;
+    private IIcon iconUltimateMegaTop;
+
+    private Block_LapotronicEnergyUnit() {
+        super(Material.iron);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_lapotronicenergyunit_block";
+        INSTANCE.setBlockName(blockName);
+        INSTANCE.setCreativeTab(CreativeTabs.tabMisc);
+        INSTANCE.setHardness(5.0f);
+        INSTANCE.setResistance(6.0f);
+        GameRegistry.registerBlock(INSTANCE, IB_LapotronicEnergyUnit.class, blockName);
+
+        return INSTANCE;
+    }
+
+    @Override
+    public void registerBlockIcons(IIconRegister ir) {
+        iconBaseSide = ir.registerIcon("kekztech:LSCBase_side");
+        iconBaseTop = ir.registerIcon("kekztech:LSCBase_top");
+
+        iconLapoEmptySide = ir.registerIcon("kekztech:LapotronicEnergyUnit6_side");
+        iconLapoEmptyTop = ir.registerIcon("kekztech:LapotronicEnergyUnit6_top");
+        iconLapoEVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit7_side");
+        iconLapoEVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit7_top");
+        iconLapoIVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit1_side");
+        iconLapoIVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit1_top");
+        iconLapoLuVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit2_side");
+        iconLapoLuVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit2_top");
+        iconLapoZPMSide = ir.registerIcon("kekztech:LapotronicEnergyUnit3_side");
+        iconLapoZPMTop = ir.registerIcon("kekztech:LapotronicEnergyUnit3_top");
+        iconLapoUVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit4_side");
+        iconLapoUVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit4_top");
+
+        iconUltimateSide = ir.registerIcon("kekztech:UltimateEnergyUnit_side");
+        iconUltimateTop = ir.registerIcon("kekztech:UltimateEnergyUnit_top");
+        iconUltimateExtremeSide = ir.registerIcon("kekztech:ReallyUltimateEnergyUnit_side");
+        iconUltimateExtremeTop = ir.registerIcon("kekztech:ReallyUltimateEnergyUnit_top");
+        iconUltimateInsaneSide = ir.registerIcon("kekztech:InsanelyUltimateEnergyUnit_side");
+        iconUltimateInsaneTop = ir.registerIcon("kekztech:InsanelyUltimateEnergyUnit_top");
+        iconUltimateMegaSide = ir.registerIcon("kekztech:MegaUltimateEnergyUnit_side");
+        iconUltimateMegaTop = ir.registerIcon("kekztech:MegaUltimateEnergyUnit_top");
+    }
+
+    @Override
+    @SuppressWarnings({ "unchecked" })
+    public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) {
+        // Multi casing
+        par3List.add(new ItemStack(par1, 1, 0));
+        // Empty capacitor
+        par3List.add(new ItemStack(par1, 1, 6));
+        // Lapo capacitors EV - UV
+        par3List.add(new ItemStack(par1, 1, 7));
+        par3List.add(new ItemStack(par1, 1, 1));
+        par3List.add(new ItemStack(par1, 1, 2));
+        par3List.add(new ItemStack(par1, 1, 3));
+        par3List.add(new ItemStack(par1, 1, 4));
+        // Ultimate battery
+        par3List.add(new ItemStack(par1, 1, 5));
+        // UEV Cap
+        par3List.add(new ItemStack(par1, 1, 8));
+        // UIV Cap
+        par3List.add(new ItemStack(par1, 1, 9));
+        // UMV Cap
+        par3List.add(new ItemStack(par1, 1, 10));
+    }
+
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        switch (meta) {
+            case 0:
+                return (side < 2) ? iconBaseTop : iconBaseSide;
+            case 1:
+                return (side < 2) ? iconLapoIVTop : iconLapoIVSide;
+            case 2:
+                return (side < 2) ? iconLapoLuVTop : iconLapoLuVSide;
+            case 3:
+                return (side < 2) ? iconLapoZPMTop : iconLapoZPMSide;
+            case 4:
+                return (side < 2) ? iconLapoUVTop : iconLapoUVSide;
+            case 5:
+                return (side < 2) ? iconUltimateTop : iconUltimateSide;
+            case 6:
+                return (side < 2) ? iconLapoEmptyTop : iconLapoEmptySide;
+            case 7:
+                return (side < 2) ? iconLapoEVTop : iconLapoEVSide;
+            case 8:
+                return (side < 2) ? iconUltimateExtremeTop : iconUltimateExtremeSide;
+            case 9:
+                return (side < 2) ? iconUltimateInsaneTop : iconUltimateInsaneSide;
+            case 10:
+                return (side < 2) ? iconUltimateMegaTop : iconUltimateMegaSide;
+            default:
+                return iconUltimateTop;
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java b/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java
new file mode 100644
index 0000000000..ac8174ff34
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java
@@ -0,0 +1,65 @@
+package common.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class Block_LargeHexPlate extends Block {
+
+    private static final Block_LargeHexPlate INSTANCE = new Block_LargeHexPlate();
+    private static final int BATCH_SIZE = 4;
+
+    private final IIcon[][] parts = new IIcon[BATCH_SIZE][BATCH_SIZE];
+
+    private Block_LargeHexPlate() {
+        super(Material.rock);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_largehextile_block";
+        INSTANCE.setBlockName(blockName);
+        INSTANCE.setCreativeTab(CreativeTabs.tabMisc);
+        INSTANCE.setHardness(6.0f);
+        INSTANCE.setResistance(10.0f);
+        GameRegistry.registerBlock(INSTANCE, blockName);
+
+        return INSTANCE;
+    }
+
+    @Override
+    public void registerBlockIcons(IIconRegister ir) {
+        for (int x = 0; x < BATCH_SIZE; x++) {
+            for (int z = 0; z < BATCH_SIZE; z++) {
+                parts[x][z] = ir.registerIcon("kekztech:LargeHexTile_" + x + "_" + z);
+            }
+        }
+    }
+
+    @Override
+    public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+        final int xMod = x >= 0 ? Math.abs(x % BATCH_SIZE)
+            : Math.abs((Math.abs(x) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE;
+        final int yMod = y >= 0 ? Math.abs(y % BATCH_SIZE)
+            : Math.abs((Math.abs(y) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE;
+        final int zMod = z >= 0 ? Math.abs(z % BATCH_SIZE)
+            : Math.abs((Math.abs(z) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE;
+
+        if (side == 0 || side == 1) {
+            return parts[xMod][zMod];
+        } else if (side == 2 || side == 3) {
+            return parts[xMod][yMod];
+        } else {
+            return parts[zMod][yMod];
+        }
+    }
+
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return parts[(int) Math.ceil(BATCH_SIZE / 2)][(int) Math.ceil(BATCH_SIZE / 2)];
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java b/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java
new file mode 100644
index 0000000000..069dd40dca
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java
@@ -0,0 +1,92 @@
+package common.blocks;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+
+import common.itemBlocks.IB_TFFTStorageField;
+import common.tileentities.GTMTE_TFFT;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Utility;
+import kekztech.KekzCore;
+
+public class Block_TFFTStorageField extends BaseGTUpdateableBlock {
+
+    private static final Block_TFFTStorageField INSTANCE = new Block_TFFTStorageField();
+    private static final int SUB_BLOCK_COUNT = GTMTE_TFFT.Field.VALUES.length + 1;
+    private static final IIcon[] textures = new IIcon[SUB_BLOCK_COUNT];
+
+    public enum TFFTCasingIcon implements IIconContainer {
+
+        INSTANCE;
+
+        @Override
+        public IIcon getIcon() {
+            return textures[0];
+        }
+
+        @Override
+        public IIcon getOverlayIcon() {
+            return null;
+        }
+
+        @Override
+        public ResourceLocation getTextureFile() {
+            return TextureMap.locationBlocksTexture;
+        }
+    }
+
+    // I guess glodblock won't mind
+    static {
+        GT_Utility.addTexturePage((byte) 12);
+        Textures.BlockIcons
+            .setCasingTexture((byte) 12, (byte) 127, TextureFactory.of(Block_TFFTStorageField.TFFTCasingIcon.INSTANCE));
+    }
+
+    private Block_TFFTStorageField() {
+        super(Material.iron);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_tfftstoragefield_block";
+        INSTANCE.setBlockName(blockName);
+        INSTANCE.setCreativeTab(CreativeTabs.tabMisc);
+        INSTANCE.setHardness(5.0f);
+        INSTANCE.setResistance(6.0f);
+        GameRegistry.registerBlock(INSTANCE, IB_TFFTStorageField.class, blockName);
+
+        return INSTANCE;
+    }
+
+    @Override
+    public void registerBlockIcons(IIconRegister ir) {
+        textures[0] = ir.registerIcon(KekzCore.MODID + ":" + "TFFTCasing");
+        for (int i = 1; i < SUB_BLOCK_COUNT; i++) {
+            textures[i] = ir.registerIcon(KekzCore.MODID + ":" + "TFFTStorageFieldBlock" + i);
+        }
+    }
+
+    @Override
+    public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) {
+        for (int i = 0; i < SUB_BLOCK_COUNT; i++) {
+            par3List.add(new ItemStack(par1, 1, i));
+        }
+    }
+
+    @Override
+    public IIcon getIcon(int side, int meta) {
+        return textures[meta];
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java
new file mode 100644
index 0000000000..3c91ac6d0d
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java
@@ -0,0 +1,252 @@
+package common.blocks;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.World;
+
+import common.itemBlocks.IB_ThaumiumReinforcedJar;
+import common.tileentities.TE_ThaumiumReinforcedJar;
+import common.tileentities.TE_ThaumiumReinforcedVoidJar;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import thaumcraft.api.aspects.Aspect;
+import thaumcraft.api.aspects.AspectList;
+import thaumcraft.common.blocks.BlockJar;
+import thaumcraft.common.config.ConfigBlocks;
+import thaumcraft.common.config.ConfigItems;
+import thaumcraft.common.items.ItemEssence;
+import thaumcraft.common.tiles.TileJarFillable;
+
+public class Block_ThaumiumReinforcedJar extends BlockJar {
+
+    private static final Block_ThaumiumReinforcedJar INSTANCE = new Block_ThaumiumReinforcedJar();
+
+    private Block_ThaumiumReinforcedJar() {
+        super();
+
+        super.setHardness(6.0F);
+        super.setResistance(6.0F);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_thaumiumreinforcedjar_block";
+        INSTANCE.setBlockName(blockName);
+        INSTANCE.setHarvestLevel("pickaxe", 2);
+        GameRegistry.registerBlock(INSTANCE, IB_ThaumiumReinforcedJar.class, blockName);
+
+        return INSTANCE;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void registerBlockIcons(IIconRegister ir) {
+        super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow");
+        super.iconJarSide = ir.registerIcon("kekztech:thaumreinforced_jar_side");
+        super.iconJarTop = ir.registerIcon("kekztech:thaumreinforced_jar_top");
+        super.iconJarTopVoid = ir.registerIcon("kekztech:thaumreinforced_jar_top_void");
+        super.iconJarSideVoid = ir.registerIcon("kekztech:thaumreinforced_jar_side_void");
+        super.iconJarBottom = ir.registerIcon("kekztech:thaumreinforced_jar_bottom");
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    @SuppressWarnings({ "unchecked" })
+    public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) {
+        par3List.add(new ItemStack(par1, 1, 0)); // Normal jar
+        par3List.add(new ItemStack(par1, 1, 3)); // Void jar
+    }
+
+    @Override
+    public TileEntity createTileEntity(World world, int meta) {
+        if (meta == 3) {
+            return new TE_ThaumiumReinforcedVoidJar();
+        } else {
+            return new TE_ThaumiumReinforcedJar();
+        }
+    }
+
+    @Override
+    public void breakBlock(World world, int x, int y, int z, Block par5, int par6) {
+        final TileEntity te = world.getTileEntity(x, y, z);
+        if (te instanceof TE_ThaumiumReinforcedJar) {
+            final TE_ThaumiumReinforcedJar ite = (TE_ThaumiumReinforcedJar) te;
+            breakBlockWarpy(world, x, y, z, ite.amount, 50, 1.0F);
+        } else if (te instanceof TE_ThaumiumReinforcedVoidJar) {
+            final TE_ThaumiumReinforcedVoidJar ite = (TE_ThaumiumReinforcedVoidJar) te;
+            breakBlockWarpy(world, x, y, z, ite.amount, 50, 1.0F);
+        }
+        super.breakBlock(world, x, y, z, par5, par6);
+    }
+
+    private void breakBlockWarpy(World world, int x, int y, int z, int fillAmount, int iterations,
+        float explosionStrength) {
+        if (fillAmount > 0) {
+            // Create a decent explosion in the center of the block (TNT has strength 4.0F)
+            world.createExplosion(null, x + 0.5D, y + 0.5D, z + 0.5D, explosionStrength, false);
+
+            // Place a lot of Flux in the area
+            final int limit = fillAmount / 16;
+            int created = 0;
+            for (int i = 0; i < iterations; i++) {
+                final int xf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                final int yf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                final int zf = x + world.rand.nextInt(7) - world.rand.nextInt(7);
+                if (world.isAirBlock(xf, yf, zf)) {
+                    if (yf > y) {
+                        world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGas, 8, 3);
+                    } else {
+                        world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGoo, 8, 3);
+                    }
+
+                    if (created++ > limit) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float f1, float f2,
+        float f3) {
+        // Call parent method to handle jar emptying, labels stuff etc
+        super.onBlockActivated(world, x, y, z, player, side, f1, f2, f3);
+        // Interact with Essentia Phials if the player holds one
+        final ItemStack heldItem = player.getHeldItem();
+        if (heldItem != null && heldItem.getItem() == ConfigItems.itemEssence) {
+            final TileEntity te = world.getTileEntity(x, y, z);
+            if (te instanceof TE_ThaumiumReinforcedJar) {
+                return dealWithPhial(world, player, x, y, z);
+            } else if (te instanceof TE_ThaumiumReinforcedVoidJar) {
+                return dealWithPhial(world, player, x, y, z);
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Handle compatibility with Essentia Phials
+     *
+     * @param world  Pass through from onBlockActivated()
+     * @param player Pass through from onBlockActivated()
+     * @param x      Pass through from onBlockActivated()
+     * @param y      Pass through from onBlockActivated()
+     * @param z      Pass through from onBlockActivated()
+     * @return Not sure tbh
+     */
+    private boolean dealWithPhial(World world, EntityPlayer player, int x, int y, int z) {
+        final TileJarFillable kte = (TileJarFillable) world.getTileEntity(x, y, z);
+        final ItemStack heldItem = player.getHeldItem();
+        // Check whether to fill or to drain the phial
+        if (heldItem.getItemDamage() == 0) {
+            if (kte.amount >= 8) {
+                if (world.isRemote) {
+                    player.swingItem();
+                    return false;
+                }
+
+                final Aspect jarAspect = Aspect.getAspect(kte.aspect.getTag());
+                if (kte.takeFromContainer(jarAspect, 8)) {
+                    // Take an empty phial from the player's inventory
+                    heldItem.stackSize--;
+                    // Fill a new phial
+                    final ItemStack filledPhial = new ItemStack(ConfigItems.itemEssence, 1, 1);
+                    final AspectList phialContent = new AspectList().add(jarAspect, 8);
+                    ((ItemEssence) ConfigItems.itemEssence).setAspects(filledPhial, phialContent);
+                    // Drop on ground if there's no inventory space
+                    if (!player.inventory.addItemStackToInventory(filledPhial)) {
+                        world.spawnEntityInWorld(
+                            new EntityItem(world, (float) x + 0.5F, (float) y + 0.5F, (float) z + 0.5F, filledPhial));
+                    }
+
+                    world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F);
+                    player.inventoryContainer.detectAndSendChanges();
+                    return true;
+                }
+            }
+        } else {
+            final AspectList phialContent = ((ItemEssence) ConfigItems.itemEssence).getAspects(heldItem);
+            if (phialContent != null && phialContent.size() == 1) {
+                final Aspect phialAspect = phialContent.getAspects()[0];
+                if (kte.amount + 8 <= kte.maxAmount && kte.doesContainerAccept(phialAspect)) {
+                    if (world.isRemote) {
+                        player.swingItem();
+                        return false;
+                    }
+
+                    if (kte.addToContainer(phialAspect, 8) == 0) {
+                        world.markBlockForUpdate(x, y, z);
+                        kte.markDirty();
+                        heldItem.stackSize--;
+                        // Drop on ground if there's no inventory space
+                        if (!player.inventory.addItemStackToInventory(new ItemStack(ConfigItems.itemEssence, 1, 0))) {
+                            world.spawnEntityInWorld(
+                                new EntityItem(
+                                    world,
+                                    (float) x + 0.5F,
+                                    (float) y + 0.5F,
+                                    (float) z + 0.5F,
+                                    new ItemStack(ConfigItems.itemEssence, 1, 0)));
+                        }
+
+                        world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F);
+                        player.inventoryContainer.detectAndSendChanges();
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int meta, int fortune) {
+        final ArrayList<ItemStack> drops = new ArrayList<>();
+        drops.add(new ItemStack(this, 1, (meta == 3) ? 3 : 0));
+        final TileEntity te = world.getTileEntity(x, y, z);
+        if (te instanceof TE_ThaumiumReinforcedJar) {
+            final TE_ThaumiumReinforcedJar ite = (TE_ThaumiumReinforcedJar) te;
+            if (ite.aspectFilter != null) {
+                final ItemStack droppedLabel = new ItemStack(ConfigItems.itemResource, 1, 13);
+                droppedLabel.setTagCompound(new NBTTagCompound());
+                final AspectList aspect = new AspectList().add(ite.aspectFilter, 0);
+                aspect.writeToNBT(droppedLabel.getTagCompound());
+                drops.add(droppedLabel);
+            }
+        } else if (te instanceof TE_ThaumiumReinforcedVoidJar) {
+            final TE_ThaumiumReinforcedVoidJar ite = (TE_ThaumiumReinforcedVoidJar) te;
+            if (ite.aspectFilter != null) {
+                final ItemStack droppedLabel = new ItemStack(ConfigItems.itemResource, 1, 13);
+                droppedLabel.setTagCompound(new NBTTagCompound());
+                final AspectList aspect = new AspectList().add(ite.aspectFilter, 0);
+                aspect.writeToNBT(droppedLabel.getTagCompound());
+                drops.add(droppedLabel);
+            }
+        }
+        return drops;
+    }
+
+    @Override
+    public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5,
+        EntityPlayer par6EntityPlayer) {}
+
+    @Override
+    public boolean canDropFromExplosion(Explosion e) {
+        return false;
+    }
+}
diff --git a/kekztech/src/main/java/common/blocks/Block_YSZUnit.java b/kekztech/src/main/java/common/blocks/Block_YSZUnit.java
new file mode 100644
index 0000000000..312d3250a4
--- /dev/null
+++ b/kekztech/src/main/java/common/blocks/Block_YSZUnit.java
@@ -0,0 +1,29 @@
+package common.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import kekztech.KekzCore;
+
+public class Block_YSZUnit extends BaseGTUpdateableBlock {
+
+    private static final Block_YSZUnit instance = new Block_YSZUnit();
+
+    private Block_YSZUnit() {
+        super(Material.iron);
+    }
+
+    public static Block registerBlock() {
+        final String blockName = "kekztech_yszceramicelectrolyteunit_block";
+        instance.setBlockName(blockName);
+        instance.setCreativeTab(CreativeTabs.tabMisc);
+        instance.setBlockTextureName(KekzCore.MODID + ":" + "YSZCeramicElectrolyteUnit");
+        instance.setHardness(5.0f);
+        instance.setResistance(6.0f);
+        GameRegistry.registerBlock(instance, blockName);
+
+        return instance;
+    }
+}
diff --git a/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java b/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java
new file mode 100644
index 0000000000..6e2d806a7e
--- /dev/null
+++ b/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java
@@ -0,0 +1,27 @@
+package common.itemBlocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class IB_IchorJar extends ItemBlock {
+
+    public IB_IchorJar(Block block) {
+        super(block);
+    }
+
+    @Override
+    public int getMetadata(int meta) {
+        return meta;
+    }
+
+    @Override
+    public boolean getHasSubtypes() {
+        return true;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+}
diff --git a/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java b/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java
new file mode 100644
index 0000000000..971aac494a
--- /dev/null
+++ b/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java
@@ -0,0 +1,190 @@
+package common.itemBlocks;
+
+import static com.google.common.math.LongMath.pow;
+
+import java.math.BigInteger;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_Utility;
+
+public class IB_LapotronicEnergyUnit extends ItemBlock {
+
+    public IB_LapotronicEnergyUnit(Block block) {
+        super(block);
+    }
+
+    @Override
+    public int getMetadata(int meta) {
+        return meta;
+    }
+
+    @Override
+    public boolean getHasSubtypes() {
+        return true;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+
+    // 5 Minutes, 5 mins * 60s * 20 ticks.
+    public static long LSC_time_between_wireless_rebalance_in_ticks = 5L * 60L * 20L;
+
+    // 60 Trillion EU.
+    public static BigInteger LSC_wireless_eu_cap = BigInteger.valueOf(60 * pow(10, 12));
+
+    // 10 Billion EU/t
+    private static final BigInteger UHV_cap_eu_per_tick = LSC_wireless_eu_cap
+        .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks));
+
+    // 6 Quadrillion EU.
+    public static BigInteger UEV_wireless_eu_cap = BigInteger.valueOf(100 * 60 * pow(10, 12));
+
+    // 1 Trillion EU/t
+    private static final BigInteger UEV_cap_eu_per_tick = UEV_wireless_eu_cap
+        .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks));
+
+    // 600 Quadrillion EU.
+    public static BigInteger UIV_wireless_eu_cap = BigInteger.valueOf(60 * pow(10, 16));
+
+    // 100 Trillion EU/t
+    private static final BigInteger UIV_cap_eu_per_tick = UIV_wireless_eu_cap
+        .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks));
+
+    // 60 Quintillion EU.
+    public static BigInteger UMV_wireless_eu_cap = UIV_wireless_eu_cap.multiply(BigInteger.valueOf(100));
+
+    // 10 Quadrillion EU/t
+    private static final BigInteger UMV_cap_eu_per_tick = UMV_wireless_eu_cap
+        .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks));
+
+    public static long EV_cap_storage = 60_000_000L;
+    public static long IV_cap_storage = 600_000_000L;
+    public static long LuV_cap_storage = 6_000_000_000L;
+    public static long ZPM_cap_storage = 60_000_000_000L;
+    public static long UV_cap_storage = 600_000_000_000L;
+    public static long UHV_cap_storage = Long.MAX_VALUE;
+    public static long UEV_cap_storage = Long.MAX_VALUE;
+    public static long UIV_cap_storage = Long.MAX_VALUE;
+    public static BigInteger UMV_cap_storage = BigInteger.valueOf(UIV_cap_storage)
+        .pow(2);
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List lines, boolean advancedTooltips) {
+        lines.add(StatCollector.translateToLocal("tile.kekztech_lapotronicenergyunit_block.desc"));
+        switch (stack.getItemDamage()) {
+            case 1:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(IV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                break;
+            case 2:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(LuV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                break;
+            case 3:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(ZPM_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                break;
+            case 4:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                break;
+            case 5:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UHV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                lines.add(
+                    "Supports up to " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UHV_cap_eu_per_tick)
+                        + EnumChatFormatting.GRAY
+                        + "EU/t of wireless transfer per "
+                        + GT_Values.TIER_COLORS[9]
+                        + GT_Values.VN[9]
+                        + EnumChatFormatting.GRAY
+                        + " capacitor.");
+                break;
+            case 6:
+                lines.add("Capacity: None");
+                break;
+            case 7:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(EV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + " EU");
+                break;
+            case 8:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UEV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                lines.add(
+                    "Supports up to " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UEV_cap_eu_per_tick)
+                        + EnumChatFormatting.GRAY
+                        + "EU/t of wireless transfer per "
+                        + GT_Values.TIER_COLORS[10]
+                        + GT_Values.VN[10]
+                        + EnumChatFormatting.GRAY
+                        + " capacitor.");
+                break;
+            case 9:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UIV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                lines.add(
+                    "Supports up to " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UIV_cap_eu_per_tick)
+                        + EnumChatFormatting.GRAY
+                        + "EU/t of wireless transfer per "
+                        + GT_Values.TIER_COLORS[11]
+                        + GT_Values.VN[11]
+                        + EnumChatFormatting.GRAY
+                        + " capacitor.");
+                break;
+            case 10:
+                lines.add(
+                    "Capacity: " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UMV_cap_storage)
+                        + EnumChatFormatting.GRAY
+                        + "EU");
+                lines.add(
+                    "Supports up to " + EnumChatFormatting.RED
+                        + GT_Utility.formatNumbers(UMV_cap_eu_per_tick)
+                        + EnumChatFormatting.GRAY
+                        + "EU/t of wireless transfer per "
+                        + GT_Values.TIER_COLORS[12]
+                        + GT_Values.VN[12]
+                        + EnumChatFormatting.GRAY
+                        + " capacitor.");
+                break;
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java b/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java
new file mode 100644
index 0000000000..43f4523f27
--- /dev/null
+++ b/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java
@@ -0,0 +1,63 @@
+package common.itemBlocks;
+
+import java.text.NumberFormat;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+import common.tileentities.GTMTE_TFFT;
+
+public class IB_TFFTStorageField extends ItemBlock {
+
+    private static final int UNIQUE_FLUIDS_PER_CELL = 25;
+
+    public IB_TFFTStorageField(Block block) {
+        super(block);
+    }
+
+    @Override
+    public int getMetadata(int meta) {
+        return meta;
+    }
+
+    @Override
+    public boolean getHasSubtypes() {
+        return true;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List lines, boolean advancedTooltips) {
+        int meta = stack.getItemDamage();
+        if (meta > 0) {
+            lines.add(StatCollector.translateToLocal("tile.kekztech_tfftstoragefield_block.desc"));
+            lines.add(
+                "Capacity: " + EnumChatFormatting.BLUE
+                    + NumberFormat.getNumberInstance()
+                        .format(GTMTE_TFFT.Field.VALUES[meta - 1].getCapacity())
+                    + EnumChatFormatting.GRAY
+                    + " L");
+            lines.add(
+                "Per Fluid Capacity: " + EnumChatFormatting.BLUE
+                    + NumberFormat.getNumberInstance()
+                        .format(GTMTE_TFFT.Field.VALUES[meta - 1].getCapacity() / UNIQUE_FLUIDS_PER_CELL)
+                    + EnumChatFormatting.GRAY
+                    + " L");
+            lines.add(
+                "Power Draw: " + EnumChatFormatting.BLUE
+                    + GTMTE_TFFT.Field.VALUES[meta - 1].getCost()
+                    + EnumChatFormatting.GRAY
+                    + " EU/t");
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java
new file mode 100644
index 0000000000..9299126d67
--- /dev/null
+++ b/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java
@@ -0,0 +1,27 @@
+package common.itemBlocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class IB_ThaumiumReinforcedJar extends ItemBlock {
+
+    public IB_ThaumiumReinforcedJar(Block block) {
+        super(block);
+    }
+
+    @Override
+    public int getMetadata(int meta) {
+        return meta;
+    }
+
+    @Override
+    public boolean getHasSubtypes() {
+        return true;
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+}
diff --git a/kekztech/src/main/java/common/items/ErrorItem.java b/kekztech/src/main/java/common/items/ErrorItem.java
new file mode 100644
index 0000000000..997686a114
--- /dev/null
+++ b/kekztech/src/main/java/common/items/ErrorItem.java
@@ -0,0 +1,48 @@
+package common.items;
+
+import java.util.List;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import kekztech.KekzCore;
+
+public class ErrorItem extends Item {
+
+    private static final ErrorItem INSTANCE = new ErrorItem();
+
+    private ErrorItem() {}
+
+    public static ErrorItem getInstance() {
+        return INSTANCE;
+    }
+
+    public void registerItem() {
+        super.setHasSubtypes(false);
+        final String unlocalizedName = "kekztech_error_item";
+        super.setUnlocalizedName(unlocalizedName);
+        super.setCreativeTab(CreativeTabs.tabMisc);
+        super.setMaxStackSize(64);
+        super.setTextureName(KekzCore.MODID + ":" + "Error");
+        GameRegistry.registerItem(getInstance(), unlocalizedName);
+    }
+
+    @SuppressWarnings({ "unchecked" })
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b) {
+        list.add("REMINDER: KekzTech recipes are only tested to work in GTNH!");
+        list.add("Placeholder item in case something went wrong");
+        list.add("If this item shows up in GTNH, you may report it to:");
+        list.add("https://github.com/kekzdealer/KekzTech");
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack item, World world, EntityPlayer player) {
+        player.swingItem();
+        return item;
+    }
+}
diff --git a/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java b/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java
new file mode 100644
index 0000000000..205e7392c5
--- /dev/null
+++ b/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java
@@ -0,0 +1,89 @@
+package common.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import kekztech.KekzCore;
+
+public class MetaItem_CraftingComponent extends Item {
+
+    private static final MetaItem_CraftingComponent INSTANCE = new MetaItem_CraftingComponent();
+    private final IIcon[] icons = new IIcon[16];
+
+    private MetaItem_CraftingComponent() {}
+
+    public static MetaItem_CraftingComponent getInstance() {
+        return INSTANCE;
+    }
+
+    public void registerItem() {
+        super.setHasSubtypes(true);
+        final String unlocalizedName = "kekztech_crafting_item";
+        super.setUnlocalizedName(unlocalizedName);
+        super.setCreativeTab(CreativeTabs.tabMisc);
+        super.setMaxStackSize(64);
+        GameRegistry.registerItem(getInstance(), unlocalizedName);
+    }
+
+    @Override
+    public void registerIcons(IIconRegister reg) {
+        int counter = 9;
+        // Ceramics
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YSZCeramicDust");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "GDCCeramicDust");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YttriaDust");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "ZirconiaDust");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "CeriaDust");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YSZCeramicPlate");
+        icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "GDCCeramicPlate");
+    }
+
+    @Override
+    public IIcon getIconFromDamage(int meta) {
+        return icons[meta];
+    }
+
+    @SuppressWarnings({ "unchecked" })
+    @Override
+    public void getSubItems(Item item, CreativeTabs tab, List list) {
+        for (int i = 9; i < icons.length; i++) {
+            list.add(new ItemStack(item, 1, i));
+        }
+    }
+
+    @Override
+    public String getUnlocalizedName(ItemStack stack) {
+        return super.getUnlocalizedName() + "." + stack.getItemDamage();
+    }
+
+    @SuppressWarnings({ "unchecked" })
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b) {
+        list.add("Crafting component for KekzTech things");
+    }
+
+    @Override
+    public double getDurabilityForDisplay(ItemStack stack) {
+        return 0.0d;
+    }
+
+    @Override
+    public boolean showDurabilityBar(ItemStack stack) {
+        return false;
+    }
+
+    public ItemStack getStackFromDamage(int meta) {
+        return new ItemStack(getInstance(), 1, meta);
+    }
+
+    public ItemStack getStackOfAmountFromDamage(int meta, int amount) {
+        return new ItemStack(getInstance(), amount, meta);
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java b/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java
new file mode 100644
index 0000000000..2737d98f4a
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java
@@ -0,0 +1,32 @@
+package common.recipeLoaders;
+
+import static gregtech.api.enums.Mods.BartWorks;
+import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
+import common.items.MetaItem_CraftingComponent;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.TierEU;
+import kekztech.Items;
+
+public class AlloySmelter implements Runnable {
+
+    @Override
+    public void run() {
+        if (BartWorks.isModLoaded()) {
+            final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance();
+
+            // YSZ Cermic Plate
+            GT_Values.RA.stdBuilder()
+                .itemInputs(
+                    craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicDust.getMetaID(), 3),
+                    ItemList.Shape_Mold_Plate.get(0))
+                .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicPlate.getMetaID(), 1))
+                .duration(20 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(alloySmelterRecipes);
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/Assembler.java b/kekztech/src/main/java/common/recipeLoaders/Assembler.java
new file mode 100644
index 0000000000..da6c863689
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/Assembler.java
@@ -0,0 +1,295 @@
+package common.recipeLoaders;
+
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidRegistry;
+
+import common.Blocks;
+import common.TileEntities;
+import common.items.ErrorItem;
+import common.items.MetaItem_CraftingComponent;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import kekztech.Items;
+
+public class Assembler implements Runnable {
+
+    @Override
+    public void run() {
+        // TFFT Casing
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DarkSteel, 3),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnderPearl, 3))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1))
+            .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(144))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // TFFT Multi Hatch
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Hull_HV.get(1),
+                ItemList.Cover_FluidStorageMonitor.get(1),
+                ItemList.Field_Generator_LV.get(4),
+                GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Polytetrafluoroethylene, 25))
+            .itemOutputs(TileEntities.tfftHatch.getStackForm(1))
+            .fluidInputs(Materials.Plastic.getMolten(432))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // TFFTStorageField1
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CrudeSteel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrudeSteel, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Steel, 3),
+                ItemList.FluidRegulator_LV.get(1))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 1))
+            .fluidInputs(Materials.Glass.getMolten(144))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // TFFTStorageField2
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                ItemList.Casing_Tank_1.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnergeticSilver, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Plastic, 3),
+                ItemList.FluidRegulator_MV.get(1))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 2))
+            .fluidInputs(Materials.Plastic.getMolten(288))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // TFFTStorageField3
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                ItemList.Casing_Tank_3.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VividAlloy, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.StainlessSteel, 3),
+                ItemList.Field_Generator_LV.get(1),
+                ItemList.FluidRegulator_HV.get(1))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 3))
+            .fluidInputs(Materials.Plastic.getMolten(432))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // TFFTStorageField4
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                ItemList.Casing_Tank_5.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Enderium, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Polytetrafluoroethylene, 3),
+                ItemList.Field_Generator_MV.get(2),
+                ItemList.FluidRegulator_EV.get(1))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 4))
+            .fluidInputs(Materials.Epoxid.getMolten(864))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+        // TFFTStorageField5
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                ItemList.Casing_Tank_7.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrystallineAlloy, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Enderium, 3),
+                ItemList.Field_Generator_HV.get(4),
+                ItemList.FluidRegulator_IV.get(1))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 5))
+            .fluidInputs(Materials.Epoxid.getMolten(1152))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+        // LSC Casing
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tantalum, 4),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 2),
+                GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.TungstenSteel, 2),
+                GT_OreDictUnificator.get(OrePrefixes.block, Materials.Lapis, 1))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0))
+            .duration(5 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // EV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6),
+                GT_ModHandler.getIC2Item("lapotronCrystal", 1L, GT_Values.W),
+                GT_Utility.getIntegratedCircuit(7))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7))
+            .duration(10 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // IV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6),
+                ItemList.Energy_LapotronicOrb.get(1L),
+                GT_Utility.getIntegratedCircuit(1))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+        // LuV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Energy_LapotronicOrb2.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2))
+            .duration(40 * SECONDS)
+            .eut(TierEU.RECIPE_IV)
+            .addTo(assemblerRecipes);
+        // ZPM Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Energy_Module.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3))
+            .duration(1 * MINUTES + 20 * SECONDS)
+            .eut(TierEU.RECIPE_LuV)
+            .addTo(assemblerRecipes);
+        // UV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.Energy_Cluster.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4))
+            .duration(2 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_ZPM)
+            .addTo(assemblerRecipes);
+        // UHV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.ZPM3.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5))
+            .duration(5 * MINUTES + 20 * SECONDS)
+            .eut(TierEU.RECIPE_UV)
+            .addTo(assemblerRecipes);
+        // UEV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.ZPM4.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8))
+            .duration(10 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_UHV)
+            .addTo(assemblerRecipes);
+        // UIV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.ZPM5.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9))
+            .duration(10 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_UEV)
+            .addTo(assemblerRecipes);
+        // UMV Capacitor alt recipe
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                ItemList.ZPM6.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10))
+            .duration(10 * MINUTES + 40 * SECONDS)
+            .eut(TierEU.RECIPE_UIV)
+            .addTo(assemblerRecipes);
+
+        final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance();
+
+        // YSZ Unit
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicPlate.getMetaID(), 4),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Yttrium, 1),
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 1),
+                ItemList.Electric_Motor_HV.get(1L))
+            .itemOutputs(new ItemStack(Blocks.yszUnit, 1))
+            .fluidInputs(Materials.Hydrogen.getGas(4000))
+            .duration(60 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(assemblerRecipes);
+        // GDC Unit
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicPlate.getMetaID(), 8),
+                GT_OreDictUnificator
+                    .get(OrePrefixes.frameGt, Materials.Gadolinium, new ItemStack(ErrorItem.getInstance(), 1), 1),
+                GT_OreDictUnificator
+                    .get(OrePrefixes.rotor, Materials.Desh, new ItemStack(ErrorItem.getInstance(), 1), 1),
+                ItemList.Electric_Motor_IV.get(1L))
+            .itemOutputs(new ItemStack(Blocks.gdcUnit, 1))
+            .fluidInputs(Materials.Hydrogen.getGas(16000))
+            .duration(2 * MINUTES)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(assemblerRecipes);
+        // Hex Tiles
+
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_Utility.getIntegratedCircuit(6),
+                GT_OreDictUnificator.get(OrePrefixes.stone, Materials.Concrete, 1),
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.DarkSteel, 2))
+            .itemOutputs(new ItemStack(Blocks.largeHexPlate, 2))
+            .fluidInputs(FluidRegistry.getFluidStack("molten.plastic", 36))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_MV)
+            .addTo(assemblerRecipes);
+
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java b/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java
new file mode 100644
index 0000000000..cad3b4ec04
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java
@@ -0,0 +1,227 @@
+package common.recipeLoaders;
+
+import static gregtech.api.enums.Mods.Avaritia;
+import static gregtech.api.enums.Mods.EnderIO;
+import static gregtech.api.enums.Mods.EternalSingularity;
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.enums.Mods.GoodGenerator;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.enums.Mods.UniversalSingularities;
+import static gregtech.api.util.GT_RecipeBuilder.HOURS;
+import static gregtech.api.util.GT_RecipeBuilder.MINUTES;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeConstants.AssemblyLine;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM;
+import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import common.Blocks;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+
+public class AssemblyLine implements Runnable {
+
+    @Override
+    public void run() {
+        final Fluid radoxPoly = FluidRegistry.getFluid("molten.radoxpoly") != null
+            ? FluidRegistry.getFluid("molten.radoxpoly")
+            : FluidRegistry.getFluid("molten.polybenzimidazole");
+
+        final Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null
+            ? FluidRegistry.getFluid("molten.indalloy140")
+            : FluidRegistry.getFluid("molten.solderingalloy");
+
+        // TFFTStorageField6
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 5))
+            .metadata(RESEARCH_TIME, 1 * HOURS + 6 * MINUTES + 40 * SECONDS)
+            .itemInputs(
+                ItemList.Casing_Tank_7.get(4),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.CrystallinePinkSlime, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Naquadah, 3),
+                GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ChromeBars", 6),
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Quantium, 6),
+                ItemList.Field_Generator_EV.get(8),
+                ItemList.FluidRegulator_LuV.get(1),
+                GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EngineeringProcessorFluidEmeraldCore", 4))
+            .fluidInputs(Materials.Enderium.getMolten(1440), Materials.Polybenzimidazole.getMolten(1584))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 6))
+            .eut(TierEU.RECIPE_LuV)
+            .duration(30 * SECONDS)
+            .addTo(AssemblyLine);
+
+        // TFFTStorageField7
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 6))
+            .metadata(RESEARCH_TIME, 1 * HOURS + 6 * MINUTES + 40 * SECONDS)
+            .itemInputs(
+                ItemList.Casing_Tank_10.get(16),
+                GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.MelodicAlloy, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.NetherStar, 3),
+                GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OsmiumBars", 6),
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.MysteriousCrystal, 6),
+                ItemList.Field_Generator_IV.get(16),
+                ItemList.Field_Generator_LuV.get(4),
+                ItemList.FluidRegulator_UV.get(1),
+                GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EngineeringProcessorFluidEmeraldCore", 16))
+            .fluidInputs(Materials.CrystallineAlloy.getMolten(2880), Materials.Polybenzimidazole.getMolten(2016))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 7))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UV)
+            .addTo(AssemblyLine);
+
+        // TFFTStorageField8
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 7))
+            .metadata(RESEARCH_TIME, 2 * HOURS + 40 * MINUTES)
+            .itemInputs(
+                ItemList.Quantum_Tank_IV.get(1),
+                GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 1),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 6),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.DraconiumAwakened, 3),
+                GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.NeutroniumBars", 6),
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.InfinityCatalyst, 6),
+                ItemList.Field_Generator_ZPM.get(16),
+                ItemList.Field_Generator_UV.get(4),
+                GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 2),
+                GT_ModHandler.getModItem(UniversalSingularities.ID, "universal.tinkersConstruct.singularity", 1, 4))
+            .fluidInputs(Materials.CrystallinePinkSlime.getMolten(4320), new FluidStack(radoxPoly, 2880))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 8))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UEV)
+            .addTo(AssemblyLine);
+
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 8))
+            .metadata(RESEARCH_TIME, 2 * HOURS + 13 * MINUTES + 20 * SECONDS)
+            .itemInputs(
+                ItemList.Quantum_Tank_IV.get(4),
+                GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 2),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 3),
+                ItemList.EnergisedTesseract.get(1),
+                GT_ModHandler.getModItem(GTPlusPlus.ID, "itemRotorHypogen", 6),
+                ItemList.Field_Generator_UHV.get(16),
+                ItemList.Field_Generator_UEV.get(4),
+                GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 3),
+                GT_ModHandler.getModItem(UniversalSingularities.ID, "universal.tinkersConstruct.singularity", 1, 4))
+            .fluidInputs(Materials.MelodicAlloy.getMolten(5760), new FluidStack(radoxPoly, 3456))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 9))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UMV)
+            .addTo(AssemblyLine);
+
+        // TFFTStorageField10
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 9))
+            .metadata(RESEARCH_TIME, 2 * HOURS + 46 * MINUTES + 40 * SECONDS)
+            .itemInputs(
+                ItemList.Quantum_Tank_IV.get(16),
+                GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 4),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6),
+                GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6),
+                GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, MaterialsUEVplus.SpaceTime, 3),
+                ItemList.EnergisedTesseract.get(6),
+                GT_OreDictUnificator.get(OrePrefixes.rotor, MaterialsUEVplus.SpaceTime, 6),
+                ItemList.Field_Generator_UEV.get(16),
+                ItemList.Field_Generator_UIV.get(4),
+                GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 4),
+                GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 4),
+                GT_ModHandler.getModItem(EnderIO.ID, "itemBasicCapacitor", 64, 6),
+                GT_ModHandler.getModItem(EternalSingularity.ID, "eternal_singularity", 1))
+            .fluidInputs(Materials.StellarAlloy.getMolten(7200), new FluidStack(radoxPoly, 4608))
+            .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 10))
+            .duration(30 * SECONDS)
+            .eut(TierEU.RECIPE_UXV)
+            .addTo(AssemblyLine);
+
+        // LuV Capacitor
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1))
+            .metadata(RESEARCH_TIME, 4 * HOURS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24),
+                ItemList.Circuit_Board_Elite.get(1),
+                GT_OreDictUnificator.get(OrePrefixes.foil, Materials.NaquadahAlloy, 64),
+                new Object[] { OrePrefixes.circuit.get(Materials.Master), 4 },
+                ItemList.Circuit_Parts_Crystal_Chip_Master.get(36),
+                ItemList.Circuit_Parts_Crystal_Chip_Master.get(36),
+                ItemList.Circuit_Chip_HPIC.get(64),
+                ItemList.Circuit_Parts_DiodeASMD.get(8),
+                ItemList.Circuit_Parts_CapacitorASMD.get(8),
+                ItemList.Circuit_Parts_ResistorASMD.get(8),
+                ItemList.Circuit_Parts_TransistorASMD.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Platinum, 64))
+            .fluidInputs(new FluidStack(solderIndalloy, 720))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2))
+            .duration(50 * SECONDS)
+            .eut(80_000)
+            .addTo(AssemblyLine);
+
+        // ZPM Capacitor
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2))
+            .metadata(RESEARCH_TIME, 4 * HOURS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Europium, 16L),
+                new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 },
+                ItemList.Energy_LapotronicOrb2.get(8L),
+                ItemList.Field_Generator_LuV.get(2),
+                ItemList.Circuit_Wafer_SoC2.get(64),
+                ItemList.Circuit_Wafer_SoC2.get(64),
+                ItemList.Circuit_Parts_DiodeASMD.get(8),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 32))
+            .fluidInputs(
+                new FluidStack(solderIndalloy, 2880),
+                new FluidStack(FluidRegistry.getFluid("ic2coolant"), 16000))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3))
+            .duration(1 * MINUTES + 40 * SECONDS)
+            .eut(100_000)
+            .addTo(AssemblyLine);
+
+        // UV Capacitor
+        GT_Values.RA.stdBuilder()
+            .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3))
+            .metadata(RESEARCH_TIME, 4 * HOURS)
+            .itemInputs(
+                GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Americium, 32L),
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 },
+                ItemList.Energy_Module.get(8L),
+                ItemList.Field_Generator_ZPM.get(2),
+                ItemList.Circuit_Wafer_HPIC.get(64),
+                ItemList.Circuit_Wafer_HPIC.get(64),
+                ItemList.Circuit_Parts_DiodeASMD.get(16),
+                GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 32))
+            .fluidInputs(
+                new FluidStack(solderIndalloy, 2880),
+                new FluidStack(FluidRegistry.getFluid("ic2coolant"), 16000))
+            .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4))
+            .eut(200_000)
+            .duration(1 * MINUTES + 40 * SECONDS)
+            .addTo(AssemblyLine);
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java b/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java
new file mode 100644
index 0000000000..f67dd253fc
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java
@@ -0,0 +1,30 @@
+package common.recipeLoaders;
+
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+import static gregtech.api.util.GT_RecipeConstants.UniversalChemical;
+
+import common.items.MetaItem_CraftingComponent;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_Utility;
+import kekztech.Items;
+
+public class ChemicalReactor implements Runnable {
+
+    @Override
+    public void run() {
+        final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance();
+
+        // Ceria Dust
+        GT_Values.RA.stdBuilder()
+            .itemInputs(Materials.Cerium.getDust(2), GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.CeriaDust.getMetaID(), 2))
+            .fluidInputs(Materials.Oxygen.getGas(3000))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_LV)
+            .addTo(UniversalChemical);
+
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/Crafting.java b/kekztech/src/main/java/common/recipeLoaders/Crafting.java
new file mode 100644
index 0000000000..72985fd8ad
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/Crafting.java
@@ -0,0 +1,72 @@
+package common.recipeLoaders;
+
+import net.minecraft.item.ItemStack;
+
+import common.Blocks;
+import common.TileEntities;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import util.Util;
+
+public class Crafting implements Runnable {
+
+    @Override
+    public void run() {
+        // TFFT Controller
+        GT_ModHandler.addCraftingRecipe(
+            TileEntities.tfft.getStackForm(1),
+            new Object[] { "ESE", "FTF", "CVC", 'E', GT_OreDictUnificator.get(OrePrefixes.screw, Materials.EnderEye, 1),
+                'S', ItemList.Cover_Screen.get(1), 'F', ItemList.Field_Generator_LV.get(1), 'T',
+                new ItemStack(Blocks.tfftStorageField, 1), 'C', "circuitData", 'V',
+                GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.VibrantAlloy, 1), });
+
+        // SOFC Controller mk1
+        final Object[] mk1_recipe = { "CCC", "PHP", "FBL", 'C', OrePrefixes.circuit.get(Materials.Advanced), 'P',
+            ItemList.Electric_Pump_HV.get(1L), 'H', ItemList.Hull_HV.get(1L), 'F',
+            GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.StainlessSteel, 1), 'B',
+            GT_OreDictUnificator.get(OrePrefixes.cableGt02, Materials.Gold, 1), 'L',
+            GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.StainlessSteel, 1) };
+        GT_ModHandler.addCraftingRecipe(TileEntities.sofc1.getStackForm(1), mk1_recipe);
+
+        // SOFC Controller mk2
+        final Object[] mk2_recipe = { "CCC", "PHP", "FBL", 'C', OrePrefixes.circuit.get(Materials.Master), 'P',
+            ItemList.Electric_Pump_IV.get(1L), 'H', ItemList.Hull_IV.get(1L), 'F',
+            GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.Ultimate, 1), 'B',
+            Util.getStackofAmountFromOreDict("wireGt04SuperconductorEV", 1), 'L',
+            GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Ultimate, 1) };
+        GT_ModHandler.addCraftingRecipe(TileEntities.sofc2.getStackForm(1), mk2_recipe);
+
+        // LSC Controller
+        final Object[] lsc_recipe = { "LPL", "CBC", "LPL", 'L', ItemList.IC2_LapotronCrystal.getWildcard(1L), 'P',
+            ItemList.Circuit_Chip_PIC.get(1L), 'C', OrePrefixes.circuit.get(Materials.Master), 'B',
+            new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0), };
+        GT_ModHandler.addCraftingRecipe(TileEntities.lsc.getStackForm(1), lsc_recipe);
+
+        // LSC casing
+        final Object[] lcBase_recipe = { "WBW", "RLR", "WBW", 'W', OrePrefixes.plate.get(Materials.Tantalum), 'B',
+            OrePrefixes.frameGt.get(Materials.TungstenSteel), 'R', OrePrefixes.stickLong.get(Materials.TungstenSteel),
+            'L', OrePrefixes.block.get(Materials.Lapis) };
+        GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0), lcBase_recipe);
+
+        // Empty Capacitor
+        final Object[] lcEmpty_recipe = { "SLS", "L L", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L',
+            OrePrefixes.plate.get(Materials.Lapis) };
+        GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6), lcEmpty_recipe);
+
+        // EV Capacitor
+        final Object[] lcEV_recipe = { "SLS", "LCL", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L',
+            OrePrefixes.plate.get(Materials.Lapis), 'C', GT_ModHandler.getIC2Item("lapotronCrystal", 1L, GT_Values.W) };
+        GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7), lcEV_recipe);
+
+        // IV Capacitor
+        final Object[] lcIV_recipe = { "SLS", "LOL", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L',
+            OrePrefixes.plate.get(Materials.Lapis), 'O', ItemList.Energy_LapotronicOrb.get(1L) };
+        GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1), lcIV_recipe);
+
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/FormingPress.java b/kekztech/src/main/java/common/recipeLoaders/FormingPress.java
new file mode 100644
index 0000000000..d226ebf2a9
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/FormingPress.java
@@ -0,0 +1,29 @@
+package common.recipeLoaders;
+
+import static gregtech.api.recipe.RecipeMaps.formingPressRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
+import common.items.MetaItem_CraftingComponent;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.TierEU;
+import kekztech.Items;
+
+public class FormingPress implements Runnable {
+
+    @Override
+    public void run() {
+        final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance();
+
+        // YSZ Ceramic Plate
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicDust.getMetaID(), 10),
+                ItemList.Shape_Mold_Plate.get(0))
+            .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicPlate.getMetaID(), 1))
+            .duration(40 * SECONDS)
+            .eut(TierEU.RECIPE_HV)
+            .addTo(formingPressRecipes);
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/Mixer.java b/kekztech/src/main/java/common/recipeLoaders/Mixer.java
new file mode 100644
index 0000000000..0fd329a01b
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/Mixer.java
@@ -0,0 +1,48 @@
+package common.recipeLoaders;
+
+import static gregtech.api.recipe.RecipeMaps.mixerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
+import net.minecraft.item.ItemStack;
+
+import common.items.ErrorItem;
+import common.items.MetaItem_CraftingComponent;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import kekztech.Items;
+
+public class Mixer implements Runnable {
+
+    @Override
+    public void run() {
+        final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance();
+
+        // YSZ Ceramic Dust
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                Items.YttriaDust.getOreDictedItemStack(1),
+                Items.ZirconiaDust.getOreDictedItemStack(5),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicDust.getMetaID(), 6))
+            .duration(20 * SECONDS)
+            .eut(96)
+            .addTo(mixerRecipes);
+
+        // GDC Ceramic Dust
+        GT_Values.RA.stdBuilder()
+            .itemInputs(
+                GT_OreDictUnificator
+                    .get(OrePrefixes.dust, Materials.Gadolinium, new ItemStack(ErrorItem.getInstance(), 1), 1),
+                craftingItem.getStackOfAmountFromDamage(Items.CeriaDust.getMetaID(), 9),
+                GT_Utility.getIntegratedCircuit(6))
+            .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicDust.getMetaID(), 10))
+            .duration(20 * SECONDS)
+            .eut(TierEU.RECIPE_EV)
+            .addTo(mixerRecipes);
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java b/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java
new file mode 100644
index 0000000000..fe1aaaf70e
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java
@@ -0,0 +1,137 @@
+package common.recipeLoaders;
+
+import static gregtech.api.enums.Mods.GTPlusPlus;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.github.technus.tectech.recipe.TT_recipeAdder;
+import common.Blocks;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+
+public class ResearchableAssemblyLine implements Runnable {
+
+    @Override
+    public void run() {
+        final Fluid solderUEV = FluidRegistry.getFluid("molten.mutatedlivingsolder") != null
+            ? FluidRegistry.getFluid("molten.mutatedlivingsolder")
+            : FluidRegistry.getFluid("molten.solderingalloy");
+
+        // Extremely Ultimate Capacitor (UEV)
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5),
+            1200000,
+            128,
+            8000000,
+            16,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.InfinityCatalyst, 32L),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.InfinityCatalyst, 32L),
+                new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 }, ItemList.ZPM3.get(8L),
+                ItemList.Field_Generator_UEV.get(4), ItemList.Circuit_Wafer_PPIC.get(64),
+                ItemList.Circuit_Wafer_PPIC.get(64), ItemList.Circuit_Wafer_SoC2.get(64),
+                ItemList.Circuit_Parts_DiodeXSMD.get(64),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64) },
+            new FluidStack[] { new FluidStack(solderUEV, 9216), Materials.Quantium.getMolten(18432),
+                Materials.Naquadria.getMolten(18432), Materials.SuperCoolant.getFluid(64000) },
+            new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8),
+            250 * 20,
+            (int) TierEU.RECIPE_UEV);
+
+        if (GTPlusPlus.isModLoaded()) {
+            // Insanely Ultimate Capacitor (UIV)
+            TT_recipeAdder.addResearchableAssemblylineRecipe(
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8),
+                24_000_000,
+                1_280,
+                32_000_000,
+                32,
+                new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 4),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24),
+                    GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleHypogen", 32),
+                    GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleHypogen", 32),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 }, ItemList.ZPM4.get(8L),
+                    ItemList.Field_Generator_UIV.get(4), ItemList.Circuit_Wafer_QPIC.get(64),
+                    ItemList.Circuit_Wafer_QPIC.get(64),
+                    GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RawPicoWafer", 64),
+                    ItemList.Circuit_Parts_DiodeXSMD.get(64), ItemList.Circuit_Parts_InductorXSMD.get(32),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt08, Materials.SuperconductorUIV, 64) },
+                new FluidStack[] { new FluidStack(solderUEV, 18_432),
+                    new FluidStack(FluidRegistry.getFluid("molten.celestialtungsten"), 18432),
+                    Materials.Quantium.getMolten(18_432), Materials.SuperCoolant.getFluid(128_000) },
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9),
+                300 * 20,
+                (int) TierEU.RECIPE_UIV);
+
+            // Mega Ultimate Capacitor (UMV)
+            TT_recipeAdder.addResearchableAssemblylineRecipe(
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9),
+                480_000_000,
+                12_288,
+                128_000_000,
+                64,
+                new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 4),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24),
+                    GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleDragonblood", 32),
+                    GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleDragonblood", 32),
+                    new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 },
+                    new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 }, ItemList.ZPM5.get(8L),
+                    ItemList.Field_Generator_UMV.get(4), ItemList.Circuit_Wafer_QPIC.get(64),
+                    ItemList.Circuit_Wafer_QPIC.get(64),
+                    GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PicoWafer", 64),
+                    ItemList.Circuit_Parts_DiodeXSMD.get(64), ItemList.Circuit_Parts_InductorXSMD.get(64),
+                    GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUMV, 64) },
+                new FluidStack[] { new FluidStack(solderUEV, 36_864),
+                    new FluidStack(FluidRegistry.getFluid("molten.astraltitanium"), 36_864),
+                    new FluidStack(FluidRegistry.getFluid("molten.celestialtungsten"), 36_864),
+                    Materials.SuperCoolant.getFluid(256_000) },
+                new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10),
+                350 * 20,
+                (int) TierEU.RECIPE_UMV);
+        }
+
+        // Ultimate Capacitor (UHV)
+        TT_recipeAdder.addResearchableAssemblylineRecipe(
+            new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4),
+            12000,
+            16,
+            300000,
+            3,
+            new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 4),
+                GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Neutronium, 32L),
+                GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Neutronium, 32L),
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 },
+                new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 }, ItemList.ZPM2.get(8L),
+                ItemList.Field_Generator_UHV.get(4), ItemList.Circuit_Wafer_UHPIC.get(64),
+                ItemList.Circuit_Wafer_UHPIC.get(64), ItemList.Circuit_Wafer_SoC2.get(32),
+                ItemList.Circuit_Parts_DiodeASMD.get(64),
+                GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUHV, 64) },
+            new FluidStack[] { new FluidStack(solderUEV, 4608), Materials.Naquadria.getMolten(9216),
+                new FluidStack(FluidRegistry.getFluid("ic2coolant"), 32000) },
+            new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5),
+            4000,
+            1600000);
+    }
+}
diff --git a/kekztech/src/main/java/common/recipeLoaders/Unpackager.java b/kekztech/src/main/java/common/recipeLoaders/Unpackager.java
new file mode 100644
index 0000000000..ec25f5c89c
--- /dev/null
+++ b/kekztech/src/main/java/common/recipeLoaders/Unpackager.java
@@ -0,0 +1,200 @@
+package common.recipeLoaders;
+
+import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes;
+import static gregtech.api.util.GT_RecipeBuilder.SECONDS;
+
+import net.minecraft.item.ItemStack;
+
+import common.Blocks;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.MaterialsUEVplus;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.TierEU;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+
+public class Unpackager implements Runnable {
+
+    @Override
+    public void run() {
+
+        // TFFT Recycling
+        {
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 1))
+                .itemOutputs(
+                    GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CrudeSteel, 1),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrudeSteel, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 2))
+                .itemOutputs(
+                    ItemList.Casing_Tank_1.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnergeticSilver, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 3))
+                .itemOutputs(
+                    ItemList.Casing_Tank_3.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VividAlloy, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 4))
+                .itemOutputs(
+                    ItemList.Casing_Tank_5.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Enderium, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 5))
+                .itemOutputs(
+                    ItemList.Casing_Tank_7.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrystallineAlloy, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 6))
+                .itemOutputs(
+                    ItemList.Casing_Tank_7.get(4),
+                    GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.CrystallinePinkSlime, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 7))
+                .itemOutputs(
+                    ItemList.Casing_Tank_10.get(16),
+                    GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.MelodicAlloy, 6))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 8))
+                .itemOutputs(
+                    ItemList.Quantum_Tank_IV.get(1),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 12))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 9))
+                .itemOutputs(
+                    ItemList.Quantum_Tank_IV.get(4),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 12))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 10))
+                .itemOutputs(
+                    ItemList.Quantum_Tank_IV.get(16),
+                    GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 12))
+                .duration(5 * SECONDS)
+                .eut(TierEU.RECIPE_HV)
+                .addTo(unpackagerRecipes);
+
+        }
+
+        // Capacitor recycling
+        {
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7))
+                .itemOutputs(
+                    GT_ModHandler.getIC2Item("lapotronCrystal", 1L, 26),
+                    new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1))
+                .itemOutputs(ItemList.Energy_LapotronicOrb.get(1L), new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2))
+                .itemOutputs(
+                    ItemList.Energy_LapotronicOrb2.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3))
+                .itemOutputs(
+                    ItemList.Energy_Module.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4))
+                .itemOutputs(
+                    ItemList.Energy_Cluster.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5))
+                .itemOutputs(
+                    ItemList.ZPM3.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8))
+                .itemOutputs(ItemList.ZPM4.get(1L), GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9))
+                .itemOutputs(
+                    ItemList.ZPM5.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+            GT_Values.RA.stdBuilder()
+                .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10))
+                .itemOutputs(
+                    ItemList.ZPM6.get(1L),
+                    GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24))
+                .duration(60 * SECONDS)
+                .eut(TierEU.RECIPE_LV)
+                .addTo(unpackagerRecipes);
+
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java b/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java
new file mode 100644
index 0000000000..40fbb656c8
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java
@@ -0,0 +1,1189 @@
+package common.tileentities;
+
+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.onlyIf;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.withChannel;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.EV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.IV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.LSC_time_between_wireless_rebalance_in_ticks;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.LSC_wireless_eu_cap;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.LuV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UEV_wireless_eu_cap;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UIV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UIV_wireless_eu_cap;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UMV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UMV_wireless_eu_cap;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.UV_cap_storage;
+import static common.itemBlocks.IB_LapotronicEnergyUnit.ZPM_cap_storage;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static gregtech.api.util.GT_StructureUtility.filterByMTEClass;
+import static java.lang.Math.min;
+import static util.Util.toPercentageFrom;
+import static util.Util.toStandardForm;
+
+import java.math.BigInteger;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti;
+import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoTunnel;
+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.google.common.collect.ImmutableList;
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+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.StructureUtility;
+import com.gtnewhorizon.structurelib.util.ItemStackPredicate.NBTMode;
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.UITexture;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import common.Blocks;
+
+import client.gui.KT_UITextures;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.gui.modularui.GT_UITextures;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.IGT_HatchAdder;
+import gregtech.common.misc.WirelessNetworkManager;
+
+public class GTMTE_LapotronicSuperCapacitor
+    extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_LapotronicSuperCapacitor> implements ISurvivalConstructable {
+
+    private enum TopState {
+        MayBeTop,
+        Top,
+        NotTop
+    }
+
+    private boolean canUseWireless = false;
+    private boolean wireless_mode = false;
+    private boolean not_processed_lsc = true;
+    private int counter = 1;
+
+    private final Queue<Long> energyInputValues = new LinkedList<>();
+    private final Queue<Long> energyOutputValues = new LinkedList<>();
+
+    private final long max_passive_drain_eu_per_tick_per_uhv_cap = 1_000_000;
+    private final long max_passive_drain_eu_per_tick_per_uev_cap = 100_000_000;
+    private final long max_passive_drain_eu_per_tick_per_uiv_cap = (long) Math.pow(10, 10);
+    private final long max_passive_drain_eu_per_tick_per_umv_cap = (long) Math.pow(10, 12);
+
+    private enum Capacitor {
+
+        IV(2, BigInteger.valueOf(IV_cap_storage)),
+        LuV(3, BigInteger.valueOf(LuV_cap_storage)),
+        ZPM(4, BigInteger.valueOf(ZPM_cap_storage)),
+        UV(5, BigInteger.valueOf(UV_cap_storage)),
+        UHV(6, MAX_LONG),
+        None(0, BigInteger.ZERO),
+        EV(1, BigInteger.valueOf(EV_cap_storage)),
+        UEV(7, MAX_LONG),
+        UIV(8, BigInteger.valueOf(UIV_cap_storage)),
+        UMV(9, UMV_cap_storage);
+
+        private final int minimalGlassTier;
+        private final BigInteger providedCapacity;
+        static final Capacitor[] VALUES = values();
+        static final Capacitor[] VALUES_BY_TIER = Arrays.stream(values())
+            .sorted(Comparator.comparingInt(Capacitor::getMinimalGlassTier))
+            .toArray(Capacitor[]::new);
+
+        Capacitor(int minimalGlassTier, BigInteger providedCapacity) {
+            this.minimalGlassTier = minimalGlassTier;
+            this.providedCapacity = providedCapacity;
+        }
+
+        public int getMinimalGlassTier() {
+            return minimalGlassTier;
+        }
+
+        public BigInteger getProvidedCapacity() {
+            return providedCapacity;
+        }
+
+        public static int getIndexFromGlassTier(int glassTier) {
+            for (int index = 0; index < values().length; index++) {
+                if (values()[index].getMinimalGlassTier() == glassTier) {
+                    return index;
+                }
+            }
+            return -1;
+        }
+    }
+
+    private static final String STRUCTURE_PIECE_BASE = "base";
+    private static final String STRUCTURE_PIECE_LAYER = "slice";
+    private static final String STRUCTURE_PIECE_TOP = "top";
+    private static final String STRUCTURE_PIECE_MID = "mid";
+    private static final int GLASS_TIER_UNSET = -2;
+
+    private static final Block LSC_PART = Blocks.lscLapotronicEnergyUnit;
+    private static final Item LSC_PART_ITEM = Item.getItemFromBlock(LSC_PART);
+    private static final int CASING_META = 0;
+    private static final int CASING_TEXTURE_ID = (42 << 7) | 127;
+
+    private static final int DURATION_AVERAGE_TICKS = 100;
+
+    // height channel for height.
+    // glass channel for glass
+    // capacitor channel for capacitor, but it really just pick whatever capacitor it can find in survival
+    private static final IStructureDefinition<GTMTE_LapotronicSuperCapacitor> STRUCTURE_DEFINITION = IStructureDefinition
+        .<GTMTE_LapotronicSuperCapacitor>builder()
+        .addShape(
+            STRUCTURE_PIECE_BASE,
+            transpose(
+                new String[][] { { "bbbbb", "bbbbb", "bbbbb", "bbbbb", "bbbbb", },
+                    { "bb~bb", "bbbbb", "bbbbb", "bbbbb", "bbbbb", }, }))
+        .addShape(
+            STRUCTURE_PIECE_LAYER,
+            transpose(new String[][] { { "ggggg", "gcccg", "gcccg", "gcccg", "ggggg", }, }))
+        .addShape(STRUCTURE_PIECE_TOP, transpose(new String[][] { { "ggggg", "ggggg", "ggggg", "ggggg", "ggggg", }, }))
+        .addShape(STRUCTURE_PIECE_MID, transpose(new String[][] { { "ggggg", "gCCCg", "gCCCg", "gCCCg", "ggggg", }, }))
+        .addElement(
+            'b',
+            buildHatchAdder(GTMTE_LapotronicSuperCapacitor.class)
+                .atLeast(LSCHatchElement.Energy, LSCHatchElement.Dynamo, Maintenance)
+                .hatchItemFilterAnd(
+                    (t, h) -> ChannelDataAccessor.getChannelData(h, "glass") < 6
+                        ? filterByMTEClass(
+                            ImmutableList.of(
+                                GT_MetaTileEntity_Hatch_EnergyTunnel.class,
+                                GT_MetaTileEntity_Hatch_DynamoTunnel.class)).negate()
+                        : s -> true)
+                .casingIndex(CASING_TEXTURE_ID)
+                .dot(1)
+                .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(LSC_PART, CASING_META))))
+        .addElement(
+            'g',
+            withChannel(
+                "glass",
+                BorosilicateGlass
+                    .ofBoroGlass((byte) GLASS_TIER_UNSET, (te, t) -> te.glassTier = t, te -> te.glassTier)))
+        .addElement(
+            'c',
+            ofChain(
+                onlyIf(
+                    te -> te.topState != TopState.NotTop,
+                    onElementPass(
+                        te -> te.topState = TopState.Top,
+                        withChannel(
+                            "glass",
+                            BorosilicateGlass.ofBoroGlass(
+                                (byte) GLASS_TIER_UNSET,
+                                (te, t) -> te.glassTier = t,
+                                te -> te.glassTier)))),
+                onlyIf(
+                    te -> te.topState != TopState.Top,
+                    onElementPass(
+                        te -> te.topState = TopState.NotTop,
+                        new IStructureElement<GTMTE_LapotronicSuperCapacitor>() {
+
+                            @Override
+                            public boolean check(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y, int z) {
+                                Block worldBlock = world.getBlock(x, y, z);
+                                int meta = worldBlock.getDamageValue(world, x, y, z);
+                                if (LSC_PART != worldBlock || meta == 0) return false;
+                                t.capacitors[meta - 1]++;
+                                return true;
+                            }
+
+                            private int getHint(ItemStack stack) {
+                                return Capacitor.VALUES_BY_TIER[Math.min(
+                                    Capacitor.VALUES_BY_TIER.length,
+                                    ChannelDataAccessor.getChannelData(stack, "capacitor")) - 1].getMinimalGlassTier()
+                                    + 1;
+                            }
+
+                            @Override
+                            public boolean spawnHint(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y, int z,
+                                ItemStack trigger) {
+                                StructureLibAPI.hintParticle(world, x, y, z, LSC_PART, getHint(trigger));
+                                return true;
+                            }
+
+                            @Override
+                            public boolean placeBlock(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y,
+                                int z, ItemStack trigger) {
+                                world.setBlock(x, y, z, LSC_PART, getHint(trigger), 3);
+                                return true;
+                            }
+
+                            @Override
+                            public PlaceResult survivalPlaceBlock(GTMTE_LapotronicSuperCapacitor t, World world, int x,
+                                int y, int z, ItemStack trigger, IItemSource source, EntityPlayerMP actor,
+                                Consumer<IChatComponent> chatter) {
+                                if (check(t, world, x, y, z)) return PlaceResult.SKIP;
+                                int glassTier = ChannelDataAccessor.getChannelData(trigger, "glass") + 2;
+                                ItemStack targetStack = source
+                                    .takeOne(
+                                        s -> s != null && s.stackSize >= 0
+                                            && s.getItem() == LSC_PART_ITEM
+                                            && Capacitor.VALUES[Math.min(s.getItemDamage(), Capacitor.VALUES.length)
+                                                - 1].getMinimalGlassTier() > glassTier,
+                                        true);
+                                if (targetStack == null) return PlaceResult.REJECT;
+                                return StructureUtility.survivalPlaceBlock(
+                                    targetStack,
+                                    NBTMode.EXACT,
+                                    targetStack.stackTagCompound,
+                                    true,
+                                    world,
+                                    x,
+                                    y,
+                                    z,
+                                    source,
+                                    actor,
+                                    chatter);
+                            }
+                        }))))
+        .addElement('C', ofBlock(LSC_PART, 1))
+        .build();
+
+    private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
+
+    private final Set<GT_MetaTileEntity_Hatch_EnergyMulti> mEnergyHatchesTT = new HashSet<>();
+    private final Set<GT_MetaTileEntity_Hatch_DynamoMulti> mDynamoHatchesTT = new HashSet<>();
+    private final Set<GT_MetaTileEntity_Hatch_EnergyTunnel> mEnergyTunnelsTT = new HashSet<>();
+    private final Set<GT_MetaTileEntity_Hatch_DynamoTunnel> mDynamoTunnelsTT = new HashSet<>();
+    /**
+     * Count the amount of capacitors of each tier in each slot. Index = meta - 1
+     */
+    private final int[] capacitors = new int[10];
+
+    private BigInteger capacity = BigInteger.ZERO;
+    private BigInteger stored = BigInteger.ZERO;
+    private long passiveDischargeAmount = 0;
+    private long inputLastTick = 0;
+    private long outputLastTick = 0;
+    private int repairStatusCache = 0;
+
+    private byte glassTier = -1;
+    private int casingAmount = 0;
+    private TopState topState = TopState.MayBeTop;
+
+    private long mMaxEUIn = 0;
+    private long mMaxEUOut = 0;
+
+    public GTMTE_LapotronicSuperCapacitor(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GTMTE_LapotronicSuperCapacitor(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+        return new GTMTE_LapotronicSuperCapacitor(super.mName);
+    }
+
+    @Override
+    public IStructureDefinition<GTMTE_LapotronicSuperCapacitor> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    private void processInputHatch(GT_MetaTileEntity_Hatch aHatch, int aBaseCasingIndex) {
+        mMaxEUIn += aHatch.maxEUInput() * aHatch.maxAmperesIn();
+        aHatch.updateTexture(aBaseCasingIndex);
+    }
+
+    private void processOutputHatch(GT_MetaTileEntity_Hatch aHatch, int aBaseCasingIndex) {
+        mMaxEUOut += aHatch.maxEUOutput() * aHatch.maxAmperesOut();
+        aHatch.updateTexture(aBaseCasingIndex);
+    }
+
+    private boolean addBottomHatches(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity == null || aTileEntity.isDead()) return false;
+        IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+        if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch)) return false;
+        if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) {
+            ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+            return GTMTE_LapotronicSuperCapacitor.this.mMaintenanceHatches
+                .add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) {
+            // Add GT hatches
+            final GT_MetaTileEntity_Hatch_Energy tHatch = ((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity);
+            processInputHatch(tHatch, aBaseCasingIndex);
+            return mEnergyHatches.add(tHatch);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyTunnel) {
+            // Add TT Laser hatches
+            final GT_MetaTileEntity_Hatch_EnergyTunnel tHatch = ((GT_MetaTileEntity_Hatch_EnergyTunnel) aMetaTileEntity);
+            processInputHatch(tHatch, aBaseCasingIndex);
+            return mEnergyTunnelsTT.add(tHatch);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+            // Add TT hatches
+            final GT_MetaTileEntity_Hatch_EnergyMulti tHatch = (GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity;
+            processInputHatch(tHatch, aBaseCasingIndex);
+            return mEnergyHatchesTT.add(tHatch);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo) {
+            // Add GT hatches
+            final GT_MetaTileEntity_Hatch_Dynamo tDynamo = (GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity;
+            processOutputHatch(tDynamo, aBaseCasingIndex);
+            return mDynamoHatches.add(tDynamo);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoTunnel) {
+            // Add TT Laser hatches
+            final GT_MetaTileEntity_Hatch_DynamoTunnel tDynamo = (GT_MetaTileEntity_Hatch_DynamoTunnel) aMetaTileEntity;
+            processOutputHatch(tDynamo, aBaseCasingIndex);
+            return mDynamoTunnelsTT.add(tDynamo);
+        } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoMulti) {
+            // Add TT hatches
+            final GT_MetaTileEntity_Hatch_DynamoMulti tDynamo = (GT_MetaTileEntity_Hatch_DynamoMulti) aMetaTileEntity;
+            processOutputHatch(tDynamo, aBaseCasingIndex);
+            return mDynamoHatchesTT.add(tDynamo);
+        }
+        return false;
+    }
+
+    private int getUHVCapacitorCount() {
+        return capacitors[4];
+    }
+
+    private int getUEVCapacitorCount() {
+        return capacitors[7];
+    }
+
+    private int getUIVCapacitorCount() {
+        return capacitors[8];
+    }
+
+    private int getUMVCapacitorCount() {
+        return capacitors[9];
+    }
+
+    private int wirelessCapableCapacitors() {
+        return capacitors[4] + capacitors[7] + capacitors[8] + capacitors[9];
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Energy Storage")
+            .addInfo("Loses energy equal to 1% of the total capacity every 24 hours.")
+            .addInfo(
+                "Capped at " + EnumChatFormatting.RED
+                    + GT_Utility.formatNumbers(max_passive_drain_eu_per_tick_per_uhv_cap)
+                    + EnumChatFormatting.GRAY
+                    + " EU/t passive loss per "
+                    + GT_Values.TIER_COLORS[9]
+                    + GT_Values.VN[9]
+                    + EnumChatFormatting.GRAY
+                    + " capacitor.")
+            .addInfo(
+                "The passive loss increases " + EnumChatFormatting.DARK_RED
+                    + "100"
+                    + EnumChatFormatting.GRAY
+                    + "-fold"
+                    + " for every capacitor tier above.")
+            .addInfo("Passive loss is multiplied by the number of maintenance issues present.")
+            .addSeparator()
+            .addInfo("Glass shell has to be Tier - 3 of the highest capacitor tier.")
+            .addInfo(
+                GT_Values.TIER_COLORS[8] + GT_Values.VN[8]
+                    + EnumChatFormatting.GRAY
+                    + "-tier glass required for "
+                    + EnumChatFormatting.BLUE
+                    + "Tec"
+                    + EnumChatFormatting.DARK_BLUE
+                    + "Tech"
+                    + EnumChatFormatting.GRAY
+                    + " Laser Hatches.")
+            .addInfo("Add more or better capacitors to increase capacity.")
+            .addSeparator()
+            .addInfo("Wireless mode can be enabled by right clicking with a screwdriver.")
+            .addInfo(
+                "This mode can only be enabled if you have a " + GT_Values.TIER_COLORS[9]
+                    + GT_Values.VN[9]
+                    + EnumChatFormatting.GRAY
+                    + "+ capacitor in the multiblock.")
+            .addInfo(
+                "When enabled every " + EnumChatFormatting.BLUE
+                    + GT_Utility.formatNumbers(LSC_time_between_wireless_rebalance_in_ticks)
+                    + EnumChatFormatting.GRAY
+                    + " ticks the LSC will attempt to re-balance against your")
+            .addInfo("wireless EU network.")
+            .addInfo(
+                "If there is less than " + EnumChatFormatting.RED
+                    + GT_Utility.formatNumbers(LSC_wireless_eu_cap)
+                    + EnumChatFormatting.GRAY
+                    + "("
+                    + GT_Values.TIER_COLORS[9]
+                    + GT_Values.VN[9]
+                    + EnumChatFormatting.GRAY
+                    + ") EU in the LSC")
+            .addInfo("it will withdraw from the network and add to the LSC.")
+            .addInfo("If there is more it will add the EU to the network and remove it from the LSC.")
+            .addInfo(
+                "The threshold increases " + EnumChatFormatting.DARK_RED
+                    + "100"
+                    + EnumChatFormatting.GRAY
+                    + "-fold"
+                    + " for every capacitor tier above.")
+            .addSeparator()
+            .beginVariableStructureBlock(5, 5, 4, 50, 5, 5, false)
+            .addStructureInfo("Modular height of 4-50 blocks.")
+            .addController("Front center bottom")
+            .addOtherStructurePart("Lapotronic Super Capacitor Casing", "5x2x5 base (at least 17x)")
+            .addOtherStructurePart(
+                "Lapotronic Capacitor (" + GT_Values.TIER_COLORS[4]
+                    + GT_Values.VN[4]
+                    + EnumChatFormatting.GRAY
+                    + "-"
+                    + GT_Values.TIER_COLORS[8]
+                    + GT_Values.VN[8]
+                    + EnumChatFormatting.GRAY
+                    + "), Ultimate Capacitor ("
+                    + GT_Values.TIER_COLORS[9]
+                    + GT_Values.VN[9]
+                    + EnumChatFormatting.GRAY
+                    + "-"
+                    + GT_Values.TIER_COLORS[12]
+                    + GT_Values.VN[12]
+                    + EnumChatFormatting.GRAY
+                    + ")",
+                "Center 3x(1-47)x3 above base (9-423 blocks)")
+            .addStructureInfo(
+                "You can also use the Empty Capacitor to save materials if you use it for less than half the blocks")
+            .addOtherStructurePart("Borosilicate Glass (any)", "41-777x, Encase capacitor pillar")
+            .addEnergyHatch("Any casing")
+            .addDynamoHatch("Any casing")
+            .addOtherStructurePart(
+                "Laser Target/Source Hatches",
+                "Any casing, must be using " + GT_Values.TIER_COLORS[8]
+                    + GT_Values.VN[8]
+                    + EnumChatFormatting.GRAY
+                    + "-tier glass")
+            .addStructureInfo("You can have several I/O Hatches")
+            .addSubChannelUsage("glass", "Borosilicate Glass Tier")
+            .addSubChannelUsage("capacitor", "Maximum Capacitor Tier")
+            .addSubChannelUsage("height", "Height of structure")
+            .addMaintenanceHatch("Any casing")
+            .toolTipFinisher("KekzTech");
+        return tt;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side,
+        ForgeDirection forgeDirectionacing, int colorIndex, boolean aActive, boolean aRedstone) {
+        ITexture[] sTexture = new ITexture[] {
+            TextureFactory.of(BlockIcons.MACHINE_CASING_FUSION_GLASS, Dyes.getModulation(-1, Dyes._NULL.mRGBa)) };
+        if (side == forgeDirectionacing && aActive) {
+            sTexture = new ITexture[] { TextureFactory
+                .of(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW, Dyes.getModulation(-1, Dyes._NULL.mRGBa)) };
+        }
+        return sTexture;
+    }
+
+    private UUID global_energy_user_uuid;
+
+    @Override
+    public void onPreTick(IGregTechTileEntity tileEntity, long aTick) {
+        super.onPreTick(tileEntity, aTick);
+
+        // On first tick (aTick restarts from 0 upon world reload).
+        if (not_processed_lsc && tileEntity.isServerSide()) {
+            // Add user to wireless network.
+            WirelessNetworkManager.strongCheckOrAddUser(tileEntity.getOwnerUuid());
+
+            // Get team UUID.
+            global_energy_user_uuid = tileEntity.getOwnerUuid();
+
+            not_processed_lsc = false;
+        }
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack stack) {
+        return true;
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack stack) {
+        this.mProgresstime = 1;
+        this.mMaxProgresstime = 1;
+        this.mEUt = 0;
+        this.mEfficiencyIncrease = 10000;
+        return true;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+        WirelessNetworkManager.strongCheckOrAddUser(thisController.getOwnerUuid());
+
+        // Reset capacitor counts
+        Arrays.fill(capacitors, 0);
+        // Clear TT hatches
+        mEnergyHatchesTT.clear();
+        mDynamoHatchesTT.clear();
+        mEnergyTunnelsTT.clear();
+        mDynamoTunnelsTT.clear();
+
+        mMaxEUIn = 0;
+        mMaxEUOut = 0;
+
+        glassTier = GLASS_TIER_UNSET;
+        casingAmount = 0;
+
+        if (!checkPiece(STRUCTURE_PIECE_BASE, 2, 1, 0)) return false;
+
+        if (casingAmount < 17) return false;
+
+        topState = TopState.NotTop; // need at least one layer of capacitor to form, obviously
+        int layer = 2;
+        while (true) {
+            if (!checkPiece(STRUCTURE_PIECE_LAYER, 2, layer, 0)) return false;
+            layer++;
+            if (topState == TopState.Top) break; // top found, break out
+            topState = TopState.MayBeTop;
+            if (layer > 50) return false; // too many layers
+        }
+
+        // Make sure glass tier is T-2 of the highest tier capacitor in the structure
+        // Count down from the highest tier until an entry is found
+        // Borosilicate glass after 5 are just recolours of 0
+        for (int highestGlassTier = capacitors.length - 1; highestGlassTier >= 0; highestGlassTier--) {
+            int highestCapacitor = Capacitor.getIndexFromGlassTier(highestGlassTier);
+            if (capacitors[highestCapacitor] > 0) {
+                if (Capacitor.VALUES[highestCapacitor].getMinimalGlassTier() > glassTier) return false;
+                break;
+            }
+        }
+
+        // Glass has to be at least UV-tier to allow TT Laser hatches
+        if (glassTier < 8) {
+            if (mEnergyTunnelsTT.size() > 0 || mDynamoTunnelsTT.size() > 0) return false;
+        }
+
+        // Check if enough (more than 50%) non-empty caps
+        if (capacitors[5] > capacitors[0] + capacitors[1]
+            + capacitors[2]
+            + capacitors[3]
+            + getUHVCapacitorCount()
+            + capacitors[6]
+            + getUEVCapacitorCount()
+            + getUIVCapacitorCount()
+            + getUMVCapacitorCount()) return false;
+
+        // Calculate total capacity
+        capacity = BigInteger.ZERO;
+        for (int i = 0; i < capacitors.length; i++) {
+            int count = capacitors[i];
+            capacity = capacity.add(
+                Capacitor.VALUES[i].getProvidedCapacity()
+                    .multiply(BigInteger.valueOf(count)));
+        }
+        // Calculate how much energy to void each tick
+        passiveDischargeAmount = recalculateLossWithMaintenance(getRepairStatus());
+        return mMaintenanceHatches.size() == 1;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        int layer = min(stackSize.stackSize + 3, 50);
+        buildPiece(STRUCTURE_PIECE_BASE, stackSize, hintsOnly, 2, 1, 0);
+        for (int i = 2; i < layer - 1; i++) buildPiece(STRUCTURE_PIECE_MID, stackSize, hintsOnly, 2, i, 0);
+        buildPiece(STRUCTURE_PIECE_TOP, stackSize, hintsOnly, 2, layer - 1, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+        if (mMachine) return -1;
+        int layer = Math.min(ChannelDataAccessor.getChannelData(stackSize, "height") + 3, 50);
+        int built;
+        built = survivialBuildPiece(
+            STRUCTURE_PIECE_BASE,
+            stackSize,
+            2,
+            1,
+            0,
+            elementBudget,
+            source,
+            actor,
+            false,
+            true);
+        if (built >= 0) return built;
+        for (int i = 2; i < layer - 1; i++) built = survivialBuildPiece(
+            STRUCTURE_PIECE_MID,
+            stackSize,
+            2,
+            i,
+            0,
+            elementBudget,
+            source,
+            actor,
+            false,
+            true);
+        if (built >= 0) return built;
+        return survivialBuildPiece(
+            STRUCTURE_PIECE_TOP,
+            stackSize,
+            2,
+            layer - 1,
+            0,
+            elementBudget,
+            source,
+            actor,
+            false,
+            true);
+    }
+
+    @Override
+    public boolean onRunningTick(ItemStack stack) {
+        // Reset I/O cache
+        inputLastTick = 0;
+        outputLastTick = 0;
+
+        long temp_stored = 0L;
+
+        // Draw energy from GT hatches
+        for (GT_MetaTileEntity_Hatch_Energy eHatch : super.mEnergyHatches) {
+            if (eHatch == null || !eHatch.isValid()) {
+                continue;
+            }
+            final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn());
+            if (eHatch.getEUVar() >= power) {
+                eHatch.setEUVar(eHatch.getEUVar() - power);
+                temp_stored += power;
+                inputLastTick += power;
+            }
+        }
+
+        // Output energy to GT hatches
+        for (GT_MetaTileEntity_Hatch_Dynamo eDynamo : super.mDynamoHatches) {
+            if (eDynamo == null || !eDynamo.isValid()) {
+                continue;
+            }
+            final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut());
+            if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) {
+                eDynamo.setEUVar(eDynamo.getEUVar() + power);
+                temp_stored -= power;
+                outputLastTick += power;
+            }
+        }
+
+        // Draw energy from TT hatches
+        for (GT_MetaTileEntity_Hatch_EnergyMulti eHatch : mEnergyHatchesTT) {
+            if (eHatch == null || !eHatch.isValid()) {
+                continue;
+            }
+            final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn());
+            if (eHatch.getEUVar() >= power) {
+                eHatch.setEUVar(eHatch.getEUVar() - power);
+                temp_stored += power;
+                inputLastTick += power;
+            }
+        }
+
+        // Output energy to TT hatches
+        for (GT_MetaTileEntity_Hatch_DynamoMulti eDynamo : mDynamoHatchesTT) {
+            if (eDynamo == null || !eDynamo.isValid()) {
+                continue;
+            }
+            final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut());
+            if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) {
+                eDynamo.setEUVar(eDynamo.getEUVar() + power);
+                temp_stored -= power;
+                outputLastTick += power;
+            }
+        }
+
+        // Draw energy from TT Laser hatches
+        for (GT_MetaTileEntity_Hatch_EnergyTunnel eHatch : mEnergyTunnelsTT) {
+            if (eHatch == null || !eHatch.isValid()) {
+                continue;
+            }
+            final long ttLaserWattage = eHatch.maxEUInput() * eHatch.Amperes - (eHatch.Amperes / 20);
+            final long power = getPowerToDraw(ttLaserWattage);
+            if (eHatch.getEUVar() >= power) {
+                eHatch.setEUVar(eHatch.getEUVar() - power);
+                temp_stored += power;
+                inputLastTick += power;
+            }
+        }
+
+        // Output energy to TT Laser hatches
+        for (GT_MetaTileEntity_Hatch_DynamoTunnel eDynamo : mDynamoTunnelsTT) {
+            if (eDynamo == null || !eDynamo.isValid()) {
+                continue;
+            }
+            final long ttLaserWattage = eDynamo.maxEUOutput() * eDynamo.Amperes - (eDynamo.Amperes / 20);
+            final long power = getPowerToPush(ttLaserWattage);
+            if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) {
+                eDynamo.setEUVar(eDynamo.getEUVar() + power);
+                temp_stored -= power;
+                outputLastTick += power;
+            }
+        }
+
+        if (wirelessCapableCapacitors() <= 0) {
+            wireless_mode = false;
+        }
+
+        // Every LSC_time_between_wireless_rebalance_in_ticks check against wireless network for re-balancing.
+        counter++;
+        if (wireless_mode && (counter >= LSC_time_between_wireless_rebalance_in_ticks)) {
+
+            // Reset tick counter.
+            counter = 1;
+
+            // Find difference.
+            BigInteger transferred_eu = stored.subtract(
+                (LSC_wireless_eu_cap.multiply(BigInteger.valueOf(getUHVCapacitorCount())))
+                    .add(UEV_wireless_eu_cap.multiply(BigInteger.valueOf(getUEVCapacitorCount())))
+                    .add(UIV_wireless_eu_cap.multiply(BigInteger.valueOf(getUIVCapacitorCount())))
+                    .add(UMV_wireless_eu_cap.multiply(BigInteger.valueOf(getUMVCapacitorCount()))));
+
+            if (transferred_eu.signum() == 1) {
+                inputLastTick += transferred_eu.longValue();
+            } else {
+                outputLastTick += transferred_eu.longValue();
+            }
+
+            // If that difference can be added then do so.
+            if (WirelessNetworkManager.addEUToGlobalEnergyMap(global_energy_user_uuid, transferred_eu)) {
+                // If it succeeds there was sufficient energy so set the internal capacity as such.
+                stored = LSC_wireless_eu_cap.multiply(BigInteger.valueOf(getUHVCapacitorCount()))
+                    .add(
+                        UEV_wireless_eu_cap.multiply(BigInteger.valueOf(getUEVCapacitorCount()))
+                            .add(UIV_wireless_eu_cap.multiply(BigInteger.valueOf(getUIVCapacitorCount())))
+                            .add(UMV_wireless_eu_cap.multiply(BigInteger.valueOf(getUMVCapacitorCount()))));
+            }
+        }
+
+        // Lose some energy.
+        // Re-calculate if the repair status changed.
+        if (super.getRepairStatus() != repairStatusCache) {
+            passiveDischargeAmount = recalculateLossWithMaintenance(super.getRepairStatus());
+        }
+
+        // This will break if you transfer more than 2^63 EU/t, so don't do that. Thanks <3
+        temp_stored -= passiveDischargeAmount;
+        stored = stored.add(BigInteger.valueOf(temp_stored));
+
+        // Check that the machine has positive EU stored.
+        stored = (stored.compareTo(BigInteger.ZERO) <= 0) ? BigInteger.ZERO : stored;
+
+        IGregTechTileEntity tBMTE = this.getBaseMetaTileEntity();
+
+        tBMTE.injectEnergyUnits(ForgeDirection.UNKNOWN, inputLastTick, 1L);
+        tBMTE.drainEnergyUnits(ForgeDirection.UNKNOWN, outputLastTick, 1L);
+
+        // Add I/O values to Queues
+        if (energyInputValues.size() > DURATION_AVERAGE_TICKS) {
+            energyInputValues.remove();
+        }
+        energyInputValues.offer(inputLastTick);
+
+        if (energyOutputValues.size() > DURATION_AVERAGE_TICKS) {
+            energyOutputValues.remove();
+        }
+
+        energyOutputValues.offer(outputLastTick);
+
+        return true;
+    }
+
+    /**
+     * To be called whenever the maintenance status changes or the capacity was recalculated
+     *
+     * @param repairStatus This machine's repair status
+     * @return new BigInteger instance for passiveDischargeAmount
+     */
+    private long recalculateLossWithMaintenance(int repairStatus) {
+        repairStatusCache = repairStatus;
+
+        long temp_capacity_divided = 0;
+
+        if (wirelessCapableCapacitors() == 0) {
+            temp_capacity_divided = capacity.divide(BigInteger.valueOf(100L * 86400L * 20L))
+                .longValue();
+        }
+
+        // Passive loss is multiplied by number of UHV+ caps. Minimum of 1 otherwise loss is 0 for non-UHV+ caps
+        // calculations.
+        if (wirelessCapableCapacitors() != 0) {
+            temp_capacity_divided = getUHVCapacitorCount() * max_passive_drain_eu_per_tick_per_uhv_cap
+                + getUEVCapacitorCount() * max_passive_drain_eu_per_tick_per_uev_cap
+                + getUIVCapacitorCount() * max_passive_drain_eu_per_tick_per_uiv_cap
+                + getUMVCapacitorCount() * max_passive_drain_eu_per_tick_per_umv_cap;
+        }
+
+        // Passive loss is multiplied by number of maintenance issues.
+        long total_passive_loss = temp_capacity_divided * (getIdealStatus() - repairStatus + 1);
+
+        // Maximum of 100,000 EU/t drained per UHV cell. The logic is 1% of EU capacity should be drained every 86400
+        // seconds (1 day).
+        return total_passive_loss;
+    }
+
+    /**
+     * Calculate how much EU to draw from an Energy Hatch
+     *
+     * @param hatchWatts Hatch amperage * voltage
+     * @return EU amount
+     */
+    private long getPowerToDraw(long hatchWatts) {
+        final BigInteger remcapActual = capacity.subtract(stored);
+        final BigInteger recampLimited = (MAX_LONG.compareTo(remcapActual) > 0) ? remcapActual : MAX_LONG;
+        return min(hatchWatts, recampLimited.longValue());
+    }
+
+    /**
+     * Calculate how much EU to push into a Dynamo Hatch
+     *
+     * @param hatchWatts Hatch amperage * voltage
+     * @return EU amount
+     */
+    private long getPowerToPush(long hatchWatts) {
+        final BigInteger remStoredLimited = (MAX_LONG.compareTo(stored) > 0) ? stored : MAX_LONG;
+        return min(hatchWatts, remStoredLimited.longValue());
+    }
+
+    private long getAvgIn() {
+        long sum = 0L;
+        for (long l : energyInputValues) {
+            sum += l;
+        }
+        return sum / Math.max(energyInputValues.size(), 1);
+    }
+
+    private long getAvgOut() {
+        long sum = 0L;
+        for (long l : energyOutputValues) {
+            sum += l;
+        }
+        return sum / Math.max(energyOutputValues.size(), 1);
+    }
+
+    @Override
+    public String[] getInfoData() {
+        NumberFormat nf = NumberFormat.getNumberInstance();
+        int secInterval = DURATION_AVERAGE_TICKS / 20;
+
+        // Caching avgin and avgout
+        double avgIn = getAvgIn();
+        double avgOut = getAvgOut();
+
+        final ArrayList<String> ll = new ArrayList<>();
+        ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+        ll.add("EU Stored: " + nf.format(stored) + " EU");
+        ll.add("EU Stored: " + toStandardForm(stored) + " EU");
+        ll.add("Used Capacity: " + toPercentageFrom(stored, capacity));
+        ll.add("Total Capacity: " + nf.format(capacity) + " EU");
+        ll.add("Total Capacity: " + toStandardForm(capacity) + " EU");
+        ll.add("Passive Loss: " + nf.format(passiveDischargeAmount) + " EU/t");
+        ll.add("EU IN: " + GT_Utility.formatNumbers(inputLastTick) + " EU/t");
+        ll.add("EU OUT: " + GT_Utility.formatNumbers(outputLastTick) + " EU/t");
+        ll.add("Avg EU IN: " + nf.format(avgIn) + " (last " + secInterval + " seconds)");
+        ll.add("Avg EU OUT: " + nf.format(avgOut) + " (last " + secInterval + " seconds)");
+
+        // Check if the system is charging or discharging
+        if (avgIn > avgOut) {
+            // Calculate time to full if charging
+            if (avgIn != 0) {
+                double timeToFull = (capacity.longValue() - stored.longValue()) / avgIn / 20;
+                String timeToFullString = formatTime(timeToFull);
+                ll.add("Time to Full: " + timeToFullString);
+            }
+        } else {
+            // Calculate time to empty if discharging
+            if (avgOut != 0) {
+                double timeToEmpty = stored.longValue() / avgOut / 20;
+                String timeToEmptyString = formatTime(timeToEmpty);
+                ll.add("Time to Empty: " + timeToEmptyString);
+            }
+        }
+        ll.add(
+            "Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus())
+                ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET
+                : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+        ll.add(
+            "Wireless mode: " + (wireless_mode ? EnumChatFormatting.GREEN + "enabled" + EnumChatFormatting.RESET
+                : EnumChatFormatting.RED + "disabled" + EnumChatFormatting.RESET));
+        ll.add(
+            GT_Values.TIER_COLORS[9] + GT_Values.VN[9]
+                + EnumChatFormatting.RESET
+                + " Capacitors detected: "
+                + getUHVCapacitorCount());
+        ll.add(
+            GT_Values.TIER_COLORS[10] + GT_Values.VN[10]
+                + EnumChatFormatting.RESET
+                + " Capacitors detected: "
+                + getUEVCapacitorCount());
+        ll.add(
+            GT_Values.TIER_COLORS[11] + GT_Values.VN[11]
+                + EnumChatFormatting.RESET
+                + " Capacitors detected: "
+                + getUIVCapacitorCount());
+        ll.add(
+            GT_Values.TIER_COLORS[12] + GT_Values.VN[12]
+                + EnumChatFormatting.RESET
+                + " Capacitors detected: "
+                + getUMVCapacitorCount());
+        ll.add(
+            "Total wireless EU: " + EnumChatFormatting.RED
+                + nf.format(WirelessNetworkManager.getUserEU(global_energy_user_uuid))
+                + " EU");
+        ll.add(
+            "Total wireless EU: " + EnumChatFormatting.RED
+                + toStandardForm(WirelessNetworkManager.getUserEU(global_energy_user_uuid))
+                + " EU");
+
+        final String[] a = new String[ll.size()];
+        return ll.toArray(a);
+    }
+
+    // Method to format time in seconds, minutes, days, and years
+    private String formatTime(double time) {
+        if (time < 1) {
+            return "Completely " + (time < 0 ? "empty" : "full");
+        } else if (time < 60) {
+            return String.format("%.2f seconds", time);
+        } else if (time < 3600) {
+            return String.format("%.2f minutes", time / 60);
+        } else if (time < 86400) {
+            return String.format("%.2f hours", time / 3600);
+        } else if (time < 31536000) {
+            return String.format("%.2f days", time / 86400);
+        } else {
+            return String.format("%.2f years", time / 31536000);
+        }
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound nbt) {
+        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+        nbt.setByteArray("capacity", capacity.toByteArray());
+        nbt.setByteArray("stored", stored.toByteArray());
+        nbt.setBoolean("wireless_mode", wireless_mode);
+        nbt.setInteger("wireless_mode_cooldown", counter);
+
+        super.saveNBTData(nbt);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound nbt) {
+        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+        capacity = new BigInteger(nbt.getByteArray("capacity"));
+        stored = new BigInteger(nbt.getByteArray("stored"));
+        wireless_mode = nbt.getBoolean("wireless_mode");
+        counter = nbt.getInteger("wireless_mode_cooldown");
+
+        super.loadNBTData(nbt);
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack stack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack stack) {
+        return false;
+    }
+
+    // called by the getEUCapacity() function in BaseMetaTileEntity
+    @Override
+    public long maxEUStore() {
+        return capacity.longValue();
+    }
+
+    // called by the getEUStored() function in BaseMetaTileEntity
+    @Override
+    public long getEUVar() {
+        return stored.longValue();
+    }
+
+    /*
+     * all of these are needed for the injectEnergyUnits() and drainEnergyUnits() in IGregTechTileEntity
+     */
+    @Override
+    public long maxEUInput() {
+        if (wireless_mode) {
+            return Long.MAX_VALUE;
+        } else {
+            return mMaxEUIn;
+        }
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return 1L;
+    }
+
+    @Override
+    public long maxEUOutput() {
+        if (wireless_mode) {
+            return Long.MAX_VALUE;
+        } else {
+            return mMaxEUOut;
+        }
+    }
+
+    @Override
+    public long maxAmperesOut() {
+        return 1L;
+    }
+
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return true;
+    }
+
+    protected boolean canUseWireless() {
+        return wirelessCapableCapacitors() != 0;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        if (canUseWireless()) {
+            wireless_mode = !wireless_mode;
+            GT_Utility.sendChatToPlayer(aPlayer, "Wireless network mode " + (wireless_mode ? "enabled." : "disabled."));
+        } else {
+            GT_Utility.sendChatToPlayer(
+                aPlayer,
+                "Wireless mode cannot be enabled without at least 1 " + GT_Values.TIER_COLORS[9]
+                    + GT_Values.VN[9]
+                    + EnumChatFormatting.RESET
+                    + "+ capacitor.");
+            wireless_mode = false;
+        }
+    }
+
+    @Override
+    public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+        super.addUIWidgets(builder, buildContext);
+        builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> {
+            if (!widget.isClient()) {
+                canUseWireless = canUseWireless();
+            }
+            if (canUseWireless) {
+                wireless_mode = !wireless_mode;
+            }
+        })
+            .setPlayClickSound(true)
+            .setBackground(() -> {
+                List<UITexture> ret = new ArrayList<>();
+                ret.add(GT_UITextures.BUTTON_STANDARD);
+                if (canUseWireless) {
+                    if (wireless_mode) {
+                        ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_ON);
+                    } else {
+                        ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_OFF);
+                    }
+                } else {
+                    ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_OFF_DISABLED);
+                }
+                return ret.toArray(new IDrawable[0]);
+            })
+            .setPos(80, 91)
+            .setSize(16, 16)
+            .addTooltip(StatCollector.translateToLocal("gui.kekztech_lapotronicenergyunit.wireless"))
+            .setTooltipShowUpDelay(TOOLTIP_DELAY))
+            .widget(new FakeSyncWidget.BooleanSyncer(() -> wireless_mode, val -> wireless_mode = val))
+            .widget(new FakeSyncWidget.BooleanSyncer(this::canUseWireless, val -> canUseWireless = val));
+    }
+
+    private enum LSCHatchElement implements IHatchElement<GTMTE_LapotronicSuperCapacitor> {
+
+        Energy(GT_MetaTileEntity_Hatch_EnergyMulti.class, GT_MetaTileEntity_Hatch_Energy.class) {
+
+            @Override
+            public long count(GTMTE_LapotronicSuperCapacitor t) {
+                return t.mEnergyHatches.size() + t.mEnergyHatchesTT.size() + t.mEnergyTunnelsTT.size();
+            }
+        },
+        Dynamo(GT_MetaTileEntity_Hatch_DynamoMulti.class, GT_MetaTileEntity_Hatch_Dynamo.class) {
+
+            @Override
+            public long count(GTMTE_LapotronicSuperCapacitor t) {
+                return t.mDynamoHatches.size() + t.mDynamoHatchesTT.size() + t.mDynamoTunnelsTT.size();
+            }
+        },;
+
+        private final List<? extends Class<? extends IMetaTileEntity>> mteClasses;
+
+        @SafeVarargs
+        LSCHatchElement(Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Arrays.asList(mteClasses);
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        @Override
+        public IGT_HatchAdder<? super GTMTE_LapotronicSuperCapacitor> adder() {
+            return GTMTE_LapotronicSuperCapacitor::addBottomHatches;
+        }
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java
new file mode 100644
index 0000000000..8ec9d43ddd
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java
@@ -0,0 +1,221 @@
+package common.tileentities;
+
+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.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_GLOW;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import common.Blocks;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+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.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+
+public class GTMTE_SOFuelCellMK1 extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_SOFuelCellMK1> {
+
+    private final int OXYGEN_PER_SEC = 100;
+    private final int EU_PER_TICK = 2048;
+    private final int STEAM_PER_SEC = 20000;
+
+    public GTMTE_SOFuelCellMK1(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GTMTE_SOFuelCellMK1(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+        return new GTMTE_SOFuelCellMK1(super.mName);
+    }
+
+    private int mCasing = 0;
+
+    private static final int CASING_TEXTURE_ID = 49;
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final IStructureDefinition<GTMTE_SOFuelCellMK1> STRUCTURE_DEFINITION = IStructureDefinition
+        .<GTMTE_SOFuelCellMK1>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            transpose(
+                new String[][] { { "ccc", "ccc", "ccc", "ccc", "ccc" }, { "c~c", "geg", "geg", "geg", "cdc" },
+                    { "ccc", "ccc", "ccc", "ccc", "ccc" } }))
+        .addElement(
+            'c',
+            ofChain(
+                onElementPass(te -> te.mCasing++, ofBlock(GregTech_API.sBlockCasings4, 1)),
+                ofHatchAdder(GTMTE_SOFuelCellMK1::addInputToMachineList, CASING_TEXTURE_ID, 1),
+                ofHatchAdder(GTMTE_SOFuelCellMK1::addMaintenanceToMachineList, CASING_TEXTURE_ID, 1),
+                ofHatchAdder(GTMTE_SOFuelCellMK1::addOutputToMachineList, CASING_TEXTURE_ID, 1)))
+        .addElement('d', ofHatchAdder(GTMTE_SOFuelCellMK1::addDynamoToMachineList, CASING_TEXTURE_ID, 1))
+        .addElement('g', ofBlockAnyMeta(GameRegistry.findBlock("IC2", "blockAlloyGlass")))
+        .addElement('e', ofBlockAnyMeta(Blocks.yszUnit))
+        .build();
+
+    @Override
+    public IStructureDefinition<GTMTE_SOFuelCellMK1> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Gas Turbine")
+            .addInfo("Oxidizes gas fuels to generate electricity without polluting the environment")
+            .addInfo(
+                "Consumes up to " + GT_Utility.formatNumbers(EU_PER_TICK * 20)
+                    + "EU worth of fuel with up to 100% efficiency each second")
+            .addInfo("Steam production requires the SOFC to heat up completely first")
+            .addInfo("Outputs " + EU_PER_TICK + "EU/t and " + STEAM_PER_SEC + "L/s Steam")
+            .addInfo("Additionally, requires " + OXYGEN_PER_SEC + "L/s Oxygen gas")
+            .addSeparator()
+            .beginStructureBlock(3, 3, 5, false)
+            .addController("Front center")
+            .addCasingInfoMin("Clean Stainless Steel Casing", 12, false)
+            .addOtherStructurePart("YSZ Ceramic Electrolyte Unit", "3x, Center 1x1x3")
+            .addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides")
+            .addDynamoHatch("Back center", 1)
+            .addMaintenanceHatch("Any casing")
+            .addInputHatch("Fuel, any casing")
+            .addInputHatch("Oxygen, any casing")
+            .addOutputHatch("Steam, any casing")
+            .toolTipFinisher("KekzTech");
+        return tt;
+    }
+
+    @Override
+    public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final ForgeDirection side,
+        final ForgeDirection facing, final int colorIndex, final boolean aActive, final boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID) };
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack stack) {
+        return true;
+    }
+
+    @Nonnull
+    @Override
+    public CheckRecipeResult checkProcessing() {
+        final ArrayList<FluidStack> storedFluids = super.getStoredFluids();
+        Collection<GT_Recipe> recipeList = RecipeMaps.gasTurbineFuels.getAllRecipes();
+
+        for (FluidStack hatchFluid : storedFluids) {
+            for (GT_Recipe aFuel : recipeList) {
+                FluidStack liquid;
+                if ((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null
+                    && hatchFluid.isFluidEqual(liquid)) {
+
+                    liquid.amount = (EU_PER_TICK * 20) / aFuel.mSpecialValue;
+
+                    if (super.depleteInput(liquid)) {
+
+                        if (!super.depleteInput(Materials.Oxygen.getGas(OXYGEN_PER_SEC))) {
+                            super.mEUt = 0;
+                            super.mEfficiency = 0;
+                            return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+                        }
+
+                        super.mEUt = EU_PER_TICK;
+                        super.mMaxProgresstime = 20;
+                        super.mEfficiencyIncrease = 40;
+                        if (super.mEfficiency == getMaxEfficiency(null)) {
+                            super.addOutput(GT_ModHandler.getSteam(STEAM_PER_SEC));
+                        }
+                        return CheckRecipeResultRegistry.GENERATING;
+                    }
+                }
+            }
+        }
+
+        super.mEUt = 0;
+        super.mEfficiency = 0;
+        return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+        this.mCasing = 0;
+
+        if (!checkPiece(STRUCTURE_PIECE_MAIN, 1, 1, 0)) return false;
+
+        return (this.mCasing >= 12 && this.mMaintenanceHatches.size() == 1 && this.mInputHatches.size() >= 2);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack stack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack stack) {
+        return false;
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        buildPiece(STRUCTURE_PIECE_MAIN, itemStack, b, 1, 1, 0);
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java
new file mode 100644
index 0000000000..01150ab910
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java
@@ -0,0 +1,222 @@
+package common.tileentities;
+
+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.onElementPass;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_GLOW;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import common.Blocks;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+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.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+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;
+
+public class GTMTE_SOFuelCellMK2 extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_SOFuelCellMK2> {
+
+    private final int OXYGEN_PER_SEC = 2000;
+    private final int EU_PER_TICK = 24576; // 100% Efficiency, 3A IV
+    private final int STEAM_PER_SEC = 96000; // SH Steam (10,800EU/t @ 150% Efficiency)
+
+    public GTMTE_SOFuelCellMK2(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GTMTE_SOFuelCellMK2(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+        return new GTMTE_SOFuelCellMK2(super.mName);
+    }
+
+    private int mCasing = 0;
+
+    private static final int CASING_TEXTURE_ID = 48;
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final IStructureDefinition<GTMTE_SOFuelCellMK2> STRUCTURE_DEFINITION = IStructureDefinition
+        .<GTMTE_SOFuelCellMK2>builder()
+        .addShape(
+            STRUCTURE_PIECE_MAIN,
+            transpose(
+                new String[][] { { "ccc", "ccc", "ccc", "ccc", "ccc" }, { "c~c", "geg", "geg", "geg", "cdc" },
+                    { "ccc", "ccc", "ccc", "ccc", "ccc" } }))
+        .addElement(
+            'c',
+            ofChain(
+                onElementPass(te -> te.mCasing++, ofBlock(GregTech_API.sBlockCasings4, 0)),
+                ofHatchAdder(GTMTE_SOFuelCellMK2::addInputToMachineList, CASING_TEXTURE_ID, 1),
+                ofHatchAdder(GTMTE_SOFuelCellMK2::addMaintenanceToMachineList, CASING_TEXTURE_ID, 1),
+                ofHatchAdder(GTMTE_SOFuelCellMK2::addOutputToMachineList, CASING_TEXTURE_ID, 1)))
+        .addElement('d', ofHatchAdder(GTMTE_SOFuelCellMK2::addDynamoToMachineList, CASING_TEXTURE_ID, 1))
+        .addElement('g', ofBlockAnyMeta(GameRegistry.findBlock("IC2", "blockAlloyGlass")))
+        .addElement('e', ofBlockAnyMeta(Blocks.gdcUnit))
+        .build();
+
+    @Override
+    public IStructureDefinition<GTMTE_SOFuelCellMK2> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Gas Turbine")
+            .addInfo("Oxidizes gas fuels to generate electricity without polluting the environment")
+            .addInfo(
+                "Consumes up to " + GT_Utility.formatNumbers(EU_PER_TICK * 20)
+                    + "EU worth of fuel with up to 100% efficiency each second")
+            .addInfo("Nitrobenzene and other gas fuels above 1M EU/bucket are more efficient")
+            .addInfo("Steam production requires the SOFC to heat up completely first")
+            .addInfo("Outputs " + EU_PER_TICK + "EU/t and " + STEAM_PER_SEC + "L/s Steam")
+            .addInfo("Additionally, requires " + OXYGEN_PER_SEC + "L/s Oxygen gas")
+            .addSeparator()
+            .beginStructureBlock(3, 3, 5, false)
+            .addController("Front center")
+            .addCasingInfoMin("Robust Tungstensteel Machine Casing", 12, false)
+            .addOtherStructurePart("GDC Ceramic Electrolyte Unit", "3x, Center 1x1x3")
+            .addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides")
+            .addDynamoHatch("Back center", 1)
+            .addMaintenanceHatch("Any casing")
+            .addInputHatch("Fuel, any casing")
+            .addInputHatch("Oxygen, any casing")
+            .addOutputHatch("Superheated Steam, any casing")
+            .toolTipFinisher("KekzTech");
+        return tt;
+    }
+
+    @Override
+    public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final ForgeDirection side,
+        final ForgeDirection facing, final int colorIndex, final boolean aActive, final boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID) };
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack stack) {
+        return true;
+    }
+
+    @Nonnull
+    @Override
+    public CheckRecipeResult checkProcessing() {
+        final ArrayList<FluidStack> storedFluids = super.getStoredFluids();
+        Collection<GT_Recipe> recipeList = RecipeMaps.gasTurbineFuels.getAllRecipes();
+
+        for (FluidStack hatchFluid : storedFluids) {
+            for (GT_Recipe aFuel : recipeList) {
+                FluidStack liquid;
+                if ((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null
+                    && hatchFluid.isFluidEqual(liquid)) {
+
+                    liquid.amount = (EU_PER_TICK * 20) / aFuel.mSpecialValue / Math.max(1, aFuel.mSpecialValue / 1000);
+
+                    if (super.depleteInput(liquid)) {
+
+                        if (!super.depleteInput(Materials.Oxygen.getGas(OXYGEN_PER_SEC))) {
+                            super.mEUt = 0;
+                            super.mEfficiency = 0;
+                            return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+                        }
+
+                        super.mEUt = EU_PER_TICK;
+                        super.mMaxProgresstime = 20;
+                        super.mEfficiencyIncrease = 80;
+                        if (super.mEfficiency == getMaxEfficiency(null)) {
+                            super.addOutput(FluidRegistry.getFluidStack("ic2superheatedsteam", STEAM_PER_SEC));
+                        }
+                        return CheckRecipeResultRegistry.GENERATING;
+                    }
+                }
+            }
+        }
+
+        super.mEUt = 0;
+        super.mEfficiency = 0;
+        return CheckRecipeResultRegistry.NO_FUEL_FOUND;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+        this.mCasing = 0;
+
+        if (!checkPiece(STRUCTURE_PIECE_MAIN, 1, 1, 0)) return false;
+
+        return (this.mCasing >= 12 && this.mMaintenanceHatches.size() == 1 && this.mInputHatches.size() >= 2);
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack stack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack stack) {
+        return false;
+    }
+
+    @Override
+    public void construct(ItemStack itemStack, boolean b) {
+        buildPiece(STRUCTURE_PIECE_MAIN, itemStack, b, 1, 1, 0);
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java b/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java
new file mode 100644
index 0000000000..18867c0656
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java
@@ -0,0 +1,787 @@
+package common.tileentities;
+
+import static com.github.bartimaeusnek.bartworks.util.BW_Util.ofGlassTieredMixed;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockUnlocalizedName;
+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.Energy;
+import static gregtech.api.enums.GT_HatchElement.InputHatch;
+import static gregtech.api.enums.GT_HatchElement.Maintenance;
+import static gregtech.api.enums.GT_HatchElement.OutputHatch;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+import static java.lang.Math.min;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import java.math.BigInteger;
+import java.text.MessageFormat;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.AutoPlaceEnvironment;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.IStructureElement;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureUtility;
+import com.gtnewhorizon.structurelib.util.ItemStackPredicate;
+import common.Blocks;
+
+import gregtech.api.enums.Textures;
+import gregtech.api.fluid.FluidTankGT;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.IGT_HatchAdder;
+import gregtech.common.items.GT_IntegratedCircuit_Item;
+
+public class GTMTE_TFFT extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_TFFT> implements ISurvivalConstructable {
+
+    public enum Field {
+
+        T1(1_000_000L, 1), // LV
+        T2(4_000_000L, 2), // MV
+        T3(16_000_000L, 5), // HV
+        T4(64_000_000L, 14), // EV
+        T5(256_000_000L, 42), // IV
+
+        T6(2_048_000_000L, 132), // LuV
+        T7(131_072_000_000L, 429), // UV
+        T8(8_388_608_000_000L, 1430), // UEV
+        T9(536_870_912_000_000L, 4862), // UMV
+
+        T10(1_099_511_627_776_000_000L, 0); // UXV
+
+        public static final GTMTE_TFFT.Field[] VALUES = values();
+        private final long capacity;
+        private final int cost;
+
+        Field(long capacity, int cost) {
+            this.capacity = capacity;
+            this.cost = cost;
+        }
+
+        public long getCapacity() {
+            return capacity;
+        }
+
+        public int getCost() {
+            return cost;
+        }
+    }
+
+    private enum TFFTMultiHatch implements IHatchElement<GTMTE_TFFT> {
+
+        INSTANCE;
+
+        private final List<? extends Class<? extends IMetaTileEntity>> mteClasses;
+
+        @SafeVarargs
+        TFFTMultiHatch(Class<? extends IMetaTileEntity>... mteClasses) {
+            this.mteClasses = Arrays.asList(mteClasses);
+        }
+
+        @Override
+        public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+            return mteClasses;
+        }
+
+        @Override
+        public IGT_HatchAdder<? super GTMTE_TFFT> adder() {
+            return GTMTE_TFFT::addMultiHatchToMachineList;
+        }
+
+        @Override
+        public long count(GTMTE_TFFT t) {
+            return t.tfftHatch == null ? 0 : 1;
+        }
+    }
+
+    private enum TFFTStorageFieldElement implements IStructureElement<GTMTE_TFFT> {
+
+        INSTANCE;
+
+        @Override
+        public boolean check(GTMTE_TFFT t, World world, int x, int y, int z) {
+            Block worldBlock = world.getBlock(x, y, z);
+            int meta = worldBlock.getDamageValue(world, x, y, z);
+            if (TFFT_FIELD != worldBlock || meta == 0) return false;
+            t.FIELDS[meta - 1]++;
+            return true;
+        }
+
+        private int getHint(ItemStack stack) {
+            return Math.min(Field.VALUES.length, ChannelDataAccessor.getChannelData(stack, "field"));
+        }
+
+        @Override
+        public boolean spawnHint(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger) {
+            StructureLibAPI.hintParticle(world, x, y, z, TFFT_FIELD, getHint(trigger));
+            return true;
+        }
+
+        @Override
+        public boolean placeBlock(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger) {
+            world.setBlock(x, y, z, TFFT_FIELD, getHint(trigger), 3);
+            return true;
+        }
+
+        @Override
+        public PlaceResult survivalPlaceBlock(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger,
+            AutoPlaceEnvironment env) {
+            if (check(t, world, x, y, z)) return PlaceResult.SKIP;
+            int fieldTier = getHint(trigger);
+            ItemStack result = env.getSource()
+                .takeOne(
+                    s -> s != null && s.stackSize >= 0
+                        && s.getItem() == TFFT_FIELD_ITEM
+                        && s.getItemDamage() != CASING_META
+                        && s.getItemDamage() <= fieldTier,
+                    true);
+            if (result == null) return PlaceResult.REJECT;
+
+            return StructureUtility.survivalPlaceBlock(
+                result,
+                ItemStackPredicate.NBTMode.EXACT,
+                null,
+                true,
+                world,
+                x,
+                y,
+                z,
+                env.getSource(),
+                env.getActor(),
+                env.getChatter());
+        }
+    }
+
+    private static final IIconContainer TEXTURE_TFFT = new Textures.BlockIcons.CustomIcon("iconsets/TFFT");
+    private static final IIconContainer TEXTURE_TFFT_ACTIVE = new Textures.BlockIcons.CustomIcon(
+        "iconsets/TFFT_ACTIVE");
+    private static final IIconContainer TEXTURE_TFFT_ACTIVE_GLOW = new Textures.BlockIcons.CustomIcon(
+        "iconsets/TFFT_ACTIVE_GLOW");
+    private static final int CASING_TEXTURE_ID_1 = (12 << 7) | 127;
+    private static final int CASING_TEXTURE_ID_2 = 176;
+
+    private static final Block TFFT_FIELD = Blocks.tfftStorageField;
+    private static final Item TFFT_FIELD_ITEM = Item.getItemFromBlock(TFFT_FIELD);
+    public static final int MAX_DISTINCT_FLUIDS = 25;
+    private static final BigInteger MAX_CAPACITY = BigInteger.valueOf(Long.MAX_VALUE)
+        .multiply(BigInteger.valueOf(25));
+    private static final int CASING_META = 0;
+    private static final int MIN_CASING_AMOUNT = 20;
+    private static final int MAX_LAYER_AMOUNT = 13;
+    private static final int DEFAULT_LAYER_AMOUNT = 3;
+
+    private static final String STRUCTURE_PIECE_TOP = "top";
+    private static final String STRUCTURE_PIECE_MID = "mid";
+    private static final String STRUCTURE_PIECE_BOTTOM = "bottom";
+
+    @Override
+    public String[] getStructureDescription(ItemStack stackSize) {
+        return description;
+    }
+
+    private static final String[] description = new String[] {
+        translateToLocal("tile.kekztech_tfftstoragefield_block.hint.1"), // Casing
+        translateToLocal("tile.kekztech_tfftstoragefield_block.hint.2"), // Casing, Maintenance Hatch, T.F.F.T Multi
+                                                                         // I/O Hatch, Input/Output Hatch, Energy
+                                                                         // Hatch
+        translateToLocal("tile.kekztech_tfftstoragefield_block.hint.3"), // Glass, T.F.F.T Multi I/O Hatch,
+                                                                         // Input/Output Hatch
+        translateToLocal("tile.kekztech_tfftstoragefield_block.hint.4"), // Glass
+    };
+
+    // height channel for height
+    // field channel for field
+    private static final IStructureDefinition<GTMTE_TFFT> STRUCTURE_DEFINITION = IStructureDefinition
+        .<GTMTE_TFFT>builder()
+        .addShape(
+            STRUCTURE_PIECE_TOP,
+            transpose(new String[][] { { "ccccc" }, { "cCCCc" }, { "cC~Cc" }, { "cCCCc" }, { "ccccc" } }))
+        .addShape(
+            STRUCTURE_PIECE_MID,
+            transpose(new String[][] { { "gGGGg" }, { "GfffG" }, { "GfffG" }, { "GfffG" }, { "gGGGg" } }))
+        .addShape(
+            STRUCTURE_PIECE_BOTTOM,
+            transpose(new String[][] { { "ccccc" }, { "cCCCc" }, { "cCCCc" }, { "cCCCc" }, { "ccccc" } }))
+        .addElement(
+            'c',
+            buildHatchAdder(GTMTE_TFFT.class).atLeast(Energy, Maintenance)
+                .casingIndex(CASING_TEXTURE_ID_1)
+                .dot(1)
+                .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(TFFT_FIELD, CASING_META))))
+        .addElement(
+            'C',
+            buildHatchAdder(GTMTE_TFFT.class).casingIndex(CASING_TEXTURE_ID_1)
+                .atLeast(
+                    Energy,
+                    Maintenance,
+                    InputHatch.or(TFFTMultiHatch.INSTANCE),
+                    OutputHatch.or(TFFTMultiHatch.INSTANCE))
+                .dot(2)
+                .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(TFFT_FIELD, CASING_META))))
+        .addElement(
+            'G',
+            buildHatchAdder(GTMTE_TFFT.class)
+                .atLeast(InputHatch.or(TFFTMultiHatch.INSTANCE), OutputHatch.or(TFFTMultiHatch.INSTANCE))
+                .casingIndex(CASING_TEXTURE_ID_2)
+                .dot(3)
+                .buildAndChain(
+                    ofBlockUnlocalizedName("Thaumcraft", "blockCosmeticOpaque", 2, false),
+                    ofGlassTieredMixed((byte) 4, (byte) 127, 3)))
+        .addElement(
+            'g',
+            ofChain(
+                ofBlockUnlocalizedName("Thaumcraft", "blockCosmeticOpaque", 2, false),
+                ofGlassTieredMixed((byte) 4, (byte) 127, 4)))
+        .addElement('f', ofChain(TFFTStorageFieldElement.INSTANCE))
+        .build();
+
+    public final FluidTankGT[] STORE = new FluidTankGT[MAX_DISTINCT_FLUIDS];
+
+    {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            STORE[i] = new FluidTankGT(0);
+        }
+    }
+
+    private final int[] FIELDS = new int[Field.VALUES.length];
+
+    private BigInteger capacity = BigInteger.ZERO;
+    private long capacityPerFluid = 0L;
+    private int casingAmount = 0;
+    private int runningCost = 0;
+
+    private boolean locked = true;
+    private boolean doVoidExcess = false;
+    private byte fluidSelector = -1;
+
+    private GTMTE_TFFTHatch tfftHatch = null;
+
+    public GTMTE_TFFT(String aName) {
+        super(aName);
+    }
+
+    public GTMTE_TFFT(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    @Override
+    public IStructureDefinition<GTMTE_TFFT> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GTMTE_TFFT(super.mName);
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        if (side == facing) {
+            if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1),
+                TextureFactory.builder()
+                    .addIcon(TEXTURE_TFFT_ACTIVE)
+                    .extFacing()
+                    .build(),
+                TextureFactory.builder()
+                    .addIcon(TEXTURE_TFFT_ACTIVE_GLOW)
+                    .extFacing()
+                    .glow()
+                    .build() };
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1),
+                TextureFactory.builder()
+                    .addIcon(TEXTURE_TFFT)
+                    .extFacing()
+                    .build() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1) };
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Fluid Tank")
+            .addInfo("High-Tech fluid tank that can hold up to 25 different fluids!")
+            .addInfo("Has 1/25th of the total capacity as capacity for each fluid.")
+            .addInfo("Right clicking the controller with a screwdriver will turn on excess voiding.")
+            .addInfo("Fluid storage amount and running cost depends on the storage field blocks used.")
+            .addSeparator()
+            .addInfo("Note on hatch locking:")
+            .addInfo("Use an Integrated Circuit in the GUI slot to limit which fluid is output.")
+            .addInfo("The index of a stored fluid can be obtained through the Tricorder.")
+            .addSeparator()
+            .beginVariableStructureBlock(5, 5, 5, 15, 5, 5, false)
+            .addController("Top Center")
+            .addCasingInfoMin("T.F.F.T Casing", MIN_CASING_AMOUNT, false)
+            .addOtherStructurePart("Storage Field Blocks (Tier I-X)", "Inner 3xhx3 solid pillar")
+            .addStructureInfo("Energy hatch is not required when running cost is 0")
+            .addOtherStructurePart("EV+ Tier Glass/Warded Glass/Reinforced Glass", "Outer 5xhx5 glass shell")
+            .addMaintenanceHatch("Any top or bottom casing")
+            .addEnergyHatch("Any top or bottom casing")
+            .addInputHatch("Instead of any casing or glass, has to touch storage field block")
+            .addOutputHatch("Instead of any casing or glass, has to touch storage field block")
+            .addStructureInfo("You can have a bunch of hatches")
+            .addOtherStructurePart(
+                "Multi I/O Hatches",
+                "Instead of any casing or glass, has to touch storage field block")
+            .addStructureInfo("Use MIOH with conduits or fluid storage busses to see all fluids at once.")
+            .addSubChannelUsage("field", "Maximum Field Tier")
+            .addSubChannelUsage("height", "Height of structure")
+            .toolTipFinisher("KekzTech");
+        return tt;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        int layer = min(stackSize.stackSize + DEFAULT_LAYER_AMOUNT, MAX_LAYER_AMOUNT + 1);
+        buildPiece(STRUCTURE_PIECE_TOP, stackSize, hintsOnly, 2, 2, 0);
+        for (int i = -1; i >= 1 - layer; i--) buildPiece(STRUCTURE_PIECE_MID, stackSize, hintsOnly, 2, 2, i);
+        buildPiece(STRUCTURE_PIECE_BOTTOM, stackSize, hintsOnly, 2, 2, -layer);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        int build = survivialBuildPiece(STRUCTURE_PIECE_TOP, stackSize, 2, 2, 0, elementBudget, env, false, true);
+        if (build >= 0) return build;
+        int layer = min(stackSize.stackSize + DEFAULT_LAYER_AMOUNT, MAX_LAYER_AMOUNT + 1);
+        for (int i = -1; i >= 1 - layer; i--) {
+            build = survivialBuildPiece(STRUCTURE_PIECE_MID, stackSize, 2, 2, i, elementBudget, env, false, true);
+            if (build >= 0) return build;
+        }
+        return survivialBuildPiece(STRUCTURE_PIECE_BOTTOM, stackSize, 2, 2, -layer, elementBudget, env, false, true);
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public void clearHatches() {
+        super.clearHatches();
+        if (tfftHatch != null) {
+            tfftHatch.unbind();
+            tfftHatch = null;
+        }
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        Arrays.fill(FIELDS, 0);
+
+        this.capacity = BigInteger.ZERO;
+        this.capacityPerFluid = 0L;
+        this.casingAmount = 0;
+        this.runningCost = 0;
+
+        if (!checkPiece(STRUCTURE_PIECE_TOP, 2, 2, 0)) return false;
+
+        int layer = 1;
+        while (checkPiece(STRUCTURE_PIECE_MID, 2, 2, -layer)) layer++;
+        if (layer - 1 > MAX_LAYER_AMOUNT || layer - 1 < DEFAULT_LAYER_AMOUNT) return false;
+        if (!checkPiece(STRUCTURE_PIECE_BOTTOM, 2, 2, -layer)) return false;
+        if (casingAmount >= MIN_CASING_AMOUNT
+            && (tfftHatch != null || (!mInputHatches.isEmpty() && !mOutputHatches.isEmpty()))
+            && mInputHatches.size() + mOutputHatches.size() <= MAX_DISTINCT_FLUIDS * 2
+            && mMaintenanceHatches.size() == 1) {
+            BigInteger tempCap = BigInteger.ZERO;
+            for (int i = 0; i < this.FIELDS.length; i++) {
+                tempCap = tempCap.add(
+                    BigInteger.valueOf(Field.VALUES[i].getCapacity())
+                        .multiply(BigInteger.valueOf(this.FIELDS[i])));
+                this.runningCost += Field.VALUES[i].getCost() * this.FIELDS[i];
+            }
+            this.setCapacity(tempCap);
+
+            if (tfftHatch != null) tfftHatch.bind(this);
+
+            if (this.runningCost == 0) {
+                return true;
+            }
+
+            return !mEnergyHatches.isEmpty();
+        }
+        return false;
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack itemStack) {
+        mEfficiency = getCurrentEfficiency(null);
+        mEfficiencyIncrease = 10000;
+        mEUt = this.runningCost;
+        mMaxProgresstime = 20;
+
+        this.fluidSelector = (itemStack != null && itemStack.getItem() instanceof GT_IntegratedCircuit_Item)
+            ? (byte) itemStack.getItemDamage()
+            : -1;
+
+        // Suck in fluids
+        final ArrayList<FluidStack> inputFluids = getStoredFluids();
+
+        if (!inputFluids.isEmpty()) {
+            for (FluidStack aFluid : inputFluids) {
+                final FluidStack toDeplete = aFluid.copy();
+                toDeplete.amount = this.pull(aFluid, true);
+                depleteInput(toDeplete);
+            }
+        }
+
+        // Push out fluids
+        if (!this.mOutputHatches.isEmpty()) {
+            final FluidTankGT sFluid = this.getSelectedFluid();
+            boolean isFluidSelected = this.fluidSelector != -1;
+
+            if (!isFluidSelected || !sFluid.isEmpty()) {
+                for (GT_MetaTileEntity_Hatch_Output tHatch : this.mOutputHatches) {
+                    int hatchCapacity = tHatch.getCapacity();
+                    int hatchAmount = tHatch.getFluidAmount();
+                    int remaining = hatchCapacity - hatchAmount;
+
+                    if (remaining <= 0) continue;
+
+                    final FluidStack tFluid = tHatch.getFluid();
+
+                    String lockedFluidName = tHatch.getLockedFluidName() == null ? "" : tHatch.getLockedFluidName();
+                    String tFluidName = tFluid == null ? ""
+                        : tFluid.getFluid()
+                            .getName();
+
+                    boolean isFluidLocked = tHatch.isFluidLocked();
+                    boolean isFluidEmpty = tFluid == null || tHatch.getFluidAmount() == 0;
+
+                    if (isFluidLocked && !this.contains(lockedFluidName)) continue;
+                    if (!isFluidEmpty && !this.contains(tFluid)) continue;
+                    if ((isFluidLocked && !isFluidEmpty) && !lockedFluidName.equals(tFluidName)) continue;
+
+                    if (isFluidSelected) {
+                        if (isFluidLocked && !lockedFluidName.equals(sFluid.name())) continue;
+                        if (!isFluidEmpty && !sFluid.contains(tFluid)) continue;
+
+                        tHatch.fill(this.push(sFluid.get(remaining), true), true);
+                    } else if (isFluidLocked) {
+                        if (!isFluidEmpty && !lockedFluidName.equals(
+                            tFluid.getFluid()
+                                .getName()))
+                            continue;
+
+                        FluidStack aFluid = FluidRegistry.getFluidStack(lockedFluidName, remaining);
+                        tHatch.fill(this.push(aFluid, true), true);
+                    } else if (isFluidEmpty) {
+                        if (this.firstNotNull() != null) tHatch.fill(this.push(hatchCapacity, true), true);
+                    } else {
+                        tHatch.fill(this.push(new FluidStack(tFluid, remaining), true), true);
+                    }
+                }
+            }
+        }
+
+        if (this.mEUt > 0) this.mEUt = -this.mEUt;
+
+        return true;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        super.onPostTick(aBaseMetaTileEntity, aTick);
+        if (aBaseMetaTileEntity.isServerSide()) this.locked = !aBaseMetaTileEntity.isActive();
+    }
+
+    @Override
+    public String[] getInfoData() {
+        ArrayList<String> ll = new ArrayList<>();
+        NumberFormat nf = NumberFormat.getNumberInstance();
+
+        ll.add(EnumChatFormatting.YELLOW + "Stored Fluids:" + EnumChatFormatting.RESET);
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            FluidTankGT tank = STORE[i];
+            if (tank.isEmpty()) {
+                ll.add(MessageFormat.format("{0} - {1}: {2}L ({3}%)", i, "NULL", 0, 0));
+            } else {
+                String localizedName = STORE[i].get()
+                    .getLocalizedName();
+                String amount = nf.format(STORE[i].amount());
+                String percentage = capacityPerFluid > 0 ? String.valueOf(STORE[i].amount() * 100 / capacityPerFluid)
+                    : "";
+
+                ll.add(MessageFormat.format("{0} - {1}: {2}L ({3}%)", i, localizedName, amount, percentage));
+            }
+        }
+        ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+        ll.add("Used Capacity: " + nf.format(getStoredAmount()) + "L");
+        ll.add("Total Capacity: " + nf.format(capacity) + "L");
+        ll.add("Per-Fluid Capacity: " + nf.format(capacityPerFluid) + "L");
+        ll.add("Running Cost: " + getActualEnergyUsage() + "EU/t");
+        ll.add("Auto-voiding: " + doVoidExcess);
+        ll.add(
+            "Maintenance Status: " + ((getRepairStatus() == getIdealStatus())
+                ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET
+                : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+        ll.add("---------------------------------------------");
+
+        return ll.toArray(new String[0]);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setByteArray("capacity", capacity.toByteArray());
+        aNBT.setBoolean("doVoidExcess", doVoidExcess);
+        aNBT.setInteger("runningCost", runningCost);
+        aNBT.setBoolean("lockFluid", locked);
+        aNBT.setByte("fluidSelector", fluidSelector);
+
+        NBTTagCompound fluidNBT = new NBTTagCompound();
+        aNBT.setTag("STORE", fluidNBT);
+
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            STORE[i].writeToNBT(fluidNBT, String.valueOf(i));
+        }
+
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        this.setCapacity(new BigInteger(aNBT.getByteArray("capacity")));
+        this.setDoVoidExcess(aNBT.getBoolean("doVoidExcess"));
+        this.runningCost = aNBT.getInteger("runningCost");
+        this.locked = aNBT.getBoolean("lockFluid");
+        this.fluidSelector = aNBT.getByte("fluidSelector");
+
+        NBTTagCompound fluidNBT = (NBTTagCompound) aNBT.getTag("STORE");
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            STORE[i].readFromNBT(fluidNBT, String.valueOf(i));
+        }
+
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public boolean isGivingInformation() {
+        return true;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack stack) {
+        return 10000;
+    }
+
+    @Override
+    public int getPollutionPerTick(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack stack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack stack) {
+        return false;
+    }
+
+    @Override
+    public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+        super.onScrewdriverRightClick(side, aPlayer, aX, aY, aZ);
+        this.setDoVoidExcess(!doVoidExcess);
+        GT_Utility.sendChatToPlayer(aPlayer, "Auto-voiding " + (this.doVoidExcess ? "enabled" : "disabled"));
+    }
+
+    private boolean addMultiHatchToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+        if (aTileEntity != null) {
+            final IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+            if (aMetaTileEntity instanceof GTMTE_TFFTHatch) {
+                if (this.tfftHatch != null) return false;
+                this.tfftHatch = (GTMTE_TFFTHatch) aMetaTileEntity;
+                this.tfftHatch.updateTexture(aBaseCasingIndex);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int pull(FluidStack aFluid, boolean doPull) {
+        if (locked) return 0;
+        int index = getFluidPosition(aFluid);
+        if (index >= 0) {
+            return STORE[index].fill(aFluid, doPull);
+        } else if (fluidCount() < MAX_DISTINCT_FLUIDS) {
+            return STORE[getNullSlot()].setCapacity(capacityPerFluid)
+                .fill(aFluid, doPull);
+        }
+        return 0;
+    }
+
+    public long pull(FluidStack aFluid, long amount, boolean doPull) {
+        if (locked) return 0;
+        int index = getFluidPosition(aFluid);
+        if (index >= 0) {
+            FluidTankGT tank = STORE[index];
+            if (doPull) return tank.add(amount);
+            return doVoidExcess ? amount
+                : tank.amount() + amount > tank.capacity() ? tank.capacity() - tank.amount() : amount;
+        } else if (fluidCount() < MAX_DISTINCT_FLUIDS) {
+            FluidTankGT tank = STORE[getNullSlot()];
+            if (doPull) return tank.add(amount, aFluid);
+            return doVoidExcess ? amount : Math.min(amount, tank.capacity());
+        }
+        return 0;
+    }
+
+    public FluidStack push(FluidStack aFluid, boolean doPush) {
+        if (locked) return null;
+        int index = getFluidPosition(aFluid);
+        if (index < 0) return null;
+        return STORE[index].drain(aFluid.amount, doPush);
+    }
+
+    public FluidStack push(int amount, boolean doPush) {
+        if (locked) return null;
+        int index = firstNotNullSlot();
+        if (index < 0) return null;
+        return STORE[index].drain(amount, doPush);
+    }
+
+    public long push(FluidStack aFluid, long amount, boolean doPush) {
+        if (locked) return 0;
+        int index = getFluidPosition(aFluid);
+        if (index < 0) return 0;
+        if (doPush) return STORE[index].remove(amount);
+        return STORE[index].amount(amount);
+    }
+
+    public long getCapacityPerFluid() {
+        return this.capacityPerFluid;
+    }
+
+    public void setCapacity(BigInteger capacity) {
+        if (capacity.compareTo(MAX_CAPACITY) > 0) {
+            this.capacity = MAX_CAPACITY;
+            this.capacityPerFluid = Long.MAX_VALUE;
+        } else {
+            this.capacity = capacity;
+            this.capacityPerFluid = capacity.divide(BigInteger.valueOf(MAX_DISTINCT_FLUIDS))
+                .longValue();
+        }
+
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            FluidTankGT tank = STORE[i];
+            if (tank.setCapacity(capacityPerFluid)
+                .amount() > capacityPerFluid) {
+                STORE[i] = new FluidTankGT(tank.get(), capacityPerFluid, capacityPerFluid);
+            }
+        }
+    }
+
+    public int fluidCount() {
+        int tCount = 0;
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (!STORE[i].isEmpty()) tCount++;
+        }
+        return tCount;
+    }
+
+    public int getFluidPosition(String fluidName) {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (!STORE[i].isEmpty() && STORE[i].name()
+                .equals(fluidName)) return i;
+        }
+        return -1;
+    }
+
+    public int getFluidPosition(FluidStack aFluid) {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (STORE[i].contains(aFluid)) return i;
+        }
+        return -1;
+    }
+
+    public int getNullSlot() {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (STORE[i].isEmpty()) return i;
+        }
+        return -1;
+    }
+
+    public boolean contains(String fluidName) {
+        return getFluidPosition(fluidName) >= 0;
+    }
+
+    public boolean contains(FluidStack aFluid) {
+        return getFluidPosition(aFluid) >= 0;
+    }
+
+    public int firstNotNullSlot() {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (!STORE[i].isEmpty()) return i;
+        }
+        return -1;
+    }
+
+    public FluidTankGT firstNotNull() {
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            if (!STORE[i].isEmpty()) return STORE[i];
+        }
+        return null;
+    }
+
+    public BigInteger getStoredAmount() {
+        BigInteger amount = BigInteger.ZERO;
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            amount = amount.add(BigInteger.valueOf(STORE[i].amount()));
+        }
+        return amount;
+    }
+
+    public byte getFluidSelector() {
+        return fluidSelector;
+    }
+
+    public FluidTankGT getSelectedFluid() {
+        return fluidSelector != -1 ? STORE[fluidSelector] : null;
+    }
+
+    public void setDoVoidExcess(boolean doVoidExcess) {
+        this.doVoidExcess = doVoidExcess;
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            STORE[i].setVoidExcess(doVoidExcess);
+        }
+    }
+
+    public FluidTankInfo[] getTankInfo() {
+        FluidTankInfo[] info = new FluidTankInfo[MAX_DISTINCT_FLUIDS];
+        for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) {
+            STORE[i].getFluid(); //
+            info[i] = STORE[i].getInfo();
+        }
+        return info;
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java b/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java
new file mode 100644
index 0000000000..39eb6dee64
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java
@@ -0,0 +1,271 @@
+package common.tileentities;
+
+import java.util.HashMap;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.storage.IExternalStorageHandler;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.IMEMonitorHandlerReceiver;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IItemList;
+import appeng.util.item.AEFluidStack;
+import appeng.util.item.FluidList;
+import cpw.mods.fml.common.Optional;
+import gregtech.api.enums.Textures;
+import gregtech.api.fluid.FluidTankGT;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.render.TextureFactory;
+
+@Optional.Interface(iface = "appeng.api.storage.IMEMonitor", modid = "appliedenergistics2", striprefs = true)
+public class GTMTE_TFFTHatch extends GT_MetaTileEntity_Hatch implements IMEMonitor<IAEFluidStack> {
+
+    @Optional.Interface(
+        iface = "appeng.api.storage.IExternalStorageHandler",
+        modid = "appliedenergistics2",
+        striprefs = true)
+    private static class AE2TFFTHatchHandler implements IExternalStorageHandler {
+
+        @Override
+        @Optional.Method(modid = "appliedenergistics2")
+        public boolean canHandle(TileEntity te, ForgeDirection d, StorageChannel channel, BaseActionSource mySrc) {
+            return channel == StorageChannel.FLUIDS && te instanceof BaseMetaTileEntity
+                && ((BaseMetaTileEntity) te).getMetaTileEntity() instanceof GTMTE_TFFTHatch;
+        }
+
+        @Override
+        @Optional.Method(modid = "appliedenergistics2")
+        public IMEInventory getInventory(TileEntity te, ForgeDirection d, StorageChannel channel,
+            BaseActionSource src) {
+            if (channel == StorageChannel.FLUIDS) {
+                return ((GTMTE_TFFTHatch) (((BaseMetaTileEntity) te).getMetaTileEntity()));
+            }
+            return null;
+        }
+    }
+
+    private static final Textures.BlockIcons.CustomIcon TEXTURE_TFFT_HATCH = new Textures.BlockIcons.CustomIcon(
+        "iconsets/TFFT_HATCH");
+
+    private HashMap<IMEMonitorHandlerReceiver<IAEFluidStack>, Object> listeners = new HashMap<>();
+    private GTMTE_TFFT controller;
+
+    public GTMTE_TFFTHatch(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional, 3, 0, "All-in-one access for the T.F.F.T");
+    }
+
+    public GTMTE_TFFTHatch(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+    }
+
+    @Override
+    public boolean isFacingValid(ForgeDirection facing) {
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+        int colorIndex, boolean aActive, boolean aRedstone) {
+        return super.getTexture(aBaseMetaTileEntity, side, facing, colorIndex, aActive, aRedstone);
+    }
+
+    @Override
+    public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(Textures.BlockIcons.OVERLAY_PIPE_IN),
+            TextureFactory.builder()
+                .addIcon(TEXTURE_TFFT_HATCH)
+                .extFacing()
+                .build() };
+    }
+
+    @Override
+    public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+        return new ITexture[] { aBaseTexture, TextureFactory.of(Textures.BlockIcons.OVERLAY_PIPE_IN),
+            TextureFactory.builder()
+                .addIcon(TEXTURE_TFFT_HATCH)
+                .extFacing()
+                .build() };
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GTMTE_TFFTHatch(mName, mTier, mDescriptionArray, mTextures);
+    }
+
+    @Override
+    public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+        return (controller != null) ? controller.pull(resource, doFill) : 0;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+        if (controller != null) {
+            final FluidTankGT sFluid = controller.getSelectedFluid();
+            if (controller.getFluidSelector() == -1 || (sFluid != null && sFluid.contains(resource))) {
+                return controller.push(resource, doDrain);
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+        if (controller != null) {
+            final FluidTankGT sFluid = controller.getSelectedFluid();
+            if (controller.getFluidSelector() == -1) return controller.push(maxDrain, doDrain);
+            if (sFluid != null) return controller.push(sFluid.get(maxDrain), doDrain);
+        }
+        return null;
+    }
+
+    @Override
+    public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+        return (controller != null) ? controller.getTankInfo() : null;
+    }
+
+    public void bind(GTMTE_TFFT controller) {
+        this.controller = controller;
+    }
+
+    public void unbind() {
+        this.controller = null;
+    }
+
+    @Optional.Method(modid = "appliedenergistics2")
+    public static void registerAEIntegration() {
+        AEApi.instance()
+            .registries()
+            .externalStorage()
+            .addExternalStorageInterface(new AE2TFFTHatchHandler());
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public IItemList<IAEFluidStack> getAvailableItems(IItemList out) {
+        if (controller != null) {
+            for (int i = 0; i < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; i++) {
+                if (!controller.STORE[i].isEmpty()) {
+                    IAEFluidStack s = AEFluidStack.create(controller.STORE[i].get());
+                    s.setStackSize(controller.STORE[i].amount());
+                    out.add(s);
+                }
+            }
+        }
+        return out;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public IItemList<IAEFluidStack> getStorageList() {
+        IItemList<IAEFluidStack> fluidList = new FluidList();
+        if (controller != null) {
+            for (int i = 0; i < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; i++) {
+                if (!controller.STORE[i].isEmpty()) {
+                    IAEFluidStack s = AEFluidStack.create(controller.STORE[i].get());
+                    s.setStackSize(controller.STORE[i].amount());
+                    fluidList.add(s);
+                }
+            }
+        }
+        return fluidList;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public void addListener(IMEMonitorHandlerReceiver<IAEFluidStack> l, Object verificationToken) {
+        if (listeners == null) listeners = new HashMap<>();
+        listeners.put(l, verificationToken);
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public void removeListener(IMEMonitorHandlerReceiver<IAEFluidStack> l) {
+        if (listeners == null) listeners = new HashMap<>();
+        listeners.remove(l);
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public AccessRestriction getAccess() {
+        return AccessRestriction.READ_WRITE;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public boolean isPrioritized(IAEFluidStack input) {
+        if (controller == null || input == null) return false;
+        return controller.contains(input.getFluidStack()) || controller.fluidCount() < GTMTE_TFFT.MAX_DISTINCT_FLUIDS;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public boolean canAccept(IAEFluidStack input) {
+        if (controller == null || input == null) return false;
+        return controller.contains(input.getFluidStack()) || controller.fluidCount() < GTMTE_TFFT.MAX_DISTINCT_FLUIDS;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public int getPriority() {
+        return 0;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public int getSlot() {
+        return 0;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public boolean validForPass(int i) {
+        return true;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public IAEFluidStack injectItems(IAEFluidStack input, Actionable mode, BaseActionSource src) {
+        final FluidStack inputStack = input.getFluidStack();
+        if (inputStack == null) return null;
+        if (controller == null || getBaseMetaTileEntity() == null) return input;
+        if (mode != Actionable.SIMULATE) getBaseMetaTileEntity().markDirty();
+        long amount = controller.pull(input.getFluidStack(), input.getStackSize(), mode != Actionable.SIMULATE);
+        if (amount == 0) return input;
+        if (amount == input.getStackSize()) return null;
+        IAEFluidStack result = AEFluidStack.create(input.getFluidStack());
+        result.setStackSize(input.getStackSize() - amount);
+        return result;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public IAEFluidStack extractItems(IAEFluidStack request, Actionable mode, BaseActionSource src) {
+        if (controller == null || getBaseMetaTileEntity() == null) return null;
+        if (mode != Actionable.SIMULATE) getBaseMetaTileEntity().markDirty();
+        long amount = controller.push(request.getFluidStack(), request.getStackSize(), mode != Actionable.SIMULATE);
+        if (amount == 0) return null;
+        if (amount == request.getStackSize()) return request.copy();
+        IAEFluidStack result = AEFluidStack.create(request.getFluidStack());
+        result.setStackSize(amount);
+        return result;
+    }
+
+    @Override
+    @Optional.Method(modid = "appliedenergistics2")
+    public StorageChannel getChannel() {
+        return StorageChannel.FLUIDS;
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/TE_IchorJar.java b/kekztech/src/main/java/common/tileentities/TE_IchorJar.java
new file mode 100644
index 0000000000..b5e85a9f2b
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/TE_IchorJar.java
@@ -0,0 +1,10 @@
+package common.tileentities;
+
+import thaumcraft.common.tiles.TileJarFillable;
+
+public class TE_IchorJar extends TileJarFillable {
+
+    public TE_IchorJar() {
+        super.maxAmount = 4096;
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java b/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java
new file mode 100644
index 0000000000..9046b2bc33
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java
@@ -0,0 +1,10 @@
+package common.tileentities;
+
+import thaumcraft.common.tiles.TileJarFillableVoid;
+
+public class TE_IchorVoidJar extends TileJarFillableVoid {
+
+    public TE_IchorVoidJar() {
+        super.maxAmount = 4096;
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java
new file mode 100644
index 0000000000..e54324220f
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java
@@ -0,0 +1,10 @@
+package common.tileentities;
+
+import thaumcraft.common.tiles.TileJarFillable;
+
+public class TE_ThaumiumReinforcedJar extends TileJarFillable {
+
+    public TE_ThaumiumReinforcedJar() {
+        super.maxAmount = 256;
+    }
+}
diff --git a/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java
new file mode 100644
index 0000000000..dd0166fe6e
--- /dev/null
+++ b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java
@@ -0,0 +1,10 @@
+package common.tileentities;
+
+import thaumcraft.common.tiles.TileJarFillableVoid;
+
+public class TE_ThaumiumReinforcedVoidJar extends TileJarFillableVoid {
+
+    public TE_ThaumiumReinforcedVoidJar() {
+        super.maxAmount = 256;
+    }
+}