Merge branch 'master' of https://bitbucket.org/AlgorithmX2/appliedenergistics2 into rv1

Conflicts:
	core/localization/GuiText.java

client/me/ItemRepo.java

@@ -239,7 +239,7 @@ public class ItemRepo
 			String dspName = Platform.getItemDisplayName( is );
 			notDone = true;
 
-			if ( m.matcher( dspName ).find() )
+			if ( m.matcher( dspName.toLowerCase() ).find() )
 			{
 				view.add( is );
 				notDone = false;

core/Registration.java

@@ -481,29 +481,27 @@ public class Registration
 			recipeHandler.parseRecipes( new JarLoader( "/assets/appliedenergistics2/recipes/" ), "index.recipe" );
 
 		IPartHelper ph = AEApi.instance().partHelper();
-		ph.registerNewLayer( "appeng.api.parts.layers.LayerISidedInventory", "net.minecraft.inventory.ISidedInventory" );
-		ph.registerNewLayer( "appeng.api.parts.layers.LayerIFluidHandler", "net.minecraftforge.fluids.IFluidHandler" );
-		ph.registerNewLayer( "appeng.api.parts.layers.LayerITileStorageMonitorable", "appeng.api.implementations.tiles.ITileStorageMonitorable" );
+		ph.registerNewLayer( "appeng.parts.layers.LayerISidedInventory", "net.minecraft.inventory.ISidedInventory" );
+		ph.registerNewLayer( "appeng.parts.layers.LayerIFluidHandler", "net.minecraftforge.fluids.IFluidHandler" );
+		ph.registerNewLayer( "appeng.parts.layers.LayerITileStorageMonitorable", "appeng.api.implementations.tiles.ITileStorageMonitorable" );
 
 		if ( AppEng.instance.isIntegrationEnabled( "IC2" ) )
 		{
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergySink", "ic2.api.energy.tile.IEnergySink" );
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergySource", "ic2.api.energy.tile.IEnergySource" );
+			ph.registerNewLayer( "appeng.parts.layers.LayerIEnergySink", "ic2.api.energy.tile.IEnergySink" );
+			ph.registerNewLayer( "appeng.parts.layers.LayerIEnergySource", "ic2.api.energy.tile.IEnergySource" );
 		}
 
 		if ( AppEng.instance.isIntegrationEnabled( "MJ5" ) )
 		{
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIPowerEmitter", "buildcraft.api.power.IPowerEmitter" );
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIPowerReceptor", "buildcraft.api.power.IPowerReceptor" );
+			ph.registerNewLayer( "appeng.parts.layers.LayerIPowerEmitter", "buildcraft.api.power.IPowerEmitter" );
+			ph.registerNewLayer( "appeng.parts.layers.LayerIPowerReceptor", "buildcraft.api.power.IPowerReceptor" );
 		}
 
 		if ( AppEng.instance.isIntegrationEnabled( "MJ6" ) )
-		{
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIBatteryProvider", "buildcraft.api.mj.IBatteryProvider" );
-		}
+			ph.registerNewLayer( "appeng.parts.layers.LayerIBatteryProvider", "buildcraft.api.mj.IBatteryProvider" );
 
 		if ( AppEng.instance.isIntegrationEnabled( "RF" ) )
-			ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergyHandler", "cofh.api.energy.IEnergyHandler" );
+			ph.registerNewLayer( "appeng.parts.layers.LayerIEnergyHandler", "cofh.api.energy.IEnergyHandler" );
 
 		FMLCommonHandler.instance().bus().register( TickHandler.instance );
 		MinecraftForge.EVENT_BUS.register( TickHandler.instance );

core/localization/GuiText.java

@@ -28,7 +28,7 @@ public enum GuiText
 
 	CopyMode, CopyModeDesc, PatternTerminal, CraftingPattern, ProcessingPattern, Crafts, Creates, And, With, MolecularAssembler,
 
-	StoredPower, MaxPower, RequiredPower, Efficiency, InWorldCrafting, inWorldFluix, inWorldPurification, inWorldSingularity,
+	StoredPower, MaxPower, RequiredPower, Efficiency, InWorldCrafting, inWorldFluix, inWorldPurificationCertus, inWorldPurificationNether, inWorldPurificationFluix, inWorldSingularity,
 
 	OfSecondOutput, NoSecondOutput, RFTunnel, Stores, Next, SelectAmount, Lumen, Empty;
 

integration/modules/NEIHelpers/NEIWorldCraftingHandler.java

@@ -55,9 +55,9 @@ public class NEIWorldCraftingHandler implements ICraftingHandler, IUsageHandler
 
 		if ( AEConfig.instance.isFeatureEnabled( AEFeature.inWorldPurification ) )
 		{
-			addRecipe( AEApi.instance().materials().materialPureifiedCertusQuartzCrystal, GuiText.inWorldPurification.getLocal() );
-			addRecipe( AEApi.instance().materials().materialPureifiedNetherQuartzCrystal, GuiText.inWorldPurification.getLocal() );
-			addRecipe( AEApi.instance().materials().materialPureifiedFluixCrystal, GuiText.inWorldPurification.getLocal() );
+			addRecipe( AEApi.instance().materials().materialPureifiedCertusQuartzCrystal, GuiText.inWorldPurificationCertus.getLocal() );
+			addRecipe( AEApi.instance().materials().materialPureifiedNetherQuartzCrystal, GuiText.inWorldPurificationNether.getLocal() );
+			addRecipe( AEApi.instance().materials().materialPureifiedFluixCrystal, GuiText.inWorldPurificationFluix.getLocal() );
 		}
 	}
 

me/helpers/AENetworkProxy.java

@@ -36,7 +36,7 @@ public class AENetworkProxy implements IGridBlock
 	final private IGridProxyable gp;
 	final private boolean worldNode;
 
-	final private ItemStack myRepInstance;
+	private ItemStack myRepInstance;
 
 	private boolean isReady = false;
 	private IGridNode node = null;
@@ -57,7 +57,12 @@ public class AENetworkProxy implements IGridBlock
 	{
 		return myRepInstance;
 	}
-
+	
+	public void setVisualRepresentation( ItemStack is )
+	{
+		myRepInstance = is;
+	}
+	
 	public AENetworkProxy(IGridProxyable te, String nbtName, ItemStack visual, boolean inWorld) {
 		this.gp = te;
 		this.nbtName = nbtName;

parts/CableBusContainer.java

@@ -40,6 +40,7 @@ import appeng.api.util.AEColor;
 import appeng.api.util.DimensionalCoord;
 import appeng.client.render.BusRenderHelper;
 import appeng.client.render.CableRenderHelper;
+import appeng.core.AELog;
 import appeng.core.AppEng;
 import appeng.facade.FacadeContainer;
 import appeng.helpers.AEMultiTile;
@@ -704,7 +705,9 @@ public class CableBusContainer implements AEMultiTile, ICableBusContainer
 						p.readFromNBT( extra );
 					}
 					else
-						throw new RuntimeException( "Invalid NBT For CableBus Container: " + iss.getItem().getClass().getName() + " is not a valid part." );
+					{
+						AELog.warning( "Invalid NBT For CableBus Container: " + iss.getItem().getClass().getName() + " is not a valid part; it was ignored." );
+					}
 				}
 			}
 			else

parts/automation/PartAnnihilationPlane.java

@@ -2,6 +2,7 @@ package appeng.parts.automation;
 
 import java.io.IOException;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.concurrent.Callable;
 
 import net.minecraft.block.Block;
@@ -203,6 +204,14 @@ public class PartAnnihilationPlane extends PartBasicState implements IGridTickab
 		return Buffer.isEmpty();
 	}
 
+	@Override
+	public void getDrops(List<ItemStack> drops, boolean wrenched)
+	{
+		for (IAEItemStack is : Buffer)
+			if ( is != null )
+				drops.add( is.getItemStack() );
+	}
+
 	@MENetworkEventSubscribe
 	public void chanRender(MENetworkChannelsChanged c)
 	{

parts/layers/InvSot.java

@@ -0,0 +1,47 @@
+package appeng.parts.layers;
+
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+
+public class InvSot
+{
+
+	final public ISidedInventory partInv;
+	final public int index;
+
+	public InvSot(ISidedInventory part, int slot) {
+		partInv = part;
+		index = slot;
+	}
+
+	public ItemStack decrStackSize(int j)
+	{
+		return partInv.decrStackSize( index, j );
+	}
+
+	public ItemStack getStackInSlot()
+	{
+		return partInv.getStackInSlot( index );
+	}
+
+	public boolean isItemValidForSlot(ItemStack itemstack)
+	{
+		return partInv.isItemValidForSlot( index, itemstack );
+	}
+
+	public void setInventorySlotContents(ItemStack itemstack)
+	{
+		partInv.setInventorySlotContents( index, itemstack );
+	}
+
+	public boolean canExtractItem(ItemStack itemstack, int side)
+	{
+		return partInv.canExtractItem( index, itemstack, side );
+	}
+
+	public boolean canInsertItem(ItemStack itemstack, int side)
+	{
+		return partInv.canInsertItem( index, itemstack, side );
+	}
+
+}

parts/layers/LayerIBatteryProvider.java

@@ -0,0 +1,23 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+import buildcraft.api.mj.IBatteryObject;
+import buildcraft.api.mj.ISidedBatteryProvider;
+
+public class LayerIBatteryProvider extends LayerBase implements ISidedBatteryProvider
+{
+
+	@Override
+	public IBatteryObject getMjBattery(String kind, ForgeDirection direction)
+	{
+		IPart p = getPart( direction );
+
+		if ( p instanceof ISidedBatteryProvider )
+			return ((ISidedBatteryProvider) p).getMjBattery( kind, direction );
+
+		return null;
+	}
+
+}

parts/layers/LayerIEnergyHandler.java

@@ -0,0 +1,61 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+import cofh.api.energy.IEnergyHandler;
+
+public class LayerIEnergyHandler extends LayerBase implements IEnergyHandler
+{
+
+	@Override
+	public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IEnergyHandler )
+			return ((IEnergyHandler) part).receiveEnergy( from, maxReceive, simulate );
+
+		return 0;
+	}
+
+	@Override
+	public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IEnergyHandler )
+			return ((IEnergyHandler) part).extractEnergy( from, maxExtract, simulate );
+
+		return 0;
+	}
+
+	@Override
+	public int getEnergyStored(ForgeDirection from)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IEnergyHandler )
+			return ((IEnergyHandler) part).getEnergyStored( from );
+
+		return 0;
+	}
+
+	@Override
+	public int getMaxEnergyStored(ForgeDirection from)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IEnergyHandler )
+			return ((IEnergyHandler) part).getMaxEnergyStored( from );
+
+		return 0;
+	}
+
+	@Override
+	public boolean canConnectEnergy(ForgeDirection from)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IEnergyHandler )
+			return ((IEnergyHandler) part).canConnectEnergy( from );
+
+		return false;
+	}
+
+}

parts/layers/LayerIEnergySink.java

@@ -0,0 +1,146 @@
+package appeng.parts.layers;
+
+import ic2.api.energy.tile.IEnergySink;
+import ic2.api.energy.tile.IEnergyTile;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.LayerBase;
+import appeng.api.parts.LayerFlags;
+import appeng.util.Platform;
+
+public class LayerIEnergySink extends LayerBase implements IEnergySink
+{
+
+	private boolean isInIC2()
+	{
+		return getLayerFlags().contains( LayerFlags.IC2_ENET );
+	}
+
+	private TileEntity getEnergySinkTile()
+	{
+		IPartHost host = (IPartHost) this;
+		return host.getTile();
+	}
+
+	private World getEnergySinkWorld()
+	{
+		if ( getEnergySinkTile() == null )
+			return null;
+		
+		return getEnergySinkTile().getWorldObj();
+	}
+
+	final private void addToENet()
+	{
+		if ( getEnergySinkWorld() == null )
+			return;
+
+		// re-add
+		removeFromENet();
+
+		if ( !isInIC2() && Platform.isServer() )
+		{
+			getLayerFlags().add( LayerFlags.IC2_ENET );
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergySink) getEnergySinkTile() ) );
+		}
+	}
+
+	final private void removeFromENet()
+	{
+		if ( getEnergySinkWorld() == null )
+			return;
+
+		if ( isInIC2() && Platform.isServer() )
+		{
+			getLayerFlags().remove( LayerFlags.IC2_ENET );
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergySink) getEnergySinkTile() ) );
+		}
+	}
+
+	final private boolean interestedInIC2()
+	{
+		int interested = 0;
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergyTile )
+			{
+				interested++;
+			}
+		}
+		return interested == 1;// if more then one tile is interested we need to abandonship...
+	}
+
+	@Override
+	public void partChanged()
+	{
+		super.partChanged();
+
+		if ( interestedInIC2() )
+			addToENet();
+		else
+			removeFromENet();
+	}
+
+	@Override
+	public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
+	{
+		if ( !isInIC2() )
+			return false;
+
+		IPart part = getPart( direction );
+		if ( part instanceof IEnergySink )
+			return ((IEnergySink) part).acceptsEnergyFrom( emitter, direction );
+		return false;
+	}
+
+	@Override
+	public double demandedEnergyUnits()
+	{
+		if ( !isInIC2() )
+			return 0;
+
+		// this is a flawed implementation, that requires a change to the IC2 API.
+
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergySink )
+			{
+				// use lower number cause ic2 deletes power it sends that isn't recieved.
+				return ((IEnergySink) part).demandedEnergyUnits();
+			}
+		}
+
+		return 0;
+	}
+
+	@Override
+	public double injectEnergyUnits(ForgeDirection directionFrom, double amount)
+	{
+		if ( !isInIC2() )
+			return amount;
+
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergySink )
+			{
+				return ((IEnergySink) part).injectEnergyUnits( directionFrom, amount );
+			}
+		}
+
+		return amount;
+	}
+
+	@Override
+	public int getMaxSafeInput()
+	{
+		return Integer.MAX_VALUE; // no real options here...
+	}
+
+}

parts/layers/LayerIEnergySource.java

@@ -0,0 +1,139 @@
+package appeng.parts.layers;
+
+import ic2.api.energy.tile.IEnergyEmitter;
+import ic2.api.energy.tile.IEnergySink;
+import ic2.api.energy.tile.IEnergySource;
+import ic2.api.energy.tile.IEnergyTile;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.LayerBase;
+import appeng.api.parts.LayerFlags;
+import appeng.util.Platform;
+
+public class LayerIEnergySource extends LayerBase implements IEnergySource
+{
+
+	private boolean isInIC2()
+	{
+		return getLayerFlags().contains( LayerFlags.IC2_ENET );
+	}
+
+	private TileEntity getEnergySourceTile()
+	{
+		IPartHost host = (IPartHost) this;
+		return host.getTile();
+	}
+
+	private World getEnergySourceWorld()
+	{
+		if ( getEnergySourceTile() == null )
+			return null;
+		return getEnergySourceTile().getWorldObj();
+	}
+
+	final private void addToENet()
+	{
+		if ( getEnergySourceWorld() == null )
+			return;
+
+		// re-add
+		removeFromENet();
+
+		if ( !isInIC2() && Platform.isServer() )
+		{
+			getLayerFlags().add( LayerFlags.IC2_ENET );
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergySink) getEnergySourceTile() ) );
+		}
+	}
+
+	final private void removeFromENet()
+	{
+		if ( getEnergySourceWorld() == null )
+			return;
+
+		if ( isInIC2() && Platform.isServer() )
+		{
+			getLayerFlags().remove( LayerFlags.IC2_ENET );
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergySink) getEnergySourceTile() ) );
+		}
+	}
+
+	final private boolean interestedInIC2()
+	{
+		int interested = 0;
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergyTile )
+			{
+				interested++;
+			}
+		}
+		return interested == 1;// if more then one tile is interested we need to abandonship...
+	}
+
+	@Override
+	public void partChanged()
+	{
+		super.partChanged();
+
+		if ( interestedInIC2() )
+			addToENet();
+		else
+			removeFromENet();
+	}
+
+	@Override
+	public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction)
+	{
+		if ( !isInIC2() )
+			return false;
+
+		IPart part = getPart( direction );
+		if ( part instanceof IEnergySink )
+			return ((IEnergyEmitter) part).emitsEnergyTo( receiver, direction );
+		return false;
+	}
+
+	@Override
+	public double getOfferedEnergy()
+	{
+		if ( !isInIC2() )
+			return 0;
+
+		// this is a flawed implementation, that requires a change to the IC2 API.
+
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergySource )
+			{
+				// use lower number cause ic2 deletes power it sends that isn't recieved.
+				return ((IEnergySource) part).getOfferedEnergy();
+			}
+		}
+
+		return 0;
+	}
+
+	@Override
+	public void drawEnergy(double amount)
+	{
+		// this is a flawed implementation, that requires a change to the IC2 API.
+
+		for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart part = getPart( dir );
+			if ( part instanceof IEnergySource )
+			{
+				((IEnergySource) part).drawEnergy( amount );
+				return;
+			}
+		}
+	}
+
+}

parts/layers/LayerIFluidHandler.java

@@ -0,0 +1,69 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+
+public class LayerIFluidHandler extends LayerBase implements IFluidHandler
+{
+
+	static final FluidTankInfo[] emptyList = new FluidTankInfo[0];
+
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).fill( from, resource, doFill );
+		return 0;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).drain( from, resource, doDrain );
+		return null;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).drain( from, maxDrain, doDrain );
+		return null;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, net.minecraftforge.fluids.Fluid fluid)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).canFill( from, fluid );
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, net.minecraftforge.fluids.Fluid fluid)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).canDrain( from, fluid );
+		return false;
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from)
+	{
+		IPart part = getPart( from );
+		if ( part instanceof IFluidHandler )
+			return ((IFluidHandler) part).getTankInfo( from );
+		return emptyList;
+	}
+
+}

parts/layers/LayerIPipeConnection.java

@@ -0,0 +1,21 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+import buildcraft.api.transport.IPipeConnection;
+import buildcraft.api.transport.IPipeTile.PipeType;
+
+public class LayerIPipeConnection extends LayerBase implements IPipeConnection
+{
+
+	@Override
+	public ConnectOverride overridePipeConnection(PipeType type, ForgeDirection with)
+	{
+		IPart part = getPart( with );
+		if ( part instanceof IPipeConnection )
+			return ((IPipeConnection) part).overridePipeConnection( type, with );
+		return ConnectOverride.DEFAULT;
+	}
+
+}

parts/layers/LayerIPowerEmitter.java

@@ -0,0 +1,19 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+import buildcraft.api.power.IPowerEmitter;
+
+public class LayerIPowerEmitter extends LayerBase implements IPowerEmitter
+{
+
+	@Override
+	public boolean canEmitPowerFrom(ForgeDirection side)
+	{
+		IPart part = getPart( side );
+		if ( part instanceof IPowerEmitter )
+			return ((IPowerEmitter) part).canEmitPowerFrom( side );
+		return false;
+	}
+}

parts/layers/LayerIPowerReceptor.java

@@ -0,0 +1,36 @@
+package appeng.parts.layers;
+
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.LayerBase;
+import buildcraft.api.power.IPowerReceptor;
+import buildcraft.api.power.PowerHandler;
+import buildcraft.api.power.PowerHandler.PowerReceiver;
+
+public class LayerIPowerReceptor extends LayerBase implements IPowerReceptor
+{
+
+	@Override
+	public PowerReceiver getPowerReceiver(ForgeDirection side)
+	{
+		IPart part = getPart( side );
+		if ( part instanceof IPowerReceptor )
+			return ((IPowerReceptor) part).getPowerReceiver( side );
+		return null;
+	}
+
+	@Override
+	public void doWork(PowerHandler workProvider)
+	{
+		// do nothing, this seems pointless.
+	}
+
+	@Override
+	public World getWorld()
+	{
+		return ((IPartHost) this).getTile().getWorldObj();
+	}
+
+}

parts/layers/LayerISidedInventory.java

@@ -0,0 +1,228 @@
+package appeng.parts.layers;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.LayerBase;
+
+/**
+ * Inventory wrapper for parts,
+ * 
+ * this is considerably more complicated then the other wrappers as it requires creating a "unified inventory".
+ * 
+ * You must use {@link ISidedInventory} instead of {@link IInventory}.
+ * 
+ * If your inventory changes in between placement and removal, you must trigger a PartChange on the {@link IPartHost} so
+ * it can recalculate the inventory wrapper.
+ */
+public class LayerISidedInventory extends LayerBase implements ISidedInventory
+{
+
+	// a simple empty array for empty stuff..
+	private final static int[] nullSides = new int[] {};
+
+	// cache of inventory state.
+	private int sides[][] = null;
+	private List<ISidedInventory> invs = null;
+	private List<InvSot> slots = null;
+
+	/**
+	 * Recalculate inventory wrapper cache.
+	 */
+	@Override
+	public void partChanged()
+	{
+		invs = new ArrayList();
+		int slotCount = 0;
+
+		for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
+		{
+			IPart bp = getPart( side );
+			if ( bp instanceof ISidedInventory )
+			{
+				ISidedInventory part = (ISidedInventory) bp;
+				slotCount += part.getSizeInventory();
+				invs.add( part );
+			}
+		}
+
+		if ( invs.isEmpty() || slotCount == 0 )
+		{
+			invs = null;
+			sides = null;
+			slots = null;
+		}
+		else
+		{
+			sides = new int[][] { nullSides, nullSides, nullSides, nullSides, nullSides, nullSides };
+			slots = new ArrayList<InvSot>( Collections.nCopies( slotCount, (InvSot) null ) );
+
+			int offsetForLayer = 0;
+			int offsetForPart = 0;
+			for (ISidedInventory sides : invs)
+			{
+				offsetForPart = 0;
+				slotCount = sides.getSizeInventory();
+
+				ForgeDirection currentSide = ForgeDirection.UNKNOWN;
+				for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
+					if ( getPart( side ) == sides )
+					{
+						currentSide = side;
+						break;
+					}
+
+				int cSidesList[] = this.sides[currentSide.ordinal()] = new int[slotCount];
+				for (int cSlot = 0; cSlot < slotCount; cSlot++)
+				{
+					cSidesList[cSlot] = offsetForLayer;
+					slots.set( offsetForLayer++, new InvSot( sides, offsetForPart++ ) );
+				}
+			}
+		}
+
+		// make sure inventory is updated before we call FMP.
+		super.partChanged();
+	}
+
+	/**
+	 * check if a slot index is valid, prevent crashes from bad code :)
+	 * 
+	 * @param slot
+	 * @return true, if the slot exists.
+	 */
+	boolean isSlotValid(int slot)
+	{
+		return slots != null && slot >= 0 && slot < slots.size();
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int amount)
+	{
+		if ( isSlotValid( slot ) )
+			return slots.get( slot ).decrStackSize( amount );
+
+		return null;
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		if ( slots == null )
+			return 0;
+
+		return slots.size();
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int slot)
+	{
+		if ( isSlotValid( slot ) )
+			return slots.get( slot ).getStackInSlot();
+
+		return null;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack itemstack)
+	{
+		if ( isSlotValid( slot ) )
+			return slots.get( slot ).isItemValidForSlot( itemstack );
+
+		return false;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack itemstack)
+	{
+		if ( isSlotValid( slot ) )
+			slots.get( slot ).setInventorySlotContents( itemstack );
+	}
+
+	@Override
+	public boolean canExtractItem(int slot, ItemStack itemstack, int side)
+	{
+		if ( isSlotValid( slot ) )
+			return slots.get( slot ).canExtractItem( itemstack, side );
+
+		return false;
+	}
+
+	@Override
+	public boolean canInsertItem(int slot, ItemStack itemstack, int side)
+	{
+		if ( isSlotValid( slot ) )
+			return slots.get( slot ).canInsertItem( itemstack, side );
+
+		return false;
+	}
+
+	@Override
+	public void markDirty()
+	{
+		super.markForSave();
+
+		if ( invs != null )
+		{
+			for (IInventory inv : invs)
+				inv.markDirty();
+		}
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		if ( sides == null || side < 0 || side > 5 )
+			return nullSides;
+		return sides[side];
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 64; // no options here.
+	}
+
+	@Override
+	public String getInventoryName()
+	{
+		return "AEMultiPart";
+	}
+
+	@Override
+	public boolean hasCustomInventoryName()
+	{
+		return false;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int slot)
+	{
+		return null;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer entityplayer)
+	{
+		return false;
+	}
+
+	@Override
+	public void closeInventory()
+	{
+	}
+
+	@Override
+	public void openInventory()
+	{
+	}
+
+}

parts/layers/LayerITileStorageMonitorable.java

@@ -0,0 +1,22 @@
+package appeng.parts.layers;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.implementations.tiles.ITileStorageMonitorable;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.parts.IPart;
+import appeng.api.parts.LayerBase;
+import appeng.api.storage.IStorageMonitorable;
+
+public class LayerITileStorageMonitorable extends LayerBase implements ITileStorageMonitorable
+{
+
+	@Override
+	public IStorageMonitorable getMonitorable(ForgeDirection side, BaseActionSource src)
+	{
+		IPart part = getPart( side );
+		if ( part instanceof ITileStorageMonitorable )
+			return ((ITileStorageMonitorable) part).getMonitorable( side, src );
+		return null;
+	}
+
+}

tile/qnb/TileQuantumBridge.java

@@ -31,6 +31,8 @@ import appeng.util.Platform;
 public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock
 {
 
+	final private static ItemStack ring = AEApi.instance().blocks().blockQuantumRing.stack(1);
+	
 	final int sidesRing[] = new int[] {};
 	final int sidesLink[] = new int[] { 0 };
 
@@ -147,6 +149,14 @@ public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock
 	{
 		return !isInvalid();
 	}
+	
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		if ( worldObj.getBlock( xCoord, yCoord, zCoord) == AEApi.instance().blocks().blockQuantumRing.block() )
+			gridProxy.setVisualRepresentation( ring );
+	}
 
 	public void updateStatus(QuantumCluster c, byte flags)
 	{

util/item/AEItemStack.java

@@ -53,7 +53,10 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
 
 		def = new AEItemDef();
 		def.item = is.getItem();
-
+		
+		if ( def.item == null )
+			throw new RuntimeException( "This ItemStack is bad, it has a null item." );
+		
 		/*
 		 * Prevent an Item from changing the damage value on me... Either, this or a core mod.
 		 */

util/item/OreHelper.java

@@ -98,7 +98,8 @@ public class OreHelper
 
 				// SUMMON AE STACKS!
 				for (ItemStack is : set)
-					aeset.add( AEItemStack.create( is ) );
+					if ( is.getItem() != null )
+						aeset.add( AEItemStack.create( is ) );
 			}
 		}