mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-20 03:59:37 +00:00
As of now, only items are supported, and the actual config GUI has not been changed. Only gameplay difference is three new configurator modes.
454 lines
12 KiB
Java
454 lines
12 KiB
Java
package mekanism.common.tile;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Map;
|
|
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.EnumColor;
|
|
import mekanism.api.MekanismConfig.usage;
|
|
import mekanism.api.gas.Gas;
|
|
import mekanism.api.gas.GasRegistry;
|
|
import mekanism.api.gas.GasStack;
|
|
import mekanism.api.gas.GasTank;
|
|
import mekanism.api.gas.IGasHandler;
|
|
import mekanism.api.gas.ITubeConnection;
|
|
import mekanism.api.transmitters.TransmissionType;
|
|
import mekanism.common.SideData;
|
|
import mekanism.common.Upgrade;
|
|
import mekanism.common.base.IDropperHandler;
|
|
import mekanism.common.base.ISustainedData;
|
|
import mekanism.common.block.BlockMachine.MachineType;
|
|
import mekanism.common.item.ItemUpgrade;
|
|
import mekanism.common.recipe.RecipeHandler;
|
|
import mekanism.common.recipe.inputs.PressurizedInput;
|
|
import mekanism.common.recipe.machines.PressurizedRecipe;
|
|
import mekanism.common.recipe.outputs.PressurizedProducts;
|
|
import mekanism.common.tile.component.TileComponentConfig;
|
|
import mekanism.common.tile.component.TileComponentEjector;
|
|
import mekanism.common.tile.component.TileComponentUpgrade;
|
|
import mekanism.common.util.ChargeUtils;
|
|
import mekanism.common.util.InventoryUtils;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import mekanism.common.util.PipeUtils;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidRegistry;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTank;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
import cpw.mods.fml.common.Optional.Method;
|
|
import dan200.computercraft.api.lua.ILuaContext;
|
|
import dan200.computercraft.api.lua.LuaException;
|
|
import dan200.computercraft.api.peripheral.IComputerAccess;
|
|
|
|
public class TileEntityPRC extends TileEntityBasicMachine<PressurizedInput, PressurizedProducts, PressurizedRecipe> implements IFluidHandler, IGasHandler, ITubeConnection, ISustainedData, IDropperHandler
|
|
{
|
|
public FluidTank inputFluidTank = new FluidTank(10000);
|
|
public GasTank inputGasTank = new GasTank(10000);
|
|
|
|
public GasTank outputGasTank = new GasTank(10000);
|
|
|
|
public TileEntityPRC()
|
|
{
|
|
super("prc", "PressurizedReactionChamber", new ResourceLocation("mekanism", "gui/GuiPRC.png"), usage.pressurizedReactionBaseUsage, 100, MachineType.PRESSURIZED_REACTION_CHAMBER.baseEnergy);
|
|
|
|
configComponent = new TileComponentConfig(this, TransmissionType.ITEM);
|
|
|
|
configComponent.addOutput(TransmissionType.ITEM, new SideData(EnumColor.GREY, InventoryUtils.EMPTY));
|
|
configComponent.addOutput(TransmissionType.ITEM, new SideData(EnumColor.DARK_RED, new int[] {0}));
|
|
configComponent.addOutput(TransmissionType.ITEM, new SideData(EnumColor.DARK_GREEN, new int[] {1}));
|
|
configComponent.addOutput(TransmissionType.ITEM, new SideData(EnumColor.DARK_BLUE, new int[] {2}));
|
|
configComponent.addOutput(TransmissionType.ITEM, new SideData(EnumColor.ORANGE, new int[] {3}));
|
|
|
|
configComponent.setConfig(TransmissionType.ITEM, new byte[] {2, 1, 0, 0, 0, 3});
|
|
|
|
inventory = new ItemStack[4];
|
|
|
|
upgradeComponent = new TileComponentUpgrade(this, 3);
|
|
ejectorComponent = new TileComponentEjector(this, configComponent.getOutputs(TransmissionType.ITEM).get(3));
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate()
|
|
{
|
|
super.onUpdate();
|
|
|
|
if(!worldObj.isRemote)
|
|
{
|
|
PressurizedRecipe recipe = getRecipe();
|
|
|
|
ChargeUtils.discharge(1, this);
|
|
|
|
if(canOperate(recipe) && MekanismUtils.canFunction(this) && getEnergy() >= MekanismUtils.getEnergyPerTick(this, BASE_ENERGY_PER_TICK + recipe.extraEnergy))
|
|
{
|
|
boolean update = BASE_TICKS_REQUIRED != recipe.ticks;
|
|
|
|
BASE_TICKS_REQUIRED = recipe.ticks;
|
|
|
|
if(update)
|
|
{
|
|
recalculateUpgradables(Upgrade.SPEED);
|
|
}
|
|
|
|
setActive(true);
|
|
|
|
if((operatingTicks+1) < ticksRequired)
|
|
{
|
|
operatingTicks++;
|
|
electricityStored -= energyPerTick;
|
|
}
|
|
else if((operatingTicks+1) >= ticksRequired && getEnergy() >= MekanismUtils.getEnergyPerTick(this, BASE_ENERGY_PER_TICK + recipe.extraEnergy))
|
|
{
|
|
operate(recipe);
|
|
|
|
operatingTicks = 0;
|
|
electricityStored -= MekanismUtils.getEnergyPerTick(this, BASE_ENERGY_PER_TICK + recipe.extraEnergy);
|
|
}
|
|
}
|
|
else {
|
|
BASE_TICKS_REQUIRED = 100;
|
|
|
|
if(prevEnergy >= getEnergy())
|
|
{
|
|
setActive(false);
|
|
}
|
|
}
|
|
|
|
if(!canOperate(recipe))
|
|
{
|
|
operatingTicks = 0;
|
|
}
|
|
|
|
prevEnergy = getEnergy();
|
|
|
|
if(outputGasTank.getGas() != null)
|
|
{
|
|
GasStack toSend = new GasStack(outputGasTank.getGas().getGas(), Math.min(outputGasTank.getStored(), 16));
|
|
|
|
TileEntity tileEntity = Coord4D.get(this).getFromSide(MekanismUtils.getRight(facing)).getTileEntity(worldObj);
|
|
|
|
if(tileEntity instanceof IGasHandler)
|
|
{
|
|
if(((IGasHandler)tileEntity).canReceiveGas(MekanismUtils.getLeft(facing), outputGasTank.getGas().getGas()))
|
|
{
|
|
outputGasTank.draw(((IGasHandler)tileEntity).receiveGas(MekanismUtils.getLeft(facing), toSend, true), true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotID, ItemStack itemstack)
|
|
{
|
|
if(slotID == 0)
|
|
{
|
|
return RecipeHandler.isInPressurizedRecipe(itemstack);
|
|
}
|
|
else if(slotID == 1)
|
|
{
|
|
return ChargeUtils.canBeDischarged(itemstack);
|
|
}
|
|
else if(slotID == 3)
|
|
{
|
|
return itemstack.getItem() instanceof ItemUpgrade;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public PressurizedRecipe getRecipe()
|
|
{
|
|
PressurizedInput input = getInput();
|
|
|
|
if(cachedRecipe == null || !input.testEquality(cachedRecipe.getInput()))
|
|
{
|
|
cachedRecipe = RecipeHandler.getPRCRecipe(input);
|
|
}
|
|
|
|
return cachedRecipe;
|
|
}
|
|
|
|
@Override
|
|
public PressurizedInput getInput()
|
|
{
|
|
return new PressurizedInput(inventory[0], inputFluidTank.getFluid(), inputGasTank.getGas());
|
|
}
|
|
|
|
@Override
|
|
public void operate(PressurizedRecipe recipe)
|
|
{
|
|
recipe.operate(inventory, inputFluidTank, inputGasTank, outputGasTank);
|
|
|
|
markDirty();
|
|
ejectorComponent.onOutput();
|
|
}
|
|
|
|
@Override
|
|
public boolean canOperate(PressurizedRecipe recipe)
|
|
{
|
|
return recipe != null && recipe.canOperate(inventory, inputFluidTank, inputGasTank, outputGasTank);
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtractItem(int slotID, ItemStack itemstack, int side)
|
|
{
|
|
if(slotID == 1)
|
|
{
|
|
return ChargeUtils.canBeOutputted(itemstack, false);
|
|
}
|
|
else if(slotID == 2 || slotID == 4)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public ArrayList getNetworkedData(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
if(inputFluidTank.getFluid() != null)
|
|
{
|
|
data.add(true);
|
|
data.add(inputFluidTank.getFluid().getFluid().getID());
|
|
data.add(inputFluidTank.getFluidAmount());
|
|
}
|
|
else {
|
|
data.add(false);
|
|
}
|
|
|
|
if(inputGasTank.getGas() != null)
|
|
{
|
|
data.add(true);
|
|
data.add(inputGasTank.getGas().getGas().getID());
|
|
data.add(inputGasTank.getStored());
|
|
}
|
|
else {
|
|
data.add(false);
|
|
}
|
|
|
|
if(outputGasTank.getGas() != null)
|
|
{
|
|
data.add(true);
|
|
data.add(outputGasTank.getGas().getGas().getID());
|
|
data.add(outputGasTank.getStored());
|
|
}
|
|
else {
|
|
data.add(false);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream)
|
|
{
|
|
super.handlePacketData(dataStream);
|
|
|
|
if(dataStream.readBoolean())
|
|
{
|
|
inputFluidTank.setFluid(new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt()));
|
|
}
|
|
else {
|
|
inputFluidTank.setFluid(null);
|
|
}
|
|
|
|
if(dataStream.readBoolean())
|
|
{
|
|
inputGasTank.setGas(new GasStack(GasRegistry.getGas(dataStream.readInt()), dataStream.readInt()));
|
|
}
|
|
else {
|
|
inputGasTank.setGas(null);
|
|
}
|
|
|
|
if(dataStream.readBoolean())
|
|
{
|
|
outputGasTank.setGas(new GasStack(GasRegistry.getGas(dataStream.readInt()), dataStream.readInt()));
|
|
}
|
|
else {
|
|
outputGasTank.setGas(null);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.readFromNBT(nbtTags);
|
|
|
|
inputFluidTank.readFromNBT(nbtTags.getCompoundTag("inputFluidTank"));
|
|
inputGasTank.read(nbtTags.getCompoundTag("inputGasTank"));
|
|
outputGasTank.read(nbtTags.getCompoundTag("outputGasTank"));
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.writeToNBT(nbtTags);
|
|
|
|
nbtTags.setTag("inputFluidTank", inputFluidTank.writeToNBT(new NBTTagCompound()));
|
|
nbtTags.setTag("inputGasTank", inputGasTank.write(new NBTTagCompound()));
|
|
nbtTags.setTag("outputGasTank", outputGasTank.write(new NBTTagCompound()));
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName()
|
|
{
|
|
return MekanismUtils.localize(getBlockType().getUnlocalizedName() + "." + fullName + ".short.name");
|
|
}
|
|
|
|
@Override
|
|
public Map getRecipes()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "ComputerCraft")
|
|
public String[] getMethodNames()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "ComputerCraft")
|
|
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException, InterruptedException
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
|
|
{
|
|
if(from == ForgeDirection.getOrientation(facing).getOpposite())
|
|
{
|
|
return inputFluidTank.fill(resource, doFill);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill(ForgeDirection from, Fluid fluid)
|
|
{
|
|
if(from == ForgeDirection.getOrientation(facing).getOpposite())
|
|
{
|
|
return inputFluidTank.getFluid() == null || inputFluidTank.getFluid().getFluid() == fluid;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain(ForgeDirection from, Fluid fluid)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo(ForgeDirection from)
|
|
{
|
|
if(from == ForgeDirection.getOrientation(facing).getOpposite())
|
|
{
|
|
return new FluidTankInfo[] {new FluidTankInfo(inputFluidTank)};
|
|
}
|
|
|
|
return PipeUtils.EMPTY;
|
|
}
|
|
|
|
@Override
|
|
public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer)
|
|
{
|
|
if(side == MekanismUtils.getLeft(facing))
|
|
{
|
|
return inputGasTank.receive(stack, doTransfer);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer)
|
|
{
|
|
if(side == MekanismUtils.getRight(facing))
|
|
{
|
|
return outputGasTank.draw(amount, doTransfer);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceiveGas(ForgeDirection side, Gas type)
|
|
{
|
|
return side == MekanismUtils.getLeft(facing) && (inputGasTank.getGas() == null || inputGasTank.getGas().getGas() == type);
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrawGas(ForgeDirection side, Gas type)
|
|
{
|
|
return side == MekanismUtils.getRight(facing) && outputGasTank.getGas() != null && outputGasTank.getGas().getGas() == type;
|
|
}
|
|
|
|
@Override
|
|
public boolean canTubeConnect(ForgeDirection side)
|
|
{
|
|
return side == MekanismUtils.getLeft(facing) || side == MekanismUtils.getRight(facing);
|
|
}
|
|
|
|
@Override
|
|
public void writeSustainedData(ItemStack itemStack)
|
|
{
|
|
if(inputFluidTank.getFluid() != null)
|
|
{
|
|
itemStack.stackTagCompound.setTag("inputFluidTank", inputFluidTank.getFluid().writeToNBT(new NBTTagCompound()));
|
|
}
|
|
|
|
if(inputGasTank.getGas() != null)
|
|
{
|
|
itemStack.stackTagCompound.setTag("inputGasTank", inputGasTank.getGas().write(new NBTTagCompound()));
|
|
}
|
|
|
|
if(outputGasTank.getGas() != null)
|
|
{
|
|
itemStack.stackTagCompound.setTag("outputGasTank", outputGasTank.getGas().write(new NBTTagCompound()));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readSustainedData(ItemStack itemStack)
|
|
{
|
|
inputFluidTank.setFluid(FluidStack.loadFluidStackFromNBT(itemStack.stackTagCompound.getCompoundTag("inputFluidTank")));
|
|
inputGasTank.setGas(GasStack.readFromNBT(itemStack.stackTagCompound.getCompoundTag("inputGasTank")));
|
|
outputGasTank.setGas(GasStack.readFromNBT(itemStack.stackTagCompound.getCompoundTag("outputGasTank")));
|
|
}
|
|
|
|
@Override
|
|
public Object[] getTanks()
|
|
{
|
|
return new Object[] {inputFluidTank, inputGasTank, outputGasTank};
|
|
}
|
|
}
|