mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-21 04:22:26 +00:00
Require IC2, BC or CoFHCore to be loaded in order to use their respective APIs. Remove all the individual mod deps to prevent us depending on mods that depend on us.
451 lines
9.5 KiB
Java
451 lines
9.5 KiB
Java
package mekanism.common.tile;
|
|
|
|
import ic2.api.energy.EnergyNet;
|
|
import ic2.api.energy.event.EnergyTileLoadEvent;
|
|
import ic2.api.energy.event.EnergyTileUnloadEvent;
|
|
import ic2.api.energy.tile.IEnergyConductor;
|
|
import ic2.api.energy.tile.IEnergyTile;
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.EnumSet;
|
|
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.EnumColor;
|
|
import mekanism.api.IConfigurable;
|
|
import mekanism.api.MekanismConfig.general;
|
|
import mekanism.api.Range4D;
|
|
import mekanism.api.transmitters.IGridTransmitter;
|
|
import mekanism.common.Mekanism;
|
|
import mekanism.common.base.IEnergyWrapper;
|
|
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
|
|
import mekanism.common.util.CableUtils;
|
|
import mekanism.common.util.LangUtils;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.ChatComponentText;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import cpw.mods.fml.common.Optional.Interface;
|
|
import cpw.mods.fml.common.Optional.InterfaceList;
|
|
import cpw.mods.fml.common.Optional.Method;
|
|
|
|
@InterfaceList({
|
|
@Interface(iface = "ic2.api.energy.tile.IEnergySink", modid = "IC2"),
|
|
@Interface(iface = "ic2.api.energy.tile.IEnergySource", modid = "IC2"),
|
|
@Interface(iface = "ic2.api.tile.IEnergyStorage", modid = "IC2"),
|
|
@Interface(iface = "cofh.api.energy.IEnergyHandler", modid = "CoFHCore"),
|
|
})
|
|
public class TileEntityInductionPort extends TileEntityInductionCasing implements IEnergyWrapper, IConfigurable
|
|
{
|
|
public boolean ic2Registered = false;
|
|
|
|
/** false = input, true = output */
|
|
public boolean mode;
|
|
|
|
public TileEntityInductionPort()
|
|
{
|
|
super("InductionPort");
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate()
|
|
{
|
|
super.onUpdate();
|
|
|
|
if(!ic2Registered && MekanismUtils.useIC2())
|
|
{
|
|
register();
|
|
}
|
|
|
|
if(!worldObj.isRemote)
|
|
{
|
|
if(structure != null && mode == true)
|
|
{
|
|
double prev = getEnergy();
|
|
CableUtils.emit(this);
|
|
structure.remainingOutput -= (prev-getEnergy());
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public EnumSet<ForgeDirection> getOutputtingSides()
|
|
{
|
|
if(structure != null && mode == true)
|
|
{
|
|
EnumSet set = EnumSet.allOf(ForgeDirection.class);
|
|
set.remove(ForgeDirection.UNKNOWN);
|
|
return set;
|
|
}
|
|
|
|
return EnumSet.noneOf(ForgeDirection.class);
|
|
}
|
|
|
|
@Override
|
|
public EnumSet<ForgeDirection> getConsumingSides()
|
|
{
|
|
if(structure != null && mode == false)
|
|
{
|
|
EnumSet set = EnumSet.allOf(ForgeDirection.class);
|
|
set.remove(ForgeDirection.UNKNOWN);
|
|
return set;
|
|
}
|
|
|
|
return EnumSet.noneOf(ForgeDirection.class);
|
|
}
|
|
|
|
@Override
|
|
public boolean canUpdate()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Method(modid = "IC2")
|
|
public void register()
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord);
|
|
|
|
if(registered != this)
|
|
{
|
|
if(registered instanceof IEnergyTile)
|
|
{
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered));
|
|
}
|
|
else if(registered == null)
|
|
{
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
|
|
ic2Registered = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Method(modid = "IC2")
|
|
public void deregister()
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord);
|
|
|
|
if(registered instanceof IEnergyTile)
|
|
{
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double getMaxOutput()
|
|
{
|
|
return structure != null ? structure.remainingOutput : 0;
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream)
|
|
{
|
|
super.handlePacketData(dataStream);
|
|
|
|
mode = dataStream.readBoolean();
|
|
|
|
MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
@Override
|
|
public ArrayList getNetworkedData(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
data.add(mode);
|
|
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public void onAdded()
|
|
{
|
|
super.onAdded();
|
|
|
|
if(MekanismUtils.useIC2())
|
|
{
|
|
register();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload()
|
|
{
|
|
if(MekanismUtils.useIC2())
|
|
{
|
|
deregister();
|
|
}
|
|
|
|
super.onChunkUnload();
|
|
}
|
|
|
|
@Override
|
|
public void invalidate()
|
|
{
|
|
super.invalidate();
|
|
|
|
if(MekanismUtils.useIC2())
|
|
{
|
|
deregister();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.readFromNBT(nbtTags);
|
|
|
|
mode = nbtTags.getBoolean("mode");
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.writeToNBT(nbtTags);
|
|
|
|
nbtTags.setBoolean("mode", mode);
|
|
}
|
|
|
|
/**
|
|
* Gets the scaled energy level for the GUI.
|
|
* @param i - multiplier
|
|
* @return scaled energy
|
|
*/
|
|
public int getScaledEnergyLevel(int i)
|
|
{
|
|
return (int)(getEnergy()*i / getMaxEnergy());
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "CoFHCore")
|
|
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
|
|
{
|
|
if(getConsumingSides().contains(from))
|
|
{
|
|
double toAdd = (int)Math.min(getMaxEnergy()-getEnergy(), maxReceive* general.FROM_TE);
|
|
|
|
if(!simulate)
|
|
{
|
|
setEnergy(getEnergy() + toAdd);
|
|
}
|
|
|
|
return (int)Math.round(toAdd* general.TO_TE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "CoFHCore")
|
|
public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
|
|
{
|
|
if(getOutputtingSides().contains(from))
|
|
{
|
|
double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), maxExtract*general.FROM_TE));
|
|
|
|
if(!simulate)
|
|
{
|
|
setEnergy(getEnergy() - toSend);
|
|
structure.remainingOutput -= toSend;
|
|
}
|
|
|
|
return (int)Math.round(toSend* general.TO_TE);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "CoFHCore")
|
|
public boolean canConnectEnergy(ForgeDirection from)
|
|
{
|
|
return structure != null;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "CoFHCore")
|
|
public int getEnergyStored(ForgeDirection from)
|
|
{
|
|
return (int)Math.round(getEnergy()* general.TO_TE);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "CoFHCore")
|
|
public int getMaxEnergyStored(ForgeDirection from)
|
|
{
|
|
return (int)Math.round(getMaxEnergy()* general.TO_TE);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int getSinkTier()
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int getSourceTier()
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public void setStored(int energy)
|
|
{
|
|
setEnergy(energy*general.FROM_IC2);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int addEnergy(int amount)
|
|
{
|
|
setEnergy(getEnergy() + amount*general.FROM_IC2);
|
|
return (int)Math.round(getEnergy()*general.TO_IC2);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public boolean isTeleporterCompatible(ForgeDirection side)
|
|
{
|
|
return canOutputTo(side);
|
|
}
|
|
|
|
@Override
|
|
public boolean canOutputTo(ForgeDirection side)
|
|
{
|
|
return getOutputtingSides().contains(side);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
|
|
{
|
|
return getConsumingSides().contains(direction);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction)
|
|
{
|
|
return getOutputtingSides().contains(direction) && receiver instanceof IEnergyConductor;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int getStored()
|
|
{
|
|
return (int)Math.round(getEnergy()*general.TO_IC2);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int getCapacity()
|
|
{
|
|
return (int)Math.round(getMaxEnergy()*general.TO_IC2);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public int getOutput()
|
|
{
|
|
return (int)Math.round(getMaxOutput()*general.TO_IC2);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public double getDemandedEnergy()
|
|
{
|
|
return (getMaxEnergy() - getEnergy())*general.TO_IC2;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public double getOfferedEnergy()
|
|
{
|
|
return Math.min(getEnergy(), getMaxOutput())*general.TO_IC2;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceiveEnergy(ForgeDirection side)
|
|
{
|
|
return getConsumingSides().contains(side);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public double getOutputEnergyUnitsPerTick()
|
|
{
|
|
return getMaxOutput()*general.TO_IC2;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public double injectEnergy(ForgeDirection direction, double amount, double voltage)
|
|
{
|
|
if(Coord4D.get(this).getFromSide(direction).getTileEntity(worldObj) instanceof IGridTransmitter)
|
|
{
|
|
return amount;
|
|
}
|
|
|
|
return amount-transferEnergyToAcceptor(direction, amount*general.FROM_IC2)*general.TO_IC2;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public void drawEnergy(double amount)
|
|
{
|
|
if(structure != null)
|
|
{
|
|
double toDraw = Math.min(amount*general.FROM_IC2, getMaxOutput());
|
|
setEnergy(Math.max(getEnergy() - toDraw, 0));
|
|
structure.remainingOutput -= toDraw;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double transferEnergyToAcceptor(ForgeDirection side, double amount)
|
|
{
|
|
if(!getConsumingSides().contains(side))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double toUse = Math.min(getMaxEnergy()-getEnergy(), amount);
|
|
setEnergy(getEnergy() + toUse);
|
|
|
|
return toUse;
|
|
}
|
|
|
|
@Override
|
|
public boolean onSneakRightClick(EntityPlayer player, int side)
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
mode = !mode;
|
|
String modeText = " " + (mode ? EnumColor.DARK_RED : EnumColor.DARK_GREEN) + LangUtils.transOutputInput(mode) + ".";
|
|
player.addChatMessage(new ChatComponentText(EnumColor.DARK_BLUE + "[Mekanism] " + EnumColor.GREY + MekanismUtils.localize("tooltip.configurator.inductionPortMode") + modeText));
|
|
|
|
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this)));
|
|
markDirty();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onRightClick(EntityPlayer player, int side)
|
|
{
|
|
return false;
|
|
}
|
|
}
|