mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 04:52:25 +00:00
* prevent Out of Bounds exception in factory ItemMeshDefinition * prevent Out of Bounds error in item stack display name * Respect NONE connection between pipes. Fixes #4781 * prevent fluid/gas pipes from connecting if their contents arent the same (part 1) * prevent some case of incorrect network merges that would convert/void a fluid/gas * Add a way to check if a network is compatible with an buffer Used for checking the orphan's buffer against the external network * rename some generic type variables for readability * introduce BUFFER generic type variable * Fix missing null check causing new pipes not being able to be added to a network * More checks for when there is an invalid factory * bump api version & use a constant for all * add default method to not break binary compat * Refresh if a connection exists if a transmitter failed to combine two networks Fallback to the network's buffer as if we have not saved any data yet the TE's buffer may still be null * Add a way to get the pipes buffer falling back to the network, rather than doing it from the same method. This ensures that there is no accidental leakage where the count of the buffer matters * Return a null buffer for pressurized tube buffer if the stack is empty * Allow merging of networks when they are able to connect again Visuals still need a minor update to sync the type it should be rendering * Update network visuals when networks merge * allow unconnected sides to have their mode set - except logistical transporters which already used that function, they only can un-NONE their unconnected sides
416 lines
15 KiB
Java
416 lines
15 KiB
Java
package mekanism.common.tile.transmitter;
|
|
|
|
import cofh.redstoneflux.api.IEnergyProvider;
|
|
import cofh.redstoneflux.api.IEnergyReceiver;
|
|
import ic2.api.energy.EnergyNet;
|
|
import ic2.api.energy.tile.IEnergySource;
|
|
import ic2.api.energy.tile.IEnergyTile;
|
|
import io.netty.buffer.ByteBuf;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import javax.annotation.Nonnull;
|
|
import mekanism.api.TileNetworkList;
|
|
import mekanism.api.energy.EnergyStack;
|
|
import mekanism.api.energy.IStrictEnergyAcceptor;
|
|
import mekanism.api.energy.IStrictEnergyStorage;
|
|
import mekanism.api.transmitters.TransmissionType;
|
|
import mekanism.common.tier.BaseTier;
|
|
import mekanism.common.tier.CableTier;
|
|
import mekanism.common.base.EnergyAcceptorWrapper;
|
|
import mekanism.common.block.states.BlockStateTransmitter.TransmitterType;
|
|
import mekanism.common.capabilities.Capabilities;
|
|
import mekanism.common.capabilities.CapabilityWrapperManager;
|
|
import mekanism.common.config.MekanismConfig;
|
|
import mekanism.common.integration.MekanismHooks;
|
|
import mekanism.common.integration.forgeenergy.ForgeEnergyCableIntegration;
|
|
import mekanism.common.integration.tesla.TeslaCableIntegration;
|
|
import mekanism.common.transmitters.grid.EnergyNetwork;
|
|
import mekanism.common.util.CableUtils;
|
|
import mekanism.common.util.CapabilityUtils;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import net.darkhax.tesla.api.ITeslaProducer;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraftforge.common.capabilities.Capability;
|
|
import net.minecraftforge.energy.CapabilityEnergy;
|
|
import net.minecraftforge.energy.IEnergyStorage;
|
|
import net.minecraftforge.fml.common.Optional;
|
|
|
|
@Optional.InterfaceList(
|
|
@Optional.Interface(iface = "cofh.redstoneflux.api.IEnergyReceiver", modid = MekanismHooks.REDSTONEFLUX_MOD_ID)
|
|
)
|
|
public class TileEntityUniversalCable extends TileEntityTransmitter<EnergyAcceptorWrapper, EnergyNetwork, EnergyStack> implements
|
|
IStrictEnergyAcceptor, IStrictEnergyStorage, IEnergyReceiver {
|
|
|
|
public CableTier tier = CableTier.BASIC;
|
|
|
|
public double currentPower = 0;
|
|
public double lastWrite = 0;
|
|
|
|
public EnergyStack buffer = new EnergyStack(0);
|
|
private CapabilityWrapperManager teslaManager = new CapabilityWrapperManager<>(getClass(),
|
|
TeslaCableIntegration.class);
|
|
private CapabilityWrapperManager forgeEnergyManager = new CapabilityWrapperManager<>(getClass(),
|
|
ForgeEnergyCableIntegration.class);
|
|
|
|
@Override
|
|
public BaseTier getBaseTier() {
|
|
return tier.getBaseTier();
|
|
}
|
|
|
|
@Override
|
|
public void setBaseTier(BaseTier baseTier) {
|
|
tier = CableTier.get(baseTier);
|
|
}
|
|
|
|
@Override
|
|
public void update() {
|
|
if (getWorld().isRemote) {
|
|
double targetPower =
|
|
getTransmitter().hasTransmitterNetwork() ? getTransmitter().getTransmitterNetwork().clientEnergyScale
|
|
: 0;
|
|
|
|
if (Math.abs(currentPower - targetPower) > 0.01) {
|
|
currentPower = (9 * currentPower + targetPower) / 10;
|
|
}
|
|
} else {
|
|
updateShare();
|
|
|
|
List<EnumFacing> sides = getConnections(ConnectionType.PULL);
|
|
|
|
if (!sides.isEmpty()) {
|
|
TileEntity[] connectedOutputters = CableUtils.getConnectedOutputters(getPos(), getWorld());
|
|
double canDraw = tier.getCableCapacity();
|
|
|
|
for (EnumFacing side : sides) {
|
|
if (connectedOutputters[side.ordinal()] != null) {
|
|
TileEntity outputter = connectedOutputters[side.ordinal()];
|
|
|
|
if (CapabilityUtils
|
|
.hasCapability(outputter, Capabilities.ENERGY_OUTPUTTER_CAPABILITY, side.getOpposite())
|
|
&& CapabilityUtils
|
|
.hasCapability(outputter, Capabilities.ENERGY_STORAGE_CAPABILITY, side.getOpposite())) {
|
|
IStrictEnergyStorage storage = CapabilityUtils
|
|
.getCapability(outputter, Capabilities.ENERGY_STORAGE_CAPABILITY, side.getOpposite());
|
|
double received = Math.min(storage.getEnergy(), canDraw);
|
|
double toDraw = received;
|
|
|
|
if (received > 0) {
|
|
toDraw -= takeEnergy(received, true);
|
|
}
|
|
|
|
storage.setEnergy(storage.getEnergy() - toDraw);
|
|
} else if (MekanismUtils.useTesla() && CapabilityUtils
|
|
.hasCapability(outputter, Capabilities.TESLA_PRODUCER_CAPABILITY, side.getOpposite())) {
|
|
ITeslaProducer producer = CapabilityUtils
|
|
.getCapability(outputter, Capabilities.TESLA_PRODUCER_CAPABILITY, side.getOpposite());
|
|
double toDraw = producer
|
|
.takePower(Math.round(Math.min(Integer.MAX_VALUE,
|
|
canDraw * MekanismConfig.current().general.TO_TESLA.val())), true)
|
|
* MekanismConfig.current().general.FROM_TESLA.val();
|
|
|
|
if (toDraw > 0) {
|
|
toDraw -= takeEnergy(toDraw, true);
|
|
}
|
|
|
|
producer.takePower(Math.round(toDraw * MekanismConfig.current().general.TO_TESLA.val()),
|
|
false);
|
|
} else if (MekanismUtils.useForge() && CapabilityUtils
|
|
.hasCapability(outputter, CapabilityEnergy.ENERGY, side.getOpposite())) {
|
|
IEnergyStorage storage = CapabilityUtils
|
|
.getCapability(outputter, CapabilityEnergy.ENERGY, side.getOpposite());
|
|
double toDraw = storage.extractEnergy(
|
|
(int) Math.round(canDraw * MekanismConfig.current().general.TO_FORGE.val()), true)
|
|
* MekanismConfig.current().general.FROM_FORGE.val();
|
|
|
|
if (toDraw > 0) {
|
|
toDraw -= takeEnergy(toDraw, true);
|
|
}
|
|
|
|
storage.extractEnergy(
|
|
(int) Math.round(toDraw * MekanismConfig.current().general.TO_TESLA.val()), false);
|
|
} else if (MekanismUtils.useRF() && outputter instanceof IEnergyProvider) {
|
|
double toDraw = ((IEnergyProvider) outputter).extractEnergy(side.getOpposite(),
|
|
(int) Math.round(Math.min(Integer.MAX_VALUE,
|
|
canDraw * MekanismConfig.current().general.TO_RF.val())), true)
|
|
* MekanismConfig.current().general.FROM_RF.val();
|
|
|
|
if (toDraw > 0) {
|
|
toDraw -= takeEnergy(toDraw, true);
|
|
}
|
|
|
|
((IEnergyProvider) outputter)
|
|
.extractEnergy(side.getOpposite(),
|
|
(int) Math.round(toDraw * MekanismConfig.current().general.TO_RF.val()), false);
|
|
} else if (MekanismUtils.useIC2()) {
|
|
IEnergyTile tile = EnergyNet.instance.getSubTile(outputter.getWorld(), outputter.getPos());
|
|
|
|
if (tile instanceof IEnergySource) {
|
|
double received = Math
|
|
.min(((IEnergySource) tile).getOfferedEnergy() * MekanismConfig
|
|
.current().general.FROM_IC2.val(), canDraw);
|
|
double toDraw = received;
|
|
|
|
if (received > 0) {
|
|
toDraw -= takeEnergy(received, true);
|
|
}
|
|
|
|
((IEnergySource) tile)
|
|
.drawEnergy(toDraw * MekanismConfig.current().general.TO_IC2.val());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
super.update();
|
|
}
|
|
|
|
@Override
|
|
public void updateShare() {
|
|
if (getTransmitter().hasTransmitterNetwork() && getTransmitter().getTransmitterNetworkSize() > 0) {
|
|
double last = getSaveShare();
|
|
|
|
if (last != lastWrite) {
|
|
lastWrite = last;
|
|
markDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
private double getSaveShare() {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
return EnergyNetwork.round(getTransmitter().getTransmitterNetwork().buffer.amount * (1F / getTransmitter()
|
|
.getTransmitterNetwork().transmitters.size()));
|
|
} else {
|
|
return buffer.amount;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public TransmitterType getTransmitterType() {
|
|
return TransmitterType.UNIVERSAL_CABLE;
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTags) {
|
|
super.readFromNBT(nbtTags);
|
|
|
|
buffer.amount = nbtTags.getDouble("cacheEnergy");
|
|
if (buffer.amount < 0) {
|
|
buffer.amount = 0;
|
|
}
|
|
|
|
if (nbtTags.hasKey("tier")) {
|
|
tier = CableTier.values()[nbtTags.getInteger("tier")];
|
|
}
|
|
}
|
|
|
|
@Nonnull
|
|
@Override
|
|
public NBTTagCompound writeToNBT(NBTTagCompound nbtTags) {
|
|
super.writeToNBT(nbtTags);
|
|
|
|
nbtTags.setDouble("cacheEnergy", lastWrite);
|
|
nbtTags.setInteger("tier", tier.ordinal());
|
|
|
|
return nbtTags;
|
|
}
|
|
|
|
@Override
|
|
public TransmissionType getTransmissionType() {
|
|
return TransmissionType.ENERGY;
|
|
}
|
|
|
|
@Override
|
|
public EnergyNetwork createNetworkByMerging(Collection<EnergyNetwork> networks) {
|
|
return new EnergyNetwork(networks);
|
|
}
|
|
|
|
@Override
|
|
public boolean isValidAcceptor(TileEntity acceptor, EnumFacing side) {
|
|
return CableUtils.isValidAcceptorOnSide(getWorld().getTileEntity(getPos()), acceptor, side);
|
|
}
|
|
|
|
@Override
|
|
public EnergyNetwork createNewNetwork() {
|
|
return new EnergyNetwork();
|
|
}
|
|
|
|
@Override
|
|
public EnergyStack getBuffer() {
|
|
return buffer;
|
|
}
|
|
|
|
@Override
|
|
public void takeShare() {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
getTransmitter().getTransmitterNetwork().buffer.amount -= lastWrite;
|
|
buffer.amount = lastWrite;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid = MekanismHooks.REDSTONEFLUX_MOD_ID)
|
|
public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate) {
|
|
return maxReceive - (int) Math
|
|
.round(Math.min(Integer.MAX_VALUE,
|
|
takeEnergy(maxReceive * MekanismConfig.current().general.FROM_RF.val(), !simulate) * MekanismConfig
|
|
.current().general.TO_RF.val()));
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid = MekanismHooks.REDSTONEFLUX_MOD_ID)
|
|
public boolean canConnectEnergy(EnumFacing from) {
|
|
return canConnect(from);
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid = MekanismHooks.REDSTONEFLUX_MOD_ID)
|
|
public int getEnergyStored(EnumFacing from) {
|
|
return (int) Math
|
|
.round(Math.min(Integer.MAX_VALUE, getEnergy() * MekanismConfig.current().general.TO_RF.val()));
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid = MekanismHooks.REDSTONEFLUX_MOD_ID)
|
|
public int getMaxEnergyStored(EnumFacing from) {
|
|
return (int) Math
|
|
.round(Math.min(Integer.MAX_VALUE, getMaxEnergy() * MekanismConfig.current().general.TO_RF.val()));
|
|
}
|
|
|
|
@Override
|
|
public int getCapacity() {
|
|
return tier.getCableCapacity();
|
|
}
|
|
|
|
@Override
|
|
public double acceptEnergy(EnumFacing side, double amount, boolean simulate) {
|
|
double toUse = Math.min(getMaxEnergy() - getEnergy(), amount);
|
|
|
|
if (toUse < 0.0001 || (side != null && !canReceiveEnergy(side))) {
|
|
return 0;
|
|
}
|
|
|
|
if (!simulate) {
|
|
setEnergy(getEnergy() + toUse);
|
|
}
|
|
|
|
return toUse;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceiveEnergy(EnumFacing side) {
|
|
if (side == null) {
|
|
return true;
|
|
}
|
|
|
|
return getConnectionType(side) == ConnectionType.NORMAL;
|
|
}
|
|
|
|
@Override
|
|
public double getMaxEnergy() {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
return getTransmitter().getTransmitterNetwork().getCapacity();
|
|
} else {
|
|
return getCapacity();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double getEnergy() {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
return getTransmitter().getTransmitterNetwork().buffer.amount;
|
|
} else {
|
|
return buffer.amount;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setEnergy(double energy) {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
getTransmitter().getTransmitterNetwork().buffer.amount = energy;
|
|
} else {
|
|
buffer.amount = energy;
|
|
}
|
|
}
|
|
|
|
public double takeEnergy(double energy, boolean doEmit) {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
return getTransmitter().getTransmitterNetwork().emit(energy, doEmit);
|
|
} else {
|
|
double used = Math.min(getCapacity() - buffer.amount, energy);
|
|
|
|
if (doEmit) {
|
|
buffer.amount += used;
|
|
}
|
|
|
|
return energy - used;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public EnergyAcceptorWrapper getCachedAcceptor(EnumFacing side) {
|
|
return EnergyAcceptorWrapper.get(getCachedTile(side), side.getOpposite());
|
|
}
|
|
|
|
@Override
|
|
public boolean upgrade(int tierOrdinal) {
|
|
if (tier.ordinal() < BaseTier.ULTIMATE.ordinal() && tierOrdinal == tier.ordinal() + 1) {
|
|
tier = CableTier.values()[tier.ordinal() + 1];
|
|
|
|
markDirtyTransmitters();
|
|
sendDesc = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream) throws Exception {
|
|
tier = CableTier.values()[dataStream.readInt()];
|
|
|
|
super.handlePacketData(dataStream);
|
|
}
|
|
|
|
@Override
|
|
public TileNetworkList getNetworkedData(TileNetworkList data) {
|
|
data.add(tier.ordinal());
|
|
|
|
super.getNetworkedData(data);
|
|
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCapability(@Nonnull Capability<?> capability, EnumFacing facing) {
|
|
return capability == Capabilities.ENERGY_STORAGE_CAPABILITY
|
|
|| capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY
|
|
|| capability == Capabilities.TESLA_CONSUMER_CAPABILITY
|
|
|| capability == CapabilityEnergy.ENERGY
|
|
|| super.hasCapability(capability, facing);
|
|
}
|
|
|
|
@Override
|
|
public <T> T getCapability(@Nonnull Capability<T> capability, EnumFacing facing) {
|
|
if (capability == Capabilities.ENERGY_STORAGE_CAPABILITY
|
|
|| capability == Capabilities.ENERGY_ACCEPTOR_CAPABILITY) {
|
|
return (T) this;
|
|
}
|
|
|
|
if (capability == Capabilities.TESLA_CONSUMER_CAPABILITY) {
|
|
return (T) teslaManager.getWrapper(this, facing);
|
|
}
|
|
|
|
if (capability == CapabilityEnergy.ENERGY) {
|
|
return (T) forgeEnergyManager.getWrapper(this, facing);
|
|
}
|
|
|
|
return super.getCapability(capability, facing);
|
|
}
|
|
}
|