AE2 First Commit, the dawn of 1.7 hast arrived.

tile/AEBaseInvTile.java

@@ -0,0 +1,144 @@
+package appeng.tile;
+
+import java.util.EnumSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.inventory.IAEAppEngInventory;
+import appeng.tile.inventory.InvOperation;
+
+public abstract class AEBaseInvTile extends AEBaseTile implements ISidedInventory, IAEAppEngInventory
+{
+
+	public AEBaseInvTile() {
+		addNewHandler( new AETileEventHandler( EnumSet.of( TileEventType.WORLD_NBT ) ) {
+
+			@Override
+			public void readFromNBT(net.minecraft.nbt.NBTTagCompound data)
+			{
+				IInventory inv = getInternalInventory();
+				NBTTagCompound opt = data.getCompoundTag( "inv" );
+				for (int x = 0; x < inv.getSizeInventory(); x++)
+				{
+					NBTTagCompound item = opt.getCompoundTag( "item" + x );
+					inv.setInventorySlotContents( x, ItemStack.loadItemStackFromNBT( item ) );
+				}
+			}
+
+			@Override
+			public void writeToNBT(net.minecraft.nbt.NBTTagCompound data)
+			{
+				IInventory inv = getInternalInventory();
+				NBTTagCompound opt = new NBTTagCompound();
+				for (int x = 0; x < inv.getSizeInventory(); x++)
+				{
+					NBTTagCompound item = new NBTTagCompound();
+					ItemStack is = getStackInSlot( x );
+					if ( is != null )
+						is.writeToNBT( item );
+					opt.setCompoundTag( "item" + x, item );
+				}
+				data.setCompoundTag( "inv", opt );
+			}
+
+		} );
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return getInternalInventory().getSizeInventory();
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int i)
+	{
+		return getInternalInventory().getStackInSlot( i );
+	}
+
+	@Override
+	public ItemStack decrStackSize(int i, int j)
+	{
+		return getInternalInventory().decrStackSize( i, j );
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int i)
+	{
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int i, ItemStack itemstack)
+	{
+		getInternalInventory().setInventorySlotContents( i, itemstack );
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return getClass().getSimpleName();
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 64;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer p)
+	{
+		return this.worldObj.getBlockTileEntity( this.xCoord, this.yCoord, this.zCoord ) != this ? false : p.getDistanceSq( (double) this.xCoord + 0.5D,
+				(double) this.yCoord + 0.5D, (double) this.zCoord + 0.5D ) <= 32.0D;
+	}
+
+	@Override
+	public void openChest()
+	{
+	}
+
+	@Override
+	public void closeChest()
+	{
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j)
+	{
+		return isItemValidForSlot( i, itemstack );
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return true;
+	}
+
+	@Override
+	public abstract IInventory getInternalInventory();
+
+	@Override
+	public abstract void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added);
+
+	@Override
+	public abstract int[] getAccessibleSlotsFromSide(int side);
+
+}

tile/AEBaseTile.java

@@ -0,0 +1,310 @@
+package appeng.tile;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.Packet;
+import net.minecraft.network.packet.Packet132TileEntityData;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.ICommonTile;
+import appeng.api.util.IOrientable;
+import appeng.core.AELog;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.util.SettingsFrom;
+
+public class AEBaseTile extends TileEntity implements IOrientable, ICommonTile
+{
+
+	private final EnumMap<TileEventType, List<AETileEventHandler>> handlers = new EnumMap<TileEventType, List<AETileEventHandler>>( TileEventType.class );
+
+	private ForgeDirection forward = ForgeDirection.UNKNOWN;
+	private ForgeDirection up = ForgeDirection.UNKNOWN;
+
+	public boolean dropItems = true;
+
+	/**
+	 * isRedstonePowerd has already changed.
+	 */
+	public void onRedstoneEvent()
+	{
+
+	}
+
+	protected boolean hasHandlerFor(TileEventType type)
+	{
+		List<AETileEventHandler> list = handlers.get( type );
+		return list != null;
+	}
+
+	protected List<AETileEventHandler> getHandlerListFor(TileEventType type)
+	{
+		List<AETileEventHandler> list = handlers.get( type );
+
+		if ( list == null )
+			handlers.put( type, list = new LinkedList<AETileEventHandler>() );
+
+		return list;
+	}
+
+	protected void addNewHandler(AETileEventHandler handler)
+	{
+		EnumSet<TileEventType> types = handler.getSubscribedEvents();
+
+		for (TileEventType type : types)
+			getHandlerListFor( type ).add( handler );
+	}
+
+	@Override
+	final public boolean canUpdate()
+	{
+		return hasHandlerFor( TileEventType.TICK );
+	}
+
+	@Override
+	final public void updateEntity()
+	{
+		for (AETileEventHandler h : getHandlerListFor( TileEventType.TICK ))
+			h.Tick();
+	}
+
+	@Override
+	final public void writeToNBT(NBTTagCompound data)
+	{
+		super.writeToNBT( data );
+
+		if ( canBeRotated() )
+		{
+			data.setString( "orientation_forward", forward.name() );
+			data.setString( "orientation_up", up.name() );
+		}
+
+		for (AETileEventHandler h : getHandlerListFor( TileEventType.WORLD_NBT ))
+			h.writeToNBT( data );
+	}
+
+	@Override
+	final public void readFromNBT(NBTTagCompound data)
+	{
+		super.readFromNBT( data );
+
+		try
+		{
+			if ( canBeRotated() )
+			{
+				forward = ForgeDirection.valueOf( data.getString( "orientation_forward" ) );
+				up = ForgeDirection.valueOf( data.getString( "orientation_up" ) );
+			}
+		}
+		catch (IllegalArgumentException iae)
+		{
+		}
+
+		for (AETileEventHandler h : getHandlerListFor( TileEventType.WORLD_NBT ))
+		{
+			h.readFromNBT( data );
+		}
+	}
+
+	final public void writeToStream(DataOutputStream data)
+	{
+		try
+		{
+			if ( canBeRotated() )
+			{
+				byte orientation = (byte) ((up.ordinal() << 3) | forward.ordinal());
+				data.writeByte( orientation );
+			}
+
+			for (AETileEventHandler h : getHandlerListFor( TileEventType.NETWORK ))
+				h.writeToStream( data );
+		}
+		catch (Throwable t)
+		{
+			t.printStackTrace();
+		}
+	}
+
+	final public boolean readfromStream(DataInputStream data)
+	{
+		boolean output = false;
+
+		try
+		{
+
+			if ( canBeRotated() )
+			{
+				ForgeDirection old_Forward = forward;
+				ForgeDirection old_Up = up;
+
+				byte orientation = data.readByte();
+				forward = ForgeDirection.getOrientation( orientation & 0x7 );
+				up = ForgeDirection.getOrientation( orientation >> 3 );
+
+				output = !forward.equals( old_Forward ) || !up.equals( old_Up );
+			}
+
+			for (AETileEventHandler h : getHandlerListFor( TileEventType.NETWORK ))
+				if ( h.readFromStream( data ) )
+					output = true;
+		}
+		catch (Throwable t)
+		{
+			t.printStackTrace();
+		}
+
+		return output;
+	}
+
+	/**
+	 * By default all blocks can have orientation, this handles saving, and loading, as well as synchronization.
+	 * 
+	 * @return
+	 */
+	@Override
+	public boolean canBeRotated()
+	{
+		return true;
+	}
+
+	@Override
+	public ForgeDirection getForward()
+	{
+		return forward;
+	}
+
+	@Override
+	public ForgeDirection getUp()
+	{
+		return up;
+	}
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		forward = inForward;
+		up = inUp;
+		markForUpdate();
+		worldObj.notifyBlocksOfNeighborChange( xCoord, yCoord, zCoord, 0 );
+	}
+
+	public void onPlacement(ItemStack stack, EntityPlayer player, int side)
+	{
+		if ( stack.hasTagCompound() )
+		{
+			uploadSettings( SettingsFrom.DISMANTLE_ITEM, stack.getTagCompound() );
+		}
+	}
+
+	@Override
+	public Packet getDescriptionPacket()
+	{
+		NBTTagCompound data = new NBTTagCompound();
+
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+		DataOutputStream stream = new DataOutputStream( bytes );
+
+		try
+		{
+			writeToStream( stream );
+			if ( bytes.size() == 0 )
+				return null;
+		}
+		catch (Throwable t)
+		{
+			AELog.error( t );
+		}
+
+		data.setByteArray( "X", bytes.toByteArray() );
+		return new Packet132TileEntityData( xCoord, yCoord, zCoord, 64, data );
+	}
+
+	@Override
+	public void onDataPacket(INetworkManager net, Packet132TileEntityData pkt)
+	{
+		if ( pkt.actionType == 64 )
+		{
+			DataInputStream stream = new DataInputStream( new ByteArrayInputStream( pkt.data.getByteArray( "X" ) ) );
+			if ( readfromStream( stream ) )
+				markForUpdate();
+		}
+	}
+
+	public void markForUpdate()
+	{
+		if ( worldObj != null )
+			worldObj.markBlockForUpdate( xCoord, yCoord, zCoord );
+	}
+
+	/**
+	 * returns the contents of the tile entity, into the world, defaults to dropping everything in the inventory.
+	 * 
+	 * @param w
+	 * @param x
+	 * @param y
+	 * @param z
+	 * @param drops
+	 */
+	@Override
+	public void getDrops(World w, int x, int y, int z, ArrayList<ItemStack> drops)
+	{
+		if ( this instanceof IInventory )
+		{
+			IInventory inv = (IInventory) this;
+
+			for (int l = 0; l < inv.getSizeInventory(); l++)
+			{
+				ItemStack is = inv.getStackInSlot( l );
+
+				if ( is != null )
+				{
+					drops.add( is );
+					inv.setInventorySlotContents( l, (ItemStack) null );
+				}
+			}
+		}
+
+	}
+
+	public void onReady()
+	{
+
+	}
+
+	/**
+	 * depending on the from, diffrent settings will be accepted, don't call this with null
+	 * 
+	 * @param from
+	 * @param compound
+	 */
+	public void uploadSettings(SettingsFrom from, NBTTagCompound compound)
+	{
+
+	}
+
+	/**
+	 * null means nothing to store...
+	 * 
+	 * @param from
+	 * @return
+	 */
+	public NBTTagCompound downloadSettings(SettingsFrom from)
+	{
+		return null;
+	}
+
+}

tile/events/AETileEventHandler.java

@@ -0,0 +1,60 @@
+package appeng.tile.events;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public abstract class AETileEventHandler
+{
+
+	final EnumSet<TileEventType> supportedEvents;
+
+	public AETileEventHandler(EnumSet<TileEventType> events) {
+		supportedEvents = events;
+	}
+
+	public EnumSet<TileEventType> getSubscribedEvents()
+	{
+		return supportedEvents;
+	}
+
+	// TICK
+	public void Tick()
+	{
+	}
+
+	// WORLD_NBT
+	public void writeToNBT(NBTTagCompound data)
+	{
+	}
+
+	// WORLD NBT
+	public void readFromNBT(NBTTagCompound data)
+	{
+	}
+
+	// NETWORK
+	public void writeToStream(DataOutputStream data) throws IOException
+	{
+	}
+
+	// NETWORK
+	/**
+	 * returning true from this method, will update the block's render
+	 * 
+	 * @param data
+	 * @return
+	 * @throws IOException
+	 */
+	@SideOnly(Side.CLIENT)
+	public boolean readFromStream(DataInputStream data) throws IOException
+	{
+		return false;
+	}
+
+}

tile/events/TileEventType.java

@@ -0,0 +1,6 @@
+package appeng.tile.events;
+
+public enum TileEventType
+{
+	TICK, WORLD_NBT, NETWORK
+}

tile/grid/AENetworkInvTile.java

@@ -0,0 +1,54 @@
+package appeng.tile.grid;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.AEBaseInvTile;
+
+public abstract class AENetworkInvTile extends AEBaseInvTile implements IGridHost, IGridProxyable
+{
+
+	protected AENetworkProxy gridProxy = new AENetworkProxy( this, "proxy", true );
+
+	@Override
+	public IGridNode getGridNode(ForgeDirection dir)
+	{
+		return gridProxy.getNode();
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		gridProxy.onReady();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		gridProxy.onChunkUnload();
+	}
+
+	@Override
+	public void validate()
+	{
+		super.validate();
+		gridProxy.validate();
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		gridProxy.invalidate();
+	}
+
+	@Override
+	public void gridChanged()
+	{
+
+	}
+}

tile/grid/AENetworkPowerTile.java

@@ -0,0 +1,68 @@
+package appeng.tile.grid;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.powersink.AEBasePoweredTile;
+
+public abstract class AENetworkPowerTile extends AEBasePoweredTile implements IGridHost, IGridProxyable
+{
+
+	protected AENetworkProxy gridProxy = new AENetworkProxy( this, "proxy", true );
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IGridNode getGridNode(ForgeDirection dir)
+	{
+		return gridProxy.getNode();
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		gridProxy.onReady();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		gridProxy.onChunkUnload();
+	}
+
+	@Override
+	public void validate()
+	{
+		super.validate();
+		gridProxy.validate();
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		gridProxy.invalidate();
+	}
+
+	@Override
+	public void gridChanged()
+	{
+
+	}
+}

tile/grid/AENetworkTile.java

@@ -0,0 +1,73 @@
+package appeng.tile.grid;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.AEBaseTile;
+
+public class AENetworkTile extends AEBaseTile implements IGridHost, IGridProxyable
+{
+
+	final protected AENetworkProxy gridProxy = createProxy();
+
+	protected AENetworkProxy createProxy()
+	{
+		return new AENetworkProxy( this, "proxy", true );
+	}
+
+	@Override
+	public IGridNode getGridNode(ForgeDirection dir)
+	{
+		return gridProxy.getNode();
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		gridProxy.onReady();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		gridProxy.onChunkUnload();
+	}
+
+	@Override
+	public void validate()
+	{
+		super.validate();
+		gridProxy.validate();
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		gridProxy.invalidate();
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public void gridChanged()
+	{
+
+	}
+}

tile/grindstone/TileCrank.java

@@ -0,0 +1,133 @@
+package appeng.tile.grindstone;
+
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.implementations.ICrankable;
+import appeng.helpers.ICustomCollision;
+import appeng.tile.AEBaseTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.util.Platform;
+
+public class TileCrank extends AEBaseTile implements ICustomCollision
+{
+
+	final int ticksPerRoation = 18;
+
+	// sided values..
+	public float visibleRotation = 0;
+	public int charge = 0;
+
+	public int hits = 0;
+	public int rotation = 0;
+
+	public TileCrank() {
+		addNewHandler( new AETileEventHandler( EnumSet.of( TileEventType.NETWORK, TileEventType.TICK ) ) {
+
+			@Override
+			public void Tick()
+			{
+				if ( rotation > 0 )
+				{
+					visibleRotation -= 360 / (ticksPerRoation);
+					charge++;
+					if ( charge >= ticksPerRoation )
+					{
+						charge -= ticksPerRoation;
+						ICrankable g = getGrinder();
+						if ( g != null )
+							g.applyTurn();
+					}
+
+					rotation--;
+				}
+			}
+
+			@Override
+			public boolean readFromStream(java.io.DataInputStream data) throws java.io.IOException
+			{
+				rotation = data.readInt();
+				return false;
+			}
+
+			@Override
+			public void writeToStream(java.io.DataOutputStream data) throws java.io.IOException
+			{
+				data.writeInt( rotation );
+			}
+
+		} );
+	}
+
+	public ICrankable getGrinder()
+	{
+		if ( Platform.isClient() )
+			return null;
+
+		ForgeDirection grinder = getUp().getOpposite();
+		TileEntity te = worldObj.getBlockTileEntity( xCoord + grinder.offsetX, yCoord + grinder.offsetY, zCoord + grinder.offsetZ );
+		if ( te instanceof ICrankable )
+			return (ICrankable) te;
+		return null;
+	}
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		super.setOrientation( inForward, inUp );
+		getBlockType().onNeighborBlockChange( worldObj, xCoord, yCoord, zCoord, 0 );
+	}
+
+	public void power()
+	{
+		if ( Platform.isClient() )
+			return;
+
+		if ( rotation < 3 )
+		{
+			ICrankable g = getGrinder();
+			if ( g != null )
+			{
+				if ( g.canTurn() )
+				{
+					hits = 0;
+					rotation += ticksPerRoation;
+					this.markForUpdate();
+				}
+				else
+				{
+					hits++;
+					if ( hits > 10 )
+						worldObj.destroyBlock( xCoord, yCoord, zCoord, false );
+				}
+			}
+		}
+	}
+
+	@Override
+	public Iterable<AxisAlignedBB> getSelectedBoundingBoxsFromPool(World w, int x, int y, int z)
+	{
+		double xOff = -0.15 * getUp().offsetX;
+		double yOff = -0.15 * getUp().offsetY;
+		double zOff = -0.15 * getUp().offsetZ;
+		return Arrays
+				.asList( new AxisAlignedBB[] { AxisAlignedBB.getBoundingBox( xOff + 0.15, yOff + 0.15, zOff + 0.15, xOff + 0.85, yOff + 0.85, zOff + 0.85 ) } );
+	}
+
+	@Override
+	public void addCollidingBlockToList(World w, int x, int y, int z, AxisAlignedBB bb, List out, Entity e)
+	{
+		double xOff = -0.15 * getUp().offsetX;
+		double yOff = -0.15 * getUp().offsetY;
+		double zOff = -0.15 * getUp().offsetZ;
+		out.add( AxisAlignedBB.getAABBPool().getAABB( xOff + (double) 0.15, yOff + (double) 0.15, zOff + (double) 0.15,// ahh
+				xOff + (double) 0.85, yOff + (double) 0.85, zOff + (double) 0.85 ) );
+	}
+}

tile/grindstone/TileGrinder.java

@@ -0,0 +1,154 @@
+package appeng.tile.grindstone;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.features.IGrinderEntry;
+import appeng.api.implementations.ICrankable;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.util.WorldCoord;
+import appeng.me.storage.MEIInventoryWrapper;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.inv.WrapperInventoryRange;
+import appeng.util.item.ItemList;
+
+public class TileGrinder extends AEBaseInvTile implements ICrankable
+{
+
+	int points;
+
+	final int inputs[] = new int[] { 0, 1, 2 };
+	final int sides[] = new int[] { 0, 1, 2, 3, 4, 5 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 7 );
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		super.setOrientation( inForward, inUp );
+		getBlockType().onNeighborBlockChange( worldObj, xCoord, yCoord, zCoord, 0 );
+	}
+
+	private void addItem(InventoryAdaptor sia, ItemStack output)
+	{
+		ItemStack notAdded = sia.addItems( output );
+		if ( notAdded != null )
+		{
+			WorldCoord wc = new WorldCoord( xCoord, yCoord, zCoord );
+
+			wc.add( getForward(), 1 );
+
+			List<ItemStack> out = new ArrayList();
+			out.add( notAdded );
+
+			Platform.spawnDrops( worldObj, wc.x, wc.y, wc.z, out );
+		}
+	}
+
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j)
+	{
+		if ( AEApi.instance().registries().grinder().getRecipeForInput( itemstack ) == null )
+			return false;
+
+		return i >= 0 && i <= 2;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return i >= 3 && i <= 5;
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	@Override
+	public boolean canTurn()
+	{
+		if ( Platform.isClient() )
+			return false;
+
+		if ( null == this.getStackInSlot( 6 ) ) // Add if there isn't one...
+		{
+			IMEInventory<IAEItemStack> input = new MEIInventoryWrapper( new WrapperInventoryRange( this, inputs, true ), null );
+			for (IAEItemStack i : input.getAvailableItems( new ItemList() ))
+			{
+				IGrinderEntry r = AEApi.instance().registries().grinder().getRecipeForInput( i.getItemStack() );
+				if ( r != null )
+				{
+					if ( i.getStackSize() >= r.getInput().stackSize )
+					{
+						i = i.copy();
+						i.setStackSize( r.getInput().stackSize );
+						IAEItemStack ais = input.extractItems( (IAEItemStack) i, Actionable.MODULATE );
+						if ( ais != null )
+							this.setInventorySlotContents( 6, ais.getItemStack() );
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+		return true;
+	}
+
+	@Override
+	public void applyTurn()
+	{
+		if ( Platform.isClient() )
+			return;
+
+		points++;
+
+		ItemStack processing = this.getStackInSlot( 6 );
+		IGrinderEntry r = AEApi.instance().registries().grinder().getRecipeForInput( processing );
+		if ( r != null )
+		{
+			if ( r.getEnergyCost() > points )
+				return;
+
+			points = 0;
+			InventoryAdaptor sia = InventoryAdaptor.getAdaptor( new WrapperInventoryRange( this, 3, 3, true ), ForgeDirection.EAST );
+
+			addItem( sia, r.getOutput() );
+
+			float chance = (Platform.getRandomInt() % 2000) / 2000.0f;
+			if ( chance <= r.getOptionalChance() )
+				addItem( sia, r.getOptionalOutput() );
+
+			this.setInventorySlotContents( 6, null );
+		}
+	}
+
+	@Override
+	public boolean canCrankAttach(ForgeDirection directionToCrank)
+	{
+		return getUp().equals( directionToCrank );
+	}
+
+}

tile/inventory/AppEngInternalInventory.java

@@ -0,0 +1,227 @@
+package appeng.tile.inventory;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import appeng.api.storage.IMEInventory;
+import appeng.me.storage.MEIInventoryWrapper;
+import appeng.util.Platform;
+
+public class AppEngInternalInventory implements IInventory
+{
+
+	protected IAEAppEngInventory te;
+	int size;
+	int maxStack;
+
+	protected ItemStack inv[];
+
+	public IMEInventory getIMEI()
+	{
+		return new MEIInventoryWrapper( this, null );
+	}
+
+	public boolean isEmpty()
+	{
+		for (int x = 0; x < getSizeInventory(); x++)
+			if ( getStackInSlot( x ) != null )
+				return false;
+		return true;
+	}
+
+	public AppEngInternalInventory(IAEAppEngInventory _te, int s) {
+		te = _te;
+		size = s;
+		maxStack = 64;
+		inv = new ItemStack[s];
+	}
+
+	public void setMaxStackSize(int s)
+	{
+		maxStack = s;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int var1)
+	{
+		return inv[var1];
+	}
+
+	@Override
+	public ItemStack decrStackSize(int slot, int qty)
+	{
+		if ( inv[slot] != null )
+		{
+			ItemStack split = getStackInSlot( slot );
+			ItemStack ns = null;
+
+			if ( qty >= split.stackSize )
+			{
+				ns = inv[slot];
+				inv[slot] = null;
+			}
+			else
+				ns = split.splitStack( qty );
+
+			if ( te != null && Platform.isServer() )
+			{
+				te.onChangeInventory( this, slot, InvOperation.decrStackSize, ns, null );
+			}
+
+			return ns;
+		}
+
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int var1)
+	{
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack newItemStack)
+	{
+		ItemStack oldStack = inv[slot];
+		inv[slot] = newItemStack;
+
+		if ( te != null && Platform.isServer() )
+		{
+			ItemStack removed = oldStack;
+			ItemStack added = newItemStack;
+
+			if ( oldStack != null && newItemStack != null && Platform.isSameItem( oldStack, newItemStack ) )
+			{
+				if ( oldStack.stackSize > newItemStack.stackSize )
+				{
+					removed = removed.copy();
+					removed.stackSize -= newItemStack.stackSize;
+					added = null;
+				}
+				else if ( oldStack.stackSize < newItemStack.stackSize )
+				{
+					added = added.copy();
+					added.stackSize -= oldStack.stackSize;
+					removed = null;
+				}
+				else
+				{
+					removed = added = null;
+				}
+			}
+
+			te.onChangeInventory( this, slot, InvOperation.setInventorySlotContents, removed, added );
+		}
+	}
+
+	@Override
+	public void onInventoryChanged()
+	{
+		if ( te != null && Platform.isServer() )
+		{
+			te.onChangeInventory( this, -1, InvOperation.onInventoryChanged, null, null );
+		}
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return maxStack > 64 ? 64 : maxStack;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer var1)
+	{
+		return true;
+	}
+
+	@Override
+	public void openChest()
+	{
+	}
+
+	@Override
+	public void closeChest()
+	{
+	}
+
+	public void writeToNBT(NBTTagCompound target)
+	{
+		for (int x = 0; x < size; x++)
+		{
+			try
+			{
+				NBTTagCompound c = new NBTTagCompound();
+
+				if ( inv[x] != null )
+				{
+					inv[x].writeToNBT( c );
+				}
+
+				target.setCompoundTag( "#" + x, c );
+			}
+			catch (Exception err)
+			{
+			}
+		}
+	}
+
+	public void readFromNBT(NBTTagCompound target)
+	{
+		for (int x = 0; x < size; x++)
+		{
+			try
+			{
+				NBTTagCompound c = target.getCompoundTag( "#" + x );
+
+				if ( c != null )
+					inv[x] = ItemStack.loadItemStackFromNBT( c );
+
+			}
+			catch (Exception err)
+			{
+				err.printStackTrace();
+			}
+		}
+	}
+
+	public void writeToNBT(NBTTagCompound data, String name)
+	{
+		NBTTagCompound c = new NBTTagCompound();
+		writeToNBT( c );
+		data.setCompoundTag( name, c );
+	}
+
+	public void readFromNBT(NBTTagCompound data, String name)
+	{
+		NBTTagCompound c = data.getCompoundTag( name );
+		if ( c != null )
+			readFromNBT( c );
+	}
+
+	@Override
+	public int getSizeInventory()
+	{
+		return size;
+	}
+
+	@Override
+	public String getInvName()
+	{
+		return "appeng-internal";
+	}
+
+	@Override
+	public boolean isInvNameLocalized()
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return true;
+	}
+}

tile/inventory/IAEAppEngInventory.java

@@ -0,0 +1,13 @@
+package appeng.tile.inventory;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public interface IAEAppEngInventory
+{
+
+	IInventory getInternalInventory();
+
+	void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack);
+
+}

tile/inventory/InvOperation.java

@@ -0,0 +1,7 @@
+package appeng.tile.inventory;
+
+public enum InvOperation
+{
+	decrStackSize, setInventorySlotContents, onInventoryChanged
+
+}

tile/mac/TileMolecularAssembler.java

@@ -0,0 +1,30 @@
+package appeng.tile.mac;
+
+import appeng.me.cluster.IAECluster;
+import appeng.me.cluster.IAEMultiBlock;
+import appeng.tile.grid.AENetworkTile;
+
+public class TileMolecularAssembler extends AENetworkTile implements IAEMultiBlock
+{
+
+	@Override
+	public void disconnect()
+	{
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public IAECluster getCluster()
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+}

tile/mac/TilePatternProvider.java

@@ -0,0 +1,30 @@
+package appeng.tile.mac;
+
+import appeng.me.cluster.IAECluster;
+import appeng.me.cluster.IAEMultiBlock;
+import appeng.tile.grid.AENetworkTile;
+
+public class TilePatternProvider extends AENetworkTile implements IAEMultiBlock
+{
+
+	@Override
+	public void disconnect()
+	{
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public IAECluster getCluster()
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+}

tile/misc/TileCharger.java

@@ -0,0 +1,249 @@
+package appeng.tile.misc;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.PowerUnits;
+import appeng.api.implementations.IAEItemPowerStorage;
+import appeng.api.implementations.ICrankable;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.util.AECableType;
+import appeng.me.GridAccessException;
+import appeng.server.AccessType;
+import appeng.server.Security;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+
+public class TileCharger extends AENetworkPowerTile implements ICrankable
+{
+
+	final int sides[] = new int[] { 0 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
+	int tickTickTimer = 0;
+
+	int lastUpdate = 0;
+	boolean requiresUpdate = false;
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	private class TileChargerHandler extends AETileEventHandler
+	{
+
+		public TileChargerHandler() {
+			super( EnumSet.of( TileEventType.TICK, TileEventType.NETWORK ) );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			try
+			{
+				IAEItemStack item = AEItemStack.loadItemStackFromPacket( data );
+				ItemStack is = item.getItemStack();
+				inv.setInventorySlotContents( 0, is );
+			}
+			catch (Throwable t)
+			{
+				inv.setInventorySlotContents( 0, null );
+			}
+			return false; // TESR dosn't need updates!
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			AEItemStack is = AEItemStack.create( getStackInSlot( 0 ) );
+			if ( is != null )
+				is.writeToPacket( data );
+		}
+
+		@Override
+		public void Tick()
+		{
+			if ( lastUpdate > 60 && requiresUpdate )
+			{
+				requiresUpdate = false;
+				markForUpdate();
+				lastUpdate = 0;
+			}
+			lastUpdate++;
+
+			tickTickTimer++;
+			if ( tickTickTimer < 20 )
+				return;
+			tickTickTimer = 0;
+
+			ItemStack myItem = getStackInSlot( 0 );
+
+			// charge from the network!
+			if ( internalCurrentPower < 1499 )
+			{
+				try
+				{
+					injectExternalPower( PowerUnits.AE,
+							gridProxy.getEnergy().extractAEPower( Math.min( 150.0, 1500.0 - internalCurrentPower ), Actionable.MODULATE, PowerMultiplier.ONE ) );
+					tickTickTimer = 20; // keep tickin...
+				}
+				catch (GridAccessException e)
+				{
+					// continue!
+				}
+			}
+
+			if ( myItem == null )
+				return;
+
+			if ( internalCurrentPower > 149 && Platform.isChargeable( myItem ) )
+			{
+				IAEItemPowerStorage ps = (IAEItemPowerStorage) myItem.getItem();
+				if ( ps.getAEMaxPower( myItem ) > ps.getAECurrentPower( myItem ) )
+				{
+					double oldPower = internalCurrentPower;
+
+					double adjustment = ps.injectAEPower( myItem, extractAEPower( 150.0, Actionable.MODULATE, PowerMultiplier.CONFIG ) );
+					internalCurrentPower += adjustment;
+					if ( oldPower > internalCurrentPower )
+						requiresUpdate = true;
+					tickTickTimer = 20; // keep tickin...
+				}
+			}
+			else if ( internalCurrentPower > 1499 && AEApi.instance().materials().materialCertusQuartzCrystal.sameAs( myItem ) )
+			{
+				if ( Platform.getRandomFloat() > 0.8f ) // simulate wait
+				{
+					extractAEPower( internalMaxPower, Actionable.MODULATE, PowerMultiplier.CONFIG );// 1500
+					setInventorySlotContents( 0, AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( myItem.stackSize ) );
+				}
+			}
+		}
+
+	};
+
+	public TileCharger() {
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+		internalMaxPower = 1500;
+		gridProxy.setIdlePowerUsage( 0 );
+		addNewHandler( new TileChargerHandler() );
+	}
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		super.setOrientation( inForward, inUp );
+		gridProxy.setValidSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+		setPowerSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+	}
+
+	@Override
+	public boolean canTurn()
+	{
+		return internalCurrentPower < internalMaxPower;
+	}
+
+	@Override
+	public void applyTurn()
+	{
+		injectExternalPower( PowerUnits.AE, 150 );
+
+		ItemStack myItem = getStackInSlot( 0 );
+		if ( internalCurrentPower > 1499 && AEApi.instance().materials().materialCertusQuartzCrystal.sameAs( myItem ) )
+		{
+			extractAEPower( internalMaxPower, Actionable.MODULATE, PowerMultiplier.CONFIG );// 1500
+			setInventorySlotContents( 0, AEApi.instance().materials().materialCertusQuartzCrystalCharged.stack( myItem.stackSize ) );
+		}
+	}
+
+	@Override
+	public boolean canCrankAttach(ForgeDirection directionToCrank)
+	{
+		return getUp().equals( directionToCrank ) || getUp().getOpposite().equals( directionToCrank );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		markForUpdate();
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 1;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return Platform.isChargeable( itemstack ) || AEApi.instance().materials().materialCertusQuartzCrystal.sameAs( itemstack );
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		if ( Platform.isChargeable( itemstack ) )
+		{
+			IAEItemPowerStorage ips = (IAEItemPowerStorage) itemstack.getItem();
+			if ( ips.getAECurrentPower( itemstack ) >= ips.getAEMaxPower( itemstack ) )
+				return true;
+		}
+
+		return AEApi.instance().materials().materialCertusQuartzCrystalCharged.sameAs( itemstack );
+	}
+
+	public void activate(EntityPlayer player)
+	{
+		if ( !Security.hasPermissions( this, player, AccessType.BLOCK_ACCESS ) )
+			return;
+
+		ItemStack myItem = getStackInSlot( 0 );
+		if ( myItem == null )
+		{
+			ItemStack held = player.inventory.getCurrentItem();
+			if ( AEApi.instance().materials().materialCertusQuartzCrystal.sameAs( held ) || Platform.isChargeable( held ) )
+			{
+				held = player.inventory.decrStackSize( player.inventory.currentItem, 1 );
+				setInventorySlotContents( 0, held );
+			}
+		}
+		else
+		{
+			List<ItemStack> drops = new ArrayList();
+			drops.add( myItem );
+			setInventorySlotContents( 0, null );
+			Platform.spawnDrops( worldObj, xCoord + getForward().offsetX, yCoord + getForward().offsetY, zCoord + getForward().offsetZ, drops );
+		}
+	}
+
+}

tile/misc/TileCondenser.java

@@ -0,0 +1,251 @@
+package appeng.tile.misc;
+
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+import appeng.api.AEApi;
+import appeng.api.config.CondenserOuput;
+import appeng.api.config.Settings;
+import appeng.api.implementations.IStorageComponent;
+import appeng.api.util.IConfigManager;
+import appeng.api.util.IConfigureableObject;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.IAEAppEngInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.ConfigManager;
+import appeng.util.IConfigManagerHost;
+import appeng.util.Platform;
+
+public class TileCondenser extends AEBaseInvTile implements IAEAppEngInventory, IFluidHandler, IConfigManagerHost, IConfigureableObject
+{
+
+	int sides[] = new int[] { 0, 1 };
+	static private FluidTankInfo[] empty = new FluidTankInfo[] { new FluidTankInfo( null, 10 ) };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 3 );
+	ConfigManager cm = new ConfigManager( this );
+
+	public double storedPower = 0;
+
+	private class TileCondenserHandler extends AETileEventHandler
+	{
+
+		public TileCondenserHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setDouble( "storedPower", storedPower );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			storedPower = data.getDouble( "storedPower" );
+		}
+
+	};
+
+	public TileCondenser() {
+		addNewHandler( new TileCondenserHandler() );
+		cm.registerSetting( Settings.CONDENSER_OUTPUT, CondenserOuput.TRASH );
+	}
+
+	public double getStorage()
+	{
+		ItemStack is = inv.getStackInSlot( 2 );
+		if ( is != null )
+		{
+			if ( is.getItem() instanceof IStorageComponent )
+			{
+				IStorageComponent sc = (IStorageComponent) is.getItem();
+				if ( sc.isStorageComponent( is ) )
+					return sc.getBytes( is ) * 8;
+			}
+		}
+		return 0;
+	}
+
+	public void addPower(double rawPower)
+	{
+		storedPower += rawPower;
+		storedPower = Math.max( 0.0, Math.min( getStorage(), storedPower ) );
+
+		double requiredPower = getRequiredPower();
+		ItemStack output = getOutput();
+		while (requiredPower <= storedPower && output != null && requiredPower > 0)
+		{
+			if ( canAddOutput( output ) )
+			{
+				storedPower -= requiredPower;
+				addOutput( output );
+			}
+			else
+				break;
+		}
+
+	}
+
+	private boolean canAddOutput(ItemStack output)
+	{
+		ItemStack outputStack = getStackInSlot( 1 );
+		return outputStack == null || (Platform.isSameItem( outputStack, output ) && outputStack.stackSize < outputStack.getMaxStackSize());
+	}
+
+	/**
+	 * make sure you validate with canAddOutput prior to this.
+	 * 
+	 * @param output
+	 */
+	private void addOutput(ItemStack output)
+	{
+		ItemStack outputStack = getStackInSlot( 1 );
+		if ( outputStack == null )
+			setInventorySlotContents( 1, output.copy() );
+		else
+		{
+			outputStack.stackSize++;
+			setInventorySlotContents( 1, outputStack );
+		}
+	}
+
+	private ItemStack getOutput()
+	{
+		switch ((CondenserOuput) cm.getSetting( Settings.CONDENSER_OUTPUT ))
+		{
+		case MATTER_BALLS:
+			return AEApi.instance().materials().materialMatterBall.stack( 1 );
+		case SINGULARITY:
+			return AEApi.instance().materials().materialSingularity.stack( 1 );
+		case TRASH:
+		default:
+		}
+		return null;
+	}
+
+	public double getRequiredPower()
+	{
+		return ((CondenserOuput) cm.getSetting( Settings.CONDENSER_OUTPUT )).requiredPower;
+	}
+
+	@Override
+	public void setInventorySlotContents(int i, ItemStack itemstack)
+	{
+		if ( i == 0 )
+		{
+			if ( itemstack != null )
+				addPower( itemstack.stackSize );
+		}
+		else
+		{
+			inv.setInventorySlotContents( 1, itemstack );
+		}
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return i == 0;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return i != 0;
+	}
+
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j)
+	{
+		return i == 0;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int var1)
+	{
+		return sides;
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		if ( slot == 0 )
+		{
+			ItemStack is = inv.getStackInSlot( 0 );
+			if ( is != null )
+			{
+				addPower( is.stackSize );
+				inv.setInventorySlotContents( 0, null );
+			}
+		}
+	}
+
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
+	{
+		if ( doFill )
+			addPower( (resource == null ? 0.0 : (double) resource.amount) / 500.0 );
+
+		return resource == null ? 0 : resource.amount;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
+	{
+		return null;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+	{
+		return null;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid)
+	{
+		return false;
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from)
+	{
+		return empty;
+	}
+
+	@Override
+	public void updateSetting(Enum settingName, Enum newValue)
+	{
+		addPower( 0 );
+	}
+
+	@Override
+	public IConfigManager getConfigManager()
+	{
+		return cm;
+	}
+
+}

tile/misc/TileInscriber.java

@@ -0,0 +1,117 @@
+package appeng.tile.misc;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.AECableType;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileInscriber extends AENetworkPowerTile
+{
+
+	final int sides[] = new int[] { 0, 1 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 2 );
+	int processingTime = 0;
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	private class TileInscriberHandler extends AETileEventHandler
+	{
+
+		public TileInscriberHandler() {
+			super( EnumSet.of( TileEventType.TICK, TileEventType.NETWORK ) );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+
+			return false;
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+
+		}
+
+		@Override
+		public void Tick()
+		{
+
+		}
+
+	};
+
+	public TileInscriber() {
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+		internalMaxPower = 1500;
+		gridProxy.setIdlePowerUsage( 0 );
+		addNewHandler( new TileInscriberHandler() );
+	}
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		super.setOrientation( inForward, inUp );
+		gridProxy.setValidSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+		setPowerSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 1;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return i == 0;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return i == 1;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	public void activate(EntityPlayer player)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

tile/misc/TileInterface.java

@@ -0,0 +1,133 @@
+package appeng.tile.misc;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.implementations.IStorageMonitorable;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.GridAccessException;
+import appeng.me.storage.MEMonitorPassthu;
+import appeng.me.storage.NullInventory;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileInterface extends AENetworkInvTile implements IGridTickable, IStorageMonitorable
+{
+
+	final int sides[] = new int[] { 0, 1, 2, 3, 4, 5, 6, 7 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 16 + 9 );
+
+	MEMonitorPassthu<IAEItemStack> items = new MEMonitorPassthu<IAEItemStack>( new NullInventory() );
+	MEMonitorPassthu<IAEFluidStack> fluids = new MEMonitorPassthu<IAEFluidStack>( new NullInventory() );
+
+	@Override
+	public void gridChanged()
+	{
+		try
+		{
+			items.setInternal( gridProxy.getStorage().getItemInventory() );
+			fluids.setInternal( gridProxy.getStorage().getFluidInventory() );
+		}
+		catch (GridAccessException gae)
+		{
+			items.setInternal( new NullInventory() );
+			fluids.setInternal( new NullInventory() );
+		}
+
+		worldObj.notifyBlocksOfNeighborChange( xCoord, yCoord, zCoord, 0 );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		if ( slot >= 16 )
+		{
+			// gridProxy.getCrafting()
+		}
+		else
+			updateStorage();
+	}
+
+	public boolean hasWorkToDo()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	private boolean updateStorage()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public boolean hasConfig()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		return new TickingRequest( 5, 120, !hasWorkToDo(), false );
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		boolean couldDoWork = updateStorage();
+		return hasWorkToDo() ? (couldDoWork ? TickRateModulation.URGENT : TickRateModulation.SLOWER) : TickRateModulation.SLEEP;
+	}
+
+	@Override
+	public IMEMonitor<IAEItemStack> getItemInventory()
+	{
+		if ( hasConfig() )
+			return null;
+
+		return items;
+	}
+
+	@Override
+	public IMEMonitor<IAEFluidStack> getFluidInventory()
+	{
+		if ( hasConfig() )
+			return null;
+
+		return fluids;
+	}
+
+}

tile/misc/TileNetworkEmitter.java

@@ -0,0 +1,22 @@
+package appeng.tile.misc;
+
+import java.util.EnumSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.tile.grid.AENetworkTile;
+
+public class TileNetworkEmitter extends AENetworkTile
+{
+
+	public TileNetworkEmitter() {
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+	}
+
+	public void activate(EntityPlayer player)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

tile/misc/TilePartitionerEditor.java

@@ -0,0 +1,8 @@
+package appeng.tile.misc;
+
+import appeng.tile.AEBaseTile;
+
+public class TilePartitionerEditor extends AEBaseTile
+{
+
+}

tile/misc/TileQuartzCrystalizer.java

@@ -0,0 +1,83 @@
+package appeng.tile.misc;
+
+import java.util.EnumSet;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.AECableType;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileQuartzCrystalizer extends AENetworkPowerTile
+{
+
+	final int sides[] = new int[] { 0, 1 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 2 );
+	int processingTime = 0;
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	public TileQuartzCrystalizer() {
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+		internalMaxPower = 1500;
+		gridProxy.setIdlePowerUsage( 0 );
+	}
+
+	@Override
+	public void setOrientation(ForgeDirection inForward, ForgeDirection inUp)
+	{
+		super.setOrientation( inForward, inUp );
+		gridProxy.setValidSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+		setPowerSides( EnumSet.of( getUp(), getUp().getOpposite() ) );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 1;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return i == 0;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return i == 1;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	public void activate(EntityPlayer player)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+}

tile/misc/TileVibrationChamber.java

@@ -0,0 +1,245 @@
+package appeng.tile.misc;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntityFurnace;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.Actionable;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.GridAccessException;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileVibrationChamber extends AENetworkInvTile implements IGridTickable
+{
+
+	final double powerPerTick = 5;
+
+	final int sides[] = new int[] { 0 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
+
+	public int burnSpeed = 100;
+	public double burnTime = 0;
+	public double maxBurnTime = 0;
+
+	// client side..
+	public boolean isOn;
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	private class TileVibrationChamberHandler extends AETileEventHandler
+	{
+
+		public TileVibrationChamberHandler() {
+			super( EnumSet.of( TileEventType.NETWORK, TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			boolean wasOn = isOn;
+			isOn = data.readBoolean();
+			return wasOn != isOn; // TESR dosn't need updates!
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			data.writeBoolean( burnTime > 0 );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setDouble( "burnTime", burnTime );
+			data.setDouble( "maxBurnTime", maxBurnTime );
+			data.setInteger( "burnSpeed", burnSpeed );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			burnTime = data.getDouble( "burnTime" );
+			maxBurnTime = data.getDouble( "maxBurnTime" );
+			burnSpeed = data.getInteger( "burnSpeed" );
+		}
+
+	};
+
+	public TileVibrationChamber() {
+		gridProxy.setIdlePowerUsage( 0 );
+		addNewHandler( new TileVibrationChamberHandler() );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		if ( burnTime <= 0 )
+		{
+			eatFuel();
+
+			if ( burnTime > 0 )
+			{
+				try
+				{
+					gridProxy.getTick().wakeDevice( gridProxy.getNode() );
+				}
+				catch (GridAccessException e)
+				{
+					// wake up!
+				}
+			}
+		}
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 64;
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		return TileEntityFurnace.getItemBurnTime( itemstack ) > 0;
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return false;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		if ( burnTime <= 0 )
+			eatFuel();
+
+		return new TickingRequest( 10, 40, burnTime <= 0, false );
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		if ( burnTime <= 0 )
+		{
+			eatFuel();
+
+			if ( burnTime > 0 )
+				return TickRateModulation.URGENT;
+
+			burnSpeed = 100;
+			return TickRateModulation.SLEEP;
+		}
+
+		burnSpeed = Math.max( 20, Math.min( burnSpeed, 200 ) );
+		double dialiation = burnSpeed / 100.0;
+
+		double timePassed = (double) TicksSinceLastCall * dialiation;
+		burnTime -= timePassed;
+		if ( burnTime < 0 )
+		{
+			timePassed += burnTime;
+			burnTime = 0;
+		}
+
+		try
+		{
+			IEnergyGrid grid = gridProxy.getEnergy();
+			double newPower = timePassed * powerPerTick;
+			double overFlow = grid.injectPower( newPower, Actionable.SIMULATE );
+
+			// burn the over flow.
+			grid.injectPower( Math.max( 0.0, newPower - overFlow ), Actionable.MODULATE );
+
+			if ( overFlow > 0 )
+				burnSpeed -= TicksSinceLastCall;
+			else
+				burnSpeed += TicksSinceLastCall;
+
+			burnSpeed = Math.max( 20, Math.min( burnSpeed, 200 ) );
+			return overFlow > 0 ? TickRateModulation.SLOWER : TickRateModulation.FASTER;
+		}
+		catch (GridAccessException e)
+		{
+			burnSpeed -= TicksSinceLastCall;
+			burnSpeed = Math.max( 20, Math.min( burnSpeed, 200 ) );
+			return TickRateModulation.SLOWER;
+		}
+	}
+
+	private void eatFuel()
+	{
+		ItemStack is = getStackInSlot( 0 );
+		if ( is != null )
+		{
+			int newBurnTime = TileEntityFurnace.getItemBurnTime( is );
+			if ( newBurnTime > 0 && is.stackSize > 0 )
+			{
+				burnTime += newBurnTime;
+				maxBurnTime = burnTime;
+				is.stackSize--;
+				if ( is.stackSize <= 0 )
+					setInventorySlotContents( 0, null );
+				else
+					setInventorySlotContents( 0, is );
+			}
+		}
+
+		if ( burnTime > 0 )
+		{
+			try
+			{
+				gridProxy.getTick().wakeDevice( gridProxy.getNode() );
+			}
+			catch (GridAccessException e)
+			{
+				// gah!
+			}
+		}
+
+		if ( (!isOn && burnTime > 0) || (isOn && burnTime <= 0) )
+		{
+			isOn = burnTime > 0;
+			markForUpdate();
+		}
+	}
+}

tile/networking/TileCableBus.java

@@ -0,0 +1,252 @@
+package appeng.tile.networking;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.IGridNode;
+import appeng.api.parts.IFacadeContainer;
+import appeng.api.parts.IPart;
+import appeng.api.parts.SelectedPart;
+import appeng.api.util.AECableType;
+import appeng.api.util.AEColor;
+import appeng.api.util.DimensionalCoord;
+import appeng.helpers.AEMultiTile;
+import appeng.helpers.ICustomCollision;
+import appeng.helpers.TickHandler;
+import appeng.parts.CableBusContainer;
+import appeng.tile.AEBaseTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+
+public class TileCableBus extends AEBaseTile implements AEMultiTile, ICustomCollision
+{
+
+	public CableBusContainer cb = new CableBusContainer( this );
+	private int oldLV = -1; // on re-calculate light when it changes
+
+	class CableBusHandler extends AETileEventHandler
+	{
+
+		public CableBusHandler() {
+			super( EnumSet.of( TileEventType.NETWORK, TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			cb.readFromNBT( data );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			cb.writeToNBT( data );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			boolean ret = cb.readFromStream( data );
+
+			int newLV = cb.getLightValue();
+			if ( newLV != oldLV )
+			{
+				oldLV = newLV;
+				worldObj.updateAllLightTypes( xCoord, yCoord, zCoord );
+			}
+
+			return ret;
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			cb.writeToStream( data );
+		}
+
+	};
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		if ( cb.isEmpty() )
+			worldObj.destroyBlock( xCoord, yCoord, zCoord, true );
+		else
+			cb.addToWorld();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		cb.removeFromWorld();
+	}
+
+	@Override
+	public void validate()
+	{
+		super.validate();
+		TickHandler.instance.addInit( this );
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		cb.removeFromWorld();
+	}
+
+	@Override
+	public boolean canBeRotated()
+	{
+		return false;
+	}
+
+	@Override
+	public void getDrops(World w, int x, int y, int z, ArrayList drops)
+	{
+		cb.getDrops( drops );
+	}
+
+	public TileCableBus() {
+		addNewHandler( new CableBusHandler() );
+	}
+
+	@Override
+	public IGridNode getGridNode(ForgeDirection dir)
+	{
+		return cb.getGridNode( dir );
+	}
+
+	@Override
+	public boolean canAddPart(ItemStack is, ForgeDirection side)
+	{
+		return cb.canAddPart( is, side );
+	}
+
+	@Override
+	public ForgeDirection addPart(ItemStack is, ForgeDirection side)
+	{
+		return cb.addPart( is, side );
+	}
+
+	@Override
+	public void removePart(ForgeDirection side)
+	{
+		cb.removePart( side );
+	}
+
+	@Override
+	public IPart getPart(ForgeDirection side)
+	{
+		return cb.getPart( side );
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public TileEntity getTile()
+	{
+		return this;
+	}
+
+	@Override
+	public Iterable<AxisAlignedBB> getSelectedBoundingBoxsFromPool(World w, int x, int y, int z)
+	{
+		return cb.getSelectedBoundingBoxsFromPool( false );
+	}
+
+	@Override
+	public void addCollidingBlockToList(World w, int x, int y, int z, AxisAlignedBB bb, List out, Entity e)
+	{
+		for (AxisAlignedBB bx : getSelectedBoundingBoxsFromPool( w, x, y, z ))
+			out.add( AxisAlignedBB.getAABBPool().getAABB( bx.minX, bx.minY, bx.minZ, bx.maxX, bx.maxY, bx.maxZ ) );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection side)
+	{
+		return cb.getCableConnectionType( side );
+	}
+
+	@Override
+	public AEColor getColor()
+	{
+		return cb.getColor();
+	}
+
+	@Override
+	public IFacadeContainer getFacadeContainer()
+	{
+		return cb.getFacadeContainer();
+	}
+
+	@Override
+	public void clearContainer()
+	{
+		cb = new CableBusContainer( this );
+	}
+
+	@Override
+	public boolean isBlocked(ForgeDirection side)
+	{
+		return false;
+	}
+
+	@Override
+	public void markForUpdate()
+	{
+		if ( worldObj == null )
+			return;
+
+		int newLV = cb.getLightValue();
+		if ( newLV != oldLV )
+		{
+			oldLV = newLV;
+			worldObj.updateAllLightTypes( xCoord, yCoord, zCoord );
+		}
+
+		super.markForUpdate();
+	}
+
+	@Override
+	public SelectedPart selectPart(Vec3 pos)
+	{
+		return cb.selectPart( pos );
+	}
+
+	@Override
+	public void PartChanged()
+	{
+		// nothing!
+	}
+
+	@Override
+	public void markForSave()
+	{
+		onInventoryChanged();
+	}
+
+	@Override
+	public boolean hasRedstone(ForgeDirection side)
+	{
+		return cb.hasRedstone( side );
+	}
+}

tile/networking/TileController.java

@@ -0,0 +1,171 @@
+package appeng.tile.networking;
+
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.Actionable;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.networking.events.MENetworkControllerChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.events.MENetworkPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
+import appeng.api.networking.pathing.ControllerState;
+import appeng.me.GridAccessException;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileController extends AENetworkPowerTile implements IAEPowerStorage
+{
+
+	boolean isValid = false;
+
+	public TileController() {
+		internalMaxPower = 8000;
+		internalPublicPowerStorage = true;
+		gridProxy.setIdlePowerUsage( 6 );
+		gridProxy.setFlags( GridFlags.CANNOT_CARRY );
+	}
+
+	@Override
+	protected double getFunnelPowerDemand()
+	{
+		try
+		{
+			return gridProxy.getEnergy().getEnergyDemand( 8000 );
+		}
+		catch (GridAccessException e)
+		{
+			// no grid? use local...
+			return super.getFunnelPowerDemand();
+		}
+	}
+
+	@Override
+	protected double funnelPowerIntoStorage(double AEUnits, Actionable mode)
+	{
+		try
+		{
+			double ret = gridProxy.getEnergy().injectPower( AEUnits, mode );
+			if ( mode == Actionable.SIMULATE )
+				return ret;
+			return 0;
+		}
+		catch (GridAccessException e)
+		{
+			// no grid? use local...
+			return super.funnelPowerIntoStorage( AEUnits, mode );
+		}
+	}
+
+	@Override
+	protected void PowerEvent(PowerEventType x)
+	{
+		try
+		{
+			gridProxy.getGrid().postEvent( new MENetworkPowerStorage( this, x ) );
+		}
+		catch (GridAccessException e)
+		{
+			// not ready!
+		}
+	}
+
+	@MENetworkEventSubscribe
+	public void onPowerChange(MENetworkControllerChange status)
+	{
+		updateMeta();
+	}
+
+	@MENetworkEventSubscribe
+	public void onPowerChange(MENetworkPowerStatusChange status)
+	{
+		updateMeta();
+	}
+
+	@Override
+	public void onReady()
+	{
+		onNeighborChange( true );
+		super.onReady();
+	}
+
+	public void onNeighborChange(boolean force)
+	{
+		boolean xx = worldObj.getBlockTileEntity( xCoord - 1, yCoord, zCoord ) instanceof TileController
+				&& worldObj.getBlockTileEntity( xCoord + 1, yCoord, zCoord ) instanceof TileController;
+		boolean yy = worldObj.getBlockTileEntity( xCoord, yCoord - 1, zCoord ) instanceof TileController
+				&& worldObj.getBlockTileEntity( xCoord, yCoord + 1, zCoord ) instanceof TileController;
+		boolean zz = worldObj.getBlockTileEntity( xCoord, yCoord, zCoord - 1 ) instanceof TileController
+				&& worldObj.getBlockTileEntity( xCoord, yCoord, zCoord + 1 ) instanceof TileController;
+
+		// int meta = world.getBlockMetadata( xCoord, yCoord, zCoord );
+		// boolean hasPower = meta > 0;
+		// boolean isConflict = meta == 2;
+
+		boolean oldValid = isValid;
+
+		isValid = (xx && !yy && !zz) || (!xx && yy && !zz) || (!xx && !yy && zz) || ((xx ? 1 : 0) + (yy ? 1 : 0) + (zz ? 1 : 0) <= 1);
+
+		if ( oldValid != isValid || force )
+		{
+			if ( isValid )
+				gridProxy.setValidSides( EnumSet.allOf( ForgeDirection.class ) );
+			else
+				gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+		}
+
+		updateMeta();
+	}
+
+	private void updateMeta()
+	{
+		if ( !gridProxy.isReady() )
+			return;
+
+		int meta = 0;
+
+		try
+		{
+			if ( gridProxy.getEnergy().isNetworkPowered() )
+			{
+				meta = 1;
+
+				if ( gridProxy.getPath().getControllerState() == ControllerState.CONTROLLER_CONFLICT )
+					meta = 2;
+			}
+		}
+		catch (GridAccessException e)
+		{
+			meta = 0;
+		}
+
+		worldObj.setBlockMetadataWithNotify( xCoord, yCoord, zCoord, meta, 2 );
+	}
+
+	final int sides[] = new int[] { 0 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+}

tile/networking/TileCreativeEnergyCell.java

@@ -0,0 +1,60 @@
+package appeng.tile.networking;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.util.AECableType;
+import appeng.tile.grid.AENetworkTile;
+
+public class TileCreativeEnergyCell extends AENetworkTile implements IAEPowerStorage
+{
+
+	public TileCreativeEnergyCell() {
+		gridProxy.setIdlePowerUsage( 0 );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	@Override
+	public double injectAEPower(double amt, Actionable mode)
+	{
+		return 0;
+	}
+
+	@Override
+	public double extractAEPower(double amt, Actionable mode, PowerMultiplier pm)
+	{
+		return amt;
+	}
+
+	@Override
+	public double getAEMaxPower()
+	{
+		return Integer.MAX_VALUE;
+	}
+
+	@Override
+	public double getAECurrentPower()
+	{
+		return Integer.MAX_VALUE - 32;
+	}
+
+	@Override
+	public boolean isAEPublicPowerStorage()
+	{
+		return true;
+	}
+
+	@Override
+	public AccessRestriction getPowerFlow()
+	{
+		return AccessRestriction.READ_WRITE;
+	}
+
+}

tile/networking/TileDenseEnergyCell.java

@@ -0,0 +1,10 @@
+package appeng.tile.networking;
+
+public class TileDenseEnergyCell extends TileEnergyCell
+{
+
+	public TileDenseEnergyCell() {
+		internalMaxPower = 200000 * 8;
+	}
+
+}

tile/networking/TileEnergyAcceptor.java

@@ -0,0 +1,85 @@
+package appeng.tile.networking;
+
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.util.AECableType;
+import appeng.me.GridAccessException;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileEnergyAcceptor extends AENetworkPowerTile
+{
+
+	final int sides[] = new int[] {};
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 0 );
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	private class TilePowerRelayHandler extends AETileEventHandler
+	{
+
+		public TilePowerRelayHandler() {
+			super( EnumSet.of( TileEventType.TICK ) );
+		}
+
+		@Override
+		public void Tick()
+		{
+			if ( internalCurrentPower > 0 )
+			{
+				try
+				{
+					IEnergyGrid eg = gridProxy.getEnergy();
+					double powerRequested = internalCurrentPower - eg.injectPower( internalCurrentPower, Actionable.SIMULATE );
+					
+					if ( powerRequested > 0 )
+					{
+						internalCurrentPower += eg.injectPower( extractAEPower( powerRequested, Actionable.MODULATE, PowerMultiplier.ONE ), Actionable.MODULATE );
+					}
+				}
+				catch (GridAccessException e)
+				{
+					// null net, probably bads.
+				}
+
+			}
+		}
+	};
+
+	public TileEnergyAcceptor() {
+		gridProxy.setIdlePowerUsage( 1.0 / 16.0 );
+		addNewHandler( new TilePowerRelayHandler() );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+}

tile/networking/TileEnergyCell.java

@@ -0,0 +1,210 @@
+package appeng.tile.networking;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
+import appeng.api.util.AECableType;
+import appeng.me.GridAccessException;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkTile;
+import appeng.util.SettingsFrom;
+
+public class TileEnergyCell extends AENetworkTile implements IAEPowerStorage
+{
+
+	protected double internalCurrentPower = 0.0;
+	protected double internalMaxPower = 200000.0;
+
+	private byte currentMeta = -1;
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.COVERED;
+	}
+
+	private void changePowerLevel()
+	{
+		byte leel = (byte) (8.0 * (internalCurrentPower / internalMaxPower));
+
+		if ( leel > 7 )
+			leel = 7;
+		if ( leel < 0 )
+			leel = 0;
+
+		if ( currentMeta != leel )
+		{
+			currentMeta = leel;
+			worldObj.setBlockMetadataWithNotify( xCoord, yCoord, zCoord, currentMeta, 2 );
+		}
+	}
+
+	private class TileEnergyCellHandler extends AETileEventHandler
+	{
+
+		public TileEnergyCellHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setDouble( "internalCurrentPower", internalCurrentPower );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			internalCurrentPower = data.getDouble( "internalCurrentPower" );
+		}
+
+	};
+
+	public TileEnergyCell() {
+		gridProxy.setIdlePowerUsage( 0 );
+		addNewHandler( new TileEnergyCellHandler() );
+	}
+
+	@Override
+	public boolean canBeRotated()
+	{
+		return false;
+	}
+
+	@Override
+	final public double injectAEPower(double amt, Actionable mode)
+	{
+		if ( mode == Actionable.SIMULATE )
+		{
+			double fakeBattery = internalCurrentPower + amt;
+			if ( fakeBattery > internalMaxPower )
+			{
+				return fakeBattery - internalMaxPower;
+			}
+
+			return 0;
+		}
+
+		if ( internalCurrentPower < 0.01 && amt > 0.01 )
+			gridProxy.getNode().getGrid().postEvent( new MENetworkPowerStorage( this, PowerEventType.PROVIDE_POWER ) );
+
+		internalCurrentPower += amt;
+		if ( internalCurrentPower > internalMaxPower )
+		{
+			amt = internalCurrentPower - internalMaxPower;
+			internalCurrentPower = internalMaxPower;
+
+			changePowerLevel();
+			return amt;
+		}
+
+		changePowerLevel();
+		return 0;
+	}
+
+	final private double extractAEPower(double amt, Actionable mode)
+	{
+		if ( mode == Actionable.SIMULATE )
+		{
+			if ( internalCurrentPower > amt )
+				return amt;
+			return internalCurrentPower;
+		}
+
+		boolean wasFull = internalCurrentPower >= internalMaxPower - 0.001;
+
+		if ( wasFull && amt > 0.001 )
+		{
+			try
+			{
+				gridProxy.getGrid().postEvent( new MENetworkPowerStorage( this, PowerEventType.REQUEST_POWER ) );
+			}
+			catch (GridAccessException e)
+			{
+
+			}
+		}
+
+		if ( internalCurrentPower > amt )
+		{
+			internalCurrentPower -= amt;
+
+			changePowerLevel();
+			return amt;
+		}
+
+		amt = internalCurrentPower;
+		internalCurrentPower = 0;
+
+		changePowerLevel();
+		return amt;
+	}
+
+	@Override
+	final public double extractAEPower(double amt, Actionable mode, PowerMultiplier pm)
+	{
+		return pm.divide( extractAEPower( pm.multiply( amt ), mode ) );
+	}
+
+	@Override
+	public double getAEMaxPower()
+	{
+		return internalMaxPower;
+	}
+
+	@Override
+	public double getAECurrentPower()
+	{
+		return internalCurrentPower;
+	}
+
+	@Override
+	public boolean isAEPublicPowerStorage()
+	{
+		return true;
+	}
+
+	@Override
+	public AccessRestriction getPowerFlow()
+	{
+		return AccessRestriction.READ_WRITE;
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		currentMeta = (byte) worldObj.getBlockMetadata( xCoord, yCoord, zCoord );
+		changePowerLevel();
+	}
+
+	@Override
+	public NBTTagCompound downloadSettings(SettingsFrom from)
+	{
+		if ( from == SettingsFrom.DISMANTLE_ITEM )
+		{
+			NBTTagCompound tag = new NBTTagCompound();
+			tag.setDouble( "internalCurrentPower", internalCurrentPower );
+			tag.setDouble( "internalMaxPower", internalMaxPower ); // used for tool tip.
+			return tag;
+		}
+		return null;
+	}
+
+	@Override
+	public void uploadSettings(SettingsFrom from, NBTTagCompound compound)
+	{
+		if ( from == SettingsFrom.DISMANTLE_ITEM )
+		{
+			internalCurrentPower = compound.getDouble( "internalCurrentPower" );
+		}
+	}
+}

tile/networking/TileWireless.java

@@ -0,0 +1,137 @@
+package appeng.tile.networking;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.core.Configuration;
+import appeng.me.GridAccessException;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileWireless extends AENetworkInvTile
+{
+
+	public static final int POWERED_FLAG = 1;
+	public static final int CHANNEL_FLAG = 2;
+
+	final int sides[] = new int[] { 0 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
+
+	public int clientFlags = 0;
+
+	public TileWireless() {
+		gridProxy.setFlags( GridFlags.REQURE_CHANNEL );
+		addNewHandler( new TileWirelessHandler() );
+	}
+
+	@MENetworkEventSubscribe
+	public void chanRender(MENetworkChannelsChanged c)
+	{
+		markForUpdate();
+	}
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		markForUpdate();
+	}
+
+	class TileWirelessHandler extends AETileEventHandler
+	{
+
+		public TileWirelessHandler() {
+			super( EnumSet.of( TileEventType.NETWORK ) );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			boolean eh = super.readFromStream( data );
+
+			int old = clientFlags;
+			clientFlags = data.readByte();
+
+			return eh || old != clientFlags;
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+
+			clientFlags = 0;
+
+			try
+			{
+				if ( gridProxy.getEnergy().isNetworkPowered() )
+					clientFlags |= POWERED_FLAG;
+
+				if ( gridProxy.getNode().meetsChannelRequirements() )
+					clientFlags |= CHANNEL_FLAG;
+			}
+			catch (GridAccessException e)
+			{
+				// meh
+			}
+
+			data.writeByte( (byte) clientFlags );
+		}
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onReady()
+	{
+		updatePower();
+		super.onReady();
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		updatePower();
+	}
+
+	private void updatePower()
+	{
+		ItemStack boosters = inv.getStackInSlot( 0 );
+		gridProxy.setIdlePowerUsage( Configuration.instance.wireless_getPowerDrain( boosters == null ? 0 : boosters.stackSize ) );
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+}

tile/powersink/AEBasePoweredTile.java

@@ -0,0 +1,6 @@
+package appeng.tile.powersink;
+
+public abstract class AEBasePoweredTile extends ThermalExpansion
+{
+
+}

tile/powersink/AERootPoweredTile.java

@@ -0,0 +1,177 @@
+package appeng.tile.powersink;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.PowerUnits;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+
+public abstract class AERootPoweredTile extends AEBaseInvTile implements IAEPowerStorage
+{
+
+	// values that determin general function, are set by inheriting classes if
+	// needed. These should generally remain static.
+	protected double internalMaxPower = 10000;
+	protected boolean internalCanAcceptPower = true;
+	protected boolean internalPublicPowerStorage = false;
+	private EnumSet<ForgeDirection> internalPowerSides = EnumSet.allOf( ForgeDirection.class );
+
+	protected AccessRestriction internalPowerFlow = AccessRestriction.READ_WRITE;
+
+	// the current power buffer.
+	protected double internalCurrentPower = 0;
+
+	protected void setPowerSides(EnumSet<ForgeDirection> sides)
+	{
+		internalPowerSides = sides;
+		// trigger re-calc!
+	}
+
+	protected EnumSet<ForgeDirection> getPowerSides()
+	{
+		return internalPowerSides.clone();
+	}
+
+	private class AEPoweredRootHandler extends AETileEventHandler
+	{
+
+		public AEPoweredRootHandler() {
+			super( EnumSet.of( TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setDouble( "internalCurrentPower", internalCurrentPower );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			internalCurrentPower = data.getDouble( "internalCurrentPower" );
+		}
+
+	};
+
+	public AERootPoweredTile() {
+		addNewHandler( new AEPoweredRootHandler() );
+	}
+
+	final protected double getExternalPowerDemand(PowerUnits externalUnit)
+	{
+		return PowerUnits.AE.convertTo( externalUnit, Math.max( 0.0, getFunnelPowerDemand() ) );
+	}
+
+	protected double getFunnelPowerDemand()
+	{
+		return internalMaxPower - internalCurrentPower;
+	}
+
+	final public double injectExternalPower(PowerUnits input, double amt)
+	{
+		return PowerUnits.AE.convertTo( input, funnelPowerIntoStorage( input.convertTo( PowerUnits.AE, amt ), Actionable.MODULATE ) );
+	}
+
+	protected double funnelPowerIntoStorage(double AEUnits, Actionable mode)
+	{
+		return injectAEPower( AEUnits, mode );
+	}
+
+	@Override
+	final public double injectAEPower(double amt, Actionable mode)
+	{
+		if ( mode == Actionable.SIMULATE )
+		{
+			double fakeBattery = internalCurrentPower + amt;
+
+			if ( fakeBattery > internalMaxPower )
+				return fakeBattery - internalMaxPower;
+
+			return 0;
+		}
+		else
+		{
+			if ( internalCurrentPower < 0.01 && amt > 0.01 )
+				PowerEvent( PowerEventType.PROVIDE_POWER );
+
+			internalCurrentPower += amt;
+			if ( internalCurrentPower > internalMaxPower )
+			{
+				amt = internalCurrentPower - internalMaxPower;
+				internalCurrentPower = internalMaxPower;
+				return amt;
+			}
+
+			return 0;
+		}
+	}
+
+	protected void PowerEvent(PowerEventType x)
+	{
+		// nothing.
+	}
+
+	protected double extractAEPower(double amt, Actionable mode)
+	{
+		if ( mode == Actionable.SIMULATE )
+		{
+			if ( internalCurrentPower > amt )
+				return amt;
+			return internalCurrentPower;
+		}
+
+		boolean wasFull = internalCurrentPower >= internalMaxPower - 0.001;
+		if ( wasFull && amt > 0.001 )
+		{
+			PowerEvent( PowerEventType.REQUEST_POWER );
+		}
+
+		if ( internalCurrentPower > amt )
+		{
+			internalCurrentPower -= amt;
+			return amt;
+		}
+
+		amt = internalCurrentPower;
+		internalCurrentPower = 0;
+		return amt;
+	}
+
+	@Override
+	final public double extractAEPower(double amt, Actionable mode, PowerMultiplier multiplier)
+	{
+		return multiplier.divide( extractAEPower( multiplier.multiply( amt ), mode ) );
+	}
+
+	@Override
+	final public double getAEMaxPower()
+	{
+		return internalMaxPower;
+	}
+
+	@Override
+	final public double getAECurrentPower()
+	{
+		return internalCurrentPower;
+	}
+
+	@Override
+	final public boolean isAEPublicPowerStorage()
+	{
+		return internalPublicPowerStorage;
+	}
+
+	@Override
+	final public AccessRestriction getPowerFlow()
+	{
+		return internalPowerFlow;
+	}
+}

tile/powersink/BuildCraft.java

@@ -0,0 +1,98 @@
+package appeng.tile.powersink;
+
+import java.util.EnumSet;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import appeng.core.AppEng;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import buildcraft.api.power.IPowerReceptor;
+import buildcraft.api.power.PowerHandler;
+import buildcraft.api.power.PowerHandler.PowerReceiver;
+import buildcraft.api.power.PowerHandler.Type;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.Optional.Interface;
+import cpw.mods.fml.common.Optional.Method;
+
+@Interface(modid = "BuildCraftAPI|power", iface = "buildcraft.api.power.IPowerReceptor")
+public abstract class BuildCraft extends AERootPoweredTile implements IPowerReceptor
+{
+
+	private class BCPerdition extends AETileEventHandler
+	{
+
+		final protected PowerHandler bcPowerHandler;
+
+		public BCPerdition(IPowerReceptor te) {
+			super( EnumSet.of( TileEventType.TICK, TileEventType.WORLD_NBT ) );
+			bcPowerHandler = new PowerHandler( te, Type.MACHINE );
+		}
+
+		@Override
+		public void Tick()
+		{
+			bcPowerHandler.update();
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			bcPowerHandler.writeToNBT( data, "bcPowerHandler" );
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			bcPowerHandler.readFromNBT( data, "bcPowerHandler" );
+		}
+
+	};
+
+	BCPerdition bcPowerWrapper;
+
+	public BuildCraft() {
+		try
+		{
+			if ( Loader.isModLoaded( "BuildCraftAPI|power" ) )
+			{
+				if ( AppEng.instance.isIntegrationEnabled( "" ) )
+					addNewHandler( bcPowerWrapper = new BCPerdition( this ) );
+				bcPowerWrapper.bcPowerHandler.configure( 1, 380, 1.0f / 5.0f, 1000 );
+			}
+		}
+		catch (Throwable t)
+		{
+			// ignore.. no bc?
+		}
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public PowerReceiver getPowerReceiver(ForgeDirection side)
+	{
+		if ( internalCanAcceptPower && getPowerSides().contains( side ) )
+			return bcPowerWrapper.bcPowerHandler.getPowerReceiver();
+		return null;
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public void doWork(PowerHandler workProvider)
+	{
+		float requred = (float) getExternalPowerDemand( PowerUnits.MJ );
+		double failed = injectExternalPower( PowerUnits.MJ, bcPowerWrapper.bcPowerHandler.useEnergy( 0.0f, requred, true ) );
+		if ( failed > 0.01 )
+			bcPowerWrapper.bcPowerHandler.addEnergy( (float) failed );
+	}
+
+	@Override
+	@Method(modid = "BuildCraftAPI|power")
+	final public World getWorld()
+	{
+		return worldObj;
+	}
+
+}

tile/powersink/IC2.java

@@ -0,0 +1,96 @@
+package appeng.tile.powersink;
+
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.EnumSet;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.ForgeDirection;
+import net.minecraftforge.common.MinecraftForge;
+import appeng.api.config.PowerUnits;
+import appeng.util.Platform;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "IC2", iface = "ic2.api.energy.tile.IEnergySink")
+public abstract class IC2 extends BuildCraft implements IEnergySink
+{
+
+	boolean isInIC2 = false;
+
+	@Override
+	final public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( direction );
+	}
+
+	@Override
+	final public double demandedEnergyUnits()
+	{
+		return getExternalPowerDemand( PowerUnits.EU );
+	}
+
+	@Override
+	final public double injectEnergyUnits(ForgeDirection directionFrom, double amount)
+	{
+		// just store the excess in the current block, if I return the waste,
+		// IC2 will just disintegrate it - Oct 20th 2013
+		double overflow = PowerUnits.EU.convertTo( PowerUnits.AE, injectExternalPower( PowerUnits.EU, amount ) );
+		internalCurrentPower += overflow;
+		return 0; // see above comment.
+	}
+
+	@Override
+	final public int getMaxSafeInput()
+	{
+		return Integer.MAX_VALUE;
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		removeFromENet();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		removeFromENet();
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		addToENet();
+	}
+
+	@Override
+	protected void setPowerSides(EnumSet<ForgeDirection> sides)
+	{
+		super.setPowerSides( sides );
+		removeFromENet();
+		addToENet();
+
+	}
+
+	final private void addToENet()
+	{
+		if ( !isInIC2 && Platform.isServer() )
+		{
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( this ) );
+			isInIC2 = true;
+		}
+	}
+
+	final private void removeFromENet()
+	{
+		if ( isInIC2 && Platform.isServer() )
+		{
+			MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( this ) );
+			isInIC2 = false;
+		}
+	}
+
+}

tile/powersink/RotaryCraft.java

@@ -0,0 +1,125 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.ForgeDirection;
+import Reika.RotaryCraft.API.ShaftPowerReceiver;
+import appeng.api.config.PowerUnits;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "RotaryCraft", iface = "Reika.RotaryCraft.API.ShaftPowerReceiver")
+public abstract class RotaryCraft extends IC2 implements ShaftPowerReceiver
+{
+
+	private int omega = 0;
+	private int torque = 0;
+	private long power = 0;
+	private int alpha = 0;
+
+	@Override
+	final public int getOmega()
+	{
+		return omega;
+	}
+
+	@Override
+	final public int getTorque()
+	{
+		return torque;
+	}
+
+	@Override
+	final public long getPower()
+	{
+		return power;
+	}
+
+	@Override
+	final public String getName()
+	{
+		return "AE";
+	}
+
+	@Override
+	final public int getIORenderAlpha()
+	{
+		return alpha;
+	}
+
+	@Override
+	final public void setIORenderAlpha(int io)
+	{
+		alpha = io;
+	}
+
+	@Override
+	final public int getMachineX()
+	{
+		return xCoord;
+	}
+
+	@Override
+	final public int getMachineY()
+	{
+		return yCoord;
+	}
+
+	@Override
+	final public int getMachineZ()
+	{
+		return zCoord;
+	}
+
+	@Override
+	final public void setOmega(int o)
+	{
+		omega = o;
+	}
+
+	@Override
+	final public void setTorque(int t)
+	{
+		torque = t;
+	}
+
+	@Override
+	final public void setPower(long p)
+	{
+		injectExternalPower( PowerUnits.WA, p );
+		power = p;
+	}
+
+	@Override
+	final public boolean canReadFromBlock(int x, int y, int z)
+	{
+		ForgeDirection side = ForgeDirection.UNKNOWN;
+
+		if ( x == xCoord - 1 )
+			side = ForgeDirection.WEST;
+		else if ( x == xCoord + 1 )
+			side = ForgeDirection.EAST;
+		else if ( z == zCoord - 1 )
+			side = ForgeDirection.NORTH;
+		else if ( z == zCoord + 1 )
+			side = ForgeDirection.SOUTH;
+		else if ( y == yCoord - 1 )
+			side = ForgeDirection.DOWN;
+		else if ( y == yCoord + 1 )
+			side = ForgeDirection.UP;
+
+		return internalCanAcceptPower && getPowerSides().contains( side );
+	}
+
+	@Override
+	final public boolean isReceiving()
+	{
+		return true;
+	}
+
+	@Override
+	final public void noInputMachine()
+	{
+		power = 0;
+		torque = 0;
+		omega = 0;
+	}
+
+}

tile/powersink/ThermalExpansion.java

@@ -0,0 +1,55 @@
+package appeng.tile.powersink;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.config.PowerUnits;
+import cofh.api.energy.IEnergyHandler;
+import cpw.mods.fml.common.Optional.Interface;
+
+@Interface(modid = "ThermalExpansion", iface = "cofh.api.energy.IEnergyHandler")
+public abstract class ThermalExpansion extends RotaryCraft implements IEnergyHandler
+{
+
+	@Override
+	final public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
+	{
+		if ( simulate )
+		{
+			double demand = getExternalPowerDemand( PowerUnits.RF );
+			if ( demand > maxReceive )
+				return maxReceive;
+			return (int) Math.floor( maxReceive - demand );
+		}
+		else
+		{
+			double overFlow = injectExternalPower( PowerUnits.RF, maxReceive );
+			double ox = Math.floor( overFlow );
+			internalCurrentPower += PowerUnits.RF.convertTo( PowerUnits.AE, overFlow - ox );
+			return maxReceive - (int) ox;
+		}
+	}
+
+	@Override
+	final public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
+	{
+		return 0;
+	}
+
+	@Override
+	final public boolean canInterface(ForgeDirection from)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( from );
+	}
+
+	@Override
+	final public int getEnergyStored(ForgeDirection from)
+	{
+		return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, getAECurrentPower() ) );
+	}
+
+	@Override
+	final public int getMaxEnergyStored(ForgeDirection from)
+	{
+		return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, getAEMaxPower() ) );
+	}
+
+}

tile/powersink/UniversalElectricity.java

@@ -0,0 +1,65 @@
+package appeng.tile.powersink;
+
+/*
+import net.minecraftforge.common.ForgeDirection;
+import universalelectricity.core.block.IElectrical;
+import universalelectricity.core.electricity.ElectricityPack;
+import appeng.api.config.PowerUnits;
+
+public abstract class UniversalElectricity extends ThermalExpansion implements IElectrical
+{
+
+	@Override
+	final public boolean canConnect(ForgeDirection direction)
+	{
+		return internalCanAcceptPower && getPowerSides().contains( direction );
+	}
+
+	@Override
+	final public float receiveElectricity(ForgeDirection from, ElectricityPack receive, boolean doReceive)
+	{
+		float accepted = 0;
+		double recievedPower = receive.getWatts();
+
+		if ( doReceive )
+		{
+			accepted = (float) (recievedPower - injectExternalPower( PowerUnits.KJ, recievedPower ));
+		}
+		else
+		{
+			double whatIWant = getExternalPowerDemand( PowerUnits.KJ );
+			if ( whatIWant > recievedPower )
+				accepted = (float) recievedPower;
+			else
+				accepted = (float) whatIWant;
+		}
+
+		return accepted;
+	}
+
+	@Override
+	final public float getRequest(ForgeDirection direction)
+	{
+		return (float) getExternalPowerDemand( PowerUnits.KJ );
+	}
+
+	@Override
+	final public float getVoltage()
+	{
+		return 120;
+	}
+
+	@Override
+	final public ElectricityPack provideElectricity(ForgeDirection from, ElectricityPack request, boolean doProvide)
+	{
+		return null; // cannot be dis-charged
+	}
+
+	@Override
+	final public float getProvide(ForgeDirection direction)
+	{
+		return 0;
+	}
+
+}
+*/

tile/qnb/TileQuantumBridge.java

@@ -0,0 +1,111 @@
+package appeng.tile.qnb;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import appeng.api.AEApi;
+import appeng.me.cluster.IAECluster;
+import appeng.me.cluster.IAEMultiBlock;
+import appeng.me.cluster.implementations.QuantumCluster;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+
+public class TileQuantumBridge extends AENetworkPowerTile implements IAEMultiBlock
+{
+
+	final int sidesRing[] = new int[] {};
+	final int sidesLink[] = new int[] { 0 };
+
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
+
+	final byte start = 8 + 7;
+	public final byte corner = 16;
+	final byte hasSingularity = 32;
+	final byte powered = 64;
+
+	// private QuantumCalculator calc = new QuantumCalculator( this );
+	int oldxdex = -1;
+	byte xdex = -1;
+
+	QuantumCluster clust;
+	public boolean bridgePowered;
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		if ( isCenter() )
+			return sidesLink;
+		return sidesRing;
+	}
+
+	@Override
+	public void disconnect()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public IAECluster getCluster()
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public void updateStatus(QuantumCluster c, byte fish)
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	public long getQEDest()
+	{
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	public boolean isCenter()
+	{
+		return getBlockType() == AEApi.instance().blocks().blockQuantumLink.block();
+	}
+
+	public boolean isCorner()
+	{
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public boolean isPowered()
+	{
+		if ( Platform.isClient() )
+			return (xdex & powered) == powered;
+
+		return false;
+	}
+
+	public boolean isFormed()
+	{
+		return xdex != -1;
+	}
+
+}

tile/spatial/TileSpatialIOPort.java

@@ -0,0 +1,68 @@
+package appeng.tile.spatial;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileSpatialIOPort extends AENetworkInvTile
+{
+
+	final int sides[] = { 0, 1 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 2 );
+	boolean lastRedstoneState = false;
+
+	public void updateRedstoneState()
+	{
+		boolean currentState = worldObj.isBlockIndirectlyGettingPowered( xCoord, yCoord, zCoord );
+		if ( lastRedstoneState != currentState )
+		{
+			lastRedstoneState = currentState;
+			if ( currentState )
+			{
+				triggerTransition();
+			}
+		}
+	}
+
+	private void triggerTransition()
+	{
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+}

tile/spatial/TileSpatialPylon.java

@@ -0,0 +1,229 @@
+package appeng.tile.spatial;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.me.GridAccessException;
+import appeng.me.cluster.IAEMultiBlock;
+import appeng.me.cluster.implementations.SpatialPylonCalculator;
+import appeng.me.cluster.implementations.SpatialPylonCluster;
+import appeng.me.helpers.AENetworkProxy;
+import appeng.me.helpers.AENetworkProxyMultiblock;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkTile;
+
+public class TileSpatialPylon extends AENetworkTile implements IAEMultiBlock
+{
+
+	public final int DISPLAY_ENDMIN = 0x01;
+	public final int DISPLAY_ENDMAX = 0x02;
+	public final int DISPLAY_MIDDLE = 0x01 + 0x02;
+	public final int DISPLAY_X = 0x04;
+	public final int DISPLAY_Y = 0x08;
+	public final int DISPLAY_Z = 0x04 + 0x08;
+	public final int MB_STATUS = 0x01 + 0x02 + 0x04 + 0x08;
+
+	public final int DISPLAY_ENABLED = 0x10;
+	public final int DISPLAY_POWEREDENABLED = 0x20;
+	public final int NET_STATUS = 0x10 + 0x20;
+
+	int displayBits = 0;
+	SpatialPylonCluster clust;
+	final SpatialPylonCalculator calc = new SpatialPylonCalculator( this );
+
+	boolean didHaveLight = false;
+
+	@Override
+	protected AENetworkProxy createProxy()
+	{
+		return new AENetworkProxyMultiblock( this, "proxy", true );
+	}
+
+	@Override
+	public boolean canBeRotated()
+	{
+		return false;
+	}
+
+	private class TileSpatialPylonHandler extends AETileEventHandler
+	{
+
+		public TileSpatialPylonHandler() {
+			super( EnumSet.of( TileEventType.NETWORK ) );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			int old = displayBits;
+			displayBits = data.readByte();
+			return old != displayBits;
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			data.writeByte( displayBits );
+		}
+
+	};
+
+	public TileSpatialPylon() {
+		gridProxy.setFlags( GridFlags.REQURE_CHANNEL, GridFlags.MULTIBLOCK );
+		gridProxy.setIdlePowerUsage( 0.5 );
+		gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
+		addNewHandler( new TileSpatialPylonHandler() );
+	}
+
+	@Override
+	public void onReady()
+	{
+		super.onReady();
+		onNeighborBlockChange();
+	}
+
+	@Override
+	public void markForUpdate()
+	{
+		super.markForUpdate();
+		boolean hasLight = getLightValue() > 0;
+		if ( hasLight != didHaveLight )
+		{
+			didHaveLight = hasLight;
+			worldObj.updateAllLightTypes( xCoord, yCoord, zCoord );
+		}
+	}
+
+	public int getLightValue()
+	{
+		if ( (displayBits & DISPLAY_POWEREDENABLED) == DISPLAY_POWEREDENABLED )
+		{
+			return 8;
+		}
+		return 0;
+	}
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		recalculateDisplay();
+	}
+
+	@MENetworkEventSubscribe
+	public void activeRender(MENetworkChannelsChanged c)
+	{
+		recalculateDisplay();
+	}
+
+	@Override
+	public void invalidate()
+	{
+		super.invalidate();
+		disconnect();
+	}
+
+	@Override
+	public void onChunkUnload()
+	{
+		super.onChunkUnload();
+		disconnect();
+	}
+
+	public void onNeighborBlockChange()
+	{
+		calc.calculateMultiblock( worldObj, getLocation() );
+	}
+
+	@Override
+	public SpatialPylonCluster getCluster()
+	{
+		return clust;
+	}
+
+	public void recalculateDisplay()
+	{
+		int oldBits = displayBits;
+
+		displayBits = 0;
+
+		if ( clust != null )
+		{
+			if ( clust.min.equals( getLocation() ) )
+				displayBits = DISPLAY_ENDMIN;
+			else if ( clust.max.equals( getLocation() ) )
+				displayBits = DISPLAY_ENDMAX;
+			else
+				displayBits = DISPLAY_MIDDLE;
+
+			switch (clust.currentAxis)
+			{
+			case X:
+				displayBits |= DISPLAY_X;
+				break;
+			case Y:
+				displayBits |= DISPLAY_Y;
+				break;
+			case Z:
+				displayBits |= DISPLAY_Z;
+				break;
+			default:
+				displayBits = 0;
+				break;
+			}
+
+			try
+			{
+				if ( gridProxy.getEnergy().isNetworkPowered() )
+					displayBits |= DISPLAY_POWEREDENABLED;
+
+				if ( clust.isValid && gridProxy.isActive() )
+					displayBits |= DISPLAY_ENABLED;
+			}
+			catch (GridAccessException e)
+			{
+				// nothing?
+			}
+
+		}
+
+		if ( oldBits != displayBits )
+			markForUpdate();
+	}
+
+	public void updateStatus(SpatialPylonCluster c)
+	{
+		clust = c;
+		gridProxy.setValidSides( c == null ? EnumSet.noneOf( ForgeDirection.class ) : EnumSet.allOf( ForgeDirection.class ) );
+		recalculateDisplay();
+	}
+
+	@Override
+	public void disconnect()
+	{
+		if ( clust != null )
+		{
+			clust.destroy();
+			updateStatus( null );
+		}
+	}
+
+	@Override
+	public boolean isValid()
+	{
+		return true;
+	}
+
+	public int getDisplayBits()
+	{
+		return displayBits;
+	}
+
+}

tile/storage/TileChest.java

@@ -0,0 +1,620 @@
+package appeng.tile.storage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.implementations.IMEChest;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.events.MENetworkCellArrayUpdate;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.events.MENetworkPowerStorage;
+import appeng.api.networking.events.MENetworkPowerStorage.PowerEventType;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.ICellHandler;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.IMEMontorHandlerReciever;
+import appeng.api.storage.MEMontorHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.core.AELog;
+import appeng.helpers.AENoHandler;
+import appeng.me.GridAccessException;
+import appeng.me.storage.MEInventoryHandler;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkPowerTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import appeng.util.item.AEFluidStack;
+
+public class TileChest extends AENetworkPowerTile implements IMEChest, IFluidHandler
+{
+
+	static final AENoHandler noHandler = new AENoHandler();
+
+	static final int sides[] = new int[] { 0 };
+	static final int front[] = new int[] { 1 };
+
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 2 );
+
+	ItemStack storageType;
+	long lastStateChange = 0;
+	int priority = 0;
+	int state = 0;
+
+	private void recalculateDisplay()
+	{
+		int oldState = state;
+
+		for (int x = 0; x < getCellCount(); x++)
+			state |= (getCellStatus( x ) << (3 * x));
+
+		if ( getAECurrentPower() > 64 || gridProxy.isActive() )
+			state |= 0x40;
+		else
+			state &= ~0x40;
+
+		if ( oldState != state )
+			markForUpdate();
+	}
+
+	@Override
+	protected void PowerEvent(PowerEventType x)
+	{
+		if ( x == PowerEventType.REQUEST_POWER )
+		{
+			try
+			{
+				gridProxy.getGrid().postEvent( new MENetworkPowerStorage( this, PowerEventType.REQUEST_POWER ) );
+			}
+			catch (GridAccessException e)
+			{
+				// :(
+			}
+		}
+		else
+			recalculateDisplay();
+	}
+
+	private class invManger extends AETileEventHandler
+	{
+
+		public invManger() {
+			super( EnumSet.of( TileEventType.TICK, TileEventType.NETWORK, TileEventType.WORLD_NBT ) );
+		}
+
+		@Override
+		public void Tick()
+		{
+			if ( Platform.isClient() )
+				return;
+
+			double idleUsage = gridProxy.getIdlePowerUsage();
+
+			try
+			{
+				if ( !gridProxy.getEnergy().isNetworkPowered() )
+				{
+					double powerUsed = extractAEPower( idleUsage, Actionable.MODULATE, PowerMultiplier.CONFIG ); // drain
+					if ( powerUsed + 0.1 >= idleUsage != (state & 0x40) > 0 )
+						recalculateDisplay();
+				}
+			}
+			catch (GridAccessException e)
+			{
+				double powerUsed = extractAEPower( gridProxy.getIdlePowerUsage(), Actionable.MODULATE, PowerMultiplier.CONFIG ); // drain
+				if ( powerUsed + 0.1 >= idleUsage != (state & 0x40) > 0 )
+					recalculateDisplay();
+			}
+
+			if ( inv.getStackInSlot( 0 ) != null )
+			{
+				tryToStoreContents();
+			}
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			if ( worldObj.getTotalWorldTime() - lastStateChange > 8 )
+				state = 0;
+			else
+				state &= 0x24924924; // just keep the blinks...
+
+			for (int x = 0; x < getCellCount(); x++)
+				state |= (getCellStatus( x ) << (3 * x));
+
+			if ( getAECurrentPower() > 64 || gridProxy.isActive() )
+				state |= 0x40;
+			else
+				state &= ~0x40;
+
+			data.writeByte( state );
+			ItemStack is = inv.getStackInSlot( 1 );
+
+			if ( is == null )
+			{
+				data.writeInt( 0 );
+			}
+			else
+			{
+				data.writeInt( (is.getItemDamage() << Platform.DEF_OFFSET) | is.itemID );
+			}
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			int oldState = state;
+			ItemStack oldType = storageType;
+
+			state = data.readByte();
+
+			int item = data.readInt();
+
+			if ( item == 0 )
+				storageType = null;
+			else
+				storageType = new ItemStack( item & 0xffff, 1, item >> Platform.DEF_OFFSET );
+
+			lastStateChange = worldObj.getTotalWorldTime();
+
+			AELog.info( "" + (state & 0x40) );
+			return (state & 0xDB6DB6DB) != (oldState & 0xDB6DB6DB) || oldType != storageType;
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			priority = data.getInteger( "priority" );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setInteger( "priority", priority );
+		}
+
+	};
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		recalculateDisplay();
+	}
+
+	@MENetworkEventSubscribe
+	public void channelRender(MENetworkChannelsChanged c)
+	{
+		recalculateDisplay();
+	}
+
+	public TileChest() {
+		gridProxy.setFlags( GridFlags.REQURE_CHANNEL );
+		addNewHandler( new invManger() );
+
+		internalPublicPowerStorage = true;
+		internalPowerFlow = AccessRestriction.WRITE;
+	}
+
+	boolean isCached = false;
+
+	private ICellHandler cellHandler;
+	private MEMontorHandler icell;
+	private MEMontorHandler fcell;
+
+	@Override
+	public IMEMonitor getItemInventory()
+	{
+		return icell;
+	}
+
+	@Override
+	public IMEMonitor getFluidInventory()
+	{
+		return fcell;
+	}
+
+	class ChestNetNotifier<T extends IAEStack<T>> implements IMEMontorHandlerReciever<T>
+	{
+
+		final StorageChannel chan;
+
+		public ChestNetNotifier(StorageChannel chan) {
+			this.chan = chan;
+		}
+
+		@Override
+		public void postChange(T change)
+		{
+			try
+			{
+				gridProxy.getStorage().postAlterationOfStoredItems( chan, change );
+			}
+			catch (GridAccessException e)
+			{
+				// :(
+			}
+		}
+
+		@Override
+		public boolean isValid(Object verificationToken)
+		{
+			if ( chan == StorageChannel.ITEMS )
+				return verificationToken == icell;
+			if ( chan == StorageChannel.FLUIDS )
+				return verificationToken == fcell;
+			return false;
+		}
+
+	};
+
+	private <StackType extends IAEStack> MEMontorHandler<StackType> wrap(IMEInventoryHandler h)
+	{
+		if ( h == null )
+			return null;
+
+		MEInventoryHandler ih = new MEInventoryHandler( h );
+		ih.myPriority = priority;
+
+		MEMontorHandler<StackType> g = new MEMontorHandler<StackType>( ih );
+		g.addListener( new ChestNetNotifier( h.getChannel() ), g );
+
+		return g;
+	}
+
+	private IMEInventoryHandler getHandler(StorageChannel channel) throws AENoHandler
+	{
+		if ( !isCached )
+		{
+			ItemStack is = inv.getStackInSlot( 1 );
+			if ( is != null )
+			{
+				isCached = true;
+				cellHandler = AEApi.instance().registries().cell().getHander( is );
+				icell = wrap( cellHandler.getCellInventory( is, StorageChannel.ITEMS ) );
+				fcell = wrap( cellHandler.getCellInventory( is, StorageChannel.FLUIDS ) );
+			}
+		}
+
+		switch (channel)
+		{
+		case FLUIDS:
+			if ( fcell == null )
+				throw noHandler;
+			return fcell;
+		case ITEMS:
+			if ( icell == null )
+				throw noHandler;
+			return icell;
+		default:
+		}
+
+		return null;
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		if ( slot == 1 )
+		{
+			icell = null;
+			fcell = null;
+			isCached = false; // recalculate the storage cell.
+
+			try
+			{
+				IStorageGrid gs = gridProxy.getStorage();
+				Platform.postChanges( gs, removed, added );
+
+				gridProxy.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+			}
+			catch (GridAccessException e)
+			{
+
+			}
+
+			// update the neighbors
+			if ( worldObj != null )
+			{
+				worldObj.notifyBlocksOfNeighborChange( xCoord, yCoord, zCoord, 0 );
+				markForUpdate();
+			}
+		}
+	}
+
+	@Override
+	public void setInventorySlotContents(int i, ItemStack itemstack)
+	{
+		inv.setInventorySlotContents( i, itemstack );
+		tryToStoreContents();
+	}
+
+	private void tryToStoreContents()
+	{
+		try
+		{
+			if ( getStackInSlot( 0 ) != null )
+			{
+				IMEInventory<IAEItemStack> cell = getHandler( StorageChannel.ITEMS );
+
+				IAEItemStack returns = Platform.poweredInsert( this, cell, AEApi.instance().storage().createItemStack( inv.getStackInSlot( 0 ) ) );
+
+				if ( returns == null )
+					inv.setInventorySlotContents( 0, null );
+				else
+					inv.setInventorySlotContents( 0, returns.getItemStack() );
+			}
+		}
+		catch (AENoHandler t)
+		{
+		}
+	}
+
+	@Override
+	public boolean canExtractItem(int i, ItemStack itemstack, int j)
+	{
+		return false;
+	}
+
+	@Override
+	public boolean canInsertItem(int i, ItemStack itemstack, int j)
+	{
+		try
+		{
+			IMEInventory<IAEItemStack> cell = getHandler( StorageChannel.ITEMS );
+			IAEItemStack returns = cell.injectItems( AEApi.instance().storage().createItemStack( inv.getStackInSlot( 0 ) ), Actionable.SIMULATE );
+			return returns == null || returns.getStackSize() != itemstack.stackSize;
+		}
+		catch (AENoHandler t)
+		{
+		}
+
+		return false;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		if ( side == getForward().ordinal() )
+			return front;
+		return sides;
+	}
+
+	@Override
+	public List<IMEInventoryHandler> getCellArray(StorageChannel channel)
+	{
+		try
+		{
+			return Arrays.asList( new IMEInventoryHandler[] { getHandler( channel ) } );
+		}
+		catch (AENoHandler e)
+		{
+			return new ArrayList();
+		}
+	}
+
+	@Override
+	public int getPriority()
+	{
+		return priority;
+	}
+
+	@Override
+	public int getCellCount()
+	{
+		return 1;
+	}
+
+	@Override
+	public void blinkCell(int slot)
+	{
+		long now = worldObj.getTotalWorldTime();
+		if ( now - lastStateChange > 8 )
+			state = 0;
+		lastStateChange = now;
+
+		state |= 1 << (slot * 3 + 2);
+	}
+
+	@Override
+	public boolean isCellBlinking(int slot)
+	{
+		long now = worldObj.getTotalWorldTime();
+		if ( now - lastStateChange > 8 )
+			return false;
+
+		return ((state >> (slot * 3 + 2)) & 0x01) == 0x01;
+	}
+
+	@Override
+	public int getCellStatus(int slot)
+	{
+		if ( Platform.isClient() )
+			return (state >> (slot * 3)) & 3;
+
+		ItemStack cell = inv.getStackInSlot( 1 );
+		ICellHandler ch = AEApi.instance().registries().cell().getHander( cell );
+
+		if ( ch != null )
+		{
+			try
+			{
+				IMEInventoryHandler handler = getHandler( StorageChannel.ITEMS );
+				if ( ch != null )
+					return ch.getStatusForCell( cell, handler );
+			}
+			catch (AENoHandler e)
+			{
+			}
+
+			try
+			{
+				IMEInventoryHandler handler = getHandler( StorageChannel.FLUIDS );
+				if ( ch != null )
+					return ch.getStatusForCell( cell, handler );
+			}
+			catch (AENoHandler e)
+			{
+			}
+		}
+
+		return 0;
+	}
+
+	@Override
+	public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
+	{
+		double req = resource.amount / 500.0;
+		double available = extractAEPower( req, Actionable.SIMULATE, PowerMultiplier.CONFIG );
+		if ( available >= req - 0.01 )
+		{
+			try
+			{
+				IMEInventoryHandler h = getHandler( StorageChannel.FLUIDS );
+
+				extractAEPower( req, Actionable.MODULATE, PowerMultiplier.CONFIG );
+				IAEStack results = h.injectItems( AEFluidStack.create( resource ), doFill ? Actionable.MODULATE : Actionable.SIMULATE );
+
+				if ( results == null )
+					return resource.amount;
+
+				return resource.amount - (int) results.getStackSize();
+			}
+			catch (AENoHandler e)
+			{
+			}
+		}
+		return 0;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
+	{
+		return null;
+	}
+
+	@Override
+	public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+	{
+		return null;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid)
+	{
+		try
+		{
+			IMEInventoryHandler h = getHandler( StorageChannel.FLUIDS );
+			return h.canAccept( AEFluidStack.create( new FluidStack( fluid, 1 ) ) );
+		}
+		catch (AENoHandler e)
+		{
+		}
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid)
+	{
+		return false;
+	}
+
+	@Override
+	public FluidTankInfo[] getTankInfo(ForgeDirection from)
+	{
+		try
+		{
+			IMEInventoryHandler h = getHandler( StorageChannel.FLUIDS );
+			if ( h.getChannel() == StorageChannel.FLUIDS )
+				return new FluidTankInfo[] { new FluidTankInfo( null ) }; // eh?
+		}
+		catch (AENoHandler e)
+		{
+		}
+
+		return null;
+	}
+
+	@Override
+	protected double extractAEPower(double amt, Actionable mode)
+	{
+		double stash = 0.0;
+
+		IEnergyGrid eg;
+		try
+		{
+			eg = gridProxy.getEnergy();
+			stash = eg.extractAEPower( amt, mode, PowerMultiplier.ONE );
+			if ( stash >= amt )
+				return stash;
+		}
+		catch (GridAccessException e)
+		{
+			// no grid :(
+		}
+
+		// local battery!
+		return super.extractAEPower( amt - stash, mode ) + stash;
+	}
+
+	@Override
+	public boolean isPowered()
+	{
+		if ( Platform.isClient() )
+			return (state & 0x40) == 0x40;
+
+		boolean gridPowered = getAECurrentPower() > 64;
+
+		if ( !gridPowered )
+		{
+			try
+			{
+				gridPowered = gridProxy.getEnergy().isNetworkPowered();
+			}
+			catch (GridAccessException e)
+			{
+			}
+		}
+
+		return super.getAECurrentPower() > 1 || gridPowered;
+	}
+
+	public ItemStack getStorageType()
+	{
+		if ( isPowered() )
+			return storageType;
+		return null;
+	}
+
+}

tile/storage/TileDrive.java

@@ -0,0 +1,303 @@
+package appeng.tile.storage;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.implementations.IChestOrDrive;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.events.MENetworkCellArrayUpdate;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.ICellHandler;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.GridAccessException;
+import appeng.me.storage.MEInventoryHandler;
+import appeng.tile.events.AETileEventHandler;
+import appeng.tile.events.TileEventType;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+
+public class TileDrive extends AENetworkInvTile implements IChestOrDrive
+{
+
+	final int sides[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 10 );
+
+	boolean isCached = false;
+	ICellHandler handlersBySlot[] = new ICellHandler[10];
+	IMEInventoryHandler invBySlot[] = new IMEInventoryHandler[10];
+	List<MEInventoryHandler> items = new LinkedList();
+	List<MEInventoryHandler> fluids = new LinkedList();
+
+	long lastStateChange = 0;
+	int state = 0;
+	int priority = 0;
+
+	private void recalculateDisplay()
+	{
+		int oldState = 0;
+
+		if ( gridProxy.isActive() )
+			state |= 0x80000000;
+		else
+			state &= ~0x80000000;
+
+		for (int x = 0; x < getCellCount(); x++)
+			state |= (getCellStatus( x ) << (3 * x));
+
+		if ( oldState != state )
+			markForUpdate();
+	}
+
+	private class invManger extends AETileEventHandler
+	{
+
+		public invManger() {
+			super( EnumSet.of( TileEventType.WORLD_NBT, TileEventType.NETWORK ) );
+		}
+
+		@Override
+		public void writeToStream(DataOutputStream data) throws IOException
+		{
+			if ( worldObj.getTotalWorldTime() - lastStateChange > 8 )
+				state = 0;
+			else
+				state &= 0x24924924; // just keep the blinks...
+
+			if ( gridProxy.isActive() )
+				state |= 0x80000000;
+			else
+				state &= ~0x80000000;
+
+			for (int x = 0; x < getCellCount(); x++)
+				state |= (getCellStatus( x ) << (3 * x));
+
+			data.writeInt( state );
+		}
+
+		@Override
+		public boolean readFromStream(DataInputStream data) throws IOException
+		{
+			int oldState = state;
+			state = data.readInt();
+			lastStateChange = worldObj.getTotalWorldTime();
+			return (state & 0xDB6DB6DB) != (oldState & 0xDB6DB6DB);
+		}
+
+		@Override
+		public void readFromNBT(NBTTagCompound data)
+		{
+			priority = data.getInteger( "priority" );
+		}
+
+		@Override
+		public void writeToNBT(NBTTagCompound data)
+		{
+			data.setInteger( "priority", priority );
+		}
+
+	};
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		recalculateDisplay();
+	}
+
+	@MENetworkEventSubscribe
+	public void channelRender(MENetworkChannelsChanged c)
+	{
+		recalculateDisplay();
+	}
+
+	public TileDrive() {
+		gridProxy.setFlags( GridFlags.REQURE_CHANNEL );
+		addNewHandler( new invManger() );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		isCached = false; // recalculate the storage cell.
+		updateState();
+
+		try
+		{
+			IStorageGrid gs = gridProxy.getStorage();
+			Platform.postChanges( gs, removed, added );
+
+			gridProxy.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+		}
+		catch (GridAccessException e)
+		{
+		}
+
+		markForUpdate();
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+	public void updateState()
+	{
+		if ( !isCached )
+		{
+			items = new LinkedList();
+			fluids = new LinkedList();
+
+			for (int x = 0; x < inv.getSizeInventory(); x++)
+			{
+				ItemStack is = inv.getStackInSlot( x );
+				invBySlot[x] = null;
+				handlersBySlot[x] = null;
+
+				if ( is != null )
+				{
+					handlersBySlot[x] = AEApi.instance().registries().cell().getHander( is );
+
+					if ( handlersBySlot[x] != null )
+					{
+						IMEInventoryHandler cell = handlersBySlot[x].getCellInventory( is, StorageChannel.ITEMS );
+
+						if ( cell != null )
+						{
+							MEInventoryHandler ih = new MEInventoryHandler( cell );
+							ih.myPriority = priority;
+							invBySlot[x] = ih;
+							items.add( ih );
+						}
+						else
+						{
+							cell = handlersBySlot[x].getCellInventory( is, StorageChannel.FLUIDS );
+
+							if ( cell != null )
+							{
+								MEInventoryHandler ih = new MEInventoryHandler( cell );
+								ih.myPriority = priority;
+								invBySlot[x] = ih;
+								fluids.add( ih );
+							}
+						}
+					}
+				}
+			}
+
+			isCached = true;
+		}
+	}
+
+	@Override
+	public List<IMEInventoryHandler> getCellArray(StorageChannel channel)
+	{
+		updateState();
+		return (List) (channel == StorageChannel.ITEMS ? items : fluids);
+	}
+
+	@Override
+	public int getPriority()
+	{
+		return priority;
+	}
+
+	@Override
+	public int getCellCount()
+	{
+		return 10;
+	}
+
+	@Override
+	public void blinkCell(int slot)
+	{
+		long now = worldObj.getTotalWorldTime();
+		if ( now - lastStateChange > 8 )
+			state = 0;
+		lastStateChange = now;
+
+		state |= 1 << (slot * 3 + 2);
+	}
+
+	@Override
+	public boolean isCellBlinking(int slot)
+	{
+		long now = worldObj.getTotalWorldTime();
+		if ( now - lastStateChange > 8 )
+			return false;
+
+		return ((state >> (slot * 3 + 2)) & 0x01) == 0x01;
+	}
+
+	@Override
+	public int getCellStatus(int slot)
+	{
+		if ( Platform.isClient() )
+			return (state >> (slot * 3)) & 3;
+
+		ItemStack cell = inv.getStackInSlot( 2 );
+		ICellHandler ch = handlersBySlot[slot];
+
+		IMEInventoryHandler handler = invBySlot[slot];
+		if ( handler == null )
+			return 0;
+
+		if ( handler.getChannel() == StorageChannel.ITEMS )
+		{
+			if ( ch != null )
+				return ch.getStatusForCell( cell, handler );
+		}
+
+		if ( handler.getChannel() == StorageChannel.FLUIDS )
+		{
+			if ( ch != null )
+				return ch.getStatusForCell( cell, handler );
+		}
+
+		return 0;
+	}
+
+	@Override
+	public boolean isPowered()
+	{
+		if ( Platform.isClient() )
+			return (state & 0x80000000) == 0x80000000;
+
+		return gridProxy.isActive();
+	}
+
+}

tile/storage/TileIOPort.java

@@ -0,0 +1,48 @@
+package appeng.tile.storage;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.ForgeDirection;
+import appeng.api.util.AECableType;
+import appeng.api.util.DimensionalCoord;
+import appeng.tile.grid.AENetworkInvTile;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.InvOperation;
+
+public class TileIOPort extends AENetworkInvTile
+{
+
+	final int sides[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+	AppEngInternalInventory inv = new AppEngInternalInventory( this, 12 );
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public DimensionalCoord getLocation()
+	{
+		return new DimensionalCoord( this );
+	}
+
+	@Override
+	public IInventory getInternalInventory()
+	{
+		return inv;
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
+	{
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side)
+	{
+		return sides;
+	}
+
+}