From 877312184c472d9845e5ef1008bc538f4634059f Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:50:56 +0300 Subject: fix missing source folder --- main/java/ihl/flexible_cable/AnchorTileEntity.java | 342 +++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 main/java/ihl/flexible_cable/AnchorTileEntity.java (limited to 'main/java/ihl/flexible_cable/AnchorTileEntity.java') diff --git a/main/java/ihl/flexible_cable/AnchorTileEntity.java b/main/java/ihl/flexible_cable/AnchorTileEntity.java new file mode 100644 index 0000000..488e89b --- /dev/null +++ b/main/java/ihl/flexible_cable/AnchorTileEntity.java @@ -0,0 +1,342 @@ +package ihl.flexible_cable; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +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.interfaces.IEnergyNetNode; +import ihl.interfaces.IMultiPowerCableHolder; +import ihl.utils.IHLUtils; +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.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 sacrifices = new HashSet(); + 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 getNetworkedFields() { + List 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() { + super.onUnloaded(); + if (IC2.platform.isSimulating()) { + if (this.addedToEnergyNet) { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); + this.addedToEnergyNet = false; + } + for (SubAnchorEnergyNetNode sen : energyNetNodes) { + sen.onUnloaded(); + } + + } + } + + @Override + public boolean wrenchCanRemove(EntityPlayer var1) { + return false; + } + + public boolean enableUpdateEntity() { + return IC2.platform.isSimulating(); + } + + @Override + public void updateEntityServer() { + if (!sacrifices.isEmpty()) { + Iterator 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) { + if (direction != ForgeDirection.UNKNOWN) { + return this.energyNetNodes[direction.getOpposite().ordinal()].getGridID() != -1; + } + 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 teset = new HashSet(); + 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) { + if (directionFrom != ForgeDirection.UNKNOWN) { + return this.energyNetNodes[directionFrom.getOpposite().ordinal()].injectEnergyToGrid(amount); + } + 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 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); + } + } + + @Override + 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(); + } + + } + + public boolean isTileEntityInvalid() { + return this.tileEntityInvalid; + } +} -- cgit v1.2.3