2013-08-27 00:49:32 +02:00
|
|
|
package mekanism.common.tileentity;
|
2012-10-28 23:18:23 +01:00
|
|
|
|
2013-10-09 00:06:25 +02:00
|
|
|
import ic2.api.energy.event.EnergyTileLoadEvent;
|
2013-04-13 16:33:37 +02:00
|
|
|
import ic2.api.energy.event.EnergyTileUnloadEvent;
|
|
|
|
import ic2.api.energy.tile.IEnergyTile;
|
2013-05-03 02:12:51 +02:00
|
|
|
import ic2.api.tile.IWrenchable;
|
2013-04-13 16:33:37 +02:00
|
|
|
|
2013-02-27 02:21:30 +01:00
|
|
|
import java.util.ArrayList;
|
2013-03-18 17:23:57 +01:00
|
|
|
import java.util.EnumSet;
|
|
|
|
|
2013-08-27 00:49:32 +02:00
|
|
|
import mekanism.api.energy.IStrictEnergyStorage;
|
|
|
|
import mekanism.common.ITileNetwork;
|
|
|
|
import mekanism.common.Mekanism;
|
2013-04-13 16:33:37 +02:00
|
|
|
import net.minecraft.nbt.NBTTagCompound;
|
2013-07-31 17:54:58 +02:00
|
|
|
import net.minecraft.world.World;
|
2013-04-13 16:33:37 +02:00
|
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
|
|
import net.minecraftforge.common.MinecraftForge;
|
2013-03-18 17:23:57 +01:00
|
|
|
import universalelectricity.core.block.IConnector;
|
2013-07-27 00:16:21 +02:00
|
|
|
import universalelectricity.core.block.IElectrical;
|
|
|
|
import universalelectricity.core.block.IElectricalStorage;
|
2013-03-18 17:23:57 +01:00
|
|
|
import universalelectricity.core.electricity.ElectricityPack;
|
2012-12-20 22:53:39 +01:00
|
|
|
import buildcraft.api.power.IPowerReceptor;
|
2013-07-31 17:54:58 +02:00
|
|
|
import buildcraft.api.power.PowerHandler;
|
|
|
|
import buildcraft.api.power.PowerHandler.PowerReceiver;
|
2012-10-28 23:18:23 +01:00
|
|
|
|
2013-04-13 16:33:37 +02:00
|
|
|
import com.google.common.io.ByteArrayDataInput;
|
|
|
|
|
2013-07-27 00:16:21 +02:00
|
|
|
public abstract class TileEntityElectricBlock extends TileEntityContainerBlock implements IWrenchable, ITileNetwork, IPowerReceptor, IEnergyTile, IElectrical, IElectricalStorage, IConnector, IStrictEnergyStorage
|
2012-10-28 23:18:23 +01:00
|
|
|
{
|
|
|
|
/** How much energy is stored in this block. */
|
2012-11-25 16:45:00 +01:00
|
|
|
public double electricityStored;
|
2012-10-28 23:18:23 +01:00
|
|
|
|
|
|
|
/** Maximum amount of energy this machine can hold. */
|
2012-11-25 16:45:00 +01:00
|
|
|
public double MAX_ELECTRICITY;
|
2012-10-28 23:18:23 +01:00
|
|
|
|
2013-07-31 17:54:58 +02:00
|
|
|
/** BuildCraft power handler. */
|
|
|
|
public PowerHandler powerHandler;
|
2012-10-28 23:18:23 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The base of all blocks that deal with electricity. It has a facing state, initialized state,
|
|
|
|
* and a current amount of stored energy.
|
|
|
|
* @param name - full name of this block
|
|
|
|
* @param maxEnergy - how much energy this block can store
|
|
|
|
*/
|
2013-02-01 01:43:39 +01:00
|
|
|
public TileEntityElectricBlock(String name, double maxEnergy)
|
2012-10-28 23:18:23 +01:00
|
|
|
{
|
2012-11-21 16:14:35 +01:00
|
|
|
super(name);
|
2012-11-25 16:45:00 +01:00
|
|
|
MAX_ELECTRICITY = maxEnergy;
|
2012-12-21 14:30:40 +01:00
|
|
|
|
2013-07-31 17:54:58 +02:00
|
|
|
powerHandler = new PowerHandler(this, PowerHandler.Type.MACHINE);
|
|
|
|
powerHandler.configure(0, 100, 0, (int)(maxEnergy*Mekanism.TO_BC));
|
2012-10-28 23:18:23 +01:00
|
|
|
}
|
2012-12-19 21:23:55 +01:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onUpdate()
|
|
|
|
{
|
2013-07-31 17:54:58 +02:00
|
|
|
if(!worldObj.isRemote)
|
2012-12-19 21:23:55 +01:00
|
|
|
{
|
2013-10-09 00:06:25 +02:00
|
|
|
if(packetTick == 0)
|
|
|
|
{
|
|
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
|
|
|
|
}
|
|
|
|
|
2013-07-31 17:54:58 +02:00
|
|
|
if(getEnergy() < getMaxEnergy() && powerHandler.getEnergyStored() > 0)
|
|
|
|
{
|
|
|
|
setEnergy(getEnergy() + powerHandler.useEnergy(0, (float)((getMaxEnergy()-getEnergy())*Mekanism.TO_BC), true)*Mekanism.FROM_BC);
|
|
|
|
}
|
2012-12-19 21:23:55 +01:00
|
|
|
}
|
2013-03-18 17:23:57 +01:00
|
|
|
}
|
2013-11-02 17:00:29 +01:00
|
|
|
|
|
|
|
public ForgeDirection getOutputtingSide()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
2013-03-18 17:23:57 +01:00
|
|
|
|
|
|
|
protected EnumSet<ForgeDirection> getConsumingSides()
|
|
|
|
{
|
|
|
|
return EnumSet.allOf(ForgeDirection.class);
|
|
|
|
}
|
|
|
|
|
2013-11-02 17:00:29 +01:00
|
|
|
public double getMaxOutput()
|
2013-03-18 17:23:57 +01:00
|
|
|
{
|
2013-11-02 17:00:29 +01:00
|
|
|
return 0;
|
2013-03-18 17:23:57 +01:00
|
|
|
}
|
|
|
|
|
2013-07-27 00:16:21 +02:00
|
|
|
@Override
|
|
|
|
public boolean canConnect(ForgeDirection direction)
|
2013-03-18 17:23:57 +01:00
|
|
|
{
|
2013-11-02 17:00:29 +01:00
|
|
|
return getConsumingSides().contains(direction) || getOutputtingSide() == direction;
|
2013-03-18 17:23:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2013-04-19 21:43:00 +02:00
|
|
|
public double getEnergy()
|
|
|
|
{
|
|
|
|
return electricityStored;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void setEnergy(double energy)
|
|
|
|
{
|
|
|
|
electricityStored = Math.max(Math.min(energy, getMaxEnergy()), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public double getMaxEnergy()
|
2013-03-18 17:23:57 +01:00
|
|
|
{
|
|
|
|
return MAX_ELECTRICITY;
|
|
|
|
}
|
|
|
|
|
2013-04-19 21:43:00 +02:00
|
|
|
@Override
|
2013-07-27 00:16:21 +02:00
|
|
|
public float getVoltage()
|
2013-03-18 17:23:57 +01:00
|
|
|
{
|
|
|
|
return 120;
|
2012-12-19 21:23:55 +01:00
|
|
|
}
|
|
|
|
|
2013-02-27 02:21:30 +01:00
|
|
|
@Override
|
|
|
|
public void handlePacketData(ByteArrayDataInput dataStream)
|
|
|
|
{
|
|
|
|
super.handlePacketData(dataStream);
|
2013-08-22 17:36:31 +02:00
|
|
|
setEnergy(dataStream.readDouble());
|
2013-02-27 02:21:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ArrayList getNetworkedData(ArrayList data)
|
|
|
|
{
|
|
|
|
super.getNetworkedData(data);
|
2013-08-22 17:36:31 +02:00
|
|
|
data.add(getEnergy());
|
2013-02-27 02:21:30 +01:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2012-12-19 21:23:55 +01:00
|
|
|
@Override
|
|
|
|
public void invalidate()
|
|
|
|
{
|
2013-08-30 21:20:52 +02:00
|
|
|
if(!worldObj.isRemote)
|
2012-12-19 21:23:55 +01:00
|
|
|
{
|
|
|
|
if(Mekanism.hooks.IC2Loaded)
|
|
|
|
{
|
|
|
|
MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
|
|
|
|
}
|
|
|
|
}
|
2013-03-18 17:23:57 +01:00
|
|
|
|
|
|
|
super.invalidate();
|
2012-12-19 21:23:55 +01:00
|
|
|
}
|
2012-10-28 23:18:23 +01:00
|
|
|
|
2012-11-06 16:44:14 +01:00
|
|
|
@Override
|
2012-11-02 02:30:40 +01:00
|
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
|
|
|
{
|
|
|
|
super.readFromNBT(nbtTags);
|
|
|
|
|
2012-11-25 16:45:00 +01:00
|
|
|
electricityStored = nbtTags.getDouble("electricityStored");
|
2013-10-20 05:36:09 +02:00
|
|
|
powerHandler.readFromNBT(nbtTags);
|
2012-11-02 02:30:40 +01:00
|
|
|
}
|
|
|
|
|
2012-11-06 16:44:14 +01:00
|
|
|
@Override
|
2012-11-02 02:30:40 +01:00
|
|
|
public void writeToNBT(NBTTagCompound nbtTags)
|
|
|
|
{
|
|
|
|
super.writeToNBT(nbtTags);
|
|
|
|
|
2013-08-22 17:36:31 +02:00
|
|
|
nbtTags.setDouble("electricityStored", getEnergy());
|
2013-10-20 05:36:09 +02:00
|
|
|
powerHandler.writeToNBT(nbtTags);
|
2012-11-02 02:30:40 +01:00
|
|
|
}
|
2012-10-28 23:18:23 +01:00
|
|
|
|
2012-11-15 21:04:12 +01:00
|
|
|
@Override
|
2013-07-31 17:54:58 +02:00
|
|
|
public PowerReceiver getPowerReceiver(ForgeDirection side)
|
2012-11-15 21:04:12 +01:00
|
|
|
{
|
2013-07-31 17:54:58 +02:00
|
|
|
return powerHandler.getPowerReceiver();
|
2012-11-15 21:04:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2013-07-31 17:54:58 +02:00
|
|
|
public void doWork(PowerHandler workProvider) {}
|
2012-11-15 21:04:12 +01:00
|
|
|
|
|
|
|
@Override
|
2013-07-31 17:54:58 +02:00
|
|
|
public World getWorld()
|
|
|
|
{
|
|
|
|
return worldObj;
|
|
|
|
}
|
2013-07-27 00:16:21 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public float receiveElectricity(ForgeDirection from, ElectricityPack receive, boolean doReceive)
|
|
|
|
{
|
|
|
|
if(getConsumingSides().contains(from))
|
|
|
|
{
|
2013-07-31 22:44:53 +02:00
|
|
|
double toAdd = (float)Math.min(getMaxEnergy()-getEnergy(), receive.getWatts()*Mekanism.FROM_UE);
|
2013-07-27 00:16:21 +02:00
|
|
|
|
|
|
|
if(doReceive)
|
|
|
|
{
|
|
|
|
setEnergy(getEnergy() + toAdd);
|
|
|
|
}
|
|
|
|
|
2013-07-31 22:44:53 +02:00
|
|
|
return (float)(toAdd*Mekanism.TO_UE);
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ElectricityPack provideElectricity(ForgeDirection from, ElectricityPack request, boolean doProvide)
|
|
|
|
{
|
2013-11-02 17:00:29 +01:00
|
|
|
if(getOutputtingSide() == from)
|
|
|
|
{
|
|
|
|
double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), request.getWatts()*Mekanism.FROM_UE));
|
|
|
|
|
|
|
|
if(doProvide)
|
|
|
|
{
|
|
|
|
setEnergy(getEnergy() - toSend);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ElectricityPack.getFromWatts((float)(toSend*Mekanism.TO_UE), getVoltage());
|
|
|
|
}
|
|
|
|
|
|
|
|
return new ElectricityPack();
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public float getRequest(ForgeDirection direction)
|
|
|
|
{
|
|
|
|
if(getConsumingSides().contains(direction))
|
|
|
|
{
|
2013-08-01 17:23:07 +02:00
|
|
|
return getMaxEnergyStored()-getEnergyStored();
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2013-11-02 17:00:29 +01:00
|
|
|
public float getProvide(ForgeDirection direction)
|
2013-07-27 00:16:21 +02:00
|
|
|
{
|
2013-11-02 17:00:29 +01:00
|
|
|
return getOutputtingSide() == direction ? Math.min(getEnergyStored(), (float)(getMaxOutput()*Mekanism.TO_UE)) : 0;
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void setEnergyStored(float energy)
|
|
|
|
{
|
2013-07-31 22:44:53 +02:00
|
|
|
setEnergy(energy*Mekanism.FROM_UE);
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public float getEnergyStored()
|
|
|
|
{
|
2013-07-31 22:44:53 +02:00
|
|
|
return (float)(getEnergy()*Mekanism.TO_UE);
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public float getMaxEnergyStored()
|
|
|
|
{
|
2013-07-31 22:44:53 +02:00
|
|
|
return (float)(getMaxEnergy()*Mekanism.TO_UE);
|
2013-07-27 00:16:21 +02:00
|
|
|
}
|
2013-08-22 17:36:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the scaled energy level for the GUI.
|
|
|
|
* @param i - multiplier
|
|
|
|
* @return scaled energy
|
|
|
|
*/
|
|
|
|
public int getScaledEnergyLevel(int i)
|
|
|
|
{
|
|
|
|
return (int)(getEnergy()*i / getMaxEnergy());
|
|
|
|
}
|
2012-10-28 23:18:23 +01:00
|
|
|
}
|