From 05c78126859231a68e199dc34613689bd0978e2f Mon Sep 17 00:00:00 2001
From: Foghrye4 <foghrye4@gmail.com>
Date: Mon, 11 Apr 2016 19:44:54 +0300
Subject: Initial commit

---
 ihl/flexible_cable/AnchorTileEntity.java | 446 +++++++++++++++++++++++++++++++
 1 file changed, 446 insertions(+)
 create mode 100644 ihl/flexible_cable/AnchorTileEntity.java

(limited to 'ihl/flexible_cable/AnchorTileEntity.java')

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();
+		}
+
+	}
+}
-- 
cgit v1.2.3