electrodynamics/archive/java/resonantinduction/old/transport/TileEntityAssembly.java
2014-01-11 17:44:07 +08:00

200 lines
4.6 KiB
Java

package resonantinduction.old.transport;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraftforge.common.ForgeDirection;
import resonantinduction.core.prefab.tile.TileEntityEnergyMachine;
import resonantinduction.core.tilenetwork.INetworkEnergyPart;
import resonantinduction.core.tilenetwork.ITileNetwork;
import resonantinduction.core.tilenetwork.prefab.NetworkSharedPower;
import universalelectricity.api.vector.Vector3;
/**
* A class to be inherited by all machines on the assembly line. This class acts as a single peace
* in a network of similar tiles allowing all to share power from one or more sources
*
* @author DarkGuardsman
*/
public abstract class TileEntityAssembly extends TileEntityEnergyMachine implements INetworkEnergyPart
{
/** lowest value the network can update at */
public static int refresh_min_rate = 20;
/** range by which the network can update at */
public static int refresh_diff = 9;
/** Network used to link assembly machines together */
private NetworkAssembly assemblyNetwork;
/** Tiles that are connected to this */
public List<TileEntity> connectedTiles = new ArrayList<TileEntity>();
/** Random instance */
public Random random = new Random();
/** Random rate by which this tile updates its network connections */
private int updateTick = 1;
public TileEntityAssembly(long wattsPerTick)
{
super(wattsPerTick);
}
public TileEntityAssembly(long wattsPerTick, long maxEnergy)
{
super(wattsPerTick, maxEnergy);
}
@Override
public void invalidate()
{
this.getTileNetwork().splitNetwork(this);
super.invalidate();
}
@Override
public void updateEntity()
{
super.updateEntity();
if (!this.worldObj.isRemote)
{
if (ticks % updateTick == 0)
{
this.updateTick = (random.nextInt(1 + refresh_diff) + refresh_min_rate);
this.refresh();
}
}
}
@Override
public boolean canTileConnect(Connection type, ForgeDirection dir)
{
return true;
}
@Override
public void refresh()
{
if (this.worldObj != null && !this.worldObj.isRemote)
{
this.connectedTiles.clear();
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity tileEntity = new Vector3(this).modifyPositionFromSide(dir).getTileEntity(this.worldObj);
if (tileEntity instanceof TileEntityAssembly && ((TileEntityAssembly) tileEntity).canTileConnect(Connection.NETWORK, dir.getOpposite()))
{
this.getTileNetwork().mergeNetwork(((TileEntityAssembly) tileEntity).getTileNetwork(), this);
connectedTiles.add(tileEntity);
}
}
}
}
@Override
public List<TileEntity> getNetworkConnections()
{
return this.connectedTiles;
}
@Override
public NetworkAssembly getTileNetwork()
{
if (!(this.assemblyNetwork instanceof NetworkAssembly))
{
this.assemblyNetwork = new NetworkAssembly(this);
}
return this.assemblyNetwork;
}
@Override
public void setTileNetwork(ITileNetwork network)
{
if (network instanceof NetworkAssembly)
{
this.assemblyNetwork = (NetworkAssembly) network;
}
}
@Override
public boolean consumePower(long request, boolean doExtract)
{
return ((NetworkSharedPower) this.getTileNetwork()).removePower(this, request, doExtract) >= request;
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (this.canConnect(from))
{
return this.getTileNetwork().addPower(this, receive, doReceive);
}
return 0;
}
/** Amount of energy this tile runs on per tick */
public int getWattLoad()
{
return 1;// 1J/t or 20J/t
}
/** Conditional load that may not be consumed per tick */
public int getExtraLoad()
{
return 1;// 1J/t or 20J/t
}
@Override
public void togglePowerMode()
{
super.togglePowerMode();
((NetworkSharedPower) this.getTileNetwork()).setPowerLess(!this.runPowerLess());
}
@Override
public long getEnergyStored()
{
return ((NetworkSharedPower) this.getTileNetwork()).getEnergy();
}
@Override
public long getMaxEnergyStored()
{
return ((NetworkSharedPower) this.getTileNetwork()).getEnergyCapacity();
}
@Override
public long getEnergy(ForgeDirection from)
{
return this.getEnergyStored();
}
@Override
public long getEnergyCapacity(ForgeDirection from)
{
return this.getMaxEnergyStored();
}
@Override
public long getPartEnergy()
{
return this.energyStored;
}
@Override
public long getPartMaxEnergy()
{
return this.MAX_JOULES_STORED;
}
@Override
public void setPartEnergy(long energy)
{
this.energyStored = energy;
}
@Override
public AxisAlignedBB getRenderBoundingBox()
{
return INFINITE_EXTENT_AABB;
}
}