Relocate Source to proper directory.

src/main/java/appeng/me/cache/CraftingGridCache.java

@@ -0,0 +1,578 @@
+package appeng.me.cache;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+
+import net.minecraft.world.World;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.crafting.ICraftingCPU;
+import appeng.api.networking.crafting.ICraftingCallback;
+import appeng.api.networking.crafting.ICraftingGrid;
+import appeng.api.networking.crafting.ICraftingJob;
+import appeng.api.networking.crafting.ICraftingLink;
+import appeng.api.networking.crafting.ICraftingMedium;
+import appeng.api.networking.crafting.ICraftingPatternDetails;
+import appeng.api.networking.crafting.ICraftingProvider;
+import appeng.api.networking.crafting.ICraftingProviderHelper;
+import appeng.api.networking.crafting.ICraftingRequester;
+import appeng.api.networking.crafting.ICraftingWatcher;
+import appeng.api.networking.crafting.ICraftingWatcherHost;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.events.MENetworkCraftingCpuChange;
+import appeng.api.networking.events.MENetworkCraftingPatternChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPostCacheConstruction;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.ICellProvider;
+import appeng.api.storage.IMEInventoryHandler;
+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.crafting.CraftingJob;
+import appeng.crafting.CraftingLink;
+import appeng.crafting.CraftingLinkNexus;
+import appeng.crafting.CraftingWatcher;
+import appeng.me.cluster.implementations.CraftingCPUCluster;
+import appeng.me.helpers.GenericInterestManager;
+import appeng.me.storage.ItemWatcher;
+import appeng.tile.crafting.TileCraftingStorageTile;
+import appeng.tile.crafting.TileCraftingTile;
+import appeng.util.ItemSorters;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.SetMultimap;
+
+public class CraftingGridCache implements ICraftingGrid, ICraftingProviderHelper, ICellProvider, IMEInventoryHandler
+{
+
+	HashSet<CraftingCPUCluster> cpuClusters = new HashSet();
+	HashSet<ICraftingProvider> providers = new HashSet();
+
+	private HashMap<IGridNode, ICraftingWatcher> watchers = new HashMap<IGridNode, ICraftingWatcher>();
+
+	IGrid grid;
+	IStorageGrid sg;
+	IEnergyGrid eg;
+
+	HashMap<ICraftingPatternDetails, List<ICraftingMedium>> craftingMethods = new HashMap();
+	HashMap<IAEItemStack, ImmutableList<ICraftingPatternDetails>> craftableItems = new HashMap();
+	HashSet<IAEItemStack> emitableItems = new HashSet();
+	HashMap<String, CraftingLinkNexus> links = new HashMap();
+
+	boolean updateList = false;
+	final private SetMultimap<IAEStack, ItemWatcher> interests = HashMultimap.create();
+	final public GenericInterestManager interestManager = new GenericInterestManager( interests );
+
+	class ActiveCpuIterator implements Iterator<ICraftingCPU>
+	{
+
+		final Iterator<CraftingCPUCluster> i;
+		CraftingCPUCluster c = null;
+
+		public ActiveCpuIterator(Collection<CraftingCPUCluster> o)
+		{
+			i = o.iterator();
+		}
+
+		@Override
+		public boolean hasNext()
+		{
+			findNext();
+			return c != null;
+		}
+
+		private void findNext()
+		{
+			while (i.hasNext() && c == null)
+			{
+				c = i.next();
+				if ( !c.isActive() || c.isDestroyed )
+					c = null;
+			}
+		}
+
+		@Override
+		public ICraftingCPU next()
+		{
+			ICraftingCPU o = c;
+			c = null;
+			return o;
+		}
+
+		@Override
+		public void remove()
+		{
+			// no..
+		}
+
+	};
+
+	@Override
+	public ImmutableSet<ICraftingCPU> getCpus()
+	{
+		return ImmutableSet.copyOf( new ActiveCpuIterator( cpuClusters ) );
+	}
+
+	public CraftingGridCache(IGrid g)
+	{
+		grid = g;
+	}
+
+	@MENetworkEventSubscribe
+	public void afterCacheConstruction(MENetworkPostCacheConstruction cc)
+	{
+		sg = grid.getCache( IStorageGrid.class );
+		eg = grid.getCache( IEnergyGrid.class );
+
+		sg.registerCellProvider( this );
+	}
+
+	public void addLink(CraftingLink l)
+	{
+		if ( l.isStandalone() )
+			return;
+
+		CraftingLinkNexus n = links.get( l.getCraftingID() );
+		if ( n == null )
+			links.put( l.getCraftingID(), n = new CraftingLinkNexus( l.getCraftingID() ) );
+
+		l.setNexus( n );
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+		if ( updateList )
+		{
+			updateList = false;
+			updateCPUClusters();
+		}
+
+		Iterator<CraftingLinkNexus> i = links.values().iterator();
+		while (i.hasNext())
+		{
+			if ( i.next().isDead( grid, this ) )
+				i.remove();
+		}
+
+		for (CraftingCPUCluster cpu : cpuClusters)
+			cpu.updateCraftingLogic( grid, eg, this );
+	}
+
+	@MENetworkEventSubscribe
+	public void updateCPUClusters(MENetworkCraftingCpuChange c)
+	{
+		updateList = true;
+	}
+
+	@MENetworkEventSubscribe
+	public void updateCPUClusters(MENetworkCraftingPatternChange c)
+	{
+		updatePatterns();
+	}
+
+	@Override
+	public void removeNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof ICraftingWatcherHost )
+		{
+			ICraftingWatcher myWatcher = watchers.get( machine );
+			if ( myWatcher != null )
+			{
+				myWatcher.clear();
+				watchers.remove( machine );
+			}
+		}
+
+		if ( machine instanceof ICraftingRequester )
+		{
+			Iterator<CraftingLinkNexus> nex = links.values().iterator();
+			while (nex.hasNext())
+			{
+				CraftingLinkNexus n = nex.next();
+				if ( n.isMachine( machine ) )
+					n.removeNode();
+			}
+		}
+
+		if ( machine instanceof TileCraftingTile )
+			updateList = true;
+		if ( machine instanceof ICraftingProvider )
+		{
+			providers.remove( machine );
+			updatePatterns();
+		}
+	}
+
+	@Override
+	public void addNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof ICraftingWatcherHost )
+		{
+			ICraftingWatcherHost swh = (ICraftingWatcherHost) machine;
+			CraftingWatcher iw = new CraftingWatcher( this, (ICraftingWatcherHost) swh );
+			watchers.put( gridNode, iw );
+			swh.updateWatcher( iw );
+		}
+
+		if ( machine instanceof ICraftingRequester )
+		{
+			for (ICraftingLink l : ((ICraftingRequester) machine).getRequestedJobs())
+			{
+				if ( l instanceof CraftingLink )
+					addLink( (CraftingLink) l );
+			}
+		}
+
+		if ( machine instanceof TileCraftingTile )
+			updateList = true;
+		if ( machine instanceof ICraftingProvider )
+		{
+			providers.add( (ICraftingProvider) machine );
+			updatePatterns();
+		}
+	}
+
+	private void updateCPUClusters()
+	{
+		cpuClusters.clear();
+		for (IGridNode cst : grid.getMachines( TileCraftingStorageTile.class ))
+		{
+			TileCraftingStorageTile tile = (TileCraftingStorageTile) cst.getMachine();
+			CraftingCPUCluster clust = (CraftingCPUCluster) tile.getCluster();
+			if ( clust != null )
+			{
+				cpuClusters.add( clust );
+
+				if ( clust.myLastLink != null )
+					addLink( (CraftingLink) clust.myLastLink );
+			}
+		}
+	}
+
+	@Override
+	public void addCraftingOption(ICraftingMedium medium, ICraftingPatternDetails api)
+	{
+		List<ICraftingMedium> details = craftingMethods.get( api );
+		if ( details == null )
+		{
+			details = new ArrayList<ICraftingMedium>();
+			details.add( medium );
+			craftingMethods.put( api, details );
+		}
+		else
+			details.add( medium );
+	}
+
+	private void updatePatterns()
+	{
+		HashMap<IAEItemStack, ImmutableList<ICraftingPatternDetails>> oldItems = craftableItems;
+
+		// erase list.
+		craftingMethods.clear();
+		craftableItems = new HashMap();
+		emitableItems.clear();
+
+		// update the stuff that was in the list...
+		sg.postAlterationOfStoredItems( StorageChannel.ITEMS, oldItems.keySet(), new BaseActionSource() );
+
+		// re-create list..
+		for (ICraftingProvider cp : providers)
+			cp.provideCrafting( this );
+
+		HashMap<IAEItemStack, Set<ICraftingPatternDetails>> tmpCraft = new HashMap();
+
+		// new craftables!
+		for (ICraftingPatternDetails details : craftingMethods.keySet())
+		{
+			for (IAEItemStack out : details.getOutputs())
+			{
+				out = out.copy();
+				out.reset();
+				out.setCraftable( true );
+
+				Set<ICraftingPatternDetails> methods = tmpCraft.get( out );
+
+				if ( methods == null )
+					tmpCraft.put( out, methods = new HashSet() );
+
+				methods.add( details );
+			}
+		}
+
+		// make them immutable
+		for (Entry<IAEItemStack, Set<ICraftingPatternDetails>> e : tmpCraft.entrySet())
+			craftableItems.put( e.getKey(), ImmutableList.copyOf( e.getValue() ) );
+
+		sg.postAlterationOfStoredItems( StorageChannel.ITEMS, craftableItems.keySet(), new BaseActionSource() );
+	}
+
+	@Override
+	public void onSplit(IGridStorage destinationStorage)
+	{ // nothing!
+	}
+
+	@Override
+	public void onJoin(IGridStorage sourceStorage)
+	{
+		// nothing!
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage destinationStorage)
+	{
+		// nothing!
+	}
+
+	@Override
+	public List<IMEInventoryHandler> getCellArray(StorageChannel channel)
+	{
+		ArrayList<IMEInventoryHandler> list = new ArrayList<IMEInventoryHandler>( 1 );
+		if ( channel == StorageChannel.ITEMS )
+			list.add( this );
+		return list;
+	}
+
+	@Override
+	public int getPriority()
+	{
+		return Integer.MAX_VALUE;
+	}
+
+	@Override
+	public IAEStack extractItems(IAEStack request, Actionable mode, BaseActionSource src)
+	{
+		return null;
+	}
+
+	@Override
+	public IItemList getAvailableItems(IItemList out)
+	{
+		// add craftable items!
+		for (IAEItemStack st : craftableItems.keySet())
+			out.addCrafting( st );
+
+		for (IAEItemStack st : emitableItems)
+			out.addCrafting( st );
+
+		return out;
+	}
+
+	@Override
+	public StorageChannel getChannel()
+	{
+		return StorageChannel.ITEMS;
+	}
+
+	@Override
+	public AccessRestriction getAccess()
+	{
+		return AccessRestriction.WRITE;
+	}
+
+	@Override
+	public boolean isPrioritized(IAEStack input)
+	{
+		return true;
+	}
+
+	@Override
+	public IAEStack injectItems(IAEStack input, Actionable type, BaseActionSource src)
+	{
+		for (CraftingCPUCluster cpu : cpuClusters)
+			input = cpu.injectItems( input, type, src );
+
+		return input;
+	}
+
+	@Override
+	public boolean canAccept(IAEStack input)
+	{
+		for (CraftingCPUCluster cpu : cpuClusters)
+			if ( cpu.canAccept( (IAEItemStack) input ) )
+				return true;
+
+		return false;
+	}
+
+	@Override
+	public ICraftingLink submitJob(ICraftingJob job, ICraftingRequester requestingMachine, ICraftingCPU target, final boolean prioritizePower,
+			BaseActionSource src)
+	{
+		if ( job.isSimulation() )
+			return null;
+
+		CraftingCPUCluster cpuClust = null;
+
+		if ( target instanceof CraftingCPUCluster )
+			cpuClust = (CraftingCPUCluster) target;
+
+		if ( target == null )
+		{
+			List<CraftingCPUCluster> validCpusClusters = new ArrayList<CraftingCPUCluster>();
+			for (CraftingCPUCluster cpu : cpuClusters)
+			{
+				if ( cpu.isActive() && !cpu.isBusy() && cpu.getAvailableStorage() >= job.getByteTotal() )
+				{
+					validCpusClusters.add( cpu );
+				}
+			}
+
+			Collections.sort( validCpusClusters, new Comparator<CraftingCPUCluster>() {
+
+				@Override
+				public int compare(CraftingCPUCluster o1, CraftingCPUCluster o2)
+				{
+					if ( prioritizePower )
+					{
+						int a = ItemSorters.compareLong( o2.getCoProcessors(), o1.getCoProcessors() );
+						if ( a != 0 )
+							return a;
+						return ItemSorters.compareLong( o2.getAvailableStorage(), o1.getAvailableStorage() );
+					}
+
+					int a = ItemSorters.compareLong( o1.getCoProcessors(), o2.getCoProcessors() );
+					if ( a != 0 )
+						return a;
+					return ItemSorters.compareLong( o1.getAvailableStorage(), o2.getAvailableStorage() );
+				}
+
+			} );
+
+			if ( !validCpusClusters.isEmpty() )
+				cpuClust = validCpusClusters.get( 0 );
+		}
+
+		if ( cpuClust != null )
+		{
+			return cpuClust.submitJob( grid, job, src, requestingMachine );
+		}
+
+		return null;
+	}
+
+	@Override
+	public int getSlot()
+	{
+		return 0;
+	}
+
+	@Override
+	public ImmutableCollection<ICraftingPatternDetails> getCraftingFor(IAEItemStack whatToCraft, ICraftingPatternDetails details, int slotIndex, World world)
+	{
+		ImmutableList<ICraftingPatternDetails> res = craftableItems.get( whatToCraft );
+
+		if ( res == null )
+		{
+			if ( details != null && details.isCraftable() )
+			{
+				for (IAEItemStack ais : craftableItems.keySet())
+				{
+					if ( ais.getItem() == whatToCraft.getItem() && (!ais.getItem().getHasSubtypes() || ais.getItemDamage() == whatToCraft.getItemDamage()) )
+					{
+						if ( details.isValidItemForSlot( slotIndex, ais.getItemStack(), world ) )
+						{
+							return craftableItems.get( ais );
+						}
+					}
+				}
+			}
+
+			return ImmutableSet.of();
+		}
+
+		return res;
+	}
+
+	public List<ICraftingMedium> getMediums(ICraftingPatternDetails key)
+	{
+		List<ICraftingMedium> o = craftingMethods.get( key );
+
+		if ( o == null )
+			o = ImmutableList.of();
+
+		return o;
+	}
+
+	@Override
+	public boolean validForPass(int i)
+	{
+		return i == 1;
+	}
+
+	final public static ExecutorService craftingPool;
+
+	static
+	{
+		ThreadFactory factory = new ThreadFactory() {
+
+			@Override
+			public Thread newThread(Runnable ar)
+			{
+				return new Thread( ar, "AE Crafting Calculator" );
+			}
+
+		};
+
+		craftingPool = Executors.newCachedThreadPool( factory );
+	}
+
+	@Override
+	public Future<ICraftingJob> beginCraftingJob(World world, IGrid grid, BaseActionSource actionSrc, IAEItemStack slotItem, ICraftingCallback cb)
+	{
+		if ( world == null || grid == null || actionSrc == null || slotItem == null )
+			throw new RuntimeException( "Invalid Crafting Job Request" );
+
+		CraftingJob cj = new CraftingJob( world, grid, actionSrc, slotItem, cb );
+		return craftingPool.submit( cj, (ICraftingJob) cj );
+	}
+
+	public boolean hasCpu(ICraftingCPU cpu)
+	{
+		return cpuClusters.contains( cpu );
+	}
+
+	@Override
+	public boolean isRequesting(IAEItemStack what)
+	{
+		for (CraftingCPUCluster c : cpuClusters)
+			if ( c.isMaking( what ) )
+				return true;
+		return false;
+	}
+
+	@Override
+	public boolean canEmitFor(IAEItemStack what)
+	{
+		return emitableItems.contains( what );
+	}
+
+	@Override
+	public void setEmitable(IAEItemStack what)
+	{
+		emitableItems.add( what.copy() );
+	}
+
+}

src/main/java/appeng/me/cache/EnergyGridCache.java

@@ -0,0 +1,583 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.Actionable;
+import appeng.api.config.PowerMultiplier;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridBlock;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.energy.IAEPowerStorage;
+import appeng.api.networking.energy.IEnergyGrid;
+import appeng.api.networking.energy.IEnergyGridProvider;
+import appeng.api.networking.energy.IEnergyWatcher;
+import appeng.api.networking.energy.IEnergyWatcherHost;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPostCacheConstruction;
+import appeng.api.networking.events.MENetworkPowerIdleChange;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.events.MENetworkPowerStorage;
+import appeng.api.networking.pathing.IPathingGrid;
+import appeng.api.networking.storage.IStackWatcherHost;
+import appeng.me.Grid;
+import appeng.me.GridNode;
+import appeng.me.energy.EnergyThreshold;
+import appeng.me.energy.EnergyWatcher;
+
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+
+public class EnergyGridCache implements IEnergyGrid
+{
+
+	/**
+	 * estimated power available.
+	 */
+	int availableTicksSinceUpdate = 0;
+	double globalAvailablePower = 0;
+	double globalMaxPower = 0;
+
+	/**
+	 * idle draw.
+	 */
+	double drainPerTick = 0;
+
+	final double AvgLength = 40.0;
+
+	double avgDrainPerTick = 0;
+	double avgInjectionPerTick = 0;
+
+	double tickDrainPerTick = 0;
+	double tickInjectionPerTick = 0;
+
+	/**
+	 * power status
+	 */
+	boolean publicHasPower = false;
+	boolean hasPower = true;
+	long ticksSinceHasPowerChange = 900;
+
+	/**
+	 * excess power in the system.
+	 */
+	double extra = 0;
+
+	IAEPowerStorage lastProvider;
+	final Set<IAEPowerStorage> providers = new LinkedHashSet();
+
+	IAEPowerStorage lastRequestor;
+	final Set<IAEPowerStorage> requesters = new LinkedHashSet();
+
+	final public TreeSet<EnergyThreshold> interests = new TreeSet<EnergyThreshold>();
+	final private HashMap<IGridNode, IEnergyWatcher> watchers = new HashMap<IGridNode, IEnergyWatcher>();
+
+	final private Set<IEnergyGrid> localSeen = new HashSet();
+
+	private double buffer()
+	{
+		return providers.isEmpty() ? 1000.0 : 0.0;
+	}
+
+	private IAEPowerStorage getFirstRequestor()
+	{
+		if ( lastRequestor == null )
+		{
+			Iterator<IAEPowerStorage> i = requesters.iterator();
+			lastRequestor = i.hasNext() ? i.next() : null;
+		}
+
+		return lastRequestor;
+	}
+
+	private IAEPowerStorage getFirstProvider()
+	{
+		if ( lastProvider == null )
+		{
+			Iterator<IAEPowerStorage> i = providers.iterator();
+			lastProvider = i.hasNext() ? i.next() : null;
+		}
+
+		return lastProvider;
+	}
+
+	final Multiset<IEnergyGridProvider> gproviders = HashMultiset.create();
+
+	final IGrid myGrid;
+	PathGridCache pgc;
+
+	public EnergyGridCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@MENetworkEventSubscribe
+	public void postInit(MENetworkPostCacheConstruction pcc)
+	{
+		pgc = myGrid.getCache( IPathingGrid.class );
+	}
+
+	@MENetworkEventSubscribe
+	public void EnergyNodeChanges(MENetworkPowerIdleChange ev)
+	{
+		// update power usage based on event.
+		GridNode node = (GridNode) ev.node;
+		IGridBlock gb = node.getGridBlock();
+
+		double newDraw = gb.getIdlePowerUsage();
+		double diffDraw = newDraw - node.previousDraw;
+		node.previousDraw = newDraw;
+
+		drainPerTick += diffDraw;
+	}
+
+	@MENetworkEventSubscribe
+	public void EnergyNodeChanges(MENetworkPowerStorage ev)
+	{
+		if ( ev.storage.isAEPublicPowerStorage() )
+		{
+			switch (ev.type)
+			{
+			case PROVIDE_POWER:
+				if ( ev.storage.getPowerFlow() != AccessRestriction.WRITE )
+					providers.add( ev.storage );
+				break;
+			case REQUEST_POWER:
+				if ( ev.storage.getPowerFlow() != AccessRestriction.READ )
+					requesters.add( ev.storage );
+				break;
+			}
+		}
+		else
+		{
+			(new RuntimeException( "Attempt to ask the IEnergyGrid to charge a non public energy store." )).printStackTrace();
+		}
+	}
+
+	@Override
+	public double getEnergyDemand(double maxRequired)
+	{
+		localSeen.clear();
+		return getEnergyDemand( maxRequired, localSeen );
+	}
+
+	public double getEnergyDemand(double maxRequired, Set<IEnergyGrid> seen)
+	{
+		if ( !seen.add( this ) )
+			return 0;
+
+		double required = buffer() - extra;
+
+		Iterator<IAEPowerStorage> it = requesters.iterator();
+		while (required < maxRequired && it.hasNext())
+		{
+			IAEPowerStorage node = it.next();
+			if ( node.getPowerFlow() != AccessRestriction.READ )
+				required += Math.max( 0.0, node.getAEMaxPower() - node.getAECurrentPower() );
+		}
+
+		Iterator<IEnergyGridProvider> ix = gproviders.iterator();
+		while (required < maxRequired && ix.hasNext())
+		{
+			IEnergyGridProvider node = ix.next();
+			required += node.getEnergyDemand( maxRequired - required, seen );
+		}
+
+		return required;
+	}
+
+	@Override
+	public double injectPower(double amt, Actionable mode)
+	{
+		localSeen.clear();
+		return injectAEPower( amt, mode, localSeen );
+	}
+
+	public double injectAEPower(double amt, Actionable mode, Set<IEnergyGrid> seen)
+	{
+		if ( !seen.add( this ) )
+			return 0;
+
+		double ignore = extra;
+		amt += extra;
+
+		if ( mode == Actionable.SIMULATE )
+		{
+			Iterator<IAEPowerStorage> it = requesters.iterator();
+			while (amt > 0 && it.hasNext())
+			{
+				IAEPowerStorage node = it.next();
+				amt = node.injectAEPower( amt, Actionable.SIMULATE );
+			}
+
+			Iterator<IEnergyGridProvider> i = gproviders.iterator();
+			while (amt > 0 && i.hasNext())
+				amt = i.next().injectAEPower( amt, mode, seen );
+		}
+		else
+		{
+			tickInjectionPerTick += amt - ignore;
+			// totalInjectionPastTicks[0] += i;
+
+			while (amt > 0 && !requesters.isEmpty())
+			{
+				IAEPowerStorage node = getFirstRequestor();
+
+				amt = node.injectAEPower( amt, Actionable.MODULATE );
+				if ( amt > 0 )
+				{
+					requesters.remove( node );
+					lastRequestor = null;
+				}
+			}
+
+			Iterator<IEnergyGridProvider> i = gproviders.iterator();
+			while (amt > 0 && i.hasNext())
+			{
+				IEnergyGridProvider what = i.next();
+				Set<IEnergyGrid> listCopy = new HashSet<IEnergyGrid>();
+				listCopy.addAll( seen );
+
+				double cannotHold = what.injectAEPower( amt, Actionable.SIMULATE, listCopy );
+				what.injectAEPower( amt - cannotHold, mode, seen );
+
+				amt = cannotHold;
+			}
+
+			extra = amt;
+		}
+
+		return Math.max( 0.0, amt - buffer() );
+	}
+
+	@Override
+	public double extractAEPower(double amt, Actionable mode, PowerMultiplier pm)
+	{
+		localSeen.clear();
+		return pm.divide( extractAEPower( pm.multiply( amt ), mode, localSeen ) );
+	}
+
+	@Override
+	public void addNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof IEnergyGridProvider )
+			gproviders.add( (IEnergyGridProvider) machine );
+
+		// idle draw...
+		GridNode gnode = (GridNode) node;
+		IGridBlock gb = gnode.getGridBlock();
+		gnode.previousDraw = gb.getIdlePowerUsage();
+		drainPerTick += gnode.previousDraw;
+
+		// power storage
+		if ( machine instanceof IAEPowerStorage )
+		{
+			IAEPowerStorage ps = (IAEPowerStorage) machine;
+			if ( ps.isAEPublicPowerStorage() )
+			{
+				double max = ps.getAEMaxPower();
+				double current = ps.getAECurrentPower();
+
+				if ( ps.getPowerFlow() != AccessRestriction.WRITE )
+				{
+					globalMaxPower += ps.getAEMaxPower();
+				}
+
+				if ( current > 0 && ps.getPowerFlow() != AccessRestriction.WRITE )
+				{
+					globalAvailablePower += current;
+					providers.add( ps );
+				}
+
+				if ( current < max && ps.getPowerFlow() != AccessRestriction.READ )
+					requesters.add( ps );
+			}
+		}
+
+		if ( machine instanceof IEnergyWatcherHost )
+		{
+			IEnergyWatcherHost swh = (IEnergyWatcherHost) machine;
+			EnergyWatcher iw = new EnergyWatcher( this, (IEnergyWatcherHost) swh );
+			watchers.put( node, iw );
+			swh.updateWatcher( iw );
+		}
+
+		myGrid.postEventTo( node, new MENetworkPowerStatusChange() );
+	}
+
+	@Override
+	public void removeNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof IEnergyGridProvider )
+			gproviders.remove( machine );
+
+		// idle draw.
+		GridNode gnode = (GridNode) node;
+		drainPerTick -= gnode.previousDraw;
+
+		// power storage.
+		if ( machine instanceof IAEPowerStorage )
+		{
+			IAEPowerStorage ps = (IAEPowerStorage) machine;
+			if ( ps.isAEPublicPowerStorage() )
+			{
+				if ( ps.getPowerFlow() != AccessRestriction.WRITE )
+				{
+					globalMaxPower -= ps.getAEMaxPower();
+					globalAvailablePower -= ps.getAECurrentPower();
+				}
+
+				if ( lastProvider == machine )
+					lastProvider = null;
+
+				if ( lastRequestor == machine )
+					lastRequestor = null;
+
+				providers.remove( machine );
+				requesters.remove( machine );
+			}
+		}
+
+		if ( machine instanceof IStackWatcherHost )
+		{
+			IEnergyWatcher myWatcher = watchers.get( machine );
+			if ( myWatcher != null )
+			{
+				myWatcher.clear();
+				watchers.remove( machine );
+			}
+		}
+
+	}
+
+	double lastStoredPower = -1;
+
+	@Override
+	public void onUpdateTick()
+	{
+		if ( !interests.isEmpty() )
+		{
+			double oldPower = lastStoredPower;
+			lastStoredPower = getStoredPower();
+
+			EnergyThreshold low = new EnergyThreshold( Math.min( oldPower, lastStoredPower ), null );
+			EnergyThreshold high = new EnergyThreshold( Math.max( oldPower, lastStoredPower ), null );
+			for (EnergyThreshold th : interests.subSet( low, true, high, true ))
+			{
+				((EnergyWatcher) th.watcher).post( this );
+			}
+		}
+
+		avgDrainPerTick *= (AvgLength - 1) / AvgLength;
+		avgInjectionPerTick *= (AvgLength - 1) / AvgLength;
+
+		avgDrainPerTick += tickDrainPerTick / AvgLength;
+		avgInjectionPerTick += tickInjectionPerTick / AvgLength;
+
+		tickDrainPerTick = 0;
+		tickInjectionPerTick = 0;
+
+		// power information.
+		boolean currentlyHasPower = false;
+
+		if ( drainPerTick > 0.0001 )
+		{
+			double drained = extractAEPower( getIdlePowerUsage(), Actionable.MODULATE, PowerMultiplier.CONFIG );
+			currentlyHasPower = drained >= drainPerTick - 0.001;
+		}
+		else
+		{
+			currentlyHasPower = extractAEPower( 0.1, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > 0;
+		}
+
+		// ticks since change..
+		if ( currentlyHasPower == hasPower )
+			ticksSinceHasPowerChange++;
+		else
+			ticksSinceHasPowerChange = 0;
+
+		// update status..
+		hasPower = currentlyHasPower;
+
+		// update public status, this buffers power ups for 30 ticks.
+		if ( hasPower && ticksSinceHasPowerChange > 30 )
+			publicPowerState( true, myGrid );
+		else if ( !hasPower )
+			publicPowerState( false, myGrid );
+
+		availableTicksSinceUpdate++;
+	}
+
+	private void publicPowerState(boolean newState, IGrid grid)
+	{
+		if ( publicHasPower == newState )
+			return;
+
+		publicHasPower = newState;
+		((Grid) myGrid).setImportantFlag( 0, publicHasPower );
+		grid.postEvent( new MENetworkPowerStatusChange() );
+	}
+
+	/**
+	 * refresh current stored power.
+	 */
+	public void refreshPower()
+	{
+		availableTicksSinceUpdate = 0;
+		globalAvailablePower = 0;
+		for (IAEPowerStorage p : providers)
+			globalAvailablePower += p.getAECurrentPower();
+	}
+
+	@Override
+	public double getStoredPower()
+	{
+		if ( availableTicksSinceUpdate > 90 )
+			refreshPower();
+
+		return Math.max( 0.0, globalAvailablePower );
+	}
+
+	@Override
+	public double getMaxStoredPower()
+	{
+		return globalMaxPower;
+	}
+
+	@Override
+	public double extractAEPower(double amt, Actionable mode, Set<IEnergyGrid> seen)
+	{
+		if ( !seen.add( this ) )
+			return 0;
+
+		double extractedPower = extra;
+
+		if ( mode == Actionable.SIMULATE )
+		{
+			extractedPower += simulateExtract( extractedPower, amt );
+
+			if ( extractedPower < amt )
+			{
+				Iterator<IEnergyGridProvider> i = gproviders.iterator();
+				while (extractedPower < amt && i.hasNext())
+					extractedPower += i.next().extractAEPower( amt - extractedPower, mode, seen );
+			}
+
+			return extractedPower;
+		}
+		else
+		{
+			extra = 0;
+			extractedPower = doExtract( extractedPower, amt );
+		}
+
+		// got more then we wanted?
+		if ( extractedPower > amt )
+		{
+			extra = extractedPower - amt;
+			globalAvailablePower -= amt;
+
+			tickDrainPerTick += amt;
+			return amt;
+		}
+
+		if ( extractedPower < amt )
+		{
+			Iterator<IEnergyGridProvider> i = gproviders.iterator();
+			while (extractedPower < amt && i.hasNext())
+				extractedPower += i.next().extractAEPower( amt - extractedPower, mode, seen );
+		}
+
+		// go less or the correct amount?
+		globalAvailablePower -= extractedPower;
+		tickDrainPerTick += extractedPower;
+		return extractedPower;
+	}
+
+	private double doExtract(double extractedPower, double amt)
+	{
+		while (extractedPower < amt && !providers.isEmpty())
+		{
+			IAEPowerStorage node = getFirstProvider();
+
+			double req = amt - extractedPower;
+			double newPower = node.extractAEPower( req, Actionable.MODULATE, PowerMultiplier.ONE );
+			extractedPower += newPower;
+
+			if ( newPower < req )
+			{
+				providers.remove( node );
+				lastProvider = null;
+			}
+		}
+
+		// totalDrainPastTicks[0] += extractedPower;
+		return extractedPower;
+	}
+
+	private double simulateExtract(double extractedPower, double amt)
+	{
+		Iterator<IAEPowerStorage> it = providers.iterator();
+
+		while (extractedPower < amt && it.hasNext())
+		{
+			IAEPowerStorage node = it.next();
+
+			double req = amt - extractedPower;
+			double newPower = node.extractAEPower( req, Actionable.SIMULATE, PowerMultiplier.ONE );
+			extractedPower += newPower;
+		}
+
+		return extractedPower;
+	}
+
+	@Override
+	public boolean isNetworkPowered()
+	{
+		return publicHasPower;
+	}
+
+	@Override
+	public double getIdlePowerUsage()
+	{
+		return drainPerTick + pgc.channelPowerUsage;
+	}
+
+	@Override
+	public double getAvgPowerUsage()
+	{
+		return avgDrainPerTick;
+	}
+
+	@Override
+	public double getAvgPowerInjection()
+	{
+		return avgInjectionPerTick;
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+		extra /= 2;
+		storageB.dataObject().setDouble( "extraEnergy", extra );
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+		extra += storageB.dataObject().getDouble( "extraEnergy" );
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+		storage.dataObject().setDouble( "extraEnergy", this.extra );
+	}
+
+}

src/main/java/appeng/me/cache/GridStorageCache.java

@@ -0,0 +1,351 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import appeng.api.AEApi;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.events.MENetworkCellArrayUpdate;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.networking.security.ISecurityGrid;
+import appeng.api.networking.security.MachineSource;
+import appeng.api.networking.storage.IStackWatcher;
+import appeng.api.networking.storage.IStackWatcherHost;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.ICellContainer;
+import appeng.api.storage.ICellProvider;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
+import appeng.me.helpers.GenericInterestManager;
+import appeng.me.storage.ItemWatcher;
+import appeng.me.storage.NetworkInventoryHandler;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.SetMultimap;
+
+public class GridStorageCache implements IStorageGrid
+{
+
+	final private SetMultimap<IAEStack, ItemWatcher> interests = HashMultimap.create();
+	final public GenericInterestManager interestManager = new GenericInterestManager( interests );
+
+	final HashSet<ICellProvider> activeCellProviders = new HashSet();
+	final HashSet<ICellProvider> inactiveCellProviders = new HashSet();
+	final public IGrid myGrid;
+
+	private NetworkInventoryHandler<IAEItemStack> myItemNetwork;
+	private NetworkMonitor<IAEItemStack> itemMonitor = new NetworkMonitor<IAEItemStack>( this, StorageChannel.ITEMS );
+
+	private NetworkInventoryHandler<IAEFluidStack> myFluidNetwork;
+	private NetworkMonitor<IAEFluidStack> fluidMonitor = new NetworkMonitor<IAEFluidStack>( this, StorageChannel.FLUIDS );
+
+	private HashMap<IGridNode, IStackWatcher> watchers = new HashMap<IGridNode, IStackWatcher>();
+
+	public GridStorageCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+		itemMonitor.onTick();
+		fluidMonitor.onTick();
+	}
+
+	private class CellChangeTrackerRecord
+	{
+
+		final StorageChannel channel;
+		final int up_or_down;
+		final IItemList list;
+		final BaseActionSource src;
+
+		public CellChangeTrackerRecord(StorageChannel channel, int i, IMEInventoryHandler<? extends IAEStack> h, BaseActionSource actionSrc) {
+			this.channel = channel;
+			this.up_or_down = i;
+			this.src = actionSrc;
+
+			if ( channel == StorageChannel.ITEMS )
+				this.list = ((IMEInventoryHandler<IAEItemStack>) h).getAvailableItems( AEApi.instance().storage().createItemList() );
+			else if ( channel == StorageChannel.FLUIDS )
+				this.list = ((IMEInventoryHandler<IAEFluidStack>) h).getAvailableItems( AEApi.instance().storage().createFluidList() );
+			else
+				this.list = null;
+		}
+
+		public void applyChanges()
+		{
+			postChangesToNetwork( channel, up_or_down, list, src );
+		}
+
+	};
+
+	private class CellChangeTracker
+	{
+
+		List<CellChangeTrackerRecord> data = new LinkedList();
+
+		public void postChanges(StorageChannel channel, int i, IMEInventoryHandler<? extends IAEStack> h, BaseActionSource actionSrc)
+		{
+			data.add( new CellChangeTrackerRecord( channel, i, h, actionSrc ) );
+		}
+
+		public void applyChanges()
+		{
+			for (CellChangeTrackerRecord rec : data)
+				rec.applyChanges();
+		}
+	};
+
+	@Override
+	public void registerCellProvider(ICellProvider provider)
+	{
+		inactiveCellProviders.add( provider );
+		addCellProvider( provider, new CellChangeTracker() ).applyChanges();
+	}
+
+	@Override
+	public void unregisterCellProvider(ICellProvider provider)
+	{
+		removeCellProvider( provider, new CellChangeTracker() ).applyChanges();
+		inactiveCellProviders.remove( provider );
+	}
+
+	public CellChangeTracker addCellProvider(ICellProvider cc, CellChangeTracker tracker)
+	{
+		if ( inactiveCellProviders.contains( cc ) )
+		{
+			inactiveCellProviders.remove( cc );
+			activeCellProviders.add( cc );
+
+			BaseActionSource actionSrc = new BaseActionSource();
+			if ( cc instanceof IActionHost )
+				actionSrc = new MachineSource( (IActionHost) cc );
+
+			for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( StorageChannel.ITEMS ))
+			{
+				tracker.postChanges( StorageChannel.ITEMS, 1, h, actionSrc );
+			}
+
+			for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( StorageChannel.FLUIDS ))
+			{
+				tracker.postChanges( StorageChannel.FLUIDS, 1, h, actionSrc );
+			}
+		}
+
+		return tracker;
+	}
+
+	public CellChangeTracker removeCellProvider(ICellProvider cc, CellChangeTracker tracker)
+	{
+		if ( activeCellProviders.contains( cc ) )
+		{
+			inactiveCellProviders.add( cc );
+			activeCellProviders.remove( cc );
+
+			BaseActionSource actionSrc = new BaseActionSource();
+			if ( cc instanceof IActionHost )
+				actionSrc = new MachineSource( (IActionHost) cc );
+
+			for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( StorageChannel.ITEMS ))
+			{
+				tracker.postChanges( StorageChannel.ITEMS, -1, h, actionSrc );
+			}
+
+			for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( StorageChannel.FLUIDS ))
+			{
+				tracker.postChanges( StorageChannel.FLUIDS, -1, h, actionSrc );
+			}
+		}
+
+		return tracker;
+	}
+
+	@MENetworkEventSubscribe
+	public void cellUpdate(MENetworkCellArrayUpdate ev)
+	{
+		myItemNetwork = null;
+		myFluidNetwork = null;
+
+		LinkedList<ICellProvider> ll = new LinkedList();
+		ll.addAll( inactiveCellProviders );
+		ll.addAll( activeCellProviders );
+
+		CellChangeTracker tracker = new CellChangeTracker();
+
+		for (ICellProvider cc : ll)
+		{
+			boolean Active = true;
+
+			if ( cc instanceof IActionHost )
+			{
+				IGridNode node = ((IActionHost) cc).getActionableNode();
+				if ( node != null && node.isActive() )
+					Active = true;
+				else
+					Active = false;
+			}
+
+			if ( Active )
+				addCellProvider( cc, tracker );
+			else
+				removeCellProvider( cc, tracker );
+		}
+
+		itemMonitor.forceUpdate();
+		fluidMonitor.forceUpdate();
+
+		tracker.applyChanges();
+	}
+
+	@Override
+	public void removeNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof ICellContainer )
+		{
+			ICellContainer cc = (ICellContainer) machine;
+
+			myGrid.postEvent( new MENetworkCellArrayUpdate() );
+			removeCellProvider( cc, new CellChangeTracker() ).applyChanges();
+			inactiveCellProviders.remove( cc );
+		}
+
+		if ( machine instanceof IStackWatcherHost )
+		{
+			IStackWatcher myWatcher = watchers.get( machine );
+			if ( myWatcher != null )
+			{
+				myWatcher.clear();
+				watchers.remove( machine );
+			}
+		}
+	}
+
+	@Override
+	public void addNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof ICellContainer )
+		{
+			ICellContainer cc = (ICellContainer) machine;
+			inactiveCellProviders.add( cc );
+
+			myGrid.postEvent( new MENetworkCellArrayUpdate() );
+			if ( node.isActive() )
+				addCellProvider( cc, new CellChangeTracker() ).applyChanges();
+		}
+
+		if ( machine instanceof IStackWatcherHost )
+		{
+			IStackWatcherHost swh = (IStackWatcherHost) machine;
+			ItemWatcher iw = new ItemWatcher( this, (IStackWatcherHost) swh );
+			watchers.put( node, iw );
+			swh.updateWatcher( iw );
+		}
+	}
+
+	private void buildNetworkStorage(StorageChannel chan)
+	{
+		SecurityCache security = myGrid.getCache( ISecurityGrid.class );
+
+		switch (chan)
+		{
+		case FLUIDS:
+			myFluidNetwork = new NetworkInventoryHandler<IAEFluidStack>( StorageChannel.FLUIDS, security );
+			for (ICellProvider cc : activeCellProviders)
+			{
+				for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( chan ))
+					myFluidNetwork.addNewStorage( h );
+			}
+			break;
+		case ITEMS:
+			myItemNetwork = new NetworkInventoryHandler<IAEItemStack>( StorageChannel.ITEMS, security );
+			for (ICellProvider cc : activeCellProviders)
+			{
+				for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( chan ))
+					myItemNetwork.addNewStorage( h );
+			}
+			break;
+		default:
+		}
+	}
+
+	private void postChangesToNetwork(StorageChannel chan, int up_or_down, IItemList availableItems, BaseActionSource src)
+	{
+		switch (chan)
+		{
+		case FLUIDS:
+			fluidMonitor.postChange( up_or_down > 0, (IItemList<IAEFluidStack>) availableItems, src );
+			break;
+		case ITEMS:
+			itemMonitor.postChange( up_or_down > 0, (IItemList<IAEItemStack>) availableItems, src );
+			break;
+		default:
+		}
+	}
+
+	public IMEInventoryHandler<IAEItemStack> getItemInventoryHandler()
+	{
+		if ( myItemNetwork == null )
+			buildNetworkStorage( StorageChannel.ITEMS );
+		return myItemNetwork;
+	}
+
+	public IMEInventoryHandler<IAEFluidStack> getFluidInventoryHandler()
+	{
+		if ( myFluidNetwork == null )
+			buildNetworkStorage( StorageChannel.FLUIDS );
+		return myFluidNetwork;
+	}
+
+	@Override
+	public void postAlterationOfStoredItems(StorageChannel chan, Iterable<? extends IAEStack> input, BaseActionSource src)
+	{
+		if ( chan == StorageChannel.ITEMS )
+			itemMonitor.postChange( true, (Iterable<IAEItemStack>) input, src );
+		else if ( chan == StorageChannel.FLUIDS )
+			fluidMonitor.postChange( true, (Iterable<IAEFluidStack>) input, src );
+	}
+
+	@Override
+	public IMEMonitor<IAEFluidStack> getFluidInventory()
+	{
+		return fluidMonitor;
+	}
+
+	@Override
+	public IMEMonitor<IAEItemStack> getItemInventory()
+	{
+		return itemMonitor;
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

src/main/java/appeng/me/cache/NetworkMonitor.java

@@ -0,0 +1,126 @@
+package appeng.me.cache;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import appeng.api.networking.events.MENetworkStorageEvent;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.IMEMonitorHandlerReceiver;
+import appeng.api.storage.MEMonitorHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
+import appeng.me.storage.ItemWatcher;
+
+public class NetworkMonitor<T extends IAEStack<T>> extends MEMonitorHandler<T>
+{
+
+	final private GridStorageCache myGridCache;
+	final private StorageChannel myChannel;
+
+	boolean sendEvent = false;
+
+	public void forceUpdate()
+	{
+		hasChanged = true;
+
+		Iterator<Entry<IMEMonitorHandlerReceiver<T>, Object>> i = getListeners();
+		while (i.hasNext())
+		{
+			Entry<IMEMonitorHandlerReceiver<T>, Object> o = i.next();
+			IMEMonitorHandlerReceiver<T> recv = o.getKey();
+
+			if ( recv.isValid( o.getValue() ) )
+				recv.onListUpdate();
+			else
+				i.remove();
+		}
+	}
+
+	public NetworkMonitor(GridStorageCache cache, StorageChannel chan) {
+		super( null, chan );
+		myGridCache = cache;
+		myChannel = chan;
+	}
+
+	final static public LinkedList depth = new LinkedList();
+	
+	@Override
+	protected void postChangesToListeners(Iterable<T> changes, BaseActionSource src)
+	{
+		postChange( true, changes, src );
+	}
+	
+	protected void postChange(boolean Add, Iterable<T> changes, BaseActionSource src)
+	{
+		if ( depth.contains( this ) )
+			return;
+
+		depth.push( this );
+
+		sendEvent = true;
+		notifyListenersOfChange( changes, src );
+
+		IItemList<T> myStorageList = getStorageList();
+
+		for (T changedItem : changes)
+		{
+			T difference = changedItem;
+
+			if ( !Add && changedItem != null )
+				(difference = changedItem.copy()).setStackSize( -changedItem.getStackSize() );
+
+			if ( myGridCache.interestManager.containsKey( changedItem ) )
+			{
+				Set<ItemWatcher> list = myGridCache.interestManager.get( changedItem );
+				if ( !list.isEmpty() )
+				{
+					IAEStack fullStack = myStorageList.findPrecise( changedItem );
+					if ( fullStack == null )
+					{
+						fullStack = changedItem.copy();
+						fullStack.setStackSize( 0 );
+					}
+
+					myGridCache.interestManager.enableTransactions();
+
+					for (ItemWatcher iw : list)
+						iw.getHost().onStackChange( myStorageList, fullStack, difference, src, getChannel() );
+
+					myGridCache.interestManager.disableTransactions();
+				}
+			}
+		}
+
+		Object last = depth.pop();
+		if ( last != this )
+			throw new RuntimeException( "Invalid Access to Networked Storage API detected." );
+	}
+
+	public void onTick()
+	{
+		if ( sendEvent )
+		{
+			sendEvent = false;
+			myGridCache.myGrid.postEvent( new MENetworkStorageEvent( this, myChannel ) );
+		}
+	}
+
+	@Override
+	protected IMEInventoryHandler getHandler()
+	{
+		switch (myChannel)
+		{
+		case ITEMS:
+			return myGridCache.getItemInventoryHandler();
+		case FLUIDS:
+			return myGridCache.getFluidInventoryHandler();
+		default:
+		}
+		return null;
+	}
+
+}

src/main/java/appeng/me/cache/P2PCache.java

@@ -0,0 +1,186 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridCache;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.ticking.ITickManager;
+import appeng.me.cache.helpers.TunnelCollection;
+import appeng.parts.p2p.PartP2PTunnel;
+import appeng.parts.p2p.PartP2PTunnelME;
+
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+
+public class P2PCache implements IGridCache
+{
+
+	final private HashMap<Long, PartP2PTunnel> inputs = new HashMap();
+	final private Multimap<Long, PartP2PTunnel> outputs = LinkedHashMultimap.create();
+	final private TunnelCollection NullColl = new TunnelCollection<PartP2PTunnel>( null, null );
+
+	final IGrid myGrid;
+
+	public P2PCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@MENetworkEventSubscribe
+	public void bootComplete(MENetworkBootingStatusChange bootstat)
+	{
+		ITickManager tm = myGrid.getCache( ITickManager.class );
+		for (PartP2PTunnel me : inputs.values())
+		{
+			if ( me instanceof PartP2PTunnelME )
+				tm.wakeDevice( me.getGridNode() );
+		}
+	}
+
+	@MENetworkEventSubscribe
+	public void bootComplete(MENetworkPowerStatusChange power)
+	{
+		ITickManager tm = myGrid.getCache( ITickManager.class );
+		for (PartP2PTunnel me : inputs.values())
+		{
+			if ( me instanceof PartP2PTunnelME )
+				tm.wakeDevice( me.getGridNode() );
+		}
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+
+	}
+
+	public void updateFreq(PartP2PTunnel t, long NewFreq)
+	{
+		if ( outputs.containsValue( t ) )
+			outputs.remove( t.freq, t );
+
+		if ( inputs.containsValue( t ) )
+			inputs.remove( t.freq );
+
+		t.freq = NewFreq;
+
+		if ( t.output )
+			outputs.put( t.freq, t );
+		else
+			inputs.put( t.freq, t );
+
+		// AELog.info( "update-" + (t.output ? "output: " : "input: ") + t.freq
+		// );
+		updateTunnel( t.freq, t.output, true );
+		updateTunnel( t.freq, !t.output, true );
+	}
+
+	@Override
+	public void addNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof PartP2PTunnel )
+		{
+			if ( machine instanceof PartP2PTunnelME )
+			{
+				if ( !node.hasFlag( GridFlags.REQUIRE_CHANNEL ) )
+					return;
+			}
+
+			PartP2PTunnel t = (PartP2PTunnel) machine;
+			// AELog.info( "add-" + (t.output ? "output: " : "input: ") + t.freq
+			// );
+
+			if ( t.output )
+				outputs.put( t.freq, t );
+			else
+				inputs.put( t.freq, t );
+
+			updateTunnel( t.freq, !t.output, false );
+		}
+	}
+
+	@Override
+	public void removeNode(IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof PartP2PTunnel )
+		{
+			if ( machine instanceof PartP2PTunnelME )
+			{
+				if ( !node.hasFlag( GridFlags.REQUIRE_CHANNEL ) )
+					return;
+			}
+
+			PartP2PTunnel t = (PartP2PTunnel) machine;
+			// AELog.info( "rmv-" + (t.output ? "output: " : "input: ") + t.freq
+			// );
+
+			if ( t.output )
+				outputs.remove( t.freq, t );
+			else
+				inputs.remove( t.freq );
+
+			updateTunnel( t.freq, !t.output, false );
+		}
+	}
+
+	private void updateTunnel(long freq, boolean updateOutputs, boolean configChange)
+	{
+		for (PartP2PTunnel p : outputs.get( freq ))
+		{
+			if ( configChange )
+				p.onTunnelConfigChange();
+			p.onTunnelNetworkChange();
+		}
+
+		PartP2PTunnel in = inputs.get( freq );
+		if ( in != null )
+		{
+			if ( configChange )
+				in.onTunnelConfigChange();
+			in.onTunnelNetworkChange();
+		}
+	}
+
+	public TunnelCollection<PartP2PTunnel> getOutputs(long freq, Class<? extends PartP2PTunnel> c)
+	{
+		PartP2PTunnel in = inputs.get( freq );
+		if ( in == null )
+			return NullColl;
+
+		TunnelCollection<PartP2PTunnel> out = inputs.get( freq ).getCollection( outputs.get( freq ), c );
+		if ( out == null )
+			return NullColl;
+
+		return out;
+	}
+
+	public PartP2PTunnel getInput(long freq)
+	{
+		return inputs.get( freq );
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

src/main/java/appeng/me/cache/PathGridCache.java

@@ -0,0 +1,379 @@
+package appeng.me.cache;
+
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import net.minecraftforge.common.util.ForgeDirection;
+import appeng.api.networking.GridFlags;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridBlock;
+import appeng.api.networking.IGridConnection;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridMultiblock;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkChannelChanged;
+import appeng.api.networking.events.MENetworkControllerChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.pathing.ControllerState;
+import appeng.api.networking.pathing.IPathingGrid;
+import appeng.api.util.DimensionalCoord;
+import appeng.core.AEConfig;
+import appeng.core.features.AEFeature;
+import appeng.core.stats.Achievements;
+import appeng.me.GridConnection;
+import appeng.me.GridNode;
+import appeng.me.pathfinding.AdHocChannelUpdater;
+import appeng.me.pathfinding.ControllerChannelUpdater;
+import appeng.me.pathfinding.ControllerValidator;
+import appeng.me.pathfinding.IPathItem;
+import appeng.me.pathfinding.PathSegment;
+import appeng.tile.networking.TileController;
+import appeng.util.Platform;
+
+public class PathGridCache implements IPathingGrid
+{
+
+	boolean recalculateControllerNextTick = true;
+	boolean updateNetwork = true;
+	boolean booting = false;
+
+	final LinkedList<PathSegment> active = new LinkedList();
+
+	ControllerState controllerState = ControllerState.NO_CONTROLLER;
+
+	int instance = Integer.MIN_VALUE;
+
+	int ticksUntilReady = 20;
+	public int channelsInUse = 0;
+	int lastChannels = 0;
+
+	final Set<TileController> controllers = new HashSet();
+	final Set<IGridNode> requireChannels = new HashSet();
+	final Set<IGridNode> blockDense = new HashSet();
+
+	final IGrid myGrid;
+	private HashSet<IPathItem> semiOpen = new HashSet();
+	private HashSet<IPathItem> closedList = new HashSet();
+
+	public int channelsByBlocks = 0;
+	public double channelPowerUsage = 0.0;
+
+	public PathGridCache(IGrid g)
+	{
+		myGrid = g;
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+		if ( recalculateControllerNextTick )
+		{
+			recalcController();
+		}
+
+		if ( updateNetwork )
+		{
+			if ( !booting )
+				myGrid.postEvent( new MENetworkBootingStatusChange() );
+
+			booting = true;
+			updateNetwork = false;
+			instance++;
+			channelsInUse = 0;
+
+			if ( !AEConfig.instance.isFeatureEnabled( AEFeature.Channels ) )
+			{
+				int used = calculateRequiredChannels();
+
+				int nodes = myGrid.getNodes().size();
+				ticksUntilReady = 20 + Math.max( 0, nodes / 100 - 20 );
+				channelsByBlocks = nodes * used;
+				channelPowerUsage = (double) channelsByBlocks / 128.0;
+
+				myGrid.getPivot().beginVisit( new AdHocChannelUpdater( used ) );
+			}
+			else if ( controllerState == ControllerState.NO_CONTROLLER )
+			{
+				int requiredChannels = calculateRequiredChannels();
+				int used = requiredChannels;
+				if ( requiredChannels > 8 )
+					used = 0;
+
+				int nodes = myGrid.getNodes().size();
+				channelsInUse = used;
+
+				ticksUntilReady = 20 + Math.max( 0, nodes / 100 - 20 );
+				channelsByBlocks = nodes * used;
+				channelPowerUsage = (double) channelsByBlocks / 128.0;
+
+				myGrid.getPivot().beginVisit( new AdHocChannelUpdater( used ) );
+			}
+			else if ( controllerState == ControllerState.CONTROLLER_CONFLICT )
+			{
+				ticksUntilReady = 20;
+				myGrid.getPivot().beginVisit( new AdHocChannelUpdater( 0 ) );
+			}
+			else
+			{
+				int nodes = myGrid.getNodes().size();
+				ticksUntilReady = 20 + Math.max( 0, nodes / 100 - 20 );
+				closedList = new HashSet();
+				semiOpen = new HashSet();
+
+				// myGrid.getPivot().beginVisit( new AdHocChannelUpdater( 0 )
+				// );
+				for (IGridNode node : myGrid.getMachines( TileController.class ))
+				{
+					closedList.add( (IPathItem) node );
+					for (IGridConnection gcc : node.getConnections())
+					{
+						GridConnection gc = (GridConnection) gcc;
+						if ( !(gc.getOtherSide( node ).getMachine() instanceof TileController) )
+						{
+							List open = new LinkedList();
+							closedList.add( gc );
+							open.add( gc );
+							gc.setControllerRoute( (GridNode) node, true );
+							active.add( new PathSegment( this, open, semiOpen, closedList ) );
+						}
+					}
+				}
+			}
+		}
+
+		if ( !active.isEmpty() || ticksUntilReady > 0 )
+		{
+			Iterator<PathSegment> i = active.iterator();
+			while (i.hasNext())
+			{
+				PathSegment pat = i.next();
+				if ( pat.step() )
+				{
+					pat.isDead = true;
+					i.remove();
+				}
+			}
+
+			ticksUntilReady--;
+
+			if ( active.isEmpty() && ticksUntilReady <= 0 )
+			{
+				if ( controllerState == ControllerState.CONTROLLER_ONLINE )
+				{
+					for (TileController tc : controllers)
+					{
+						tc.getGridNode( ForgeDirection.UNKNOWN ).beginVisit( new ControllerChannelUpdater() );
+						break;
+					}
+				}
+
+				// check for achievements
+				achievementPost();
+
+				booting = false;
+				channelPowerUsage = (double) channelsByBlocks / 128.0;
+				myGrid.postEvent( new MENetworkBootingStatusChange() );
+			}
+		}
+	}
+
+	private void achievementPost()
+	{
+		if ( lastChannels != channelsInUse && AEConfig.instance.isFeatureEnabled( AEFeature.Channels ) )
+		{
+			Achievements currentBracket = getAchievementBracket( channelsInUse );
+			Achievements lastBracket = getAchievementBracket( lastChannels );
+			if ( currentBracket != lastBracket && currentBracket != null )
+			{
+				Set<Integer> players = new HashSet();
+				for (IGridNode n : requireChannels)
+					players.add( n.getPlayerID() );
+
+				for (int id : players)
+				{
+					Platform.addStat( id, currentBracket.getAchievement() );
+				}
+			}
+		}
+		lastChannels = channelsInUse;
+	}
+
+	private Achievements getAchievementBracket(int ch)
+	{
+		if ( ch < 8 )
+			return null;
+
+		if ( ch < 128 )
+			return Achievements.Networking1;
+
+		if ( ch < 2048 )
+			return Achievements.Networking2;
+
+		return Achievements.Networking3;
+	}
+
+	private int calculateRequiredChannels()
+	{
+		int depth = 0;
+		semiOpen.clear();
+
+		for (IGridNode nodes : requireChannels)
+		{
+			if ( !semiOpen.contains( nodes ) )
+			{
+				IGridBlock gb = nodes.getGridBlock();
+				EnumSet<GridFlags> flags = gb.getFlags();
+
+				if ( flags.contains( GridFlags.COMPRESSED_CHANNEL ) && !blockDense.isEmpty() )
+					return 9;
+
+				depth++;
+
+				if ( flags.contains( GridFlags.MULTIBLOCK ) )
+				{
+					IGridMultiblock gmb = (IGridMultiblock) gb;
+					Iterator<IGridNode> i = gmb.getMultiblockNodes();
+					while (i.hasNext())
+						semiOpen.add( (IPathItem) i.next() );
+				}
+			}
+		}
+
+		return depth;
+	}
+
+	@Override
+	public void repath()
+	{
+		// clean up...
+		active.clear();
+
+		channelsByBlocks = 0;
+		updateNetwork = true;
+	}
+
+	@Override
+	public void removeNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof TileController )
+		{
+			controllers.remove( machine );
+			recalculateControllerNextTick = true;
+		}
+
+		EnumSet<GridFlags> flags = gridNode.getGridBlock().getFlags();
+
+		if ( flags.contains( GridFlags.REQUIRE_CHANNEL ) )
+			requireChannels.remove( gridNode );
+
+		if ( flags.contains( GridFlags.CANNOT_CARRY_COMPRESSED ) )
+			blockDense.remove( gridNode );
+
+		repath();
+	}
+
+	@Override
+	public void addNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof TileController )
+		{
+			controllers.add( (TileController) machine );
+			recalculateControllerNextTick = true;
+		}
+
+		EnumSet<GridFlags> flags = gridNode.getGridBlock().getFlags();
+
+		if ( flags.contains( GridFlags.REQUIRE_CHANNEL ) )
+			requireChannels.add( gridNode );
+
+		if ( flags.contains( GridFlags.CANNOT_CARRY_COMPRESSED ) )
+			blockDense.add( gridNode );
+
+		repath();
+	}
+
+	@MENetworkEventSubscribe
+	void updateNodReq(MENetworkChannelChanged ev)
+	{
+		IGridNode gridNode = ev.node;
+
+		if ( gridNode.getGridBlock().getFlags().contains( GridFlags.REQUIRE_CHANNEL ) )
+			requireChannels.add( gridNode );
+		else
+			requireChannels.remove( gridNode );
+
+		repath();
+	}
+
+	private void recalcController()
+	{
+		recalculateControllerNextTick = false;
+		ControllerState old = controllerState;
+
+		if ( controllers.isEmpty() )
+		{
+			controllerState = ControllerState.NO_CONTROLLER;
+		}
+		else
+		{
+			IGridNode startingNode = controllers.iterator().next().getGridNode( ForgeDirection.UNKNOWN );
+			if ( startingNode == null )
+			{
+				controllerState = ControllerState.CONTROLLER_CONFLICT;
+				return;
+			}
+
+			DimensionalCoord dc = startingNode.getGridBlock().getLocation();
+			ControllerValidator cv = new ControllerValidator( dc.x, dc.y, dc.z );
+
+			startingNode.beginVisit( cv );
+
+			if ( cv.isValid && cv.found == controllers.size() )
+				controllerState = ControllerState.CONTROLLER_ONLINE;
+			else
+				controllerState = ControllerState.CONTROLLER_CONFLICT;
+		}
+
+		if ( old != controllerState )
+		{
+			myGrid.postEvent( new MENetworkControllerChange() );
+		}
+	}
+
+	@Override
+	public ControllerState getControllerState()
+	{
+		return controllerState;
+	}
+
+	@Override
+	public boolean isNetworkBooting()
+	{
+		return !active.isEmpty() && booting == false;
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

src/main/java/appeng/me/cache/SecurityCache.java

@@ -0,0 +1,153 @@
+package appeng.me.cache;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import appeng.api.config.SecurityPermissions;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridCache;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkSecurityChange;
+import appeng.api.networking.security.ISecurityGrid;
+import appeng.api.networking.security.ISecurityProvider;
+import appeng.core.WorldSettings;
+import appeng.me.GridNode;
+
+public class SecurityCache implements IGridCache, ISecurityGrid
+{
+
+	final private List<ISecurityProvider> securityProvider = new ArrayList();
+	final private HashMap<Integer, EnumSet<SecurityPermissions>> playerPerms = new HashMap<Integer, EnumSet<SecurityPermissions>>();
+
+	public SecurityCache(IGrid g) {
+		myGrid = g;
+	}
+
+	private long securityKey = -1;
+	public final IGrid myGrid;
+
+	@MENetworkEventSubscribe
+	public void updatePermissions(MENetworkSecurityChange ev)
+	{
+		playerPerms.clear();
+		if ( securityProvider.isEmpty() )
+			return;
+
+		securityProvider.get( 0 ).readPermissions( playerPerms );
+	}
+
+	public long getSecurityKey()
+	{
+		return securityKey;
+	}
+
+	@Override
+	public boolean isAvailable()
+	{
+		return securityProvider.size() == 1 && securityProvider.get( 0 ).isSecurityEnabled();
+	}
+
+	@Override
+	public boolean hasPermission(EntityPlayer player, SecurityPermissions perm)
+	{
+		return hasPermission( player == null ? -1 : WorldSettings.getInstance().getPlayerID( player.getGameProfile() ), perm );
+	}
+
+	@Override
+	public boolean hasPermission(int playerID, SecurityPermissions perm)
+	{
+		if ( isAvailable() )
+		{
+			EnumSet<SecurityPermissions> perms = playerPerms.get( playerID );
+
+			if ( perms == null )
+			{
+				if ( playerID == -1 ) // no default?
+					return false;
+				else
+					return hasPermission( -1, perm );
+			}
+
+			return perms.contains( perm );
+		}
+		return true;
+	}
+
+	private void updateSecurityKey()
+	{
+		long lastCode = securityKey;
+
+		if ( securityProvider.size() == 1 )
+			securityKey = securityProvider.get( 0 ).getSecurityKey();
+		else
+			securityKey = -1;
+
+		if ( lastCode != securityKey )
+		{
+			myGrid.postEvent( new MENetworkSecurityChange() );
+			for (IGridNode n : myGrid.getNodes())
+				((GridNode) n).lastSecurityKey = securityKey;
+		}
+	}
+
+	@Override
+	public void removeNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof ISecurityProvider )
+		{
+			securityProvider.remove( (ISecurityProvider) machine );
+			updateSecurityKey();
+		}
+	}
+
+	@Override
+	public void addNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof ISecurityProvider )
+		{
+			securityProvider.add( (ISecurityProvider) machine );
+			updateSecurityKey();
+		}
+		else
+			((GridNode) gridNode).lastSecurityKey = securityKey;
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+
+	}
+
+	@Override
+	public void onSplit(IGridStorage destinationStorage)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage sourceStorage)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage destinationStorage)
+	{
+
+	}
+
+	@Override
+	public int getOwner()
+	{
+		if ( isAvailable() )
+			return securityProvider.get( 0 ).getOwner();
+		return -1;
+	}
+
+}

src/main/java/appeng/me/cache/SpatialPylonCache.java

@@ -0,0 +1,232 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridCache;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.spatial.ISpatialCache;
+import appeng.api.util.DimensionalCoord;
+import appeng.api.util.IReadOnlyCollection;
+import appeng.core.AEConfig;
+import appeng.me.cluster.implementations.SpatialPylonCluster;
+import appeng.tile.spatial.TileSpatialIOPort;
+import appeng.tile.spatial.TileSpatialPylon;
+
+public class SpatialPylonCache implements IGridCache, ISpatialCache
+{
+
+	long powerRequired = 0;
+	double efficiency = 0.0;
+
+	DimensionalCoord captureMin;
+	DimensionalCoord captureMax;
+	boolean isValid = false;
+
+	List<TileSpatialIOPort> ioPorts = new LinkedList();
+	HashMap<SpatialPylonCluster, SpatialPylonCluster> clusters = new HashMap();
+
+	boolean needsUpdate = false;
+
+	final IGrid myGrid;
+
+	public SpatialPylonCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@Override
+	public long requiredPower()
+	{
+		return powerRequired;
+	}
+
+	@Override
+	public boolean hasRegion()
+	{
+		return captureMin != null;
+	}
+
+	@Override
+	public boolean isValidRegion()
+	{
+		return hasRegion() && isValid;
+	}
+
+	@Override
+	public DimensionalCoord getMin()
+	{
+		return captureMin;
+	}
+
+	@Override
+	public DimensionalCoord getMax()
+	{
+		return captureMax;
+	}
+
+	public void reset(IGrid grid)
+	{
+		int reqX = 0;
+		int reqY = 0;
+		int reqZ = 0;
+		int requirePylonBlocks = 1;
+
+		double minPower = 0;
+		double maxPower = 0;
+
+		clusters = new HashMap();
+		ioPorts = new LinkedList();
+
+		for (IGridNode gm : grid.getMachines( TileSpatialIOPort.class ))
+		{
+			ioPorts.add( (TileSpatialIOPort) gm.getMachine() );
+		}
+
+		IReadOnlyCollection<IGridNode> set = grid.getMachines( TileSpatialPylon.class );
+		for (IGridNode gm : set)
+		{
+			if ( gm.meetsChannelRequirements() )
+			{
+				SpatialPylonCluster c = ((TileSpatialPylon) gm.getMachine()).getCluster();
+				if ( c != null )
+					clusters.put( c, c );
+			}
+		}
+
+		captureMax = null;
+		captureMin = null;
+		isValid = true;
+
+		int pylonBlocks = 0;
+		for (SpatialPylonCluster cl : clusters.values())
+		{
+			if ( captureMax == null )
+				captureMax = cl.max.copy();
+			if ( captureMin == null )
+				captureMin = cl.min.copy();
+
+			pylonBlocks += cl.tileCount();
+
+			captureMin.x = Math.min( captureMin.x, cl.min.x );
+			captureMin.y = Math.min( captureMin.y, cl.min.y );
+			captureMin.z = Math.min( captureMin.z, cl.min.z );
+
+			captureMax.x = Math.max( captureMax.x, cl.max.x );
+			captureMax.y = Math.max( captureMax.y, cl.max.y );
+			captureMax.z = Math.max( captureMax.z, cl.max.z );
+		}
+
+		if ( hasRegion() )
+		{
+			isValid = captureMax.x - captureMin.x > 1 && captureMax.y - captureMin.y > 1 && captureMax.z - captureMin.z > 1;
+
+			for (SpatialPylonCluster cl : clusters.values())
+			{
+				switch (cl.currentAxis)
+				{
+				case X:
+
+					isValid = isValid && ((captureMax.y == cl.min.y || captureMin.y == cl.max.y) || (captureMax.z == cl.min.z || captureMin.z == cl.max.z))
+							&& ((captureMax.y == cl.max.y || captureMin.y == cl.min.y) || (captureMax.z == cl.max.z || captureMin.z == cl.min.z));
+
+					break;
+				case Y:
+
+					isValid = isValid && ((captureMax.x == cl.min.x || captureMin.x == cl.max.x) || (captureMax.z == cl.min.z || captureMin.z == cl.max.z))
+							&& ((captureMax.x == cl.max.x || captureMin.x == cl.min.x) || (captureMax.z == cl.max.z || captureMin.z == cl.min.z));
+
+					break;
+				case Z:
+
+					isValid = isValid && ((captureMax.y == cl.min.y || captureMin.y == cl.max.y) || (captureMax.x == cl.min.x || captureMin.x == cl.max.x))
+							&& ((captureMax.y == cl.max.y || captureMin.y == cl.min.y) || (captureMax.x == cl.max.x || captureMin.x == cl.min.x));
+
+					break;
+				case UNFORMED:
+					isValid = false;
+					break;
+				}
+			}
+
+			reqX = captureMax.x - captureMin.x;
+			reqY = captureMax.y - captureMin.y;
+			reqZ = captureMax.z - captureMin.z;
+			requirePylonBlocks = Math.max( 6, ((reqX * reqZ + reqX * reqY + reqY * reqZ) * 3) / 8 );
+			
+			efficiency = (double) pylonBlocks / (double) requirePylonBlocks;
+			
+			if ( efficiency > 1.0 )
+				efficiency = 1.0;
+			if ( efficiency < 0.0 )
+				efficiency = 0.0;
+			
+			minPower = (double) reqX * (double) reqY * reqZ * AEConfig.instance.spatialPowerMultiplier;
+			maxPower = Math.pow( minPower, AEConfig.instance.spatialPowerScaler );
+		}
+
+		double affective_efficiency = Math.pow( efficiency, 0.25 );
+		powerRequired = (long) (affective_efficiency * minPower + (1.0 - affective_efficiency) * maxPower);
+
+		for (SpatialPylonCluster cl : clusters.values())
+		{
+			boolean myWasValid = cl.isValid;
+			cl.isValid = isValid;
+			if ( myWasValid != isValid )
+				cl.updateStatus( false );
+		}
+	}
+
+	@Override
+	public float currentEfficiency()
+	{
+		return (float) efficiency * 100;
+	}
+
+	@MENetworkEventSubscribe
+	public void bootingRender(MENetworkBootingStatusChange c)
+	{
+		reset( myGrid );
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+	}
+
+	@Override
+	public void addNode(IGridNode node, IGridHost machine)
+	{
+
+	}
+
+	@Override
+	public void removeNode(IGridNode node, IGridHost machine)
+	{
+
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

src/main/java/appeng/me/cache/TickManagerCache.java

@@ -0,0 +1,225 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.util.ReportedException;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.IGridStorage;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.ITickManager;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.me.cache.helpers.TickTracker;
+
+public class TickManagerCache implements ITickManager
+{
+
+	private long currentTick = 0;
+
+	final IGrid myGrid;
+
+	public TickManagerCache(IGrid g) {
+		myGrid = g;
+	}
+
+	final HashMap<IGridNode, TickTracker> alertable = new HashMap<IGridNode, TickTracker>();
+
+	final HashMap<IGridNode, TickTracker> sleeping = new HashMap<IGridNode, TickTracker>();
+	final HashMap<IGridNode, TickTracker> awake = new HashMap<IGridNode, TickTracker>();
+
+	final PriorityQueue<TickTracker> upcomingTicks = new PriorityQueue<TickTracker>();
+
+	public long getCurrentTick()
+	{
+		return currentTick;
+	}
+
+	public long getAvgNanoTime(IGridNode node)
+	{
+		TickTracker tt = awake.get( node );
+
+		if ( tt == null )
+			tt = sleeping.get( node );
+
+		if ( tt == null )
+			return -1;
+
+		return tt.getAvgNanos();
+	}
+
+	@Override
+	public void onUpdateTick()
+	{
+		TickTracker tt = null;
+		try
+		{
+			currentTick++;
+			while (!upcomingTicks.isEmpty())
+			{
+				tt = upcomingTicks.peek();
+				int diff = (int) (currentTick - tt.lastTick);
+				if ( diff >= tt.current_rate )
+				{
+					// remove tt..
+					upcomingTicks.poll();
+					TickRateModulation mod = tt.gt.tickingRequest( tt.node, diff );
+	
+					switch (mod)
+					{
+					case FASTER:
+						tt.setRate( tt.current_rate - 2 );
+						break;
+					case IDLE:
+						tt.setRate( tt.request.maxTickRate );
+						break;
+					case SAME:
+						break;
+					case SLEEP:
+						sleepDevice( tt.node );
+						break;
+					case SLOWER:
+						tt.setRate( tt.current_rate + 1 );
+						break;
+					case URGENT:
+						tt.setRate( 0 );
+						break;
+					default:
+						break;
+					}
+	
+					if ( awake.containsKey( tt.node ) )
+						addToQueue( tt );
+				}
+				else
+					return; // done!
+			}
+		}
+		catch( Throwable t )
+		{
+	        CrashReport crashreport = CrashReport.makeCrashReport(t, "Ticking GridNode");
+	        CrashReportCategory crashreportcategory = crashreport.makeCategory( tt.gt.getClass().getSimpleName() + " being ticked." );
+            tt.addEntityCrashInfo(crashreportcategory);
+            throw new ReportedException(crashreport);
+		}
+	}
+
+	private void addToQueue(TickTracker tt)
+	{
+		tt.lastTick = currentTick;
+		upcomingTicks.add( tt );
+	}
+
+	@Override
+	public boolean alertDevice(IGridNode node)
+	{
+		TickTracker tt = alertable.get( node );
+		if ( tt == null )
+			return false;
+		// throw new RuntimeException(
+		// "Invalid alerted device, this node is not marked as alertable, or part of this grid." );
+
+		// set to awake, this is for sanity.
+		sleeping.remove( node );
+		awake.put( node, tt );
+
+		// configure sort.
+		tt.lastTick = tt.lastTick - tt.request.maxTickRate;
+		tt.current_rate = tt.request.minTickRate;
+
+		// prevent dupes and tick build up.
+		upcomingTicks.remove( tt );
+		upcomingTicks.add( tt );
+
+		return true;
+	}
+
+	@Override
+	public boolean sleepDevice(IGridNode node)
+	{
+		if ( awake.containsKey( node ) )
+		{
+			TickTracker gt = awake.get( node );
+			awake.remove( node );
+			sleeping.put( node, gt );
+
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean wakeDevice(IGridNode node)
+	{
+		if ( sleeping.containsKey( node ) )
+		{
+			TickTracker gt = sleeping.get( node );
+			sleeping.remove( node );
+			awake.put( node, gt );
+			addToQueue( gt );
+
+			return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public void removeNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof IGridTickable )
+		{
+			alertable.remove( gridNode );
+			sleeping.remove( gridNode );
+			awake.remove( gridNode );
+		}
+	}
+
+	@Override
+	public void addNode(IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof IGridTickable )
+		{
+			TickingRequest tr = ((IGridTickable) machine).getTickingRequest( gridNode );
+			if ( tr != null )
+			{
+				TickTracker tt = new TickTracker( tr, gridNode, (IGridTickable) machine, currentTick, this );
+
+				if ( tr.canBeAlerted )
+					alertable.put( gridNode, tt );
+
+				if ( tr.isSleeping )
+					sleeping.put( gridNode, tt );
+				else
+				{
+					awake.put( gridNode, tt );
+					addToQueue( tt );
+				}
+
+			}
+		}
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+}

src/main/java/appeng/me/cache/helpers/ConnectionWrapper.java

@@ -0,0 +1,14 @@
+package appeng.me.cache.helpers;
+
+import appeng.api.networking.IGridConnection;
+
+public class ConnectionWrapper
+{
+
+	public IGridConnection connection;
+
+	public ConnectionWrapper(IGridConnection gc) {
+		connection = gc;
+	}
+
+}

src/main/java/appeng/me/cache/helpers/Connections.java

@@ -0,0 +1,42 @@
+package appeng.me.cache.helpers;
+
+import java.util.HashMap;
+import java.util.concurrent.Callable;
+
+import appeng.api.networking.IGridNode;
+import appeng.parts.p2p.PartP2PTunnelME;
+
+public class Connections implements Callable
+{
+
+	final private PartP2PTunnelME me;
+	final public HashMap<IGridNode, TunnelConnection> connections = new HashMap();
+
+	public boolean create = false;
+	public boolean destroy = false;
+
+	public Connections(PartP2PTunnelME o) {
+		me = o;
+	}
+
+	@Override
+	public Object call() throws Exception
+	{
+		me.updateConnections( this );
+
+		return null;
+	}
+
+	public void markDestroy()
+	{
+		create = false;
+		destroy = true;
+	}
+
+	public void markCreate()
+	{
+		create = true;
+		destroy = false;
+	}
+
+};

src/main/java/appeng/me/cache/helpers/TickTracker.java

@@ -0,0 +1,76 @@
+package appeng.me.cache.helpers;
+
+import net.minecraft.crash.CrashReportCategory;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.util.DimensionalCoord;
+import appeng.me.cache.TickManagerCache;
+import appeng.parts.AEBasePart;
+
+public class TickTracker implements Comparable<TickTracker>
+{
+
+	public final TickingRequest request;
+	public final IGridTickable gt;
+	public final IGridNode node;
+	public final TickManagerCache host;
+
+	public long LastFiveTicksTime = 0;
+
+	public long lastTick;
+	public int current_rate;
+
+	public TickTracker(TickingRequest req, IGridNode node, IGridTickable gt, long currentTick, TickManagerCache tickManagerCache) {
+		request = req;
+		this.gt = gt;
+		this.node = node;
+		current_rate = (req.minTickRate + req.maxTickRate) / 2;
+		lastTick = currentTick;
+		host = tickManagerCache;
+	}
+
+	public long getAvgNanos()
+	{
+		return (LastFiveTicksTime / 5);
+	}
+
+	public void setRate(int rate)
+	{
+		current_rate = rate;
+
+		if ( current_rate < request.minTickRate )
+			current_rate = request.minTickRate;
+
+		if ( current_rate > request.maxTickRate )
+			current_rate = request.maxTickRate;
+	}
+
+	@Override
+	public int compareTo(TickTracker t)
+	{
+		int nextTick = (int) ((lastTick - host.getCurrentTick()) + current_rate);
+		int ts_nextTick = (int) ((t.lastTick - host.getCurrentTick()) + t.current_rate);
+		return nextTick - ts_nextTick;
+	}
+
+	public void addEntityCrashInfo(CrashReportCategory crashreportcategory)
+	{
+		if ( gt instanceof AEBasePart )
+		{
+			AEBasePart part = (AEBasePart)gt;
+			part.addEntityCrashInfo( crashreportcategory );
+		}
+		
+		crashreportcategory.addCrashSection( "CurrentTickRate", current_rate );
+		crashreportcategory.addCrashSection( "MinTickRate", request.minTickRate );
+		crashreportcategory.addCrashSection( "MaxTickRate", request.maxTickRate );
+		crashreportcategory.addCrashSection( "MachineType", gt.getClass().getName() );
+		crashreportcategory.addCrashSection( "GridBlockType", node.getGridBlock().getClass().getName() );
+		crashreportcategory.addCrashSection( "ConnectedSides", node.getConnectedSides() );
+		
+		DimensionalCoord dc = node.getGridBlock().getLocation();
+		if ( dc != null )
+			crashreportcategory.addCrashSection( "Location", dc );
+	}
+};

src/main/java/appeng/me/cache/helpers/TunnelCollection.java

@@ -0,0 +1,47 @@
+package appeng.me.cache.helpers;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import appeng.parts.p2p.PartP2PTunnel;
+import appeng.util.iterators.NullIterator;
+
+public class TunnelCollection<T extends PartP2PTunnel> implements Iterable<T>
+{
+
+	final Class clz;
+	Collection<T> tunnelsource;
+
+	public TunnelCollection(Collection<T> src, Class c) {
+		tunnelsource = src;
+		clz = c;
+	}
+
+	@Override
+	public Iterator<T> iterator()
+	{
+		if ( tunnelsource == null )
+			return new NullIterator();
+		return new TunnelIterator( tunnelsource, clz );
+	}
+
+	public void setSource(Collection<T> c)
+	{
+		tunnelsource = c;
+	}
+
+	public boolean isEmpty()
+	{
+		return !iterator().hasNext();
+	}
+
+	public boolean matches(Class<? extends PartP2PTunnel> c)
+	{
+		return clz == c;
+	}
+
+	public Class<? extends PartP2PTunnel> getClz()
+	{
+		return clz;
+	}
+}

src/main/java/appeng/me/cache/helpers/TunnelConnection.java

@@ -0,0 +1,16 @@
+package appeng.me.cache.helpers;
+
+import appeng.api.networking.IGridConnection;
+import appeng.parts.p2p.PartP2PTunnelME;
+
+public class TunnelConnection
+{
+
+	final public PartP2PTunnelME tunnel;
+	final public IGridConnection c;
+
+	public TunnelConnection(PartP2PTunnelME t, IGridConnection con) {
+		tunnel = t;
+		c = con;
+	}
+}

src/main/java/appeng/me/cache/helpers/TunnelIterator.java

@@ -0,0 +1,52 @@
+package appeng.me.cache.helpers;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import appeng.parts.p2p.PartP2PTunnel;
+
+public class TunnelIterator<T extends PartP2PTunnel> implements Iterator<T>
+{
+
+	Iterator<T> wrapped;
+	Class targetType;
+	T Next;
+
+	private void findNext()
+	{
+		while (Next == null && wrapped.hasNext())
+		{
+			Next = wrapped.next();
+			if ( !targetType.isInstance( Next ) )
+				Next = null;
+		}
+	}
+
+	public TunnelIterator(Collection<T> tunnelsource, Class clz) {
+		wrapped = tunnelsource.iterator();
+		targetType = clz;
+		findNext();
+	}
+
+	@Override
+	public boolean hasNext()
+	{
+		findNext();
+		return Next != null;
+	}
+
+	@Override
+	public T next()
+	{
+		T tmp = Next;
+		Next = null;
+		return tmp;
+	}
+
+	@Override
+	public void remove()
+	{
+		// no.
+	}
+
+}