+More classes stolen from GT to implement my own items on a metaitem.

+Added LuV -> Max Voltage Machine components.
+Added Rocket Engines, High tier diesel generators.
+Added new textures for everything.
+Added BedLocator_Base.java - Debug item for testing and NBT data storage.
+Added Machine_Charger.java - Another Debug machine for testing NBT value manipulation.

5 files changed, 1396 insertions, 0 deletions

diff --git a/src/Java/miscutil/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java b/src/Java/miscutil/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
new file mode 100644
index 0000000000..ecf292392a
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/generators/GregtechMetaTileEntityRocketFuelGenerator.java
@@ -0,0 +1,119 @@
+package miscutil.gregtech.common.tileentities.generators;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import miscutil.gregtech.api.metatileentity.implementations.base.GregtechRocketFuelGeneratorBase;
+import net.minecraft.item.ItemStack;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class GregtechMetaTileEntityRocketFuelGenerator
+        extends GregtechRocketFuelGeneratorBase {
+
+    public int mEfficiency;
+
+    public GregtechMetaTileEntityRocketFuelGenerator(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, "Requires liquid Fuel", new ITexture[0]);
+        onConfigLoad();
+    }
+
+    public GregtechMetaTileEntityRocketFuelGenerator(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, aDescription, aTextures);
+        onConfigLoad();
+    }
+
+    @Override
+	public boolean isOutputFacing(byte aSide) {
+        return aSide == getBaseMetaTileEntity().getFrontFacing();
+    }
+
+    @Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityRocketFuelGenerator(this.mName, this.mTier, this.mDescription, this.mTextures);
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipes() {
+        return GT_Recipe.GT_Recipe_Map.sDieselFuels;
+    }
+
+    @Override
+	public int getCapacity() {
+        return 32000;
+    }
+
+    public void onConfigLoad() {
+        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "RocketEngine.efficiency.tier." + this.mTier, (100 - this.mTier * 8));
+    }
+
+    @Override
+	public int getEfficiency() {
+        return this.mEfficiency;
+    }
+
+    @Override
+	public int getFuelValue(ItemStack aStack) {
+        int rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack));
+        if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) {
+            rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3);
+        }
+        return rValue;
+    }
+
+    @Override
+	public ITexture[] getFront(byte aColor) {
+        return new ITexture[]{super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBack(byte aColor) {
+        return new ITexture[]{super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK)};
+    }
+
+    @Override
+	public ITexture[] getBottom(byte aColor) {
+        return new ITexture[]{super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM)};
+    }
+
+    @Override
+	public ITexture[] getTop(byte aColor) {
+        return new ITexture[]{super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP)};
+    }
+
+    @Override
+	public ITexture[] getSides(byte aColor) {
+        return new ITexture[]{super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE)};
+    }
+
+    @Override
+	public ITexture[] getFrontActive(byte aColor) {
+        return new ITexture[]{super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier]};
+    }
+
+    @Override
+	public ITexture[] getBackActive(byte aColor) {
+        return new ITexture[]{super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK_ACTIVE)};
+    }
+
+    @Override
+	public ITexture[] getBottomActive(byte aColor) {
+        return new ITexture[]{super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM_ACTIVE)};
+    }
+
+    @Override
+	public ITexture[] getTopActive(byte aColor) {
+        return new ITexture[]{super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP_ACTIVE)};
+    }
+
+    @Override
+	public ITexture[] getSidesActive(byte aColor) {
+        return new ITexture[]{super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE_ACTIVE)};
+    }
+}
diff --git a/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java
new file mode 100644
index 0000000000..904f8db77d
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java
@@ -0,0 +1,391 @@
+package miscutil.gregtech.common.tileentities.machines.multi;
+
+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_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import miscutil.core.block.ModBlocks;
+import miscutil.core.util.Utils;
+import miscutil.gregtech.api.gui.GUI_MultiMachine;
+import miscutil.gregtech.api.objects.GregtechRenderedTexture;
+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 org.apache.commons.lang3.ArrayUtils;
+
+public class GregtechMetaTileEntityIndustrialCentrifuge
+extends GT_MetaTileEntity_MultiBlockBase {
+	private static boolean controller;
+
+	public GregtechMetaTileEntityIndustrialCentrifuge(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public GregtechMetaTileEntityIndustrialCentrifuge(String aName) {
+		super(aName);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntityIndustrialCentrifuge(this.mName);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[]{
+				"Controller Block for the Industrial Centrifuge",
+				"Size: 3x3x3 (Hollow)", 
+				"Controller (Front Center)",
+				"1x Maintenance Hatch (Rear Center)",
+				"The rest can be placed anywhere except the Front",
+				"1x Input Hatch",
+				"1x Output Hatch",
+				"1x Input Bus",
+				"1x Output Bus",
+				"1x [EV] Energy Hatch (Can be higher Tier)",
+				"Needs a Turbine Item (inside controller GUI)",
+				"Centrifuge Casings for the rest (16 at least)",};
+	}
+
+	/*@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) {
+			return new ITexture[]{GregtechTextures.BlockIcons.GT_CASING_BLOCKS[0], new GT_RenderedTexture(aActive ? Textures.BlockIcons.LARGETURBINE_ACTIVE5 : Textures.BlockIcons.LARGETURBINE5)};
+		}
+		return new ITexture[]{GregtechTextures.BlockIcons.GT_CASING_BLOCKS[0]};
+	}*/
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[1][aColorIndex + 1], aFacing == aSide ? aActive ? new GregtechRenderedTexture(Textures.BlockIcons.LARGETURBINE_ACTIVE5) : new GregtechRenderedTexture(Textures.BlockIcons.LARGETURBINE5) : Textures.BlockIcons.CASING_BLOCKS[57]};
+	}
+
+	@Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GUI_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "CokeOven.png");
+	}
+
+	@Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+		return GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes;
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+	@Override
+	public boolean isFacingValid(byte aFacing) {
+		return aFacing > 1;
+	}
+
+	ArrayList<ItemStack> tInputList = getStoredInputs();
+	GT_Recipe mLastRecipe;
+
+	@Override
+	public boolean checkRecipe(ItemStack aStack) {
+		long tVoltage = getMaxInputVoltage();
+		byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+
+		GT_Recipe.GT_Recipe_Map map = getRecipeMap();
+		for (int i = 0; i < tInputList.size() - 1; i++) {
+			for (int j = i + 1; j < tInputList.size(); j++) {
+				if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) {
+					if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) {
+						tInputList.remove(j--);
+					} else {
+						tInputList.remove(i--);
+						break;
+					}
+				}
+			}
+		}
+		ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2);
+
+		ArrayList<FluidStack> tFluidList = getStoredFluids();
+		for (int i = 0; i < tFluidList.size() - 1; i++) {
+			for (int j = i + 1; j < tFluidList.size(); j++) {
+				if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) {
+					if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) {
+						tFluidList.remove(j--);
+					} else {
+						tFluidList.remove(i--);
+						break;
+					}
+				}
+			}
+		}
+		FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
+		if (tInputList.size() > 0 || tFluids.length > 0) {
+			GT_Recipe tRecipe = map.findRecipe(getBaseMetaTileEntity(), mLastRecipe, false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
+			if (tRecipe != null) {
+				if (tRecipe.mFluidInputs != null) {
+
+				}
+				mLastRecipe = tRecipe;
+				this.mEUt = 0;
+				this.mOutputItems = null;
+				this.mOutputFluids = null;
+				int machines = Math.min(16, mInventory[1].stackSize);
+				int i = 0;
+				for (; i < machines; i++) {
+					if (!tRecipe.isRecipeInputEqual(true, tFluids, tInputs)) {
+						if (i == 0) {
+							return false;
+						}
+						break;
+					}
+				}
+				this.mMaxProgresstime = tRecipe.mDuration;
+				this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+				this.mEfficiencyIncrease = 10000;
+				if (tRecipe.mEUt <= 16) {
+					this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+					this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1));
+				} else {
+					this.mEUt = tRecipe.mEUt;
+					this.mMaxProgresstime = tRecipe.mDuration;
+					while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+						this.mEUt *= 4;
+						this.mMaxProgresstime /= 4;
+					}
+				}
+				this.mEUt *= i;
+				if (this.mEUt > 0) {
+					this.mEUt = (-this.mEUt);
+				}
+				ItemStack[] tOut = new ItemStack[tRecipe.mOutputs.length];
+				for (int h = 0; h < tRecipe.mOutputs.length; h++) {
+					tOut[h] = tRecipe.getOutput(h).copy();
+					tOut[h].stackSize = 0;
+				}
+				FluidStack tFOut = null;
+				if (tRecipe.getFluidOutput(0) != null) tFOut = tRecipe.getFluidOutput(0).copy();
+				for (int f = 0; f < tOut.length; f++) {
+					if (tRecipe.mOutputs[f] != null && tOut[f] != null) {
+						for (int g = 0; g < i; g++) {
+							if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(f))
+								tOut[f].stackSize += tRecipe.mOutputs[f].stackSize;
+						}
+					}
+				}
+				if (tFOut != null) {
+					int tSize = tFOut.amount;
+					tFOut.amount = tSize * i;
+				}
+				this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+				List<ItemStack> overStacks = new ArrayList<ItemStack>();
+				for (int f = 0; f < tOut.length; f++) {
+					if (tOut[f].getMaxStackSize() < tOut[f].stackSize) {
+						while (tOut[f].getMaxStackSize() < tOut[f].stackSize) {
+							ItemStack tmp = tOut[f].copy();
+							tmp.stackSize = tmp.getMaxStackSize();
+							tOut[f].stackSize = tOut[f].stackSize - tOut[f].getMaxStackSize();
+							overStacks.add(tmp);
+						}
+					}
+				}
+				if (overStacks.size() > 0) {
+					ItemStack[] tmp = new ItemStack[overStacks.size()];
+					tmp = overStacks.toArray(tmp);
+					tOut = ArrayUtils.addAll(tOut, tmp);
+				}
+				List<ItemStack> tSList = new ArrayList<ItemStack>();
+				for (ItemStack tS : tOut) {
+					if (tS.stackSize > 0) tSList.add(tS);
+				}
+				tOut = tSList.toArray(new ItemStack[tSList.size()]);
+				this.mOutputItems = tOut;
+				this.mOutputFluids = new FluidStack[]{tFOut};
+				updateSlots();
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@SuppressWarnings("static-method")
+	public Block getCasingBlock() {
+		return ModBlocks.blockCasingsMisc;
+	}
+
+	@SuppressWarnings("static-method")
+	public byte getCasingMeta() {
+		return 0;
+	}
+
+	@SuppressWarnings("static-method")
+	public byte getCasingTextureIndex() {
+		return 0;
+	}
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int yDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetY;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+		//Utils.LOG_WARNING("X:"+xDir+" Y:"+yDir+" Z:"+zDir);
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 0, zDir)) {
+			return false;
+		}
+		int tAmount = 0;
+		for (int i = -1; i < 2; i++) { //X-Dir
+			for (int j = -1; j < 2; j++) { //Z-Dir
+				for (int h = -1; h < 2; h++) { //Y-Dir
+					if ((h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))) {			
+
+						IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);
+						//Utils.LOG_INFO("X:"+tTileEntity.getXCoord()+" Y:"+tTileEntity.getYCoord()+" Z:"+tTileEntity.getZCoord());
+						if ((!addMaintenanceToMachineList(tTileEntity, 57)) && (!addInputToMachineList(tTileEntity, 57)) && (!addOutputToMachineList(tTileEntity, 57)) && (!addEnergyInputToMachineList(tTileEntity, 57))) {
+
+							//Maintenance Hatch
+							if ((tTileEntity != null) && (tTileEntity.getMetaTileEntity() != null)) {
+								if (tTileEntity.getXCoord() == aBaseMetaTileEntity.getXCoord() && tTileEntity.getYCoord() == aBaseMetaTileEntity.getYCoord() && tTileEntity.getZCoord() == (aBaseMetaTileEntity.getZCoord()+2)) {
+									if ((tTileEntity.getMetaTileEntity() instanceof GT_MetaTileEntity_Hatch_Maintenance)) {
+										Utils.LOG_INFO("MAINT HATCH IN CORRECT PLACE");
+										this.mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) tTileEntity.getMetaTileEntity());
+										((GT_MetaTileEntity_Hatch) tTileEntity.getMetaTileEntity()).mMachineBlock = getCasingTextureIndex();
+									} else {
+										return false;
+									}
+								}	
+								else {
+									Utils.LOG_INFO("MAINT HATCH IN WRONG PLACE");
+								}
+							}
+
+							if (aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j) != ModBlocks.blockCasingsMisc) {
+								return false;
+							}
+							if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j) != 0) {
+								return false;
+							}
+							tAmount++;
+
+						}
+					}
+				}
+			}
+		}		
+		return tAmount >= 16;
+	}
+
+	@SuppressWarnings("static-method")
+	public boolean ignoreController(Block tTileEntity) {
+		if (!controller && tTileEntity == GregTech_API.sBlockMachines) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public int getMaxEfficiency(ItemStack aStack) {
+		return 10000;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack aStack) {
+		return 0;
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack aStack) {
+		return 0;
+	}
+
+	@Override
+	public int getAmountOfOutputs() {
+		return 1;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+		return false;
+	}
+
+	private boolean checkStructure(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack){
+
+		Utils.LOG_INFO("structure checking");
+		int x = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int y = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetY;
+		int z = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+		Utils.LOG_INFO("X:"+x+" Y:"+y+" Z:"+z);
+
+		//North case
+		int hatchMaintainence[] = {x, y, z+2};
+		int hatchInputBus[] = {x+1, y, z+1};
+		int hatchOutputBus[] = {x-1, y, z+1};
+		int hatchInput[] = {x+1, y+1, z+1};
+		int hatchOutput[] = {x-1, y+1, z+1};
+		int hatchEnergy[] = {x, y+1, z+2};
+
+		//South case
+		int hatchMaintainence0[] = {x, y, z-2};
+		int hatchInputBus0[] = {x-1, y, z-1};
+		int hatchOutputBus0[] = {x+1, y, z-1};
+		int hatchInput0[] = {x-1, y+1, z-1};
+		int hatchOutput0[] = {x+1, y+1, z-1};
+		int hatchEnergy0[] = {x, y+1, z-2};
+
+
+		//East case
+		int hatchMaintainence1[] = {x+2, y, z};
+		int hatchInputBus1[] = {x+1, y, z+1};
+		int hatchOutputBus1[] = {x+1, y, z-1};
+		int hatchInput1[] = {x+1, y+1, z+1};
+		int hatchOutput1[] = {x+1, y+1, z-1};
+		int hatchEnergy1[] = {x+2, y+1, z};
+
+		//West case
+		int hatchMaintainence2[] = {x-2, y, z};
+		int hatchInputBus2[] = {x-1, y, z-1};
+		int hatchOutputBus2[] = {x-1, y, z+1};
+		int hatchInput2[] = {x-1, y+1, z-1};
+		int hatchOutput2[] = {x-1, y+1, z+1};
+		int hatchEnergy2[] = {x-2, y+1, z};
+
+
+
+		/*//Maintenance Hatch
+		IGregTechTileEntity tTileEntityMaintenanceHatch = getBaseMetaTileEntity().getIGregTechTileEntityAtSideAndDistance(getBaseMetaTileEntity().getBackFacing(), 2);
+		if ((tTileEntityMaintenanceHatch != null) && (tTileEntityMaintenanceHatch.getMetaTileEntity() != null)) {
+			if ((tTileEntityMaintenanceHatch.getMetaTileEntity() instanceof GT_MetaTileEntity_Hatch_Maintenance)) {
+				this.mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) tTileEntityMaintenanceHatch.getMetaTileEntity());
+				((GT_MetaTileEntity_Hatch) tTileEntityMaintenanceHatch.getMetaTileEntity()).mMachineBlock = getCasingTextureIndex();
+			} else {
+				return false;
+			}
+		}*/
+
+		/*//Energy Hatch
+		IGregTechTileEntity tTileEntityEnergyHatch = getBaseMetaTileEntity().getIGregTechTileEntity(i, h+1, j+2);
+		if ((tTileEntityEnergyHatch != null) && (tTileEntityEnergyHatch.getMetaTileEntity() != null)) {
+			if ((tTileEntityEnergyHatch.getMetaTileEntity() instanceof GT_MetaTileEntity_Hatch_Energy)) {
+				this.mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) tTileEntityEnergyHatch.getMetaTileEntity());
+				((GT_MetaTileEntity_Hatch) tTileEntityEnergyHatch.getMetaTileEntity()).mMachineBlock = getCasingTextureIndex();
+			} else {
+				return false;
+			}
+		}*/
+
+
+
+
+		return false;
+	}
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCokeOven.java b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCokeOven.java
new file mode 100644
index 0000000000..756a8add4a
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCokeOven.java
@@ -0,0 +1,268 @@
+package miscutil.gregtech.common.tileentities.machines.multi;
+
+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 gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import miscutil.core.block.ModBlocks;
+import miscutil.core.util.Utils;
+import miscutil.gregtech.api.gui.GUI_MultiMachine;
+import miscutil.gregtech.api.util.GregtechRecipe;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GregtechMetaTileEntityIndustrialCokeOven
+        extends GT_MetaTileEntity_MultiBlockBase {
+    private int mLevel = 0;
+
+    public GregtechMetaTileEntityIndustrialCokeOven(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GregtechMetaTileEntityIndustrialCokeOven(String aName) {
+        super(aName);
+    }
+
+    @Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityIndustrialCokeOven(this.mName);
+    }
+
+    @Override
+	public String[] getDescription() {
+        return new String[]{"Smelts up to 6-18 Items at once",
+        		"Controller Block for the Multi Smelter",
+        		"Size: 3x3x3 (Hollow)",
+        		"Controller (front middle at bottom)",
+        		"8x Heating Coils (middle Layer, hollow)",
+        		"1x Input (one of bottom)",
+        		"1x Output (one of bottom)", 
+        		"1x Energy Hatch (one of bottom)",
+        		"1x Maintenance Hatch (one of bottom)",
+        		"1x Muffler Hatch (top middle)",
+        		"Heat Proof Machine Casings for the rest"};
+    }
+
+    @Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[58], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_MULTI_SMELTER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_MULTI_SMELTER)};
+        }
+        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[58]};
+    }
+
+    @Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GUI_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "CokeOven.png");
+    }
+
+    @Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+        return GregtechRecipe.Gregtech_Recipe_Map.sCokeOvenRecipes;
+        
+    }
+
+    @Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+	public boolean isFacingValid(byte aFacing) {
+        return aFacing > 1;
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack aStack) {
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+        for (int i = 0; i < tInputList.size() - 1; i++) {
+            for (int j = i + 1; j < tInputList.size(); j++) {
+                if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) {
+                    if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) {
+                        tInputList.remove(j--);
+                    } else {
+                        tInputList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2);
+
+        ArrayList<FluidStack> tFluidList = getStoredFluids();
+        for (int i = 0; i < tFluidList.size() - 1; i++) {
+            for (int j = i + 1; j < tFluidList.size(); j++) {
+                if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) {
+                    if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) {
+                        tFluidList.remove(j--);
+                    } else {
+                        tFluidList.remove(i--);
+                        break;
+                    }
+                }
+            }
+        }
+        FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1);
+        if (tInputList.size() > 0) {
+            long tVoltage = getMaxInputVoltage();
+            byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+            GT_Recipe tRecipe = GregtechRecipe.Gregtech_Recipe_Map.sCokeOvenRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs);
+            if ((tRecipe != null) && (this.mLevel >= tRecipe.mSpecialValue) && (tRecipe.isRecipeInputEqual(true, tFluids, tInputs))) {
+                this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+                this.mEfficiencyIncrease = 10000;
+                if (tRecipe.mEUt <= 16) {
+                    this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+                    this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1));
+                } else {
+                    this.mEUt = tRecipe.mEUt;
+                    this.mMaxProgresstime = tRecipe.mDuration;
+                    while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+                        this.mEUt *= 4;
+                        this.mMaxProgresstime /= 2;
+                    }
+                }
+                if (this.mEUt > 0) {
+                    this.mEUt = (-this.mEUt);
+                }
+                this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+                this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0)};
+                this.mOutputFluids = new FluidStack[]{tRecipe.getFluidOutput(0)};
+                updateSlots();
+                return true;
+            }
+        }
+        return false;
+    }
+	/*public boolean checkRecipe(ItemStack aStack) {
+        ArrayList<ItemStack> tInputList = getStoredInputs();
+        if (!tInputList.isEmpty()) {
+            byte tTier = (byte) Math.max(1, GT_Utility.getTier(getMaxInputVoltage()));
+
+            int j = 0;
+            this.mOutputItems = new ItemStack[12 * this.mLevel];
+            for (int i = 0; (i < 100) && (j < this.mOutputItems.length); i++) {
+                if (null != (this.mOutputItems[j] = GT_ModHandler.getSmeltingOutput((ItemStack) tInputList.get(i % tInputList.size()), true, null))) {
+                    j++;
+                }
+            }
+            if (j > 0) {
+                this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+                this.mEfficiencyIncrease = 10000;
+
+                this.mEUt = (-4 * (1 << tTier - 1) * (1 << tTier - 1) * this.mLevel);
+                this.mMaxProgresstime = Math.max(1, 512 / (1 << tTier - 1));
+            }
+            updateSlots();
+            return true;
+        }
+        return false;
+    }*/
+
+    @Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+        int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+        int xr = aBaseMetaTileEntity.getXCoord();
+    	int yr = aBaseMetaTileEntity.getYCoord();
+    	int zr = aBaseMetaTileEntity.getZCoord();
+        this.mLevel = 0;
+        if (!aBaseMetaTileEntity.getAirOffset(xDir, 1, zDir)) {
+            return false;
+        }
+        addMufflerToMachineList(aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir, 2, zDir), 1);
+
+        byte tUsedMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + 1, 1, zDir);
+        switch (tUsedMeta) {
+            case 2:
+                this.mLevel = 1;
+                break;
+            case 3:
+                this.mLevel = 2;
+                break;
+            default:
+                return false;
+        }
+        this.mOutputItems = new ItemStack[12 * this.mLevel];
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 2; j++) {
+                if ((i != 0) || (j != 0)) {
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 1, zDir + j) != ModBlocks.blockCasingsMisc) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 1, zDir + j) != tUsedMeta) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 2, zDir + j) != ModBlocks.blockCasingsMisc) {
+                        return false;
+                    }
+                    if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 2, zDir + j) != 1) {
+                        return false;
+                    }
+                }
+            }
+        }
+        for (int i = -1; i < 2; i++) {
+        	xr = aBaseMetaTileEntity.getXCoord();
+        	yr = aBaseMetaTileEntity.getYCoord();
+        	zr = aBaseMetaTileEntity.getZCoord();
+        	Utils.LOG_INFO("STEP 1 - x ["+xr+"]  y ["+yr+"]  z ["+zr+"]");
+            for (int j = -1; j < 2; j++) {
+            	xr = aBaseMetaTileEntity.getXCoord();
+            	yr = aBaseMetaTileEntity.getYCoord();
+            	zr = aBaseMetaTileEntity.getZCoord();
+            	Utils.LOG_INFO("STEP 2 - x ["+xr+"]  y ["+yr+"]  z ["+zr+"]");
+                if ((xDir + i != 0) || (zDir + j != 0)) {
+                	xr = aBaseMetaTileEntity.getXCoord();
+                	yr = aBaseMetaTileEntity.getYCoord();
+                	zr = aBaseMetaTileEntity.getZCoord();
+                	Utils.LOG_INFO("STEP 3 - x ["+xr+"]  y ["+yr+"]  z ["+zr+"]");
+                    IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0, zDir + j);
+                    if ((!addMaintenanceToMachineList(tTileEntity, 1)) && (!addInputToMachineList(tTileEntity, 1)) && (!addOutputToMachineList(tTileEntity, 1)) && (!addEnergyInputToMachineList(tTileEntity, 1))) {
+                        if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j) != ModBlocks.blockCasingsMisc) {
+                            return false;
+                        }
+                        if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j) != 1) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+	public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+	public int getPollutionPerTick(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+	public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+	public int getAmountOfOutputs() {
+        return 24;
+    }
+
+    @Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+}
diff --git a/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialPlatePress.java b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialPlatePress.java
new file mode 100644
index 0000000000..e733c55c1c
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialPlatePress.java
@@ -0,0 +1,249 @@
+package miscutil.gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.GregTech_API;
+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 java.util.ArrayList;
+
+import miscutil.core.util.Utils;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class GregtechMetaTileEntityIndustrialPlatePress
+extends GT_MetaTileEntity_MultiBlockBase {
+	public GregtechMetaTileEntityIndustrialPlatePress(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+	}
+
+	public GregtechMetaTileEntityIndustrialPlatePress(String aName) {
+		super(aName);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntityIndustrialPlatePress(this.mName);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[]{"Controller Block for the Vacuum Freezer", "Size: 3x3x3 (Hollow)", "Controller (front centered)", "1x Input (anywhere)", "1x Output (anywhere)", "1x Energy Hatch (anywhere)", "1x Maintenance Hatch (anywhere)", "Frost Proof Casings for the rest (16 at least!)"};
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) {
+			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[17], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_VACUUM_FREEZER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_VACUUM_FREEZER)};
+		}
+		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[17]};
+	}
+
+	@Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "VacuumFreezer.png");
+	}
+
+	@Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+		return GT_Recipe.GT_Recipe_Map.sBenderRecipes;
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+		return true;
+	}
+
+	@Override
+	public boolean isFacingValid(byte aFacing) {
+		return aFacing > 1;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack aStack) {
+		ArrayList<ItemStack> tInputList = getStoredInputs();
+		for (ItemStack tInput : tInputList) {
+			long tVoltage = getMaxInputVoltage();
+			byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage));
+
+			GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sVacuumRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], null, new ItemStack[]{tInput});
+			if (tRecipe != null) {
+				if (tRecipe.isRecipeInputEqual(true, null, new ItemStack[]{tInput})) {
+					this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+					this.mEfficiencyIncrease = 10000;
+					if (tRecipe.mEUt <= 16) {
+						this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+						this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1));
+					} else {
+						this.mEUt = tRecipe.mEUt;
+						this.mMaxProgresstime = tRecipe.mDuration;
+						while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+							this.mEUt *= 4;
+							this.mMaxProgresstime /= 2;
+						}
+					}
+					if (this.mEUt > 0) {
+						this.mEUt = (-this.mEUt);
+					}
+					this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+					this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0)};
+					updateSlots();
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/*public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 0, zDir)) {
+			return false;
+		}
+		int stepX = 0;
+		int stepY = 0;
+		int stepZ = 0;
+
+		int tAmount = 0;
+		for (int i = -1; i < 2; i++) {
+			stepX=+i;
+			for (int j = -1; j < 2; j++) {
+				stepZ=+j;
+				for (int h = -1; h < 2; h++) {
+					stepY=+h;
+					Utils.LOG_INFO("X:"+stepX);
+					Utils.LOG_INFO("Y:"+stepY);
+					Utils.LOG_INFO("Z:"+stepZ);
+					Utils.LOG_INFO("Block Facing - X:"+xDir+"    Z:"+zDir);
+					Utils.LOG_INFO("(h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))");
+					Utils.LOG_INFO("  "+(h != 0)+"   ||       "+(((xDir + i != 0)+"       ||       "+(zDir + j != 0))+"       &&    "+((i != 0)+"   ||   "+(j != 0))));
+					try {
+						IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);						
+						Utils.LOG_INFO("IPP - RESULT - ? - ["+tTileEntity.getXCoord()+"]  y ["+tTileEntity.getYCoord()+"]  z ["+tTileEntity.getZCoord()+"] || i ["+i+"]  j ["+j+"]  h ["+h+"]");
+					} catch(Throwable t){Utils.LOG_INFO("Bad move");				
+					}
+					if ((h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))) {
+						IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);
+						if ((!addMaintenanceToMachineList(tTileEntity, 17)) && (!addInputToMachineList(tTileEntity, 17)) && (!addOutputToMachineList(tTileEntity, 17)) && (!addEnergyInputToMachineList(tTileEntity, 17))) {
+							if (aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j) != GregTech_API.sBlockCasings2) {
+								return false;
+							}
+							if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j) != 1) {
+								return false;
+							}
+							tAmount++;
+						}
+					}		
+
+				}
+			}
+		}
+		return tAmount >= 16;
+	}*/
+
+
+	@Override
+	public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
+		if (!aBaseMetaTileEntity.getAirOffset(xDir, 0, zDir)) {
+			return false;
+		}
+		int stepX = aBaseMetaTileEntity.getXCoord();
+		int stepY = aBaseMetaTileEntity.getYCoord();
+		int stepZ = aBaseMetaTileEntity.getZCoord();
+		int temp = 0;
+
+		Utils.LOG_INFO("Starting Block located @ "+"[X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+
+		int tAmount = 0;
+		switch (xDir) {
+		case -1:
+			stepX++;
+			Utils.LOG_INFO("Modifying stepX + accomodate a "+xDir+" xDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+
+		case 1:
+			stepX--;
+			Utils.LOG_INFO("Modifying stepX - accomodate a "+xDir+" xDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+		}
+		switch (zDir) {
+		case -1:
+			stepZ++;
+			Utils.LOG_INFO("Modifying stepZ + accomodate a "+zDir+" zDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+
+		case 1:
+			stepZ--;
+			Utils.LOG_INFO("Modifying stepZ - accomodate a "+zDir+" zDir - [X:"+stepX+"][Y:"+stepY+"][Z:"+stepZ+"]");	
+			break;
+		}
+
+		for (int i = stepX-1; i <= stepX+1; i++){
+			for (int j = stepZ-1; j <= stepZ+1; j++){
+				for (int h = stepY-1; h <= stepY+1; h++){	
+
+
+					Utils.LOG_INFO("Block Facing - X:"+xDir+"    Z:"+zDir);
+					Utils.LOG_INFO("(h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))");
+					Utils.LOG_INFO("  "+(h != 0)+"   ||       "+(((xDir + i != 0)+"       ||       "+(zDir + j != 0))+"       &&    "+((i != 0)+"   ||   "+(j != 0))));
+
+					try {
+						IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);						
+						Utils.LOG_INFO("IPP - RESULT - ? - ["+tTileEntity.getXCoord()+"]  y ["+tTileEntity.getYCoord()+"]  z ["+tTileEntity.getZCoord()+"] || i ["+i+"]  j ["+j+"]  h ["+h+"]");
+					} catch(Throwable t){Utils.LOG_INFO("Checking Non-Hatch/Bus Block/Casing");				
+					}
+					if ((h != 0) || (((xDir + i != 0) || (zDir + j != 0)) && ((i != 0) || (j != 0)))) {
+						IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, h, zDir + j);
+						if ((!addMaintenanceToMachineList(tTileEntity, 17)) && (!addInputToMachineList(tTileEntity, 17)) && (!addOutputToMachineList(tTileEntity, 17)) && (!addEnergyInputToMachineList(tTileEntity, 17))) {
+							if (aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j) != GregTech_API.sBlockCasings2) {
+								return false;
+							}
+							if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j) != 1) {
+								return false;
+							}
+							tAmount++;
+						}
+					}	
+				}
+			}
+		}
+
+
+		return tAmount >= 16;
+	}
+
+	@Override
+	public int getMaxEfficiency(ItemStack aStack) {
+		return 10000;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack aStack) {
+		return 0;
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack aStack) {
+		return 0;
+	}
+
+	@Override
+	public int getAmountOfOutputs() {
+		return 1;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+		return false;
+	}
+}
diff --git a/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIronBlastFurnace.java b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIronBlastFurnace.java
new file mode 100644
index 0000000000..630d5054f9
--- /dev/null
+++ b/src/Java/miscutil/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIronBlastFurnace.java
@@ -0,0 +1,369 @@
+package miscutil.gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import miscutil.core.block.ModBlocks;
+import miscutil.gregtech.api.gui.CONTAINER_IronBlastFurnace;
+import miscutil.gregtech.api.gui.GUI_IronBlastFurnace;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class GregtechMetaTileEntityIronBlastFurnace
+        extends MetaTileEntity {
+    private static final ITexture[] FACING_SIDE = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_SOLID_STEEL)};
+    private static final ITexture[] FACING_FRONT = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT)};
+    private static final ITexture[] FACING_ACTIVE = {new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT_ACTIVE)};
+    public int mMaxProgresstime = 0;
+    public int mUpdate = 30;
+    public int mProgresstime = 0;
+    public boolean mMachine = false;
+    public ItemStack mOutputItem1;
+    public ItemStack mOutputItem2;
+
+    public GregtechMetaTileEntityIronBlastFurnace(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional, 4);
+    }
+
+    public GregtechMetaTileEntityIronBlastFurnace(String aName) {
+        super(aName, 4);
+    }
+
+    @Override
+	public String[] getDescription() {
+        return new String[]{"Slowly, Skip the Bronze age, Get some Steel!", "Multiblock: 3x3x5 hollow with opening on top", "40 Iron Plated Bricks required"};
+    }
+
+    @Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            return aActive ? FACING_ACTIVE : FACING_FRONT;
+        }
+        return FACING_SIDE;
+    }
+
+    @Override
+	public boolean isSteampowered() {
+        return false;
+    }
+
+    @Override
+	public boolean isElectric() {
+        return false;
+    }
+
+    @Override
+	public boolean isPneumatic() {
+        return false;
+    }
+
+    @Override
+	public boolean isEnetInput() {
+        return false;
+    }
+
+    @Override
+	public boolean isEnetOutput() {
+        return false;
+    }
+
+    @Override
+	public boolean isInputFacing(byte aSide) {
+        return false;
+    }
+
+    @Override
+	public boolean isOutputFacing(byte aSide) {
+        return false;
+    }
+
+    @Override
+	public boolean isTeleporterCompatible() {
+        return false;
+    }
+
+    @Override
+	public boolean isFacingValid(byte aFacing) {
+        return aFacing > 1;
+    }
+
+    @Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+
+    @Override
+	public int getProgresstime() {
+        return this.mProgresstime;
+    }
+
+    @Override
+	public int maxProgresstime() {
+        return this.mMaxProgresstime;
+    }
+
+    @Override
+	public int increaseProgress(int aProgress) {
+        this.mProgresstime += aProgress;
+        return this.mMaxProgresstime - this.mProgresstime;
+    }
+
+    @Override
+	public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) {
+        return (GregTech_API.getCoverBehavior(aCoverID.toStack()).isSimpleCover()) && (super.allowCoverOnSide(aSide, aCoverID));
+    }
+
+    @Override
+	public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntityIronBlastFurnace(this.mName);
+    }
+
+    @Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setInteger("mProgresstime", this.mProgresstime);
+        aNBT.setInteger("mMaxProgresstime", this.mMaxProgresstime);
+        if (this.mOutputItem1 != null) {
+            NBTTagCompound tNBT = new NBTTagCompound();
+            this.mOutputItem1.writeToNBT(tNBT);
+            aNBT.setTag("mOutputItem1", tNBT);
+        }
+        if (this.mOutputItem2 != null) {
+            NBTTagCompound tNBT = new NBTTagCompound();
+            this.mOutputItem2.writeToNBT(tNBT);
+            aNBT.setTag("mOutputItem2", tNBT);
+        }
+    }
+
+    @Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+        this.mUpdate = 30;
+        this.mProgresstime = aNBT.getInteger("mProgresstime");
+        this.mMaxProgresstime = aNBT.getInteger("mMaxProgresstime");
+        this.mOutputItem1 = GT_Utility.loadItem(aNBT, "mOutputItem1");
+        this.mOutputItem2 = GT_Utility.loadItem(aNBT, "mOutputItem2");
+    }
+
+    @Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) {
+            return true;
+        }
+        aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    @Override
+	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new CONTAINER_IronBlastFurnace(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    @Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GUI_IronBlastFurnace(aPlayerInventory, aBaseMetaTileEntity);
+    }
+
+    private boolean checkMachine() {
+        int xDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX;
+        int zDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ;
+        for (int i = -1; i < 2; i++) {
+            for (int j = -1; j < 4; j++) { //This is height
+                for (int k = -1; k < 2; k++) {
+                    if ((xDir + i != 0) || (j != 0) || (zDir + k != 0)) {
+                        if ((i != 0) || (j == -1) || (k != 0)) {
+                            if ((getBaseMetaTileEntity().getBlockOffset(xDir + i, j, zDir + k) != ModBlocks.blockCasingsMisc) || (getBaseMetaTileEntity().getMetaIDOffset(xDir + i, j, zDir + k) != 10)) {
+                                return false;
+                            }
+                        } else if ((!GT_Utility.arrayContains(getBaseMetaTileEntity().getBlockOffset(xDir + i, j, zDir + k), new Object[]{Blocks.lava, Blocks.flowing_lava, null})) && (!getBaseMetaTileEntity().getAirOffset(xDir + i, j, zDir + k))) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+	public void onMachineBlockUpdate() {
+        this.mUpdate = 30;
+    }
+
+    @Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+        if ((aBaseMetaTileEntity.isClientSide()) &&
+                (aBaseMetaTileEntity.isActive())) {
+            aBaseMetaTileEntity.getWorld().spawnParticle("cloud", aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1) + Math.random(), aBaseMetaTileEntity.getOffsetY(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1) + Math.random(), 0.0D, 0.3D, 0.0D);
+        }
+        if (aBaseMetaTileEntity.isServerSide()) {
+            if (this.mUpdate-- == 0) {
+                this.mMachine = checkMachine();
+            }
+            if (this.mMachine) {
+                if (this.mMaxProgresstime > 0) {
+                    if (++this.mProgresstime >= this.mMaxProgresstime) {
+                        addOutputProducts();
+                        this.mOutputItem1 = null;
+                        this.mOutputItem2 = null;
+                        this.mProgresstime = 0;
+                        this.mMaxProgresstime = 0;
+                        try {
+                          //  GT_Mod.instance.achievements.issueAchievement(aBaseMetaTileEntity.getWorld().getPlayerEntityByName(aBaseMetaTileEntity.getOwnerName()), "steel");
+                        } catch (Exception e) {
+                        }
+                    }
+                } else if (aBaseMetaTileEntity.isAllowedToWork()) {
+                    checkRecipe();
+                }
+            }
+            aBaseMetaTileEntity.setActive((this.mMaxProgresstime > 0) && (this.mMachine));
+            if (aBaseMetaTileEntity.isActive()) {
+                if (aBaseMetaTileEntity.getAir(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1))) {
+                    aBaseMetaTileEntity.getWorld().setBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1), Blocks.lava, 1, 2);
+                    this.mUpdate = 1;
+                }
+                if (aBaseMetaTileEntity.getAir(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord() + 1, aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1))) {
+                    aBaseMetaTileEntity.getWorld().setBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord() + 1, aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1), Blocks.lava, 1, 2);
+                    this.mUpdate = 1;
+                }
+            } else {
+                if (aBaseMetaTileEntity.getBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1)) == Blocks.lava) {
+                    aBaseMetaTileEntity.getWorld().setBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord(), aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1), Blocks.air, 0, 2);
+                    this.mUpdate = 1;
+                }
+                if (aBaseMetaTileEntity.getBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord() + 1, aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1)) == Blocks.lava) {
+                    aBaseMetaTileEntity.getWorld().setBlock(aBaseMetaTileEntity.getOffsetX(aBaseMetaTileEntity.getBackFacing(), 1), aBaseMetaTileEntity.getYCoord() + 1, aBaseMetaTileEntity.getOffsetZ(aBaseMetaTileEntity.getBackFacing(), 1), Blocks.air, 0, 2);
+                    this.mUpdate = 1;
+                }
+            }
+        }
+    }
+
+    private void addOutputProducts() {
+        if (this.mOutputItem1 != null) {
+            if (this.mInventory[2] == null) {
+                this.mInventory[2] = GT_Utility.copy(new Object[]{this.mOutputItem1});
+            } else if (GT_Utility.areStacksEqual(this.mInventory[2], this.mOutputItem1)) {
+                this.mInventory[2].stackSize = Math.min(this.mOutputItem1.getMaxStackSize(), this.mOutputItem1.stackSize + this.mInventory[2].stackSize);
+            }
+        }
+        if (this.mOutputItem2 != null) {
+            if (this.mInventory[3] == null) {
+                this.mInventory[3] = GT_Utility.copy(new Object[]{this.mOutputItem2});
+            } else if (GT_Utility.areStacksEqual(this.mInventory[3], this.mOutputItem2)) {
+                this.mInventory[3].stackSize = Math.min(this.mOutputItem2.getMaxStackSize(), this.mOutputItem2.stackSize + this.mInventory[3].stackSize);
+            }
+        }
+    }
+
+    private boolean spaceForOutput(ItemStack aStack1, ItemStack aStack2) {
+        if (((this.mInventory[2] == null) || (aStack1 == null) || ((this.mInventory[2].stackSize + aStack1.stackSize <= this.mInventory[2].getMaxStackSize()) && (GT_Utility.areStacksEqual(this.mInventory[2], aStack1)))) && (
+                (this.mInventory[3] == null) || (aStack2 == null) || ((this.mInventory[3].stackSize + aStack2.stackSize <= this.mInventory[3].getMaxStackSize()) && (GT_Utility.areStacksEqual(this.mInventory[3], aStack2))))) {
+            return true;
+        }
+        return false;
+    }
+
+    private boolean checkRecipe() {
+        if (!this.mMachine) {
+            return false;
+        }
+        if ((this.mInventory[0] != null) && (this.mInventory[1] != null) && (this.mInventory[0].stackSize >= 1)) {
+            if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[0], "dustIron")) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[0], "ingotIron"))) {
+                if ((this.mInventory[1].getItem() == Items.coal) && (this.mInventory[1].stackSize >= 4) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 4*3);
+                    this.mMaxProgresstime = 36000;
+                    return true;
+                }
+                if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "fuelCoke")) && (this.mInventory[1].stackSize >= 2) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 2*3);
+                    this.mMaxProgresstime = 4800*5;
+                    return true;
+                }
+                if ((this.mInventory[0].stackSize >= 9) && ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCoal")) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCharcoal"))) && (this.mInventory[1].stackSize >= 4) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 9L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 9);
+                    getBaseMetaTileEntity().decrStackSize(1, 4*3);
+                    this.mMaxProgresstime = 64800*5;
+                    return true;
+                }
+            } else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[0], "dustSteel")) {
+                if ((this.mInventory[1].getItem() == Items.coal) && (this.mInventory[1].stackSize >= 2) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 2*3);
+                    this.mMaxProgresstime = 3600*5;
+                    return true;
+                }
+                if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "fuelCoke")) && (this.mInventory[1].stackSize >= 1) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 2L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 1*3);
+                    this.mMaxProgresstime = 2400*5;
+                    return true;
+                }
+                if ((this.mInventory[0].stackSize >= 9) && ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCoal")) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCharcoal"))) && (this.mInventory[1].stackSize >= 2) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 9L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 2L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 9);
+                    getBaseMetaTileEntity().decrStackSize(1, 2*3);
+                    this.mMaxProgresstime = 32400*5;
+                    return true;
+                }
+            } else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[0], "blockIron")) {
+                if ((this.mInventory[1].getItem() == Items.coal) && (this.mInventory[1].stackSize >= 36) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 9L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 64);
+                    this.mMaxProgresstime = 64800*9;
+                    return true;
+                }
+                if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "fuelCoke")) && (this.mInventory[1].stackSize >= 18) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 9L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ash, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 18*3);
+                    this.mMaxProgresstime = 43200*5;
+                    return true;
+                }
+                if (((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCoal")) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[1], "blockCharcoal"))) && (this.mInventory[1].stackSize >= 4) && (spaceForOutput(this.mOutputItem1 = GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 9L), this.mOutputItem2 = GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 4L)))) {
+                    getBaseMetaTileEntity().decrStackSize(0, 1);
+                    getBaseMetaTileEntity().decrStackSize(1, 4*3);
+                    this.mMaxProgresstime = 64800*5;
+                    return true;
+                }
+            }
+        }
+        this.mOutputItem1 = null;
+        this.mOutputItem2 = null;
+        return false;
+    }
+
+    @Override
+	public boolean isGivingInformation() {
+        return false;
+    }
+
+    @Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        return aIndex > 1;
+    }
+
+    @Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+        if (aIndex < 2) {
+        }
+        return !GT_Utility.areStacksEqual(aStack, this.mInventory[0]);
+    }
+
+    @Override
+	public byte getTileEntityBaseType() {
+        return 0;
+    }
+}