Power network structure [1.12.2]

[Gaffa]

Hello all forge modders,

 

How would one create an efficient power network system with cables? I have had multiple thoughts, but don't know the usual/best implementation. The goal is a simple power system similar to IC2, but without different voltages and power falloff over distance. Any cables connected shares power 1:1, meaning a generator (adding power to a neighboring cable) could power an electric furnace (consuming power from neighboring cable), however many blocks away. 

 

My suggestions:

• Cables being TileEntities distributing power to its neighbors directly. Every cable has a IEnergyStorage. Would require power splitting on multiple neighbors. This would probably be very inefficient (based on other posts in this forum).

 

• Creating a WorldSavedData class, containing a List<List<BlockPos>> (note; this structure might be inefficient as well. Suggestions here are also welcome  ). Every time a cable block is placed, add it to the WorldSavedData. The First list represents one isolated network, the second all blocks in that network. By adding blocks to the network (and merging/splitting networks when needed), only one IEnergyStorage would be needed for one isolated network. This system would barely use tileEntities. Every cable TileEntity would have to store the corresponding network id (or a search in the List<List<BlockPos>> every time a power generator/consumer is placed). Therefore, this system may be redundant compared to next suggestion.

 

• Similar to the last one, but instead every Cable TileEntity keeping track of its own networkId. Merging of two networks would become more complex (TileEntities would need to update their neighbors, resulting in a chain reaction). This makes saves smaller. The previous system has an advantage, I believe copying all BlockPos from one net to another is performance-cheaper than executing this chain reaction. Not tested.

 

 

 

To those curious, this is my implementation of WorldSavedData (nbt saving not yet done):

package olle.techal.world;

import java.util.ArrayList;
import java.util.List;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.storage.MapStorage;
import net.minecraft.world.storage.WorldSavedData;
import olle.techal.Reference;
import olle.techal.Techal;

public class CableNetworkData extends WorldSavedData {

	private static final String dataIdentifier = Reference.MODID + "_cableNetwork";
	
	private List<List<BlockPos>> cableNetworks = new ArrayList<List<BlockPos>>();
	private int testData = 0;
	
	public CableNetworkData() {
		super(dataIdentifier);
	}
	public CableNetworkData(String name) {
		super(name);
	}

	@Override
	public void readFromNBT(NBTTagCompound compound) {
		testData = compound.getInteger("testData");
	}

	@Override
	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
		compound.setInteger("testData", testData);
		return compound;
	}

	
	public static CableNetworkData get(World world) {
		MapStorage storage = world.getPerWorldStorage();
		CableNetworkData instance = (CableNetworkData) storage.getOrLoadData(
				CableNetworkData.class, dataIdentifier);
		
		// If data doesn't exist, create it
		if (instance == null) {
			instance = new CableNetworkData();
			storage.setData(dataIdentifier, instance);
		}
		
		return instance;
	}
	
	public int addCable(BlockPos pos) {
		// Loop through all cableNetworks
		// If one entry in the cableNetwork is neighbor
		//		Add to that cableNetwork
		// If none, create new cableNetwork and add to that
		
		List<Integer> foundNetIds = new ArrayList<Integer>();
		
		for(int i = 0; i < cableNetworks.size(); i++) {
			for(BlockPos block : cableNetworks.get(i)) {
				if(isNeighbor(pos, block)) {
					foundNetIds.add(i);
					
					// Stop searching this network
					// One block means connected
					break;
				}
			}
		}
		
		// If foundNetIds contains more than one netId, 
		if(foundNetIds.size() > 1) {
			Techal.info("Found multiple (" + Integer.toString(foundNetIds.size()) + ") neighboring networks. merging down!");
			Techal.info(foundNetIds);
			
			
			// Merge all networks[foundNetIds]
			// Merge top down, deleting causes indexOutOfRange
			int rootId = foundNetIds.get(0);
			for(int i = foundNetIds.size() -1; i > 0; i--) {
				int branchId = foundNetIds.get(i);
				Techal.info("Merging net " + Integer.toString(branchId) + 
						" to root (net " + Integer.toString(rootId) + ")");
				
				Techal.info("to merge (net " + Integer.toString(branchId) + "): " + cableNetworks.get(branchId).toString());
				
				Techal.info("before (net " + Integer.toString(rootId) + "): " + cableNetworks.get(rootId).toString());
				
				cableNetworks.get(rootId).addAll(
						cableNetworks.get(branchId)
				);
				
				Techal.info("after (net " + Integer.toString(rootId) + "): " + cableNetworks.get(rootId).toString());
				
				// add remove old branch
				cableNetworks.remove(branchId);
			}
			cableNetworks.get(rootId).add(pos);
			return rootId;
					
		} else if(foundNetIds.size() == 1){
			Techal.info("Found a neighboring network.");
			// Get id
			int networkId = foundNetIds.get(0);
			
			// Add BlockPos to network networkId
			cableNetworks.get(networkId).add(pos);
			return networkId;
		}
		
		// If no neighboring network found
		Techal.info("Found no neighboring network. Creating new!");
		List<BlockPos> newNetwork = new ArrayList<BlockPos>();
		newNetwork.add(pos);
		cableNetworks.add(newNetwork);

		return cableNetworks.size()-1;
	}
	
	public void removeCable(BlockPos pos) {
		
	}
	
	public List<List<BlockPos>> getNetworks() {
		return cableNetworks;
	}
	
	
	
	// Returns true if a and b are neighbors (directly connected)
	private boolean isNeighbor(BlockPos a, BlockPos b) {
		// Test X
		if( a.getX() == b.getX()-1 && a.getY() == b.getY() && a.getZ() == b.getZ() ) return true;
		if( a.getX() == b.getX()+1 && a.getY() == b.getY() && a.getZ() == b.getZ() ) return true;
		
		// Test Y
		if( a.getX() == b.getX() && a.getY() == b.getY()-1 && a.getZ() == b.getZ() ) return true;
		if( a.getX() == b.getX() && a.getY() == b.getY()+1 && a.getZ() == b.getZ() ) return true;
		
		// Test Z
		if( a.getX() == b.getX() && a.getY() == b.getY() && a.getZ() == b.getZ()-1 ) return true;
		if( a.getX() == b.getX() && a.getY() == b.getY() && a.getZ() == b.getZ()+1 ) return true;
		
		return false;
	}
}

 

 

 

 

Do you have any other suggestions? Which of the above would be best scalable for performance (and world save size, but not as big of a priority). 

 

Any help would be appreciated!