mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-19 19:49:50 +00:00
I went for what seemed like a good level of organisation: Java __________ Mekanism __________ Minecraft Forge FML __________ Netty LWJGL __________ Other APIs __________ Static Imports.
185 lines
4.3 KiB
Java
185 lines
4.3 KiB
Java
package mekanism.common.tile;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.EnumSet;
|
|
|
|
import mekanism.api.gas.Gas;
|
|
import mekanism.api.gas.GasStack;
|
|
import mekanism.api.gas.IGasHandler;
|
|
import mekanism.api.gas.ITubeConnection;
|
|
import mekanism.common.PacketHandler;
|
|
import mekanism.common.content.teleportation.SharedInventory;
|
|
import mekanism.common.content.teleportation.SharedInventoryManager;
|
|
import mekanism.common.util.CableUtils;
|
|
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
public class TileEntityEntangledBlock extends TileEntityElectricBlock implements IFluidHandler, IGasHandler, ITubeConnection
|
|
{
|
|
public SharedInventory sharedInventory;
|
|
|
|
public static final EnumSet<ForgeDirection> nothing = EnumSet.noneOf(ForgeDirection.class);
|
|
|
|
public TileEntityEntangledBlock()
|
|
{
|
|
super("Entangled", 0);
|
|
inventory = new ItemStack[0];
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate()
|
|
{
|
|
super.onUpdate();
|
|
|
|
CableUtils.emit(this);
|
|
}
|
|
|
|
public void setInventory(String frequency)
|
|
{
|
|
sharedInventory = SharedInventoryManager.getInventory(frequency);
|
|
markDirty();
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream)
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
switch(dataStream.readInt())
|
|
{
|
|
case 0:
|
|
setInventory(PacketHandler.readString(dataStream));
|
|
return;
|
|
}
|
|
}
|
|
|
|
super.handlePacketData(dataStream);
|
|
setEnergy(dataStream.readDouble());
|
|
}
|
|
|
|
@Override
|
|
public ArrayList getNetworkedData(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
data.add(getEnergy());
|
|
return data;
|
|
}
|
|
|
|
public EnumSet<ForgeDirection> getOutputtingSides()
|
|
{
|
|
return sharedInventory == null ? nothing : EnumSet.of(ForgeDirection.UP);
|
|
}
|
|
|
|
protected EnumSet<ForgeDirection> getConsumingSides()
|
|
{
|
|
return sharedInventory == null ? nothing : EnumSet.complementOf(EnumSet.of(ForgeDirection.UNKNOWN, ForgeDirection.UP));
|
|
}
|
|
|
|
public double getMaxOutput()
|
|
{
|
|
return sharedInventory == null ? 0 : 1000;
|
|
}
|
|
|
|
@Override
|
|
public double getEnergy()
|
|
{
|
|
return sharedInventory == null ? 0 : sharedInventory.getEnergy();
|
|
}
|
|
|
|
@Override
|
|
public void setEnergy(double energy)
|
|
{
|
|
if(sharedInventory != null)
|
|
{
|
|
sharedInventory.setEnergy(energy);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public double getMaxEnergy()
|
|
{
|
|
return sharedInventory == null ? 0 : sharedInventory.getMaxEnergy();
|
|
}
|
|
|
|
@Override
|
|
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
|
|
{
|
|
return sharedInventory == null ? 0 : sharedInventory.fill(from, resource, doFill);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
|
|
{
|
|
if(sharedInventory == null)
|
|
{
|
|
return null;
|
|
}
|
|
return sharedInventory.drain(from, resource, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
|
|
{
|
|
if(sharedInventory == null)
|
|
{
|
|
return null;
|
|
}
|
|
return sharedInventory.drain(from, maxDrain, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill(ForgeDirection from, Fluid fluid)
|
|
{
|
|
return sharedInventory == null ? false : sharedInventory.canFill(from, fluid);
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain(ForgeDirection from, Fluid fluid)
|
|
{
|
|
return sharedInventory == null ? false : sharedInventory.canDrain(from, fluid);
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo(ForgeDirection from)
|
|
{
|
|
return sharedInventory == null ? new FluidTankInfo[0] : sharedInventory.getTankInfo(from);
|
|
}
|
|
|
|
@Override
|
|
public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer)
|
|
{
|
|
return sharedInventory == null ? 0 : sharedInventory.receiveGas(side, stack, doTransfer);
|
|
}
|
|
|
|
@Override
|
|
public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer)
|
|
{
|
|
return sharedInventory == null ? null : sharedInventory.drawGas(side, amount, doTransfer);
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceiveGas(ForgeDirection side, Gas type)
|
|
{
|
|
return sharedInventory == null ? false : sharedInventory.canReceiveGas(side, type);
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrawGas(ForgeDirection side, Gas type)
|
|
{
|
|
return sharedInventory == null ? false : sharedInventory.canDrawGas(side, type);
|
|
}
|
|
|
|
@Override
|
|
public boolean canTubeConnect(ForgeDirection side)
|
|
{
|
|
return sharedInventory == null ? false : true;
|
|
}
|
|
}
|