public static Collection<ItemStack> getContainersFilledWith(FluidStack fluidStack) {
List<ItemStack> containers = new ArrayList<ItemStack>();
for (FluidContainerData data : FluidContainerRegistry.getRegisteredFluidContainerData()) {
FluidStack inContainer = FluidItemHelper.getFluidStackInContainer(data.filledContainer);
if (inContainer != null && inContainer.containsFluid(fluidStack))
containers.add(data.filledContainer.copy());
}
return containers;
}
private void normalOperation(byte type) {
int amount = tank[1].getCapacity() - tank[1].getFluidAmount();
if (amount > FluidContainerRegistry.BUCKET_VOLUME / 10)
amount = FluidContainerRegistry.BUCKET_VOLUME / 10;
if (amount > 0) {
FluidStack fluidStack;
FluidStack activeLava;
int activeValue;
if (tank[0].getFluid().getFluid() == ModFluids.ActiveLava) {
fluidStack = tank[0].drain(amount, true);
activeLava = new FluidStack(ModFluids.ActiveLava, fluidStack.amount);
activeValue = ((ActiveLava) activeLava.getFluid()).getActiveValue(fluidStack);
} else {
activeValue = tank[0].getFluid().getFluid().getTemperature();
fluidStack = tank[0].drain(amount * 2, true);
activeLava = new FluidStack(ModFluids.ActiveLava, fluidStack.amount / 2);
}
ActiveLava fluid = (ActiveLava) tank[1].getFluid().getFluid();
// activeValue += fluid.getActiveValue(tank[1].getFluid());
activeValue += type * 6;
activeValue = Math.abs(activeValue);
((ActiveLava) activeLava.getFluid()).setActiveValue(activeLava, activeValue);
tank[1].fill(activeLava, true);
if (Math.random() < 0.42) {
fluid.increaseActiveValue(tank[1].getFluid());
if (Math.random() < 0.16) decrStackSize(1, 1);
}
} else {
ActiveLava fluid = (ActiveLava) tank[1].getFluid().getFluid();
int activeValue = fluid.getActiveValue(tank[1].getFluid());
activeValue += type * 2;
fluid.setActiveValue(tank[1].getFluid(), activeValue);
if (Math.random() < 0.22) decrStackSize(1, 1);
if (Math.random() < 0.27) heatOperation(type);
}
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
if (hasValidMaster() && canDrain(from, resource.getFluid())) {
SmelteryLogic smeltery =
(SmelteryLogic)
worldObj.getTileEntity(
getMasterPosition().x, getMasterPosition().y, getMasterPosition().z);
if (resource.getFluid() == smeltery.getFluid().getFluid()) {
return smeltery.drain(resource.amount, doDrain);
}
}
return null;
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
if (from == ForgeDirection.UP && resource.getFluid().canBePlacedInWorld()) {
return fluidTank.fill(resource, true);
}
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
if (fluidTank.getFluid() != null
&& fluidTank.getFluid().getFluid() == resource.getFluid()
&& from == ForgeDirection.UP) {
return drain(from, resource.amount, doDrain);
}
return null;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
if ((from == ForgeDirection.UNKNOWN) || (this.sideCache[from.ordinal()] != 2)) {
return null;
}
if ((resource == null) || (!resource.isFluidEqual(this.tank.getFluid()))) {
return null;
}
return this.tank.drain(resource.amount, doDrain);
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
if (worldObj.isRemote) return 0;
if (resource == null) // What!?
return 0;
if (resource.getFluid() == null) return 0;
if (resource.getFluid().getID() != FluidRegistry.LAVA.getID()) {
return 0;
}
if (tank != null && tank.getFluid() != null && tank.getFluidAmount() > 0) {
if (resource.getFluid().getID() != tank.getFluid().getFluid().getID()) {
return 0;
}
} else if (tank == null) {
setTier(getTier());
}
return tank.fill(resource, doFill);
}
/* IFluidBlock */
@Override
public FluidStack drain(World world, int x, int y, int z, boolean doDrain) {
if (!isSourceBlock(world, x, y, z)) {
return null;
}
if (doDrain) {
world.setBlockToAir(x, y, z);
}
return stack.copy();
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
if (hasValidMaster() && resource != null && canFill(from, resource.getFluid())) {
SmelteryLogic smeltery =
(SmelteryLogic)
worldObj.getTileEntity(
getMasterPosition().x, getMasterPosition().y, getMasterPosition().z);
return smeltery.fill(resource, doFill);
} else {
return 0;
}
}
private void outputActiveLava() {
FluidStack fluid = tank[1].getFluid();
if (fluid != null) {
if (itemStacks[2] != null && itemStacks[2].stackSize == 1) {
ItemStack itemStack = itemStacks[2];
if (FluidContainerRegistry.isEmptyContainer(itemStack)) {
if (fluid.amount >= FluidContainerRegistry.BUCKET_VOLUME) {
FluidStack oneBucketOfFluid =
new FluidStack(fluid, FluidContainerRegistry.BUCKET_VOLUME);
ItemStack filledBucket =
FluidContainerRegistry.fillFluidContainer(
oneBucketOfFluid, FluidContainerRegistry.EMPTY_BUCKET);
itemStacks[2] = filledBucket;
fluid.amount -= FluidContainerRegistry.BUCKET_VOLUME;
}
} else if (itemStack.getItem() instanceof IFluidContainerItem && (workingTick % 20) == 10) {
if (fluid.amount >= FluidContainerRegistry.BUCKET_VOLUME) {
IFluidContainerItem fluidContainerItem = (IFluidContainerItem) itemStack.getItem();
FluidStack fluidStack = fluid.copy();
if (fluidStack.amount > FluidContainerRegistry.BUCKET_VOLUME)
fluidStack.amount = FluidContainerRegistry.BUCKET_VOLUME;
int amount = fluidContainerItem.fill(itemStack, fluidStack, true);
if (amount > 0) {
fluid.amount -= amount;
}
if (fluid.amount == 0) tank[1].setFluid(null);
}
}
}
}
}
private void initOperation(byte type) {
if (tank[0].getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) {
FluidStack fluidStacks = tank[0].drain(FluidContainerRegistry.BUCKET_VOLUME, true);
FluidStack activeLava;
int activeValue = 0;
if (fluidStacks.getFluid() == ModFluids.ActiveLava) {
activeLava = new FluidStack(ModFluids.ActiveLava, FluidContainerRegistry.BUCKET_VOLUME / 5);
activeValue = ((ActiveLava) fluidStacks.getFluid()).getActiveValue(fluidStacks);
} else
activeLava =
new FluidStack(ModFluids.ActiveLava, FluidContainerRegistry.BUCKET_VOLUME / 10);
activeValue += type * 3;
((ActiveLava) activeLava.getFluid()).setActiveValue(activeLava, activeValue);
tank[1].fill(activeLava, true);
decrStackSize(1, 1);
}
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid) {
// Check that the drain is coming from the from the front of the block
// and that the fluid to be drained is in the smeltery.
if (!hasValidMaster()) return false;
boolean containsFluid = fluid == null;
if (fluid != null) {
SmelteryLogic smeltery =
(SmelteryLogic)
worldObj.getTileEntity(
getMasterPosition().x, getMasterPosition().y, getMasterPosition().z);
for (FluidStack fstack : smeltery.moltenMetal) {
if (fstack.getFluidID() == fluid.getID()) {
containsFluid = true;
break;
}
}
}
// return from == getForgeDirection().getOpposite() && containsFluid;
return containsFluid;
}
private void inputLava() {
if (itemStacks[0] != null) {
Item item = itemStacks[0].getItem();
if (item != null) {
if (item == Items.lava_bucket || item == ModItems.itemActiveLavaBucket) {
if (tank[0].getCapacity() - tank[0].getFluidAmount()
>= FluidContainerRegistry.BUCKET_VOLUME) {
FluidStack fluidStack = FluidContainerRegistry.getFluidForFilledItem(itemStacks[0]);
int result = tank[0].fill(fluidStack, false);
if (result == FluidContainerRegistry.BUCKET_VOLUME) {
itemStacks[0] = new ItemStack(Items.bucket, 1);
tank[0].fill(fluidStack, true);
}
}
} else if (item instanceof IFluidContainerItem && (workingTick % 20) == 5) {
IFluidContainerItem fluidContainerItem = (IFluidContainerItem) item;
FluidStack fluidStack = fluidContainerItem.getFluid(itemStacks[0]);
if (fluidStack != null) {
fluidStack = fluidStack.copy();
if (fluidStack.amount > FluidContainerRegistry.BUCKET_VOLUME)
fluidStack.amount = FluidContainerRegistry.BUCKET_VOLUME;
int result = tank[0].fill(fluidStack, true);
if (result > 0) {
fluidContainerItem.drain(itemStacks[0], result, true);
}
}
}
}
}
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
if (resource.getFluid().getName().equalsIgnoreCase("steam"))
return _steamTank.fill(resource, doFill);
return 0;
}
@Override
public void onUpdate() {
if (!worldObj.isRemote) {
ChargeUtils.discharge(2, this);
if (inventory[0] != null) {
if (inventory[0].getItem() instanceof IFluidContainerItem
&& ((IFluidContainerItem) inventory[0].getItem()).getFluid(inventory[0]) != null) {
if (((IFluidContainerItem) inventory[0].getItem())
.getFluid(inventory[0])
.getFluid()
.canBePlacedInWorld()) {
fluidTank.fill(FluidContainerUtils.extractFluid(fluidTank, inventory[0]), true);
if (((IFluidContainerItem) inventory[0].getItem()).getFluid(inventory[0]) == null
|| fluidTank.getFluidAmount() == fluidTank.getCapacity()) {
if (inventory[1] == null) {
inventory[1] = inventory[0].copy();
inventory[0] = null;
markDirty();
}
}
}
} else if (FluidContainerRegistry.isFilledContainer(inventory[0])) {
FluidStack itemFluid = FluidContainerRegistry.getFluidForFilledItem(inventory[0]);
if ((fluidTank.getFluid() == null && itemFluid.amount <= fluidTank.getCapacity())
|| fluidTank.getFluid().amount + itemFluid.amount <= fluidTank.getCapacity()) {
if ((fluidTank.getFluid() != null && !fluidTank.getFluid().isFluidEqual(itemFluid))
|| !itemFluid.getFluid().canBePlacedInWorld()) {
return;
}
ItemStack containerItem = inventory[0].getItem().getContainerItem(inventory[0]);
boolean filled = false;
if (containerItem != null) {
if (inventory[1] == null
|| (inventory[1].isItemEqual(containerItem)
&& inventory[1].stackSize + 1 <= containerItem.getMaxStackSize())) {
inventory[0] = null;
if (inventory[1] == null) {
inventory[1] = containerItem;
} else {
inventory[1].stackSize++;
}
filled = true;
}
} else {
inventory[0].stackSize--;
if (inventory[0].stackSize == 0) {
inventory[0] = null;
}
filled = true;
}
if (filled) {
fluidTank.fill(itemFluid, true);
markDirty();
}
}
}
}
if (getEnergy() >= usage.fluidicPlenisherUsage
&& worldObj.getWorldTime() % 10 == 0
&& fluidTank.getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) {
if (fluidTank.getFluid().getFluid().canBePlacedInWorld()) {
if (!finishedCalc) {
doPlenish();
} else {
Coord4D below = Coord4D.get(this).getFromSide(ForgeDirection.DOWN);
if (canReplace(below, false, false)
&& getEnergy() >= usage.fluidicPlenisherUsage
&& fluidTank.getFluidAmount() >= FluidContainerRegistry.BUCKET_VOLUME) {
if (fluidTank.getFluid().getFluid().canBePlacedInWorld()) {
worldObj.setBlock(
below.xCoord,
below.yCoord,
below.zCoord,
MekanismUtils.getFlowingBlock(fluidTank.getFluid().getFluid()),
0,
3);
setEnergy(getEnergy() - usage.fluidicPlenisherUsage);
fluidTank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
}
}
}
}
}
}
}
public static int getFluidId(FluidStack stack) {
if (stack == null) return -1;
if (stack.getFluid() == null) return -1;
return FluidRegistry.getFluidID(stack.getFluid().getName());
}
@Override
protected void drawGuiContainerBackgroundLayer(float f, int mouseX, int mouseY) {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.getTextureManager().bindTexture(background);
int cornerX = (width - xSize) / 2 + 36;
int cornerY = (height - ySize) / 2;
drawTexturedModalRect(cornerX + 46, cornerY, 0, 0, 176, ySize);
// Fuel - Lava
this.mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
if (scomp.fuelGague > 0) {
Icon lavaIcon = Block.lavaStill.getIcon(0, 0);
int fuel = scomp.getScaledFuelGague(52);
int count = 0;
while (fuel > 0) {
int size = fuel >= 16 ? 16 : fuel;
fuel -= size;
drawLiquidRect(cornerX + 117, (cornerY + 68) - size - 16 * count, lavaIcon, 12, size);
count++;
}
}
FluidTankInfo[] info = logic.getTankInfo(ForgeDirection.UNKNOWN);
int capacity = 0;
for (int i = 0; i < info.length - 1; i++) {
FluidStack liquid = info[i].fluid;
if (liquid != null) capacity += info[i].capacity;
}
// Liquids - molten metal
int base = 0;
for (int i = 0; i < info.length - 1; i++) {
FluidStack liquid = info[i].fluid;
Icon renderIndex = liquid.getFluid().getStillIcon();
int basePos = 54;
if (capacity > 0) {
int liquidSize = liquid.amount * 52 / capacity;
if (liquidSize == 0) liquidSize = 1;
while (liquidSize > 0) {
int size = liquidSize >= 16 ? 16 : liquidSize;
drawLiquidRect(cornerX + basePos, (cornerY + 68) - size - base, renderIndex, 16, size);
drawLiquidRect(
cornerX + basePos + 16, (cornerY + 68) - size - base, renderIndex, 16, size);
drawLiquidRect(
cornerX + basePos + 32, (cornerY + 68) - size - base, renderIndex, 16, size);
drawLiquidRect(
cornerX + basePos + 48, (cornerY + 68) - size - base, renderIndex, 4, size);
liquidSize -= size;
base += size;
}
}
}
// Liquid gague
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.getTextureManager().bindTexture(background);
drawTexturedModalRect(cornerX + 54, cornerY + 16, 176, 76, 52, 52);
// Side inventory
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.getTextureManager().bindTexture(backgroundSide);
// if (logic.layers > 0)
{
/*if (logic.layers == 1)
{
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, 43);
drawTexturedModalRect(cornerX - 46, cornerY + 43, 0, 133, 98, 25);
}
else if (logic.layers == 2)
{
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, 61);
drawTexturedModalRect(cornerX - 46, cornerY + 61, 0, 97, 98, 61);
}
else*/
{
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, ySize - 8);
}
drawTexturedModalRect(cornerX + 32, (int) (cornerY + 8 + 127 * currentScroll), 98, 0, 12, 15);
}
// Temperature
int slotSize = logic.getSizeInventory();
if (slotSize > 24) slotSize = 24;
for (int iter = 0; iter < slotSize; iter++) {
int slotTemp = logic.getTempForSlot(iter + slotPos * 3) - 20;
int maxTemp = logic.getMeltingPointForSlot(iter + slotPos * 3) - 20;
if (slotTemp > 0 && maxTemp > 0) {
int size = 16 * slotTemp / maxTemp + 1;
drawTexturedModalRect(
cornerX - 38 + (iter % 3 * 22),
cornerY + 8 + (iter / 3 * 18) + 16 - size,
98,
15 + 16 - size,
5,
size);
}
}
}
