18 files changed, 3557 insertions, 0 deletions
diff --git a/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java b/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java
new file mode 100644
index 0000000000..1c32525c4e
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java
@@ -0,0 +1,531 @@
+package common.tileentities;
+
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import kekztech.MultiFluidHandler;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import org.lwjgl.input.Keyboard;
+
+import common.Blocks;
+import common.blocks.*;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class GTMTE_FluidMultiStorage extends GT_MetaTileEntity_MultiBlockBase {
+	
+	private final static String glassNameIC2Reinforced = "blockAlloyGlass";
+	private final static Block CASING = Blocks.tfftCasing;
+	private final static Block_TFFTStorageFieldBlockT1 STORAGE_FIELD1 = (Block_TFFTStorageFieldBlockT1) Blocks.tfftStorageField1;
+	private final static Block_TFFTStorageFieldBlockT2 STORAGE_FIELD2 = (Block_TFFTStorageFieldBlockT2) Blocks.tfftStorageField2;
+	private final static Block_TFFTStorageFieldBlockT3 STORAGE_FIELD3 = (Block_TFFTStorageFieldBlockT3) Blocks.tfftStorageField3;
+	private final static Block_TFFTStorageFieldBlockT4 STORAGE_FIELD4 = (Block_TFFTStorageFieldBlockT4) Blocks.tfftStorageField4;
+	private final static Block_TFFTStorageFieldBlockT5 STORAGE_FIELD5 = (Block_TFFTStorageFieldBlockT5) Blocks.tfftStorageField5;
+	private final static Block MULTI_HATCH = Blocks.tfftMultiHatch;
+	private final static int CASING_TEXTURE_ID = 176;
+
+	private MultiFluidHandler mfh;
+	private HashSet<TE_TFFTMultiHatch> multiHatches = new HashSet<>();
+
+	private int runningCost = 0;
+	private boolean doVoidExcess = false;
+	private byte fluidSelector = 0;
+
+	public GTMTE_FluidMultiStorage(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public GTMTE_FluidMultiStorage(String aName) {
+		super(aName);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+		return new GTMTE_FluidMultiStorage(super.mName);
+	}
+
+	@Override
+	public String[] getDescription() {
+		final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+		b.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()
+				.beginStructureBlock(5, 9, 5)
+				.addController("Top Center")
+				.addEnergyHatch("Any top or bottom casing")
+				.addOtherStructurePart("Inner 3x7x3 solid pillar", "Storage Field Blocks")
+				.addOtherStructurePart("Outer 5x7x5 glass shell", "IC2 Reinforced Glass")
+				.addMaintenanceHatch("Any top or bottom casing")
+				.addIOHatches("Instead of any casing or glass, have to touch storage field.")
+				.signAndFinalize("Kekzdealer");
+		if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex,
+								 boolean aActive, boolean aRedstone) {
+		return aSide == aFacing
+				? new ITexture[]{BlockIcons.casingTexturePages[1][48],
+				new GT_RenderedTexture(aActive
+						? BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR_ACTIVE
+						: BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR)}
+				: new ITexture[]{BlockIcons.casingTexturePages[1][48]};
+	}
+
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack var1) {
+		return true;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack guiSlotItem) {
+
+		super.mEfficiency = 10000 - (super.getIdealStatus() - super.getRepairStatus()) * 1000;
+		super.mEfficiencyIncrease = 10000;
+		super.mEUt = runningCost;
+		super.mMaxProgresstime = 10;
+		
+		if(guiSlotItem != null && guiSlotItem.getUnlocalizedName().equals("gt.integrated_circuit")) {
+			this.fluidSelector = (byte) guiSlotItem.getItemDamage();
+		}
+		
+		// If there are no basic I/O hatches, let multi hatches handle it and skip a lot of code!
+		if (multiHatches.size() > 0 && super.mInputHatches.size() == 0 && super.mOutputHatches.size() == 0) {
+			return true;
+		}
+
+		// Suck in fluids
+		final ArrayList<FluidStack> inputHatchFluids = super.getStoredFluids();
+		if (inputHatchFluids.size() > 0) {
+
+			for (FluidStack fluidStack : inputHatchFluids) {
+
+				final int pushed = mfh.pushFluid(fluidStack, true);
+				final FluidStack toDeplete = fluidStack.copy();
+				toDeplete.amount = pushed;
+				super.depleteInput(toDeplete);
+			}
+		}
+
+		// Push out fluids
+		if (guiSlotItem != null && guiSlotItem.getUnlocalizedName().equals("gt.integrated_circuit")) {
+			final FluidStack storedFluid = mfh.getFluid(fluidSelector);
+			// Sum available output capacity
+			int possibleOutput = 0;
+			for (GT_MetaTileEntity_Hatch_Output outputHatch : super.mOutputHatches) {
+				if (outputHatch.isFluidLocked() && outputHatch.getLockedFluidName().equals(storedFluid.getUnlocalizedName())) {
+					possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+				} else if (outputHatch.getFluid() != null && outputHatch.getFluid().getUnlocalizedName().equals(storedFluid.getUnlocalizedName())) {
+					possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+				} else if (outputHatch.getFluid() == null) {
+					possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+				}
+			}
+			// Output as much as possible
+			final FluidStack tempStack = storedFluid.copy();
+			tempStack.amount = possibleOutput;
+			tempStack.amount = mfh.pullFluid(tempStack, fluidSelector, true);
+			super.addOutput(tempStack);
+
+		} else {
+			for (FluidStack storedFluid : mfh.getFluids()) {
+				// Sum available output capacity
+				int possibleOutput = 0;
+				for (GT_MetaTileEntity_Hatch_Output outputHatch : super.mOutputHatches) {
+					if (outputHatch.isFluidLocked() && outputHatch.getLockedFluidName().equals(storedFluid.getUnlocalizedName())) {
+						possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+					} else if (outputHatch.getFluid() != null && outputHatch.getFluid().getUnlocalizedName().equals(storedFluid.getUnlocalizedName())) {
+						possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+					} else if (outputHatch.getFluid() == null) {
+						possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount();
+					}
+				}
+				// output as much as possible
+				final FluidStack tempStack = storedFluid.copy();
+				tempStack.amount = possibleOutput;
+				// TODO possible concurrent modification exception as pullFluid calls remove() without an iterator
+				tempStack.amount = mfh.pullFluid(tempStack, true);
+				super.addOutput(tempStack);
+			}
+		}
+
+		return true;
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		super.onPostTick(aBaseMetaTileEntity, aTick);
+
+		if (mfh != null) {
+			mfh.setLock(!super.getBaseMetaTileEntity().isActive());
+			mfh.setFluidSelector(fluidSelector);
+			mfh.setDoVoidExcess(doVoidExcess);
+		}
+	}
+
+	public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+		final Vector3i offset = new Vector3i();
+
+		// either direction on z-axis
+		if (forgeDirection.x() == 0 && forgeDirection.z() == -1) {
+			offset.x = x;
+			offset.y = y;
+			offset.z = z;
+		}
+		if (forgeDirection.x() == 0 && forgeDirection.z() == 1) {
+			offset.x = -x;
+			offset.y = y;
+			offset.z = -z;
+		}
+		// either direction on x-axis
+		if (forgeDirection.x() == -1 && forgeDirection.z() == 0) {
+			offset.x = z;
+			offset.y = y;
+			offset.z = -x;
+		}
+		if (forgeDirection.x() == 1 && forgeDirection.z() == 0) {
+			offset.x = -z;
+			offset.y = y;
+			offset.z = x;
+		}
+		// either direction on y-axis
+		if (forgeDirection.y() == -1) {
+			offset.x = x;
+			offset.y = z;
+			offset.z = y;
+		}
+
+		return offset;
+	}
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+		// Figure out the vector for the direction the back face of the controller is facing
+		final Vector3ic forgeDirection = new Vector3i(
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+		);
+		int minCasingAmount = 20;
+		boolean formationChecklist = true; // If this is still true at the end, machine is good to go :)
+		float runningCostAcc = 0;
+		double fluidCapacityAcc = 0;
+
+		multiHatches.clear();
+
+		// Front segment
+		for (int X = -2; X <= 2; X++) {
+			for (int Y = -2; Y <= 2; Y++) {
+				if (X == 0 && Y == 0) {
+					continue; // Skip controller
+				}
+
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0);
+				final IGregTechTileEntity currentTE =
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+
+				// Fluid hatches should touch the storage field. 
+				// Maintenance/Energy hatch can go anywhere
+				if (X > -2 && X < 2 && Y > -2 && Y < 2) {
+					if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+
+						final Block b = thisController.getBlockOffset(offset.x(), offset.y(), offset.z());
+
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						// Also check for multi hatch
+						if (b == CASING) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else if (b == MULTI_HATCH) {
+							final TE_TFFTMultiHatch mh =
+									(TE_TFFTMultiHatch) thisController.getWorld().getTileEntity(
+											thisController.getXCoord() + offset.x(),
+											thisController.getYCoord() + offset.y(),
+											thisController.getZCoord() + offset.z());
+							multiHatches.add(mh);
+						} else {
+							formationChecklist = false;
+						}
+					}
+				} else {
+					if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+
+		// Middle seven long segment
+		for (int X = -2; X <= 2; X++) {
+			for (int Y = -2; Y <= 2; Y++) {
+				for (int Z = -1; Z >= -7; Z--) {
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+					if (X > -2 && X < 2 && Y > -2 && Y < 2) {
+						if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(STORAGE_FIELD1.getUnlocalizedName())) {
+							runningCostAcc += 0.5f;
+							fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT1.getCapacity();
+						} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(STORAGE_FIELD2.getUnlocalizedName())) {
+							runningCostAcc += 1.0f;
+							fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT2.getCapacity();
+						} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(STORAGE_FIELD3.getUnlocalizedName())) {
+							runningCostAcc += 2.0f;
+							fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT3.getCapacity();
+						} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(STORAGE_FIELD4.getUnlocalizedName())) {
+							runningCostAcc += 4.0f;
+							fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT4.getCapacity();
+						} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(STORAGE_FIELD5.getUnlocalizedName())) {
+							runningCostAcc += 8.0f;
+							fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT5.getCapacity();
+						} else {
+							formationChecklist = false;
+						}
+						continue;
+					}
+
+					// Get next TE
+					final IGregTechTileEntity currentTE =
+							thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+
+					// Corner allows only glass
+					if (X == -2 && Y == -2 || X == 2 && Y == 2 || X == -2 && Y == 2 || X == 2 && Y == -2) {
+						if (!(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameIC2Reinforced))) {
+							formationChecklist = false;
+						}
+					} else {
+						// Tries to add TE as either of those kinds of hatches.
+						// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+						if (!super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+								&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+
+							// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+							// Also check for multi hatch
+							if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+								// Seems to be valid casing. Decrement counter.
+								minCasingAmount--;
+							} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == MULTI_HATCH) {
+								final TE_TFFTMultiHatch mh =
+										(TE_TFFTMultiHatch) thisController.getWorld().getTileEntity(
+												thisController.getXCoord() + offset.x(),
+												thisController.getYCoord() + offset.y(),
+												thisController.getZCoord() + offset.z());
+								multiHatches.add(mh);
+							} else if (!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameIC2Reinforced)) {
+								formationChecklist = false;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Back segment
+		for (int X = -2; X <= 2; X++) {
+			for (int Y = -2; Y <= 2; Y++) {
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, -8);
+				final IGregTechTileEntity currentTE =
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+
+				// Fluid hatches should touch the storage field. 
+				// Maintenance/Energy hatch can go anywhere
+				if (X > -2 && X < 2 && Y > -2 && Y < 2) {
+					if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == MULTI_HATCH) {
+							final TE_TFFTMultiHatch mh =
+									(TE_TFFTMultiHatch) thisController.getWorld().getTileEntity(
+											thisController.getXCoord() + offset.x(),
+											thisController.getYCoord() + offset.y(),
+											thisController.getZCoord() + offset.z());
+							multiHatches.add(mh);
+						} else {
+							formationChecklist = false;
+						}
+					}
+				} else {
+					if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+							&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+
+		if (this.mEnergyHatches.size() < 1) {
+			formationChecklist = false;
+		}
+
+		if (this.mMaintenanceHatches.size() < 1) {
+			formationChecklist = false;
+		}
+
+		if (minCasingAmount > 0) {
+			formationChecklist = false;
+		}
+
+		if (formationChecklist) {
+			runningCost = Math.round(-runningCostAcc);
+			// Update MultiFluidHandler in case storage cells have been changed
+			final int capacityPerFluid = (int) Math.round(fluidCapacityAcc / 25.0f);
+			if (mfh == null) {
+				mfh = new MultiFluidHandler(capacityPerFluid);
+			} else {
+				if (mfh.getCapacity() != capacityPerFluid) {
+					mfh = new MultiFluidHandler(capacityPerFluid, mfh.getFluids());
+				}
+			}
+			for (TE_TFFTMultiHatch mh : multiHatches) {
+				mh.setMultiFluidHandler(mfh);
+			}
+		}
+
+		return formationChecklist;
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		if (doVoidExcess) {
+			doVoidExcess = false;
+			aPlayer.addChatComponentMessage(new ChatComponentText("Auto-voiding turned off"));
+		} else {
+			doVoidExcess = true;
+			aPlayer.addChatComponentMessage(new ChatComponentText("Auto-voiding turned on"));
+		}
+	}
+
+	@Override
+	public String[] getInfoData() {
+		final ArrayList<String> ll = mfh.getInfoData();
+
+		ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+		ll.add("Auto-voiding: " + doVoidExcess);
+		ll.add("Per-Fluid Capacity: " + mfh.getCapacity() + "L");
+		ll.add("Running Cost: "
+				// mEUt does not naturally reflect efficiency status. Do that here.
+				+ ((-super.mEUt) * 10000 / Math.max(1000, super.mEfficiency)) + "EU/t");
+		ll.add("Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus())
+				? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET
+				: EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+		ll.add("---------------------------------------------");
+
+		final String[] a = new String[ll.size()];
+		return ll.toArray(a);
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+		nbt.setInteger("runningCost", runningCost);
+		nbt.setBoolean("doVoidExcess", doVoidExcess);
+
+		nbt.setInteger("capacityPerFluid", mfh.getCapacity());
+		nbt.setTag("fluids", mfh.saveNBTData(new NBTTagCompound()));
+
+		super.saveNBTData(nbt);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+		runningCost = nbt.getInteger("runningCost");
+		doVoidExcess = nbt.getBoolean("doVoidExcess");
+
+		mfh = new MultiFluidHandler();
+		mfh.loadNBTData(nbt);
+		for (TE_TFFTMultiHatch mh : multiHatches) {
+			mh.setMultiFluidHandler(mfh);
+		}
+		super.loadNBTData(nbt);
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public int getMaxEfficiency(ItemStack var1) {
+		return 10000;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack var1) {
+		return 0;
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack var1) {
+		return 0;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack var1) {
+		return false;
+	}
+}
+\ No newline at end of file
diff --git a/src/main/java/common/tileentities/GTMTE_ItemServer.java b/src/main/java/common/tileentities/GTMTE_ItemServer.java
new file mode 100644
index 0000000000..cfff360ce4
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_ItemServer.java
@@ -0,0 +1,393 @@
+package common.tileentities;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+import org.lwjgl.input.Keyboard;
+
+import common.Blocks;
+import common.blocks.Block_ItemServerDrive;
+import common.blocks.Block_ItemServerIOPort;
+import common.blocks.Block_ItemServerRackCasing;
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import kekztech.MultiItemHandler;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+public class GTMTE_ItemServer extends GT_MetaTileEntity_MultiBlockBase {
+	
+	private static final int BASE_SEGMENT_ENERGY_COST = 1;
+	private static final int BASE_PER_ITEM_CAPACITY = 1024;
+	private static final int BASE_ITEM_TYPES_PER_SEGMENT = 4;
+	
+	private final Block_ItemServerDrive DRIVE = (Block_ItemServerDrive) Blocks.itemServerDrive;
+	private final Block_ItemServerRackCasing CASING = (Block_ItemServerRackCasing) Blocks.itemServerRackCasing;
+	private final Block_ItemServerIOPort IO_PORT = (Block_ItemServerIOPort) Blocks.itemServerIOPort;
+	private final String ALU_FRAME_BOX_NAME = "gt.blockmachines";
+	private final int ALU_FRAME_BOX_META = 6;
+	private final int CASING_TEXTURE_ID = 176;
+	
+	private MultiItemHandler mih;
+	private HashSet<TE_ItemServerIOPort> ioPorts = new HashSet<>(); 
+	private int sliceCount = 0;
+	
+	public GTMTE_ItemServer(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public GTMTE_ItemServer(String aName) {
+		super(aName);
+	}
+	
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+		return new GTMTE_ItemServer(super.mName);
+	}
+	
+	@Override
+	public String[] getDescription() {
+		final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+		b.addInfo("[W.I.P - Probably doesn't work]")
+				.addInfo("High-Tech item storage!")
+				.addInfo("Variable length: Slices 2-4 can be repeated as long as the total length does not exceed 16 blocks.")
+				.addInfo("Each segment offers storage for 128 item types")
+				.addInfo("Storage capacity per item depends on the controller configuration.")
+				.addInfo("Insert an Integrated Circuit into the controller with your desired configuration.")
+				.addInfo("The base configuration (0) is 1024 items per type. For each higher level, the capacity quadruples.")
+				.addInfo("Each slice also adds 1EU/t of power consumption and doubles with rising configuration values.")
+				.addInfo("Valid config values are from zero to eight.")
+				.addSeparator()
+				.beginStructureBlock(3, 5, 4)
+				.addController("Front Bottom Center")
+				.addEnergyHatch("Any casing")
+				.addOtherStructurePart("Front slice", "3x5x1 Item Server Rack Casing")
+				.addOtherStructurePart("2nd and 3rd slice, center", "1x4x1 Aluminium Frame Box")
+				.addOtherStructurePart("2nd and 3rd slice, top", "3x1x1 Item Server Rack Casing")
+				.addOtherStructurePart("2nd and 3rd slice, sides", "2x 1x4x1 Item Server Drive")
+				.addOtherStructurePart("Back slice", "3x5x1 Item Server Rack Casing")
+				.signAndFinalize("Kekzdealer");
+		if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+	
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex,
+			boolean aActive, boolean aRedstone) {
+		return aSide == aFacing
+				? new ITexture[]{BlockIcons.casingTexturePages[1][48],
+						new GT_RenderedTexture(aActive
+								? BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR_ACTIVE
+								: BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR)}
+				: new ITexture[]{BlockIcons.casingTexturePages[1][48]};
+	}
+
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack var1) {
+		return true;
+	}
+	
+	@Override
+	public boolean checkRecipe(ItemStack guiSlotItem) {
+		final int config = (guiSlotItem != null && guiSlotItem.getUnlocalizedName().equals("gt.integrated_circuit")) 
+				? Math.min(8, guiSlotItem.getItemDamage()) : 0;
+				
+		this.mEfficiency = 10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000;
+		this.mEfficiencyIncrease = 10000;
+		this.mEUt = (int) -(BASE_SEGMENT_ENERGY_COST * sliceCount * Math.pow(2, config));
+		super.mMaxProgresstime = 20;
+		
+		mih.setPerTypeCapacity((int) (BASE_PER_ITEM_CAPACITY * Math.pow(4, config)));
+		
+		return true;
+	}
+	
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		super.onPostTick(aBaseMetaTileEntity, aTick);
+		
+		if(mih != null) {
+			mih.setLock(!super.getBaseMetaTileEntity().isActive());
+		}
+	}
+	
+	public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+		final Vector3i offset = new Vector3i();
+		
+		// either direction on z-axis
+		if(forgeDirection.x() == 0 && forgeDirection.z() == -1) {
+			offset.x = x;
+			offset.y = y;
+			offset.z = z;
+		}
+		if(forgeDirection.x() == 0 && forgeDirection.z() == 1) {
+			offset.x = -x;
+			offset.y = y;
+			offset.z = -z;
+		}
+		// either direction on x-axis
+		if(forgeDirection.x() == -1 && forgeDirection.z() == 0) {
+			offset.x = z;
+			offset.y = y;
+			offset.z = -x;
+		}
+		if(forgeDirection.x() == 1 && forgeDirection.z() == 0) {
+			offset.x = -z;
+			offset.y = y;
+			offset.z = x;
+		}
+		
+		return offset;
+	}
+	
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+		// Figure out the vector for the direction the back face of the controller is facing
+		final Vector3ic forgeDirection = new Vector3i(
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+				); 
+		boolean formationChecklist = true;
+		
+		// Front slice
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = 0; Y <= 4; Y++) {
+				if(X == 0 && Y == 0) {
+					continue; // is controller
+				}
+				
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0);
+				IGregTechTileEntity currentTE = 
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+				
+				if(!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+						&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+					
+					// Is casing or IO port?
+					if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+						// Is casing, but there's no casing requirements
+					} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == IO_PORT) {
+						final TE_ItemServerIOPort port = 
+								(TE_ItemServerIOPort) thisController.getWorld().getTileEntity(
+										thisController.getXCoord() + offset.x(), 
+										thisController.getYCoord() + offset.y(),
+										thisController.getZCoord() + offset.z());
+						ioPorts.add(port);
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}
+		
+		// Check slices
+		int segmentsFound = 0;
+		int zOffset = -1; // -1 is the first slice after the front one. It goes in negative direction.
+		
+		while(segmentsFound < 5) {
+			if(checkSegment(thisController, forgeDirection, zOffset)) {
+				segmentsFound++;
+				zOffset -= 3; // Each segment is 3 blocks long, so progress Z by -3
+				
+				System.out.println("Item Server segment approved: " + segmentsFound);
+			} else {
+				System.out.println("Item Server segment rejected: " + (segmentsFound + 1));
+				break;
+			}
+		}
+		
+		if(segmentsFound < 1) {
+			System.out.println("At least one slice required for storage");
+			formationChecklist = false;
+		}
+		
+		if(this.mEnergyHatches.size() < 1) {
+			System.out.println("At least one energy hatch is required!");
+			formationChecklist = false;
+		}
+		
+		if(this.mMaintenanceHatches.size() < 1) {
+			System.out.println("You need a maintenance hatch to do maintenance.");
+			formationChecklist = false;
+		}
+		
+		if(formationChecklist) {
+			sliceCount = segmentsFound;
+			
+			if(mih == null) {
+				mih = new MultiItemHandler();
+				mih.setItemTypeCapacity(segmentsFound * BASE_ITEM_TYPES_PER_SEGMENT);
+			}
+			System.out.println("Configuring " + ioPorts.size() + " ports");
+			for(TE_ItemServerIOPort port : ioPorts) {
+				port.setMultiItemHandler(mih);
+			}
+		}
+		
+		return formationChecklist;
+	}
+	
+	public boolean checkSegment(IGregTechTileEntity thisController, Vector3ic forgeDirection, int zOffset) {
+		boolean formationChecklist = true;
+		// Slice by slice
+		for(int Z = 0; Z >= -2; Z--) {
+			// Is not back slice
+			if(Z != -2) {
+				// Left to right
+				for(int X = -1; X <= 1; X++) {
+					// Bottom to top
+					for(int Y = 0; Y <= 4; Y++) {
+						final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, zOffset + Z);
+						
+						// Server rack roof
+						if(Y == 4) {
+							final IGregTechTileEntity currentTE = 
+									thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+							
+							if(!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+									&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+								// Is casing or IO port?
+								if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+									// Is casing, but there's no casing requirements
+								} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == IO_PORT) {
+									final TE_ItemServerIOPort port = 
+											(TE_ItemServerIOPort) thisController.getWorld().getTileEntity(
+													thisController.getXCoord() + offset.x(), 
+													thisController.getYCoord() + offset.y(),
+													thisController.getZCoord() + offset.z());
+									ioPorts.add(port);
+								} else {
+									formationChecklist = false;
+								}
+							}
+						}
+						
+						// Middle wall is aluminium frame boxes
+						else if(Y <= 3 && X == 0) {
+							if(!(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(ALU_FRAME_BOX_NAME))
+									|| !(thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == ALU_FRAME_BOX_META)) {
+								formationChecklist = false;
+							}
+						}
+						
+						// Side walls are item server drives
+						else if(Y <= 3 && X != 0) {
+							if(!(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == DRIVE)) {
+								formationChecklist = false;
+							}
+						}
+					}
+				}
+			} else {
+				// Back slice
+				for(int X = -1; X <= 1; X++) {
+					for(int Y = 0; Y <= 4; Y++) {
+						
+						final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, zOffset + Z);
+						IGregTechTileEntity currentTE = 
+								thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+						
+						if(!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+								&& !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+							// Is casing or IO port?
+							if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) {
+								// Is casing, but there's no casing requirements
+							} else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == IO_PORT) {
+								final TE_ItemServerIOPort port = 
+										(TE_ItemServerIOPort) thisController.getWorld().getTileEntity(
+												thisController.getXCoord() + offset.x(), 
+												thisController.getYCoord() + offset.y(),
+												thisController.getZCoord() + offset.z());
+								ioPorts.add(port);
+							} else {
+								formationChecklist = false;
+							}
+						}
+					}
+				}
+			}
+		}
+		
+		
+		return formationChecklist;
+	}
+	
+	@Override
+	public String[] getInfoData() {
+		final ArrayList<String> ll = new ArrayList<>();//mfh.getInfoData();
+		
+		ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+		ll.add("Per-Item Capacity: " + mih.getPerTypeCapacity());
+		ll.add("Item-Type Capacity: " + BASE_ITEM_TYPES_PER_SEGMENT * sliceCount);
+		ll.add("Running Cost: "
+				// mEUt does not naturally reflect efficiency status. Do that here.
+				+ ((-super.mEUt) * 10000 / Math.max(1000, super.mEfficiency)) + "EU/t");
+		ll.add("Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus()) 
+				? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET 
+						: EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+		ll.add("---------------------------------------------");
+		
+		final String[] a = new String[ll.size()];
+		return ll.toArray(a);
+	}
+	
+	@Override
+	public void saveNBTData(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+		
+		super.saveNBTData(nbt);
+	}
+	
+	@Override
+	public void loadNBTData(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+		
+		super.loadNBTData(nbt);
+	}
+	
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public int getMaxEfficiency(ItemStack var1) {
+		return 10000;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack var1) {
+		return 0;
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack var1) {
+		return 0;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack var1) {
+		return false;
+	}
+}
diff --git a/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java b/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java
new file mode 100644
index 0000000000..fc743a56d3
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java
@@ -0,0 +1,558 @@
+package common.tileentities;
+
+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 common.Blocks;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+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_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import org.lwjgl.input.Keyboard;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class GTMTE_LapotronicSuperCapacitor extends GT_MetaTileEntity_MultiBlockBase {
+	
+	private final static String glassNameBorosilicate = "BW_GlasBlocks";
+	private static final Block LSC_PART = Blocks.lscLapotronicEnergyUnit;
+	private static final int CASING_META = 0;
+	private static final int CASING_TEXTURE_ID = 62;
+
+	private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
+	private static final BigDecimal PASSIVE_DISCHARGE_FACTOR_PER_TICK =
+			BigDecimal.valueOf(0.01D / 1728000.0D); // The magic number is ticks per 24 hours
+
+	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 (translate with meta - 1)
+	private final int[] capacitors = new int[5];
+	private BigInteger capacity = BigInteger.ZERO;
+	private BigInteger stored = BigInteger.ZERO;
+	private BigInteger passiveDischargeAmount = BigInteger.ZERO;
+	private BigInteger intputLastTick = BigInteger.ZERO;
+	private BigInteger outputLastTick = BigInteger.ZERO;
+	private int repairStatusCache = 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 String[] getDescription() {
+		final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+		b.addInfo("Power storage structure!")
+				.addInfo("Looses energy equal to 1% of the total capacity every 24 hours.")
+				.addInfo("EXCEPTION: Ultimate Capacitors only count as Lapotronic Capacitors (UV) for the")
+				.addInfo("purpose of passive loss calculation. The full capacity is counted towards the actual power capacity.")
+				.addSeparator()
+				.addInfo("Glass shell has to be Tier - 2 of the highest capacitor tier")
+				.addInfo("UV-Tier glass required for TecTech Laser Hatches")
+				.addInfo("Modular height of 4 to 18 blocks.")
+				.addSeparator()
+				.beginStructureBlock(5, 4, 5)
+				.addController("Front Bottom Center")
+				.addDynamoHatch("Instead of any casing")
+				.addEnergyHatch("Instead of any casing")
+				.addOtherStructurePart("Lapotronic Capacitor Base", "5x2x5 base (at least 17x)")
+				.addOtherStructurePart("Lapotronic Capacitor, (Really) Ultimate Capacitor", "Center 3x(1-15)x3 above base (9-135 blocks)")
+				.addOtherStructurePart("Borosilicate Glass", "41-265x, Encase capacitor pillar")
+				.addMaintenanceHatch("Instead of any casing")
+				.signAndFinalize("Kekzdealer");
+		if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+	
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex,
+			boolean aActive, boolean aRedstone) {
+		ITexture[] sTexture = new ITexture[]{new GT_RenderedTexture(BlockIcons.MACHINE_CASING_FUSION_GLASS,
+				Dyes.getModulation(-1, Dyes._NULL.mRGBa))};
+		if (aSide == aFacing && aActive) {
+			sTexture = new ITexture[]{new GT_RenderedTexture(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW,
+					Dyes.getModulation(-1, Dyes._NULL.mRGBa))};
+		}
+		return sTexture;
+	}
+	
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");
+	}
+	
+	@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;
+	}
+
+	public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+		final Vector3i offset = new Vector3i();
+
+		// either direction on z-axis
+		if (forgeDirection.x() == 0 && forgeDirection.z() == -1) {
+			offset.x = x;
+			offset.y = y;
+			offset.z = z;
+		}
+		if (forgeDirection.x() == 0 && forgeDirection.z() == 1) {
+			offset.x = -x;
+			offset.y = y;
+			offset.z = -z;
+		}
+		// either direction on x-axis
+		if (forgeDirection.x() == -1 && forgeDirection.z() == 0) {
+			offset.x = z;
+			offset.y = y;
+			offset.z = -x;
+		}
+		if (forgeDirection.x() == 1 && forgeDirection.z() == 0) {
+			offset.x = -z;
+			offset.y = y;
+			offset.z = x;
+		}
+		// either direction on y-axis
+		if (forgeDirection.y() == -1) {
+			offset.x = x;
+			offset.y = z;
+			offset.z = y;
+		}
+
+		return offset;
+	}
+	
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+		// Figure out the vector for the direction the back face of the controller is facing
+		final Vector3ic forgeDirection = new Vector3i(
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+				);
+		boolean formationChecklist = true;
+		int minCasingAmount = 16;
+		int firstGlassMeta = -1;
+		// Reset capacitor counts
+		Arrays.fill(capacitors, 0);
+		// Clear TT hatches
+		mEnergyHatchesTT.clear();
+		mDynamoHatchesTT.clear();
+		mEnergyTunnelsTT.clear();
+		mDynamoTunnelsTT.clear();
+		// Temp var for loss calculation
+		BigInteger tempCapacity = BigInteger.ZERO;
+
+		// Capacitor base
+		for(int Y = 0; Y <= 1; Y++) {
+			for(int X = -2; X <= 2; X++) {
+				for(int Z = 0; Z >= -4; Z--) {
+					if(X == 0 && Y == 0 && Z == 0) {
+						continue; // Skip controller
+					}
+					
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+					final IGregTechTileEntity currentTE =
+							thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+					
+					// Tries to add TE as either of those kinds of hatches.
+					// The number is the texture index number for the texture that needs to be painted over the hatch texture
+					if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID)
+						&& !this.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)
+						&& !this.addDynamoToMachineList(currentTE, CASING_TEXTURE_ID)) {
+						
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == LSC_PART) 
+								&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+		// Capacitor units
+		int firstGlassHeight = 3; // Initialize at basic height (-1 because it's an offset)
+		for(int X = -1; X <= 1; X++) {
+			for(int Z = -1; Z >= -3; Z--) {
+				// Y has to be the innermost loop to properly deal with the dynamic height.
+				// This way each "pillar" of capacitors is checked from bottom to top until it hits glass.
+				for(int Y = 2; Y <= 17; Y++) {
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+
+					final int meta = thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z());
+					if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == LSC_PART && (meta > 0)) {
+						// Add capacity
+						if(meta <= 4){
+							final long c = (long) (100000000L * Math.pow(10, meta - 1));
+							tempCapacity = tempCapacity.add(BigInteger.valueOf(c));
+							capacity = capacity.add(BigInteger.valueOf(c));
+						} else if(meta <= 5){
+							tempCapacity = tempCapacity.add(BigInteger.valueOf((long) (100000000L * Math.pow(10, 3))));
+							capacity = capacity.add(MAX_LONG);
+						}
+						capacitors[meta - 1]++;
+					} else if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameBorosilicate)){
+						firstGlassHeight = Y;
+						break;
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}
+		// Glass shell
+		// Make Y the outermost loop, so each layer is checked completely before moving up
+		for(int Y = 2; Y <= firstGlassHeight; Y++) {
+			for(int X = -2; X <= 2; X++) {
+				for(int Z = 0; Z >= -4; Z--) {
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+					final String blockNameAt = thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName();
+					final int meta = thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z());
+					// Check only outer ring, except when on roof height
+					if((Y < firstGlassHeight)){
+						if(X == -2 || X == 2 || Z == 0 || Z == 4){
+							if(glassNameBorosilicate.equals(blockNameAt)) {
+								if(firstGlassMeta == -1) {
+									firstGlassMeta = meta;
+								} else if(meta != firstGlassMeta) {
+									formationChecklist = false;
+								}
+							} else {
+								formationChecklist = false;
+							}
+						}
+					} else {
+						if (glassNameBorosilicate.equals(blockNameAt)) {
+							if(meta != firstGlassMeta) {
+								formationChecklist = false;
+							}
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+
+		if(minCasingAmount > 0){
+			formationChecklist = false;
+		}
+
+		// 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
+		final int colourCorrectedMeta = firstGlassMeta > 5 ? 0 : firstGlassMeta;
+		for(int highestCapacitor = capacitors.length - 1; highestCapacitor >= 0; highestCapacitor--){
+			if(capacitors[highestCapacitor] > 0){
+				if(colourCorrectedMeta < highestCapacitor){
+					formationChecklist = false;
+				}
+				break;
+			}
+		}
+
+		// Glass has to be at least UV-tier to allow TT Laser hatches
+		if(colourCorrectedMeta < 5) {
+			if(mEnergyTunnelsTT.size() > 0 || mDynamoTunnelsTT.size() > 0) {
+				formationChecklist = false;
+			}
+			mEnergyTunnelsTT.clear();
+			mDynamoTunnelsTT.clear();
+
+		}
+
+		// Calculate total capacity
+		capacity = BigInteger.ZERO;
+		for(int i = 0; i < capacitors.length; i++){
+			if(i <= 3){
+				final long c = (long) (100000000L * Math.pow(10, i));
+				capacity = capacity.add(
+						BigInteger.valueOf(c).multiply(BigInteger.valueOf(capacitors[i])));
+			} else {
+				capacity = capacity.add(
+						MAX_LONG.multiply(BigInteger.valueOf(capacitors[i])));
+			}
+		}
+		// Calculate how much energy to void each tick
+		passiveDischargeAmount = new BigDecimal(tempCapacity).multiply(PASSIVE_DISCHARGE_FACTOR_PER_TICK).toBigInteger();
+		passiveDischargeAmount = recalculateLossWithMaintenance(super.getRepairStatus());
+		return formationChecklist;
+	}
+
+	@Override
+	public boolean addEnergyInputToMachineList(IGregTechTileEntity te, int aBaseCasingIndex) {
+		if (te == null) {
+			return false;
+		} else {
+			final IMetaTileEntity mte = te.getMetaTileEntity();
+			if (mte instanceof GT_MetaTileEntity_Hatch_Energy) {
+				// Add GT hatches
+				((GT_MetaTileEntity_Hatch) mte).updateTexture(aBaseCasingIndex);
+				return super.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) mte);
+			} else if(mte instanceof  GT_MetaTileEntity_Hatch_EnergyTunnel) {
+				// Add TT Laser hatches
+				return mEnergyTunnelsTT.add((GT_MetaTileEntity_Hatch_EnergyTunnel) mte);
+			} else if(mte instanceof GT_MetaTileEntity_Hatch_EnergyMulti) {
+				// Add TT hatches
+				((GT_MetaTileEntity_Hatch) mte).updateTexture(aBaseCasingIndex);
+				return mEnergyHatchesTT.add((GT_MetaTileEntity_Hatch_EnergyMulti) mte);
+			} else {
+				return false;
+			}
+		}
+	}
+
+	@Override
+	public boolean addDynamoToMachineList(IGregTechTileEntity te, int aBaseCasingIndex) {
+		if (te == null) {
+			return false;
+		} else {
+			final IMetaTileEntity mte = te.getMetaTileEntity();
+			if (mte instanceof GT_MetaTileEntity_Hatch_Dynamo) {
+				// Add GT hatches
+				((GT_MetaTileEntity_Hatch) mte).updateTexture(aBaseCasingIndex);
+				return super.mDynamoHatches.add((GT_MetaTileEntity_Hatch_Dynamo) mte);
+			} else if(mte instanceof  GT_MetaTileEntity_Hatch_DynamoTunnel) {
+				// Add TT Laser hatches
+				return mDynamoTunnelsTT.add((GT_MetaTileEntity_Hatch_DynamoTunnel) mte);
+			} else if(mte instanceof GT_MetaTileEntity_Hatch_DynamoMulti) {
+				// Add TT hatches
+				((GT_MetaTileEntity_Hatch) mte).updateTexture(aBaseCasingIndex);
+				return mDynamoHatchesTT.add((GT_MetaTileEntity_Hatch_DynamoMulti) mte);
+			} else {
+				return false;
+			}
+		}
+	}
+
+	@Override
+	public boolean onRunningTick(ItemStack stack){
+		// Reset I/O cache
+		intputLastTick = BigInteger.ZERO;
+		outputLastTick = BigInteger.ZERO;
+
+		// Draw energy from GT hatches
+		for(GT_MetaTileEntity_Hatch_Energy eHatch : super.mEnergyHatches) {
+			if(eHatch == null || eHatch.getBaseMetaTileEntity().isInvalidTileEntity()) {
+				continue;
+			}
+			final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn());
+			if(eHatch.getEUVar() >= power) {
+				eHatch.setEUVar(eHatch.getEUVar() - power);
+				stored = stored.add(BigInteger.valueOf(power));
+				intputLastTick = intputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Output energy to GT hatches
+		for(GT_MetaTileEntity_Hatch_Dynamo eDynamo : super.mDynamoHatches){
+			if(eDynamo == null || eDynamo.getBaseMetaTileEntity().isInvalidTileEntity()){
+				continue;
+			}
+			final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut());
+			if(power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) {
+				eDynamo.setEUVar(eDynamo.getEUVar() + power);
+				stored = stored.subtract(BigInteger.valueOf(power));
+				outputLastTick = outputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Draw energy from TT hatches
+		for(GT_MetaTileEntity_Hatch_EnergyMulti eHatch : mEnergyHatchesTT) {
+			if(eHatch == null || eHatch.getBaseMetaTileEntity().isInvalidTileEntity()) {
+				continue;
+			}
+			final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn());
+			if(eHatch.getEUVar() >= power) {
+				eHatch.setEUVar(eHatch.getEUVar() - power);
+				stored = stored.add(BigInteger.valueOf(power));
+				intputLastTick = intputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Output energy to TT hatches
+		for(GT_MetaTileEntity_Hatch_DynamoMulti eDynamo : mDynamoHatchesTT){
+			if(eDynamo == null || eDynamo.getBaseMetaTileEntity().isInvalidTileEntity()){
+				continue;
+			}
+			final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut());
+			if(power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) {
+				eDynamo.setEUVar(eDynamo.getEUVar() + power);
+				stored = stored.subtract(BigInteger.valueOf(power));
+				outputLastTick = outputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Draw energy from TT Laser hatches
+		for(GT_MetaTileEntity_Hatch_EnergyTunnel eHatch : mEnergyTunnelsTT) {
+			if(eHatch == null || eHatch.getBaseMetaTileEntity().isInvalidTileEntity()) {
+				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);
+				stored = stored.add(BigInteger.valueOf(power));
+				intputLastTick = intputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Output energy to TT Laser hatches
+		for(GT_MetaTileEntity_Hatch_DynamoTunnel eDynamo : mDynamoTunnelsTT){
+			if(eDynamo == null || eDynamo.getBaseMetaTileEntity().isInvalidTileEntity()){
+				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);
+				stored = stored.subtract(BigInteger.valueOf(power));
+				outputLastTick = outputLastTick.add(BigInteger.valueOf(power));
+			}
+		}
+		// Loose some energy
+		// Recalculate if the repair status changed
+		if(super.getRepairStatus() != repairStatusCache) {
+			passiveDischargeAmount = recalculateLossWithMaintenance(super.getRepairStatus());
+		}
+		stored = stored.subtract(passiveDischargeAmount);
+		stored = (stored.compareTo(BigInteger.ZERO) <= 0) ? BigInteger.ZERO : stored;
+
+		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 BigInteger recalculateLossWithMaintenance(int repairStatus) {
+		repairStatusCache = repairStatus;
+		return new BigDecimal(passiveDischargeAmount)
+				.multiply(BigDecimal.valueOf(1.0D + 0.2D * repairStatus)).toBigInteger();
+	}
+
+	/**
+	 * 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 Math.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 Math.min(hatchWatts, remStoredLimited.longValue());
+	}
+
+	@Override
+	public String[] getInfoData() {
+		final ArrayList<String> ll = new ArrayList<>();
+		ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+		ll.add("Used Capacity: " + NumberFormat.getNumberInstance().format(stored) + "EU");
+		ll.add("Total Capacity: " + NumberFormat.getNumberInstance().format(capacity) + "EU");
+		ll.add("Passive Loss: " + NumberFormat.getNumberInstance().format(passiveDischargeAmount) + "EU/t");
+		ll.add("EU IN: " + NumberFormat.getNumberInstance().format(intputLastTick) + "EU/t");
+		ll.add("EU OUT: " + NumberFormat.getNumberInstance().format(outputLastTick) + "EU/t");
+		ll.add("Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus())
+				? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET
+				: EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+		ll.add("---------------------------------------------");
+
+		final String[] a = new String[ll.size()];
+		return ll.toArray(a);
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+		nbt.setByteArray("capacity", capacity.toByteArray());
+		nbt.setByteArray("stored", stored.toByteArray());
+		nbt.setByteArray("passiveDischargeAmount", passiveDischargeAmount.toByteArray());
+
+		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"));
+		passiveDischargeAmount = new BigInteger(nbt.getByteArray("passiveDischargeAmount"));
+
+		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; }
+	
+}
diff --git a/src/main/java/common/tileentities/GTMTE_ModularNuclearReactor.java b/src/main/java/common/tileentities/GTMTE_ModularNuclearReactor.java
new file mode 100644
index 0000000000..5e0b86ed69
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_ModularNuclearReactor.java
@@ -0,0 +1,244 @@
+package common.tileentities;
+
+import org.joml.Vector3i;
+import org.lwjgl.input.Keyboard;
+
+import client.gui.GUIContainer_ModularNuclearReactor;
+import common.Blocks;
+import gregtech.api.GregTech_API;
+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_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import util.MultiBlockTooltipBuilder;
+
+public class GTMTE_ModularNuclearReactor extends GT_MetaTileEntity_MultiBlockBase {
+	
+	private final Block CASING = GregTech_API.sBlockCasings3;
+	private final int CASING_META = 12;
+	private final int CASING_TEXTURE_ID = 44;
+	
+	private final Block CHAMBER_OFF = Blocks.reactorChamberOFF;
+	private final Block CHAMBER_ON = Blocks.reactorChamberON;
+	private final Block CONTROL_ROD = Blocks.reactorControlRod;
+	
+	private boolean euMode = true;
+	
+	public GTMTE_ModularNuclearReactor(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+		
+	}
+	
+	public GTMTE_ModularNuclearReactor(String aName) {
+		super(aName);
+		
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+		return new GTMTE_ModularNuclearReactor(super.mName);
+	}
+
+	@Override
+	public String[] getDescription() {
+		final MultiBlockTooltipBuilder b =  new MultiBlockTooltipBuilder();
+		b.addInfo("Can be built, BUT DOES NOT WORK")
+				.addInfo("Converts fissile material and outputs power or heat")
+				.addSeparator()
+				.addInfo("EU-MODE:")
+				.addInfo("   Directly outputs electricity depending on inserted fuel rods")
+				.addSeparator()
+				.addInfo("COOLANT-MODE:")
+				.addInfo("   Requires coolant to be pumped into the reactor.")
+				.addInfo("   Coolant is heated and should be drained and converted to electricity by other means.")
+				.addSeparator()
+				.addInfo("NOTES:")
+				.addInfo("  Does NOT use Industrialcraft 2 reactor components!")
+				.addInfo("  Consult controller GUI on how to arrange the outer casings.")
+				.addSeparator()
+				.beginStructureBlock(7, 6, 7)
+				.addController("Front bottom Center")
+				.addCasingInfo("Radiation Proof Machine Casing", 100)
+				.addOtherStructurePart("Control Rods", "Four pillars, four blocks high each. Diagonal to the inner edges of the shell")
+				.addOtherStructurePart("Nuclear Reactor Chamber", "17 of them to fill out the rest of the floor inside the shell")
+				.addDynamoHatch("ONLY in EU-mode, at least one")
+				.addOtherStructurePart("Input Bus, Output Bus", "Optional but required for automation")
+				.addOtherStructurePart("Input Hatch, Output Hatch", "ONLY in Coolant-Mode, at least one each")
+				.signAndFinalize("Kekzdealer");
+		if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+
+	@Override
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing,
+			final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return aSide == aFacing
+				? new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID],
+						new GT_RenderedTexture(aActive ? 
+								Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE 
+								: Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER)}
+				: new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID]};
+	}
+	
+	// TODO: Opening UI crashes server. Controller isn't craftable right now.
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		/*return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");*/
+		return new GUIContainer_ModularNuclearReactor(aBaseMetaTileEntity, aPlayerInventory.player);
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack stack) {
+		return true;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack stack) {
+		return false;
+	}
+	
+	@Override
+	public void onPostTick(IGregTechTileEntity thisController, long aTick) {
+		super.onPostTick(thisController, aTick);
+		
+		if(super.getBaseMetaTileEntity().isActive()) {
+			// Switch to ON blocks
+		} else {
+			// Switch to OFF blocks
+		}
+	}
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {		
+		// Figure out the vector for the direction the back face of the controller is facing
+		final int dirX = ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX;
+		final int dirZ = ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ;
+		int minCasingAmount = 100;
+		boolean checklist = true; // if this is still true at the end, machine is good to go :)
+		
+		// Determine the ground level center of the structure
+		final Vector3i center = new Vector3i(
+				thisController.getXCoord(),
+				thisController.getYCoord(),
+				thisController.getZCoord())
+				.add(dirX * 3, 0, dirZ * 3);
+		// Scan for outer tube
+		//	- Scan sides
+		for(int x = -3; x <= 3; x++) {
+			for(int z = -3; z <= 3; z++) {
+				// Only scan the three wide even sides, skip rest
+				if((Math.abs(x) <= 1 && Math.abs(z) == 3) || (Math.abs(z) <= 1 && Math.abs(x) == 3)) {
+					for(int h = 0; h < 6; h++) {
+						final Vector3i pos = new Vector3i(center.x() + x, center.y() + h, center.z() + z);
+						if(h == 0 && pos.x() == thisController.getXCoord() && pos.y() == thisController.getYCoord() && pos.z() == thisController.getZCoord()) {
+							// Ignore controller
+							continue;
+						} else if (thisController.getBlock(pos.x(), pos.y(), pos.z()) == CASING
+								&& thisController.getMetaID(pos.x(), pos.y(), pos.z()) == CASING_META) {
+							minCasingAmount--;
+						} else {
+							checklist = false;
+						}
+					}
+				}
+			}
+		}
+		// 	- Scan corners of tube
+		for(int x = -2; x <= 2; x++) {
+			for(int z = -2; z <= 2; z++) {
+				// Only scan the four corners, skip rest
+				if(Math.abs(x) + Math.abs(z) == 4) {
+					for(int h = 0; h < 6; h++) {
+						final Vector3i pos = new Vector3i(center.x() + x, center.y() + h, center.z() + z);
+						if(h == 0 && pos.x() == thisController.getXCoord() && pos.y() == thisController.getYCoord() && pos.z() == thisController.getZCoord()) {
+							// Ignore controller
+							continue;
+						} else if (thisController.getBlock(pos.x(), pos.y(), pos.z()) == CASING
+								&& thisController.getMetaID(pos.x(), pos.y(), pos.z()) == CASING_META) {
+							minCasingAmount--;
+						} else {
+							checklist = false;
+						}
+					}
+				}
+			}
+		}
+		// Scan ground layer
+		for(int x = -2; x <= 2; x++) {
+			for(int z = -2; z <= 2; z++) {
+				if(!(thisController.getBlock(center.x() + x, center.y(), center.z() + z) == CASING 
+						&& thisController.getMetaID(center.x() + x, center.y(), center.z() + z) == CASING_META)) {
+					checklist = false;
+				} else {
+					minCasingAmount--;
+				}
+			}
+		}
+		// Scan reactor chambers
+		for(int x = -2; x <= 2; x++) {
+			for(int z = -2; z <= 2; z++) {
+				// Skip if diagonal, don't skip center
+				if(Math.abs(x) == Math.abs(z) && !(x == 0 && z == 0)) {
+					continue;
+				}
+				if(!(thisController.getBlock(center.x() + x, center.y() + 1, center.z() + z) == CHAMBER_OFF
+						|| thisController.getBlock(center.x() + x, center.y() + 1, center.z() + z) == CHAMBER_ON)) {
+					checklist = false;
+				}
+			}
+		}
+		// Scan control rods
+		for(int h = 1; h < 5; h++) {
+			for(int x = -1; x <= 1; x++) {
+				for(int z = -1; z <= 1; z++) {
+					// Only check diagonal
+					if(x == 0 || z == 0) {
+						continue;
+					}
+					if(!(thisController.getBlock(center.x() + x, center.y() + h, center.z() + z) == CONTROL_ROD)) {
+						checklist = false;
+					}
+				}
+			}			
+		}
+		
+		
+		
+		
+		if(minCasingAmount > 0) {
+			checklist = false;
+		}
+		
+		return checklist;
+	}
+
+	@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;
+	}
+
+}
diff --git a/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java b/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java
new file mode 100644
index 0000000000..76536f0e50
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java
@@ -0,0 +1,335 @@
+package common.tileentities;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.lwjgl.input.Keyboard;
+
+import common.Blocks;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+public class GTMTE_SOFuelCellMK1  extends GT_MetaTileEntity_MultiBlockBase {
+	
+	private final Block CASING = GregTech_API.sBlockCasings4;
+	private final int CASING_META = 1;
+	private final int CASING_TEXTURE_ID = 49;
+	
+	private final int OXYGEN_PER_SEC = 400;
+	private final int EU_PER_TICK = 1024;
+	private final int STEAM_PER_SEC = 18000;
+	
+	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);
+	}
+
+	@Override
+	public String[] getDescription() {
+		final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+		b.addInfo("Oxidizes gas fuels to generate electricity without polluting the environment")
+				.addInfo("Consumes 29,480EU worth of fuel with up to 97% 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)
+				.addController("Front Center")
+				.addDynamoHatch("Back Center")
+				.addOtherStructurePart("YSZ Ceramic Electrolyte Unit", "3x, Center 1x1x3")
+				.addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides")
+				.addCasingInfo("Clean Stainless Steel Casing", 12)
+				.addMaintenanceHatch("Instead of any casing")
+				.addIOHatches("Instead of any casing")
+				.signAndFinalize("Kekzdealer");
+		if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+	
+	@Override
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing,
+			final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return aSide == aFacing
+				? new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID],
+						new GT_RenderedTexture(aActive ? 
+								Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE 
+								: Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER)}
+				: new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID]};
+	}
+	
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");
+	}
+	
+	@Override
+	public boolean isCorrectMachinePart(ItemStack stack) {
+		return true;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack stack) {
+		final ArrayList<FluidStack> storedFluids = super.getStoredFluids();
+		Collection<GT_Recipe> recipeList = GT_Recipe_Map.sTurbineFuels.mRecipeList;
+		
+		if((storedFluids.size() > 0 && recipeList != null)) {
+						
+			final Iterator<FluidStack> fluidsIterator = storedFluids.iterator();
+			while(fluidsIterator.hasNext()) {
+				
+				final FluidStack hatchFluid = fluidsIterator.next();
+				final Iterator<GT_Recipe> recipeIterator = recipeList.iterator();
+				while(recipeIterator.hasNext()) {
+					
+					final GT_Recipe aFuel = recipeIterator.next();
+					FluidStack liquid;
+					if((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null
+							&& hatchFluid.isFluidEqual(liquid)) {
+						
+						liquid.amount = Math.round((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 false;
+							}
+							
+							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 true;
+						}
+					}
+				}
+			}			
+		}
+		
+		super.mEUt = 0;
+		super.mEfficiency = 0;
+		return false;
+	}
+	
+	public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+		final Vector3i offset = new Vector3i();
+		
+		// either direction on z-axis
+		if(forgeDirection.x() == 0 && forgeDirection.z() == -1) {
+			offset.x = x;
+			offset.y = y;
+			offset.z = z;
+		}
+		if(forgeDirection.x() == 0 && forgeDirection.z() == 1) {
+			offset.x = -x;
+			offset.y = y;
+			offset.z = -z;
+		}
+		// either direction on x-axis
+		if(forgeDirection.x() == -1 && forgeDirection.z() == 0) {
+			offset.x = z;
+			offset.y = y;
+			offset.z = -x;
+		}
+		if(forgeDirection.x() == 1 && forgeDirection.z() == 0) {
+			offset.x = -z;
+			offset.y = y;
+			offset.z = x;
+		}
+		// either direction on y-axis
+		if(forgeDirection.y() == -1) {
+			offset.x = x;
+			offset.y = z;
+			offset.z = y;
+		}
+		
+		return offset;
+	}
+	
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {		
+		// Figure out the vector for the direction the back face of the controller is facing
+		final Vector3ic forgeDirection = new Vector3i(
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+				);
+		int minCasingAmount = 12; 
+		boolean formationChecklist = true; // if this is still true at the end, machine is good to go :)
+		
+		// Front slice			
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				if(X == 0 && Y == 0) {
+					continue; // is controller
+				}
+				
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0);
+				IGregTechTileEntity currentTE = 
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+				
+				// Tries to add TE as either of those kinds of hatches.
+				// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+				if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+					&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+					
+					// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+					if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+							&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+						// Seems to be valid casing. Decrement counter.
+						minCasingAmount--;
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}
+		
+		// Middle three slices
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				for(int Z = -1; Z >= -3; Z--) {
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+					if(X == 0 && Y == 0) {
+						if(!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(Blocks.yszUnit.getUnlocalizedName())) {
+							formationChecklist = false;
+						}
+						continue;
+					}
+					if(Y == 0 && (X == -1 || X == 1)) {
+						if(!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals("blockAlloyGlass")) {
+							formationChecklist = false;
+						}
+						continue;
+					}
+					// Get next TE
+					IGregTechTileEntity currentTE = 
+							thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());// x, y ,z
+					
+					// Tries to add TE as either of those kinds of hatches.
+					// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+					if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+						&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+						&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+						
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+								&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+		
+		// Back slice
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, -4);
+				IGregTechTileEntity currentTE = 
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());// x, y ,z
+				
+				// Tries to add TE as either of those kinds of hatches.
+				// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+				if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+					&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addDynamoToMachineList(currentTE, CASING_TEXTURE_ID)) {
+					
+					// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+					if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+							&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+						// Seems to be valid casing. Decrement counter.
+						minCasingAmount--;
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}		
+		
+		if(minCasingAmount > 0) {
+			formationChecklist = false;
+		}
+		
+		if(this.mDynamoHatches.size() != 1) {
+			System.out.println("Exactly one dynamo hatch is required!");
+			formationChecklist = false;
+		}
+		if(this.mInputHatches.size() < 2) {
+			System.out.println("At least two input hatches are required!");
+			formationChecklist = false;
+		}
+		
+		if(this.mMaintenanceHatches.size() < 1) {
+			System.out.println("You need a maintenance hatch to do maintenance.");
+		}
+		
+		return formationChecklist;
+	}
+	
+	@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;
+	}
+	
+}
diff --git a/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java b/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java
new file mode 100644
index 0000000000..fb3fb7e9c7
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java
@@ -0,0 +1,335 @@
+package common.tileentities;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.lwjgl.input.Keyboard;
+
+import common.Blocks;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+public class GTMTE_SOFuelCellMK2  extends GT_MetaTileEntity_MultiBlockBase {
+	
+	final Block CASING = GregTech_API.sBlockCasings4;
+	final int CASING_META = 0;
+	final int CASING_TEXTURE_ID = 48;
+	
+	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);
+	}
+
+	@Override
+	public String[] getDescription() {
+		final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+		b.addInfo("Oxidizes gas fuels to generate electricity without polluting the environment")
+				.addInfo("Consumes 442,200EU worth of fuel with up to 97% 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)
+				.addController("Front Center")
+				.addDynamoHatch("Back Center")
+				.addOtherStructurePart("GDC Ceramic Electrolyte Unit", "3x, Center 1x1x3")
+				.addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides")
+				.addCasingInfo("Robust Tungstensteel Machine Casing", 12)
+				.addMaintenanceHatch("Instead of any casing")
+				.addIOHatches("Instead of any casing")
+				.signAndFinalize("Kekzdealer");
+		if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+			return b.getInformation();
+		} else {
+			return b.getStructureInformation();
+		}
+	}
+	
+	@Override
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing,
+			final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return aSide == aFacing
+				? new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID],
+						new GT_RenderedTexture(aActive ? 
+								Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE 
+								: Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER)}
+				: new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_TEXTURE_ID]};
+	}
+	
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+				"MultiblockDisplay.png");
+	}
+	
+	@Override
+	public boolean isCorrectMachinePart(ItemStack stack) {
+		return true;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack stack) {
+		final ArrayList<FluidStack> storedFluids = super.getStoredFluids();
+		Collection<GT_Recipe> recipeList = GT_Recipe_Map.sTurbineFuels.mRecipeList;
+		
+		if((storedFluids.size() > 0 && recipeList != null)) {
+						
+			final Iterator<FluidStack> fluidsIterator = storedFluids.iterator();
+			while(fluidsIterator.hasNext()) {
+				
+				final FluidStack hatchFluid = fluidsIterator.next();
+				final Iterator<GT_Recipe> recipeIterator = recipeList.iterator();
+				while(recipeIterator.hasNext()) {
+					
+					final GT_Recipe aFuel = recipeIterator.next();
+					FluidStack liquid;
+					if((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null
+							&& hatchFluid.isFluidEqual(liquid)) {
+						
+						liquid.amount = Math.round((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 false;
+							}
+							
+							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 true;
+						}
+					}
+				}
+			}			
+		}
+		
+		super.mEUt = 0;
+		super.mEfficiency = 0;
+		return false;
+	}
+	
+	public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+		final Vector3i offset = new Vector3i();
+		
+		// either direction on z-axis
+		if(forgeDirection.x() == 0 && forgeDirection.z() == -1) {
+			offset.x = x;
+			offset.y = y;
+			offset.z = z;
+		}
+		if(forgeDirection.x() == 0 && forgeDirection.z() == 1) {
+			offset.x = -x;
+			offset.y = y;
+			offset.z = -z;
+		}
+		// either direction on x-axis
+		if(forgeDirection.x() == -1 && forgeDirection.z() == 0) {
+			offset.x = z;
+			offset.y = y;
+			offset.z = -x;
+		}
+		if(forgeDirection.x() == 1 && forgeDirection.z() == 0) {
+			offset.x = -z;
+			offset.y = y;
+			offset.z = x;
+		}
+		// either direction on y-axis
+		if(forgeDirection.y() == -1) {
+			offset.x = x;
+			offset.y = z;
+			offset.z = y;
+		}
+		
+		return offset;
+	}
+	
+	@Override
+	public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {		
+		// Figure out the vector for the direction the back face of the controller is facing
+		final Vector3ic forgeDirection = new Vector3i(
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+				ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+				);
+		int minCasingAmount = 12; 
+		boolean formationChecklist = true; // if this is still true at the end, machine is good to go :)
+		
+		// Front slice			
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				if(X == 0 && Y == 0) {
+					continue; // is controller
+				}
+				
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0);
+				IGregTechTileEntity currentTE = 
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+				
+				// Tries to add TE as either of those kinds of hatches.
+				// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+				if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+					&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+					
+					// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+					if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+							&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+						// Seems to be valid casing. Decrement counter.
+						minCasingAmount--;
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}
+		
+		// Middle three slices
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				for(int Z = -1; Z >= -3; Z--) {
+					final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z);
+					if(X == 0 && Y == 0) {
+						if(!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals(Blocks.gdcUnit.getUnlocalizedName())) {
+							formationChecklist = false;
+						}
+						continue;
+					}
+					if(Y == 0 && (X == -1 || X == 1)) {
+						if(!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName()
+								.equals("blockAlloyGlass")) {
+							formationChecklist = false;
+						}
+						continue;
+					}
+					// Get next TE
+					IGregTechTileEntity currentTE = 
+							thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());// x, y ,z
+					
+					// Tries to add TE as either of those kinds of hatches.
+					// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+					if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+						&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+						&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) {
+						
+						// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+						if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+								&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+							// Seems to be valid casing. Decrement counter.
+							minCasingAmount--;
+						} else {
+							formationChecklist = false;
+						}
+					}
+				}
+			}
+		}
+		
+		// Back slice
+		for(int X = -1; X <= 1; X++) {
+			for(int Y = -1; Y <= 1; Y++) {
+				// Get next TE
+				final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, -4);
+				IGregTechTileEntity currentTE = 
+						thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());// x, y ,z
+				
+				// Tries to add TE as either of those kinds of hatches.
+				// The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++)
+				if (   !super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) 
+					&& !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)
+					&& !super.addDynamoToMachineList(currentTE, CASING_TEXTURE_ID)) {
+					
+					// If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+					if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) 
+							&& (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == CASING_META)) {
+						// Seems to be valid casing. Decrement counter.
+						minCasingAmount--;
+					} else {
+						formationChecklist = false;
+					}
+				}
+			}
+		}		
+		
+		if(minCasingAmount > 0) {
+			formationChecklist = false;
+		}
+		
+		if(this.mDynamoHatches.size() != 1) {
+			System.out.println("Exactly one dynamo hatch is required!");
+			formationChecklist = false;
+		}
+		if(this.mInputHatches.size() < 2) {
+			System.out.println("At least two input hatches are required!");
+			formationChecklist = false;
+		}
+		
+		if(this.mMaintenanceHatches.size() < 1) {
+			System.out.println("You need a maintenance hatch to do maintenance.");
+		}
+		
+		return formationChecklist;
+	}
+	
+	@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;
+	}
+	
+}
diff --git a/src/main/java/common/tileentities/GTMTE_SpaceElevator.java b/src/main/java/common/tileentities/GTMTE_SpaceElevator.java
new file mode 100644
index 0000000000..8f7827f4be
--- /dev/null
+++ b/src/main/java/common/tileentities/GTMTE_SpaceElevator.java
@@ -0,0 +1,265 @@
+package common.tileentities;
+
+import common.Blocks;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraftforge.common.util.ForgeDirection;
+import org.lwjgl.input.Keyboard;
+import util.MultiBlockTooltipBuilder;
+import util.Vector3i;
+import util.Vector3ic;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class GTMTE_SpaceElevator extends GT_MetaTileEntity_MultiBlockBase {
+
+    private static final Block BASE_BLOCK = Blocks.spaceElevatorStructure;
+    private static final Block CAP_BLOCK = Blocks.spaceElevatorCapacitor;
+    private static final Block TETHER_BLOCK = Blocks.spaceElevatorTether;
+    private static final int BASE_META = 0;
+    private static final int COIL_HOLDER_META = 1;
+    private final static String glassNameBorosilicate = "BW_GlasBlocks";
+    private static final int HATCH_OVERLAY_ID = 16;
+
+    // Scan positions for capacitor banks
+    // Start with top left bank, clockwise
+    // Start with top middle pillar within bank, clockwise, middle last
+    private static final int[] bankOffsetsX = {-7, 5, 5, -7};
+    private static final int[] bankOffsetsY = {-7, -7, 5, 5};
+    private static final int[] scanOffsetsX = {1, 2, 1, 0, 1};
+    private static final int[] scanOffsetsY = {0, 1, 2, 1, 1};
+
+    private final HashSet<TE_SpaceElevatorCapacitor> capacitors = new HashSet<>();
+    private long lastLaunchEUCost = 0;
+
+    public GTMTE_SpaceElevator(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GTMTE_SpaceElevator(String aName) { super(aName); }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) {
+        return new GTMTE_SpaceElevator((super.mName));
+    }
+
+    @Override
+    public String[] getDescription() {
+        final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder();
+        b.addInfo("Access for your Space Station!")
+                .addInfo("Check out the wiki on my github if you are having trouble with the structure")
+                .addInfo("Regenerative Breaking will recover up to X% of the energy spent on launch")
+                .addInfo("Energy recovered depends on coil tier: +10% per coil tier, up to 90%")
+                .addSeparator()
+                .beginStructureBlock(15, 11, 15)
+                .addController("Bottom Center")
+                .addEnergyHatch("Instead of any casing in the bottom floor")
+                .addMaintenanceHatch("Instead of any casing in the bottom floor")
+                .addCasingInfo("Solid Steel Machine Casing", 320)
+                .addOtherStructurePart("Any EBF coil", "40x, have to be all the same")
+                .addOtherStructurePart("Space Elevator Tether", "4x")
+                .addOtherStructurePart("Space Elevator Cabin Block", "42x")
+                .addOtherStructurePart("Space Elevator Cabin Guide", "8x")
+                .signAndFinalize("Kekzdealer");
+        if(!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+            return b.getInformation();
+        } else {
+            return b.getStructureInformation();
+        }
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex,
+                                 boolean aActive, boolean aRedstone) {
+        ITexture[] sTexture = new ITexture[]{new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS,
+                Dyes.getModulation(-1, Dyes._NULL.mRGBa))};
+        if (aSide == aFacing && aActive) {
+            sTexture = new ITexture[]{new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW,
+                    Dyes.getModulation(-1, Dyes._NULL.mRGBa))};
+        }
+        return sTexture;
+    }
+
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(),
+                "MultiblockDisplay.png");
+    }
+
+    @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;
+    }
+
+    public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) {
+        final Vector3i offset = new Vector3i(0, 0, 0);
+        // either direction on y-axis
+        if (forgeDirection.y() == -1) {
+            offset.x = x;
+            offset.y = z;
+            offset.z = y;
+        }
+
+        return offset;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) {
+        // Make sure the controller is either facing up or down
+        if(thisController.getFrontFacing() > 1) {
+            return false;
+        }
+
+        // Figure out the vector for the direction the back face of the controller is facing
+        final Vector3ic forgeDirection = new Vector3i(
+                ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX,
+                ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY,
+                ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ
+        );
+        boolean formationChecklist = true;
+        int minCasingAmount = 320;
+        int firstCoilMeta = -1;
+
+        // Base floor
+        for(int X = -7; X <= 7; X++){
+            for(int Y = -7; Y <= 7; Y++){
+                if(X == 0 && Y == 0){
+                    continue; // Skip controller
+                }
+
+                final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0);
+                final IGregTechTileEntity currentTE =
+                        thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());
+
+                // Tries to add TE as either of those kinds of hatches.
+                // The number is the texture index number for the texture that needs to be painted over the hatch texture
+                if (   !super.addMaintenanceToMachineList(currentTE, HATCH_OVERLAY_ID)
+                        && !this.addEnergyInputToMachineList(currentTE, HATCH_OVERLAY_ID)) {
+
+                    // If it's not a hatch, is it the right casing for this machine? Check block and block meta.
+                    if ((thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == BASE_BLOCK)
+                            && (thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == BASE_META)) {
+                        // Seems to be valid casing. Decrement counter.
+                        minCasingAmount--;
+                    } else {
+                        formationChecklist = false;
+                    }
+                }
+            }
+        }
+        System.out.println("");
+        // Capacitor banks
+        for(int bank = 0; bank < 4; bank++) {
+            for(int Z = 1; Z <= 5; Z++) {
+                for(int scan = 0; scan < 5; scan++){
+                    final Vector3ic offset = rotateOffsetVector(forgeDirection,
+                            bankOffsetsX[bank] + scanOffsetsX[scan],
+                            bankOffsetsY[bank] + scanOffsetsY[scan],
+                            Z);
+                    if(Z == 1 || Z == 5) {
+                        // Check for casings
+                        if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == BASE_BLOCK
+                                && thisController.getMetaIDOffset(offset.x(), offset.y(), offset.z()) == BASE_META) {
+                            minCasingAmount--;
+                        } else {
+                            formationChecklist = false;
+                        }
+                    } else {
+                        if(scan == 4){
+                            // Check for capacitors
+                            final TileEntity te = thisController.getTileEntityOffset(offset.x(), offset.y(), offset.z());
+                            if(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CAP_BLOCK
+                                    &&  te instanceof  TE_SpaceElevatorCapacitor) {
+                                capacitors.add((TE_SpaceElevatorCapacitor) te);
+                            } else {
+                                formationChecklist = false;
+                            }
+                        } else {
+                            // Check for Glass
+                            if(!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameBorosilicate)) {
+                                formationChecklist = false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Anchor
+
+        // Coil holders
+
+        // Coils
+
+        if(minCasingAmount > 0) {
+            formationChecklist = false;
+        }
+
+        return formationChecklist;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        final ArrayList<String> ll = new ArrayList<>();
+        ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET);
+
+        ll.add("Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus())
+                ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET
+                : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET));
+        ll.add("---------------------------------------------");
+
+        final String[] a = new String[ll.size()];
+        return ll.toArray(a);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound nbt) {
+        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+        super.saveNBTData(nbt);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound nbt) {
+        nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+        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; }
+}
diff --git a/src/main/java/common/tileentities/TE_IchorJar.java b/src/main/java/common/tileentities/TE_IchorJar.java
new file mode 100644
index 0000000000..1baa06a969
--- /dev/null
+++ b/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/src/main/java/common/tileentities/TE_IchorVoidJar.java b/src/main/java/common/tileentities/TE_IchorVoidJar.java
new file mode 100644
index 0000000000..6644461a88
--- /dev/null
+++ b/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/src/main/java/common/tileentities/TE_ItemProxyCable.java b/src/main/java/common/tileentities/TE_ItemProxyCable.java
new file mode 100644
index 0000000000..f4caab3d36
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_ItemProxyCable.java
@@ -0,0 +1,121 @@
+package common.tileentities;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TE_ItemProxyCable extends TileEntity {
+	
+	private static final float THICKNESS = 0.5F;
+	private byte connections = 0;
+	private byte connectionAllowed = 63;
+	private String idCache = null;
+	
+	public TE_ItemProxyCable() {
+
+	}
+
+	@Override
+	public void updateEntity() {
+		// Check all 6 sides and connect the conduit if it is allowed to
+		for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+			final TileEntity te = super.getWorldObj().getTileEntity(
+					super.xCoord + side.offsetX,
+					super.yCoord + side.offsetY,
+					super.zCoord + side.offsetZ);
+			if(te instanceof TE_ItemProxyCable) {
+				final TE_ItemProxyCable cable = (TE_ItemProxyCable) te;
+				setConnection(side, cable.isConnectionAllowed(side.getOpposite()));
+			} else {
+				setConnection(side, false);
+			}
+		}
+	}
+	
+	public static float getThickness() {
+		return THICKNESS;
+	}
+	
+	/**
+	 * Builds a simple unique identifier for this TileEntity by appending 
+	 * the x, y, and z coordinates in a string.
+	 * 
+	 * @return unique identifier for this TileEntity
+	 */
+	public String getIdentifier() {
+		if(idCache == null) {
+			idCache = "" + super.xCoord + super.yCoord + super.zCoord;
+			return idCache;
+		} else {
+			return idCache;
+		}
+	}
+	
+	/**
+	 * 0 0 0 0 0 0 0 0 = 0     -> no connection </br>
+	 * 0 0 0 0 0 0 0 1 = 1     -> down  </br>
+	 * 0 0 0 0 0 0 1 0 = 2     -> up  </br>
+	 * 0 0 0 0 0 1 0 0 = 4     -> north  </br>
+	 * 0 0 0 0 1 0 0 0 = 8     -> south  </br>
+	 * 0 0 0 1 0 0 0 0 = 16    -> west  </br>
+	 * 0 0 1 0 0 0 0 0 = 32    -> east  </br>
+	 * 
+	 * @param side
+	 * 			The side for which to set the connection status.
+	 * @param connected
+	 * 			Whether this side should be connected or not
+	 * @return
+	 * 			True if the connection was allowed
+	 */
+	public boolean setConnection(ForgeDirection side, boolean connected) {
+		if(isConnectionAllowed(side)){
+			switch(side) {
+			case DOWN: 	connections = (byte) ((connected) ? connections | 1 : connections ^ 1); break;
+			case UP:	connections = (byte) ((connected) ? connections | 2 : connections ^ 2); break;
+			case NORTH:	connections = (byte) ((connected) ? connections | 4 : connections ^ 4); break;
+			case SOUTH:	connections = (byte) ((connected) ? connections | 8 : connections ^ 8); break;
+			case WEST:	connections = (byte) ((connected) ? connections | 16 : connections ^ 16); break;
+			case EAST:	connections = (byte) ((connected) ? connections | 32 : connections ^ 32); break;
+			default: return false;
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	public boolean isConnected(ForgeDirection side) {
+		switch(side) {
+		case DOWN: 	return (connections & 1) == 1;
+		case UP: 	return (connections & 2) == 2;
+		case NORTH: return (connections & 4) == 4;
+		case SOUTH: return (connections & 8) == 8;
+		case WEST: 	return (connections & 16) == 16;
+		case EAST: 	return (connections & 32) == 32;
+		default: return false;
+		}
+	}
+
+	public void setConnectionAllowed(ForgeDirection side, boolean allowed) {
+		switch(side) {
+			case DOWN: 	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 1 : connectionAllowed ^ 1); break;
+			case UP:	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 2 : connectionAllowed ^ 2); break;
+			case NORTH:	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 4 : connectionAllowed ^ 4); break;
+			case SOUTH:	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 8 : connectionAllowed ^ 8); break;
+			case WEST:	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 16 : connectionAllowed ^ 16); break;
+			case EAST:	connectionAllowed = (byte) ((allowed) ? connectionAllowed | 32 : connectionAllowed ^ 32); break;
+			default: break;
+		}
+	}
+
+	public boolean isConnectionAllowed(ForgeDirection side) {
+		switch(side) {
+			case DOWN: 	return (connectionAllowed & 1) == 1;
+			case UP: 	return (connectionAllowed & 2) == 2;
+			case NORTH: return (connectionAllowed & 4) == 4;
+			case SOUTH: return (connectionAllowed & 8) == 8;
+			case WEST: 	return (connectionAllowed & 16) == 16;
+			case EAST: 	return (connectionAllowed & 32) == 32;
+			default: return false;
+		}
+	}
+}
diff --git a/src/main/java/common/tileentities/TE_ItemProxyEndpoint.java b/src/main/java/common/tileentities/TE_ItemProxyEndpoint.java
new file mode 100644
index 0000000000..1eca1ff3df
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_ItemProxyEndpoint.java
@@ -0,0 +1,179 @@
+package common.tileentities;
+
+import java.util.HashSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TE_ItemProxyEndpoint extends TileEntity implements ISidedInventory {
+
+	private byte channel = -1;
+	private IInventory proxyInventory = null;
+	private int tickCounter = 0;
+
+	public TE_ItemProxyEndpoint() {
+		channel = 0;
+	}
+
+	public void setChannel(byte channel) {
+		this.channel = channel;
+	}
+
+	public int getChannel() { return channel; }
+	
+	@Override
+	public void updateEntity() {
+		if(tickCounter == 20) {
+			if(channel != -1) {
+				proxyInventory = searchSource();
+			}
+			tickCounter = 0;				
+		}
+		tickCounter++;
+	}
+	
+	private TE_ItemProxySource searchSource() {
+		
+		final HashSet<TE_ItemProxySource> sources = new HashSet<>();
+		final HashSet<String> visited = new HashSet<>();
+		
+		for(ForgeDirection next : ForgeDirection.VALID_DIRECTIONS) {
+			final TileEntity te = super.getWorldObj().getTileEntity(
+					super.xCoord + next.offsetX, 
+					super.yCoord + next.offsetY, 
+					super.zCoord + next.offsetZ);
+			if(te instanceof TE_ItemProxyCable) {
+				final TE_ItemProxyCable cable = (TE_ItemProxyCable) te;
+				if(cable.isConnected(next.getOpposite())) {
+					searchSourceRecursive(sources, visited, next.getOpposite(), cable);
+				}
+			}
+		}
+		
+		if(sources.isEmpty()) {
+			return null;
+		} else {
+			return sources.iterator().next();
+		}
+		
+	}
+	
+	private void searchSourceRecursive(HashSet<TE_ItemProxySource> sources, HashSet<String> visited, 
+			ForgeDirection from, TE_ItemProxyCable nextTarget) {
+		
+		if(!visited.contains(nextTarget.getIdentifier())) {
+			visited.add(nextTarget.getIdentifier());
+
+			for(ForgeDirection next : ForgeDirection.VALID_DIRECTIONS) {
+				if(next != from) {
+					final TileEntity te = super.getWorldObj().getTileEntity(
+							nextTarget.xCoord + next.offsetX,
+							nextTarget.yCoord + next.offsetY,
+							nextTarget.zCoord + next.offsetZ);
+					if(te instanceof TE_ItemProxyCable) {
+						final TE_ItemProxyCable cable = (TE_ItemProxyCable) te;
+						if(cable.isConnected(next.getOpposite())) {
+							searchSourceRecursive(sources, visited, next.getOpposite(), cable);
+						}
+					} else if (te instanceof TE_ItemProxySource) {
+						sources.add((TE_ItemProxySource) te);
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return 1;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slot) {
+		if(proxyInventory != null && slot == 0) {
+			return proxyInventory.getStackInSlot(channel);
+		} else {
+			return null;
+		}
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int amount) {
+		if(proxyInventory != null && slot == 0) {
+			return proxyInventory.decrStackSize(channel, amount);
+		} else {
+			return null;
+		}
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slot) {
+		return (proxyInventory != null) ? proxyInventory.getStackInSlotOnClosing(channel) : null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack itemStack) {
+		if(proxyInventory != null && slot == 0) {
+			proxyInventory.setInventorySlotContents(channel, itemStack);
+		}
+	}
+
+	@Override
+	public String getInventoryName() {
+		return (proxyInventory != null) ? "Connected: " + proxyInventory.getInventoryName() : "Untethered Proxy";
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return true;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return (proxyInventory != null) ? proxyInventory.getInventoryStackLimit() : 0;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return true;
+	}
+
+	@Override
+	public void openInventory() {
+		
+	}
+
+	@Override
+	public void closeInventory() {
+		
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
+		if(proxyInventory != null && slot == 0) {
+			return proxyInventory.isItemValidForSlot(channel, itemStack);
+		} else {
+			return false;
+		}
+	}
+	
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		return new int[]{0};
+	}
+	
+	@Override
+	public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
+		return isItemValidForSlot(slot, itemStack);
+	}
+	
+	@Override
+	public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
+		return slot == 0;
+	}
+	
+}
diff --git a/src/main/java/common/tileentities/TE_ItemProxySource.java b/src/main/java/common/tileentities/TE_ItemProxySource.java
new file mode 100644
index 0000000000..a960a7b914
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_ItemProxySource.java
@@ -0,0 +1,112 @@
+package common.tileentities;
+
+import java.util.UUID;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+
+public class TE_ItemProxySource extends TileEntity implements IInventory {
+
+	private ItemStack[] slots = new ItemStack[16];
+	private String idCache = null;
+
+	/**
+	 * Builds a simple unique identifier for this TileEntity by appending
+	 * the x, y, and z coordinates in a string.
+	 *
+	 * @return unique identifier for this TileEntity
+	 */
+	public String getIdentifier() {
+		if(idCache == null) {
+			idCache = "" + super.xCoord + super.yCoord + super.zCoord;
+			return idCache;
+		} else {
+			return idCache;
+		}
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return slots.length;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slot) {
+		return slots[slot];
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int amount) {
+		if(slots[slot] != null) {
+			
+			ItemStack copy;
+			
+			if(slots[slot].stackSize == amount) {
+				copy = slots[slot];
+				slots[slot] = null;
+				super.markDirty();
+				return copy;
+			} else {
+				copy = slots[slot].splitStack(amount);
+				if(slots[slot].stackSize == 0) {
+					slots[slot] = null;
+				}
+				return copy;
+			}
+			
+		} else {
+			return null;			
+		}	
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slot) {
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack itemStack) {
+		slots[slot] = itemStack;
+		if(itemStack != null && itemStack.stackSize > getInventoryStackLimit()) {
+			itemStack.stackSize = getInventoryStackLimit();
+		}
+		super.markDirty();
+	}
+
+	@Override
+	public String getInventoryName() {
+		return "Item Proxy Source";
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return true;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return 64;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+		return true;
+	}
+
+	@Override
+	public void openInventory() {
+
+	}
+
+	@Override
+	public void closeInventory() {
+
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
+		return true;
+	}
+}
diff --git a/src/main/java/common/tileentities/TE_ItemServerIOPort.java b/src/main/java/common/tileentities/TE_ItemServerIOPort.java
new file mode 100644
index 0000000000..0e96ff75b9
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_ItemServerIOPort.java
@@ -0,0 +1,145 @@
+package common.tileentities;
+
+import kekztech.MultiItemHandler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+
+public class TE_ItemServerIOPort extends TileEntity implements ISidedInventory {
+	
+	private MultiItemHandler mih;
+	
+	private int tickCounter = 0;
+	
+	public void setMultiItemHandler(MultiItemHandler mih) {
+		this.mih = mih;
+	}
+	
+	@Override
+	public void updateEntity() {
+		if(mih != null) {
+			
+			tickCounter++;
+			if(tickCounter >= 40) {
+				mih.debugPrint();
+				tickCounter = 0;
+			}
+		}
+	}
+	
+	@Override
+	public int getSizeInventory() {
+		return (mih != null) ? mih.getItemTypeCapacity() : 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slot) {
+		return (mih != null) ? mih.getStackInSlot(slot) : null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int amount) {
+		if(mih != null) {
+			if(mih.getStackInSlot(slot) != null) {
+				final ItemStack obtained = mih.getStackInSlot(slot).copy();
+				obtained.stackSize = mih.reduceStackInSlot(slot, amount);
+				super.markDirty();
+				return obtained;
+			} else {
+				return null;			
+			}			
+		} else {
+			return null;			
+		}
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slot) {
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack itemStack) {
+		System.out.println("Set slot: " + slot);
+		if(mih != null) {
+			if(itemStack == null) {
+				return;
+			} else {
+				if(!mih.insertStackInSlot(slot, itemStack)) {
+					final int delta = itemStack.stackSize - mih.getStackInSlot(slot).stackSize;
+					if(delta < 0) {
+						System.out.println("Set slot reduce: " + itemStack.getDisplayName());
+						mih.reduceStackInSlot(slot, delta);
+					} else {
+						System.out.println("Set slot increase: " + itemStack.getDisplayName());
+						mih.increaseStackInSlot(slot, delta);
+					}
+					
+				} else {
+					System.out.println("Allocated new slot for: " + itemStack.getDisplayName());
+				}
+				super.markDirty();
+			}
+		}
+	}
+
+	@Override
+	public String getInventoryName() {
+		return "Item Server IO Port";
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return true;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return (mih != null) ? mih.getPerTypeCapacity() : 0;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer player) {
+		return true;
+	}
+
+	@Override
+	public void openInventory() {
+		
+	}
+
+	@Override
+	public void closeInventory() {
+		
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
+		return (mih != null) ? (mih.getStackInSlot(slot).isItemEqual(itemStack) || mih.getStackInSlot(slot) == null) : false;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		if(mih != null) {
+			final int[] as = new int[mih.getItemTypeCapacity()];
+			for(int i = 0; i < mih.getItemTypeCapacity(); i++) {
+				as[i] = i;
+			}
+			return as;
+		} else {
+			return new int[1];
+		}
+	}
+
+	@Override
+	public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
+		return isItemValidForSlot(slot, itemStack);
+	}
+
+	@Override
+	public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
+		return (mih != null) ? true : false;
+	}
+
+}
diff --git a/src/main/java/common/tileentities/TE_SpaceElevatorCapacitor.java b/src/main/java/common/tileentities/TE_SpaceElevatorCapacitor.java
new file mode 100644
index 0000000000..a8de775f98
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_SpaceElevatorCapacitor.java
@@ -0,0 +1,54 @@
+package common.tileentities;
+
+import net.minecraft.tileentity.TileEntity;
+
+public class TE_SpaceElevatorCapacitor extends TileEntity {
+
+    private float chargeLevel = 0.0F;
+    private boolean isDamaged = true;
+
+    /**
+     * Called by {@link GTMTE_SpaceElevator} while charging
+     * @param charge
+     *              Current elevator charge
+     * @param maxCharge
+     *              Charge level it is trying to reach
+     */
+    public void updateChargeLevel(int charge, int maxCharge) {
+        chargeLevel = ((float) charge) / ((float) maxCharge);
+    }
+
+    /**
+     * Called by {@link client.renderer.TESR_SECapacitor} to calculate the block's colour saturation
+     * @return
+     *          Charge level from 0.0F to 1.0F
+     */
+    public float getChargeLevel() {
+        return chargeLevel;
+    }
+
+    /**
+     * Called by {@link GTMTE_SpaceElevator} in case of power loss
+     */
+    public void resetChargeLevel() {
+        chargeLevel = 0.0F;
+    }
+
+    /**
+     * Called by {@link GTMTE_SpaceElevator} in case of maintenance issues
+     * @param isDamaged
+     *            has maintenance issue
+     */
+    public void setIsDamaged(boolean isDamaged) {
+        this.isDamaged = isDamaged;
+    }
+
+    /**
+     * Called by {@link client.renderer.TESR_SECapacitor} to check whether the block should be rendered red
+     * @return
+     *          should be rendered red
+     */
+    public boolean isDamaged() {
+        return isDamaged;
+    }
+}
diff --git a/src/main/java/common/tileentities/TE_SpaceElevatorTether.java b/src/main/java/common/tileentities/TE_SpaceElevatorTether.java
new file mode 100644
index 0000000000..c4df059563
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_SpaceElevatorTether.java
@@ -0,0 +1,23 @@
+package common.tileentities;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+
+public class TE_SpaceElevatorTether extends TileEntity {
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    public double getMaxRenderDistanceSquared() {
+        // 4k is standard, 65k is what the vanilla beacon uses
+        return 65536.0D;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public AxisAlignedBB getRenderBoundingBox() {
+        // Make it so the beam is still rendered even when the source block is out of sight
+        return INFINITE_EXTENT_AABB;
+    }
+}
diff --git a/src/main/java/common/tileentities/TE_TFFTMultiHatch.java b/src/main/java/common/tileentities/TE_TFFTMultiHatch.java
new file mode 100644
index 0000000000..c4f9451478
--- /dev/null
+++ b/src/main/java/common/tileentities/TE_TFFTMultiHatch.java
@@ -0,0 +1,222 @@
+package common.tileentities;
+
+import java.util.Iterator;
+import java.util.List;
+
+import common.Blocks;
+import kekztech.MultiFluidHandler;
+import net.minecraft.block.Block;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class TE_TFFTMultiHatch extends TileEntity implements IFluidHandler {
+	
+	private static final int OUTPUT_PER_SECOND = 1000; // L/s
+	
+	private MultiFluidHandler mfh;
+	private int tickCounter = 0;
+	private boolean autoOutput = false;
+	
+	public void setMultiFluidHandler(MultiFluidHandler mfh) {
+		this.mfh = mfh;
+	}
+	
+	public void toggleAutoOutput() {
+		autoOutput = !autoOutput;
+	}
+	
+	public boolean isOutputting() {
+		return autoOutput;
+	}
+	
+	@Override
+	public void updateEntity() {
+		if(!autoOutput || mfh == null) {
+			return;
+		}
+		
+		tickCounter++;
+		if(tickCounter >= 20) {
+			
+			final ForgeDirection d = getOutwardsFacingDirection();
+			if(d == ForgeDirection.UNKNOWN) {
+				return;
+			}
+			final TileEntity t = this.getWorldObj().getTileEntity(
+					this.xCoord + d.offsetX, 
+					this.yCoord + d.offsetY, 
+					this.zCoord + d.offsetZ);
+			
+			if(t instanceof IFluidHandler) {
+				
+				final IFluidHandler fh = (IFluidHandler) t;
+				
+				// Cycle through fluids
+				final Iterator<FluidStack> volumes = mfh.getFluids().iterator();
+				while(volumes.hasNext()) {
+					final FluidStack volume = volumes.next();
+					
+					// Remember for later
+					final int oVolume = volume.amount;
+					
+					// Use API methods
+					if(fh.canFill(d.getOpposite(), volume.getFluid())) {
+						
+						// Test how much can be output
+						final FluidStack copy = volume.copy();
+						copy.amount = Math.min(copy.amount, OUTPUT_PER_SECOND);
+												
+						// How much is drawn
+						copy.amount = mfh.pullFluid(copy, false);
+						
+						// Test how much can be filled (and fill if possible)
+						copy.amount = fh.fill(d.getOpposite(), copy, true);
+												
+						// Actually deplete storage
+						mfh.pullFluid(copy, true);
+						
+						// Prevent ConcurrentModificationException
+						if(copy.amount >= oVolume) {
+							break;
+						}
+					}
+				}
+			}
+			
+			tickCounter = 0;
+		}
+	}
+	
+	private ForgeDirection getOutwardsFacingDirection() {
+		// TODO Revisit this once the hatch has a facing side
+		// Look up which side has the storage field block and choose the other side.
+		// This is important so the tank doesn't output into itself in case
+		// there is another hatch next to this one. 
+		for(ForgeDirection direction : ForgeDirection.values()) {
+			
+			final Block b = this.getWorldObj().getBlock(this.xCoord + direction.offsetX, this.yCoord + direction.offsetY, this.zCoord + direction.offsetZ);
+			if(b != null && (
+					b.equals(Blocks.tfftStorageField1)
+					|| b.equals(Blocks.tfftStorageField2)
+					|| b.equals(Blocks.tfftStorageField3)
+					|| b.equals(Blocks.tfftStorageField4)
+					|| b.equals(Blocks.tfftStorageField5))) {
+				return direction.getOpposite();
+			}
+		}
+		return ForgeDirection.UNKNOWN;
+	}
+	
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+		return (mfh != null) ? mfh.pushFluid(resource, doFill) : 0; 
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+		return (mfh != null) ? new FluidStack(resource.getFluid(), mfh.pullFluid(resource, doDrain)) : null; 
+	}
+	
+	/**
+     * Drains fluid out of 0th internal tank. 
+     * If the TFFT Controller contains an Integrated Circuit, drain fluid
+     * from the slot equal to the circuit configuration.
+     * 
+     * @param from
+     *            Orientation the fluid is drained to.
+     * @param maxDrain
+     *            Maximum amount of fluid to drain.
+     * @param doDrain
+     *            If false, drain will only be simulated.
+     * @return FluidStack representing the Fluid and amount that was (or would have been, if
+     *         simulated) drained.
+     */
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+		if(mfh != null) {
+			final FluidStack drain = mfh.getFluid(0);
+			if(drain != null) {
+				// If there's no integrated circuit in the T.F.F.T. controller, output slot 0
+				final byte selectedSlot = (mfh.getSelectedFluid() == -1) ? 0 : mfh.getSelectedFluid();
+				
+				return new FluidStack(
+						drain.getFluid(), 
+						mfh.pullFluid(new FluidStack(drain.getFluid(), maxDrain), selectedSlot, doDrain)
+						);			
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		return (mfh != null) && mfh.couldPush(new FluidStack(fluid, 1));
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		return (mfh != null) && mfh.contains(new FluidStack(fluid, 1));
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+		if(mfh == null) {
+			return null;
+		}
+		final List<FluidStack> fluids = mfh.getFluids();
+		final FluidTankInfo[] tankInfo = new FluidTankInfo[fluids.size()];
+		for(int i = 0; i < tankInfo.length; i++) {
+			tankInfo[i] = new FluidTankInfo(fluids.get(i), mfh.getCapacity());
+		}
+		return tankInfo;
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+		nbt.setBoolean("autoOutput", autoOutput);
+
+		super.writeToNBT(nbt);
+	}
+	
+	@Override
+	public void readFromNBT(NBTTagCompound nbt) {
+		nbt = (nbt == null) ? new NBTTagCompound() : nbt;
+
+		autoOutput = nbt.getBoolean("autoOutput");
+
+		super.readFromNBT(nbt);
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+}
diff --git a/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java b/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java
new file mode 100644
index 0000000000..23b19495ae
--- /dev/null
+++ b/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/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java b/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java
new file mode 100644
index 0000000000..c648d4be00
--- /dev/null
+++ b/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;
+	}
+}