Relocate Source to proper directory.

src/main/java/appeng/parts/automation/NonNullArrayIterator.java

@@ -0,0 +1,38 @@
+package appeng.parts.automation;
+
+import java.util.Iterator;
+
+import scala.NotImplementedError;
+
+public class NonNullArrayIterator<E> implements Iterator<E>
+{
+
+	int offset = 0;
+	final E[] g;
+
+	public NonNullArrayIterator(E[] o) {
+		g = o;
+	}
+
+	@Override
+	public boolean hasNext()
+	{
+		while (offset < g.length && g[offset] == null)
+			offset++;
+
+		return offset != g.length;
+	}
+
+	@Override
+	public E next()
+	{
+		return g[offset++];
+	}
+
+	@Override
+	public void remove()
+	{
+		throw new NotImplementedError();
+	}
+
+}

src/main/java/appeng/parts/automation/PartAnnihilationPlane.java

@@ -0,0 +1,458 @@
+package appeng.parts.automation;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.WorldServer;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.AELog;
+import appeng.core.settings.TickRates;
+import appeng.core.sync.packets.PacketTransitionEffect;
+import appeng.hooks.TickHandler;
+import appeng.me.GridAccessException;
+import appeng.parts.PartBasicState;
+import appeng.server.ServerHelper;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PartAnnihilationPlane extends PartBasicState implements IGridTickable, Callable
+{
+
+	public PartAnnihilationPlane(ItemStack is) {
+		super( PartAnnihilationPlane.class, is );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInventory(IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		rh.setTexture( CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), is.getIconIndex(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartPlaneSides.getIcon() );
+
+		rh.setBounds( 1, 1, 15, 15, 15, 16 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderInventoryBox( renderer );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		int minX = 1;
+		int minY = 1;
+		int maxX = 15;
+		int maxY = 15;
+
+		ForgeDirection e = rh.getWorldX();
+		ForgeDirection u = rh.getWorldY();
+
+		TileEntity te = getHost().getTile();
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - e.offsetX, y - e.offsetY, z - e.offsetZ ), side ) )
+			minX = 0;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + e.offsetX, y + e.offsetY, z + e.offsetZ ), side ) )
+			maxX = 16;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - u.offsetX, y - u.offsetY, z - u.offsetZ ), side ) )
+			minY = 0;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + u.offsetX, y + u.offsetY, z + u.offsetZ ), side ) )
+			maxY = 16;
+
+		boolean isActive = (clientFlags & (POWERED_FLAG | CHANNEL_FLAG)) == (POWERED_FLAG | CHANNEL_FLAG);
+
+		renderCache = rh.useSimplifiedRendering( x, y, z, this, renderCache );
+		rh.setTexture( CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), isActive ? CableBusTextures.BlockAnnihilationPlaneOn.getIcon() : is.getIconIndex(),
+				CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon() );
+
+		rh.setBounds( minX, minY, 15, maxX, maxY, 16 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setTexture( CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), isActive ? CableBusTextures.BlockAnnihilationPlaneOn.getIcon() : is.getIconIndex(),
+				CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon() );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderBlock( x, y, z, renderer );
+
+		renderLights( x, y, z, rh, renderer );
+	}
+
+	private boolean isTransitionPlane(TileEntity blockTileEntity, ForgeDirection side)
+	{
+		if ( blockTileEntity instanceof IPartHost )
+		{
+			IPart p = ((IPartHost) blockTileEntity).getPart( side );
+			return p instanceof PartAnnihilationPlane;
+		}
+		return false;
+	}
+
+	@Override
+	public void getBoxes(IPartCollisionHelper bch)
+	{
+		int minX = 1;
+		int minY = 1;
+		int maxX = 15;
+		int maxY = 15;
+
+		IPartHost host = getHost();
+		if ( host != null )
+		{
+			TileEntity te = host.getTile();
+
+			int x = te.xCoord;
+			int y = te.yCoord;
+			int z = te.zCoord;
+
+			ForgeDirection e = bch.getWorldX();
+			ForgeDirection u = bch.getWorldY();
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - e.offsetX, y - e.offsetY, z - e.offsetZ ), side ) )
+				minX = 0;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + e.offsetX, y + e.offsetY, z + e.offsetZ ), side ) )
+				maxX = 16;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - u.offsetX, y - u.offsetY, z - u.offsetZ ), side ) )
+				minY = 0;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + u.offsetX, y + u.offsetY, z + u.offsetZ ), side ) )
+				maxY = 16;
+		}
+
+		bch.addBox( 5, 5, 14, 11, 11, 15 );
+		bch.addBox( minX, minY, 15, maxX, maxY, bch.isBBCollision() ? 15 : 16 );
+	}
+
+	@Override
+	public int cableConnectionRenderTo()
+	{
+		return 1;
+	}
+
+	boolean breaking = false;
+	LinkedList<IAEItemStack> Buffer = new LinkedList();
+	BaseActionSource mySrc = new MachineSource( this );
+
+	@Override
+	public void writeToNBT(NBTTagCompound data)
+	{
+		super.writeToNBT( data );
+
+		data.setInteger( "bufferSize", Buffer.size() );
+		for (int x = 0; x < Buffer.size(); x++)
+		{
+			NBTTagCompound pack = new NBTTagCompound();
+			Buffer.get( x ).writeToNBT( pack );
+			data.setTag( "buffer" + x, pack );
+		}
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound data)
+	{
+		super.readFromNBT( data );
+
+		int size = data.getInteger( "bufferSize" );
+		Buffer.clear();
+		for (int x = 0; x < size; x++)
+		{
+			NBTTagCompound pack = (NBTTagCompound) data.getTag( "buffer" + x );
+			IAEItemStack ais = AEItemStack.loadItemStackFromNBT( pack );
+			if ( ais != null )
+				Buffer.add( ais );
+		}
+	}
+
+	private boolean isAccepting()
+	{
+		return Buffer.isEmpty();
+	}
+
+	@Override
+	public void getDrops(List<ItemStack> drops, boolean wrenched)
+	{
+		for (IAEItemStack is : Buffer)
+			if ( is != null )
+				drops.add( is.getItemStack() );
+	}
+
+	@MENetworkEventSubscribe
+	public void chanRender(MENetworkChannelsChanged c)
+	{
+		onNeighborChanged();
+		getHost().markForUpdate();
+	}
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		onNeighborChanged();
+		getHost().markForUpdate();
+	}
+
+	public TickRateModulation EatBlock(boolean eatForReal)
+	{
+		if ( isAccepting() && proxy.isActive() )
+		{
+			try
+			{
+				TileEntity te = getTile();
+				WorldServer w = (WorldServer) te.getWorldObj();
+
+				int x = te.xCoord + side.offsetX;
+				int y = te.yCoord + side.offsetY;
+				int z = te.zCoord + side.offsetZ;
+
+				Block blk = w.getBlock( x, y, z );
+
+				IStorageGrid storage = (IStorageGrid) proxy.getStorage();
+				IEnergyGrid energy = (IEnergyGrid) proxy.getEnergy();
+
+				Material mat = blk.getMaterial();
+				boolean ignore = mat == Material.air || mat == Material.lava || mat == Material.water || mat.isLiquid() || blk == Blocks.bedrock
+						|| blk == Blocks.end_portal || blk == Blocks.end_portal_frame || blk == Blocks.command_block;
+
+				if ( !ignore )
+				{
+					if ( !w.isAirBlock( x, y, z ) && w.blockExists( x, y, z ) && blk != null && w.canMineBlock( Platform.getPlayer( w ), x, y, z ) )
+					{
+						float hardness = blk.getBlockHardness( w, x, y, z );
+						if ( hardness >= 0.0 )
+						{
+							ItemStack[] out = Platform.getBlockDrops( w, x, y, z );
+							float total = 1 + hardness;
+							for (ItemStack is : out)
+								total += is.stackSize;
+
+							boolean hasPower = energy.extractAEPower( total, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > total - 0.1;
+							if ( hasPower )
+							{
+								if ( eatForReal )
+								{
+									energy.extractAEPower( total, Actionable.MODULATE, PowerMultiplier.CONFIG );
+									w.setBlock( x, y, z, Platform.air, 0, 3 );
+
+									AxisAlignedBB box = AxisAlignedBB.getBoundingBox( x - 0.2, y - 0.2, z - 0.2, x + 1.2, y + 1.2, z + 1.2 );
+									for (Object ei : w.getEntitiesWithinAABB( EntityItem.class, box ))
+									{
+										if ( ei instanceof EntityItem )
+										{
+											EntityItem item = (EntityItem) ei;
+											if ( !item.isDead )
+											{
+												IAEItemStack storedItem = AEItemStack.create( item.getEntityItem() );
+												storedItem = Platform.poweredInsert( energy, storage.getItemInventory(), storedItem, mySrc );
+												if ( storedItem != null )
+													Buffer.add( storedItem );
+
+												item.setDead();
+											}
+										}
+									}
+
+									try
+									{
+										ServerHelper.proxy.sendToAllNearExcept( null, x, y, z, 64, w, new PacketTransitionEffect( x, y, z, side, true ) );
+									}
+									catch (IOException e)
+									{
+										AELog.error( e );
+									}
+
+									for (ItemStack snaggedItem : out)
+									{
+										IAEItemStack storedItem = AEItemStack.create( snaggedItem );
+										storedItem = Platform.poweredInsert( energy, storage.getItemInventory(), storedItem, mySrc );
+										if ( storedItem != null )
+											Buffer.add( storedItem );
+									}
+
+									return TickRateModulation.URGENT;
+								}
+								else
+								{
+									breaking = true;
+									TickHandler.instance.addCallable( this.tile.getWorldObj(), this );
+									return TickRateModulation.URGENT;
+								}
+							}
+						}
+					}
+				}
+			}
+			catch (GridAccessException e1)
+			{
+				// :P
+			}
+		}
+
+		// nothing to do here :)
+		return TickRateModulation.SLEEP;
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		return new TickingRequest( TickRates.AnnihilationPlane.min, TickRates.AnnihilationPlane.max, false, true );
+	}
+
+	@Override
+	public void onNeighborChanged()
+	{
+		try
+		{
+			proxy.getTick().alertDevice( proxy.getNode() );
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
+	}
+
+	@Override
+	public void onEntityCollision(Entity entity)
+	{
+		if ( entity instanceof EntityItem && !entity.isDead && isAccepting() )
+		{
+			boolean capture = false;
+
+			switch (side)
+			{
+			case DOWN:
+			case UP:
+				if ( entity.posX > tile.xCoord && entity.posX < tile.xCoord + 1 )
+					if ( entity.posZ > tile.zCoord && entity.posZ < tile.zCoord + 1 )
+						if ( (entity.posY > tile.yCoord + 0.9 && side == ForgeDirection.UP) || (entity.posY < tile.yCoord + 0.1 && side == ForgeDirection.DOWN) )
+							capture = true;
+				break;
+			case SOUTH:
+			case NORTH:
+				if ( entity.posX > tile.xCoord && entity.posX < tile.xCoord + 1 )
+					if ( entity.posY > tile.yCoord && entity.posY < tile.yCoord + 1 )
+						if ( (entity.posZ > tile.zCoord + 0.9 && side == ForgeDirection.SOUTH)
+								|| (entity.posZ < tile.zCoord + 0.1 && side == ForgeDirection.NORTH) )
+							capture = true;
+				break;
+			case EAST:
+			case WEST:
+				if ( entity.posZ > tile.zCoord && entity.posZ < tile.zCoord + 1 )
+					if ( entity.posY > tile.yCoord && entity.posY < tile.yCoord + 1 )
+						if ( (entity.posX > tile.xCoord + 0.9 && side == ForgeDirection.EAST)
+								|| (entity.posX < tile.xCoord + 0.1 && side == ForgeDirection.WEST) )
+							capture = true;
+				break;
+			default:
+				// umm?
+				break;
+			}
+
+			if ( capture && Platform.isServer() && proxy.isActive() )
+			{
+				IAEItemStack stack = AEItemStack.create( ((EntityItem) entity).getEntityItem() );
+				if ( stack != null )
+				{
+					try
+					{
+						ServerHelper.proxy.sendToAllNearExcept( null, tile.xCoord, tile.yCoord, tile.zCoord, 64, tile.getWorldObj(),
+								new PacketTransitionEffect( entity.posX, entity.posY, entity.posZ, side, false ) );
+					}
+					catch (IOException e)
+					{
+						AELog.error( e );
+					}
+
+					Buffer.add( stack );
+					storeBuffer();
+					entity.setDead();
+				}
+			}
+		}
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		if ( breaking )
+			return TickRateModulation.URGENT;
+
+		if ( isAccepting() )
+			return EatBlock( false );
+		else
+		{
+			storeBuffer();
+			return TickRateModulation.IDLE;
+		}
+	}
+
+	private void storeBuffer()
+	{
+		try
+		{
+			IStorageGrid storage = (IStorageGrid) proxy.getStorage();
+			IEnergyGrid energy = (IEnergyGrid) proxy.getEnergy();
+
+			while (!Buffer.isEmpty())
+			{
+				IAEItemStack storedItem = Buffer.pop();
+				storedItem = Platform.poweredInsert( energy, storage.getItemInventory(), storedItem, mySrc );
+				if ( storedItem != null )
+				{
+					Buffer.add( storedItem );
+					break;
+				}
+			}
+		}
+		catch (GridAccessException e1)
+		{
+			// :P
+		}
+	}
+
+	@Override
+	public Object call() throws Exception
+	{
+		breaking = false;
+		return EatBlock( true );
+	}
+
+}

src/main/java/appeng/parts/automation/PartExportBus.java

@@ -0,0 +1,335 @@
+package appeng.parts.automation;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.Vec3;
+import appeng.api.config.Actionable;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Settings;
+import appeng.api.config.Upgrades;
+import appeng.api.config.YesNo;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.crafting.ICraftingGrid;
+import appeng.api.networking.crafting.ICraftingLink;
+import appeng.api.networking.crafting.ICraftingRequester;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.AELog;
+import appeng.core.settings.TickRates;
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.MultiCraftingTracker;
+import appeng.me.GridAccessException;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PartExportBus extends PartSharedItemBus implements IGridTickable, ICraftingRequester
+{
+
+	final MultiCraftingTracker cratingTracker = new MultiCraftingTracker( this, 9 );
+	final BaseActionSource mySrc;
+
+	public PartExportBus(ItemStack is) {
+		super( PartExportBus.class, is );
+		settings.registerSetting( Settings.REDSTONE_CONTROLLED, RedstoneMode.IGNORE );
+		settings.registerSetting( Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL );
+		settings.registerSetting( Settings.CRAFT_ONLY, YesNo.NO );
+		mySrc = new MachineSource( this );
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound extra)
+	{
+		super.readFromNBT( extra );
+		cratingTracker.readFromNBT( extra );
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound extra)
+	{
+		super.writeToNBT( extra );
+		cratingTracker.writeToNBT( extra );
+	}
+
+	@Override
+	public boolean onPartActivate(EntityPlayer player, Vec3 pos)
+	{
+		if ( !player.isSneaking() )
+		{
+			if ( Platform.isClient() )
+				return true;
+
+			Platform.openGUI( player, getHost().getTile(), side, GuiBridge.GUI_BUS );
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInventory(IPartRenderHelper rh, RenderBlocks renderer)
+	{
+
+		rh.setTexture( CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartMonitorBack.getIcon(),
+				is.getIconIndex(), CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartExportSides.getIcon() );
+
+		rh.setBounds( 4, 4, 12, 12, 12, 14 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 6, 6, 15, 10, 10, 16 );
+		rh.renderInventoryBox( renderer );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		renderCache = rh.useSimplifiedRendering( x, y, z, this, renderCache );
+		rh.setTexture( CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartMonitorBack.getIcon(),
+				is.getIconIndex(), CableBusTextures.PartExportSides.getIcon(), CableBusTextures.PartExportSides.getIcon() );
+
+		rh.setBounds( 4, 4, 12, 12, 12, 14 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setBounds( 6, 6, 15, 10, 10, 16 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setTexture( CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartMonitorBack.getIcon(), is.getIconIndex(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartMonitorSidesStatus.getIcon() );
+
+		rh.setBounds( 6, 6, 11, 10, 10, 12 );
+		rh.renderBlock( x, y, z, renderer );
+
+		renderLights( x, y, z, rh, renderer );
+	}
+
+	@Override
+	public int cableConnectionRenderTo()
+	{
+		return 5;
+	}
+
+	@Override
+	public void getBoxes(IPartCollisionHelper bch)
+	{
+		bch.addBox( 4, 4, 12, 12, 12, 14 );
+		bch.addBox( 5, 5, 14, 11, 11, 15 );
+		bch.addBox( 6, 6, 15, 10, 10, 16 );
+		bch.addBox( 6, 6, 11, 10, 10, 12 );
+	}
+
+	long itemToSend = 1;
+	boolean didSomething = false;
+
+	@Override
+	TickRateModulation doBusWork()
+	{
+		if ( !proxy.isActive() )
+			return TickRateModulation.IDLE;
+
+		itemToSend = 1;
+		didSomething = false;
+
+		switch (getInstalledUpgrades( Upgrades.SPEED ))
+		{
+		default:
+		case 0:
+			itemToSend = 1;
+			break;
+		case 1:
+			itemToSend = 8;
+			break;
+		case 2:
+			itemToSend = 32;
+			break;
+		case 3:
+			itemToSend = 64;
+			break;
+		case 4:
+			itemToSend = 96;
+			break;
+		}
+
+		try
+		{
+			InventoryAdaptor d = getHandler();
+			IMEMonitor<IAEItemStack> inv = proxy.getStorage().getItemInventory();
+			IEnergyGrid energy = proxy.getEnergy();
+			ICraftingGrid cg = proxy.getCrafting();
+			FuzzyMode fzMode = (FuzzyMode) getConfigManager().getSetting( Settings.FUZZY_MODE );
+
+			if ( d != null )
+			{
+				for (int x = 0; x < availableSlots() && itemToSend > 0; x++)
+				{
+					IAEItemStack ais = config.getAEStackInSlot( x );
+					if ( ais == null || itemToSend <= 0 || craftOnly() )
+					{
+						if ( isCraftingEnabled() )
+							didSomething = cratingTracker.handleCrafting( x, itemToSend, ais, d, getTile().getWorldObj(), proxy.getGrid(), cg, mySrc )
+									|| didSomething;
+						continue;
+					}
+
+					long before = itemToSend;
+
+					if ( getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
+					{
+						for (IAEItemStack o : ImmutableList.copyOf( inv.getStorageList().findFuzzy( ais, fzMode ) ))
+						{
+							pushItemIntoTarget( d, energy, inv, o );
+							if ( itemToSend <= 0 )
+								break;
+						}
+					}
+					else
+						pushItemIntoTarget( d, energy, inv, ais );
+
+					if ( itemToSend == before && isCraftingEnabled() )
+						didSomething = cratingTracker.handleCrafting( x, itemToSend, ais, d, getTile().getWorldObj(), proxy.getGrid(), cg, mySrc )
+								|| didSomething;
+				}
+			}
+
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
+
+		return didSomething ? TickRateModulation.FASTER : TickRateModulation.SLOWER;
+	}
+
+	private boolean craftOnly()
+	{
+		return getConfigManager().getSetting( Settings.CRAFT_ONLY ) == YesNo.YES;
+	}
+
+	private boolean isCraftingEnabled()
+	{
+		return getInstalledUpgrades( Upgrades.CRAFTING ) > 0;
+	}
+
+	private void pushItemIntoTarget(InventoryAdaptor d, IEnergyGrid energy, IMEInventory<IAEItemStack> inv, IAEItemStack ais)
+	{
+		ItemStack is = ais.getItemStack();
+		is.stackSize = (int) itemToSend;
+
+		ItemStack o = d.simulateAdd( is );
+		long canFit = o == null ? itemToSend : itemToSend - o.stackSize;
+
+		if ( canFit > 0 )
+		{
+			ais = ais.copy();
+			ais.setStackSize( canFit );
+			IAEItemStack itemsToAdd = Platform.poweredExtraction( energy, inv, ais, mySrc );
+
+			if ( itemsToAdd != null )
+			{
+				itemToSend -= itemsToAdd.getStackSize();
+
+				ItemStack failed = d.addItems( itemsToAdd.getItemStack() );
+				if ( failed != null )
+				{
+					ais.setStackSize( failed.stackSize );
+					inv.injectItems( ais, Actionable.MODULATE, mySrc );
+				}
+				else
+					didSomething = true;
+			}
+
+		}
+	}
+
+	@Override
+	public IAEItemStack injectCraftedItems(ICraftingLink link, IAEItemStack items, Actionable mode)
+	{
+		InventoryAdaptor d = getHandler();
+
+		try
+		{
+			if ( d != null && proxy.isActive() )
+			{
+				IEnergyGrid energy = proxy.getEnergy();
+
+				double power = items.getStackSize();
+				if ( energy.extractAEPower( power, mode, PowerMultiplier.CONFIG ) > power - 0.01 )
+				{
+					if ( mode == Actionable.MODULATE )
+						return AEItemStack.create( d.addItems( items.getItemStack() ) );
+					return AEItemStack.create( d.simulateAdd( items.getItemStack() ) );
+				}
+			}
+		}
+		catch (GridAccessException e)
+		{
+			AELog.error( e );
+		}
+
+		return items;
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		return doBusWork();
+	}
+
+	public RedstoneMode getRSMode()
+	{
+		return (RedstoneMode) settings.getSetting( Settings.REDSTONE_CONTROLLED );
+	}
+
+	@Override
+	protected boolean isSleeping()
+	{
+		return getHandler() == null || super.isSleeping();
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		return new TickingRequest( TickRates.ExportBus.min, TickRates.ExportBus.max, isSleeping(), false );
+	}
+
+	@Override
+	public ImmutableSet<ICraftingLink> getRequestedJobs()
+	{
+		return cratingTracker.getRequestedJobs();
+	}
+
+	@Override
+	public void jobStateChange(ICraftingLink link)
+	{
+		cratingTracker.jobStateChange( link );
+	}
+
+}

src/main/java/appeng/parts/automation/PartFormationPlane.java

@@ -0,0 +1,514 @@
+package appeng.parts.automation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemFirework;
+import net.minecraft.item.ItemReed;
+import net.minecraft.item.ItemSkull;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldServer;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraftforge.common.IPlantable;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.IncludeExclude;
+import appeng.api.config.Settings;
+import appeng.api.config.Upgrades;
+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.security.BaseActionSource;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartHost;
+import appeng.api.parts.IPartItem;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.ICellContainer;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IItemList;
+import appeng.api.util.IConfigManager;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.AEConfig;
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.IPriorityHost;
+import appeng.me.GridAccessException;
+import appeng.me.storage.MEInventoryHandler;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import appeng.util.prioitylist.FuzzyPriorityList;
+import appeng.util.prioitylist.PrecisePriorityList;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PartFormationPlane extends PartUpgradeable implements ICellContainer, IPriorityHost, IMEInventory<IAEItemStack>
+{
+
+	int priority = 0;
+	boolean wasActive = false;
+	boolean blocked = false;
+	MEInventoryHandler myHandler = new MEInventoryHandler( this, StorageChannel.ITEMS );
+	AppEngInternalAEInventory Config = new AppEngInternalAEInventory( this, 63 );
+
+	public PartFormationPlane(ItemStack is) {
+		super( PartFormationPlane.class, is );
+		settings.registerSetting( Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL );
+		updateHandler();
+	}
+
+	@Override
+	public boolean onPartActivate(EntityPlayer player, Vec3 pos)
+	{
+		if ( !player.isSneaking() )
+		{
+			if ( Platform.isClient() )
+				return true;
+
+			Platform.openGUI( player, getHost().getTile(), side, GuiBridge.GUI_FPLANE );
+			return true;
+		}
+
+		return false;
+	}
+
+	protected int getUpgradeSlots()
+	{
+		return 5;
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "config" ) )
+			return Config;
+
+		return super.getInventoryByName( name );
+	}
+
+	@MENetworkEventSubscribe
+	public void powerRender(MENetworkPowerStatusChange c)
+	{
+		boolean currentActive = proxy.isActive();
+		if ( wasActive != currentActive )
+		{
+			wasActive = currentActive;
+			updateHandler();// proxy.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+			getHost().markForUpdate();
+		}
+	}
+
+	@MENetworkEventSubscribe
+	public void updateChannels(MENetworkChannelsChanged chann)
+	{
+		boolean currentActive = proxy.isActive();
+		if ( wasActive != currentActive )
+		{
+			wasActive = currentActive;
+			updateHandler();// proxy.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+			getHost().markForUpdate();
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInventory(IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		rh.setTexture( CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), is.getIconIndex(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartPlaneSides.getIcon() );
+
+		rh.setBounds( 1, 1, 15, 15, 15, 16 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderInventoryBox( renderer );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		int minX = 1;
+		int minY = 1;
+		int maxX = 15;
+		int maxY = 15;
+
+		ForgeDirection e = rh.getWorldX();
+		ForgeDirection u = rh.getWorldY();
+
+		TileEntity te = getHost().getTile();
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - e.offsetX, y - e.offsetY, z - e.offsetZ ), side ) )
+			minX = 0;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + e.offsetX, y + e.offsetY, z + e.offsetZ ), side ) )
+			maxX = 16;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - u.offsetX, y - u.offsetY, z - u.offsetZ ), side ) )
+			minY = 0;
+
+		if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + u.offsetX, y + u.offsetY, z + u.offsetZ ), side ) )
+			maxY = 16;
+
+		boolean isActive = (clientFlags & (POWERED_FLAG | CHANNEL_FLAG)) == (POWERED_FLAG | CHANNEL_FLAG);
+
+		renderCache = rh.useSimplifiedRendering( x, y, z, this, renderCache );
+		rh.setTexture( CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), isActive ? CableBusTextures.BlockFormPlaneOn.getIcon() : is.getIconIndex(),
+				CableBusTextures.PartPlaneSides.getIcon(), CableBusTextures.PartPlaneSides.getIcon() );
+
+		rh.setBounds( minX, minY, 15, maxX, maxY, 16 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setTexture( CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartTransitionPlaneBack.getIcon(), isActive ? CableBusTextures.BlockFormPlaneOn.getIcon() : is.getIconIndex(),
+				CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon() );
+
+		rh.setBounds( 5, 5, 14, 11, 11, 15 );
+		rh.renderBlock( x, y, z, renderer );
+
+		renderLights( x, y, z, rh, renderer );
+	}
+
+	private boolean isTransitionPlane(TileEntity blockTileEntity, ForgeDirection side)
+	{
+		if ( blockTileEntity instanceof IPartHost )
+		{
+			IPart p = ((IPartHost) blockTileEntity).getPart( side );
+			return p instanceof PartFormationPlane;
+		}
+		return false;
+	}
+
+	@Override
+	public void getBoxes(IPartCollisionHelper bch)
+	{
+		int minX = 1;
+		int minY = 1;
+		int maxX = 15;
+		int maxY = 15;
+
+		IPartHost host = getHost();
+		if ( host != null )
+		{
+			TileEntity te = host.getTile();
+
+			int x = te.xCoord;
+			int y = te.yCoord;
+			int z = te.zCoord;
+
+			ForgeDirection e = bch.getWorldX();
+			ForgeDirection u = bch.getWorldY();
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - e.offsetX, y - e.offsetY, z - e.offsetZ ), side ) )
+				minX = 0;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + e.offsetX, y + e.offsetY, z + e.offsetZ ), side ) )
+				maxX = 16;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x - u.offsetX, y - u.offsetY, z - u.offsetZ ), side ) )
+				minY = 0;
+
+			if ( isTransitionPlane( te.getWorldObj().getTileEntity( x + u.offsetX, y + u.offsetY, z + u.offsetZ ), side ) )
+				maxY = 16;
+		}
+
+		bch.addBox( 5, 5, 14, 11, 11, 15 );
+		bch.addBox( minX, minY, 15, maxX, maxY, 16 );
+	}
+
+	@Override
+	public int cableConnectionRenderTo()
+	{
+		return 1;
+	}
+
+	@Override
+	public List<IMEInventoryHandler> getCellArray(StorageChannel channel)
+	{
+		if ( proxy.isActive() && channel == StorageChannel.ITEMS )
+		{
+			List<IMEInventoryHandler> Handler = new ArrayList( 1 );
+			Handler.add( myHandler );
+			return Handler;
+		}
+		return new ArrayList();
+	}
+
+	@Override
+	public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
+	{
+		updateHandler();
+		host.markForSave();
+	}
+
+	@Override
+	public void setPriority(int newValue)
+	{
+		priority = newValue;
+		host.markForSave();
+		updateHandler();
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack)
+	{
+		super.onChangeInventory( inv, slot, mc, removedStack, newStack );
+
+		if ( inv == Config )
+			updateHandler();
+	}
+
+	public void upgradesChanged()
+	{
+		updateHandler();
+	}
+
+	private void updateHandler()
+	{
+		myHandler.myAccess = AccessRestriction.WRITE;
+		myHandler.myWhitelist = getInstalledUpgrades( Upgrades.INVERTER ) > 0 ? IncludeExclude.BLACKLIST : IncludeExclude.WHITELIST;
+		myHandler.myPriority = priority;
+
+		IItemList<IAEItemStack> priorityList = AEApi.instance().storage().createItemList();
+
+		int slotsToUse = 18 + getInstalledUpgrades( Upgrades.CAPACITY ) * 9;
+		for (int x = 0; x < Config.getSizeInventory() && x < slotsToUse; x++)
+		{
+			IAEItemStack is = Config.getAEStackInSlot( x );
+			if ( is != null )
+				priorityList.add( is );
+		}
+
+		if ( getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
+			myHandler.myPartitionList = new FuzzyPriorityList( priorityList, (FuzzyMode) this.getConfigManager().getSetting( Settings.FUZZY_MODE ) );
+		else
+			myHandler.myPartitionList = new PrecisePriorityList( priorityList );
+
+		try
+		{
+			proxy.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound data)
+	{
+		super.writeToNBT( data );
+		Config.writeToNBT( data, "config" );
+		data.setInteger( "priority", priority );
+	}
+
+	public void readFromNBT(NBTTagCompound data)
+	{
+		super.readFromNBT( data );
+		Config.readFromNBT( data, "config" );
+		priority = data.getInteger( "priority" );
+		updateHandler();
+	}
+
+	@Override
+	public IAEItemStack extractItems(IAEItemStack request, Actionable mode, BaseActionSource src)
+	{
+		return null;
+	}
+
+	@Override
+	public IItemList<IAEItemStack> getAvailableItems(IItemList<IAEItemStack> out)
+	{
+		return out;
+	}
+
+	@Override
+	public StorageChannel getChannel()
+	{
+		return StorageChannel.ITEMS;
+	}
+
+	@Override
+	public int getPriority()
+	{
+		return priority;
+	}
+
+	@Override
+	public void blinkCell(int slot)
+	{
+		// :P
+	}
+
+	@Override
+	public void onNeighborChanged()
+	{
+		TileEntity te = host.getTile();
+		World w = te.getWorldObj();
+		ForgeDirection side = this.side;
+
+		int x = te.xCoord + side.offsetX;
+		int y = te.yCoord + side.offsetY;
+		int z = te.zCoord + side.offsetZ;
+
+		blocked = !w.getBlock( x, y, z ).isReplaceable( w, x, y, z );
+	}
+
+	@Override
+	public IAEItemStack injectItems(IAEItemStack input, Actionable type, BaseActionSource src)
+	{
+		if ( blocked || input == null || input.getStackSize() <= 0 )
+			return input;
+
+		ItemStack is = input.getItemStack();
+		Item i = is.getItem();
+
+		long maxStorage = Math.min( input.getStackSize(), is.getMaxStackSize() );
+		boolean worked = false;
+
+		TileEntity te = host.getTile();
+		World w = te.getWorldObj();
+		ForgeDirection side = this.side;
+
+		int x = te.xCoord + side.offsetX;
+		int y = te.yCoord + side.offsetY;
+		int z = te.zCoord + side.offsetZ;
+
+		if ( w.getBlock( x, y, z ).isReplaceable( w, x, y, z ) )
+		{
+			if ( i instanceof ItemBlock || i instanceof IPlantable || i instanceof ItemSkull || i instanceof ItemFirework || i instanceof IPartItem
+					|| i instanceof ItemReed )
+			{
+				EntityPlayer player = Platform.getPlayer( (WorldServer) w );
+				Platform.configurePlayer( player, side, tile );
+
+				if ( i instanceof ItemFirework )
+				{
+					Chunk c = w.getChunkFromBlockCoords( x, z );
+					int sum = 0;
+					for (List Z : c.entityLists)
+						sum += Z.size();
+					if ( sum > 32 )
+						return input;
+				}
+				maxStorage = is.stackSize;
+				worked = true;
+				if ( type == Actionable.MODULATE )
+				{
+					if ( i instanceof IPlantable || i instanceof ItemSkull || i instanceof ItemReed )
+					{
+						boolean Worked = false;
+
+						if ( Worked == false && side.offsetX == 0 && side.offsetZ == 0 )
+							Worked = i.onItemUse( is, player, w, x + side.offsetX, y + side.offsetY, z + side.offsetZ, side.getOpposite().ordinal(),
+									side.offsetX, side.offsetY, side.offsetZ );
+
+						if ( Worked == false && side.offsetX == 0 && side.offsetZ == 0 )
+							Worked = i.onItemUse( is, player, w, x - side.offsetX, y - side.offsetY, z - side.offsetZ, side.ordinal(), side.offsetX,
+									side.offsetY, side.offsetZ );
+
+						if ( Worked == false && side.offsetY == 0 )
+							Worked = i.onItemUse( is, player, w, x, y - 1, z, ForgeDirection.UP.ordinal(), side.offsetX, side.offsetY, side.offsetZ );
+
+						if ( Worked == false )
+							Worked = i.onItemUse( is, player, w, x, y, z, side.getOpposite().ordinal(), side.offsetX, side.offsetY, side.offsetZ );
+
+						maxStorage = maxStorage - is.stackSize;
+					}
+					else
+					{
+						i.onItemUse( is, player, w, x, y, z, side.getOpposite().ordinal(), side.offsetX, side.offsetY, side.offsetZ );
+						maxStorage = maxStorage - is.stackSize;
+					}
+				}
+				else
+					maxStorage = 1;
+			}
+			else
+			{
+				worked = true;
+				Chunk c = w.getChunkFromBlockCoords( x, z );
+				int sum = 0;
+				for (List Z : c.entityLists)
+					sum += Z.size();
+
+				if ( sum < AEConfig.instance.formationPlaneEntityLimit )
+				{
+					if ( type == Actionable.MODULATE )
+					{
+
+						is.stackSize = (int) maxStorage;
+						EntityItem ei = new EntityItem( w, // w
+								((side.offsetX != 0 ? 0.0 : 0.7) * (Platform.getRandomFloat() - 0.5f)) + 0.5 + side.offsetX * -0.3 + (double) x, // spawn
+								((side.offsetY != 0 ? 0.0 : 0.7) * (Platform.getRandomFloat() - 0.5f)) + 0.5 + side.offsetY * -0.3 + (double) y, // spawn
+								((side.offsetZ != 0 ? 0.0 : 0.7) * (Platform.getRandomFloat() - 0.5f)) + 0.5 + side.offsetZ * -0.3 + (double) z, // spawn
+								is.copy() );
+
+						Entity result = ei;
+
+						ei.motionX = side.offsetX * 0.2;
+						ei.motionY = side.offsetY * 0.2;
+						ei.motionZ = side.offsetZ * 0.2;
+
+						if ( is.getItem().hasCustomEntity( is ) )
+						{
+							result = is.getItem().createEntity( w, ei, is );
+							if ( result != null )
+								ei.setDead();
+							else
+								result = ei;
+						}
+
+						if ( !w.spawnEntityInWorld( result ) )
+						{
+							result.setDead();
+							worked = false;
+						}
+
+					}
+				}
+				else
+					worked = false;
+			}
+		}
+
+		blocked = !w.getBlock( x, y, z ).isReplaceable( w, x, y, z );
+
+		if ( worked )
+		{
+			IAEItemStack out = input.copy();
+			out.decStackSize( maxStorage );
+			if ( out.getStackSize() == 0 )
+				return null;
+			return out;
+		}
+
+		return input;
+	}
+
+	@Override
+	public void saveChanges(IMEInventory cellInventory)
+	{
+		// nope!
+	}
+}

src/main/java/appeng/parts/automation/PartImportBus.java

@@ -0,0 +1,279 @@
+package appeng.parts.automation;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Vec3;
+import appeng.api.AEApi;
+import appeng.api.config.Actionable;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Settings;
+import appeng.api.config.Upgrades;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.energy.IEnergySource;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.settings.TickRates;
+import appeng.core.sync.GuiBridge;
+import appeng.me.GridAccessException;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+import appeng.util.inv.IInventoryDestination;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PartImportBus extends PartSharedItemBus implements IGridTickable, IInventoryDestination
+{
+
+	BaseActionSource mySrc;
+	IMEInventory<IAEItemStack> destination = null;
+	IAEItemStack lastItemChecked = null;
+
+	public PartImportBus(ItemStack is) {
+		super( PartImportBus.class, is );
+		settings.registerSetting( Settings.REDSTONE_CONTROLLED, RedstoneMode.IGNORE );
+		settings.registerSetting( Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL );
+		mySrc = new MachineSource( this );
+	}
+
+	@Override
+	public boolean onPartActivate(EntityPlayer player, Vec3 pos)
+	{
+		if ( !player.isSneaking() )
+		{
+			if ( Platform.isClient() )
+				return true;
+
+			Platform.openGUI( player, getHost().getTile(), side, GuiBridge.GUI_BUS );
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean canInsert(ItemStack stack)
+	{
+		if ( stack == null || stack.getItem() == null )
+			return false;
+		
+		IAEItemStack out = destination.injectItems( lastItemChecked = AEApi.instance().storage().createItemStack( stack ), Actionable.SIMULATE, mySrc );
+		if ( out == null )
+			return true;
+		return out.getStackSize() != stack.stackSize;
+	}
+
+	private IInventoryDestination configDest(IMEMonitor<IAEItemStack> itemInventory)
+	{
+		destination = itemInventory;
+		return this;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInventory(IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		rh.setTexture( CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartMonitorBack.getIcon(),
+				is.getIconIndex(), CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartImportSides.getIcon() );
+
+		rh.setBounds( 3, 3, 15, 13, 13, 16 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 4, 4, 14, 12, 12, 15 );
+		rh.renderInventoryBox( renderer );
+
+		rh.setBounds( 5, 5, 13, 11, 11, 14 );
+		rh.renderInventoryBox( renderer );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		renderCache = rh.useSimplifiedRendering( x, y, z, this, renderCache );
+		rh.setTexture( CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartMonitorBack.getIcon(),
+				is.getIconIndex(), CableBusTextures.PartImportSides.getIcon(), CableBusTextures.PartImportSides.getIcon() );
+
+		rh.setBounds( 4, 4, 14, 12, 12, 16 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setBounds( 5, 5, 13, 11, 11, 14 );
+		rh.renderBlock( x, y, z, renderer );
+
+		rh.setBounds( 6, 6, 12, 10, 10, 13 );
+		rh.renderBlock( x, y, z, renderer );
+		rh.setTexture( CableBusTextures.PartMonitorSidesStatus.getIcon(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartMonitorBack.getIcon(), is.getIconIndex(), CableBusTextures.PartMonitorSidesStatus.getIcon(),
+				CableBusTextures.PartMonitorSidesStatus.getIcon() );
+
+		rh.setBounds( 6, 6, 11, 10, 10, 12 );
+		rh.renderBlock( x, y, z, renderer );
+
+		renderLights( x, y, z, rh, renderer );
+	}
+
+	@Override
+	public void getBoxes(IPartCollisionHelper bch)
+	{
+		bch.addBox( 6, 6, 11, 10, 10, 13 );
+		bch.addBox( 5, 5, 13, 11, 11, 14 );
+		bch.addBox( 4, 4, 14, 12, 12, 16 );
+	}
+
+	@Override
+	public int cableConnectionRenderTo()
+	{
+		return 5;
+	}
+
+	@Override
+	public TickingRequest getTickingRequest(IGridNode node)
+	{
+		return new TickingRequest( TickRates.ImportBus.min, TickRates.ImportBus.max, getHandler() == null, false );
+	}
+
+	private int itemToSend; // used in tickingRequest
+	private boolean worked; // used in tickingRequest
+
+	TickRateModulation doBusWork()
+	{
+		if ( !proxy.isActive() )
+			return TickRateModulation.IDLE;
+
+		worked = false;
+
+		InventoryAdaptor myAdaptor = getHandler();
+		FuzzyMode fzMode = (FuzzyMode) getConfigManager().getSetting( Settings.FUZZY_MODE );
+
+		if ( myAdaptor != null )
+		{
+			try
+			{
+				switch (getInstalledUpgrades( Upgrades.SPEED ))
+				{
+				default:
+				case 0:
+					itemToSend = 1;
+					break;
+				case 1:
+					itemToSend = 8;
+					break;
+				case 2:
+					itemToSend = 32;
+					break;
+				case 3:
+					itemToSend = 64;
+					break;
+				case 4:
+					itemToSend = 96;
+					break;
+				}
+
+				itemToSend = Math.min( itemToSend, (int) (0.01 + proxy.getEnergy().extractAEPower( itemToSend, Actionable.SIMULATE, PowerMultiplier.CONFIG )) );
+				IMEMonitor<IAEItemStack> inv = proxy.getStorage().getItemInventory();
+				IEnergyGrid energy = proxy.getEnergy();
+
+				boolean Configured = false;
+				for (int x = 0; x < availableSlots(); x++)
+				{
+					IAEItemStack ais = config.getAEStackInSlot( x );
+					if ( ais != null && itemToSend > 0 )
+					{
+						Configured = true;
+						while (itemToSend > 0)
+						{
+							if ( importStuff( myAdaptor, ais, inv, energy, fzMode ) )
+								break;
+						}
+					}
+				}
+
+				if ( !Configured )
+				{
+					while (itemToSend > 0)
+					{
+						if ( importStuff( myAdaptor, null, inv, energy, fzMode ) )
+							break;
+					}
+				}
+			}
+			catch (GridAccessException e)
+			{
+				// :3
+			}
+		}
+		else
+			return TickRateModulation.SLEEP;
+
+		return worked ? TickRateModulation.FASTER : TickRateModulation.SLOWER;
+	}
+
+	@Override
+	public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
+	{
+		return doBusWork();
+	}
+
+	private boolean importStuff(InventoryAdaptor myAdaptor, IAEItemStack whatToImport, IMEMonitor<IAEItemStack> inv, IEnergySource energy, FuzzyMode fzMode)
+	{
+		int toSend = this.itemToSend;
+
+		if ( toSend > 64 )
+			toSend = 64;
+
+		ItemStack newItems;
+		if ( getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
+			newItems = myAdaptor.removeSimilarItems( toSend, whatToImport == null ? null : whatToImport.getItemStack(), fzMode, configDest( inv ) );
+		else
+			newItems = myAdaptor.removeItems( toSend, whatToImport == null ? null : whatToImport.getItemStack(), configDest( inv ) );
+
+		if ( newItems != null )
+		{
+			newItems.stackSize = (int) (Math.min( newItems.stackSize, energy.extractAEPower( newItems.stackSize, Actionable.SIMULATE, PowerMultiplier.CONFIG ) ) + 0.01);
+			itemToSend -= newItems.stackSize;
+
+			if ( lastItemChecked == null || !lastItemChecked.isSameType( newItems ) )
+				lastItemChecked = AEApi.instance().storage().createItemStack( newItems );
+			else
+				lastItemChecked.setStackSize( newItems.stackSize );
+
+			IAEItemStack failed = Platform.poweredInsert( energy, destination, lastItemChecked, mySrc );
+			// destination.injectItems( lastItemChecked, Actionable.MODULATE );
+			if ( failed != null )
+			{
+				myAdaptor.addItems( failed.getItemStack() );
+				return true;
+			}
+			else
+				worked = true;
+		}
+		else
+			return true;
+
+		return false;
+	}
+
+	public RedstoneMode getRSMode()
+	{
+		return (RedstoneMode) settings.getSetting( Settings.REDSTONE_CONTROLLED );
+	}
+
+	@Override
+	protected boolean isSleeping()
+	{
+		return getHandler() == null || super.isSleeping();
+	}
+
+}

src/main/java/appeng/parts/automation/PartLevelEmitter.java

@@ -0,0 +1,687 @@
+package appeng.parts.automation;
+
+import java.util.Collection;
+import java.util.Random;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.LevelType;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Settings;
+import appeng.api.config.Upgrades;
+import appeng.api.config.YesNo;
+import appeng.api.networking.crafting.ICraftingGrid;
+import appeng.api.networking.crafting.ICraftingPatternDetails;
+import appeng.api.networking.crafting.ICraftingProvider;
+import appeng.api.networking.crafting.ICraftingProviderHelper;
+import appeng.api.networking.crafting.ICraftingWatcher;
+import appeng.api.networking.crafting.ICraftingWatcherHost;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.energy.IEnergyWatcher;
+import appeng.api.networking.energy.IEnergyWatcherHost;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkCraftingPatternChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.storage.IBaseMonitor;
+import appeng.api.networking.storage.IStackWatcher;
+import appeng.api.networking.storage.IStackWatcherHost;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.IMEMonitorHandlerReceiver;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
+import appeng.api.util.AECableType;
+import appeng.api.util.IConfigManager;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.sync.GuiBridge;
+import appeng.me.GridAccessException;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class PartLevelEmitter extends PartUpgradeable implements IEnergyWatcherHost, IStackWatcherHost, ICraftingWatcherHost,
+		IMEMonitorHandlerReceiver<IAEItemStack>, ICraftingProvider
+{
+
+	final int FLAG_ON = 4;
+
+	AppEngInternalAEInventory config = new AppEngInternalAEInventory( this, 1 );
+
+	boolean prevState = false;
+
+	long lastReportedValue = 0;
+	long reportingValue = 0;
+
+	IStackWatcher myWatcher;
+	IEnergyWatcher myEnergyWatcher;
+	ICraftingWatcher myCraftingWatcher;
+
+	public long getReportingValue()
+	{
+		return reportingValue;
+	}
+
+	public void setReportingValue(long v)
+	{
+		reportingValue = v;
+		if ( getConfigManager().getSetting( Settings.LEVEL_TYPE ) == LevelType.ENERGY_LEVEL )
+			configureWatchers();
+		else
+			updateState();
+	}
+
+	@MENetworkEventSubscribe
+	public void powerChanged(MENetworkPowerStatusChange c)
+	{
+		updateState();
+	}
+
+	@MENetworkEventSubscribe
+	public void channelChanged(MENetworkChannelsChanged c)
+	{
+		updateState();
+	}
+
+	public void upgradesChanged()
+	{
+		configureWatchers();
+	}
+
+	@Override
+	public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
+	{
+		configureWatchers();
+	}
+
+	private void updateState()
+	{
+		if ( proxy.isActive() )
+		{
+			boolean isOn = isLevelEmitterOn();
+			if ( prevState != isOn )
+			{
+				host.markForUpdate();
+				TileEntity te = host.getTile();
+				prevState = isOn;
+				Platform.notifyBlocksOfNeighbors( te.getWorldObj(), te.xCoord, te.yCoord, te.zCoord );
+				Platform.notifyBlocksOfNeighbors( te.getWorldObj(), te.xCoord + side.offsetX, te.yCoord + side.offsetY, te.zCoord + side.offsetZ );
+			}
+		}
+	}
+
+	public void writeToNBT(NBTTagCompound data)
+	{
+		super.writeToNBT( data );
+		data.setLong( "lastReportedValue", lastReportedValue );
+		data.setLong( "reportingValue", reportingValue );
+		data.setBoolean( "prevState", prevState );
+		config.writeToNBT( data, "config" );
+	}
+
+	public void readFromNBT(NBTTagCompound data)
+	{
+		super.readFromNBT( data );
+		lastReportedValue = data.getLong( "lastReportedValue" );
+		reportingValue = data.getLong( "reportingValue" );
+		prevState = data.getBoolean( "prevState" );
+		config.readFromNBT( data, "config" );
+	}
+
+	@Override
+	protected int populateFlags(int cf)
+	{
+		return cf | (prevState ? FLAG_ON : 0);
+	}
+
+	@Override
+	public void updateWatcher(ICraftingWatcher newWatcher)
+	{
+		myCraftingWatcher = newWatcher;
+		configureWatchers();
+	}
+
+	@Override
+	public void updateWatcher(IStackWatcher newWatcher)
+	{
+		myWatcher = newWatcher;
+		configureWatchers();
+	}
+
+	@Override
+	public void updateWatcher(IEnergyWatcher newWatcher)
+	{
+		myEnergyWatcher = newWatcher;
+		configureWatchers();
+	}
+
+	// update the system...
+	public void configureWatchers()
+	{
+		IAEItemStack myStack = config.getAEStackInSlot( 0 );
+
+		if ( myWatcher != null )
+			myWatcher.clear();
+
+		if ( myEnergyWatcher != null )
+			myEnergyWatcher.clear();
+
+		if ( myCraftingWatcher != null )
+			myCraftingWatcher.clear();
+
+		try
+		{
+			proxy.getGrid().postEvent( new MENetworkCraftingPatternChange( this, proxy.getNode() ) );
+		}
+		catch (GridAccessException e1)
+		{
+			// :/
+		}
+
+		if ( getInstalledUpgrades( Upgrades.CRAFTING ) > 0 )
+		{
+			if ( myCraftingWatcher != null && myStack != null )
+				myCraftingWatcher.add( myStack );
+
+			return;
+		}
+
+		if ( getConfigManager().getSetting( Settings.LEVEL_TYPE ) == LevelType.ENERGY_LEVEL )
+		{
+			if ( myEnergyWatcher != null )
+				myEnergyWatcher.add( (double) reportingValue );
+
+			try
+			{
+				// update to power...
+				lastReportedValue = (long) proxy.getEnergy().getStoredPower();
+				updateState();
+
+				// no more item stuff..
+				proxy.getStorage().getItemInventory().removeListener( this );
+			}
+			catch (GridAccessException e)
+			{
+				// :P
+			}
+
+			return;
+		}
+
+		try
+		{
+			if ( getInstalledUpgrades( Upgrades.FUZZY ) > 0 || myStack == null )
+			{
+				proxy.getStorage().getItemInventory().addListener( this, proxy.getGrid() );
+			}
+			else
+			{
+				proxy.getStorage().getItemInventory().removeListener( this );
+
+				if ( myWatcher != null )
+					myWatcher.add( myStack );
+			}
+
+			updateReportingValue( proxy.getStorage().getItemInventory() );
+		}
+		catch (GridAccessException e)
+		{
+			// >.>
+		}
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack)
+	{
+		if ( inv == config )
+			configureWatchers();
+
+		super.onChangeInventory( inv, slot, mc, removedStack, newStack );
+	}
+
+	@Override
+	public void postChange(IBaseMonitor<IAEItemStack> monitor, Iterable<IAEItemStack> change, BaseActionSource actionSource)
+	{
+		updateReportingValue( (IMEMonitor<IAEItemStack>) monitor );
+	}
+
+	@Override
+	public boolean onPartActivate(EntityPlayer player, Vec3 pos)
+	{
+		if ( !player.isSneaking() )
+		{
+			if ( Platform.isClient() )
+				return true;
+
+			Platform.openGUI( player, getHost().getTile(), side, GuiBridge.GUI_LEVELEMITTER );
+			return true;
+		}
+
+		return false;
+	}
+
+	private void updateReportingValue(IMEMonitor<IAEItemStack> monitor)
+	{
+		IAEItemStack myStack = config.getAEStackInSlot( 0 );
+
+		if ( myStack == null )
+		{
+			lastReportedValue = 0;
+			for (IAEItemStack st : monitor.getStorageList())
+				lastReportedValue += st.getStackSize();
+		}
+		else if ( getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
+		{
+			lastReportedValue = 0;
+			FuzzyMode fzMode = (FuzzyMode) getConfigManager().getSetting( Settings.FUZZY_MODE );
+			Collection<IAEItemStack> fuzzyList = monitor.getStorageList().findFuzzy( myStack, fzMode );
+			for (IAEItemStack st : fuzzyList)
+				lastReportedValue += st.getStackSize();
+		}
+		else
+		{
+			IAEItemStack r = monitor.getStorageList().findPrecise( myStack );
+			if ( r == null )
+				lastReportedValue = 0;
+			else
+				lastReportedValue = r.getStackSize();
+		}
+
+		updateState();
+	}
+
+	@Override
+	public boolean isValid(Object effectiveGrid)
+	{
+		try
+		{
+			return proxy.getGrid() == effectiveGrid;
+		}
+		catch (GridAccessException e)
+		{
+			return false;
+		}
+	}
+
+	@Override
+	public void onRequestChange(ICraftingGrid craftingGrid, IAEItemStack what)
+	{
+		updateState();
+	}
+
+	@Override
+	public void onThresholdPass(IEnergyGrid energyGrid)
+	{
+		lastReportedValue = (long) energyGrid.getStoredPower();
+		updateState();
+	}
+
+	@Override
+	public void onStackChange(IItemList o, IAEStack fullStack, IAEStack diffStack, BaseActionSource src, StorageChannel chan)
+	{
+		if ( chan == StorageChannel.ITEMS && fullStack.equals( config.getAEStackInSlot( 0 ) ) && getInstalledUpgrades( Upgrades.FUZZY ) == 0 )
+		{
+			lastReportedValue = fullStack.getStackSize();
+			updateState();
+		}
+	}
+
+	public PartLevelEmitter(ItemStack is) {
+		super( PartLevelEmitter.class, is );
+		getConfigManager().registerSetting( Settings.REDSTONE_EMITTER, RedstoneMode.HIGH_SIGNAL );
+		getConfigManager().registerSetting( Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL );
+		getConfigManager().registerSetting( Settings.LEVEL_TYPE, LevelType.ITEM_LEVEL );
+		getConfigManager().registerSetting( Settings.CRAFT_VIA_REDSTONE, YesNo.NO );
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInventory(IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		rh.setTexture( is.getIconIndex() );
+		Tessellator.instance.startDrawingQuads();
+		renderTorchAtAngle( 0, -0.5, 0 );
+		Tessellator.instance.draw();
+		// rh.setBounds( 7, 7, 10, 9, 9, 15 );
+		// rh.renderInventoryBox( renderer );
+	}
+
+	double cenx;
+	double ceny;
+	double cenz;
+
+	public void addVertexWithUV(double x, double y, double z, double u, double v)
+	{
+		Tessellator var12 = Tessellator.instance;
+
+		x -= cenx;
+		y -= ceny;
+		z -= cenz;
+
+		if ( side == ForgeDirection.DOWN )
+		{
+			y = -y;
+			z = -z;
+		}
+
+		if ( side == ForgeDirection.EAST )
+		{
+			double m = x;
+			x = y;
+			y = m;
+			y = -y;
+		}
+
+		if ( side == ForgeDirection.WEST )
+		{
+			double m = x;
+			x = -y;
+			y = m;
+		}
+
+		if ( side == ForgeDirection.SOUTH )
+		{
+			double m = z;
+			z = y;
+			y = m;
+			y = -y;
+		}
+
+		if ( side == ForgeDirection.NORTH )
+		{
+			double m = z;
+			z = -y;
+			y = m;
+		}
+
+		x += cenx;// + orientation.offsetX * 0.4;
+		y += ceny;// + orientation.offsetY * 0.4;
+		z += cenz;// + orientation.offsetZ * 0.4;
+
+		var12.addVertexWithUV( x, y, z, u, v );
+	}
+
+	@Override
+	public void randomDisplayTick(World world, int x, int y, int z, Random r)
+	{
+		if ( isLevelEmitterOn() )
+		{
+			ForgeDirection d = side;
+
+			double d0 = (double) ((float) d.offsetX * 0.45F) + (double) (r.nextFloat() - 0.5F) * 0.2D;
+			double d1 = (double) ((float) d.offsetY * 0.45F) + (double) (r.nextFloat() - 0.5F) * 0.2D;
+			double d2 = (double) ((float) d.offsetZ * 0.45F) + (double) (r.nextFloat() - 0.5F) * 0.2D;
+
+			world.spawnParticle( "reddust", 0.5 + x + d0, 0.5 + y + d1, 0.5 + z + d2, 0.0D, 0.0D, 0.0D );
+		}
+	}
+
+	public void renderTorchAtAngle(double baseX, double baseY, double baseZ)
+	{
+		boolean isOn = isLevelEmitterOn();
+		IIcon offTexture = is.getIconIndex();
+		IIcon IIcon = (isOn ? CableBusTextures.LevelEmitterTorchOn.getIcon() : offTexture);
+		//
+		cenx = baseX + 0.5;
+		ceny = baseY + 0.5;
+		cenz = baseZ + 0.5;
+
+		baseY += 7.0 / 16.0;
+		;
+		double par10 = 0;
+		// double par11 = 0;
+		double Zero = 0;
+
+		/*
+		 * double d5 = (double)IIcon.func_94209_e(); double d6 = (double)IIcon.func_94206_g(); double d7 =
+		 * (double)IIcon.func_94212_f(); double d8 = (double)IIcon.func_94210_h(); double d9 =
+		 * (double)IIcon.func_94214_a(7.0D); double d10 = (double)IIcon.func_94207_b(6.0D); double d11 =
+		 * (double)IIcon.func_94214_a(9.0D); double d12 = (double)IIcon.func_94207_b(8.0D); double d13 =
+		 * (double)IIcon.func_94214_a(7.0D); double d14 = (double)IIcon.func_94207_b(13.0D); double d15 =
+		 * (double)IIcon.func_94214_a(9.0D); double d16 = (double)IIcon.func_94207_b(15.0D);
+		 */
+
+		float var16 = IIcon.getMinU();
+		float var17 = IIcon.getMaxU();
+		float var18 = IIcon.getMinV();
+		float var19 = IIcon.getMaxV();
+		/*
+		 * float var16 = (float)var14 / 256.0F; float var17 = ((float)var14 + 15.99F) / 256.0F; float var18 =
+		 * (float)var15 / 256.0F; float var19 = ((float)var15 + 15.99F) / 256.0F;
+		 */
+		double var20b = (double) offTexture.getInterpolatedU( 7.0D );
+		double var24b = (double) offTexture.getInterpolatedU( 9.0D );
+
+		double var20 = (double) IIcon.getInterpolatedU( 7.0D );
+		double var24 = (double) IIcon.getInterpolatedU( 9.0D );
+		double var22 = (double) IIcon.getInterpolatedV( 6.0D + (isOn ? 0 : 1.0D) );
+		double var26 = (double) IIcon.getInterpolatedV( 8.0D + (isOn ? 0 : 1.0D) );
+		double var28 = (double) IIcon.getInterpolatedU( 7.0D );
+		double var30 = (double) IIcon.getInterpolatedV( 13.0D );
+		double var32 = (double) IIcon.getInterpolatedU( 9.0D );
+		double var34 = (double) IIcon.getInterpolatedV( 15.0D );
+
+		double var22b = (double) IIcon.getInterpolatedV( 9.0D );
+		double var26b = (double) IIcon.getInterpolatedV( 11.0D );
+
+		baseX += 0.5D;
+		baseZ += 0.5D;
+		double var36 = baseX - 0.5D;
+		double var38 = baseX + 0.5D;
+		double var40 = baseZ - 0.5D;
+		double var42 = baseZ + 0.5D;
+		double var44 = 0.0625D;
+		double var422 = 0.1915D + 1.0 / 16.0;
+		double TorchLen = 0.625D;
+
+		double toff = 0.0d;
+
+		if ( !isOn )
+		{
+			toff = 1.0d / 16.0d;
+		}
+
+		Tessellator var12 = Tessellator.instance;
+		if ( isOn )
+		{
+			var12.setColorOpaque_F( 1.0F, 1.0F, 1.0F );
+			var12.setBrightness( 11 << 20 | 11 << 4 );
+		}
+
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) - var44, baseY + TorchLen - toff, baseZ + par10 * (1.0D - TorchLen) - var44, var20, var22 );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) - var44, baseY + TorchLen - toff, baseZ + par10 * (1.0D - TorchLen) + var44, var20, var26 );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) + var44, baseY + TorchLen - toff, baseZ + par10 * (1.0D - TorchLen) + var44, var24, var26 );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) + var44, baseY + TorchLen - toff, baseZ + par10 * (1.0D - TorchLen) - var44, var24, var22 );
+
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) + var44, baseY + var422, baseZ + par10 * (1.0D - TorchLen) - var44, var24b, var22b );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) + var44, baseY + var422, baseZ + par10 * (1.0D - TorchLen) + var44, var24b, var26b );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) - var44, baseY + var422, baseZ + par10 * (1.0D - TorchLen) + var44, var20b, var26b );
+		this.addVertexWithUV( baseX + Zero * (1.0D - TorchLen) - var44, baseY + var422, baseZ + par10 * (1.0D - TorchLen) - var44, var20b, var22b );
+
+		this.addVertexWithUV( baseX + var44 + Zero, baseY, baseZ - var44 + par10, var32, var30 );
+		this.addVertexWithUV( baseX + var44 + Zero, baseY, baseZ + var44 + par10, var32, var34 );
+		this.addVertexWithUV( baseX - var44 + Zero, baseY, baseZ + var44 + par10, var28, var34 );
+		this.addVertexWithUV( baseX - var44 + Zero, baseY, baseZ - var44 + par10, var28, var30 );
+
+		this.addVertexWithUV( baseX - var44, baseY + 1.0D, var40, (double) var16, (double) var18 );
+		this.addVertexWithUV( baseX - var44 + Zero, baseY + 0.0D, var40 + par10, (double) var16, (double) var19 );
+		this.addVertexWithUV( baseX - var44 + Zero, baseY + 0.0D, var42 + par10, (double) var17, (double) var19 );
+		this.addVertexWithUV( baseX - var44, baseY + 1.0D, var42, (double) var17, (double) var18 );
+
+		this.addVertexWithUV( baseX + var44, baseY + 1.0D, var42, (double) var16, (double) var18 );
+		this.addVertexWithUV( baseX + Zero + var44, baseY + 0.0D, var42 + par10, (double) var16, (double) var19 );
+		this.addVertexWithUV( baseX + Zero + var44, baseY + 0.0D, var40 + par10, (double) var17, (double) var19 );
+		this.addVertexWithUV( baseX + var44, baseY + 1.0D, var40, (double) var17, (double) var18 );
+
+		this.addVertexWithUV( var36, baseY + 1.0D, baseZ + var44, (double) var16, (double) var18 );
+		this.addVertexWithUV( var36 + Zero, baseY + 0.0D, baseZ + var44 + par10, (double) var16, (double) var19 );
+		this.addVertexWithUV( var38 + Zero, baseY + 0.0D, baseZ + var44 + par10, (double) var17, (double) var19 );
+		this.addVertexWithUV( var38, baseY + 1.0D, baseZ + var44, (double) var17, (double) var18 );
+
+		this.addVertexWithUV( var38, baseY + 1.0D, baseZ - var44, (double) var16, (double) var18 );
+		this.addVertexWithUV( var38 + Zero, baseY + 0.0D, baseZ - var44 + par10, (double) var16, (double) var19 );
+		this.addVertexWithUV( var36 + Zero, baseY + 0.0D, baseZ - var44 + par10, (double) var17, (double) var19 );
+		this.addVertexWithUV( var36, baseY + 1.0D, baseZ - var44, (double) var17, (double) var18 );
+	}
+
+	boolean status = false;;
+
+	private boolean isLevelEmitterOn()
+	{
+		if ( Platform.isClient() )
+			return (clientFlags & FLAG_ON) == FLAG_ON;
+
+		if ( getInstalledUpgrades( Upgrades.CRAFTING ) > 0 )
+		{
+			try
+			{
+				return proxy.getCrafting().isRequesting( config.getAEStackInSlot( 0 ) );
+			}
+			catch (GridAccessException e)
+			{
+				// :P
+			}
+
+			return prevState;
+		}
+
+		boolean flipState = getConfigManager().getSetting( Settings.REDSTONE_EMITTER ) == RedstoneMode.LOW_SIGNAL;
+		return flipState ? reportingValue >= lastReportedValue + 1 : reportingValue < lastReportedValue + 1;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer)
+	{
+		rh.setTexture( is.getIconIndex() );
+		// rh.setTexture( CableBusTextures.ItemPartLevelEmitterOn.getIcon() );
+
+		// rh.setBounds( 2, 2, 14, 14, 14, 16 );
+		// rh.renderBlock( x, y, z, renderer );
+
+		// rh.setBounds( 7, 7, 10, 9, 9, 15 );
+		// rh.renderBlock( x, y, z, renderer );
+
+		renderer.renderAllFaces = true;
+
+		Tessellator tess = Tessellator.instance;
+		tess.setBrightness( rh.getBlock().getMixedBrightnessForBlock( this.getHost().getTile().getWorldObj(), x, y, z ) );
+		tess.setColorOpaque_F( 1.0F, 1.0F, 1.0F );
+
+		renderTorchAtAngle( x, y, z );
+
+		renderer.renderAllFaces = false;
+
+		rh.setBounds( 7, 7, 11, 9, 9, 12 );
+		renderLights( x, y, z, rh, renderer );
+
+		// super.renderWorldBlock( world, x, y, z, block, modelId, renderer );
+	}
+
+	@Override
+	public IIcon getBreakingTexture()
+	{
+		return is.getIconIndex();
+	}
+
+	@Override
+	public void getBoxes(IPartCollisionHelper bch)
+	{
+		bch.addBox( 7, 7, 11, 9, 9, 16 );
+	}
+
+	@Override
+	public AECableType getCableConnectionType(ForgeDirection dir)
+	{
+		return AECableType.SMART;
+	}
+
+	@Override
+	public int cableConnectionRenderTo()
+	{
+		return 16;
+	}
+
+	@Override
+	public boolean canConnectRedstone()
+	{
+		return true;
+	}
+
+	@Override
+	public int isProvidingStrongPower()
+	{
+		return prevState ? 15 : 0;
+	}
+
+	@Override
+	public int isProvidingWeakPower()
+	{
+		return prevState ? 15 : 0;
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "config" ) )
+			return config;
+
+		return super.getInventoryByName( name );
+	}
+
+	@Override
+	public void onListUpdate()
+	{
+		try
+		{
+			updateReportingValue( proxy.getStorage().getItemInventory() );
+		}
+		catch (GridAccessException e)
+		{
+			// ;P
+		}
+	}
+
+	@Override
+	public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table)
+	{
+		return false;
+	}
+
+	@Override
+	public boolean isBusy()
+	{
+		return true;
+	}
+
+	@Override
+	public void provideCrafting(ICraftingProviderHelper craftingTracker)
+	{
+		if ( getInstalledUpgrades( Upgrades.CRAFTING ) > 0 )
+		{
+			if ( settings.getSetting( Settings.CRAFT_VIA_REDSTONE ) == YesNo.YES )
+			{
+				IAEItemStack what = config.getAEStackInSlot( 0 );
+				if ( what != null )
+					craftingTracker.setEmitable( what );
+			}
+		}
+	}
+}

src/main/java/appeng/parts/automation/PartSharedItemBus.java

@@ -0,0 +1,120 @@
+package appeng.parts.automation;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Upgrades;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.me.GridAccessException;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.util.InventoryAdaptor;
+import appeng.util.Platform;
+
+public abstract class PartSharedItemBus extends PartUpgradeable implements IGridTickable
+{
+
+	private TileEntity getTileEntity(TileEntity self, int x, int y, int z)
+	{
+		World w = self.getWorldObj();
+
+		if ( w.getChunkProvider().chunkExists( x >> 4, z >> 4 ) )
+		{
+			TileEntity te = w.getTileEntity( x, y, z );
+			return te;
+		}
+
+		return null;
+	}
+
+	public PartSharedItemBus(Class c, ItemStack is) {
+		super( c, is );
+	}
+
+	@Override
+	public void upgradesChanged()
+	{
+		updateState();
+	}
+
+	protected int availableSlots()
+	{
+		return Math.min( 1 + getInstalledUpgrades( Upgrades.CAPACITY ) * 4, config.getSizeInventory() );
+	}
+
+	public void writeToNBT(net.minecraft.nbt.NBTTagCompound extra)
+	{
+		super.writeToNBT( extra );
+		config.writeToNBT( extra, "config" );
+	}
+
+	public void readFromNBT(net.minecraft.nbt.NBTTagCompound extra)
+	{
+		super.readFromNBT( extra );
+		config.readFromNBT( extra, "config" );
+	}
+
+	AppEngInternalAEInventory config = new AppEngInternalAEInventory( this, 9 );
+
+	int adaptorHash = 0;
+	InventoryAdaptor adaptor;
+
+	InventoryAdaptor getHandler()
+	{
+		TileEntity self = getHost().getTile();
+		TileEntity target = getTileEntity( self, self.xCoord + side.offsetX, self.yCoord + side.offsetY, self.zCoord + side.offsetZ );
+
+		int newAdaptorHash = Platform.generateTileHash( target );
+
+		if ( adaptorHash == newAdaptorHash && newAdaptorHash != 0 )
+			return adaptor;
+
+		adaptorHash = newAdaptorHash;
+		adaptor = InventoryAdaptor.getAdaptor( target, side.getOpposite() );
+
+		return adaptor;
+	}
+
+	boolean lastRedstone = false;
+
+	abstract TickRateModulation doBusWork();
+
+	@Override
+	public void onNeighborChanged()
+	{
+		updateState();
+		if ( lastRedstone != host.hasRedstone( side ) )
+		{
+			lastRedstone = !lastRedstone;
+			if ( lastRedstone && getRSMode() == RedstoneMode.SIGNAL_PULSE )
+				doBusWork();
+		}
+	}
+
+	private void updateState()
+	{
+		try
+		{
+			if ( !isSleeping() )
+				proxy.getTick().wakeDevice( proxy.getNode() );
+			else
+				proxy.getTick().sleepDevice( proxy.getNode() );
+		}
+		catch (GridAccessException e)
+		{
+			// :P
+		}
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "config" ) )
+			return config;
+
+		return super.getInventoryByName( name );
+	}
+
+}

src/main/java/appeng/parts/automation/PartUpgradeable.java

@@ -0,0 +1,139 @@
+package appeng.parts.automation;
+
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import appeng.api.config.RedstoneMode;
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.tiles.ISegmentedInventory;
+import appeng.api.util.IConfigManager;
+import appeng.parts.PartBasicState;
+import appeng.tile.inventory.IAEAppEngInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.ConfigManager;
+import appeng.util.IConfigManagerHost;
+
+public class PartUpgradeable extends PartBasicState implements ISegmentedInventory, IAEAppEngInventory, IConfigManagerHost
+{
+
+	IConfigManager settings = new ConfigManager( this );
+	private UpgradeInventory upgrades = new UpgradeInventory( is, this, getUpgradeSlots() );
+
+	@Override
+	public int getInstalledUpgrades(Upgrades u)
+	{
+		return upgrades.getInstalledUpgrades( u );
+	}
+
+	@Override
+	public boolean canConnectRedstone()
+	{
+		return upgrades.getMaxInstalled( Upgrades.REDSTONE ) > 0;
+	}
+
+	protected int getUpgradeSlots()
+	{
+		return 4;
+	}
+
+	@Override
+	public void getDrops(List<ItemStack> drops, boolean wrenched)
+	{
+		for (ItemStack is : upgrades)
+			if ( is != null )
+				drops.add( is );
+	}
+
+	public void writeToNBT(net.minecraft.nbt.NBTTagCompound extra)
+	{
+		super.writeToNBT( extra );
+		settings.writeToNBT( extra );
+		upgrades.writeToNBT( extra, "upgrades" );
+	}
+
+	public void readFromNBT(net.minecraft.nbt.NBTTagCompound extra)
+	{
+		super.readFromNBT( extra );
+		settings.readFromNBT( extra );
+		upgrades.readFromNBT( extra, "upgrades" );
+	}
+
+	public PartUpgradeable(Class c, ItemStack is) {
+		super( c, is );
+		upgrades.setMaxStackSize( 1 );
+	}
+
+	@Override
+	public IConfigManager getConfigManager()
+	{
+		return settings;
+	}
+
+	@Override
+	public IInventory getInventoryByName(String name)
+	{
+		if ( name.equals( "upgrades" ) )
+			return upgrades;
+
+		return null;
+	}
+
+	@Override
+	public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
+	{
+
+	}
+
+	public void upgradesChanged()
+	{
+
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack)
+	{
+		if ( inv == upgrades )
+		{
+			upgradesChanged();
+		}
+	}
+
+	public RedstoneMode getRSMode()
+	{
+		return null;
+	}
+
+	protected boolean isSleeping()
+	{
+		if ( getInstalledUpgrades( Upgrades.REDSTONE ) > 0 )
+		{
+			switch (getRSMode())
+			{
+			case IGNORE:
+				return false;
+
+			case HIGH_SIGNAL:
+				if ( host.hasRedstone( side ) )
+					return false;
+
+				break;
+
+			case LOW_SIGNAL:
+				if ( !host.hasRedstone( side ) )
+					return false;
+
+				break;
+
+			case SIGNAL_PULSE:
+			default:
+				break;
+
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+}

src/main/java/appeng/parts/automation/UpgradeInventory.java

@@ -0,0 +1,188 @@
+package appeng.parts.automation;
+
+import net.minecraft.block.Block;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.items.IUpgradeModule;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.tile.inventory.IAEAppEngInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+
+public class UpgradeInventory extends AppEngInternalInventory implements IAEAppEngInventory
+{
+
+	private final Object itemorblock;
+	private final IAEAppEngInventory parent;
+
+	private boolean cached = false;
+	private int FuzzyUpgrades = 0;
+	private int SpeedUpgrades = 0;
+	private int RedstoneUpgrades = 0;
+	private int CapacityUpgrades = 0;
+	private int InverterUpgrades = 0;
+	private int CraftingUpgrades = 0;
+
+	public UpgradeInventory(Object itemOrBlock, IAEAppEngInventory _te, int s) {
+		super( null, s );
+		te = this;
+		parent = _te;
+		itemorblock = itemOrBlock;
+	}
+
+	@Override
+	protected boolean eventsEnabled()
+	{
+		return true;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack newItemStack)
+	{
+		super.setInventorySlotContents( slot, newItemStack );
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int i, ItemStack itemstack)
+	{
+		if ( itemstack == null )
+			return false;
+		Item it = itemstack.getItem();
+		if ( it instanceof IUpgradeModule )
+		{
+			Upgrades u = ((IUpgradeModule) it).getType( itemstack );
+			if ( u != null )
+			{
+				return getInstalledUpgrades( u ) < getMaxInstalled( u );
+			}
+		}
+		return false;
+	}
+
+	public int getMaxInstalled(Upgrades u)
+	{
+		Integer max = null;
+		for (ItemStack is : u.getSupported().keySet())
+		{
+			if ( is.getItem() == itemorblock )
+			{
+				max = u.getSupported().get( is );
+				break;
+			}
+			else if ( is.getItem() instanceof ItemBlock && Block.getBlockFromItem( is.getItem() ) == itemorblock )
+			{
+				max = u.getSupported().get( is );
+				break;
+			}
+			else if ( itemorblock instanceof ItemStack && Platform.isSameItem( (ItemStack) itemorblock, is ) )
+			{
+				max = u.getSupported().get( is );
+				break;
+			}
+		}
+
+		if ( max == null )
+			return 0;
+		return max;
+	}
+
+	@Override
+	public int getInventoryStackLimit()
+	{
+		return 1;
+	}
+
+	private void updateUpgradeInfo()
+	{
+		cached = true;
+		InverterUpgrades = CapacityUpgrades = RedstoneUpgrades = SpeedUpgrades = FuzzyUpgrades = CraftingUpgrades = 0;
+
+		for (ItemStack is : this)
+		{
+			if ( is == null || is.getItem() == null || !(is.getItem() instanceof IUpgradeModule) )
+				continue;
+
+			Upgrades myUpgrade = ((IUpgradeModule) is.getItem()).getType( is );
+			switch (myUpgrade)
+			{
+			case CAPACITY:
+				CapacityUpgrades++;
+				break;
+			case FUZZY:
+				FuzzyUpgrades++;
+				break;
+			case REDSTONE:
+				RedstoneUpgrades++;
+				break;
+			case SPEED:
+				SpeedUpgrades++;
+				break;
+			case INVERTER:
+				InverterUpgrades++;
+				break;
+			case CRAFTING:
+				CraftingUpgrades++;
+				break;
+			default:
+				break;
+			}
+		}
+
+		CapacityUpgrades = Math.min( CapacityUpgrades, getMaxInstalled( Upgrades.CAPACITY ) );
+		FuzzyUpgrades = Math.min( FuzzyUpgrades, getMaxInstalled( Upgrades.FUZZY ) );
+		RedstoneUpgrades = Math.min( RedstoneUpgrades, getMaxInstalled( Upgrades.REDSTONE ) );
+		SpeedUpgrades = Math.min( SpeedUpgrades, getMaxInstalled( Upgrades.SPEED ) );
+		InverterUpgrades = Math.min( InverterUpgrades, getMaxInstalled( Upgrades.INVERTER ) );
+		CraftingUpgrades = Math.min( CraftingUpgrades, getMaxInstalled( Upgrades.CRAFTING ) );
+	}
+
+	public int getInstalledUpgrades(Upgrades u)
+	{
+		if ( !cached )
+			updateUpgradeInfo();
+
+		switch (u)
+		{
+		case CAPACITY:
+			return CapacityUpgrades;
+		case FUZZY:
+			return FuzzyUpgrades;
+		case REDSTONE:
+			return RedstoneUpgrades;
+		case SPEED:
+			return SpeedUpgrades;
+		case INVERTER:
+			return InverterUpgrades;
+		case CRAFTING:
+			return CraftingUpgrades;
+		default:
+			return 0;
+		}
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound target)
+	{
+		super.readFromNBT( target );
+		updateUpgradeInfo();
+	}
+
+	@Override
+	public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removedStack, ItemStack newStack)
+	{
+		cached = false;
+		if ( parent != null && Platform.isServer() )
+			parent.onChangeInventory( inv, slot, mc, removedStack, newStack );
+	}
+
+	@Override
+	public void saveChanges()
+	{
+		parent.saveChanges();
+	}
+
+}