AE2 First Commit, the dawn of 1.7 hast arrived.

me/cache/EnergyGridCache.java

@@ -0,0 +1,426 @@
+package appeng.me.cache;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+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.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerIdleChange;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.events.MENetworkPowerStorage;
+import appeng.me.GridNode;
+
+public class EnergyGridCache implements IEnergyGrid
+{
+
+	/**
+	 * estimated power available.
+	 */
+	int availableTicksSinceUpdate = 0;
+	double globalAvailablePower = 0;
+
+	/**
+	 * idle draw.
+	 */
+	double drainPerTick = 0;
+	Double[] totalDrainPastTicks = new Double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+	Double[] totalInjectionPastTicks = new Double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+
+	/**
+	 * power status
+	 */
+	boolean publicHasPower = false;
+	boolean hasPower = true;
+	long ticksSinceHasPowerChange = 900;
+
+	/**
+	 * excess power in the system.
+	 */
+	double prev_extra = 0;
+	double extra = 0;
+
+	Set<IAEPowerStorage> providers = new LinkedHashSet();
+	Set<IAEPowerStorage> requesters = new LinkedHashSet();
+
+	Set<IEnergyGridProvider> gproviders = new LinkedHashSet();
+
+	final IGrid myGrid;
+
+	public EnergyGridCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@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)
+	{
+		double required = 0;
+		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() );
+		}
+		return required;
+	}
+
+	@Override
+	public double injectPower(double i, Actionable mode)
+	{
+		i += extra;
+
+		if ( mode == Actionable.SIMULATE )
+		{
+			Iterator<IAEPowerStorage> it = requesters.iterator();
+			while (i > 0 && it.hasNext())
+			{
+				IAEPowerStorage node = it.next();
+				i = node.injectAEPower( i, Actionable.SIMULATE );
+			}
+		}
+		else
+		{
+			while (i > 0 && !requesters.isEmpty())
+			{
+				IAEPowerStorage node = requesters.iterator().next();
+
+				i = node.injectAEPower( i, Actionable.MODULATE );
+				if ( i > 0 )
+					requesters.remove( node );
+			}
+
+			extra = i;
+			totalInjectionPastTicks[0] += i;
+		}
+
+		return i;
+	}
+
+	@Override
+	public double extractAEPower(double amt, Actionable mode, PowerMultiplier pm)
+	{
+		return pm.divide( extractAEPower( pm.multiply( amt ), mode, new HashSet() ) );
+	}
+
+	@Override
+	public void addNode(IGrid grid, 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 ( current > 0 && ps.getPowerFlow() != AccessRestriction.WRITE )
+				{
+					globalAvailablePower += ((IAEPowerStorage) machine).getAECurrentPower();
+					providers.add( ps );
+				}
+
+				if ( current < max && ps.getPowerFlow() != AccessRestriction.READ )
+					requesters.add( ps );
+			}
+		}
+
+		grid.postEventTo( node, new MENetworkPowerStatusChange() );
+	}
+
+	@Override
+	public void removeNode(IGrid grid, 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.getPowerFlow() != AccessRestriction.WRITE )
+				globalAvailablePower -= ps.getAECurrentPower();
+
+			providers.remove( machine );
+			requesters.remove( machine );
+		}
+	}
+
+	// recalculate the whole thing?
+	public void reset(IGrid grid)
+	{
+		providers = new LinkedHashSet();
+		requesters = new LinkedHashSet();
+
+		// re-calculate power info
+		for (Class c : grid.getMachinesClasses())
+		{
+			if ( IAEPowerStorage.class.isAssignableFrom( c ) )
+			{
+				for (Object obj : grid.getMachines( c ))
+				{
+					IAEPowerStorage ps = (IAEPowerStorage) obj;
+					if ( ps.isAEPublicPowerStorage() )
+					{
+						double max = ps.getAEMaxPower();
+						double current = ps.getAECurrentPower();
+
+						if ( current > 0 && ps.getPowerFlow() != AccessRestriction.WRITE )
+						{
+							providers.add( ps );
+							globalAvailablePower += ps.getAECurrentPower();
+						}
+
+						if ( current < max && ps.getPowerFlow() != AccessRestriction.READ )
+							requesters.add( ps );
+
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public void onUpdateTick(IGrid grid)
+	{
+		// next tick is here...
+		for (int x = 0; x < totalDrainPastTicks.length - 1; x++)
+			totalDrainPastTicks[x + 1] = totalDrainPastTicks[x];
+		totalDrainPastTicks[0] = 0.0;
+
+		for (int x = 0; x < totalInjectionPastTicks.length - 1; x++)
+			totalInjectionPastTicks[x + 1] = totalInjectionPastTicks[x];
+		totalInjectionPastTicks[0] = 0.0;
+
+		// power information.
+		double drained = extractAEPower( getIdlePowerUsage(), Actionable.MODULATE, PowerMultiplier.CONFIG );
+		boolean currentlyHasPower = drained >= drainPerTick - 0.1;
+
+		// 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, grid );
+		else if ( !hasPower )
+			publicPowerState( false, grid );
+
+		availableTicksSinceUpdate++;
+		if ( extra > 32 )
+			injectPower( 0.0, Actionable.MODULATE );
+	}
+
+	private void publicPowerState(boolean newState, IGrid grid)
+	{
+
+		if ( publicHasPower == newState )
+			return;
+
+		publicHasPower = newState;
+		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 globalAvailablePower;
+	}
+
+	@Override
+	public double extractAEPower(double amt, Actionable mode, Set<IEnergyGrid> seen)
+	{
+		if ( seen.contains( this ) )
+			return 0;
+
+		seen.add( this );
+
+		double extractedPower = extra;
+
+		if ( mode == Actionable.SIMULATE )
+		{
+			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;
+			}
+		}
+		else
+		{
+			extra = 0;
+
+			while (extractedPower < amt && !providers.isEmpty())
+			{
+				IAEPowerStorage node = providers.iterator().next();
+
+				double req = amt - extractedPower;
+				double newPower = node.extractAEPower( req, Actionable.MODULATE, PowerMultiplier.ONE );
+				extractedPower += newPower;
+
+				if ( newPower < req )
+					providers.remove( node );
+			}
+
+			// add power used to the current tick.
+			totalDrainPastTicks[0] += extractedPower;
+		}
+
+		// got more then we wanted?
+		if ( extractedPower > amt )
+		{
+			extra = extractedPower - amt;
+			globalAvailablePower -= amt;
+
+			return amt;
+		}
+
+		if ( extractedPower < amt )
+		{
+			for (IEnergyGridProvider egp : gproviders)
+				extractedPower += egp.extractAEPower( amt - extractedPower, mode, seen );
+		}
+
+		// go less or the correct amount?
+		globalAvailablePower -= extractedPower;
+		return extractedPower;
+	}
+
+	@Override
+	public boolean isNetworkPowered()
+	{
+		return publicHasPower;
+	}
+
+	@Override
+	public double getIdlePowerUsage()
+	{
+		return drainPerTick;
+	}
+
+	@Override
+	public double getAvgPowerUsage()
+	{
+		double out = 0;
+
+		for (double x : totalDrainPastTicks)
+			out += x;
+
+		return out / totalDrainPastTicks.length;
+	}
+
+	@Override
+	public double getAvgPowerInjection()
+	{
+		double out = 0;
+
+		for (double x : totalInjectionPastTicks)
+			out += x;
+
+		return out / totalInjectionPastTicks.length;
+	}
+
+	@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 );
+	}
+
+}

me/cache/GridStorageCache.java

@@ -0,0 +1,208 @@
+package appeng.me.cache;
+
+import java.util.HashSet;
+
+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.storage.IStorageGrid;
+import appeng.api.storage.ICellContainer;
+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.storage.NetworkInventoryHandler;
+import appeng.util.item.ItemList;
+
+public class GridStorageCache implements IStorageGrid
+{
+
+	final HashSet<ICellContainer> cellContainers = new HashSet();
+	final IGrid myGrid;
+
+	private IItemList<IAEItemStack> previousItemSet;
+	private NetworkInventoryHandler<IAEItemStack> myItemNetwork;
+	private NetworkMonitor<IAEItemStack> itemMonitor = new NetworkMonitor<IAEItemStack>( this, StorageChannel.ITEMS );
+
+	private IItemList<IAEFluidStack> previousFluidSet;
+	private NetworkInventoryHandler<IAEFluidStack> myFluidNetwork;
+	private NetworkMonitor<IAEFluidStack> fluidMonitor = new NetworkMonitor<IAEFluidStack>( this, StorageChannel.FLUIDS );
+
+	public GridStorageCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@Override
+	public void onUpdateTick(IGrid grid)
+	{
+		itemMonitor.onTick();
+		fluidMonitor.onTick();
+	}
+
+	@Override
+	public void removeNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof ICellContainer )
+		{
+			ICellContainer cc = (ICellContainer) machine;
+			cellContainers.remove( cc );
+
+			for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( StorageChannel.ITEMS ))
+			{
+				postChanges( StorageChannel.ITEMS, -1, h.getAvailableItems( new ItemList<IAEItemStack>() ) );
+			}
+
+			for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( StorageChannel.FLUIDS ))
+			{
+				postChanges( StorageChannel.ITEMS, -1, h.getAvailableItems( new ItemList<IAEFluidStack>() ) );
+			}
+		}
+
+		myGrid.postEvent( new MENetworkCellArrayUpdate() );
+	}
+
+	@Override
+	public void addNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof ICellContainer )
+		{
+			ICellContainer cc = (ICellContainer) machine;
+			cellContainers.add( cc );
+
+			for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( StorageChannel.ITEMS ))
+			{
+				postChanges( StorageChannel.ITEMS, 1, h.getAvailableItems( new ItemList<IAEItemStack>() ) );
+			}
+
+			for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( StorageChannel.FLUIDS ))
+			{
+				postChanges( StorageChannel.ITEMS, 1, h.getAvailableItems( new ItemList<IAEFluidStack>() ) );
+			}
+		}
+
+		myGrid.postEvent( new MENetworkCellArrayUpdate() );
+	}
+
+	private void buildNetworkStorage(StorageChannel chan)
+	{
+		switch (chan)
+		{
+		case FLUIDS:
+			myFluidNetwork = new NetworkInventoryHandler<IAEFluidStack>( StorageChannel.FLUIDS );
+			for (ICellContainer cc : cellContainers)
+			{
+				for (IMEInventoryHandler<IAEFluidStack> h : cc.getCellArray( chan ))
+					myFluidNetwork.addNewStorage( h );
+			}
+			break;
+		case ITEMS:
+			myItemNetwork = new NetworkInventoryHandler<IAEItemStack>( StorageChannel.ITEMS );
+			for (ICellContainer cc : cellContainers)
+			{
+				for (IMEInventoryHandler<IAEItemStack> h : cc.getCellArray( chan ))
+					myItemNetwork.addNewStorage( h );
+			}
+			break;
+		default:
+		}
+	}
+
+	private void postChanges(StorageChannel chan, int up_or_down, IItemList availableItems)
+	{
+		switch (chan)
+		{
+		case FLUIDS:
+			for (IAEFluidStack fs : ((IItemList<IAEFluidStack>) availableItems))
+			{
+				if ( up_or_down > 0 )
+					fluidMonitor.postChange( fs );
+				else
+				{
+					fs.setStackSize( -fs.getStackSize() );
+					fluidMonitor.postChange( fs );
+				}
+			}
+			break;
+		case ITEMS:
+			for (IAEItemStack fs : ((IItemList<IAEItemStack>) availableItems))
+			{
+				if ( up_or_down > 0 )
+					itemMonitor.postChange( fs );
+				else
+				{
+					fs.setStackSize( -fs.getStackSize() );
+					itemMonitor.postChange( fs );
+				}
+			}
+			break;
+		default:
+		}
+	}
+
+	@MENetworkEventSubscribe
+	public void cellUpdate(MENetworkCellArrayUpdate ev)
+	{
+		myItemNetwork = null;
+		myFluidNetwork = null;
+	}
+
+	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, IAEStack input)
+	{
+		if ( chan == StorageChannel.ITEMS )
+			itemMonitor.postChange( (IAEItemStack) input );
+		else if ( chan == StorageChannel.FLUIDS )
+			fluidMonitor.postChange( (IAEFluidStack) input );
+	}
+
+	@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)
+	{
+
+	}
+
+}

me/cache/NetworkMonitor.java

@@ -0,0 +1,66 @@
+package appeng.me.cache;
+
+import java.util.LinkedList;
+
+import appeng.api.networking.events.MENetworkStorageEvent;
+import appeng.api.storage.IMEInventoryHandler;
+import appeng.api.storage.MEMontorHandler;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEStack;
+
+public class NetworkMonitor<T extends IAEStack<T>> extends MEMontorHandler<T>
+{
+
+	final private GridStorageCache myGridCache;
+	final private StorageChannel myChannel;
+
+	boolean sendEvent = false;
+
+	public NetworkMonitor(GridStorageCache cache, StorageChannel chan) {
+		super( null );
+		myGridCache = cache;
+		myChannel = chan;
+	}
+
+	final static public LinkedList depth = new LinkedList();
+
+	@Override
+	protected void postChange(T diff)
+	{
+		if ( depth.contains( this ) )
+			return;
+
+		depth.push( this );
+
+		sendEvent = true;
+		super.postChange( diff );
+
+		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( getStorageList(), myChannel ) );
+		}
+	}
+
+	@Override
+	protected IMEInventoryHandler getHandler()
+	{
+		switch (myChannel)
+		{
+		case ITEMS:
+			return myGridCache.getItemInventoryHandler();
+		case FLUIDS:
+			return myGridCache.getFluidInventoryHandler();
+		default:
+		}
+		return null;
+	}
+
+}

me/cache/P2PCache.java

@@ -0,0 +1,103 @@
+package appeng.me.cache;
+
+import java.util.Collection;
+import java.util.HashMap;
+
+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.parts.misc.PartP2PTunnel;
+
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+
+public class P2PCache implements IGridCache
+{
+
+	private HashMap<Long, PartP2PTunnel> inputs = new HashMap();
+	private Multimap<Long, PartP2PTunnel> Tunnels = LinkedHashMultimap.create();
+
+	final IGrid myGrid;
+
+	public P2PCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@Override
+	public void addNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof PartP2PTunnel )
+			reset( grid );
+	}
+
+	@Override
+	public void removeNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+		if ( machine instanceof PartP2PTunnel )
+			reset( grid );
+	}
+
+	public void reset(IGrid grid)
+	{
+
+		Tunnels.clear();
+		inputs.clear();
+
+		for (IGridNode n : grid.getMachines( PartP2PTunnel.class ))
+		{
+			PartP2PTunnel p = (PartP2PTunnel) n.getMachine();
+			if ( p.freq > 0 )
+			{
+				if ( p.output )
+					Tunnels.put( p.freq, p );
+				else if ( inputs.containsKey( p.freq ) )
+					p.output = true;
+				else
+					inputs.put( p.freq, p );
+			}
+		}
+
+		for (PartP2PTunnel p : inputs.values())
+			p.onChange();
+
+		for (PartP2PTunnel p : Tunnels.values())
+			p.onChange();
+	}
+
+	public Collection<PartP2PTunnel> getOutputs(long freq)
+	{
+		return Tunnels.get( freq );
+	}
+
+	public PartP2PTunnel getInput(long freq)
+	{
+		return inputs.get( freq );
+	}
+
+	@Override
+	public void onUpdateTick(IGrid grid)
+	{
+
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

me/cache/PathGridCache.java

@@ -0,0 +1,279 @@
+package appeng.me.cache;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import net.minecraftforge.common.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.MENetworkControllerChange;
+import appeng.api.networking.pathing.ControllerState;
+import appeng.api.networking.pathing.IPathingGrid;
+import appeng.api.util.DimensionalCoord;
+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;
+
+public class PathGridCache implements IPathingGrid
+{
+
+	boolean recalculateControllerNextTick = true;
+	boolean updateNetwork = true;
+	boolean booting = false;
+
+	LinkedList<PathSegment> active = new LinkedList();
+
+	ControllerState controllerState = ControllerState.NO_CONTROLLER;
+
+	int instance = Integer.MIN_VALUE;
+
+	int ticksUntilReady = 20;
+	Set<TileController> controllers = new HashSet();
+	Set<IGridNode> requireChannels = new HashSet();
+
+	final IGrid myGrid;
+	private HashSet<IPathItem> semiOpen = new HashSet();
+	private HashSet<IPathItem> closedList = new HashSet();
+
+	public PathGridCache(IGrid g) {
+		myGrid = g;
+	}
+
+	@Override
+	public void onUpdateTick(IGrid grid)
+	{
+		if ( recalculateControllerNextTick )
+		{
+			recalcController();
+		}
+
+		if ( updateNetwork )
+		{
+			if ( !booting )
+				myGrid.postEvent( new MENetworkBootingStatusChange() );
+
+			booting = true;
+			updateNetwork = false;
+			instance++;
+
+			if ( controllerState == ControllerState.NO_CONTROLLER )
+			{
+				int requiredChannels = calculateRequiredChanels();
+				int used = requiredChannels;
+				if ( requiredChannels > 8 )
+					used = 0;
+
+				int nodes = myGrid.getNodes().size();
+				ticksUntilReady = 20 + (nodes / 10);
+
+				myGrid.getPivot().beginVisition( new AdHocChannelUpdater( used ) );
+			}
+			else if ( controllerState == ControllerState.CONTROLLER_CONFLICT )
+			{
+				ticksUntilReady = 20;
+				myGrid.getPivot().beginVisition( new AdHocChannelUpdater( 0 ) );
+			}
+			else
+			{
+				int nodes = myGrid.getNodes().size();
+				ticksUntilReady = 20 + (nodes / 10);
+				closedList = new HashSet();
+				semiOpen = new HashSet();
+
+				// myGrid.getPivot().beginVisition( new AdHocChannelUpdater( 0 ) );
+				for (IGridNode node : grid.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( 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 ).beginVisition( new ControllerChannelUpdater() );
+						break;
+					}
+				}
+
+				booting = false;
+				myGrid.postEvent( new MENetworkBootingStatusChange() );
+			}
+		}
+	}
+
+	private int calculateRequiredChanels()
+	{
+		int depth = 0;
+		semiOpen.clear();
+
+		for (IGridNode nodes : requireChannels)
+		{
+			if ( !semiOpen.contains( nodes ) )
+			{
+				depth++;
+
+				IGridBlock gb = nodes.getGridBlock();
+				if ( gb.getFlags().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();
+
+		updateNetwork = true;
+	}
+
+	@Override
+	public void removeNode(IGrid grid, IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof TileController )
+		{
+			controllers.remove( machine );
+			recalculateControllerNextTick = true;
+		}
+
+		if ( gridNode.getGridBlock().getFlags().contains( GridFlags.REQURE_CHANNEL ) )
+			requireChannels.remove( gridNode );
+
+		repath();
+	}
+
+	@Override
+	public void addNode(IGrid grid, IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof TileController )
+		{
+			controllers.add( (TileController) machine );
+			recalculateControllerNextTick = true;
+		}
+
+		if ( gridNode.getGridBlock().getFlags().contains( GridFlags.REQURE_CHANNEL ) )
+			requireChannels.add( 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.beginVisition( 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();
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

me/cache/SpatialPylonCache.java

@@ -0,0 +1,219 @@
+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.Configuration;
+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;
+
+	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 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 requirePylongBlocks = 1;
+
+		double effiency = 0.0;
+		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.isActive() )
+			{
+				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;
+			requirePylongBlocks = ((reqX * reqZ + reqX * reqY + reqY * reqZ) * 3) / 5;
+
+			effiency = (double) pylonBlocks / (double) requirePylongBlocks;
+			if ( effiency > 1.0 )
+				effiency = 1.0;
+			if ( effiency < 0.0 )
+				effiency = 0.0;
+
+			minPower = (double) reqX * (double) reqY * reqZ * Configuration.instance.spatialPowerMultiplier;
+			maxPower = Math.pow( minPower, Configuration.instance.spatialPowerScaler );
+		}
+
+		double affective_effiency = Math.pow( effiency, 0.25 );
+		powerRequired = (long) (affective_effiency * minPower + (1.0 - affective_effiency) * maxPower);
+
+		for (SpatialPylonCluster cl : clusters.values())
+		{
+			boolean myWasValid = cl.isValid;
+			cl.isValid = isValid;
+			if ( myWasValid != isValid )
+				cl.updateStatus( false );
+		}
+	}
+
+	@MENetworkEventSubscribe
+	public void bootingRender(MENetworkBootingStatusChange c)
+	{
+		reset( myGrid );
+	}
+
+	@Override
+	public void onUpdateTick(IGrid grid)
+	{
+	}
+
+	@Override
+	public void addNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+
+	}
+
+	@Override
+	public void removeNode(IGrid grid, IGridNode node, IGridHost machine)
+	{
+
+	}
+
+	@Override
+	public void onSplit(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void onJoin(IGridStorage storageB)
+	{
+
+	}
+
+	@Override
+	public void populateGridStorage(IGridStorage storage)
+	{
+
+	}
+
+}

me/cache/TickManagerCache.java

@@ -0,0 +1,217 @@
+package appeng.me.cache;
+
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+import net.minecraft.tileentity.TileEntity;
+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.core.AELog;
+import appeng.me.cache.helpers.TickTracker;
+import appeng.util.Platform;
+
+public class TickManagerCache implements ITickManager
+{
+
+	private long currentTick = 0;
+	private long lastInnerTime = 0;
+
+	final IGrid myGrid;
+
+	public TickManagerCache(IGrid g) {
+		myGrid = g;
+	}
+
+	HashMap<IGridNode, TickTracker> alertable = new HashMap<IGridNode, TickTracker>();
+
+	HashMap<IGridNode, TickTracker> sleeping = new HashMap<IGridNode, TickTracker>();
+	HashMap<IGridNode, TickTracker> awake = new HashMap<IGridNode, TickTracker>();
+
+	PriorityQueue<TickTracker> upcomingTicks = new PriorityQueue<TickTracker>();
+
+	public long getCurrentTick()
+	{
+		return currentTick;
+	}
+
+	public long getInnerTime()
+	{
+		return lastInnerTime;
+	}
+
+	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(IGrid grid)
+	{
+		currentTick++;
+		while (!upcomingTicks.isEmpty())
+		{
+			TickTracker tt = upcomingTicks.peek();
+			int diff = (int) (currentTick - tt.lastTick);
+			if ( diff >= tt.current_rate )
+			{
+				// remove tt..
+				upcomingTicks.poll();
+
+				long startTime = Platform.nanoTime();
+				TickRateModulation mod = tt.gt.tickingRequest( tt.node, diff );
+				long estimatedTime = Platform.nanoTime() - startTime;
+				lastInnerTime += estimatedTime;
+
+				tt.LastFiveTicksTime = ((tt.LastFiveTicksTime * 4) / 5) + estimatedTime;
+
+				switch (mod)
+				{
+				case FASTER:
+					tt.setRate( tt.current_rate - 1 );
+					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!
+		}
+	}
+
+	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 )
+			throw new RuntimeException( "Invalid Alertted device, this node is not marked as alertable, or part of this grid." );
+
+		tt.lastTick = -tt.request.maxTickRate;
+		addToQueue( 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(IGrid grid, IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof IGridTickable )
+		{
+			alertable.remove( gridNode );
+			sleeping.remove( gridNode );
+			awake.remove( gridNode );
+		}
+	}
+
+	@Override
+	public void addNode(IGrid grid, IGridNode gridNode, IGridHost machine)
+	{
+		if ( machine instanceof IGridTickable )
+		{
+			TickingRequest tr = ((IGridTickable) machine).getTickingRequest( gridNode );
+			if ( tr != null )
+			{
+				if ( machine instanceof TileEntity && ((TileEntity) machine).canUpdate() )
+					AELog.warning( "Tile: " + machine.getClass().getName() + " - reports to use MC ticking, but also requests Network Based Ticking." );
+
+				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)
+	{
+
+	}
+}

me/cache/helpers/TickTracker.java

@@ -0,0 +1,51 @@
+package appeng.me.cache.helpers;
+
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.me.cache.TickManagerCache;
+
+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)
+	{
+		return (int) ((host.getCurrentTick() - lastTick) + current_rate);
+	}
+};