+ Added Super Busses.

+ Added Breaker Boxes.
+ Added Super Jukebox. (framework)
+ Added King Bat. (framework)
+ Added Custom WAILA plugin. (framework)
+ Added lots of simple function calls to CI. (Recipe simplification)
% Rewrote the recipes for Wireless Chargers, they now require assembly.
% Cleaned up some old code.
$ Adjusted bug with pollution scrubbers using no durability and removing LOTS of pollution.
$ Greatly improved code base for pollution scrubbers.
$ Added pollution back to the Cyclotron.

7 files changed, 1732 insertions, 40 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java b/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
index 25997e5d35..2bea7473cc 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/Meta_GT_Proxy.java
@@ -2,6 +2,8 @@ package gtPlusPlus.xmod.gregtech.common;
 
 import static gtPlusPlus.xmod.gregtech.common.covers.GTPP_Cover_Overflow.mOverflowCache;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -10,9 +12,10 @@ import java.util.Map;
 import java.util.Timer;
 import java.util.TimerTask;
 
+import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
-
+import net.minecraft.block.Block;
 import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -22,11 +25,15 @@ import net.minecraftforge.fluids.FluidStack;
 import gregtech.GT_Mod;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.GT_Values;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaTileEntity;
 import gregtech.api.util.GT_LanguageManager;
 import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_Utility;
 import gregtech.common.GT_Proxy;
+import gregtech.common.blocks.GT_Block_Machines;
+import gregtech.common.render.GT_Renderer_Block;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.api.objects.data.AutoMap;
 import gtPlusPlus.api.objects.data.ObjMap;
@@ -34,25 +41,143 @@ import gtPlusPlus.api.objects.minecraft.FormattedTooltipString;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.reflect.ProxyFinder;
 import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.BaseCustomTileEntity;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.custom.power.BaseCustomPower_MTE;
+import gtPlusPlus.xmod.gregtech.common.blocks.GTPP_Block_Machines;
+import gtPlusPlus.xmod.gregtech.common.render.GTPP_Render_MachineBlock;
 
 public class Meta_GT_Proxy {
 
+	static {
+		instance = new Meta_GT_Proxy();
+	}
+	
+	public static final Meta_GT_Proxy instance;
+	
 	public static List<Runnable> GT_BlockIconload = new ArrayList<>();
 	public static List<Runnable> GT_ItemIconload = new ArrayList<>();
 	
 	public static AutoMap<Integer> GT_ValidHeatingCoilMetas = new AutoMap<Integer>();
+
+	private static Class sBaseMetaTileEntityClass;
+	private static Class sBaseMetaTileEntityClass2;
 	
 	public static final Map<String, FormattedTooltipString> mCustomGregtechMetaTooltips = new LinkedHashMap<String, FormattedTooltipString>();
+	
 
 	@SideOnly(Side.CLIENT)
 	public static IIconRegister sBlockIcons, sItemIcons;
 
 	public Meta_GT_Proxy() {
 		Logger.INFO("GT_PROXY - initialized.");
+	}
+	
+	public static Block sBlockMachines;
+	
+	public void preInit() {
+		
+		//New GT++ Block, yay! (Progress)
+		sBlockMachines = new GTPP_Block_Machines();
+		
+        GT_Log.out.println("GT++ Mod: Register TileEntities.");
+        BaseMetaTileEntity tBaseMetaTileEntity = constructBaseMetaTileEntity();
+        BaseMetaTileEntity tBaseMetaTileEntity2 = constructBaseMetaTileEntityCustomPower();
+
+        GT_Log.out.println("GT++ Mod: Testing BaseMetaTileEntity.");
+        if (tBaseMetaTileEntity == null || tBaseMetaTileEntity2 == null) {
+            GT_Log.out.println("GT++ Mod: Fatal Error ocurred while initializing TileEntities, crashing Minecraft.");
+            throw new RuntimeException("");
+        }
+        
+        GT_Log.out.println("GT++ Mod: Registering the BaseMetaTileEntity.");
+        GameRegistry.registerTileEntity(tBaseMetaTileEntity.getClass(), "BaseMetaTileEntity_GTPP");
+        GameRegistry.registerTileEntity(tBaseMetaTileEntity2.getClass(), "BaseMetaTileEntity_GTPP2");
+	}
+	
+	public void init() {
 		scheduleCoverMapCleaner();
-		setValidHeatingCoilMetas();
+		setValidHeatingCoilMetas();	
 	}
 	
+	public void postInit() {
+		
+	}
+	
+	public static BaseCustomTileEntity constructBaseMetaTileEntity() {
+		if (sBaseMetaTileEntityClass == null) {
+			try {
+				sBaseMetaTileEntityClass = BaseCustomTileEntity.class;
+				return (BaseCustomTileEntity) BaseCustomTileEntity.class.newInstance();
+			} catch (Throwable arg1) {
+				try {
+					Constructor<?> g =  BaseCustomTileEntity.class.getConstructors()[0];
+					g.setAccessible(true);
+					return (BaseCustomTileEntity) g.newInstance();
+				} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+						| InvocationTargetException | SecurityException e) {
+				}
+			}
+		}
+		try {
+			return (BaseCustomTileEntity) ((BaseCustomTileEntity) sBaseMetaTileEntityClass.newInstance());
+		} catch (Throwable arg0) {
+			arg0.printStackTrace(GT_Log.err);
+			try {
+				Constructor<?> g =  BaseCustomTileEntity.class.getConstructors()[0];
+				g.setAccessible(true);
+				return (BaseCustomTileEntity) g.newInstance();
+			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+					| InvocationTargetException | SecurityException e) {
+				GT_Log.err
+						.println("GT++ Mod: Fatal Error ocurred while initializing TileEntities, crashing Minecraft.");
+				e.printStackTrace(GT_Log.err);
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+	public static BaseCustomPower_MTE constructBaseMetaTileEntityCustomPower() {
+		if (sBaseMetaTileEntityClass2 == null) {
+			try {
+				sBaseMetaTileEntityClass2 = BaseCustomPower_MTE.class;
+				return (BaseCustomPower_MTE) BaseCustomPower_MTE.class.newInstance();
+			} catch (Throwable arg1) {
+				try {
+					Constructor<?> g =  BaseCustomPower_MTE.class.getConstructors()[0];
+					g.setAccessible(true);
+					return (BaseCustomPower_MTE) g.newInstance();
+				} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+						| InvocationTargetException | SecurityException e) {
+					// e.printStackTrace();
+				}
+			}
+		}
+
+		try {
+			return (BaseCustomPower_MTE) ((BaseCustomPower_MTE) sBaseMetaTileEntityClass2.newInstance());
+		} catch (Throwable arg0) {
+			arg0.printStackTrace(GT_Log.err);
+			try {
+				Constructor<?> g =  BaseCustomPower_MTE.class.getConstructors()[0];
+				g.setAccessible(true);
+				return (BaseCustomPower_MTE) g.newInstance();
+			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+					| InvocationTargetException | SecurityException e) {
+				GT_Log.err
+						.println("GT++ Mod: Fatal Error ocurred while initializing TileEntities, crashing Minecraft.");
+				e.printStackTrace(GT_Log.err);
+				throw new RuntimeException(e);
+			}
+		}
+	}
+	
+	
+	
+	
+	
+	
+	
+	
 	public void setValidHeatingCoilMetas() {
 		for (int i = 0; i <= 6; i++ ) {
 			GT_ValidHeatingCoilMetas.put(i);			
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java b/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
index 4313ca53f6..c1db39b132 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/StaticFields59.java
@@ -17,9 +17,13 @@ import gregtech.api.enums.Textures.BlockIcons;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler;
 import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.util.reflect.ReflectionUtils;
 import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
 
 public class StaticFields59 {
 
@@ -31,6 +35,7 @@ public class StaticFields59 {
 	public static final Field mCasingTexturePages;
 	
 	public static final Method mCalculatePollutionReduction;
+	public static final Method mAddFurnaceRecipe;
 
 	private static final Map<String, Materials> mMaterialCache = new LinkedHashMap<String, Materials>();
 
@@ -46,6 +51,20 @@ public class StaticFields59 {
 		mCasingTexturePages = getField(BlockIcons.class, "casingTexturePages");
 		
 		mCalculatePollutionReduction = getMethod(GT_MetaTileEntity_Hatch_Muffler.class, "calculatePollutionReduction", int.class);		
+		
+		Logger.INFO("Initializing a recipe handler for different versions of Gregtech 5.");		
+		//Yep...
+		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+			Logger.INFO("Selecting GT 5.7/5.8 Recipe Set");
+			mAddFurnaceRecipe = getMethod(GT_ModHandler.class, "addSmeltingAndAlloySmeltingRecipe", ItemStack.class, ItemStack.class);			
+		}
+		else {
+			Logger.INFO("Selecting GT 5.9 Recipe Set");
+			mAddFurnaceRecipe = getMethod(GT_ModHandler.class, "addSmeltingAndAlloySmeltingRecipe", ItemStack.class, ItemStack.class, boolean.class);			
+		}
+		
+		
+		
 	}
 
 	public static synchronized final Block getBlockCasings5() {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Block_Machines.java b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Block_Machines.java
new file mode 100644
index 0000000000..9fe89bfabc
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Block_Machines.java
@@ -0,0 +1,515 @@
+package gtPlusPlus.xmod.gregtech.common.blocks;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Textures.BlockIcons;
+import gregtech.api.interfaces.IDebugableBlock;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.ICoverable;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_Generic_Block;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.metatileentity.BaseMetaTileEntity;
+import gregtech.api.metatileentity.BaseTileEntity;
+import gregtech.api.objects.XSTR;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.blocks.GT_Item_Machines;
+import gregtech.common.blocks.GT_Material_Machines;
+import gregtech.common.render.GT_Renderer_Block;
+import gtPlusPlus.xmod.gregtech.common.Meta_GT_Proxy;
+import gtPlusPlus.xmod.gregtech.common.render.GTPP_Render_MachineBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.ITileEntityProvider;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class GTPP_Block_Machines extends GT_Generic_Block implements IDebugableBlock, ITileEntityProvider {
+	public static ThreadLocal<IGregTechTileEntity> mTemporaryTileEntity = new ThreadLocal<IGregTechTileEntity>();
+
+	public GTPP_Block_Machines() {
+		super(GTPP_Item_Machines.class, "gtpp.blockmachines", new GT_Material_Machines());
+		GregTech_API.registerMachineBlock(this, -1);
+		this.setHardness(1.0F);
+		this.setResistance(10.0F);
+		this.setStepSound(soundTypeMetal);
+		this.setCreativeTab(GregTech_API.TAB_GREGTECH);
+		this.isBlockContainer = true;
+	}
+
+	public String getHarvestTool(int aMeta) {
+		switch (aMeta / 4) {
+			case 0 :
+				return "wrench";
+			case 1 :
+				return "wrench";
+			case 2 :
+				return "cutter";
+			case 3 :
+				return "axe";
+			default :
+				return "wrench";
+		}
+	}
+
+	public int getHarvestLevel(int aMeta) {
+		return aMeta % 4;
+	}
+
+	protected boolean canSilkHarvest() {
+		return false;
+	}
+
+	public void onNeighborChange(IBlockAccess aWorld, int aX, int aY, int aZ, int aTileX, int aTileY, int aTileZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof BaseTileEntity) {
+			((BaseTileEntity) tTileEntity).onAdjacentBlockChange(aTileX, aTileY, aTileZ);
+		}
+
+	}
+
+	public void onBlockAdded(World aWorld, int aX, int aY, int aZ) {
+		super.onBlockAdded(aWorld, aX, aY, aZ);
+		if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) {
+			GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+		}
+
+	}
+
+	public String getUnlocalizedName() {
+		return "gtpp.blockmachines";
+	}
+
+	public String getLocalizedName() {
+		return StatCollector.translateToLocal("gtpp.blockmachines" + ".name");
+	}
+
+	public int getFlammability(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) {
+		return 0;
+	}
+
+	public int getFireSpreadSpeed(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) {
+		return GregTech_API.sMachineFlammable && aWorld.getBlockMetadata(aX, aY, aZ) == 0 ? 100 : 0;
+	}
+
+	public int getRenderType() {
+		return GTPP_Render_MachineBlock.INSTANCE == null ? super.getRenderType() : GTPP_Render_MachineBlock.INSTANCE.mRenderID;
+	}
+
+	public boolean isFireSource(World aWorld, int aX, int aY, int aZ, ForgeDirection side) {
+		return GregTech_API.sMachineFlammable && aWorld.getBlockMetadata(aX, aY, aZ) == 0;
+	}
+
+	public boolean isFlammable(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) {
+		return GregTech_API.sMachineFlammable && aWorld.getBlockMetadata(aX, aY, aZ) == 0;
+	}
+
+	public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess aWorld, int aX, int aY, int aZ) {
+		return false;
+	}
+
+	public boolean canConnectRedstone(IBlockAccess var1, int var2, int var3, int var4, int var5) {
+		return true;
+	}
+
+	public boolean canBeReplacedByLeaves(IBlockAccess aWorld, int aX, int aY, int aZ) {
+		return false;
+	}
+
+	public boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) {
+		return false;
+	}
+
+	public boolean hasTileEntity(int aMeta) {
+		return true;
+	}
+
+	public boolean hasComparatorInputOverride() {
+		return true;
+	}
+
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	public boolean canProvidePower() {
+		return true;
+	}
+
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	public TileEntity createNewTileEntity(World aWorld, int aMeta) {
+		return this.createTileEntity(aWorld, aMeta);
+	}
+
+	public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int aSide) {
+		return BlockIcons.MACHINE_LV_SIDE.getIcon();
+	}
+
+	public IIcon getIcon(int aSide, int aMeta) {
+		return BlockIcons.MACHINE_LV_SIDE.getIcon();
+	}
+
+	public boolean onBlockEventReceived(World aWorld, int aX, int aY, int aZ, int aData1, int aData2) {
+		super.onBlockEventReceived(aWorld, aX, aY, aZ, aData1, aData2);
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity != null ? tTileEntity.receiveClientEvent(aData1, aData2) : false;
+	}
+
+	public void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB inputAABB, List outputAABB,
+			Entity collider) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity
+				&& ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() != null) {
+			((IGregTechTileEntity) tTileEntity).addCollisionBoxesToList(aWorld, aX, aY, aZ, inputAABB, outputAABB,
+					collider);
+		} else {
+			super.addCollisionBoxesToList(aWorld, aX, aY, aZ, inputAABB, outputAABB, collider);
+		}
+	}
+
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity
+				&& ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() != null
+						? ((IGregTechTileEntity) tTileEntity).getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ)
+						: super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+	}
+
+	@SideOnly(Side.CLIENT)
+	public AxisAlignedBB getSelectedBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity
+				&& ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() != null
+						? ((IGregTechTileEntity) tTileEntity).getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ)
+						: super.getSelectedBoundingBoxFromPool(aWorld, aX, aY, aZ);
+	}
+
+	public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = blockAccess.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity
+				&& ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() != null) {
+			AxisAlignedBB bbb = ((IGregTechTileEntity) tTileEntity)
+					.getCollisionBoundingBoxFromPool(((IGregTechTileEntity) tTileEntity).getWorld(), 0, 0, 0);
+			this.minX = bbb.minX;
+			this.minY = bbb.minY;
+			this.minZ = bbb.minZ;
+			this.maxX = bbb.maxX;
+			this.maxY = bbb.maxY;
+			this.maxZ = bbb.maxZ;
+		} else {
+			super.setBlockBoundsBasedOnState(blockAccess, aX, aY, aZ);
+		}
+	}
+
+	public void setBlockBoundsForItemRender() {
+		super.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+	}
+
+	public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity collider) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity
+				&& ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() != null) {
+			((IGregTechTileEntity) tTileEntity).onEntityCollidedWithBlock(aWorld, aX, aY, aZ, collider);
+		} else {
+			super.onEntityCollidedWithBlock(aWorld, aX, aY, aZ, collider);
+		}
+	}
+
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister aIconRegister) {
+
+	}
+
+	public float getBlockHardness(World aWorld, int aX, int aY, int aZ) {
+		return super.getBlockHardness(aWorld, aX, aY, aZ);
+	}
+
+	public float getPlayerRelativeBlockHardness(EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof BaseMetaTileEntity && ((BaseMetaTileEntity) tTileEntity).privateAccess()
+				&& !((BaseMetaTileEntity) tTileEntity).playerOwnsThis(aPlayer, true)
+						? -1.0F
+						: super.getPlayerRelativeBlockHardness(aPlayer, aWorld, aX, aY, aZ);
+	}
+
+	public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int aSide, float par1,
+			float par2, float par3) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity == null) {
+			return false;
+		} else {
+			if (aPlayer.isSneaking()) {
+				ItemStack tCurrentItem = aPlayer.inventory.getCurrentItem();
+				if (tCurrentItem == null) {
+					return false;
+				}
+
+				if (!GT_Utility.isStackInList(tCurrentItem, GregTech_API.sScrewdriverList)
+						&& !GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWrenchList)) {
+					return false;
+				}
+			}
+
+			return tTileEntity instanceof IGregTechTileEntity
+					? (((IGregTechTileEntity) tTileEntity).getTimer() < 50L
+							? false
+							: (!aWorld.isRemote && !((IGregTechTileEntity) tTileEntity).isUseableByPlayer(aPlayer)
+									? true
+									: ((IGregTechTileEntity) tTileEntity).onRightclick(aPlayer, (byte) aSide, par1,
+											par2, par3)))
+					: false;
+		}
+	}
+
+	public void onBlockClicked(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity) {
+			((IGregTechTileEntity) tTileEntity).onLeftclick(aPlayer);
+		}
+
+	}
+
+	public int getDamageValue(World aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity ? ((IGregTechTileEntity) tTileEntity).getMetaTileID() : 0;
+	}
+
+	public void onBlockExploded(World aWorld, int aX, int aY, int aZ, Explosion aExplosion) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof BaseMetaTileEntity) {
+			((BaseMetaTileEntity) tTileEntity).doEnergyExplosion();
+		}
+
+		super.onBlockExploded(aWorld, aX, aY, aZ, aExplosion);
+	}
+
+	public void breakBlock(World aWorld, int aX, int aY, int aZ, Block par5, int par6) {
+		GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ);
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity) {
+			IGregTechTileEntity tGregTechTileEntity = (IGregTechTileEntity) tTileEntity;
+			XSTR tRandom = new XSTR();
+			mTemporaryTileEntity.set(tGregTechTileEntity);
+
+			for (int i = 0; i < tGregTechTileEntity.getSizeInventory(); ++i) {
+				ItemStack tItem = tGregTechTileEntity.getStackInSlot(i);
+				if (tItem != null && tItem.stackSize > 0 && tGregTechTileEntity.isValidSlot(i)) {
+					EntityItem tItemEntity = new EntityItem(aWorld,
+							(double) ((float) aX + tRandom.nextFloat() * 0.8F + 0.1F),
+							(double) ((float) aY + tRandom.nextFloat() * 0.8F + 0.1F),
+							(double) ((float) aZ + tRandom.nextFloat() * 0.8F + 0.1F),
+							new ItemStack(tItem.getItem(), tItem.stackSize, tItem.getItemDamage()));
+					if (tItem.hasTagCompound()) {
+						tItemEntity.getEntityItem().setTagCompound((NBTTagCompound) tItem.getTagCompound().copy());
+					}
+
+					tItemEntity.motionX = tRandom.nextGaussian() * 0.0500000007450581D;
+					tItemEntity.motionY = tRandom.nextGaussian() * 0.0500000007450581D + 0.2000000029802322D;
+					tItemEntity.motionZ = tRandom.nextGaussian() * 0.0500000007450581D;
+					aWorld.spawnEntityInWorld(tItemEntity);
+					tItem.stackSize = 0;
+					tGregTechTileEntity.setInventorySlotContents(i, (ItemStack) null);
+				}
+			}
+		}
+
+		super.breakBlock(aWorld, aX, aY, aZ, par5, par6);
+		aWorld.removeTileEntity(aX, aY, aZ);
+	}
+
+	public ArrayList<ItemStack> getDrops(World aWorld, int aX, int aY, int aZ, int aMeta, int aFortune) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity
+				? ((IGregTechTileEntity) tTileEntity).getDrops()
+				: (mTemporaryTileEntity.get() == null
+						? new ArrayList()
+						: ((IGregTechTileEntity) mTemporaryTileEntity.get()).getDrops());
+	}
+
+	public int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int aSide) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity
+				? ((IGregTechTileEntity) tTileEntity).getComparatorValue((byte) aSide)
+				: 0;
+	}
+
+	public int isProvidingWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) {
+		if (aSide >= 0 && aSide <= 5) {
+			TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+			return tTileEntity instanceof IGregTechTileEntity
+					? ((IGregTechTileEntity) tTileEntity).getOutputRedstoneSignal(GT_Utility.getOppositeSide(aSide))
+					: 0;
+		} else {
+			return 0;
+		}
+	}
+
+	public int isProvidingStrongPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) {
+		if (aSide >= 0 && aSide <= 5) {
+			TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+			return tTileEntity instanceof IGregTechTileEntity
+					? ((IGregTechTileEntity) tTileEntity)
+							.getStrongOutputRedstoneSignal(GT_Utility.getOppositeSide(aSide))
+					: 0;
+		} else {
+			return 0;
+		}
+	}
+
+	public void dropBlockAsItemWithChance(World aWorld, int aX, int aY, int aZ, int par5, float chance, int par7) {
+		if (!aWorld.isRemote) {
+			TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+			if (tTileEntity != null && chance < 1.0F) {
+				if (tTileEntity instanceof BaseMetaTileEntity && GregTech_API.sMachineNonWrenchExplosions) {
+					((BaseMetaTileEntity) tTileEntity).doEnergyExplosion();
+				}
+			} else {
+				super.dropBlockAsItemWithChance(aWorld, aX, aY, aZ, par5, chance, par7);
+			}
+		}
+
+	}
+
+	public boolean isSideSolid(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection aSide) {
+		if (aWorld.getBlockMetadata(aX, aY, aZ) == 0) {
+			return true;
+		} else {
+			TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+			if (tTileEntity != null) {
+				if (tTileEntity instanceof BaseMetaTileEntity) {
+					return true;
+				}
+
+				if (tTileEntity instanceof BaseMetaPipeEntity
+						&& (((BaseMetaPipeEntity) tTileEntity).mConnections & -64) != 0) {
+					return true;
+				}
+
+				if (tTileEntity instanceof ICoverable
+						&& ((ICoverable) tTileEntity).getCoverIDAtSide((byte) aSide.ordinal()) != 0) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+	}
+
+	public int getLightOpacity(IBlockAccess aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity == null
+				? 0
+				: (tTileEntity instanceof IGregTechTileEntity
+						? ((IGregTechTileEntity) tTileEntity).getLightOpacity()
+						: (aWorld.getBlockMetadata(aX, aY, aZ) == 0 ? 255 : 0));
+	}
+
+	public int getLightValue(IBlockAccess aWorld, int aX, int aY, int aZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof BaseMetaTileEntity ? ((BaseMetaTileEntity) tTileEntity).getLightValue() : 0;
+	}
+
+	public TileEntity createTileEntity(World aWorld, int aMeta) {
+		return (TileEntity) (aMeta >= 4 ? Meta_GT_Proxy.constructBaseMetaTileEntity() : Meta_GT_Proxy.constructBaseMetaTileEntityCustomPower());
+	}
+
+	public float getExplosionResistance(Entity par1Entity, World aWorld, int aX, int aY, int aZ, double explosionX,
+			double explosionY, double explosionZ) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof IGregTechTileEntity
+				? ((IGregTechTileEntity) tTileEntity).getBlastResistance((byte) 6)
+				: 10.0F;
+	}
+
+	@SideOnly(Side.CLIENT)
+	public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) {
+		for (int i = 0; i < 100; ++i) {
+			if (GregTech_API.METATILEENTITIES[(30400 + i)] != null) {
+				par3List.add(new ItemStack(par1, 1, i));
+			}
+		}
+
+	}
+
+	public void onBlockPlacedBy(World aWorld, int aX, int aY, int aZ, EntityLivingBase aPlayer, ItemStack aStack) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity != null) {
+			if (tTileEntity instanceof IGregTechTileEntity) {
+				IGregTechTileEntity var6 = (IGregTechTileEntity) tTileEntity;
+				if (aPlayer == null) {
+					var6.setFrontFacing((byte) 1);
+				} else {
+					int var7 = MathHelper.floor_double((double) (aPlayer.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
+					int var8 = Math.round(aPlayer.rotationPitch);
+					if (var8 >= 65 && var6.isValidFacing((byte) 1)) {
+						var6.setFrontFacing((byte) 1);
+					} else if (var8 <= -65 && var6.isValidFacing((byte) 0)) {
+						var6.setFrontFacing((byte) 0);
+					} else {
+						switch (var7) {
+							case 0 :
+								var6.setFrontFacing((byte) 2);
+								break;
+							case 1 :
+								var6.setFrontFacing((byte) 5);
+								break;
+							case 2 :
+								var6.setFrontFacing((byte) 3);
+								break;
+							case 3 :
+								var6.setFrontFacing((byte) 4);
+						}
+					}
+				}
+			}
+
+		}
+	}
+
+	public ArrayList<String> getDebugInfo(EntityPlayer aPlayer, int aX, int aY, int aZ, int aLogLevel) {
+		TileEntity tTileEntity = aPlayer.worldObj.getTileEntity(aX, aY, aZ);
+		return tTileEntity instanceof BaseMetaTileEntity
+				? ((BaseMetaTileEntity) tTileEntity).getDebugInfo(aPlayer, aLogLevel)
+				: (tTileEntity instanceof BaseMetaPipeEntity
+						? ((BaseMetaPipeEntity) tTileEntity).getDebugInfo(aPlayer, aLogLevel)
+						: null);
+	}
+
+	public boolean recolourBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection aSide, int aColor) {
+		TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
+		if (tTileEntity instanceof IGregTechTileEntity) {
+			if (((IGregTechTileEntity) tTileEntity).getColorization() == (byte) (~aColor & 15)) {
+				return false;
+			} else {
+				((IGregTechTileEntity) tTileEntity).setColorization((byte) (~aColor & 15));
+				return true;
+			}
+		} else {
+			return false;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Item_Machines.java b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Item_Machines.java
new file mode 100644
index 0000000000..a9645184cf
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/blocks/GTPP_Item_Machines.java
@@ -0,0 +1,219 @@
+package gtPlusPlus.xmod.gregtech.common.blocks;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_ItsNotMyFaultException;
+import gregtech.api.util.GT_LanguageManager;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.lib.CORE;
+
+import java.util.List;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+
+public class GTPP_Item_Machines extends ItemBlock {
+	public GTPP_Item_Machines(Block par1) {
+		super(par1);
+		this.setMaxDamage(0);
+		this.setHasSubtypes(true);
+		this.setCreativeTab(GregTech_API.TAB_GREGTECH);
+	}
+
+	@SuppressWarnings("unchecked")
+	public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean par4) {
+		try {
+			int e = this.getDamage(aStack) + 30400; //Add Offset
+			if (e <= 0 || e >= GregTech_API.METATILEENTITIES.length) {
+				return;
+			}
+
+			if (GregTech_API.METATILEENTITIES[e] != null) {
+				
+				IGregTechTileEntity aNBT = GregTech_API.METATILEENTITIES[e].getBaseMetaTileEntity();				
+
+				final long tVoltage = aNBT.getInputVoltage();
+				byte tTier = (byte) ((byte) Math.max(1, GT_Utility.getTier(tVoltage)));
+				
+				/*if (aNBT.getDescription() != null) {
+					int tAmount = 0;
+					String[] arg7 = aNBT.getDescription();
+					int arg8 = arg7.length-1;
+
+					if (arg7 != null && arg7.length > 0) {
+						for (String t : arg7) {
+							aList.add(t);
+						}
+						
+					}
+					else {
+						aList.add("ERROR");						
+					}
+					
+					for (int y = 0; y < arg8; y++) {
+						String tDescription = arg7[y];
+						
+						if (tDescription != null) {
+							aList.add(tDescription+"|"+arg8);
+							continue;
+						}
+						else {
+							continue;
+						}
+					}
+				}*/
+
+				if (aNBT.getEUCapacity() > 0L) {
+					
+					//Custom handling
+					if ((e - 30400) <= 100) {
+						
+
+						if ((e - 30400) <= 10) {
+							tTier -= 2;
+							aList.add(EnumChatFormatting.BOLD+"16"+" Fuse Slots"+EnumChatFormatting.GRAY);
+							aList.add("One will blow per each A of eu extra passed into it");
+							aList.add("Can receive an additional "+EnumChatFormatting.YELLOW+GT_Values.V[tTier]+EnumChatFormatting.GRAY+" EU/t per Fuse");
+							aList.add("This machine can accept upto a single amp of "+GT_Values.VN[Math.min(tTier+2, 12)]);
+							aList.add(GT_LanguageManager.addStringLocalization("TileEntity_Breaker_Loss", "Breaker Loss: "+EnumChatFormatting.RED+""+(GT_Values.V[Math.max(tTier-1, 0)]/10)+EnumChatFormatting.GRAY+" EU/t", !GregTech_API.sPostloadFinished) + EnumChatFormatting.GRAY);
+						}
+
+						
+						aList.add(GT_LanguageManager.addStringLocalization("TileEntity_Special_Power_1", EnumChatFormatting.RED+"Special Power Handling, please read manual", !GregTech_API.sPostloadFinished) + EnumChatFormatting.GRAY);
+						//aList.add(GT_LanguageManager.addStringLocalization("TileEntity_BreakerBox_2", EnumChatFormatting.RED+"Special Power Handling, please read manual", !GregTech_API.sPostloadFinished) + EnumChatFormatting.GRAY);
+						//aList.add(GT_LanguageManager.addStringLocalization("TileEntity_BreakerBox_3", EnumChatFormatting.RED+"Special Power Handling, please read manual", !GregTech_API.sPostloadFinished) + EnumChatFormatting.GRAY);
+					}					
+					
+					
+					if (aNBT.getInputVoltage() > 0L) {
+						aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_IN", "Voltage IN: ",
+								!GregTech_API.sPostloadFinished) + EnumChatFormatting.GREEN + aNBT.getInputVoltage()
+								+ " (" + GT_Values.VN[GT_Utility.getTier(aNBT.getInputVoltage())] + ")"
+								+ EnumChatFormatting.GRAY);
+					}
+
+					if (aNBT.getOutputVoltage() > 0L) {
+						aList.add(GT_LanguageManager.addStringLocalization("TileEntity_EUp_OUT", "Voltage OUT: ",
+								!GregTech_API.sPostloadFinished) + EnumChatFormatting.GREEN + aNBT.getOutputVoltage()
+								+ " (" + GT_Values.VN[GT_Utility.getTier(aNBT.getOutputVoltage())] + ")"
+								+ EnumChatFormatting.GRAY);
+					}
+					
+					aList.add(GT_LanguageManager.addStringLocalization("TileEntity_Lossess_EU", "Transmission Loss: "+EnumChatFormattin