cherry pick: from Techlone

7cb51ae461815bfd767aa0bf64f8ff075de5624d
c5402ee38998cc086ceb36fbce6c54aba6d9d79c
7c48590a49242bb26eddafa26d2cd7b4ce3546d8
75a33be210cda273ef9e6cc9cbbf739dd913907e
b187410005771f1762f3bb5c94c0c5cd26dd06db

8 files changed, 655 insertions, 366 deletions

diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Casings4.java b/src/main/java/gregtech/common/blocks/GT_Block_Casings4.java
index bbf489c6aa..81daf2c04a 100644
--- a/src/main/java/gregtech/common/blocks/GT_Block_Casings4.java
+++ b/src/main/java/gregtech/common/blocks/GT_Block_Casings4.java
@@ -37,6 +37,7 @@ public class GT_Block_Casings4
         GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".11.name", "Titanium Turbine Casing");
         GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".12.name", "Tungstensteel Turbine Casing");
         GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".13.name", "Engine Intake Casing");
+        GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".14.name", "Mining Osmiridium Casing");
 
         ItemList.Casing_RobustTungstenSteel.set(new ItemStack(this, 1, 0));
         ItemList.Casing_CleanStainlessSteel.set(new ItemStack(this, 1, 1));
@@ -52,6 +53,7 @@ public class GT_Block_Casings4
         ItemList.Casing_Turbine2.set(new ItemStack(this, 1, 11));
         ItemList.Casing_Turbine3.set(new ItemStack(this, 1, 12));
         ItemList.Casing_EngineIntake.set(new ItemStack(this, 1, 13));
+        ItemList.Casing_MiningOsmiridium.set(new ItemStack(this, 1, 14));
     }
 
     public IIcon getIcon(int aSide, int aMeta) {
@@ -85,7 +87,7 @@ public class GT_Block_Casings4
             case 13:
                 return Textures.BlockIcons.MACHINE_CASING_ENGINE_INTAKE.getIcon();
             case 14:
-                return Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon();
+                return Textures.BlockIcons.MACHINE_CASING_MINING_OSMIRIDIUM.getIcon();
             case 15:
                 return Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon();
         }
diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Machines.java b/src/main/java/gregtech/common/blocks/GT_Item_Machines.java
index 97cd810ec1..65008aaabe 100644
--- a/src/main/java/gregtech/common/blocks/GT_Item_Machines.java
+++ b/src/main/java/gregtech/common/blocks/GT_Item_Machines.java
@@ -33,46 +33,34 @@ public class GT_Item_Machines
             if ((tDamage <= 0) || (tDamage >= GregTech_API.METATILEENTITIES.length)) {

                 return;

             }

-            if (tDamage == 0) {

-                aList.add("WARNING, THE EXISTENCE OF THIS ITEM IS A BUG");

-                aList.add("IF YOU GOT IT IN SURVIVAL THEN PLEASE REPORT IT");

-            } else {

-                TileEntity temp = GregTech_API.sBlockMachines.createTileEntity(aPlayer == null ? GT_Values.DW : aPlayer.worldObj, GregTech_API.METATILEENTITIES[tDamage] == null ? 0 : GregTech_API.METATILEENTITIES[tDamage].getTileEntityBaseType());

-                if (temp != null) {

-                    temp.setWorldObj(aPlayer == null ? GT_Values.DW : aPlayer.worldObj);

-                    temp.xCoord = 0;

-                    temp.yCoord = 0;

-                    temp.zCoord = 0;

-                    if ((temp instanceof IGregTechTileEntity)) {

-                        IGregTechTileEntity tTileEntity = (IGregTechTileEntity) temp;

-                        tTileEntity.setInitialValuesAsNBT(new NBTTagCompound(), (short) tDamage);

-                        if (tTileEntity.getDescription() != null) {

-                            int i = 0;

+

+            if (GregTech_API.METATILEENTITIES[tDamage] != null) {

+                IGregTechTileEntity tTileEntity = GregTech_API.METATILEENTITIES[tDamage].getBaseMetaTileEntity();

+                if (tTileEntity.getDescription() != null) {

+                    int i = 0;

                     for (String tDescription : tTileEntity.getDescription()) {

                         if (GT_Utility.isStringValid(tDescription)) {

-                        	if(tDescription.contains("%%%")){

-                        		String[] tString = tDescription.split("%%%");

-                        		if(tString.length>=2){

+                            if(tDescription.contains("%%%")){

+                                String[] tString = tDescription.split("%%%");

+                                if(tString.length>=2){

                                     aList.add(GT_LanguageManager.addStringLocalization("TileEntity_DESCRIPTION_" + tDamage + "_Index_" + i++, tString[0], !GregTech_API.sPostloadFinished )+" "+tString[1]);

-                        		}

-                        	}else{String tTranslated = GT_LanguageManager.addStringLocalization("TileEntity_DESCRIPTION_" + tDamage + "_Index_" + i++, tDescription, !GregTech_API.sPostloadFinished );

-                            aList.add(tTranslated.equals("") ? tDescription : tTranslated);}

+                                }

+                            }else{String tTranslated = GT_LanguageManager.addStringLocalization("TileEntity_DESCRIPTION_" + tDamage + "_Index_" + i++, tDescription, !GregTech_API.sPostloadFinished );

+                                aList.add(tTranslated.equals("") ? tDescription : tTranslated);}

                         }else i++;

                     }

-                        }

-                        if (tTileEntity.getEUCapacity() > 0L) {

-                            if (tTileEntity.getInputVoltage() > 0L) {

-                                aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_IN", "Voltage IN: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.GREEN + tTileEntity.getInputVoltage() + " (" + GT_Values.VN[GT_Utility.getTier(tTileEntity.getInputVoltage())] + ")" + EnumChatFormatting.GRAY);

-                            }

-                            if (tTileEntity.getOutputVoltage() > 0L) {

-                                aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_OUT", "Voltage OUT: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.GREEN + tTileEntity.getOutputVoltage() + " (" + GT_Values.VN[GT_Utility.getTier(tTileEntity.getOutputVoltage())] + ")" + EnumChatFormatting.GRAY);

-                            }

-                            if (tTileEntity.getOutputAmperage() > 1L) {

-                                aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_AMOUNT", "Amperage: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.YELLOW + tTileEntity.getOutputAmperage() + EnumChatFormatting.GRAY);

-                            }

-                            aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_STORE", "EU Capacity: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.BLUE + tTileEntity.getEUCapacity() + EnumChatFormatting.GRAY);

-                        }

+                }

+                if (tTileEntity.getEUCapacity() > 0L) {

+                    if (tTileEntity.getInputVoltage() > 0L) {

+                        aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_IN", "Voltage IN: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.GREEN + tTileEntity.getInputVoltage() + " (" + GT_Values.VN[GT_Utility.getTier(tTileEntity.getInputVoltage())] + ")" + EnumChatFormatting.GRAY);

+                    }

+                    if (tTileEntity.getOutputVoltage() > 0L) {

+                        aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_OUT", "Voltage OUT: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.GREEN + tTileEntity.getOutputVoltage() + " (" + GT_Values.VN[GT_Utility.getTier(tTileEntity.getOutputVoltage())] + ")" + EnumChatFormatting.GRAY);

+                    }

+                    if (tTileEntity.getOutputAmperage() > 1L) {

+                        aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_AMOUNT", "Amperage: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.YELLOW + tTileEntity.getOutputAmperage() + EnumChatFormatting.GRAY);

                     }

+                    aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_STORE", "Capacity: ", !GregTech_API.sPostloadFinished ) + EnumChatFormatting.BLUE + tTileEntity.getEUCapacity() + EnumChatFormatting.GRAY);

                 }

             }

             NBTTagCompound aNBT = aStack.getTagCompound();

@@ -149,4 +137,4 @@ public class GT_Item_Machines
         }

         return true;

     }

-}

+}
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AdvMiner2.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AdvMiner2.java
deleted file mode 100644
index 7557e9af8c..0000000000
--- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AdvMiner2.java
+++ /dev/null
@@ -1,330 +0,0 @@
-package gregtech.common.tileentities.machines.multi;
-
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ItemList;
-import gregtech.api.enums.Materials;
-import gregtech.api.enums.OrePrefixes;
-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.objects.ItemData;
-import gregtech.api.util.GT_ModHandler;
-import gregtech.api.util.GT_OreDictUnificator;
-import gregtech.api.util.GT_Recipe;
-import gregtech.api.util.GT_Utility;
-import gregtech.common.blocks.GT_Block_Ores_Abstract;
-import gregtech.common.blocks.GT_TileEntity_Ores;
-import net.minecraft.block.Block;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.init.Blocks;
-import net.minecraft.item.ItemStack;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.world.ChunkPosition;
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidStack;
-
-import java.util.ArrayList;
-
-public class GT_MetaTileEntity_AdvMiner2 extends GT_MetaTileEntity_MultiBlockBase {
-
-    private final ArrayList<ChunkPosition> mMineList = new ArrayList();
-
-    public GT_MetaTileEntity_AdvMiner2(int aID, String aName, String aNameRegional) {
-        super(aID, aName, aNameRegional);
-    }
-
-    public GT_MetaTileEntity_AdvMiner2(String aName) {
-        super(aName);
-    }
-
-    public String[] getDescription() {
-        return new String[]{
-                "Controller Block for the Advanced Miner II",
-                "Size(WxHxD): 3x7x3, Controller (Front middle bottom)",
-                "3x1x3 Base of Solid Steel Casings",
-                "1x3x1 Solid Steel Casing pillar (Center of base)",
-                "1x3x1 Steel Frame Boxes (Each Steel pillar side and on top)",
-                "1x Input Hatch (Any bottom layer casing)",
-                "1x Output Bus (Any bottom layer casing)",
-                "1x Maintenance Hatch (Any bottom layer casing)",
-                "1x MV+ Energy Hatch (Any bottom layer casing)"};
-    }
-
-    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[16], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ADVMINER2_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ADVMINER2)};
-        }
-        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[16]};
-    }
-
-    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
-        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "AdvMiner2.png");
-    }
-
-    @Override
-    public boolean checkRecipe(ItemStack aStack) {
-        if (mInventory[1] == null || (mInventory[1].isItemEqual(GT_ModHandler.getIC2Item("miningPipe", 1L)) && mInventory[1].stackSize < mInventory[1].getMaxStackSize())) {
-            ArrayList<ItemStack> tItems = getStoredInputs();
-            for (ItemStack tStack : tItems) {
-                if (tStack.isItemEqual(GT_ModHandler.getIC2Item("miningPipe", 1L))) {
-                    tStack.stackSize--;
-                    if (tStack.stackSize < 1) {
-                        tStack = null;
-                    }
-                    if (mInventory[1] == null) {
-                        mInventory[1] = GT_ModHandler.getIC2Item("miningPipe", 1L);
-                    } else {
-                        mInventory[1].stackSize++;
-                    }
-                }
-
-            }
-        }
-        if (mInputHatches == null || mInputHatches.get(0).mFluid == null || mInputHatches.get(0).mFluid.getFluid().getID() != ItemList.sDrillingFluid.getID()) {
-            return false;
-        }
-        FluidStack tFluid = mInputHatches.get(0).mFluid.copy();
-        if (tFluid == null) {
-            return false;
-        }
-        if (tFluid.amount < 100) {
-            return false;
-        }
-        tFluid.amount = 100;
-        depleteInput(tFluid);
-        long tVoltage = getMaxInputVoltage();
-        if (getBaseMetaTileEntity().getRandomNumber(20) == 0) {
-            if (mMineList.isEmpty()) {
-                int yLevel = getYOfPumpHead();
-                for (int i = -48; i < 49; i++) {
-                    for (int f = -48; f < 49; f++) {
-                        Block tBlock = getBaseMetaTileEntity().getBlockOffset(i, yLevel - getBaseMetaTileEntity().getYCoord(), f);
-                        int tMetaID = getBaseMetaTileEntity().getMetaIDOffset(i, yLevel - getBaseMetaTileEntity().getYCoord(), f);
-                        if (tBlock instanceof GT_Block_Ores_Abstract) {
-                            TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityOffset(i, yLevel - getBaseMetaTileEntity().getYCoord(), f);
-                            if ((tTileEntity!=null) && (tTileEntity instanceof GT_TileEntity_Ores) && ((GT_TileEntity_Ores) tTileEntity).mNatural && !mMineList.contains(new ChunkPosition(i, yLevel - getBaseMetaTileEntity().getYCoord(), f))) {
-                                mMineList.add(new ChunkPosition(i, yLevel - getBaseMetaTileEntity().getYCoord(), f));
-                            }
-                        }
-                        else {
-                            ItemData tAssotiation = GT_OreDictUnificator.getAssociation(new ItemStack(tBlock, 1, tMetaID));
-                            if ((tAssotiation != null) && (tAssotiation.mPrefix.toString().startsWith("ore"))) {
-                                ChunkPosition cp = new ChunkPosition(i, yLevel - getBaseMetaTileEntity().getYCoord(), f);
-                                if (!mMineList.contains(cp)) {
-                                    mMineList.add(cp);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            if (mMineList.isEmpty()) {
-                if(getBaseMetaTileEntity().getBlockOffset(ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX, getYOfPumpHead() - 1 - getBaseMetaTileEntity().getYCoord(), ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ) != Blocks.bedrock){
-                    if (mEnergyHatches.size() > 0 && mEnergyHatches.get(0).getEUVar() > (512 + getMaxInputVoltage() * 4)) {
-                        if (!moveOneDown())
-                            return false;
-                    }
-                }else{
-                    stopMachine();
-                    return false;
-                }
-            }
-            ArrayList<ItemStack> tDrops = new ArrayList();
-            Block tMineBlock = null;
-            ChunkPosition mle = null;
-            int posX, posY, posZ, offX, offY, offZ;
-            while ((tMineBlock==null || tMineBlock == Blocks.air) && !mMineList.isEmpty()) {
-                mle = mMineList.get(0);
-                mMineList.remove(0);
-                tMineBlock = getBaseMetaTileEntity().getBlockOffset(mle.chunkPosX, mle.chunkPosY, mle.chunkPosZ);
-            }
-            
-            if (tMineBlock!=null && tMineBlock!=Blocks.air) {
-                posX = mle.chunkPosX + getBaseMetaTileEntity().getXCoord();
-                posY = mle.chunkPosY + getBaseMetaTileEntity().getYCoord();
-                posZ = mle.chunkPosZ + getBaseMetaTileEntity().getZCoord();
-                offX = mle.chunkPosX;
-                offY = mle.chunkPosY;
-                offZ = mle.chunkPosZ;
-
-                int metadata = getBaseMetaTileEntity().getMetaIDOffset(offX, offY, offZ);
-                boolean silkTouch = tMineBlock.canSilkHarvest(getBaseMetaTileEntity().getWorld(), null, posX, posY, posZ, metadata);
-                if (silkTouch){
-                    ItemStack IS = new ItemStack(tMineBlock);
-                    IS.setItemDamage(metadata);
-                    IS.stackSize=1;
-                    tDrops.add(IS);
-                }
-                else{
-                    tDrops = tMineBlock.getDrops(getBaseMetaTileEntity().getWorld(), posX, posY, posZ, metadata, 1);
-                }
-
-                getBaseMetaTileEntity().getWorld().setBlockToAir(posX, posY, posZ);
-                if (!tDrops.isEmpty()) {
-                    ItemData tData = GT_OreDictUnificator.getItemData(tDrops.get(0).copy());
-                    if (tData.mPrefix != OrePrefixes.crushed && tData.mMaterial.mMaterial != Materials.Oilsands) {
-
-                        GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.findRecipe(getBaseMetaTileEntity(), false, tVoltage, null, tDrops.get(0).copy());
-                        if (tRecipe != null) {
-                            this.mOutputItems = new ItemStack[tRecipe.mOutputs.length];
-                            for (int g = 0; g < mOutputItems.length; g++) {
-                                mOutputItems[g] = tRecipe.mOutputs[g].copy();
-                                if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(g)) {
-                                    mOutputItems[g].stackSize *= getBaseMetaTileEntity().getRandomNumber(4) + 1;
-                                }
-                            }
-                        } else {
-                            this.mOutputItems = new ItemStack[tDrops.size()];
-                            for (int g = 0; g < mOutputItems.length; g++) {
-                                mOutputItems[g] = tDrops.get(g).copy();
-                            }
-                        }
-                    } else {
-                        this.mOutputItems = null;
-                        ItemStack[] tStack = new ItemStack[tDrops.size()];
-                        for (int j = 0; j < tDrops.size(); j++) {
-                            tStack[j] = tDrops.get(j).copy();
-                            tStack[j].stackSize = tStack[j].stackSize * (getBaseMetaTileEntity().getRandomNumber(4) + 1);
-                        }
-                        mOutputItems = tStack;
-                    }
-                }
-
-            }
-        }
-        calculateOverclockedNessMulti(48, 24, 1, tVoltage);
-        //In case recipe is too OP for that machine
-        if (mMaxProgresstime == Integer.MAX_VALUE - 1 && mEUt == Integer.MAX_VALUE - 1)
-            return false;
-        this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
-        this.mEfficiencyIncrease = 10000;
-        if (this.mEUt > 0) {
-            this.mEUt = (-this.mEUt);
-        }
-        return true;
-    }
-
-    private boolean moveOneDown() {
-        if ((this.mInventory[1] == null) || (this.mInventory[1].stackSize < 1)
-                || (!GT_Utility.areStacksEqual(this.mInventory[1], GT_ModHandler.getIC2Item("miningPipe", 1L)))) {
-        	stopMachine();
-            return false;
-        }
-        int xDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX;
-        int zDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ;
-        int yHead = getYOfPumpHead();
-        if (yHead <= 0) {
-        	stopMachine();
-            return false;
-        }
-        if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord() + xDir, yHead - 1, getBaseMetaTileEntity().getZCoord() + zDir) == Blocks.bedrock) {
-        	stopMachine();
-            return false;
-        }
-        if (!(getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord() + xDir, yHead - 1, getBaseMetaTileEntity().getZCoord() + zDir, GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))))) {
-            stopMachine();
-        	return false;
-        }
-        if (yHead != getBaseMetaTileEntity().getYCoord()) {
-            getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord() + xDir, yHead, getBaseMetaTileEntity().getZCoord() + zDir, GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipe", 1L)));
-        }
-        getBaseMetaTileEntity().decrStackSize(1, 1);
-        return true;
-    }
-
-    private int getYOfPumpHead() {
-        int xDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX;
-        int zDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ;
-        int y = getBaseMetaTileEntity().getYCoord() - 1;
-        while (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord() + xDir, y, getBaseMetaTileEntity().getZCoord() + zDir) == GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipe", 1L))) {
-            y--;
-        }
-        if (y == getBaseMetaTileEntity().getYCoord() - 1) {
-            if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord() + xDir, y, getBaseMetaTileEntity().getZCoord() + zDir) != GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))) {
-                return y + 1;
-            }
-        } else if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord() + xDir, y, getBaseMetaTileEntity().getZCoord() + zDir) != GT_Utility
-                .getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L)) && this.mInventory[1] != null && this.mInventory[1].stackSize > 0 && GT_Utility.areStacksEqual(this.mInventory[1], GT_ModHandler.getIC2Item("miningPipe", 1L))) {
-            getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord() + xDir, y, getBaseMetaTileEntity().getZCoord() + zDir,
-                    GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L)));
-            getBaseMetaTileEntity().decrStackSize(0, 1);
-        }
-        return y;
-    }
-
-    @Override
-    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
-        int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;
-        int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ;
-        for (int i = -1; i < 2; i++) {
-            for (int j = -1; j < 2; j++) {
-                if ((xDir + i != 0) || (zDir + j != 0)) {
-                    IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0, zDir + j);
-                    if ((!addMaintenanceToMachineList(tTileEntity, 16)) && (!addInputToMachineList(tTileEntity, 16)) && (!addOutputToMachineList(tTileEntity, 16)) && (!addEnergyInputToMachineList(tTileEntity, 16))) {
-                        if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j) != GregTech_API.sBlockCasings2) {
-                            return false;
-                        }
-                        if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j) != 0) {
-                            return false;
-                        }
-                    }
-                }
-            }
-        }
-        for (int y = 1; y < 4; y++) {
-            if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir) != GregTech_API.sBlockCasings2) {
-                return false;
-            }
-            if (aBaseMetaTileEntity.getBlockOffset(xDir + 1, y, zDir) != GregTech_API.sBlockMachines) {
-                return false;
-            }
-            if (aBaseMetaTileEntity.getBlockOffset(xDir - 1, y, zDir) != GregTech_API.sBlockMachines) {
-                return false;
-            }
-            if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir + 1) != GregTech_API.sBlockMachines) {
-                return false;
-            }
-            if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir - 1) != GregTech_API.sBlockMachines) {
-                return false;
-            }
-            if (aBaseMetaTileEntity.getBlockOffset(xDir, y + 3, zDir) != GregTech_API.sBlockMachines) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    @Override
-    public boolean isCorrectMachinePart(ItemStack aStack) {
-        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 boolean explodesOnComponentBreak(ItemStack aStack) {
-        return false;
-    }
-
-    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GT_MetaTileEntity_AdvMiner2(this.mName);
-    }
-
-}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant1.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant1.java
new file mode 100644
index 0000000000..ae88ba732a
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant1.java
@@ -0,0 +1,51 @@
+package gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class GT_MetaTileEntity_OreDrillingPlant1 extends GT_MetaTileEntity_OreDrillingPlantBase {
+    public GT_MetaTileEntity_OreDrillingPlant1(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_OreDrillingPlant1(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return getDescriptionInternal("I");
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_OreDrillingPlant1(mName);
+    }
+
+    @Override
+    protected ItemList getCasingBlockItem() {
+        return ItemList.Casing_SolidSteel;
+    }
+
+    @Override
+    protected Materials getFrameMaterial() {
+        return Materials.Steel;
+    }
+
+    @Override
+    protected int getCasingTextureIndex() {
+        return 16;
+    }
+
+    @Override
+    protected int getRadiusInChunks() {
+        return 3;
+    }
+
+    @Override
+    protected int getMinTier() {
+        return 2;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant2.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant2.java
new file mode 100644
index 0000000000..2b161fe471
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant2.java
@@ -0,0 +1,51 @@
+package gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class GT_MetaTileEntity_OreDrillingPlant2 extends GT_MetaTileEntity_OreDrillingPlantBase {
+    public GT_MetaTileEntity_OreDrillingPlant2(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_OreDrillingPlant2(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return getDescriptionInternal("II");
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_OreDrillingPlant2(mName);
+    }
+
+    @Override
+    protected ItemList getCasingBlockItem() {
+        return ItemList.Casing_StableTitanium;
+    }
+
+    @Override
+    protected Materials getFrameMaterial() {
+        return Materials.Titanium;
+    }
+
+    @Override
+    protected int getCasingTextureIndex() {
+        return 50;
+    }
+
+    @Override
+    protected int getRadiusInChunks() {
+        return 4;
+    }
+
+    @Override
+    protected int getMinTier() {
+        return 3;
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant3.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant3.java
new file mode 100644
index 0000000000..1be6391f7a
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant3.java
@@ -0,0 +1,51 @@
+package gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class GT_MetaTileEntity_OreDrillingPlant3 extends GT_MetaTileEntity_OreDrillingPlantBase {
+    public GT_MetaTileEntity_OreDrillingPlant3(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_OreDrillingPlant3(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return getDescriptionInternal("III");
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_OreDrillingPlant3(mName);
+    }
+
+    @Override
+    protected ItemList getCasingBlockItem() {
+        return ItemList.Casing_RobustTungstenSteel;
+    }
+
+    @Override
+    protected Materials getFrameMaterial() {
+        return Materials.TungstenSteel;
+    }
+
+    @Override
+    protected int getCasingTextureIndex() {
+        return 48;
+    }
+
+    @Override
+    protected int getRadiusInChunks() {
+        return 6;
+    }
+
+    @Override
+    protected int getMinTier() {
+        return 4;
+    }
+}
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant4.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant4.java
new file mode 100644
index 0000000000..c3b3c9ea64
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlant4.java
@@ -0,0 +1,51 @@
+package gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class GT_MetaTileEntity_OreDrillingPlant4 extends GT_MetaTileEntity_OreDrillingPlantBase {
+    public GT_MetaTileEntity_OreDrillingPlant4(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public GT_MetaTileEntity_OreDrillingPlant4(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public String[] getDescription() {
+        return getDescriptionInternal("IV");
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GT_MetaTileEntity_OreDrillingPlant4(mName);
+    }
+
+    @Override
+    protected ItemList getCasingBlockItem() {
+        return ItemList.Casing_MiningOsmiridium;
+    }
+
+    @Override
+    protected Materials getFrameMaterial() {
+        return Materials.Osmiridium;
+    }
+
+    @Override
+    protected int getCasingTextureIndex() {
+        return 62;
+    }
+
+    @Override
+    protected int getRadiusInChunks() {
+        return 9;
+    }
+
+    @Override
+    protected int getMinTier() {
+        return 5;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlantBase.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlantBase.java
new file mode 100644
index 0000000000..0f720b4d4a
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OreDrillingPlantBase.java
@@ -0,0 +1,425 @@
+package gregtech.common.tileentities.machines.multi;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.objects.ItemData;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.blocks.GT_Block_Ores_Abstract;
+import gregtech.common.blocks.GT_TileEntity_Ores;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.ChunkPosition;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.ArrayList;
+
+import static gregtech.api.enums.GT_Values.*;
+
+public abstract class GT_MetaTileEntity_OreDrillingPlantBase extends GT_MetaTileEntity_MultiBlockBase {
+    private static final ItemStack miningPipe = GT_ModHandler.getIC2Item("miningPipe", 0);
+    private static final ItemStack miningPipeTip = GT_ModHandler.getIC2Item("miningPipeTip", 0);
+    private static final Block miningPipeBlock = GT_Utility.getBlockFromStack(miningPipe);
+    private static final Block miningPipeTipBlock = GT_Utility.getBlockFromStack(miningPipeTip);
+
+    private final ArrayList<ChunkPosition> oreBlockPositions = new ArrayList<>();
+
+    private Block casingBlock;
+    private int casingMeta;
+    private int frameMeta;
+    private int casingTextureIndex;
+
+    private ForgeDirection back;
+    private int xDrill, yDrill, zDrill, xCenter, zCenter, yHead;
+
+    private boolean isPickingPipes;
+
+    public GT_MetaTileEntity_OreDrillingPlantBase(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+        initFields();
+    }
+
+    public GT_MetaTileEntity_OreDrillingPlantBase(String aName) {
+        super(aName);
+        initFields();
+    }
+
+    private void initFields() {
+        casingBlock = getCasingBlockItem().getBlock();
+        casingMeta = getCasingBlockItem().get(0).getItemDamage();
+        int frameId = 4096 + getFrameMaterial().mMetaItemSubID;
+        frameMeta = GregTech_API.METATILEENTITIES[frameId] != null ? GregTech_API.METATILEENTITIES[frameId].getTileEntityBaseType() : W;
+        casingTextureIndex = getCasingTextureIndex();
+        isPickingPipes = false;
+    }
+
+    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[casingTextureIndex],new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ORE_DRILL_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ORE_DRILL)};
+        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[casingTextureIndex]};
+    }
+
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "OreDrillingPlant.png");
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setBoolean("isPickingPipe", isPickingPipes);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        isPickingPipes = aNBT.getBoolean("isPickingPipes");
+    }
+
+    @Override
+    public boolean checkRecipe(ItemStack aStack) {
+        setElectricityStats();
+        int oldYHead = yHead;
+        if (!checkPipesAndSetYHead() || !isEnergyEnough()) {
+            stopMachine();
+            return false;
+        }
+        if (yHead != oldYHead) oreBlockPositions.clear();
+        if (isPickingPipes) {
+            if (tryPickPipe()) {
+                mOutputItems = new ItemStack[] {GT_Utility.copyAmount(1, miningPipe)};
+                return true;
+            } else {
+                isPickingPipes = false;
+                stopMachine();
+                return false;
+            }
+        }
+
+        putMiningPipesFromInputsInController();
+        if (!tryConsumeDrillingFluid()) return false;
+
+        fillMineListIfEmpty();
+        if (oreBlockPositions.isEmpty()) {
+            if (!tryLowerPipe()) {
+                isPickingPipes = true;
+                return true;
+            }
+            //new layer - fill again
+            fillMineListIfEmpty();
+        }
+
+        ChunkPosition oreBlockPos = null;
+        Block oreBlock = null;
+
+        while ((oreBlock == null || oreBlock == Blocks.air) && !oreBlockPositions.isEmpty()) {
+            oreBlockPos = oreBlockPositions.remove(0);
+            oreBlock = getBaseMetaTileEntity().getBlock(oreBlockPos.chunkPosX, oreBlockPos.chunkPosY, oreBlockPos.chunkPosZ);
+        }
+
+        if (oreBlock != null && oreBlock != Blocks.air) {
+            ArrayList<ItemStack> oreBlockDrops = getBlockDrops(oreBlock, oreBlockPos.chunkPosX, oreBlockPos.chunkPosY, oreBlockPos.chunkPosZ);
+            getBaseMetaTileEntity().getWorld().setBlockToAir(oreBlockPos.chunkPosX, oreBlockPos.chunkPosY, oreBlockPos.chunkPosZ);
+            mOutputItems = getOutputByDrops(oreBlockDrops);
+        }
+
+        return true;
+    }
+
+    private boolean isEnergyEnough() {
+        long requiredEnergy = 512 + getMaxInputVoltage() * 4;
+        for (GT_MetaTileEntity_Hatch_Energy energyHatch : mEnergyHatches) {
+            requiredEnergy -= energyHatch.getEUVar();
+            if (requiredEnergy <= 0) return true;
+        }
+        return false;
+    }
+
+    private boolean tryPickPipe() {
+        if (yHead == yDrill) return false;
+        if (checkBlockAndMeta(xCenter, yHead + 1, zCenter, miningPipeBlock, W))
+            getBaseMetaTileEntity().getWorld().setBlock(xCenter, yHead + 1, zCenter, miningPipeTipBlock);
+        getBaseMetaTileEntity().getWorld().setBlockToAir(xCenter, yHead, zCenter);
+        return true;
+    }
+
+    private void setElectricityStats() {
+        this.mEfficiency = getCurrentEfficiency(null);
+        this.mEfficiencyIncrease = 10000;
+        //T1 = 12; T2 = 48; T3 = 192; T4 = 768
+        this.mEUt = 3 * (1 << (getMinTier() << 1));
+        //T1 = 960; T2 = 480; T3 = 240; T4 = 120
+        this.mMaxProgresstime = (isPickingPipes ? 80 : 1920) / (1 << getMinTier());
+
+        long voltage = getMaxInputVoltage();
+        long overclockEu = V[Math.max(1, GT_Utility.getTier(voltage)) - 1];
+        while (this.mEUt <= overclockEu) {
+            this.mEUt *= 4;
+            this.mMaxProgresstime /= 2;
+        }
+
+        this.mEUt = -this.mEUt;
+        this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+    }
+
+    private ItemStack[] getOutputByDrops(ArrayList<ItemStack> oreBlockDrops) {
+        long voltage = getMaxInputVoltage();
+        ArrayList<ItemStack> outputItems = new ArrayList<>();
+        while (!oreBlockDrops.isEmpty()) {
+            ItemStack currentItem = oreBlockDrops.remove(0).copy();
+            if (!doUseMaceratorRecipe(currentItem)) {
+                multiplyStackSize(currentItem);
+                outputItems.add(currentItem);
+                continue;
+            }
+
+            GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.findRecipe(getBaseMetaTileEntity(), false, voltage, null, currentItem);
+            if (tRecipe == null) {
+                outputItems.add(currentItem);
+                continue;
+            }
+
+            for (int i = 0; i < tRecipe.mOutputs.length; i++) {
+                ItemStack recipeOutput = tRecipe.mOutputs[i].copy();
+                if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(i))
+                    multiplyStackSize(recipeOutput);
+                outputItems.add(recipeOutput);
+            }
+        }
+        return outputItems.toArray(new ItemStack[0]);
+    }
+
+    private boolean doUseMaceratorRecipe(ItemStack currentItem) {
+        ItemData itemData = GT_OreDictUnificator.getItemData(currentItem);
+        return itemData == null
+                || itemData.mPrefix != OrePrefixes.crushed
+                && itemData.mPrefix != OrePrefixes.dustImpure
+                && itemData.mPrefix != OrePrefixes.dust
+                && itemData.mMaterial.mMaterial != Materials.Oilsands;
+    }
+
+    private void multiplyStackSize(ItemStack itemStack) {
+        itemStack.stackSize *= getBaseMetaTileEntity().getRandomNumber(4) + 1;
+    }
+
+    private ArrayList<ItemStack> getBlockDrops(final Block oreBlock, int posX, int posY, int posZ) {
+        final int blockMeta = getBaseMetaTileEntity().getMetaID(posX, posY, posZ);
+        if (oreBlock.canSilkHarvest(getBaseMetaTileEntity().getWorld(), null, posX, posY, posZ, blockMeta)) {
+            return new ArrayList<ItemStack>() {{
+                add(new ItemStack(oreBlock, 1, blockMeta));
+            }};
+        } else return oreBlock.getDrops(getBaseMetaTileEntity().getWorld(), posX, posY, posZ, blockMeta, 1);
+    }
+
+    private boolean tryConsumeDrillingFluid() {
+        return depleteInput(new FluidStack(ItemList.sDrillingFluid, 2000));
+    }
+
+    private void putMiningPipesFromInputsInController() {
+        int maxPipes = miningPipe.getMaxStackSize();
+        if (isHasMiningPipes(maxPipes)) return;
+
+        ItemStack pipes = getStackInSlot(1);
+        for (ItemStack storedItem : getStoredInputs()) {
+            if (!storedItem.isItemEqual(miningPipe)) continue;
+
+            if (pipes == null) {
+                setInventorySlotContents(1, GT_Utility.copy(miningPipe));
+                pipes = getStackInSlot(1);
+            }
+
+            if (pipes.stackSize == maxPipes) break;
+
+            int needPipes = maxPipes - pipes.stackSize;
+            int transferPipes = storedItem.stackSize < needPipes ? storedItem.stackSize : needPipes;
+
+            pipes.stackSize += transferPipes;
+            storedItem.stackSize -= transferPipes;
+        }
+        updateSlots();
+    }
+
+    private void fillMineListIfEmpty() {
+        if (!oreBlockPositions.isEmpty()) return;
+
+        tryAddOreBlockToMineList(xCenter, yHead - 1, zCenter);
+        if (yHead == yDrill) return; //skip controller block layer
+
+        int radius = getRadiusInChunks() << 4;
+        for (int xOff = -radius; xOff <= radius; xOff++)
+            for (int zOff = -radius; zOff <= radius; zOff++)
+                tryAddOreBlockToMineList(xDrill + xOff, yHead, zDrill + zOff);
+    }
+
+    private void tryAddOreBlockToMineList(int x, int y, int z) {
+        Block block = getBaseMetaTileEntity().getBlock(x, y, z);
+        int blockMeta = getBaseMetaTileEntity().getMetaID(x, y, z);
+        ChunkPosition blockPos = new ChunkPosition(x, y, z);
+        if (oreBlockPositions.contains(blockPos)) return;
+        if (block instanceof GT_Block_Ores_Abstract) {
+            TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntity(x, y, z);
+            if (tTileEntity != null && tTileEntity instanceof GT_TileEntity_Ores && ((GT_TileEntity_Ores) tTileEntity).mNatural)
+                oreBlockPositions.add(blockPos);
+        } else {
+            ItemData association = GT_OreDictUnificator.getAssociation(new ItemStack(block, 1, blockMeta));
+            if (association != null && association.mPrefix.toString().startsWith("ore"))
+                oreBlockPositions.add(blockPos);
+        }
+    }
+
+    private boolean tryLowerPipe() {
+        if (!isHasMiningPipes()) return false;
+
+        if (yHead <= 0) return false;
+        if (checkBlockAndMeta(xCenter, yHead - 1, zCenter, Blocks.bedrock, W)) return false;
+
+        getBaseMetaTileEntity().getWorld().setBlock(xCenter, yHead - 1, zCenter, miningPipeTipBlock);
+        if (yHead != yDrill) getBaseMetaTileEntity().getWorld().setBlock(xCenter, yHead, zCenter, miningPipeBlock);
+
+        getBaseMetaTileEntity().decrStackSize(1, 1);
+        return true;
+    }
+
+    private boolean isHasMiningPipes() {
+        return isHasMiningPipes(1);
+    }
+
+    private boolean isHasMiningPipes(int minCount) {
+        ItemStack pipe = getStackInSlot(1);
+        return pipe != null && pipe.stackSize > minCount - 1 && pipe.isItemEqual(miningPipe);
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        updateCoordinates();
+        //check base layer
+        for (int xOff = -1 + back.offsetX; xOff <= 1 + back.offsetX; xOff++) {
+            for (int zOff = -1 + back.offsetZ; zOff <= 1 + back.offsetZ; zOff++) {
+                if (xOff == 0 && zOff == 0) continue;
+
+                IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xOff, 0, zOff);
+                if (!checkCasingBlock(xOff, 0, zOff)
+                        && !addMaintenanceToMachineList(tTileEntity, casingTextureIndex)
+                        && !addInputToMachineList(tTileEntity, casingTextureIndex)
+                        && !addOutputToMachineList(tTileEntity, casingTextureIndex)
+                        && !addEnergyInputToMachineList(tTileEntity, casingTextureIndex))
+                    return false;
+            }
+        }
+        if (mMaintenanceHatches.isEmpty() || mInputHatches.isEmpty() || mOutputBusses.isEmpty() || mEnergyHatches.isEmpty()) return false;
+        if (GT_Utility.getTier(getMaxInputVoltage()) < getMinTier()) return false;
+        //check tower
+        for (int yOff = 1; yOff < 4; yOff++) {
+            if (!checkCasingBlock(back.offsetX, yOff, back.offsetZ)
+                    || !checkFrameBlock(back.offsetX + 1, yOff, back.offsetZ)
+                    || !checkFrameBlock(back.offsetX - 1, yOff, back.offsetZ)
+                    || !checkFrameBlock(back.offsetX, yOff, back.offsetZ + 1)
+                    || !checkFrameBlock(back.offsetX, yOff, back.offsetZ - 1)
+                    || !checkFrameBlock(back.offsetX, yOff + 3, back.offsetZ))
+                return false;
+        }
+        return true;
+    }
+
+    private void updateCoordinates() {
+        xDrill = getBaseMetaTileEntity().getXCoord();
+        yDrill = getBaseMetaTileEntity().getYCoord();
+        zDrill = getBaseMetaTileEntity().getZCoord();
+        back = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing());
+        xCenter = xDrill + back.offsetX;
+        zCenter = zDrill + back.offsetZ;
+    }
+
+    private boolean checkPipesAndSetYHead() {
+        yHead = yDrill - 1;
+        while (checkBlockAndMeta(xCenter, yHead, zCenter, miningPipeBlock, W)) yHead--; //skip pipes
+        //is pipe tip OR is controller layer
+        if (checkBlockAndMeta(xCenter, yHead, zCenter, miningPipeTipBlock, W) || ++yHead == yDrill) return true;
+        //pipe column is broken - try fix
+        getBaseMetaTileEntity().getWorld().setBlock(xCenter, yHead, zCenter, miningPipeTipBlock);
+        return true;
+    }
+
+    private boolean checkCasingBlock(int xOff, int yOff, int zOff) {
+        return checkBlockAndMetaOffset(xOff, yOff, zOff, casingBlock, casingMeta);
+    }
+    //meta of frame is getTileEntityBaseType; frame should be checked using its drops (possible a high weight operation)
+    private boolean checkFrameBlock(int xOff, int yOff, int zOff) {
+        return checkBlockAndMetaOffset(xOff, yOff, zOff, GregTech_API.sBlockMachines, frameMeta);
+    }
+
+    private boolean checkBlockAndMetaOffset(int xOff, int yOff, int zOff, Block block, int meta) {
+        return checkBlockAndMeta(xDrill + xOff, yDrill + yOff, zDrill + zOff, block, meta);
+    }
+
+    private boolean checkBlockAndMeta(int x, int y, int z, Block block, int meta) {
+        return (meta == W || getBaseMetaTileEntity().getMetaID(x, y, z) == meta)
+                && getBaseMetaTileEntity().getBlock(x, y, z) == block;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        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 boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    protected abstract ItemList getCasingBlockItem();
+
+    protected abstract Materials getFrameMaterial();
+
+    protected abstract int getCasingTextureIndex();
+
+    protected abstract int getRadiusInChunks();
+
+    protected abstract int getMinTier();
+
+    protected String[] getDescriptionInternal(String tierSuffix) {
+        String casings = getCasingBlockItem().get(0).getDisplayName();
+        return new String[]{
+                "Controller Block for the Ore Drilling Plant " + (tierSuffix != null ? tierSuffix : ""),
+                "Size(WxHxD): 3x7x3, Controller (Front middle bottom)",
+                "3x1x3 Base of " + casings,
+                "1x3x1 " + casings + " pillar (Center of base)",
+                "1x3x1 " + getFrameMaterial().mName + " Frame Boxes (Each pillar side and on top)",
+                "1x Input Hatch for drilling fluid (Any bottom layer casing)",
+                "1x Input Bus for mining pipes (Any bottom layer casing; not necessary)",
+                "1x Output Bus (Any bottom layer casing)",
+                "1x Maintenance Hatch (Any bottom layer casing)",
+                "1x " + VN[getMinTier()] + "+ Energy Hatch (Any bottom layer casing)",
+                "Radius is " + (getRadiusInChunks() << 4) + " blocks"};
+    }
+}
\ No newline at end of file