diff options
Diffstat (limited to 'src/Java/miscutil')
14 files changed, 1946 insertions, 0 deletions
diff --git a/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java b/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java new file mode 100644 index 0000000000..f8786fd578 --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/ConduitGTHandler.java @@ -0,0 +1,76 @@ +package miscutil.enderio.conduit; + +import gregtech.api.interfaces.tileentity.IEnergyConnected; +import gregtech.api.metatileentity.BaseTileEntity; +import mekanism.api.gas.GasStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +public class ConduitGTHandler extends BaseTileEntity implements IEnergyConnected{ + + @Override + public byte getColorization() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public byte setColorization(byte arg0) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public long getTimer() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public boolean isInvalidTileEntity() { + // TODO Auto-generated method stub + return false; + } + + @Override + public void readFromNBT(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void setLightValue(byte arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void writeToNBT(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + public long injectEnergyUnits(byte arg0, long arg1, long arg2) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public boolean inputEnergyFrom(byte arg0) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean outputsEnergyTo(byte arg0) { + // TODO Auto-generated method stub + return false; + } + + public int receiveGas(ForgeDirection dir, GasStack offer) { + // TODO Auto-generated method stub + return 0; + } + +} diff --git a/src/Java/miscutil/enderio/conduit/Conduit_Base.java b/src/Java/miscutil/enderio/conduit/Conduit_Base.java new file mode 100644 index 0000000000..7a4b6ac1cf --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/Conduit_Base.java @@ -0,0 +1,415 @@ +package miscutil.enderio.conduit; + +import gregtech.api.interfaces.tileentity.IEnergyConnected; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraftforge.fluids.IFluidHandler; + +public class Conduit_Base implements IEnergyConnected{ + + @Override + public byte getColorization() { + + return 0; + } + + @Override + public byte setColorization(byte aColor) { + + return 0; + } + + @Override + public World getWorld() { + + return null; + } + + @Override + public int getXCoord() { + + return 0; + } + + @Override + public short getYCoord() { + + return 0; + } + + @Override + public int getZCoord() { + + return 0; + } + + @Override + public boolean isServerSide() { + + return false; + } + + @Override + public boolean isClientSide() { + + return false; + } + + @Override + public int getRandomNumber(int aRange) { + + return 0; + } + + @Override + public TileEntity getTileEntity(int aX, int aY, int aZ) { + + return null; + } + + @Override + public TileEntity getTileEntityOffset(int aX, int aY, int aZ) { + + return null; + } + + @Override + public TileEntity getTileEntityAtSide(byte aSide) { + + return null; + } + + @Override + public TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance) { + + return null; + } + + @Override + public IInventory getIInventory(int aX, int aY, int aZ) { + + return null; + } + + @Override + public IInventory getIInventoryOffset(int aX, int aY, int aZ) { + + return null; + } + + @Override + public IInventory getIInventoryAtSide(byte aSide) { + + return null; + } + + @Override + public IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance) { + + return null; + } + + @Override + public IFluidHandler getITankContainer(int aX, int aY, int aZ) { + + return null; + } + + @Override + public IFluidHandler getITankContainerOffset(int aX, int aY, int aZ) { + + return null; + } + + @Override + public IFluidHandler getITankContainerAtSide(byte aSide) { + + return null; + } + + @Override + public IFluidHandler getITankContainerAtSideAndDistance(byte aSide, + int aDistance) { + + return null; + } + + @Override + public IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ) { + + return null; + } + + @Override + public IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, + int aZ) { + + return null; + } + + @Override + public IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide) { + + return null; + } + + @Override + public IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance( + byte aSide, int aDistance) { + + return null; + } + + @Override + public Block getBlock(int aX, int aY, int aZ) { + + return null; + } + + @Override + public Block getBlockOffset(int aX, int aY, int aZ) { + + return null; + } + + @Override + public Block getBlockAtSide(byte aSide) { + + return null; + } + + @Override + public Block getBlockAtSideAndDistance(byte aSide, int aDistance) { + + return null; + } + + @Override + public byte getMetaID(int aX, int aY, int aZ) { + + return 0; + } + + @Override + public byte getMetaIDOffset(int aX, int aY, int aZ) { + + return 0; + } + + @Override + public byte getMetaIDAtSide(byte aSide) { + + return 0; + } + + @Override + public byte getMetaIDAtSideAndDistance(byte aSide, int aDistance) { + + return 0; + } + + @Override + public byte getLightLevel(int aX, int aY, int aZ) { + + return 0; + } + + @Override + public byte getLightLevelOffset(int aX, int aY, int aZ) { + + return 0; + } + + @Override + public byte getLightLevelAtSide(byte aSide) { + + return 0; + } + + @Override + public byte getLightLevelAtSideAndDistance(byte aSide, int aDistance) { + + return 0; + } + + @Override + public boolean getOpacity(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getOpacityOffset(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getOpacityAtSide(byte aSide) { + + return false; + } + + @Override + public boolean getOpacityAtSideAndDistance(byte aSide, int aDistance) { + + return false; + } + + @Override + public boolean getSky(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getSkyOffset(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getSkyAtSide(byte aSide) { + + return false; + } + + @Override + public boolean getSkyAtSideAndDistance(byte aSide, int aDistance) { + + return false; + } + + @Override + public boolean getAir(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getAirOffset(int aX, int aY, int aZ) { + + return false; + } + + @Override + public boolean getAirAtSide(byte aSide) { + + return false; + } + + @Override + public boolean getAirAtSideAndDistance(byte aSide, int aDistance) { + + return false; + } + + @Override + public BiomeGenBase getBiome() { + + return null; + } + + @Override + public BiomeGenBase getBiome(int aX, int aZ) { + + return null; + } + + @Override + public int getOffsetX(byte aSide, int aMultiplier) { + + return 0; + } + + @Override + public short getOffsetY(byte aSide, int aMultiplier) { + + return 0; + } + + @Override + public int getOffsetZ(byte aSide, int aMultiplier) { + + return 0; + } + + @Override + public boolean isDead() { + + return false; + } + + @Override + public void sendBlockEvent(byte aID, byte aValue) { + + + } + + @Override + public long getTimer() { + + return 0; + } + + @Override + public void setLightValue(byte aLightValue) { + + + } + + @Override + public void writeToNBT(NBTTagCompound aNBT) { + + + } + + @Override + public void readFromNBT(NBTTagCompound aNBT) { + + + } + + @Override + public boolean isInvalidTileEntity() { + + return false; + } + + @Override + public boolean openGUI(EntityPlayer aPlayer, int aID) { + + return false; + } + + @Override + public boolean openGUI(EntityPlayer aPlayer) { + + return false; + } + + @Override + public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + + return 0; + } + + @Override + public boolean inputEnergyFrom(byte aSide) { + + return false; + } + + @Override + public boolean outputsEnergyTo(byte aSide) { + + return false; + } + +} diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java new file mode 100644 index 0000000000..de0fc13371 --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtConduit.java @@ -0,0 +1,73 @@ +package miscutil.enderio.conduit.GregTech; + +import mekanism.api.gas.Gas; +import mekanism.api.gas.GasStack; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.common.util.ForgeDirection; +import crazypants.enderio.conduit.AbstractConduitNetwork; +import crazypants.enderio.conduit.gas.AbstractGasConduit; +import crazypants.enderio.conduit.geom.CollidableComponent; + +public class AbstractGtConduit extends AbstractGasConduit{ + + @Override + public ItemStack createItem() { + // TODO Auto-generated method stub + return null; + } + + @Override + public AbstractConduitNetwork<?, ?> getNetwork() { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean setNetwork(AbstractConduitNetwork<?, ?> network) { + // TODO Auto-generated method stub + return false; + } + + @Override + public IIcon getTextureForState(CollidableComponent component) { + // TODO Auto-generated method stub + return null; + } + + @Override + public IIcon getTransmitionTextureForState(CollidableComponent component) { + // TODO Auto-generated method stub + return null; + } + + @Override + public int receiveGas(ForgeDirection side, GasStack stack) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public GasStack drawGas(ForgeDirection side, int amount) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean canReceiveGas(ForgeDirection side, Gas type) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean canDrawGas(ForgeDirection side, Gas type) { + // TODO Auto-generated method stub + return false; + } + + protected boolean canJoinNeighbour(IGtConduit n) { + // TODO Auto-generated method stub + return false; + } + +} diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java new file mode 100644 index 0000000000..1b440aa0bb --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduit.java @@ -0,0 +1,161 @@ +package miscutil.enderio.conduit.GregTech; + +import java.util.List; + +import mekanism.api.gas.GasStack; +import mekanism.api.gas.IGasHandler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; +import crazypants.enderio.conduit.AbstractConduitNetwork; +import crazypants.enderio.conduit.ConduitUtil; +import crazypants.enderio.conduit.ConnectionMode; +import crazypants.enderio.conduit.RaytraceResult; +import crazypants.enderio.tool.ToolUtil; +import crazypants.util.BlockCoord; + +public abstract class AbstractGtTankConduit extends AbstractGtConduit { + + protected ConduitGtTank tank = new ConduitGtTank(0); + protected boolean stateDirty = false; + protected long lastEmptyTick = 0; + protected int numEmptyEvents = 0; + + @Override + public boolean onBlockActivated(EntityPlayer player, RaytraceResult res, List<RaytraceResult> all) { + if(player.getCurrentEquippedItem() == null) { + return false; + } + if(ToolUtil.isToolEquipped(player)) { + + if(!getBundle().getEntity().getWorldObj().isRemote) { + + if(res != null && res.component != null) { + + ForgeDirection connDir = res.component.dir; + ForgeDirection faceHit = ForgeDirection.getOrientation(res.movingObjectPosition.sideHit); + + if(connDir == ForgeDirection.UNKNOWN || connDir == faceHit) { + + if(getConnectionMode(faceHit) == ConnectionMode.DISABLED) { + setConnectionMode(faceHit, getNextConnectionMode(faceHit)); + return true; + } + + BlockCoord loc = getLocation().getLocation(faceHit); + IGtConduit n = ConduitUtil.getConduit(getBundle().getEntity().getWorldObj(), loc.x, loc.y, loc.z, IGtConduit.class); + if(n == null) { + return false; + } + if(!canJoinNeighbour(n)) { + return false; + } + if(!(n instanceof AbstractGtTankConduit)) { + return false; + } + AbstractGtTankConduit neighbour = (AbstractGtTankConduit) n; + if(neighbour.getGasType() == null || getGasType() == null) { + GasStack type = getGasType(); + type = type != null ? type : neighbour.getGasType(); + neighbour.setGasTypeOnNetwork(neighbour, type); + setGasTypeOnNetwork(this, type); + } + return ConduitUtil.joinConduits(this, faceHit); + } else if(containsExternalConnection(connDir)) { + // Toggle extraction mode + setConnectionMode(connDir, getNextConnectionMode(connDir)); + } else if(containsConduitConnection(connDir)) { + GasStack curGasType = null; + if(getTankNetwork() != null) { + curGasType = getTankNetwork().getGasType(); + } + ConduitUtil.disconectConduits(this, connDir); + setGasType(curGasType); + + } + } + } + return true; + + } + + return false; + } + + private void setGasTypeOnNetwork(AbstractGtTankConduit con, GasStack type) { + AbstractConduitNetwork<?, ?> n = con.getNetwork(); + if(n != null) { + AbstractGtTankConduitNetwork<?> network = (AbstractGtTankConduitNetwork<?>) n; + network.setGasType(type); + } + + } + + protected abstract boolean canJoinNeighbour(IGtConduit n); + + public abstract AbstractGtTankConduitNetwork<? extends AbstractGtTankConduit> getTankNetwork(); + + public void setGasType(GasStack gasType) { + if(tank.getGas() != null && tank.getGas().isGasEqual(gasType)) { + return; + } + if(gasType != null) { + gasType = gasType.copy(); + } else if(tank.getGas() == null) { + return; + } + tank.setGas(gasType); + stateDirty = true; + } + + public ConduitGtTank getTank() { + return tank; + } + + public GasStack getGasType() { + GasStack result = null; + if(getTankNetwork() != null) { + result = getTankNetwork().getGasType(); + } + if(result == null) { + result = tank.getGas(); + } + return result; + } + + @Override + public boolean canOutputToDir(ForgeDirection dir) { + if (super.canOutputToDir(dir)) { + IGasHandler ext = getExternalHandler(dir); + return ext != null && ext.canReceiveGas(dir.getOpposite(), tank.getGasType()); + } + return false; + } + + protected abstract void updateTank(); + + @Override + public void readFromNBT(NBTTagCompound nbtRoot, short nbtVersion) { + super.readFromNBT(nbtRoot, nbtVersion); + updateTank(); + if(nbtRoot.hasKey("tank")) { + GasStack gas = GasStack.readFromNBT(nbtRoot.getCompoundTag("tank")); + tank.setGas(gas); + } else { + tank.setGas(null); + } + } + + @Override + public void writeToNBT(NBTTagCompound nbtRoot) { + super.writeToNBT(nbtRoot); + GasStack gt = getGasType(); + if(GtUtil.isGasValid(gt)) { + updateTank(); + gt = gt.copy(); + gt.amount = tank.getStored(); + nbtRoot.setTag("tank", gt.write(new NBTTagCompound())); + } + } + +} diff --git a/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java new file mode 100644 index 0000000000..8cd720fa18 --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/GregTech/AbstractGtTankConduitNetwork.java @@ -0,0 +1,64 @@ +package miscutil.enderio.conduit.GregTech; + +import mekanism.api.gas.GasStack; +import crazypants.enderio.conduit.AbstractConduitNetwork; + +public class AbstractGtTankConduitNetwork<T extends AbstractGtTankConduit> extends AbstractConduitNetwork<IGtConduit, T> { + + protected GasStack gasType; + + protected AbstractGtTankConduitNetwork(Class<T> cl) { + super(cl); + } + + public GasStack getGasType() { + return gasType; + } + + @Override + public Class<IGtConduit> getBaseConduitType() { + return IGtConduit.class; + } + + @Override + public void addConduit(T con) { + super.addConduit(con); + con.setGasType(gasType); + } + + public boolean setGasType(GasStack newType) { + if(gasType != null && gasType.isGasEqual(newType)) { + return false; + } + if(newType != null) { + gasType = newType.copy(); + gasType.amount = 0; + } else { + gasType = null; + } + for (AbstractGtTankConduit conduit : conduits) { + conduit.setGasType(gasType); + } + return true; + } + + public boolean canAcceptGas(GasStack acceptable) { + return areGassCompatable(gasType, acceptable); + } + + public static boolean areGassCompatable(GasStack a, GasStack b) { + if(a == null || b == null) { + return true; + } + return a.isGasEqual(b); + } + + public int getTotalVolume() { + int totalVolume = 0; + for (T con : conduits) { + totalVolume += con.getTank().getStored(); + } + return totalVolume; + } + +} diff --git a/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java b/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java new file mode 100644 index 0000000000..d1a81f32d2 --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/GregTech/ConduitGtTank.java @@ -0,0 +1,153 @@ +package miscutil.enderio.conduit.GregTech; + +import mekanism.api.gas.GasStack; +import mekanism.api.gas.GasTank; +import net.minecraft.nbt.NBTTagCompound; + +public class ConduitGtTank extends GasTank { + + private int capacity; + + ConduitGtTank(int capacity) { + super(capacity); + this.capacity = capacity; + } + + public float getFilledRatio() { + if(getStored() <= 0) { + return 0; + } + if(getMaxGas() <= 0) { + return -1; + } + float res = (float) getStored() / getMaxGas(); + return res; + } + + public boolean isFull() { + return getStored() >= getMaxGas(); + } + + public void setAmount(int amount) { + if(stored != null) { + stored.amount = amount; + } + } + + public int getAvailableSpace() { + return getMaxGas() - getStored(); + } + + public void addAmount(int amount) { + setAmount(getStored() + amount); + } + + @Override + public int getMaxGas() { + return this.capacity; + } + + public void setCapacity(int capacity) { + this.capacity = capacity; + if(getStored() > capacity) { + setAmount(capacity); + } + } + + @Override + public int receive(GasStack resource, boolean doReceive) { + if(resource == null || resource.getGas().getID() < 0) { + return 0; + } + + if(stored == null || stored.getGas().getID() < 0) { + if(resource.amount <= capacity) { + if(doReceive) { + setGas(resource.copy()); + } + return resource.amount; + } else { + if(doReceive) { + stored = resource.copy(); + stored.amount = capacity; + } + return capacity; + } + } + + if(!stored.isGasEqual(resource)) { + return 0; + } + + int space = capacity - stored.amount; + if(resource.amount <= space) { + if(doReceive) { + addAmount(resource.amount); + } + return resource.amount; + } else { + if(doReceive) { + stored.amount = capacity; + } + return space; + } + + } + + @Override + public GasStack draw(int maxDrain, boolean doDraw) { + if(stored == null || stored.getGas().getID() < 0) { + return null; + } + if(stored.amount <= 0) { + return null; + } + + int used = maxDrain; + if(stored.amount < used) { + used = stored.amount; + } + + if(doDraw) { + addAmount(-used); + } + + GasStack drained = new GasStack(stored.getGas().getID(), used); + + if(stored.amount < 0) { + stored.amount = 0; + } + return drained; + } + + public String getGasName() { + return stored != null ? stored.getGas().getLocalizedName() : null; + } + + public boolean containsValidGas() { + return GtUtil.isGasValid(stored); + } + + public NBTTagCompound write(NBTTagCompound nbt) { + if(containsValidGas()) { + stored.write(nbt); + } else { + nbt.setBoolean("emptyGasTank", true); + } + return nbt; + } + + public void read(NBTTagCompound nbt) { + if(!nbt.hasKey("emptyGasTank")) { + GasStack gas = GasStack.readFromNBT(nbt); + if(gas != null) { + setGas(gas); + } + } + } + + public boolean isEmpty() { + return stored == null || stored.amount == 0; + } + +} diff --git a/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java b/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java new file mode 100644 index 0000000000..3af9f089e4 --- /dev/null +++ b/src/Java/miscutil/enderio/conduit/GregTech/GtConduit.java @@ -0,0 +1,265 @@ +package miscutil.enderio.conduit.GregTech; + +import java.util.HashMap; +import java.util.Map; + +import mekanism.api.gas.Gas; +import mekanism.api.gas.GasStack; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import crazypants.enderio.EnderIO; +import crazypants.enderio.conduit.AbstractConduitNetwork; +import crazypants.enderio.conduit.ConnectionMode; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.geom.CollidableComponent; +import crazypants.enderio.config.Config; +import crazypants.render.IconUtil; +import crazypants.util.BlockCoord; + +public class GtConduit extends AbstractGtTankConduit { + + public static final int CONDUIT_VOLUME = 1000; + + public static final String ICON_KEY = "enderio:gasConduit"; + public static final String ICON_CORE_KEY = "enderio:gasConduitCore"; + public static final String ICON_EXTRACT_KEY = "enderio:gasConduitInput"; + public static final String ICON_INSERT_KEY = "enderio:gasConduitOutput"; + public static final String ICON_EMPTY_EDGE = "enderio:gasConduitEdge"; + + static final Map<String, IIcon> ICONS = new HashMap<String, IIcon>(); + + @SideOnly(Side.CLIENT) + public static void initIcons() { + IconUtil.addIconProvider(new IconUtil.IIconProvider() { + + @Override + public void registerIcons(IIconRegister register) { + ICONS.put(ICON_KEY, register.registerIcon(ICON_KEY)); + ICONS.put(ICON_CORE_KEY, register.registerIcon(ICON_CORE_KEY)); + ICONS.put(ICON_EXTRACT_KEY, register.registerIcon(ICON_EXTRACT_KEY)); + ICONS.put(ICON_INSERT_KEY, register.registerIcon(ICON_INSERT_KEY)); + ICONS.put(ICON_EMPTY_EDGE, register.registerIcon(ICON_EMPTY_EDGE)); + } + + @Override + public int getTextureType() { + return 0; + } + + }); + } + + private GtConduitNetwork network; + + private long ticksSinceFailedExtract = 0; + + public static final int MAX_EXTRACT_PER_TICK = Config.gasConduitExtractRate; + + public static final int MAX_IO_PER_TICK = Config.gasConduitMaxIoRate; + + public GtConduit() { + updateTank(); + } + + @Override + public void updateEntity(World world) { + super.updateEntity(world); + if(world.isRemote) { + return; + } + doExtract(); + if(stateDirty) { + getBundle().dirty(); + stateDirty = false; + } + } + + private void doExtract() { + BlockCoord loc = getLocation(); + if(!hasConnectionMode(ConnectionMode.INPUT)) { + return; + } + if(network == null) { + return; + } + + // assume failure, reset to 0 if we do extract + ticksSinceFailedExtract++; + if(ticksSinceFailedExtract > 25 && ticksSinceFailedExtract % 10 != 0) { + // after 25 ticks of failing, only check every 10 ticks + return; + } + + Gas f = tank.getGas() == null ? null : tank.getGas().getGas(); + for (ForgeDirection dir : externalConnections) { + if(autoExtractForDir(dir)) { + if(network.extractFrom(this, dir, MAX_EXTRACT_PER_TICK)) { + ticksSinceFailedExtract = 0; + } + } + } + + } + + @Override + protected void updateTank() { + tank.setCapacity(CONDUIT_VOLUME); + if(network != null) { + network.updateConduitVolumes(); + } + } + + @Override + public ItemStack createItem() { + return new ItemStack(EnderIO.itemGasConduit); + } + + @Override + public AbstractConduitNetwork<?, ?> getNetwork() { + return network; + } + + @Override + public boolean setNetwork(AbstractConduitNetwork<?, ?> network) { + if(network == null) { + this.network = null; + return true; + } + if(!(network instanceof GtConduitNetwork)) { + return false; + } + + GtConduitNetwork n = (GtConduitNetwork) network; + if(tank.getGas() == null) { + tank.setGas(n.getGasType() == null ? null : n.getGasType().copy()); + } else if(n.getGasType() == null) { + n.setGasType(tank.getGas()); + } else if(!tank.getGas().isGasEqual(n.getGasType())) { + return false; + } + this.network = n; + return true; + + } + + @Override + public boolean canConnectToConduit(ForgeDirection direction, IConduit con) { + if(!super.canConnectToConduit(direction, con)) { + return false; + } + if(!(con instanceof GtConduit)) { + return false; + } + if(getGasType() != null && ((GtConduit) con).getGasType() == null) { + return false; + } + return GtConduitNetwork.areGassCompatable(getGasType(), ((GtConduit) con).getGasType()); + } + + @Override + public void setConnectionMode(ForgeDirection dir, ConnectionMode mode) { + super.setConnectionMode(dir, mode); + refreshInputs(dir); + } + + private void refreshInputs(ForgeDirection dir) { + if(network == null) { + return; + } + GtOutput lo = new GtOutput(getLocation().getLocation(dir), dir.getOpposite()); + network.removeInput(lo); + if(getConnectionMode(dir).acceptsOutput() && containsExternalConnection(dir)) { + network.addInput(lo); + } + } + + @Override + |