generated from tilera/1710mod
161 lines
6.6 KiB
Java
161 lines
6.6 KiB
Java
package mffs.base;
|
|
|
|
import cpw.mods.fml.common.Optional;
|
|
import calclavia.lib.IUniversalEnergyTile;
|
|
import cofh.api.energy.IEnergyReceiver;
|
|
import ic2.api.energy.event.EnergyTileLoadEvent;
|
|
import ic2.api.energy.event.EnergyTileUnloadEvent;
|
|
import ic2.api.energy.tile.IEnergySink;
|
|
import mffs.ConversionHelper;
|
|
import mffs.tileentity.TileEntityCoercionDeriver;
|
|
|
|
import java.util.EnumSet;
|
|
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import universalelectricity.core.UniversalElectricity;
|
|
import universalelectricity.core.electricity.ElectricityNetworkHelper;
|
|
import universalelectricity.core.electricity.ElectricityPack;
|
|
import universalelectricity.core.vector.Vector3;
|
|
|
|
@Optional.Interface(modid = "IC2", iface = "ic2.api.energy.tile.IEnergySink")
|
|
public abstract class TileEntityUniversalEnergy
|
|
extends TileEntityModuleAcceptor implements IUniversalEnergyTile, IEnergyReceiver, IEnergySink {
|
|
public double prevWatts;
|
|
public double wattsReceived;
|
|
|
|
public TileEntityUniversalEnergy() { this.wattsReceived = 0.0; }
|
|
|
|
@Override
|
|
public void initiate() {
|
|
super.initiate();
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
|
|
}
|
|
|
|
@Override
|
|
public void invalidate() {
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
|
|
super.invalidate();
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
super.updateEntity();
|
|
this.prevWatts = this.wattsReceived;
|
|
if (!this.worldObj.isRemote) {
|
|
if (!this.isDisabled()) {
|
|
final ElectricityPack electricityPack =
|
|
ElectricityNetworkHelper.consumeFromMultipleSides(
|
|
this, this.getConsumingSides(), this.getRequest());
|
|
this.onReceive(electricityPack);
|
|
} else {
|
|
ElectricityNetworkHelper.consumeFromMultipleSides(
|
|
this, new ElectricityPack());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected EnumSet<ForgeDirection> getConsumingSides() {
|
|
return ElectricityNetworkHelper.getDirections(this);
|
|
}
|
|
|
|
public ElectricityPack getRequest() { return new ElectricityPack(); }
|
|
|
|
public void onReceive(final ElectricityPack electricityPack) {
|
|
if (UniversalElectricity.isVoltageSensitive &&
|
|
electricityPack.voltage > this.getVoltage()) {
|
|
return;
|
|
}
|
|
this.wattsReceived = Math.min(
|
|
this.wattsReceived + electricityPack.getWatts(), this.getWattBuffer());
|
|
}
|
|
|
|
public double getWattBuffer() { return this.getRequest().getWatts() * 2.0; }
|
|
|
|
@Override
|
|
public double getVoltage() {
|
|
return 120.0;
|
|
}
|
|
|
|
public ElectricityPack produce(double watts) {
|
|
ElectricityPack pack =
|
|
new ElectricityPack(watts / this.getVoltage(), this.getVoltage());
|
|
ElectricityPack remaining =
|
|
ElectricityNetworkHelper.produceFromMultipleSides(this, pack);
|
|
|
|
return remaining;
|
|
}
|
|
|
|
public int produceRF(int amount) {
|
|
int available = amount;
|
|
for(ForgeDirection dir : ForgeDirection.values()) {
|
|
TileEntity te = new Vector3(this).modifyPositionFromSide(dir).getTileEntity(this.worldObj);
|
|
if (te instanceof IEnergyReceiver) {
|
|
IEnergyReceiver receiver = (IEnergyReceiver) te;
|
|
if (!receiver.canConnectEnergy(dir.getOpposite())) continue;
|
|
available -= receiver.receiveEnergy(dir.getOpposite(), (available), false);
|
|
}
|
|
}
|
|
return amount - available;
|
|
}
|
|
|
|
@Override
|
|
public boolean canConnectEnergy(ForgeDirection side) {
|
|
return canConnect(side);
|
|
}
|
|
|
|
@Override
|
|
public int receiveEnergy(ForgeDirection side, int energy, boolean simulate) {
|
|
if (!canConnect(side)) return 0;
|
|
double toReceive = ConversionHelper.fromRF(energy);
|
|
double free = getWattBuffer() - wattsReceived;
|
|
double toInject = Math.min(toReceive, free);
|
|
if (!simulate) {
|
|
wattsReceived += toInject;
|
|
}
|
|
return (int) Math.ceil(toInject / UniversalElectricity.UE_RF_RATIO);
|
|
}
|
|
|
|
@Override
|
|
public int getEnergyStored(ForgeDirection var1) {
|
|
return ConversionHelper.toRF(getFortronEnergy() * TileEntityCoercionDeriver.FORTRON_UE_RATIO);
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyStored(ForgeDirection var1) {
|
|
return ConversionHelper.toRF(getFortronCapacity() * TileEntityCoercionDeriver.FORTRON_UE_RATIO);
|
|
}
|
|
|
|
@Optional.Method(modid = "IC2")
|
|
@Override
|
|
public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) {
|
|
return getConsumingSides().contains(direction);
|
|
}
|
|
|
|
@Optional.Method(modid = "IC2")
|
|
@Override
|
|
public double getDemandedEnergy() {
|
|
return ConversionHelper.toEU(this.getRequest().getWatts());
|
|
}
|
|
|
|
@Optional.Method(modid = "IC2")
|
|
@Override
|
|
public int getSinkTier() {
|
|
return 2;
|
|
}
|
|
|
|
@Optional.Method(modid = "IC2")
|
|
@Override
|
|
public double injectEnergy(ForgeDirection direction, double i, double voltage) {
|
|
double givenElectricity = ConversionHelper.fromEU(i);
|
|
double rejects = 0.0;
|
|
if (givenElectricity > this.getWattBuffer()) {
|
|
rejects = givenElectricity - this.getRequest().getWatts();
|
|
}
|
|
this.onReceive(new ElectricityPack(givenElectricity / this.getVoltage(), this.getVoltage()));
|
|
return ConversionHelper.toEU(rejects);
|
|
}
|
|
|
|
}
|