Initial commit

1 files changed, 300 insertions, 0 deletions

diff --git a/ihl/flexible_cable/IHLGrid.java b/ihl/flexible_cable/IHLGrid.java
new file mode 100644
index 0000000..04a9d4c
--- /dev/null
+++ b/ihl/flexible_cable/IHLGrid.java
@@ -0,0 +1,300 @@
+package ihl.flexible_cable;

+

+import ihl.IHLMod;

+import ihl.interfaces.IEnergyNetNode;

+import ihl.utils.IHLUtils;

+

+import java.util.ArrayList;

+import java.util.HashMap;

+import java.util.HashSet;

+import java.util.Iterator;

+import java.util.List;

+import java.util.Map;

+import java.util.Set;

+

+import net.minecraft.nbt.NBTTagCompound;

+import net.minecraft.server.MinecraftServer;

+

+public class IHLGrid 

+{

+	private static final double powerLossLimitPerMeter=1.6D;

+	public final Set<IEnergyNetNode> telist = new HashSet();

+	public double energy=0D;

+	private IEnergyNetNode sink;

+	private IEnergyNetNode source;

+	private double voltage;

+	private short frequency=0;

+	private double lastVoltage;

+	public boolean isGridValid=true;

+	private double total20TicksEU;

+	private int lastTickCounter=0;

+	private int tickCounterFireStart=0;

+	public final List<IEnergyNetNode> calculatedSinks = new ArrayList();

+	public final List<IEnergyNetNode> calculatedSources = new ArrayList();

+	public final Set<NBTTagCompound> cablesOnFire = new HashSet();

+	private final Map<IEnergyNetNode, Double> energyLossSinkMap = new HashMap();

+	private final Map<IEnergyNetNode, Double> voltageSinkMap = new HashMap();

+	private double averageEUTransfered;

+	private double lastAverageEUTransfered=0D;

+	

+	public void drawEnergy(double amount, IEnergyNetNode sink1)

+	{

+		this.energy-=amount;

+		if(energyLossSinkMap.get(sink1)!=null)

+		{

+			this.energy-=energyLossSinkMap.get(sink1)*amount*amount;

+		}

+		else

+		{

+			this.telist.add(sink1);

+		}

+		this.sink=sink1;

+	}

+	

+	public void injectEnergy(double amount,	double voltage1, IEnergyNetNode source1) 

+	{

+    	this.energy+=amount;

+    	this.voltage=voltage1;

+   		this.source=source1;

+		this.total20TicksEU+=amount;

+		int tickCounter = MinecraftServer.getServer().getTickCounter();

+		if(tickCounter-lastTickCounter<0)

+		{

+			lastTickCounter=tickCounter;

+			this.total20TicksEU=0D;

+		}

+		Iterator<IEnergyNetNode> i = telist.iterator();

+		while(this.energy>1d && i.hasNext())

+		{

+			IEnergyNetNode eNode = i.next();

+			if(eNode.getEnergyAmountThisNodeWant()>0d)

+			{

+				double powerToInject = Math.min(energy,eNode.getEnergyAmountThisNodeWant());

+				eNode.injectEnergyInThisNode(powerToInject, this.getSinkVoltage(eNode));

+				this.energy-=powerToInject;

+				if(energyLossSinkMap.get(eNode)!=null)

+				{

+					this.energy-=energyLossSinkMap.get(eNode)*powerToInject*powerToInject;

+				}

+				else

+				{

+					this.sink=eNode;

+				}

+			}

+		}

+		int d=tickCounter-lastTickCounter;

+		if(d>=200)

+		{

+			this.averageEUTransfered=this.total20TicksEU/d;

+			lastTickCounter=tickCounter;

+			this.total20TicksEU=0D;

+			if(IHLMod.config.enableFlexibleCablesGridPowerLossCalculations && isGridValid && this.averageEUTransfered>1D)

+			{

+				this.telist.add(source1);

+				this.updateGrid();

+			}

+		}

+		d=tickCounter-tickCounterFireStart;

+		if(d>=200 && !this.cablesOnFire.isEmpty())

+		{

+			for(NBTTagCompound cable:this.cablesOnFire)

+			{

+    			this.removeCableAndSplitGrids(cable);

+			}

+			this.cablesOnFire.clear();

+		}

+

+	}

+	

+	public void removeCableAndSplitGrids(NBTTagCompound cable)

+	{

+		IHLUtils.removeChain(cable,null);

+		Iterator<IEnergyNetNode> atei = this.telist.iterator();

+		while(atei.hasNext())

+		{

+			IEnergyNetNode cte = atei.next();

+			cte.setGrid(-1);

+		}

+		IHLMod.enet.removeCableEntities(cable);

+		Iterator<IEnergyNetNode> atei2 = telist.iterator();

+		while(atei2.hasNext())

+		{

+			IEnergyNetNode cte = atei2.next();

+			if(cte.getGridID()==-1)//Warning! Potential future bugs are hidden here!

+			{

+				Iterator<IEnergyNetNode> atei3 = telist.iterator();

+				while(atei3.hasNext())

+				{

+					IEnergyNetNode cte2 = atei3.next();

+					if(cte2!=cte && IHLMod.enet.hasSame(cte.getCableList(),cte2.getCableList()))

+					{

+						int result=IHLMod.enet.mergeGrids(cte.getGridID(), cte2.getGridID());

+						cte.setGrid(result);

+						cte2.setGrid(result);

+						break;

+					}

+				}

+				

+			}

+		}

+	}

+	

+	private void updateGrid()

+	{

+		if(this.source!=null && 

+		this.sink!=null && 

+		this.source!=this.sink &&

+		!this.sink.getCableList().isEmpty() &&

+		!this.source.getCableList().isEmpty() &&

+		(!this.calculatedSources.contains(this.source) || 

+		!this.calculatedSinks.contains(this.sink) || 

+		this.averageEUTransfered>this.lastAverageEUTransfered ||

+		this.voltage!=this.lastVoltage))

+		{

+			Map<IEnergyNetNode, NBTTagCompound> map = new HashMap();

+			Set<IEnergyNetNode> templist = new HashSet();

+			Set<IEnergyNetNode> processlist = new HashSet();

+			Set<IEnergyNetNode> templist2 = new HashSet();

+			templist.addAll(telist);

+			processlist.add(sink);

+			int threads=0;

+			a: while(!templist.isEmpty())

+			{

+				if(threads++>1000)

+				{

+					this.isGridValid=false;

+					return;

+				}

+				templist.removeAll(processlist);

+				templist2.clear();

+				Iterator<IEnergyNetNode> it1 = processlist.iterator();

+				while(it1.hasNext())

+				{

+					if(threads++>1000)

+					{

+						this.isGridValid=false;

+						return;

+					}

+					IEnergyNetNode ate1 = it1.next();

+					Iterator<IEnergyNetNode> it2 = templist.iterator();

+					while(it2.hasNext())

+					{

+						if(threads++>1000)

+						{

+							this.isGridValid=false;

+							return;

+						}

+						IEnergyNetNode ate2 = it2.next();

+						if(ate1!=ate2)

+						{

+							NBTTagCompound cable = this.getSame(ate1.getCableList(), ate2.getCableList());

+							if(cable!=null)

+							{

+								map.put(ate2, cable);

+								templist2.add(ate2);

+								if(ate2==source)

+								{

+									break a;

+								}

+							}

+						}

+					}

+					templist.removeAll(templist2);

+				}

+				processlist.clear();

+				processlist.addAll(templist2);

+			}

+			IEnergyNetNode cursor=source;

+			{

+				double voltage1=this.voltage;

+				double euTransfered=this.averageEUTransfered;

+				double voltageLossPerMeter=0D;

+				double powerLossPerMeter=0D;

+				double powerLossPerSquaredEU=0D;

+				this.energyLossSinkMap.remove(sink);

+				this.voltageSinkMap.remove(sink);

+				while(cursor!=sink)

+				{

+					//System.out.println("cycle 4");

+					NBTTagCompound cable = map.get(cursor);

+					voltageLossPerMeter=IHLUtils.getResistance(cable)/1000D*euTransfered/voltage1;

+					powerLossPerMeter=voltageLossPerMeter*euTransfered/voltage1;

+					euTransfered-=powerLossPerMeter*cable.getInteger("length");

+					voltage1-=voltageLossPerMeter*cable.getInteger("length");

+					powerLossPerSquaredEU+=IHLUtils.getResistance(cable)/1000d*cable.getInteger("length")/voltage1/voltage1;

+					//System.out.println("voltageLossPerMeter=" + voltageLossPerMeter);

+					//System.out.println("powerLossPerMeter=" + powerLossPerMeter);

+					//System.out.println("euTransfered=" + euTransfered);

+					//System.out.println("voltage1=" + voltage1);

+					//System.out.println("powerLossPerSquaredEU=" + powerLossPerSquaredEU);

+					if(!this.cablesOnFire.contains(cable) && (powerLossPerMeter>IHLGrid.powerLossLimitPerMeter))

+					{

+						IHLMod.enet.setOnFire(cable);

+						tickCounterFireStart=lastTickCounter;

+						this.cablesOnFire.add(cable);

+					}

+					cursor=this.getHasCable(cable, cursor);

+				}

+				this.energyLossSinkMap.put(sink, powerLossPerSquaredEU);

+				this.voltageSinkMap.put(sink, voltage1);

+			}

+			this.calculatedSources.add(this.source);

+			this.calculatedSinks.add(this.sink); 

+			this.lastAverageEUTransfered=this.averageEUTransfered;

+			this.lastVoltage=this.voltage;

+		}

+	}

+	

+	private NBTTagCompound getSame(Set<NBTTagCompound> set, Set<NBTTagCompound> set2)

+	{

+		Iterator<NBTTagCompound> i1 = set.iterator();

+		while(i1.hasNext())

+		{

+			NBTTagCompound cable=i1.next();

+			if(set2.contains(cable))

+			{

+				return cable;

+			}

+		}

+		return null;

+	}

+	

+	public double getSinkVoltage(IEnergyNetNode node)

+	{

+		if(this.voltageSinkMap.containsKey(node))

+		{

+			return this.voltageSinkMap.get(node);

+		}

+		else

+		{

+			return this.voltage;

+		}

+	}

+	

+	private IEnergyNetNode getHasCable(NBTTagCompound cable, IEnergyNetNode exclude)

+	{

+		Iterator<IEnergyNetNode> it1 = this.telist.iterator();

+		while(it1.hasNext())

+		{

+			IEnergyNetNode ate1 = it1.next();

+			if(ate1!=exclude && ate1.getCableList().contains(cable))

+			{

+				return ate1;

+			}

+		}

+		return null;

+	}

+

+	public void add(IEnergyNetNode e) 

+	{

+		this.telist.add(e);

+		this.isGridValid=true;

+		if(!e.getCableList().isEmpty())

+		{

+			for(NBTTagCompound cable:e.getCableList())

+			{

+				IHLMod.enet.cablesToGrids.put(cable.getInteger("chainUID"), this);

+			}

+		}

+	}

+}