From 66d0bca37c53caee9316fd58a484283bb56861b5 Mon Sep 17 00:00:00 2001 From: pupnewfster Date: Mon, 1 Apr 2019 12:53:40 -0400 Subject: [PATCH] Remove usage of TUBE_CONNECTION_CAPABILITY, in favor of using toggleable capabilities --- .../mekanism/api/gas/ITubeConnection.java | 3 + .../java/mekanism/common/base/IFactory.java | 8 +-- .../common/capabilities/Capabilities.java | 3 + .../capabilities/DefaultTubeConnection.java | 1 + .../tile/TileEntityAmbientAccumulator.java | 25 +++++--- .../tile/TileEntityChemicalCrystallizer.java | 12 +--- .../TileEntityChemicalDissolutionChamber.java | 32 +++++----- .../tile/TileEntityChemicalInfuser.java | 32 +++++----- .../TileEntityChemicalInjectionChamber.java | 5 -- .../tile/TileEntityChemicalOxidizer.java | 62 +++++++++++++++---- .../common/tile/TileEntityChemicalWasher.java | 33 +++++----- .../tile/TileEntityElectrolyticSeparator.java | 31 +++++----- .../common/tile/TileEntityFactory.java | 24 +++---- .../common/tile/TileEntityGasTank.java | 19 ++---- .../tile/TileEntityOsmiumCompressor.java | 5 -- .../mekanism/common/tile/TileEntityPRC.java | 29 ++++----- .../tile/TileEntityPurificationChamber.java | 5 -- .../tile/TileEntityQuantumEntangloporter.java | 26 ++++---- .../tile/TileEntityRotaryCondensentrator.java | 29 +++++---- .../tile/TileEntitySolarNeutronActivator.java | 33 +++++----- .../TileEntityAdvancedElectricMachine.java | 22 +++---- .../java/mekanism/common/util/GasUtils.java | 10 +-- .../common/tile/TileEntityGasGenerator.java | 31 +++++----- .../tile/reactor/TileEntityReactorPort.java | 20 +++--- 24 files changed, 262 insertions(+), 238 deletions(-) diff --git a/src/main/java/mekanism/api/gas/ITubeConnection.java b/src/main/java/mekanism/api/gas/ITubeConnection.java index 30e5d4fdd..dbd2bd70f 100644 --- a/src/main/java/mekanism/api/gas/ITubeConnection.java +++ b/src/main/java/mekanism/api/gas/ITubeConnection.java @@ -6,7 +6,10 @@ import net.minecraft.util.EnumFacing; * Implement this if your block can connect to Pressurized Tubes. * * @author AidanBrady + * @deprecated Dropped in favor of better support for machines of what implements GAS_HANDLER_CAPABILITY use {@link + * IGasHandler} instead. */ +@Deprecated public interface ITubeConnection { /** diff --git a/src/main/java/mekanism/common/base/IFactory.java b/src/main/java/mekanism/common/base/IFactory.java index dbfced202..d5b0bf52f 100644 --- a/src/main/java/mekanism/common/base/IFactory.java +++ b/src/main/java/mekanism/common/base/IFactory.java @@ -183,12 +183,8 @@ public interface IFactory { return false; } - public boolean canTubeConnect(EnumFacing side) { - if (fuelType == MachineFuelType.ADVANCED) { - return getTile().canTubeConnect(side); - } - - return false; + public boolean supportsGas() { + return fuelType == MachineFuelType.ADVANCED; } public boolean isValidGas(Gas gas) { diff --git a/src/main/java/mekanism/common/capabilities/Capabilities.java b/src/main/java/mekanism/common/capabilities/Capabilities.java index 9e68a5c19..177d615e4 100644 --- a/src/main/java/mekanism/common/capabilities/Capabilities.java +++ b/src/main/java/mekanism/common/capabilities/Capabilities.java @@ -54,6 +54,9 @@ public class Capabilities { @CapabilityInject(IAlloyInteraction.class) public static Capability ALLOY_INTERACTION_CAPABILITY = null; + //Kept in for compatibility with any mods that may try to reference it. + // However, nothing in Mekanism uses this anymore + @Deprecated @CapabilityInject(ITubeConnection.class) public static Capability TUBE_CONNECTION_CAPABILITY = null; diff --git a/src/main/java/mekanism/common/capabilities/DefaultTubeConnection.java b/src/main/java/mekanism/common/capabilities/DefaultTubeConnection.java index 235595d62..f6a743d0e 100644 --- a/src/main/java/mekanism/common/capabilities/DefaultTubeConnection.java +++ b/src/main/java/mekanism/common/capabilities/DefaultTubeConnection.java @@ -5,6 +5,7 @@ import mekanism.common.capabilities.DefaultStorageHelper.NullStorage; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.CapabilityManager; +@Deprecated public class DefaultTubeConnection implements ITubeConnection { public static void register() { diff --git a/src/main/java/mekanism/common/tile/TileEntityAmbientAccumulator.java b/src/main/java/mekanism/common/tile/TileEntityAmbientAccumulator.java index b6193c5b6..9b4914d6a 100644 --- a/src/main/java/mekanism/common/tile/TileEntityAmbientAccumulator.java +++ b/src/main/java/mekanism/common/tile/TileEntityAmbientAccumulator.java @@ -9,7 +9,7 @@ import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; -import mekanism.api.gas.ITubeConnection; +import mekanism.common.capabilities.Capabilities; import mekanism.common.recipe.RecipeHandler; import mekanism.common.recipe.inputs.IntegerInput; import mekanism.common.recipe.machines.AmbientGasRecipe; @@ -19,9 +19,10 @@ import mekanism.common.util.TileUtils; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; import net.minecraft.util.NonNullList; +import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityAmbientAccumulator extends TileEntityContainerBlock implements IGasHandler, ITubeConnection { +public class TileEntityAmbientAccumulator extends TileEntityContainerBlock implements IGasHandler { public static Random gasRand = new Random(); public GasTank collectedGas = new GasTank(1000); @@ -75,11 +76,6 @@ public class TileEntityAmbientAccumulator extends TileEntityContainerBlock imple return new GasTankInfo[]{collectedGas}; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return true; - } - @Override public TileNetworkList getNetworkedData(TileNetworkList data) { TileUtils.addTankData(data, collectedGas); @@ -98,4 +94,19 @@ public class TileEntityAmbientAccumulator extends TileEntityContainerBlock imple public int[] getSlotsForFace(@Nonnull EnumFacing side) { return InventoryUtils.EMPTY; } + + //Gas capability is never disabled here + @Override + public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); + } + + @Override + public T getCapability(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return (T) this; + } + + return super.getCapability(capability, side); + } } diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalCrystallizer.java b/src/main/java/mekanism/common/tile/TileEntityChemicalCrystallizer.java index 1901bd962..293706e4e 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalCrystallizer.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalCrystallizer.java @@ -11,7 +11,6 @@ import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.api.transmitters.TransmissionType; import mekanism.common.SideData; import mekanism.common.base.ISideConfiguration; @@ -39,7 +38,7 @@ import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; public class TileEntityChemicalCrystallizer extends TileEntityOperationalMachine implements IGasHandler, - ITubeConnection, ISideConfiguration, ISustainedData, ITankManager, IConfigCardAccess { + ISideConfiguration, ISustainedData, ITankManager, IConfigCardAccess { public static final int MAX_GAS = 10000; @@ -175,11 +174,6 @@ public class TileEntityChemicalCrystallizer extends TileEntityOperationalMachine return i != 0 && i != 1; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(0); - } - @Override public boolean canReceiveGas(EnumFacing side, Gas type) { return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(0) && inputTank.canReceive(type) && @@ -217,7 +211,6 @@ public class TileEntityChemicalCrystallizer extends TileEntityOperationalMachine return false; } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY || super.hasCapability(capability, side); } @@ -226,8 +219,7 @@ public class TileEntityChemicalCrystallizer extends TileEntityOperationalMachine if (isCapabilityDisabled(capability, side)) { return null; } - if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || capability == Capabilities.CONFIG_CARD_CAPABILITY) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY) { return (T) this; } diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalDissolutionChamber.java b/src/main/java/mekanism/common/tile/TileEntityChemicalDissolutionChamber.java index 27d2ef7b6..aa6f850e2 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalDissolutionChamber.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalDissolutionChamber.java @@ -2,18 +2,17 @@ package mekanism.common.tile; import io.netty.buffer.ByteBuf; import javax.annotation.Nonnull; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.MekanismFluids; import mekanism.common.Upgrade; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.usage; @@ -36,8 +35,8 @@ import net.minecraft.util.NonNullList; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityChemicalDissolutionChamber extends TileEntityMachine implements ITubeConnection, IGasHandler, - ISustainedData, ITankManager { +public class TileEntityChemicalDissolutionChamber extends TileEntityMachine implements IGasHandler, ISustainedData, + ITankManager { public static final int MAX_GAS = 10000; public static final int BASE_INJECT_USAGE = 1; @@ -230,11 +229,6 @@ public class TileEntityChemicalDissolutionChamber extends TileEntityMachine impl return i != 0 && i != 1; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == MekanismUtils.getLeft(facing) || side == MekanismUtils.getRight(facing); - } - @Override public int receiveGas(EnumFacing side, GasStack stack, boolean doTransfer) { if (canReceiveGas(side, stack.getGas())) { @@ -272,21 +266,31 @@ public class TileEntityChemicalDissolutionChamber extends TileEntityMachine impl @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != MekanismUtils.getLeft(facing) && side != MekanismUtils.getRight(facing); + } + return super.isCapabilityDisabled(capability, side); + } + @Override public TileComponentUpgrade getComponent() { return upgradeComponent; diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalInfuser.java b/src/main/java/mekanism/common/tile/TileEntityChemicalInfuser.java index 48d279ab8..217538be0 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalInfuser.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalInfuser.java @@ -3,20 +3,19 @@ package mekanism.common.tile; import io.netty.buffer.ByteBuf; import java.util.List; import javax.annotation.Nonnull; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.Upgrade; import mekanism.common.Upgrade.IUpgradeInfoHandler; import mekanism.common.base.IRedstoneControl; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; import mekanism.common.base.IUpgradeTile; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.usage; @@ -38,8 +37,8 @@ import net.minecraft.util.NonNullList; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityChemicalInfuser extends TileEntityMachine implements IGasHandler, ITubeConnection, - IRedstoneControl, ISustainedData, IUpgradeTile, IUpgradeInfoHandler, ITankManager, ISecurityTile { +public class TileEntityChemicalInfuser extends TileEntityMachine implements IGasHandler, IRedstoneControl, + ISustainedData, IUpgradeTile, IUpgradeInfoHandler, ITankManager, ISecurityTile { public static final int MAX_GAS = 10000; public GasTank leftTank = new GasTank(MAX_GAS); @@ -198,11 +197,6 @@ public class TileEntityChemicalInfuser extends TileEntityMachine implements IGas return new GasTankInfo[]{leftTank, centerTank, rightTank}; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == MekanismUtils.getLeft(facing) || side == MekanismUtils.getRight(facing) || side == facing; - } - @Override public boolean canReceiveGas(EnumFacing side, Gas type) { return (getTank(side) != null && getTank(side) != centerTank) && getTank(side).canReceive(type); @@ -233,21 +227,31 @@ public class TileEntityChemicalInfuser extends TileEntityMachine implements IGas @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != MekanismUtils.getLeft(facing) && side != MekanismUtils.getRight(facing) && side != facing; + } + return super.isCapabilityDisabled(capability, side); + } + @Override public boolean isItemValidForSlot(int slotID, @Nonnull ItemStack itemstack) { return slotID == 3 && ChargeUtils.canBeDischarged(itemstack); diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalInjectionChamber.java b/src/main/java/mekanism/common/tile/TileEntityChemicalInjectionChamber.java index ec3c59072..d37c06076 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalInjectionChamber.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalInjectionChamber.java @@ -68,11 +68,6 @@ public class TileEntityChemicalInjectionChamber extends TileEntityAdvancedElectr super.handleSecondaryFuel(); } - @Override - public boolean canTubeConnect(EnumFacing side) { - return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(0); - } - @Override public boolean isValidGas(Gas gas) { return Recipe.CHEMICAL_INJECTION_CHAMBER.containsRecipe(gas); diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalOxidizer.java b/src/main/java/mekanism/common/tile/TileEntityChemicalOxidizer.java index 5e92da8e8..e67786d9d 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalOxidizer.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalOxidizer.java @@ -2,13 +2,15 @@ package mekanism.common.tile; import io.netty.buffer.ByteBuf; import javax.annotation.Nonnull; +import mekanism.api.TileNetworkList; +import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; +import mekanism.api.gas.GasTankInfo; +import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.usage; @@ -29,8 +31,8 @@ import net.minecraft.util.NonNullList; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityChemicalOxidizer extends TileEntityOperationalMachine implements ITubeConnection, ISustainedData, - ITankManager { +public class TileEntityChemicalOxidizer extends TileEntityOperationalMachine implements ISustainedData, ITankManager, + IGasHandler { public static final int MAX_GAS = 10000; public GasTank gasTank = new GasTank(MAX_GAS); @@ -176,25 +178,33 @@ public class TileEntityChemicalOxidizer extends TileEntityOperationalMachine imp return i != 0 && i != 1; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == MekanismUtils.getRight(facing); - } - @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { - return capability == Capabilities.TUBE_CONNECTION_CAPABILITY || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != MekanismUtils.getRight(facing); + } + return super.isCapabilityDisabled(capability, side); + } + @Override public void writeSustainedData(ItemStack itemStack) { if (gasTank.getGas() != null) { @@ -211,4 +221,34 @@ public class TileEntityChemicalOxidizer extends TileEntityOperationalMachine imp public Object[] getTanks() { return new Object[]{gasTank}; } + + @Override + public boolean canReceiveGas(EnumFacing side, Gas type) { + return false; + } + + + @Override + public int receiveGas(EnumFacing side, GasStack stack, boolean doTransfer) { + return 0; + } + + @Override + public GasStack drawGas(EnumFacing side, int amount, boolean doTransfer) { + if (canDrawGas(side, null)) { + return gasTank.draw(amount, doTransfer); + } + return null; + } + + @Override + public boolean canDrawGas(EnumFacing side, Gas type) { + return side == MekanismUtils.getRight(facing) && gasTank.canDraw(type); + } + + @Nonnull + @Override + public GasTankInfo[] getTankInfo() { + return new GasTankInfo[]{gasTank}; + } } diff --git a/src/main/java/mekanism/common/tile/TileEntityChemicalWasher.java b/src/main/java/mekanism/common/tile/TileEntityChemicalWasher.java index 74aac9d70..792b14695 100644 --- a/src/main/java/mekanism/common/tile/TileEntityChemicalWasher.java +++ b/src/main/java/mekanism/common/tile/TileEntityChemicalWasher.java @@ -4,20 +4,19 @@ import io.netty.buffer.ByteBuf; import java.util.List; import javax.annotation.Nonnull; import javax.annotation.Nullable; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.Upgrade; import mekanism.common.Upgrade.IUpgradeInfoHandler; import mekanism.common.base.FluidHandlerWrapper; import mekanism.common.base.IFluidHandlerWrapper; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.usage; @@ -47,8 +46,8 @@ import net.minecraftforge.fluids.FluidUtil; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityChemicalWasher extends TileEntityMachine implements IGasHandler, ITubeConnection, - IFluidHandlerWrapper, ISustainedData, IUpgradeInfoHandler, ITankManager { +public class TileEntityChemicalWasher extends TileEntityMachine implements IGasHandler, IFluidHandlerWrapper, + ISustainedData, IUpgradeInfoHandler, ITankManager { public static final int MAX_GAS = 10000; public static final int MAX_FLUID = 10000; @@ -199,11 +198,6 @@ public class TileEntityChemicalWasher extends TileEntityMachine implements IGasH return null; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return getTank(side) != null; - } - @Override public boolean canReceiveGas(EnumFacing side, Gas type) { if (getTank(side) == inputTank) { @@ -283,25 +277,34 @@ public class TileEntityChemicalWasher extends TileEntityMachine implements IGasH @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + if (isCapabilityDisabled(capability, side)) { + return false; + } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; - } - - if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + } else if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { return (T) new FluidHandlerWrapper(this, side); } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return getTank(side) == null; + } + return super.isCapabilityDisabled(capability, side); + } + @Override public int fill(EnumFacing from, @Nullable FluidStack resource, boolean doFill) { if (canFill(from, resource)) { diff --git a/src/main/java/mekanism/common/tile/TileEntityElectrolyticSeparator.java b/src/main/java/mekanism/common/tile/TileEntityElectrolyticSeparator.java index f49d5d18d..62937608b 100644 --- a/src/main/java/mekanism/common/tile/TileEntityElectrolyticSeparator.java +++ b/src/main/java/mekanism/common/tile/TileEntityElectrolyticSeparator.java @@ -5,13 +5,13 @@ import java.util.Collections; import java.util.List; import javax.annotation.Nonnull; import javax.annotation.Nullable; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.MekanismFluids; import mekanism.common.Upgrade; import mekanism.common.Upgrade.IUpgradeInfoHandler; @@ -19,7 +19,6 @@ import mekanism.common.base.FluidHandlerWrapper; import mekanism.common.base.IFluidHandlerWrapper; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.integration.computer.IComputerIntegration; @@ -51,7 +50,7 @@ import net.minecraftforge.fluids.capability.CapabilityFluidHandler; import net.minecraftforge.fml.common.FMLCommonHandler; public class TileEntityElectrolyticSeparator extends TileEntityMachine implements IFluidHandlerWrapper, - IComputerIntegration, ITubeConnection, ISustainedData, IGasHandler, IUpgradeInfoHandler, ITankManager { + IComputerIntegration, ISustainedData, IGasHandler, IUpgradeInfoHandler, ITankManager { private static final String[] methods = new String[]{"getEnergy", "getOutput", "getMaxEnergy", "getEnergyNeeded", "getWater", "getWaterNeeded", "getHydrogen", "getHydrogenNeeded", "getOxygen", "getOxygenNeeded"}; @@ -377,11 +376,6 @@ public class TileEntityElectrolyticSeparator extends TileEntityMachine implement } } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == MekanismUtils.getLeft(facing) || side == MekanismUtils.getRight(facing); - } - @Override public void writeSustainedData(ItemStack itemStack) { if (fluidTank.getFluid() != null) { @@ -483,25 +477,34 @@ public class TileEntityElectrolyticSeparator extends TileEntityMachine implement @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + if (isCapabilityDisabled(capability, side)) { + return false; + } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; - } - - if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + } else if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { return (T) new FluidHandlerWrapper(this, side); } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != MekanismUtils.getLeft(facing) && side != MekanismUtils.getRight(facing); + } + return super.isCapabilityDisabled(capability, side); + } + @Override public List getInfo(Upgrade upgrade) { return upgrade == Upgrade.SPEED ? upgrade.getExpScaledInfo(this) : upgrade.getMultScaledInfo(this); diff --git a/src/main/java/mekanism/common/tile/TileEntityFactory.java b/src/main/java/mekanism/common/tile/TileEntityFactory.java index 87a1a984a..ef825a2b3 100644 --- a/src/main/java/mekanism/common/tile/TileEntityFactory.java +++ b/src/main/java/mekanism/common/tile/TileEntityFactory.java @@ -15,7 +15,6 @@ import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.api.infuse.InfuseObject; import mekanism.api.infuse.InfuseRegistry; import mekanism.api.transmitters.TransmissionType; @@ -69,7 +68,7 @@ import net.minecraftforge.fml.common.FMLCommonHandler; import org.apache.commons.lang3.tuple.Pair; public class TileEntityFactory extends TileEntityMachine implements IComputerIntegration, ISideConfiguration, - IGasHandler, ITubeConnection, ISpecialConfigData, ITierUpgradeable, ISustainedData { + IGasHandler, ISpecialConfigData, ITierUpgradeable, ISustainedData { private static final String[] methods = new String[]{"getEnergy", "getProgress", "facing", "canOperate", "getMaxEnergy", "getEnergyNeeded"}; @@ -874,15 +873,6 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt return false; } - @Override - public boolean canTubeConnect(EnumFacing side) { - if (recipeType.canTubeConnect(side)) { - return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(0); - } - - return false; - } - @Override public GasStack drawGas(EnumFacing side, int amount, boolean doTransfer) { return null; @@ -905,7 +895,6 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt return false; } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY || capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY || super.hasCapability(capability, side); @@ -916,8 +905,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt if (isCapabilityDisabled(capability, side)) { return null; } - if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || capability == Capabilities.CONFIG_CARD_CAPABILITY + if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY || capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY) { return (T) this; } @@ -927,8 +915,12 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt @Override public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { - return configComponent.isCapabilityDisabled(capability, side, facing) || super - .isCapabilityDisabled(capability, side); + if (configComponent.isCapabilityDisabled(capability, side, facing)) { + return true; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return !recipeType.supportsGas(); + } + return super.isCapabilityDisabled(capability, side); } @Override diff --git a/src/main/java/mekanism/common/tile/TileEntityGasTank.java b/src/main/java/mekanism/common/tile/TileEntityGasTank.java index 2073d1242..763fae288 100644 --- a/src/main/java/mekanism/common/tile/TileEntityGasTank.java +++ b/src/main/java/mekanism/common/tile/TileEntityGasTank.java @@ -12,7 +12,6 @@ import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.api.transmitters.TransmissionType; import mekanism.common.Mekanism; import mekanism.common.SideData; @@ -29,7 +28,6 @@ import mekanism.common.tile.component.TileComponentConfig; import mekanism.common.tile.component.TileComponentEjector; import mekanism.common.tile.component.TileComponentSecurity; import mekanism.common.tile.prefab.TileEntityContainerBlock; -import mekanism.common.util.CapabilityUtils; import mekanism.common.util.GasUtils; import mekanism.common.util.InventoryUtils; import mekanism.common.util.LangUtils; @@ -45,8 +43,8 @@ import net.minecraft.util.math.MathHelper; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityGasTank extends TileEntityContainerBlock implements IGasHandler, ITubeConnection, - IRedstoneControl, ISideConfiguration, ISecurityTile, ITierUpgradeable, IComputerIntegration { +public class TileEntityGasTank extends TileEntityContainerBlock implements IGasHandler, IRedstoneControl, + ISideConfiguration, ISecurityTile, ITierUpgradeable, IComputerIntegration { private static final String[] methods = new String[]{"getMaxGas", "getStoredGas", "getGas"}; /** @@ -246,18 +244,14 @@ public class TileEntityGasTank extends TileEntityContainerBlock implements IGasH if (isCapabilityDisabled(capability, side)) { return false; } - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { if (isCapabilityDisabled(capability, side)) { return null; - } - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } @@ -349,11 +343,6 @@ public class TileEntityGasTank extends TileEntityContainerBlock implements IGasH return side != 0 && side != 1; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return true; - } - public int getRedstoneLevel() { double fractionFull = (float) gasTank.getStored() / (float) gasTank.getMaxGas(); return MathHelper.floor((float) (fractionFull * 14.0F)) + (fractionFull > 0 ? 1 : 0); diff --git a/src/main/java/mekanism/common/tile/TileEntityOsmiumCompressor.java b/src/main/java/mekanism/common/tile/TileEntityOsmiumCompressor.java index 62e676e58..3e54474dd 100644 --- a/src/main/java/mekanism/common/tile/TileEntityOsmiumCompressor.java +++ b/src/main/java/mekanism/common/tile/TileEntityOsmiumCompressor.java @@ -40,9 +40,4 @@ public class TileEntityOsmiumCompressor extends TileEntityAdvancedElectricMachin public boolean canReceiveGas(EnumFacing side, Gas type) { return gasTank.canReceive(type) && isValidGas(type); } - - @Override - public boolean canTubeConnect(EnumFacing side) { - return true; - } } diff --git a/src/main/java/mekanism/common/tile/TileEntityPRC.java b/src/main/java/mekanism/common/tile/TileEntityPRC.java index b332c7fc3..a5f2ae2a5 100644 --- a/src/main/java/mekanism/common/tile/TileEntityPRC.java +++ b/src/main/java/mekanism/common/tile/TileEntityPRC.java @@ -5,12 +5,12 @@ import java.util.Map; import javax.annotation.Nonnull; import javax.annotation.Nullable; import mekanism.api.EnumColor; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; -import mekanism.api.gas.ITubeConnection; import mekanism.api.transmitters.TransmissionType; import mekanism.common.SideData; import mekanism.common.Upgrade; @@ -18,7 +18,6 @@ import mekanism.common.base.FluidHandlerWrapper; import mekanism.common.base.IFluidHandlerWrapper; import mekanism.common.base.ISustainedData; import mekanism.common.base.ITankManager; -import mekanism.api.TileNetworkList; import mekanism.common.block.states.BlockStateMachine; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.usage; @@ -50,7 +49,7 @@ import net.minecraftforge.fml.common.FMLCommonHandler; public class TileEntityPRC extends TileEntityBasicMachine implements IFluidHandlerWrapper, - IGasHandler, ITubeConnection, ISustainedData, ITankManager { + IGasHandler, ISustainedData, ITankManager { private static final String[] methods = new String[]{"getEnergy", "getProgress", "isActive", "facing", "canOperate", "getMaxEnergy", "getEnergyNeeded", "getFluidStored", "getGasStored"}; @@ -351,11 +350,6 @@ public class TileEntityPRC extends return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(2) && outputGasTank.canDraw(type); } - @Override - public boolean canTubeConnect(EnumFacing side) { - return configComponent.getOutput(TransmissionType.GAS, side, facing).hasSlot(1, 2); - } - @Nonnull @Override public GasTankInfo[] getTankInfo() { @@ -364,25 +358,32 @@ public class TileEntityPRC extends @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + if (isCapabilityDisabled(capability, side)) { + return false; + } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; - } - - if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + } else if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { return (T) new FluidHandlerWrapper(this, side); } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + return configComponent.isCapabilityDisabled(capability, side, facing) || super + .isCapabilityDisabled(capability, side); + } + @Override public void writeSustainedData(ItemStack itemStack) { if (inputFluidTank.getFluid() != null) { diff --git a/src/main/java/mekanism/common/tile/TileEntityPurificationChamber.java b/src/main/java/mekanism/common/tile/TileEntityPurificationChamber.java index 30a93a5cd..8eed1c4d1 100644 --- a/src/main/java/mekanism/common/tile/TileEntityPurificationChamber.java +++ b/src/main/java/mekanism/common/tile/TileEntityPurificationChamber.java @@ -54,11 +54,6 @@ public class TileEntityPurificationChamber extends TileEntityAdvancedElectricMac super.handleSecondaryFuel(); } - @Override - public boolean canTubeConnect(EnumFacing side) { - return true; - } - @Override public boolean isValidGas(Gas gas) { return Recipe.PURIFICATION_CHAMBER.containsRecipe(gas); diff --git a/src/main/java/mekanism/common/tile/TileEntityQuantumEntangloporter.java b/src/main/java/mekanism/common/tile/TileEntityQuantumEntangloporter.java index e5e789e86..7bef8eb72 100644 --- a/src/main/java/mekanism/common/tile/TileEntityQuantumEntangloporter.java +++ b/src/main/java/mekanism/common/tile/TileEntityQuantumEntangloporter.java @@ -10,11 +10,11 @@ import javax.annotation.Nullable; import mekanism.api.Chunk3D; import mekanism.api.Coord4D; import mekanism.api.IHeatTransfer; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; -import mekanism.api.gas.ITubeConnection; import mekanism.api.transmitters.TransmissionType; import mekanism.common.Mekanism; import mekanism.common.PacketHandler; @@ -25,7 +25,6 @@ import mekanism.common.base.IFluidHandlerWrapper; import mekanism.common.base.ISideConfiguration; import mekanism.common.base.ITankManager; import mekanism.common.base.IUpgradeTile; -import mekanism.api.TileNetworkList; import mekanism.common.capabilities.Capabilities; import mekanism.common.chunkloading.IChunkLoader; import mekanism.common.config.MekanismConfig.general; @@ -62,8 +61,8 @@ import net.minecraftforge.fluids.capability.CapabilityFluidHandler; import net.minecraftforge.fml.common.FMLCommonHandler; public class TileEntityQuantumEntangloporter extends TileEntityElectricBlock implements ISideConfiguration, - ITankManager, IFluidHandlerWrapper, IFrequencyHandler, IGasHandler, IHeatTransfer, ITubeConnection, - IComputerIntegration, ISecurityTile, IChunkLoader, IUpgradeTile { + ITankManager, IFluidHandlerWrapper, IFrequencyHandler, IGasHandler, IHeatTransfer, IComputerIntegration, + ISecurityTile, IChunkLoader, IUpgradeTile { private static final int INV_SIZE = 1;//this.inventory size, used for upgrades. Manually handled private static final String[] methods = new String[]{"setFrequency"}; @@ -612,18 +611,12 @@ public class TileEntityQuantumEntangloporter extends TileEntityElectricBlock imp return securityComponent; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return hasFrequency() && configComponent.getOutput(TransmissionType.GAS, side, facing).ioState != IOState.OFF; - } - @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { if (isCapabilityDisabled(capability, side)) { return false; } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == Capabilities.HEAT_TRANSFER_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, side); @@ -634,8 +627,7 @@ public class TileEntityQuantumEntangloporter extends TileEntityElectricBlock imp if (isCapabilityDisabled(capability, side)) { return null; } - if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || capability == Capabilities.HEAT_TRANSFER_CAPABILITY) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.HEAT_TRANSFER_CAPABILITY) { return (T) this; } @@ -648,8 +640,14 @@ public class TileEntityQuantumEntangloporter extends TileEntityElectricBlock imp @Override public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { - return configComponent.isCapabilityDisabled(capability, side, facing) || super - .isCapabilityDisabled(capability, side); + if (configComponent.isCapabilityDisabled(capability, side, facing)) { + return true; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + //TODO: Figure out if checking ioState even needed + return !hasFrequency() + || configComponent.getOutput(TransmissionType.GAS, side, facing).ioState == IOState.OFF; + } + return super.isCapabilityDisabled(capability, side); } @Override diff --git a/src/main/java/mekanism/common/tile/TileEntityRotaryCondensentrator.java b/src/main/java/mekanism/common/tile/TileEntityRotaryCondensentrator.java index 12096aa9e..68ed47462 100644 --- a/src/main/java/mekanism/common/tile/TileEntityRotaryCondensentrator.java +++ b/src/main/java/mekanism/common/tile/TileEntityRotaryCondensentrator.java @@ -13,7 +13,6 @@ import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.Mekanism; import mekanism.common.Upgrade; import mekanism.common.Upgrade.IUpgradeInfoHandler; @@ -46,7 +45,7 @@ import net.minecraftforge.fluids.capability.CapabilityFluidHandler; import net.minecraftforge.fml.common.FMLCommonHandler; public class TileEntityRotaryCondensentrator extends TileEntityMachine implements ISustainedData, IFluidHandlerWrapper, - IGasHandler, ITubeConnection, IUpgradeInfoHandler, ITankManager { + IGasHandler, IUpgradeInfoHandler, ITankManager { private static final int[] GAS_SLOTS = {0, 1}; private static final int[] LIQUID_SLOTS = {2, 3}; @@ -229,11 +228,6 @@ public class TileEntityRotaryCondensentrator extends TileEntityMachine implement return nbtTags; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == MekanismUtils.getLeft(facing); - } - @Override public int receiveGas(EnumFacing side, GasStack stack, boolean doTransfer) { return gasTank.receive(stack, doTransfer); @@ -262,25 +256,34 @@ public class TileEntityRotaryCondensentrator extends TileEntityMachine implement @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + if (isCapabilityDisabled(capability, side)) { + return false; + } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; - } - - if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + } else if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { return (T) new FluidHandlerWrapper(this, side); } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != MekanismUtils.getLeft(facing); + } + return super.isCapabilityDisabled(capability, side); + } + @Override public void writeSustainedData(ItemStack itemStack) { if (fluidTank.getFluid() != null) { diff --git a/src/main/java/mekanism/common/tile/TileEntitySolarNeutronActivator.java b/src/main/java/mekanism/common/tile/TileEntitySolarNeutronActivator.java index 78d5141ed..fe2023b54 100644 --- a/src/main/java/mekanism/common/tile/TileEntitySolarNeutronActivator.java +++ b/src/main/java/mekanism/common/tile/TileEntitySolarNeutronActivator.java @@ -12,7 +12,6 @@ import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.Mekanism; import mekanism.common.Upgrade; import mekanism.common.Upgrade.IUpgradeInfoHandler; @@ -45,8 +44,8 @@ import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; public class TileEntitySolarNeutronActivator extends TileEntityContainerBlock implements IRedstoneControl, - IBoundingBlock, IGasHandler, ITubeConnection, IActiveState, ISustainedData, ITankManager, ISecurityTile, - IUpgradeTile, IUpgradeInfoHandler { + IBoundingBlock, IGasHandler, IActiveState, ISustainedData, ITankManager, ISecurityTile, IUpgradeTile, + IUpgradeInfoHandler { public static final int MAX_GAS = 10000; private static final int[] INPUT_SLOT = {0}; @@ -111,7 +110,8 @@ public class TileEntitySolarNeutronActivator extends TileEntityContainerBlock im // traffic from previous implementation that send the update every 10 ticks. if (world.getTotalWorldTime() % 20 == 0) { Mekanism.packetHandler - .sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new TileNetworkList())), + .sendToReceivers( + new TileEntityMessage(Coord4D.get(this), getNetworkedData(new TileNetworkList())), new Range4D(Coord4D.get(this))); } } @@ -244,28 +244,33 @@ public class TileEntitySolarNeutronActivator extends TileEntityContainerBlock im return new GasTankInfo[]{inputTank, outputTank}; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side == facing || side == EnumFacing.DOWN; - } - @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side != facing && side != EnumFacing.DOWN; + } + return super.isCapabilityDisabled(capability, side); + } + @Override public void writeSustainedData(ItemStack itemStack) { if (inputTank.getGas() != null) { diff --git a/src/main/java/mekanism/common/tile/prefab/TileEntityAdvancedElectricMachine.java b/src/main/java/mekanism/common/tile/prefab/TileEntityAdvancedElectricMachine.java index 852c27533..00ea0418e 100644 --- a/src/main/java/mekanism/common/tile/prefab/TileEntityAdvancedElectricMachine.java +++ b/src/main/java/mekanism/common/tile/prefab/TileEntityAdvancedElectricMachine.java @@ -3,18 +3,17 @@ package mekanism.common.tile.prefab; import io.netty.buffer.ByteBuf; import javax.annotation.Nonnull; import mekanism.api.EnumColor; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; -import mekanism.api.gas.ITubeConnection; import mekanism.api.transmitters.TransmissionType; import mekanism.common.MekanismItems; import mekanism.common.SideData; import mekanism.common.Upgrade; import mekanism.common.base.ISustainedData; -import mekanism.api.TileNetworkList; import mekanism.common.capabilities.Capabilities; import mekanism.common.recipe.RecipeHandler; import mekanism.common.recipe.inputs.AdvancedMachineInput; @@ -39,7 +38,7 @@ import net.minecraftforge.fml.common.FMLCommonHandler; public abstract class TileEntityAdvancedElectricMachine> extends TileEntityUpgradeableMachine implements IGasHandler, - ITubeConnection, ISustainedData { + ISustainedData { private static final String[] methods = new String[]{"getEnergy", "getSecondaryStored", "getProgress", "isActive", "facing", "canOperate", "getMaxEnergy", "getEnergyNeeded"}; @@ -305,11 +304,6 @@ public abstract class TileEntityAdvancedElectricMachine capability, EnumFacing side) { - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } diff --git a/src/main/java/mekanism/common/util/GasUtils.java b/src/main/java/mekanism/common/util/GasUtils.java index 08490982b..11693b687 100644 --- a/src/main/java/mekanism/common/util/GasUtils.java +++ b/src/main/java/mekanism/common/util/GasUtils.java @@ -11,7 +11,6 @@ import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.MekanismFluids; import mekanism.common.OreDictCache; import mekanism.common.Tier.GasTankTier; @@ -71,14 +70,7 @@ public final class GasUtils { return false; } - if (CapabilityUtils.hasCapability(tile, Capabilities.TUBE_CONNECTION_CAPABILITY, side.getOpposite())) { - ITubeConnection connection = CapabilityUtils - .getCapability(tile, Capabilities.TUBE_CONNECTION_CAPABILITY, side.getOpposite()); - - return connection.canTubeConnect(side.getOpposite()); - } - - return false; + return CapabilityUtils.hasCapability(tile, Capabilities.GAS_HANDLER_CAPABILITY, side.getOpposite()); } /** diff --git a/src/main/java/mekanism/generators/common/tile/TileEntityGasGenerator.java b/src/main/java/mekanism/generators/common/tile/TileEntityGasGenerator.java index 3655c7ff8..487d39b64 100644 --- a/src/main/java/mekanism/generators/common/tile/TileEntityGasGenerator.java +++ b/src/main/java/mekanism/generators/common/tile/TileEntityGasGenerator.java @@ -2,17 +2,16 @@ package mekanism.generators.common.tile; import io.netty.buffer.ByteBuf; import javax.annotation.Nonnull; +import mekanism.api.TileNetworkList; import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTank; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; import mekanism.api.gas.IGasItem; -import mekanism.api.gas.ITubeConnection; import mekanism.common.FuelHandler; import mekanism.common.FuelHandler.FuelGas; import mekanism.common.base.ISustainedData; -import mekanism.api.TileNetworkList; import mekanism.common.capabilities.Capabilities; import mekanism.common.config.MekanismConfig.general; import mekanism.common.util.ChargeUtils; @@ -27,8 +26,7 @@ import net.minecraft.util.NonNullList; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fml.common.FMLCommonHandler; -public class TileEntityGasGenerator extends TileEntityGenerator implements IGasHandler, ITubeConnection, - ISustainedData { +public class TileEntityGasGenerator extends TileEntityGenerator implements IGasHandler, ISustainedData { private static final String[] methods = new String[]{"getEnergy", "getOutput", "getMaxEnergy", "getEnergyNeeded", "getGas", "getGasNeeded"}; @@ -298,28 +296,33 @@ public class TileEntityGasGenerator extends TileEntityGenerator implements IGasH return false; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return side != facing; - } - @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { - return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || super.hasCapability(capability, side); + if (isCapabilityDisabled(capability, side)) { + return false; + } + return capability == Capabilities.GAS_HANDLER_CAPABILITY || super.hasCapability(capability, side); } @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY) { + if (isCapabilityDisabled(capability, side)) { + return null; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { return (T) this; } return super.getCapability(capability, side); } + @Override + public boolean isCapabilityDisabled(@Nonnull Capability capability, EnumFacing side) { + if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return side == facing; + } + return super.isCapabilityDisabled(capability, side); + } + @Override public void writeSustainedData(ItemStack itemStack) { if (fuelTank != null) { diff --git a/src/main/java/mekanism/generators/common/tile/reactor/TileEntityReactorPort.java b/src/main/java/mekanism/generators/common/tile/reactor/TileEntityReactorPort.java index 6742e5cbf..4c413d8f0 100644 --- a/src/main/java/mekanism/generators/common/tile/reactor/TileEntityReactorPort.java +++ b/src/main/java/mekanism/generators/common/tile/reactor/TileEntityReactorPort.java @@ -13,7 +13,6 @@ import mekanism.api.gas.Gas; import mekanism.api.gas.GasStack; import mekanism.api.gas.GasTankInfo; import mekanism.api.gas.IGasHandler; -import mekanism.api.gas.ITubeConnection; import mekanism.common.Mekanism; import mekanism.common.MekanismFluids; import mekanism.common.base.FluidHandlerWrapper; @@ -47,7 +46,7 @@ import net.minecraftforge.fml.common.FMLCommonHandler; import net.minecraftforge.items.CapabilityItemHandler; public class TileEntityReactorPort extends TileEntityReactorBlock implements IFluidHandlerWrapper, IGasHandler, - ITubeConnection, IHeatTransfer, IConfigurable { + IHeatTransfer, IConfigurable { public boolean fluidEject; @@ -199,15 +198,12 @@ public class TileEntityReactorPort extends TileEntityReactorBlock implements IFl getReactor().getFuelTank()} : IGasHandler.NONE; } - @Override - public boolean canTubeConnect(EnumFacing side) { - return getReactor() != null; - } - @Override public boolean hasCapability(@Nonnull Capability capability, EnumFacing side) { + if (isCapabilityDisabled(capability, side)) { + return false; + } return capability == Capabilities.GAS_HANDLER_CAPABILITY - || capability == Capabilities.TUBE_CONNECTION_CAPABILITY || capability == Capabilities.HEAT_TRANSFER_CAPABILITY || capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || capability == Capabilities.CONFIGURABLE_CAPABILITY || super.hasCapability(capability, side); @@ -215,8 +211,10 @@ public class TileEntityReactorPort extends TileEntityReactorBlock implements IFl @Override public T getCapability(@Nonnull Capability capability, EnumFacing side) { - if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.TUBE_CONNECTION_CAPABILITY - || capability == Capabilities.HEAT_TRANSFER_CAPABILITY + if (isCapabilityDisabled(capability, side)) { + return null; + } + if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.HEAT_TRANSFER_CAPABILITY || capability == Capabilities.CONFIGURABLE_CAPABILITY) { return (T) this; } @@ -369,6 +367,8 @@ public class TileEntityReactorPort extends TileEntityReactorBlock implements IFl if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { //Allow inserting return false; + } else if (capability == Capabilities.GAS_HANDLER_CAPABILITY) { + return getReactor() == null; } return super.isCapabilityDisabled(capability, side); }