diff options
Diffstat (limited to 'main/java/ihl/flexible_cable/AnchorTileEntity.java')
| -rw-r--r-- | main/java/ihl/flexible_cable/AnchorTileEntity.java | 342 |
1 files changed, 342 insertions, 0 deletions
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<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() {
+ 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<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) {
+ 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<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) {
+ 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<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);
+ }
+ }
+
+ @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;
+ }
+}
|