Work on Universal Cable split logistics, I think I got this @unpairedbracket

common/mekanism/api/transmitters/DynamicNetwork.java

@@ -120,7 +120,7 @@ public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implemen
 	{
 		if(!fixed)
 		{
-			++ticksSinceCreate;
+			ticksSinceCreate++;
 			
 			if(ticksSinceCreate > 1200)
 			{
@@ -187,7 +187,7 @@ public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implemen
 			
 			TileEntity[] connectedBlocks = new TileEntity[6];
 			boolean[] dealtWith = {false, false, false, false, false, false};
-			List<NetworkFinder> newNetworks = new ArrayList<NetworkFinder>();
+			List<ITransmitterNetwork<A, N>> newNetworks = new ArrayList<ITransmitterNetwork<A, N>>();
 			
 			for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
 			{
@@ -226,16 +226,6 @@ public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implemen
 						}
 					}
 					
-					newNetworks.add(finder);
-				}
-			}
-			
-			if(newNetworks.size() > 0)
-			{
-				Object[] metaArray = getMetaArray(newNetworks);
-				
-				for(NetworkFinder finder : newNetworks)
-				{
 					Set<ITransmitter<N>> newNetCables = new HashSet<ITransmitter<N>>();
 					
 					for(Object3D node : finder.iterated)
@@ -251,9 +241,17 @@ public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implemen
 						}
 					}
 					
-					ITransmitterNetwork<A, N> newNetwork = create(newNetCables);
+					newNetworks.add(create(newNetCables));
-					newNetwork.onNewFromSplit(newNetworks.indexOf(finder), metaArray);
+				}
-					newNetwork.refresh();
+			}
+			
+			if(newNetworks.size() > 0)
+			{
+				onNetworksCreated((List<N>)newNetworks);
+				
+				for(ITransmitterNetwork<A, N> network : newNetworks)
+				{
+					network.refresh();
 				}
 			}
 			
@@ -262,13 +260,7 @@ public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implemen
 	}
 	
 	@Override
-	public Object[] getMetaArray(List<NetworkFinder> networks)
+	public void onNetworksCreated(List<N> networks) {}
-	{
-		return null;
-	}
-	
-	@Override
-	public void onNewFromSplit(int netIndex, Object[] metaArray) {}
 	
 	@Override
 	public void setFixed(boolean value)

common/mekanism/api/transmitters/ITransmitterNetwork.java

@@ -43,14 +43,5 @@ public interface ITransmitterNetwork<A, N extends DynamicNetwork<A, N>>
 	 * @param size - the amount of new networks that are being created
 	 * @return meta obj
 	 */
-	public Object[] getMetaArray(List<NetworkFinder> networks);
+	public void onNetworksCreated(List<N> networks);
-	
-	/**
-	 * Called right after a new network is created after being split, before it is refreshed. Passes in it's index
-	 * in the amount of networks being created, as well as the meta value that was retrieved on the original network
-	 * by getMetaObj().
-	 * @param netIndex - the index of the network being created
-	 * @param meta - meta obj
-	 */
-	public void onNewFromSplit(int netIndex, Object[] metaArray);
 }

common/mekanism/common/EnergyNetwork.java

@@ -15,6 +15,7 @@ import mekanism.api.transmitters.DynamicNetwork;
 import mekanism.api.transmitters.ITransmitter;
 import mekanism.api.transmitters.TransmissionType;
 import mekanism.common.util.CableUtils;
+import mekanism.common.util.ListUtils;
 import mekanism.common.util.MekanismUtils;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.common.ForgeDirection;
@@ -66,6 +67,8 @@ public class EnergyNetwork extends DynamicNetwork<TileEntity, EnergyNetwork>
 					lastPowerScale = net.lastPowerScale;
 				}
 				
+				electricityStored += net.electricityStored;
+				
 				addAllTransmitters(net.transmitters);
 				net.deregister();
 			}
@@ -81,12 +84,36 @@ public class EnergyNetwork extends DynamicNetwork<TileEntity, EnergyNetwork>
         //Use the harmonic mean. Because we're mean.
         int numCables = transmitters.size();
         double reciprocalSum = 0;
+        
         for(ITransmitter<EnergyNetwork> cable : transmitters)
         {
             reciprocalSum += 1.0/(double)cable.getCapacity();
         }
+        
 		return (double)numCables / reciprocalSum;
 	}
+    
+    @Override
+    public void onNetworksCreated(List<EnergyNetwork> networks)
+    {
+    	double[] caps = new double[networks.size()];
+    	double cap = 0;
+    	
+    	for(EnergyNetwork network : networks)
+    	{
+    		caps[networks.indexOf(network)] = network.getCapacity();
+    		cap += network.getCapacity();
+    	}
+    	
+    	electricityStored = Math.min(cap, electricityStored);
+    	
+    	double[] percent = ListUtils.percent(caps);
+    	
+    	for(EnergyNetwork network : networks)
+    	{
+    		network.electricityStored = percent[networks.indexOf(network)]*electricityStored;
+    	}
+    }
 	
 	public synchronized double getEnergyNeeded()
 	{
@@ -427,6 +454,7 @@ public class EnergyNetwork extends DynamicNetwork<TileEntity, EnergyNetwork>
 		network.joulesLastTick = joulesLastTick;
 		network.joulesTransmitted = joulesTransmitted;
 		network.lastPowerScale = lastPowerScale;
+		network.electricityStored += electricityStored;
 		return network;
 	}
 
@@ -438,23 +466,14 @@ public class EnergyNetwork extends DynamicNetwork<TileEntity, EnergyNetwork>
 		network.joulesLastTick = joulesLastTick;
 		network.joulesTransmitted = joulesTransmitted;
 		network.lastPowerScale = lastPowerScale;
+		network.electricityStored += electricityStored;
 		return network;
 	}
 
 	@Override
 	protected EnergyNetwork create(Set<EnergyNetwork> networks) 
 	{
-		EnergyNetwork network = new EnergyNetwork(networks);
+		return new EnergyNetwork(networks);
-		
-		if(joulesLastTick > network.joulesLastTick || clientEnergyScale > network.clientEnergyScale)
-		{
-			network.clientEnergyScale = clientEnergyScale;
-			network.joulesLastTick = joulesLastTick;
-			network.joulesTransmitted = joulesTransmitted;
-			network.lastPowerScale = lastPowerScale;
-		}
-		
-		return network;
 	}
 	
 	@Override
@@ -472,6 +491,7 @@ public class EnergyNetwork extends DynamicNetwork<TileEntity, EnergyNetwork>
 	@Override
 	public String getFlow()
 	{
-		return MekanismUtils.getPowerDisplay(20*electricityStored);
+		return "" + electricityStored;
+	//TODO	return MekanismUtils.getPowerDisplay(20*electricityStored);
 	}
 }

common/mekanism/common/multipart/PartTransmitter.java

@@ -187,8 +187,11 @@ public abstract class PartTransmitter<N extends DynamicNetwork<?, N>> extends Pa
 			}
 			else if(connectedNets.size() == 1)
 			{
-				theNetwork = connectedNets.iterator().next();
+				N network = connectedNets.iterator().next();
+				preSingleMerge(network);
+				theNetwork = network;
 				theNetwork.transmitters.add((ITransmitter<N>)tile());
+				theNetwork.refresh();
 			}
 			else {
 				theNetwork = createNetworkByMergingSet(connectedNets);
@@ -199,6 +202,8 @@ public abstract class PartTransmitter<N extends DynamicNetwork<?, N>> extends Pa
 		return theNetwork;
 	}
 	
+	public void preSingleMerge(N network) {}
+	
 	@Override
 	public void removeFromTransmitterNetwork()
 	{

common/mekanism/common/multipart/PartUniversalCable.java

@@ -52,6 +52,7 @@ public class PartUniversalCable extends PartTransmitter<EnergyNetwork> implement
         	if(cacheEnergy > 0)
         	{
         		getTransmitterNetwork().electricityStored += cacheEnergy;
+        		cacheEnergy = 0;
         	}
         }
         
@@ -91,6 +92,13 @@ public class PartUniversalCable extends PartTransmitter<EnergyNetwork> implement
         cableIcons.registerCenterIcons(register, new String[] {"UniversalCable"});
         cableIcons.registerSideIcon(register, "TransmitterSideSmall");
     }
+    
+    @Override
+    public void preSingleMerge(EnergyNetwork network)
+    {
+    	network.electricityStored += cacheEnergy;
+    	cacheEnergy = 0;
+    }
 
     @Override
     public Icon getCenterIcon()

common/mekanism/common/util/ListUtils.java

@@ -187,6 +187,21 @@ public class ListUtils
 		return split;
 	}
 	
+	public static double[] percent(double[] values)
+	{
+		double[] ret = new double[values.length];
+		double total = 0;
+		
+		for(double d : values) total += d;
+		
+		for(int i = 0; i < values.length; i++)
+		{
+			ret[i] = values[i]/total;
+		}
+		
+		return ret;
+	}
+	
 	public static int[] splitInt(int size, int num)
 	{
 		int[] split = new int[size];