Initial commit

1 files changed, 446 insertions, 0 deletions

diff --git a/ihl/flexible_cable/AnchorTileEntity.java b/ihl/flexible_cable/AnchorTileEntity.java
new file mode 100644
index 0000000..b9057ba
--- /dev/null
+++ b/ihl/flexible_cable/AnchorTileEntity.java
@@ -0,0 +1,446 @@
+package ihl.flexible_cable;

+

+import ic2.api.energy.EnergyNet;

+import ic2.api.energy.event.EnergyTileLoadEvent;

+import ic2.api.energy.event.EnergyTileUnloadEvent;

+import ic2.api.energy.tile.IEnergySink;

+import ic2.api.energy.tile.IEnergySource;

+import ic2.core.ExplosionIC2;

+import ic2.core.IC2;

+import ic2.core.block.TileEntityBlock;

+import ihl.IHLMod;

+import ihl.interfaces.ICableHolder;

+import ihl.interfaces.IEnergyNetNode;

+import ihl.interfaces.IMultiPowerCableHolder;

+import ihl.utils.IHLUtils;

+

+import java.util.HashSet;

+import java.util.Iterator;

+import java.util.List;

+import java.util.Set;

+

+import net.minecraft.entity.EntityLivingBase;

+import net.minecraft.entity.item.EntityItem;

+import net.minecraft.entity.player.EntityPlayer;

+import net.minecraft.item.ItemStack;

+import net.minecraft.nbt.NBTTagCompound;

+import net.minecraft.nbt.NBTTagList;

+import net.minecraft.tileentity.TileEntity;

+import net.minecraft.util.AxisAlignedBB;

+import net.minecraft.world.World;

+import net.minecraftforge.common.MinecraftForge;

+import net.minecraftforge.common.util.ForgeDirection;

+

+public class AnchorTileEntity extends TileEntityBlock implements IEnergySink, IEnergySource, IMultiPowerCableHolder 

+{

+	public boolean addedToEnergyNet=false;

+	public final Set<TileEntity> sacrifices = new HashSet<TileEntity>();

+	public SubAnchorEnergyNetNode[] energyNetNodes = new SubAnchorEnergyNetNode[6];

+	public boolean[] hasCableOnSide=new boolean [] {false,false,false,false,false,false};

+	public int checksum=-1;

+	public boolean checkCables=true;

+	

+	public AnchorTileEntity()

+	{

+		super();

+		for(short i=0;i<6;i++)

+		{

+			energyNetNodes[i] = new SubAnchorEnergyNetNode(this, i);

+		}

+	}

+	

+	@Override

+    public List<String> getNetworkedFields()

+    {

+		List<String> fields = super.getNetworkedFields();

+		fields.add("hasCableOnSide");

+		return fields;

+    }

+	

+    @Override

+	public void onLoaded()

+    {

+        super.onLoaded();

+		for(short i=0;i<6;i++)

+		{

+			energyNetNodes[i].onLoaded();

+		}

+        if (IC2.platform.isSimulating()&&!this.addedToEnergyNet)

+        {

+            MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));

+            this.addedToEnergyNet = true;

+        }

+    }

+    

+    @Override

+    public void onUnloaded()

+    {

+        if (IC2.platform.isSimulating())

+        {

+        	if(this.addedToEnergyNet)

+        	{

+        		MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));

+            	this.addedToEnergyNet = false;

+        	}

+        }

+    }

+    

+    @Override

+    public boolean wrenchCanRemove(EntityPlayer var1)

+    {

+    	return false;

+    }

+    

+    public boolean enableUpdateEntity()

+    {

+        return IC2.platform.isSimulating();

+    }

+    

+    @Override

+	public void updateEntityServer()

+    {

+    	if(!sacrifices.isEmpty())

+    	{

+    		Iterator<TileEntity> victimIterator = sacrifices.iterator();

+    		while(victimIterator.hasNext())

+    		{

+    			TileEntity sacrifice = victimIterator.next();

+            	ExplosionIC2 explosion = new ExplosionIC2(this.worldObj, null, sacrifice.xCoord+0.5D, sacrifice.yCoord+0.5D, sacrifice.zCoord+0.5D, 3F, 0.3F, ExplosionIC2.Type.Normal, null, 0);

+            	explosion.doExplosion();

+            	sacrifices.remove(sacrifice);

+    		}

+

+    	}

+		int newchecksum=0;

+		for(short i=0;i<6;i++)

+		{

+			if(this.hasCableOnSide[i])

+			{

+				newchecksum++;

+			}

+		}

+		if(newchecksum!=checksum)

+		{

+			IC2.network.get().updateTileEntityField(this, "hasCableOnSide");	   							

+			checksum=newchecksum;

+		}

+    }

+

+	@Override

+	public void writeToNBT(NBTTagCompound nbt) {

+        super.writeToNBT(nbt);

+        NBTTagList energyNetNodeNBTList = new NBTTagList();

+        for(SubAnchorEnergyNetNode node:this.energyNetNodes)

+        {

+        	energyNetNodeNBTList.appendTag(node.writeToNBT());

+        }

+        nbt.setTag("energyNetNodes", energyNetNodeNBTList);

+        nbt.setBoolean("checkCables", this.checkCables);

+	}

+

+	@Override

+	public void readFromNBT(NBTTagCompound nbt) {

+        super.readFromNBT(nbt);

+		if(!nbt.hasKey("energyNetNodes"))

+        {

+        	short facing = nbt.getShort("facing");

+            int gridID=nbt.getInteger("gridID");

+            this.energyNetNodes[facing].setGrid(gridID);

+            NBTTagList cableNBTList=nbt.getTagList("cableList", 10);

+            for(int i=0;i<cableNBTList.tagCount();i++)

+            {

+            	this.energyNetNodes[facing].addCable(cableNBTList.getCompoundTagAt(i));

+            }

+        }

+		else

+		{

+	        NBTTagList energyNetNodeNBTList=nbt.getTagList("energyNetNodes", 10);

+	        for(int i=0;i<6;i++)

+	        {

+	            this.energyNetNodes[i].readFromNBT(energyNetNodeNBTList.getCompoundTagAt(i));

+	        }

+		}

+		this.checkCables=nbt.getBoolean("checkCables");

+	}

+

+	@Override

+	public void setFacing(short facing)

+	{

+		this.energyNetNodes[facing].removeAttachedChains();

+    	boolean removeTE=true;

+		for(short i=0;i<6;i++)

+		{

+			if(!energyNetNodes[i].getCableList().isEmpty())

+			{

+				removeTE=false;

+			}

+		}

+		if(removeTE)

+		{

+			worldObj.setBlockToAir(xCoord, yCoord, zCoord);

+		}

+	}

+

+	@Override

+	public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) 

+	{

+		switch(direction)

+		{

+		case UP:

+			return this.energyNetNodes[0].getGridID()!=-1;

+		case DOWN:

+			return this.energyNetNodes[1].getGridID()!=-1;

+		case SOUTH:

+			return this.energyNetNodes[2].getGridID()!=-1;

+		case NORTH:

+			return this.energyNetNodes[3].getGridID()!=-1;

+		case EAST:

+			return this.energyNetNodes[4].getGridID()!=-1;

+		case WEST:

+			return this.energyNetNodes[5].getGridID()!=-1;

+		default:

+			return false;

+		}

+	}

+

+	@Override

+	public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) 

+	{

+		return this.acceptsEnergyFrom(receiver, direction);

+	}

+

+	@Override

+	public double getOfferedEnergy() 

+	{

+		double offeredEnergy=0d;

+		for(short i=0;i<6;i++)

+		{

+			offeredEnergy+=energyNetNodes[i].getEnergyOfferedByGrid();

+		}

+		return offeredEnergy;

+	}

+

+	@Override

+	public void drawEnergy(double amount) 

+	{

+		for(short i=0;i<6;i++)

+		{

+			amount-=energyNetNodes[i].drawEnergyFromGrid(amount);

+			double voltage = energyNetNodes[i].getVoltage();

+			if(voltage>500D)

+			{

+				Set<TileEntity> teset = new HashSet<TileEntity>(); 

+				ForgeDirection direction = ForgeDirection.getOrientation(i).getOpposite();

+				TileEntity te = EnergyNet.instance.getNeighbor(this, direction);

+				teset.add(te);

+				TileEntity te1 = this.getSink(te, teset);

+				if(te1 instanceof IEnergyNetNode)

+				{

+					if(((IEnergyNetNode)te1).getMaxAllowableVoltage()>=voltage)

+					{

+						return;

+					}

+				}

+				if(te1!=null)

+				{

+					sacrifices.add(te1);

+				}

+			}

+			if(amount<=0d)

+			{

+				break;

+			}

+		}

+	}

+

+	@Override

+	public int getSourceTier() {

+		return 4;

+	}

+

+	@Override

+	public double getDemandedEnergy() 

+	{

+		double amount=0d;

+		for(short i=0;i<6;i++)

+		{

+			amount+=energyNetNodes[i].getDemandedEnergy();

+		}

+		return amount;

+	}

+

+	@Override

+	public int getSinkTier() {

+		return 4;

+	}

+

+	@Override

+	public double injectEnergy(ForgeDirection directionFrom, double amount,	double voltage) 

+	{

+		switch(directionFrom)

+		{

+		case UP:

+			return this.energyNetNodes[0].injectEnergyToGrid(amount);

+		case DOWN:

+			return this.energyNetNodes[1].injectEnergyToGrid(amount);

+		case SOUTH:

+			return this.energyNetNodes[2].injectEnergyToGrid(amount);

+		case NORTH:

+			return this.energyNetNodes[3].injectEnergyToGrid(amount);

+		case EAST:

+			return this.energyNetNodes[4].injectEnergyToGrid(amount);

+		case WEST:

+			return this.energyNetNodes[5].injectEnergyToGrid(amount);

+		default:

+			return amount;

+		}

+	}

+	

+	@Override

+	public ItemStack getWrenchDrop(EntityPlayer entityPlayer)

+	{

+		return null;

+	}

+

+	@Override

+	public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) 

+	{

+		return !this.wrenchCanRemove(entityPlayer);

+	}

+	

+	public TileEntity getSink(TileEntity te, Set<TileEntity> teset)

+	{

+		teset.add(te);

+		while(te!=null && !(te instanceof IEnergySink))

+		{

+			TileEntity te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.NORTH);

+			if(te1==null || teset.contains(te1))

+			{

+				te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.SOUTH);

+			}

+			else

+			{

+				TileEntity te2 = this.getSink(te1, teset);

+				if(te2!=null)

+				{

+					return te2;

+				}

+			}

+			if(te1==null || teset.contains(te1))

+			{

+				te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.UP);

+			}

+			else

+			{

+				TileEntity te2 = this.getSink(te1, teset);

+				if(te2!=null)

+				{

+					return te2;

+				}

+			}

+			if(te1==null || teset.contains(te1))

+			{

+				te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.DOWN);

+			}

+			else

+			{

+				TileEntity te2 = this.getSink(te1, teset);

+				if(te2!=null)

+				{

+					return te2;

+				}

+			}

+			if(te1==null || teset.contains(te1))

+			{

+				te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.WEST);

+			}

+			else

+			{

+				TileEntity te2 = this.getSink(te1, teset);

+				if(te2!=null)

+				{

+					return te2;

+				}

+			}

+			if(te1==null || teset.contains(te1))

+			{

+				te1 = EnergyNet.instance.getNeighbor(te, ForgeDirection.EAST);

+			}

+			else

+			{

+				TileEntity te2 = this.getSink(te1, teset);

+				if(te2!=null)

+				{

+					return te2;

+				}

+			}

+			if(te1!=null)

+			{

+				teset.add(te1);

+			}

+			te=te1;

+		}

+		if(te instanceof IEnergySink)

+		{

+			return te;

+		}

+		else

+		{

+			return null;

+		}

+	}

+

+	public void checkIfNoCablesLeft() 

+	{

+		boolean noCables=true;

+		for(SubAnchorEnergyNetNode sen:energyNetNodes)

+		{

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

+			{

+				noCables=false;

+			}

+		}

+		if(noCables)

+		{

+			worldObj.setBlockToAir(xCoord, yCoord, zCoord);

+		}

+	}

+

+	public boolean isCableRemoved(int chainUniqueID) 

+	{

+		if(!checkCables)

+		{

+			return false;

+		}

+		for(SubAnchorEnergyNetNode sen:energyNetNodes)

+		{

+			if(!sen.isCableRemoved(chainUniqueID))

+			{

+				return false;

+			}

+		}

+		return true;

+	}

+

+	@Override

+	public IEnergyNetNode getEnergyNetNode(short facing) 

+	{

+		return energyNetNodes[facing];

+	}

+

+	@Override

+	public short getSide(EntityPlayer player) 

+	{

+		return IHLUtils.getFacingFromPlayerView(player, true);

+	}

+

+	@Override

+	public void removeAttachedChains() 

+	{

+		for(short i=0;i<6;i++)

+		{

+			energyNetNodes[i].removeAttachedChains();

+		}

+

+	}

+}