Restore DSU Api, mark all other api's as dead.

integration/modules/dead/BC.java

@@ -0,0 +1,223 @@
+package appeng.integration.modules.dead;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.TunnelType;
+import appeng.api.features.IP2PTunnelRegistry;
+import appeng.api.parts.IFacadePart;
+import appeng.facade.FacadePart;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IBC;
+import appeng.integration.modules.helpers.dead.BCPipeHandler;
+import buildcraft.BuildCraftEnergy;
+import buildcraft.BuildCraftTransport;
+import buildcraft.api.tools.IToolWrench;
+import buildcraft.api.transport.FacadeManager;
+import buildcraft.api.transport.IPipeTile;
+import buildcraft.api.transport.IPipeTile.PipeType;
+import buildcraft.transport.ItemFacade;
+import buildcraft.transport.PipeIconProvider;
+import buildcraft.transport.TileGenericPipe;
+
+public class BC implements IIntegrationModule, IBC
+{
+
+	public static BC instance;
+
+	@Override
+	public void addFacade(ItemStack item)
+	{
+		// Myrathi :
+		// FMLInterModComms.sendMessage("BuildCraft|Transport", "add-facade",
+		// <your block ID> + "@" + <your block meta>);
+		FacadeManager.addFacade( item );
+	}
+
+	@Override
+	public boolean isWrench(Item eq)
+	{
+		return eq instanceof IToolWrench;
+	}
+
+	@Override
+	public boolean isPipe(TileEntity te, ForgeDirection dir)
+	{
+		if ( te instanceof IPipeTile )
+		{
+			try
+			{
+				if ( te instanceof TileGenericPipe )
+					if ( ((TileGenericPipe) te).hasPlug( dir.getOpposite() ) )
+						return false;
+			}
+			catch (Exception err)
+			{
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean canWrench(Item i, EntityPlayer p, int x, int y, int z)
+	{
+		return ((IToolWrench) i).canWrench( p, x, y, z );
+	}
+
+	@Override
+	public void wrenchUsed(Item i, EntityPlayer p, int x, int y, int z)
+	{
+		((IToolWrench) i).wrenchUsed( p, x, y, z );
+	}
+
+	@Override
+	public boolean addItemsToPipe(TileEntity te, ItemStack is, ForgeDirection dir)
+	{
+		if ( is != null && te != null && te instanceof IPipeTile )
+		{
+			IPipeTile pt = (IPipeTile) te;
+			if ( pt.getPipeType() == PipeType.ITEM )
+			{
+				int amt = pt.injectItem( is, false, dir );
+				if ( amt == is.stackSize )
+				{
+					pt.injectItem( is, true, dir );
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean isFacade(ItemStack is)
+	{
+		if ( is == null )
+			return false;
+		return is.getItem() instanceof ItemFacade;
+	}
+
+	@Override
+	public boolean canAddItemsToPipe(TileEntity te, ItemStack is, ForgeDirection dir)
+	{
+
+		if ( is != null && te != null && te instanceof IPipeTile )
+		{
+			IPipeTile pt = (IPipeTile) te;
+			if ( pt.getPipeType() == PipeType.ITEM )
+			{
+				int amt = pt.injectItem( is, false, dir );
+				if ( amt == is.stackSize )
+				{
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public void registerPowerP2P()
+	{
+		IP2PTunnelRegistry reg = AEApi.instance().registries().p2pTunnel();
+		reg.addNewAttunement( new ItemStack( BuildCraftEnergy.engineBlock, 1, 0 ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftEnergy.engineBlock, 1, 1 ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftEnergy.engineBlock, 1, 2 ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerCobblestone ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerDiamond ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerGold ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerQuartz ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerStone ), TunnelType.BC_POWER );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipePowerWood ), TunnelType.BC_POWER );
+	}
+
+	@Override
+	public void registerItemP2P()
+	{
+		IP2PTunnelRegistry reg = AEApi.instance().registries().p2pTunnel();
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsWood ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsVoid ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsSandstone ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsQuartz ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsObsidian ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsIron ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsGold ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsEmerald ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsDiamond ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsStone ), TunnelType.ITEM );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeItemsCobblestone ), TunnelType.ITEM );
+	}
+
+	@Override
+	public void registerLiquidsP2P()
+	{
+		IP2PTunnelRegistry reg = AEApi.instance().registries().p2pTunnel();
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsCobblestone ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsEmerald ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsGold ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsIron ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsSandstone ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsStone ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsVoid ), TunnelType.FLUID );
+		reg.addNewAttunement( new ItemStack( BuildCraftTransport.pipeFluidsWood ), TunnelType.FLUID );
+	}
+
+	@Override
+	public void Init()
+	{
+		AEApi.instance().partHelper().registerNewLayer( "appeng.api.parts.layers.LayerIPipeConnection", "buildcraft.api.transport.IPipeConnection" );
+		AEApi.instance().registries().externalStorage().addExternalStorageInterface( new BCPipeHandler() );
+	}
+
+	@Override
+	public void PostInit()
+	{
+		registerPowerP2P();
+		registerItemP2P();
+		registerLiquidsP2P();
+	}
+
+	@Override
+	public IFacadePart createFacadePart(int[] ids, ForgeDirection side)
+	{
+		ItemStack fs = ItemFacade.getStack( ids[0], ids[1] );
+		return new FacadePart( fs, side );
+	}
+
+	@Override
+	public IFacadePart createFacadePart(ItemStack fs, ForgeDirection side)
+	{
+		return new FacadePart( fs, side );
+	}
+
+	@Override
+	public ItemStack getTextureForFacade(ItemStack facade)
+	{
+		return new ItemStack( Block.blocksList[ItemFacade.getBlockId( facade )], 1, ItemFacade.getMetaData( facade ) );
+	}
+
+	@Override
+	public IIcon getFacadeTexture()
+	{
+		try
+		{
+			return BuildCraftTransport.instance.pipeIconProvider.getIcon( PipeIconProvider.TYPE.PipeStructureCobblestone.ordinal() ); // Structure
+		}
+		catch (Throwable t)
+		{
+		}
+		return null;
+		// Pipe
+	}
+
+}

integration/modules/dead/BS.java

@@ -0,0 +1,45 @@
+package appeng.integration.modules.dead;
+
+import net.mcft.copy.betterstorage.api.ICrateStorage;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IBS;
+import appeng.integration.modules.helpers.dead.BSCrateHandler;
+import appeng.integration.modules.helpers.dead.BSCrateStorageAdaptor;
+import appeng.util.InventoryAdaptor;
+
+public class BS implements IIntegrationModule, IBS
+{
+
+	public static BS instance;
+
+	@Override
+	public boolean isStorageCrate(Object te)
+	{
+		return te instanceof ICrateStorage;
+	}
+
+	@Override
+	public InventoryAdaptor getAdaptor(Object te, ForgeDirection d)
+	{
+		if ( te instanceof ICrateStorage )
+		{
+			return new BSCrateStorageAdaptor( te, d );
+		}
+		return null;
+	}
+
+	@Override
+	public void Init()
+	{
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		AEApi.instance().registries().externalStorage().addExternalStorageInterface( new BSCrateHandler() );
+	}
+
+}

integration/modules/dead/FMP.java

@@ -0,0 +1,152 @@
+package appeng.integration.modules.dead;
+
+import net.minecraft.block.Block;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.api.AEApi;
+import appeng.api.parts.IPartHost;
+import appeng.core.AELog;
+import appeng.fmp.CableBusPart;
+import appeng.fmp.FMPEvent;
+import appeng.fmp.PartRegistry;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IFMP;
+import appeng.parts.CableBusContainer;
+import appeng.util.Platform;
+import codechicken.lib.vec.BlockCoord;
+import codechicken.microblock.BlockMicroMaterial;
+import codechicken.multipart.MultiPartRegistry;
+import codechicken.multipart.MultiPartRegistry.IPartConverter;
+import codechicken.multipart.MultiPartRegistry.IPartFactory;
+import codechicken.multipart.MultipartGenerator;
+import codechicken.multipart.TMultiPart;
+import codechicken.multipart.TileMultipart;
+
+public class FMP implements IIntegrationModule, IPartFactory, IPartConverter, IFMP
+{
+
+	public static FMP instance;
+
+	@Override
+	public TMultiPart createPart(String name, boolean client)
+	{
+		for (PartRegistry pr : PartRegistry.values())
+		{
+			if ( pr.getName() == name )
+				return pr.construct( 0 );
+		}
+
+		return null;
+	}
+
+	@Override
+	public boolean canConvert(int blockID)
+	{
+		return PartRegistry.isPart( Block.blocksList[blockID] );
+	}
+
+	@Override
+	public TMultiPart convert(World world, BlockCoord pos)
+	{
+		int blockID = world.getBlockId( pos.x, pos.y, pos.z );
+		int meta = world.getBlockMetadata( pos.x, pos.y, pos.z );
+
+		TMultiPart part = PartRegistry.getPartByBlock( Block.blocksList[blockID], meta );
+		if ( part instanceof CableBusPart )
+		{
+			CableBusPart cbp = (CableBusPart) part;
+			cbp.convertFromTile( world.getTileEntity( pos.x, pos.y, pos.z ) );
+		}
+
+		return part;
+	}
+
+	@Override
+	public void Init() throws Throwable
+	{
+		BlockMicroMaterial.createAndRegister( AEApi.instance().blocks().blockQuartz.block() );
+		BlockMicroMaterial.createAndRegister( AEApi.instance().blocks().blockQuartzPiller.block() );
+		BlockMicroMaterial.createAndRegister( AEApi.instance().blocks().blockQuartzChiseled.block() );
+
+		PartRegistry reg[] = PartRegistry.values();
+
+		String data[] = new String[reg.length];
+		for (int x = 0; x < data.length; x++)
+			data[x] = reg[x].getName();
+
+		MultiPartRegistry.registerConverter( this );
+		MultiPartRegistry.registerParts( this, data );
+
+		MultipartGenerator.registerPassThroughInterface( "appeng.helpers.AEMultiTile" );
+	}
+
+	@Override
+	public void PostInit() throws Throwable
+	{
+		MinecraftForge.EVENT_BUS.register( new FMPEvent() );
+	}
+
+	@Override
+	public IPartHost getOrCreateHost(TileEntity tile)
+	{
+		try
+		{
+			BlockCoord loc = new BlockCoord( tile.xCoord, tile.yCoord, tile.zCoord );
+
+			TileMultipart mp = TileMultipart.getOrConvertTile( tile.worldObj, loc );
+			if ( mp != null )
+			{
+				scala.collection.Iterator<TMultiPart> i = mp.partList().iterator();
+				while (i.hasNext())
+				{
+					TMultiPart p = i.next();
+					if ( p instanceof CableBusPart )
+						return (IPartHost) p;
+				}
+
+				TMultiPart part = PartRegistry.CableBusPart.construct( 0 );
+				if ( mp.canAddPart( part ) && Platform.isServer() )
+					TileMultipart.addPart( tile.worldObj, loc, part );
+				return (CableBusPart) part;
+			}
+		}
+		catch (Throwable t)
+		{
+			AELog.error( t );
+		}
+		return null;
+	}
+
+	@Override
+	public CableBusContainer getCableContainer(TileEntity te)
+	{
+		if ( te instanceof TileMultipart )
+		{
+			TileMultipart mp = (TileMultipart) te;
+			scala.collection.Iterator<TMultiPart> i = mp.partList().iterator();
+			while (i.hasNext())
+			{
+				TMultiPart p = i.next();
+				if ( p instanceof CableBusPart )
+					return ((CableBusPart) p).cb;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public void registerPassThru(Class<?> layerInterface)
+	{
+		try
+		{
+			MultipartGenerator.registerPassThroughInterface( layerInterface.getName() );
+		}
+		catch (Throwable t)
+		{
+			AELog.severe( "Failed to register " + layerInterface.getName() + " with FMP, some features may not work with MultiParts." );
+			AELog.error( t );
+		}
+	}
+
+}

integration/modules/dead/FZ.java

@@ -0,0 +1,215 @@
+package appeng.integration.modules.dead;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import appeng.api.AEApi;
+import appeng.api.storage.IMEInventory;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IFZ;
+import appeng.integration.modules.helpers.dead.FactorizationBarrel;
+import appeng.integration.modules.helpers.dead.FactorizationHandler;
+import appeng.util.Platform;
+
+/**
+ * 100% Hacks.
+ */
+public class FZ implements IFZ, IIntegrationModule
+{
+
+	public static FZ instance;
+
+	private static Class day_BarrelClass;
+	private static Method day_getItemCount;
+	private static Method day_setItemCount;
+	private static Method day_getMaxSize;
+	private static Field day_item;
+
+	private static Class barrelClass;
+	private static Method getItemCount;
+	private static Method setItemCount;
+	private static Method getMaxSize;
+	private static Field item;
+
+	@Override
+	public ItemStack barrelGetItem(TileEntity te)
+	{
+		try
+		{
+			ItemStack i;
+
+			if ( day_BarrelClass.isInstance( te ) )
+				i = (ItemStack) day_item.get( te );
+			else
+				i = (ItemStack) item.get( te );
+
+			if ( i != null )
+				i = Platform.cloneItemStack( i );
+			return i;
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+		catch (IllegalAccessException e)
+		{
+		}
+		return null;
+	}
+
+	@Override
+	public int barrelGetMaxItemCount(TileEntity te)
+	{
+		try
+		{
+			if ( day_BarrelClass.isInstance( te ) )
+				return (Integer) day_getMaxSize.invoke( te );
+			else
+				return (Integer) getMaxSize.invoke( te );
+		}
+		catch (IllegalAccessException e)
+		{
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+		catch (InvocationTargetException e)
+		{
+		}
+		return 0;
+	}
+
+	@Override
+	public int barrelGetItemCount(TileEntity te)
+	{
+		try
+		{
+			if ( day_BarrelClass.isInstance( te ) )
+				return (Integer) day_getItemCount.invoke( te );
+			else
+				return (Integer) getItemCount.invoke( te );
+		}
+		catch (IllegalAccessException e)
+		{
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+		catch (InvocationTargetException e)
+		{
+		}
+		return 0;
+	}
+
+	@Override
+	public void setItemType(TileEntity te, ItemStack input)
+	{
+		try
+		{
+			if ( day_BarrelClass.isInstance( te ) )
+				day_item.set( te, input == null ? null : input.copy() );
+			else
+				item.set( te, input == null ? null : input.copy() );
+
+			te.markDirty();
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+		catch (IllegalAccessException e)
+		{
+		}
+	}
+
+	@Override
+	public void barrelSetCount(TileEntity te, int max)
+	{
+		try
+		{
+			if ( day_BarrelClass.isInstance( te ) )
+				day_setItemCount.invoke( te, max );
+			else
+				setItemCount.invoke( te, max );
+
+			te.markDirty();
+		}
+		catch (IllegalAccessException e)
+		{
+		}
+		catch (IllegalArgumentException e)
+		{
+		}
+		catch (InvocationTargetException e)
+		{
+		}
+	}
+
+	@Override
+	public IMEInventory getFactorizationBarrel(TileEntity te)
+	{
+		return new FactorizationBarrel( this, te );
+	}
+
+	@Override
+	public boolean isBarrel(TileEntity te)
+	{
+		if ( day_BarrelClass.isAssignableFrom( te.getClass() ) )
+			return true;
+		if ( barrelClass.isAssignableFrom( te.getClass() ) )
+			return true;
+		return false;
+	}
+
+	@Override
+	public void Init() throws Throwable
+	{
+		barrelClass = Class.forName( "factorization.weird.TileEntityBarrel" );
+		day_BarrelClass = Class.forName( "factorization.weird.TileEntityDayBarrel" );
+
+		getItemCount = barrelClass.getDeclaredMethod( "getItemCount", new Class[] {} );
+		setItemCount = barrelClass.getDeclaredMethod( "setItemCount", new Class[] { int.class } );
+		getMaxSize = barrelClass.getDeclaredMethod( "getMaxSize", new Class[] {} );
+		item = barrelClass.getDeclaredField( "item" );
+
+		day_getItemCount = day_BarrelClass.getDeclaredMethod( "getItemCount", new Class[] {} );
+		day_setItemCount = day_BarrelClass.getDeclaredMethod( "setItemCount", new Class[] { int.class } );
+		day_getMaxSize = day_BarrelClass.getDeclaredMethod( "getMaxSize", new Class[] {} );
+		day_item = day_BarrelClass.getDeclaredField( "item" );
+	}
+
+	@Override
+	public void PostInit()
+	{
+		AEApi.instance().registries().externalStorage().addExternalStorageInterface( new FactorizationHandler() );
+
+		// certus quartz
+		grinderRecipe( AEApi.instance().materials().materialCertusQuartzCrystal.stack( 1 ), AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		grinderRecipe( AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( 1 ),
+				AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		// fluix
+		grinderRecipe( AEApi.instance().materials().materialFluixCrystal.stack( 1 ), AEApi.instance().materials().materialFluixDust.stack( 1 ) );
+
+		// nether quartz
+		grinderRecipe( new ItemStack( Item.netherQuartz ), AEApi.instance().materials().materialNetherQuartzDust.stack( 1 ) );
+	}
+
+	private void grinderRecipe(ItemStack in, ItemStack out)
+	{
+		try
+		{
+			Class c = Class.forName( "factorization.common.TileEntityGrinder" );
+			Method m = c.getMethod( "addRecipe", Object.class, ItemStack.class, float.class );
+			m.invoke( c, in, out, 1.0 );
+		}
+		catch (Throwable t)
+		{
+			// AELog.info( "" );
+			// throw new RuntimeException( t );
+		}
+	}
+}

integration/modules/dead/Forestry.java

@@ -0,0 +1,24 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+
+public class Forestry implements IIntegrationModule
+{
+
+	public static Forestry instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

integration/modules/dead/GT.java

@@ -0,0 +1,46 @@
+package appeng.integration.modules.dead;
+
+import gregtechmod.api.interfaces.IDigitalChest;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.storage.IMEInventory;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IGT;
+import appeng.integration.modules.helpers.dead.GregTechHandler;
+import appeng.integration.modules.helpers.dead.GregTechQuantumChest;
+import appeng.util.InventoryAdaptor;
+
+public class GT implements IGT, IIntegrationModule
+{
+
+	public static GT instance;
+
+	@Override
+	public IMEInventory getQuantumChest(TileEntity te)
+	{
+		return new GregTechQuantumChest( (IInventory) te, InventoryAdaptor.getAdaptor( te, ForgeDirection.NORTH ) );
+	}
+
+	@Override
+	public boolean isQuantumChest(TileEntity te)
+	{
+		if ( te instanceof IDigitalChest )
+			return ((IDigitalChest) te).isDigitalChest();
+		return false;
+	}
+
+	@Override
+	public void Init()
+	{
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		AEApi.instance().registries().externalStorage().addExternalStorageInterface( new GregTechHandler() );
+	}
+
+}

integration/modules/dead/IC2.java

@@ -0,0 +1,70 @@
+package appeng.integration.modules.dead;
+
+import ic2.api.energy.tile.IEnergyTile;
+import ic2.api.recipe.RecipeInputItemStack;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.api.AEApi;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IIC2;
+
+public class IC2 implements IIntegrationModule, IIC2
+{
+
+	public static IC2 instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		AEApi.instance().registries().matterCannon().registerAmmo( getItem( "uraniumDrop" ), 238.0289 );
+
+		// certus quartz
+		maceratorRecipe( AEApi.instance().materials().materialCertusQuartzCrystal.stack( 1 ), AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		maceratorRecipe( AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( 1 ), AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		// fluix
+		maceratorRecipe( AEApi.instance().materials().materialFluixCrystal.stack( 1 ), AEApi.instance().materials().materialFluixDust.stack( 1 ) );
+
+		// nether quartz
+		maceratorRecipe( new ItemStack( Item.netherQuartz ), AEApi.instance().materials().materialNetherQuartzDust.stack( 1 ) );
+	}
+
+	/*
+	 * private void compressorRecipe(ItemStack in, ItemStack out) {
+	 * ic2.api.recipe.Recipes.compressor.addRecipe( new RecipeInputItemStack(
+	 * in, in.stackSize ), null, out ); }
+	 */
+	private void maceratorRecipe(ItemStack in, ItemStack out)
+	{
+		ic2.api.recipe.Recipes.macerator.addRecipe( new RecipeInputItemStack( in, in.stackSize ), null, out );
+	}
+
+	@Override
+	public void addToEnergyNet(TileEntity appEngTile)
+	{
+		MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergyTile) appEngTile ) );
+	}
+
+	@Override
+	public void removeFromEnergyNet(TileEntity appEngTile)
+	{
+		MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergyTile) appEngTile ) );
+	}
+
+	@Override
+	public ItemStack getItem(String name)
+	{
+		return ic2.api.item.Items.getItem( name );
+	}
+
+}

integration/modules/dead/InvTweaks.java

@@ -0,0 +1,24 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+
+public class InvTweaks implements IIntegrationModule
+{
+
+	public static InvTweaks instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

integration/modules/dead/LP.java

@@ -0,0 +1,24 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+
+public class LP implements IIntegrationModule
+{
+
+	public static LP instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

integration/modules/dead/MJ.java

@@ -0,0 +1,39 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.IMJ;
+import appeng.integration.modules.helpers.BaseBCperdition;
+import appeng.integration.modules.helpers.dead.BCPerdition;
+import appeng.tile.powersink.BuildCraft;
+import buildcraft.api.power.IPowerReceptor;
+
+public class MJ implements IIntegrationModule, IMJ
+{
+
+	public static MJ instance;
+
+	@Override
+	public BaseBCperdition createPerdition(BuildCraft buildCraft)
+	{
+		if ( buildCraft instanceof IPowerReceptor )
+			return new BCPerdition( buildCraft );
+		return null;
+	}
+
+	@Override
+	public void Init() throws Throwable
+	{
+		if ( ((Object) this) instanceof BCPerdition )
+		{
+
+		}
+	}
+
+	@Override
+	public void PostInit() throws Throwable
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

integration/modules/dead/Mekanism.java

@@ -0,0 +1,41 @@
+package appeng.integration.modules.dead;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import appeng.api.AEApi;
+import appeng.integration.IIntegrationModule;
+
+public class Mekanism implements IIntegrationModule
+{
+
+	public static Mekanism instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// certus quartz
+		crusher( AEApi.instance().materials().materialCertusQuartzCrystal.stack( 1 ),
+				AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		crusher( AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( 1 ),
+				AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		// fluix
+		crusher( AEApi.instance().materials().materialFluixCrystal.stack( 1 ), AEApi.instance().materials().materialFluixDust.stack( 1 ) );
+
+		// nether quartz
+		crusher( new ItemStack( Item.netherQuartz ), AEApi.instance().materials().materialNetherQuartzDust.stack( 1 ) );
+	}
+
+	private void crusher(ItemStack input, ItemStack output)
+	{
+		mekanism.api.RecipeHelper.addCrusherRecipe( input, output );
+	}
+}

integration/modules/dead/Mystcraft.java

@@ -0,0 +1,24 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+
+public class Mystcraft implements IIntegrationModule
+{
+
+	public static Mystcraft instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

integration/modules/dead/NEI.java

@@ -0,0 +1,42 @@
+package appeng.integration.modules.dead;
+
+import java.lang.reflect.Method;
+
+import appeng.integration.IIntegrationModule;
+import appeng.integration.modules.helpers.NEIQuartzShapedRecipeHandler;
+
+public class NEI implements IIntegrationModule
+{
+
+	public static NEI instance;
+
+	@Override
+	public void Init() throws Throwable
+	{
+		Class API = Class.forName( "codechicken.nei.api.API" );
+		Method registerRecipeHandler = API.getDeclaredMethod( "registerRecipeHandler", new Class[] { codechicken.nei.recipe.ICraftingHandler.class } );
+		Method registerUsageHandler = API.getDeclaredMethod( "registerUsageHandler", new Class[] { codechicken.nei.recipe.IUsageHandler.class } );
+
+		registerRecipeHandler.invoke( API, new NEIQuartzShapedRecipeHandler() );
+		registerUsageHandler.invoke( API, new NEIQuartzShapedRecipeHandler() );
+
+		/*
+		 * Method registerGuiOverlay = API.getDeclaredMethod( "registerGuiOverlay", new Class[] { Class.class,
+		 * String.class, int.class, int.class } ); Class IOverlayHandler = Class.forName(
+		 * "codechicken.nei.api.IOverlayHandler" ); Class DefaultOverlayHandler =
+		 * NEICraftingTerminalOverlayHandler.class; Method registerGuiOverlayHandler = API.getDeclaredMethod(
+		 * "registerGuiOverlayHandler", new Class[] { Class.class, IOverlayHandler, String.class } );
+		 * registerGuiOverlay.invoke( API, GuiCraftingTerminal.class, "crafting", 6, 75 ); Constructor
+		 * DefaultOverlayHandlerConstructor = DefaultOverlayHandler .getConstructor( new Class[] { int.class, int.class
+		 * } ); registerGuiOverlayHandler.invoke( API, GuiCraftingTerminal.class,
+		 * DefaultOverlayHandlerConstructor.newInstance( 6, 75 ), "crafting" );
+		 */
+	}
+
+	@Override
+	public void PostInit() throws Throwable
+	{
+
+	}
+
+}

integration/modules/dead/RC.java

@@ -0,0 +1,51 @@
+package appeng.integration.modules.dead;
+
+import mods.railcraft.api.crafting.IRockCrusherRecipe;
+import mods.railcraft.api.crafting.RailcraftCraftingManager;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import appeng.api.AEApi;
+import appeng.integration.IIntegrationModule;
+
+public class RC implements IIntegrationModule
+{
+
+	public static RC instance;
+
+	public void rockCrusher(ItemStack input, ItemStack output)
+	{
+		IRockCrusherRecipe re = RailcraftCraftingManager.rockCrusher.createNewRecipe( input, true, true );
+		re.addOutput( output, 1.0f );
+	}
+
+	public void rockCrusher(ItemStack input, ItemStack output, ItemStack secondary, float chance)
+	{
+		IRockCrusherRecipe re = RailcraftCraftingManager.rockCrusher.createNewRecipe( input, true, true );
+		re.addOutput( output, 1.0f );
+		if ( secondary != null ) re.addOutput( secondary, chance );
+	}
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// certus quartz
+		rockCrusher( AEApi.instance().materials().materialCertusQuartzCrystal.stack( 1 ),
+				AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		rockCrusher( AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( 1 ),
+				AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		// fluix
+		rockCrusher( AEApi.instance().materials().materialFluixCrystal.stack( 1 ), AEApi.instance().materials().materialFluixDust.stack( 1 ) );
+
+		// nether quartz
+		rockCrusher( new ItemStack( Item.netherQuartz ), AEApi.instance().materials().materialNetherQuartzDust.stack( 1 ) );
+	}
+}

integration/modules/dead/TE.java

@@ -0,0 +1,79 @@
+package appeng.integration.modules.dead;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.integration.IIntegrationModule;
+import appeng.integration.abstraction.ITE;
+import cofh.api.transport.IItemConduit;
+import cpw.mods.fml.common.event.FMLInterModComms;
+
+public class TE implements IIntegrationModule, ITE
+{
+
+	public static TE instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// certus quartz
+		pulverizer( AEApi.instance().materials().materialCertusQuartzCrystal.stack( 1 ), AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		pulverizer( AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( 1 ), AEApi.instance().materials().materialCertusQuartzDust.stack( 1 ) );
+
+		// fluix
+		pulverizer( AEApi.instance().materials().materialFluixCrystal.stack( 1 ), AEApi.instance().materials().materialFluixDust.stack( 1 ) );
+
+		// nether quartz
+		pulverizer( new ItemStack( Item.netherQuartz ), AEApi.instance().materials().materialNetherQuartzDust.stack( 1 ) );
+	}
+
+	private void pulverizer(ItemStack in, ItemStack out)
+	{
+		NBTTagCompound toSend = new NBTTagCompound();
+		toSend.setInteger( "energy", 3200 );
+		toSend.setTag( "input", new NBTTagCompound() );
+		toSend.setTag( "primaryOutput", new NBTTagCompound() );
+
+		in.writeToNBT( toSend.getCompoundTag( "input" ) );
+		out.writeToNBT( toSend.getCompoundTag( "primaryOutput" ) );
+		FMLInterModComms.sendMessage( "ThermalExpansion", "PulverizerRecipe", toSend );
+	}
+
+	@Override
+	public ItemStack addItemsToPipe(TileEntity ad, ItemStack itemstack, ForgeDirection dir)
+	{
+		return ((IItemConduit) ad).insertItem( dir, itemstack );
+	}
+
+	@Override
+	public void addPulverizerRecipe(int i, ItemStack blkQuartz, ItemStack blockDust)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void addPulverizerRecipe(int i, ItemStack blkQuartzOre, ItemStack matQuartz, ItemStack matQuartzDust)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public boolean isPipe(TileEntity te, ForgeDirection opposite)
+	{
+		return te instanceof IItemConduit;
+	}
+
+}

integration/modules/dead/UE.java

@@ -0,0 +1,24 @@
+package appeng.integration.modules.dead;
+
+import appeng.integration.IIntegrationModule;
+
+public class UE implements IIntegrationModule
+{
+
+	public static UE instance;
+
+	@Override
+	public void Init()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void PostInit()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}