649 lines
20 KiB
Java
649 lines
20 KiB
Java
/*
|
|
* This file is part of Industrial Wires.
|
|
* Copyright (C) 2016-2018 malte0811
|
|
* Industrial Wires is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
* Industrial Wires is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Industrial Wires. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package malte0811.industrialwires.blocks.wire;
|
|
|
|
import blusunrize.immersiveengineering.api.ApiUtils;
|
|
import blusunrize.immersiveengineering.api.TargetingInfo;
|
|
import blusunrize.immersiveengineering.api.energy.wires.*;
|
|
import blusunrize.immersiveengineering.api.energy.wires.ImmersiveNetHandler.AbstractConnection;
|
|
import blusunrize.immersiveengineering.api.energy.wires.ImmersiveNetHandler.Connection;
|
|
import blusunrize.immersiveengineering.common.blocks.IEBlockInterfaces.IDirectionalTile;
|
|
import com.cout970.magneticraft.api.core.INode;
|
|
import com.cout970.magneticraft.api.energy.IElectricNode;
|
|
import com.cout970.magneticraft.api.energy.IElectricNodeHandler;
|
|
import com.cout970.magneticraft.registry.CapabilitiesKt;
|
|
import com.cout970.magneticraft.systems.config.Config;
|
|
import gregtech.api.capability.GregtechCapabilities;
|
|
import gregtech.api.capability.IEnergyContainer;
|
|
import ic2.api.energy.tile.IEnergyAcceptor;
|
|
import ic2.api.energy.tile.IEnergyEmitter;
|
|
import ic2.api.energy.tile.IEnergySink;
|
|
import ic2.api.energy.tile.IEnergySource;
|
|
import malte0811.industrialwires.IMixedConnector;
|
|
import malte0811.industrialwires.IWConfig;
|
|
import malte0811.industrialwires.IndustrialWires;
|
|
import malte0811.industrialwires.blocks.IBlockBoundsIW;
|
|
import malte0811.industrialwires.compat.Compat;
|
|
import malte0811.industrialwires.util.ConversionUtil;
|
|
import malte0811.industrialwires.util.MiscUtils;
|
|
import malte0811.industrialwires.wires.MixedWireType;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.ITickable;
|
|
import net.minecraft.util.math.*;
|
|
import net.minecraftforge.common.capabilities.Capability;
|
|
import net.minecraftforge.energy.CapabilityEnergy;
|
|
import net.minecraftforge.energy.IEnergyStorage;
|
|
import net.minecraftforge.fml.common.Loader;
|
|
import net.minecraftforge.fml.common.Optional;
|
|
import org.apache.commons.lang3.tuple.ImmutablePair;
|
|
import org.apache.commons.lang3.tuple.Pair;
|
|
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
|
|
import static malte0811.industrialwires.wires.MixedWireType.TIN;
|
|
|
|
@Optional.InterfaceList({
|
|
@Optional.Interface(iface = "ic2.api.energy.tile.IEnergySource", modid = "ic2"),
|
|
@Optional.Interface(iface = "ic2.api.energy.tile.IEnergySink", modid = "ic2")
|
|
})
|
|
public class TileEntityIC2ConnectorTin extends TileEntityImmersiveConnectable implements IEnergySource, IEnergySink, IDirectionalTile,
|
|
ITickable, IMixedConnector, IBlockBoundsIW {
|
|
private static final double EPS = .1;
|
|
private EnumFacing facing = EnumFacing.NORTH;
|
|
private boolean relay;
|
|
// external net to IE net buffer
|
|
private double bufferToNet = 0;
|
|
private double potentialIEInputInTick = 0;
|
|
private double actualIEInputInTick = 0;
|
|
private double maxToNet = 0;
|
|
//IE net to external net buffer
|
|
private double bufferToMachine = 0;
|
|
private double externalInputInTick = 0;
|
|
private double maxToMachine = 0;
|
|
//private EnergyType energyType = NONE;
|
|
private boolean shouldBreak = false;
|
|
private final double maxIO;
|
|
private final MixedWireType wireType;
|
|
private final int tier;
|
|
private final double relayOffset;
|
|
private final double connOffset;
|
|
|
|
protected TileEntityIC2ConnectorTin(boolean relay, MixedWireType type, int tier, double relayLength, double connLength) {
|
|
this.relay = relay;
|
|
wireType = type;
|
|
maxIO = type.getIORate();
|
|
this.tier = tier;
|
|
this.relayOffset = relayLength-.5;
|
|
this.connOffset = connLength-.5;
|
|
}
|
|
|
|
public TileEntityIC2ConnectorTin(boolean relay) {
|
|
this(relay, TIN, 1, .5, .5);
|
|
}
|
|
|
|
public TileEntityIC2ConnectorTin() {
|
|
this(false);
|
|
}
|
|
|
|
@Override
|
|
public void onLoad() {
|
|
super.onLoad();
|
|
if (!world.isRemote&& IndustrialWires.hasIC2)
|
|
Compat.loadIC2Tile.accept(this);
|
|
ImmersiveNetHandler.INSTANCE.onTEValidated(this);
|
|
}
|
|
|
|
@Override
|
|
public void update() {
|
|
if (!world.isRemote) {
|
|
if (shouldBreak) {
|
|
Deque<BlockPos> open = new ArrayDeque<>();
|
|
open.push(pos);
|
|
Set<BlockPos> closed = new HashSet<>();
|
|
closed.add(pos);
|
|
while (!open.isEmpty()) {
|
|
BlockPos next = open.pop();
|
|
Set<Connection> conns = ImmersiveNetHandler.INSTANCE.getConnections(world, next);
|
|
if (conns!=null) {
|
|
for (Connection c:conns) {
|
|
ImmersiveNetHandler.INSTANCE.getTransferedRates(world.provider.getDimension())
|
|
.put(c, 2*c.cableType.getTransferRate());
|
|
if (closed.add(c.end)) {
|
|
open.push(c.end);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (BlockPos p:closed) {
|
|
TileEntity tile = world.getTileEntity(p);
|
|
if (tile instanceof IImmersiveConnectable && ((IImmersiveConnectable) tile).isEnergyOutput()) {
|
|
world.createExplosion(null, p.getX()+.5, p.getY()+.5, p.getZ()+.5,
|
|
3, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (bufferToNet < maxToNet) {
|
|
maxToNet = bufferToNet;
|
|
}
|
|
if (externalInputInTick > maxToNet) {
|
|
maxToNet = externalInputInTick;
|
|
}
|
|
externalInputInTick = 0;
|
|
|
|
if (bufferToMachine < maxToMachine) {
|
|
maxToMachine = bufferToMachine;
|
|
}
|
|
potentialIEInputInTick = Math.min(Math.max(potentialIEInputInTick, actualIEInputInTick), getMaxIO());
|
|
if (potentialIEInputInTick > maxToMachine) {
|
|
maxToMachine = potentialIEInputInTick;
|
|
}
|
|
potentialIEInputInTick = 0;
|
|
actualIEInputInTick = 0;
|
|
if (bufferToNet > EPS) {
|
|
transferPowerToNet();
|
|
}
|
|
if (bufferToNet >EPS) {
|
|
notifyAvailableEnergy(bufferToNet);
|
|
}
|
|
if (bufferToMachine > EPS) {
|
|
transferPowerToFEMachine();
|
|
if (Loader.isModLoaded("gregtech"))
|
|
transferPowerToGTMachine();
|
|
if (Loader.isModLoaded("magneticraft"))
|
|
transferPowerToMagn();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void transferPowerToNet() {
|
|
Set<AbstractConnection> conns = ImmersiveNetHandler.INSTANCE.getIndirectEnergyConnections(pos, world, true);
|
|
Map<AbstractConnection, Pair<IMixedConnector, Double>> maxOutputs = new HashMap<>();
|
|
double outputMax = Math.min(bufferToNet, maxToNet);
|
|
double sum = 0;
|
|
for (AbstractConnection c : conns) {
|
|
if (c.isEnergyOutput) {
|
|
IImmersiveConnectable iic = ApiUtils.toIIC(c.end, world);
|
|
if (iic instanceof IMixedConnector) {
|
|
double extract =
|
|
outputMax - ((IMixedConnector) iic).insertEnergy(outputMax, true);
|
|
if (extract > EPS) {
|
|
maxOutputs.put(c, new ImmutablePair<>((IMixedConnector) iic, extract));
|
|
sum += extract;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sum > EPS) {
|
|
HashMap<Connection, Integer> transferedPerConn = ImmersiveNetHandler.INSTANCE.getTransferedRates(world.provider.getDimension());
|
|
for (Map.Entry<AbstractConnection, Pair<IMixedConnector, Double>> entry : maxOutputs.entrySet()) {
|
|
Pair<IMixedConnector, Double> p = entry.getValue();
|
|
AbstractConnection c = entry.getKey();
|
|
double out = outputMax * p.getRight() / sum;
|
|
double loss = Math.min(getAverageLossRate(c), 1)*out;
|
|
out = Math.min(out, bufferToNet -loss);
|
|
if (out<=0)
|
|
continue;
|
|
double inserted = out - p.getLeft().insertEnergy(out, false);
|
|
double energyAtConn = inserted + loss;
|
|
bufferToNet -= energyAtConn;
|
|
float intermediaryLoss = 0;
|
|
HashSet<IImmersiveConnectable> passedConnectors = new HashSet<>();
|
|
for (Connection sub : c.subConnections) {
|
|
int transferredPerCon = transferedPerConn.getOrDefault(sub, 0);
|
|
energyAtConn -= sub.cableType.getLossRatio() * sub.length;
|
|
double wireLoad = energyAtConn;
|
|
transferedPerConn.put(sub, (int) (transferredPerCon + wireLoad));
|
|
IImmersiveConnectable subStart = ApiUtils.toIIC(sub.start, world);
|
|
IImmersiveConnectable subEnd = ApiUtils.toIIC(sub.end, world);
|
|
if (subStart != null && passedConnectors.add(subStart))
|
|
subStart.onEnergyPassthrough((int) (inserted - inserted * intermediaryLoss));
|
|
if (subEnd != null && passedConnectors.add(subEnd))
|
|
subEnd.onEnergyPassthrough((int) (inserted - inserted * intermediaryLoss));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void transferPowerToFEMachine() {
|
|
BlockPos outPos = pos.offset(facing);
|
|
TileEntity te = MiscUtils.getLoadedTE(world, outPos, TileEntity.class);
|
|
if (te!=null && te.hasCapability(CapabilityEnergy.ENERGY, facing.getOpposite())) {
|
|
IEnergyStorage handler = te.getCapability(CapabilityEnergy.ENERGY, facing.getOpposite());
|
|
assert handler!=null;
|
|
double outJoules = Math.min(bufferToMachine, maxToMachine*IWConfig.wireRatio);
|
|
int outFE = MathHelper.floor(outJoules*ConversionUtil.ifPerJoule());
|
|
int received = handler.receiveEnergy(outFE, false);
|
|
bufferToMachine -= received*ConversionUtil.joulesPerIf();
|
|
}
|
|
}
|
|
|
|
private void transferPowerToGTMachine() {
|
|
BlockPos outPos = pos.offset(facing);
|
|
TileEntity te = MiscUtils.getLoadedTE(world, outPos, TileEntity.class);
|
|
if (te!=null && te.hasCapability(GregtechCapabilities.CAPABILITY_ENERGY_CONTAINER, facing.getOpposite())) {
|
|
IEnergyContainer container = te.getCapability(GregtechCapabilities.CAPABILITY_ENERGY_CONTAINER, facing.getOpposite());
|
|
assert container!=null;
|
|
double outJoules = Math.min(bufferToMachine, maxToMachine*IWConfig.wireRatio);
|
|
long outEU = Math.min(MathHelper.floor(outJoules*ConversionUtil.euPerJoule()), container.getInputVoltage());
|
|
long received = container.addEnergy(outEU);
|
|
bufferToMachine -= received*ConversionUtil.joulesPerEu();
|
|
}
|
|
}
|
|
|
|
private void transferPowerToMagn() {
|
|
BlockPos outPos = pos.offset(facing);
|
|
TileEntity te = MiscUtils.getLoadedTE(world, outPos, TileEntity.class);
|
|
if (te!=null && te.hasCapability(CapabilitiesKt.getELECTRIC_NODE_HANDLER(), facing.getOpposite())) {
|
|
IElectricNodeHandler handler = te.getCapability(CapabilitiesKt.getELECTRIC_NODE_HANDLER(), facing.getOpposite());
|
|
assert handler!=null;
|
|
double outJoules = Math.min(bufferToMachine, maxToMachine*IWConfig.wireRatio);
|
|
int outRF = MathHelper.floor(outJoules*ConversionUtil.ifPerJoule());
|
|
IElectricNode node = null;
|
|
for (INode n : handler.getNodes()) {
|
|
if (n instanceof IElectricNode) {
|
|
node = (IElectricNode) n;
|
|
break;
|
|
}
|
|
}
|
|
if (node != null) {
|
|
double insertet = node.applyPower(outRF * Config.INSTANCE.getWattsToFE(), false);
|
|
bufferToMachine -= insertet/Config.INSTANCE.getWattsToFE();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void notifyAvailableEnergy(double storedNew)
|
|
{
|
|
Set<AbstractConnection> outputs = ImmersiveNetHandler.INSTANCE.getIndirectEnergyConnections(pos, world, true);
|
|
for(AbstractConnection con : outputs)
|
|
{
|
|
IImmersiveConnectable end = ApiUtils.toIIC(con.end, world);
|
|
if(con.cableType!=null && end!=null && end.allowEnergyToPass(null))
|
|
{
|
|
Pair<Float, Consumer<Float>> e = getEnergyForConnection(con, storedNew);
|
|
end.addAvailableEnergy(e.getKey(), e.getValue());
|
|
}
|
|
}
|
|
addAvailableEnergy(-1, null);
|
|
}
|
|
|
|
private Pair<Float, Consumer<Float>> getEnergyForConnection(@Nullable AbstractConnection c, double storedNew)
|
|
{
|
|
float loss = c!=null?c.getAverageLossRate():0;
|
|
float max = (float) (storedNew-loss);
|
|
Consumer<Float> extract = (energy)-> bufferToNet -= energy+loss;
|
|
return new ImmutablePair<>(max, extract);
|
|
}
|
|
|
|
private double getAverageLossRate(AbstractConnection conn) {
|
|
double f = 0;
|
|
for (Connection c : conn.subConnections) {
|
|
WireType type = c.cableType;
|
|
if (type instanceof MixedWireType) {
|
|
f += c.length * ((MixedWireType)type).getLoss();
|
|
} else {
|
|
f = Double.POSITIVE_INFINITY;
|
|
}
|
|
}
|
|
return f;
|
|
}
|
|
|
|
//Input through the net
|
|
@Override
|
|
public double insertEnergy(double joules, boolean simulate) {
|
|
double insert = Math.min(getMaxIO() - bufferToMachine, joules);
|
|
insert = Math.min(getMaxIO()-actualIEInputInTick, insert);
|
|
if (!simulate) {
|
|
bufferToMachine += insert;
|
|
actualIEInputInTick += insert;
|
|
} else {
|
|
//Yes, this is weird. But it works, otherwise the system can get stuck at a lower output rate with a full buffer
|
|
potentialIEInputInTick += Math.min(joules, getMaxIO());
|
|
}
|
|
return joules - insert;
|
|
}
|
|
|
|
private double getMaxIO() {
|
|
return maxIO;
|
|
}
|
|
|
|
@Override
|
|
public void invalidate() {
|
|
if (!world.isRemote)
|
|
Compat.unloadIC2Tile.accept(this);
|
|
super.invalidate();
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload() {
|
|
super.onChunkUnload();
|
|
if (!world.isRemote)
|
|
Compat.unloadIC2Tile.accept(this);
|
|
}
|
|
|
|
@Override
|
|
public Vec3d getConnectionOffset(Connection con) {
|
|
EnumFacing side = facing.getOpposite();
|
|
double conRadius = con.cableType.getRenderDiameter() / 2;
|
|
double length = relay?relayOffset:connOffset;
|
|
return new Vec3d(.5 + (length - conRadius) * side.getXOffset(),
|
|
.5 + (length - conRadius) * side.getYOffset(),
|
|
.5 + (length - conRadius) * side.getZOffset());
|
|
}
|
|
|
|
@Override
|
|
public boolean canConnect() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnergyOutput() {
|
|
return !relay;
|
|
}
|
|
|
|
@Override
|
|
public boolean canConnectCable(WireType cableType, TargetingInfo target, Vec3i offset) {
|
|
return (limitType == null || this.isRelay()) && WireApi.canMix(cableType, wireType);
|
|
}
|
|
|
|
@Override
|
|
protected boolean isRelay() {
|
|
return relay;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public boolean emitsEnergyTo(IEnergyAcceptor receiver, EnumFacing side) {
|
|
return !relay && side == facing;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public boolean acceptsEnergyFrom(IEnergyEmitter emitter, EnumFacing side) {
|
|
return !relay && side == facing;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public double getDemandedEnergy() {
|
|
double ret = (getMaxIO() - bufferToNet) * ConversionUtil.euPerJoule() + .05;
|
|
if (ret < .1)
|
|
ret = 0;
|
|
return ret;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public int getSinkTier() {
|
|
return tier;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public double injectEnergy(EnumFacing directionFrom, double amount, double voltage) {
|
|
return amount-ConversionUtil.euPerJoule()*addToIn(ConversionUtil.joulesPerEu()*amount, false);
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public double getOfferedEnergy() {
|
|
return Math.min(maxToMachine, bufferToMachine) * ConversionUtil.euPerJoule();
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public void drawEnergy(double amount) {
|
|
bufferToMachine -= amount*ConversionUtil.joulesPerEu();
|
|
markDirty();
|
|
}
|
|
|
|
@Nullable
|
|
protected Pair<Float,Consumer<Float>> getOwnEnergy()
|
|
{
|
|
if (isRelay())
|
|
return null;
|
|
return new ImmutablePair<>((float) bufferToNet, (d)-> bufferToNet -= d);
|
|
}
|
|
@Override
|
|
protected float getBaseDamage(ImmersiveNetHandler.Connection c) {
|
|
return 1/64F;
|
|
}
|
|
|
|
@Override
|
|
@Optional.Method(modid="ic2")
|
|
public int getSourceTier() {
|
|
return tier;
|
|
}
|
|
|
|
// Returns amount of energy consumed
|
|
private double addToIn(double joules, boolean simulate) {
|
|
joules = Math.min(getMaxIO() - externalInputInTick + .5, joules);
|
|
if (bufferToNet < getMaxIO()) {
|
|
if (!simulate) {
|
|
bufferToNet += joules;
|
|
externalInputInTick += joules;
|
|
notifyAvailableEnergy(joules);
|
|
}
|
|
markDirty();
|
|
return joules;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void readCustomNBT(@Nonnull NBTTagCompound nbt, boolean descPacket) {
|
|
super.readCustomNBT(nbt, descPacket);
|
|
facing = EnumFacing.byIndex(nbt.getInteger("facing"));
|
|
relay = nbt.getBoolean("relay");
|
|
int version = nbt.getInteger("version");
|
|
bufferToNet = nbt.getDouble("inBuffer");
|
|
bufferToMachine = nbt.getDouble("outBuffer");
|
|
if (nbt.hasKey("maxToNet")) {
|
|
maxToNet = nbt.getDouble("maxToNet");
|
|
} else {
|
|
maxToNet = bufferToNet;
|
|
}
|
|
if (nbt.hasKey("maxToMachine")) {
|
|
maxToMachine = nbt.getDouble("maxToMachine");
|
|
} else {
|
|
maxToMachine = bufferToMachine;
|
|
}
|
|
if (version==0) {
|
|
bufferToNet *= ConversionUtil.joulesPerEu();
|
|
bufferToMachine *= ConversionUtil.joulesPerEu();
|
|
maxToNet *= ConversionUtil.joulesPerEu();
|
|
maxToMachine *= ConversionUtil.joulesPerEu();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeCustomNBT(@Nonnull NBTTagCompound nbt, boolean descPacket) {
|
|
super.writeCustomNBT(nbt, descPacket);
|
|
nbt.setInteger("facing", facing.getIndex());
|
|
nbt.setBoolean("relay", relay);
|
|
nbt.setDouble("inBuffer", bufferToNet);
|
|
nbt.setDouble("outBuffer", bufferToMachine);
|
|
nbt.setDouble("maxToNet", maxToNet);
|
|
nbt.setDouble("maxToMachine", maxToMachine);
|
|
nbt.setInteger("version", 1);
|
|
}
|
|
|
|
@Nonnull
|
|
@Override
|
|
public EnumFacing getFacing() {
|
|
return facing;
|
|
}
|
|
|
|
@Override
|
|
public void setFacing(@Nonnull EnumFacing facing) {
|
|
this.facing = facing;
|
|
}
|
|
|
|
@Override
|
|
public int getFacingLimitation() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean mirrorFacingOnPlacement(@Nonnull EntityLivingBase placer) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canHammerRotate(@Nonnull EnumFacing side, float hitX, float hitY, float hitZ, @Nonnull EntityLivingBase entity) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public AxisAlignedBB getBoundingBox() {
|
|
double length = .5+(relay?relayOffset:connOffset);
|
|
double wMin = .3125;
|
|
double wMax = .6875;
|
|
switch (facing.getOpposite()) {
|
|
case UP:
|
|
return new AxisAlignedBB(wMin, 0, wMin, wMax, length, wMax);
|
|
case DOWN:
|
|
return new AxisAlignedBB(wMin, 1 - length, wMin, wMax, 1, wMax);
|
|
case SOUTH:
|
|
return new AxisAlignedBB(wMin, wMin, 0, wMax, wMax, length);
|
|
case NORTH:
|
|
return new AxisAlignedBB(wMin, wMin, 1 - length, wMax, wMax, 1);
|
|
case EAST:
|
|
return new AxisAlignedBB(0, wMin, wMin, length, wMax, wMax);
|
|
case WEST:
|
|
return new AxisAlignedBB(1 - length, wMin, wMin, 1, wMax, wMax);
|
|
}
|
|
return new AxisAlignedBB(0, 0, 0, 1, 1, 1);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
|
|
if (capability==CapabilityEnergy.ENERGY) {
|
|
return !isRelay() && facing == this.facing;
|
|
}
|
|
return super.hasCapability(capability, facing);
|
|
}
|
|
|
|
@Override
|
|
public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
|
|
if (capability==CapabilityEnergy.ENERGY) {
|
|
if (!isRelay() && facing == this.facing) {
|
|
return CapabilityEnergy.ENERGY.cast(energyHandler);
|
|
}
|
|
return null;
|
|
}
|
|
return super.getCapability(capability, facing);
|
|
}
|
|
|
|
/*
|
|
* regarding equals+hashCode
|
|
* TE's are considered equal if they have the same pos+dimension id
|
|
* This is necessary to work around a weird bug causing a lot of log spam (100GB and above are well possible).
|
|
* For further information see #1 (https://github.com/malte0811/IndustrialWires/issues/1)
|
|
*/
|
|
@Override
|
|
public int hashCode() {
|
|
if (world==null)
|
|
return 0;
|
|
int ret = world.provider.getDimension();
|
|
ret = 31 * ret + pos.hashCode();
|
|
return ret;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (obj == this) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof TileEntityIC2ConnectorTin)) {
|
|
return false;
|
|
}
|
|
if (obj.getClass() != getClass()) {
|
|
return false;
|
|
}
|
|
TileEntityIC2ConnectorTin te = (TileEntityIC2ConnectorTin) obj;
|
|
if (!te.pos.equals(pos)) {
|
|
return false;
|
|
}
|
|
if (te.world.provider.getDimension() != world.provider.getDimension()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canRotate(@Nonnull EnumFacing axis) {
|
|
return false;
|
|
}
|
|
|
|
private EnergyHandler energyHandler = new EnergyHandler();
|
|
|
|
private class EnergyHandler implements IEnergyStorage {
|
|
|
|
@Override
|
|
public int receiveEnergy(int maxReceive, boolean simulate) {
|
|
if (bufferToNet>=getMaxIO()) {
|
|
return 0;
|
|
}
|
|
double joules = maxReceive*ConversionUtil.joulesPerIf();
|
|
double accepted = addToIn(joules, simulate);
|
|
return MathHelper.ceil(accepted*ConversionUtil.ifPerJoule());
|
|
}
|
|
|
|
@Override
|
|
public int extractEnergy(int maxExtract, boolean simulate) {
|
|
double joules = maxExtract*ConversionUtil.joulesPerIf();
|
|
if (joules>maxToMachine) {
|
|
joules = maxToMachine;
|
|
}
|
|
if (joules>bufferToMachine) {
|
|
joules = bufferToMachine;
|
|
}
|
|
if (!simulate) {
|
|
bufferToMachine -= joules;
|
|
}
|
|
return MathHelper.floor(ConversionUtil.ifPerJoule()*joules);
|
|
}
|
|
|
|
@Override
|
|
public int getEnergyStored() {
|
|
return (int)((bufferToMachine+bufferToNet)*ConversionUtil.ifPerJoule());
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyStored() {
|
|
return (int) (2* getMaxIO() *ConversionUtil.ifPerJoule());
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtract() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceive() {
|
|
return true;
|
|
}
|
|
}
|
|
}
|