net.minecraftforge.fluids.capability.IFluidTankProperties Java Examples

public static Predicate<ItemStack> getFluidPredicate(Fluid fluid) {
	return new Predicate<ItemStack>() {
		@Override
		public boolean test(ItemStack itemStack) {
			IFluidHandlerItem handler = FluidUtil.getFluidHandler(itemStack);
			if (handler == null) {
				return false;
			}
			for (IFluidTankProperties properties : handler.getTankProperties()) {
				FluidStack stack = properties.getContents();
				if (stack != null && stack.getFluid() == fluid) {
					return true;
				}
			}
			return false;
		}
	};
}
 

public ArrayList<FluidStack> getFluidStacksInInventory(EnumFacing face){
	ArrayList<FluidStack> result = new ArrayList<FluidStack>();
	
	if (!hasInventoryOnSide(face.getIndex())) {
		return result;
	}
	TileEntity te = world.getTileEntity(getPos().offset(face));
	if (!te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, face.getOpposite())) {
		return result;
	}
	IFluidHandler fluidHandler = te.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, face.getOpposite());
	for (IFluidTankProperties tank : fluidHandler.getTankProperties()) {
		if (!(tank.getContents() == null)) {
			result.add(tank.getContents());
		}
	}
	return result;
}
 

public static int moveHandlerFluids(IFluidHandler sourceHandler, IFluidHandler destHandler, int transferLimit, Predicate<FluidStack> fluidFilter) {
    int fluidLeftToTransfer = transferLimit;
    for (IFluidTankProperties tankProperties : sourceHandler.getTankProperties()) {
        FluidStack currentFluid = tankProperties.getContents();
        if (currentFluid == null || currentFluid.amount == 0 || !fluidFilter.test(currentFluid)) continue;
        currentFluid.amount = fluidLeftToTransfer;
        FluidStack fluidStack = sourceHandler.drain(currentFluid, false);
        if (fluidStack == null || fluidStack.amount == 0) continue;
        int canInsertAmount = destHandler.fill(fluidStack, false);
        if (canInsertAmount > 0) {
            fluidStack.amount = canInsertAmount;
            fluidStack = sourceHandler.drain(fluidStack, true);
            if (fluidStack != null && fluidStack.amount > 0) {
                destHandler.fill(fluidStack, true);

                fluidLeftToTransfer -= fluidStack.amount;
                if (fluidLeftToTransfer == 0) break;
            }
        }
    }
    return transferLimit - fluidLeftToTransfer;
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return new IFluidTankProperties[] {
        new FluidTankPropertiesWrapper(fluidTank),
        new FluidTankPropertiesWrapper(gasTank)
    };
}
 

public void cacheCapacity(ItemStack stack)
{
    if (LinkMode.fromStack(stack) == LinkMode.ENABLED)
    {
        ItemStack moduleStack = this.getSelectedModuleStack(stack, ModuleType.TYPE_LINKCRYSTAL);

        if (moduleStack.isEmpty() == false && moduleStack.getTagCompound() != null)
        {
            NBTTagCompound moduleNbt = moduleStack.getTagCompound();
            IFluidHandler handler = this.getLinkedTank(stack);

            if (handler != null)
            {
                IFluidTankProperties[] tank = handler.getTankProperties();

                if (tank != null && tank.length > 0 && tank[0] != null)
                {
                    moduleNbt.setInteger("CapacityCached", tank[0].getCapacity());
                }
                else
                {
                    moduleNbt.setInteger("CapacityCached", 0);
                }
            }
            else
            {
                moduleNbt.removeTag("CapacityCached");
            }

            moduleStack.setTagCompound(moduleNbt);
            this.setSelectedModuleStack(stack, ModuleType.TYPE_LINKCRYSTAL, moduleStack);
        }
    }
}
 

public void collectFluidTankInformation() {
	IFluidHandler fluidTile = GTHelperFluid.getFluidHandler(world, this.targetPos, null);
	if (fluidTile != null) {
		IFluidTankProperties[] props = fluidTile.getTankProperties();
		for (int i = 0; i < props.length; ++i) {
			FluidStack fluid = props[i].getContents();
			if (fluid != null && fluid.amount > 0) {
				addInfoToScreen(fluid.amount + MB);
				addInfoToScreen(fluid.getLocalizedName());
			} else {
				addInfoToScreen(EMPTY_TANK);
			}
		}
	}
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    IFluidHandlerItem nextInChain = getNextInChain();
    IFluidTankProperties[] properties = nextInChain == null ? new IFluidTankProperties[0] : nextInChain.getTankProperties();
    IFluidTankProperties ownProperties = new FluidTankProperties(null, PotionFluids.POTION_ITEM_FLUID_AMOUNT, true, false);
    return ArrayUtils.add(properties, ownProperties);
}
 

@Override
public double getDurabilityForDisplay(ItemStack itemStack) {
    IFluidHandlerItem fluidHandlerItem = itemStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
    IFluidTankProperties fluidTankProperties = fluidHandlerItem.getTankProperties()[0];
    FluidStack fluidStack = fluidTankProperties.getContents();
    return fluidStack == null ? 1.0 : (1.0 - fluidStack.amount / (fluidTankProperties.getCapacity() * 1.0));
}
 

@Override
public int getActualLightValue() {
    IFluidTankProperties properties = getTankProperties();
    if (properties == null) {
        return 0;
    }
    FluidStack fluidStack = properties.getContents();
    if (fluidStack == null) {
        return 0;
    }
    return fluidStack.getFluid().getLuminosity(fluidStack);
}
 

@Override
public int getActualComparatorValue() {
    IFluidTankProperties properties = getTankProperties();
    if (properties == null) {
        return 0;
    }
    FluidStack fluidStack = properties.getContents();
    int fluidAmount = fluidStack == null ? 0 : fluidStack.amount;
    int maxCapacity = properties.getCapacity();
    float f = fluidAmount / (maxCapacity * 1.0f);
    return MathHelper.floor(f * 14.0f) + (fluidAmount > 0 ? 1 : 0);
}
 

@Override
@SideOnly(Side.CLIENT)
public void addInformation(ItemStack itemStack, @Nullable World worldIn, List<String> lines, ITooltipFlag tooltipFlag) {
    T item = getItem(itemStack);
    if (item == null) return;
    String unlocalizedTooltip = "metaitem." + item.unlocalizedName + ".tooltip";
    if (I18n.hasKey(unlocalizedTooltip)) {
        lines.addAll(Arrays.asList(I18n.format(unlocalizedTooltip).split("/n")));
    }

    IElectricItem electricItem = itemStack.getCapability(GregtechCapabilities.CAPABILITY_ELECTRIC_ITEM, null);
    if (electricItem != null) {
        lines.add(I18n.format("metaitem.generic.electric_item.tooltip",
            electricItem.getCharge(),
            electricItem.getMaxCharge(),
            GTValues.VN[electricItem.getTier()]));
    }

    IFluidHandlerItem fluidHandler = ItemHandlerHelper.copyStackWithSize(itemStack, 1)
        .getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
    if (fluidHandler != null) {
        IFluidTankProperties fluidTankProperties = fluidHandler.getTankProperties()[0];
        FluidStack fluid = fluidTankProperties.getContents();
        if (fluid != null) {
            lines.add(I18n.format("metaitem.generic.fluid_container.tooltip",
                fluid.amount,
                fluidTankProperties.getCapacity(),
                fluid.getLocalizedName()));
        } else lines.add(I18n.format("metaitem.generic.fluid_container.tooltip_empty"));
    }

    for (IItemBehaviour behaviour : getBehaviours(itemStack)) {
        behaviour.addInformation(itemStack, lines);
    }
}
 

public static String getFluidContainerSubType(ItemStack itemStack) {
    IFluidHandlerItem fluidHandler = itemStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
    if (fluidHandler != null) {
        IFluidTankProperties fluidTankProperties = fluidHandler.getTankProperties()[0];
        FluidStack fluid = fluidTankProperties.getContents();
        return String.format("f=%s", fluid == null ? "empty" : fluid.getFluid().getName());
    }
    return "";
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    if (fluidTankProperties == null) {
        ArrayList<IFluidTankProperties> propertiesList = new ArrayList<>();
        for (IFluidTank fluidTank : fluidTanks) {
            if (fluidTank instanceof IFluidHandler) {
                IFluidHandler fluidHandler = (IFluidHandler) fluidTank;
                propertiesList.addAll(Arrays.asList(fluidHandler.getTankProperties()));
            }
        }
        this.fluidTankProperties = propertiesList.toArray(new IFluidTankProperties[0]);
    }
    return fluidTankProperties;
}
 

public FluidHandlerProxy(IFluidHandler input, IFluidHandler output) {
    this.input = input;
    this.output = output;

    List<IFluidTankProperties> tanks = Lists.newArrayList();
    Collections.addAll(tanks, input.getTankProperties());
    Collections.addAll(tanks, output.getTankProperties());
    this.properties = tanks.toArray(new IFluidTankProperties[0]);
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return new IFluidTankProperties[] {
        new FluidTankPropertiesWrapper(inputTank),
        new FluidTankPropertiesWrapper(outputTank)
    };
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
	if (!canInteract(side)) return EMPTY;
	return tank.getTankProperties();
}
 

private IFluidTankProperties getTankProperties() {
    IFluidTankProperties[] properties = fluidInventory.getTankProperties();
    return properties.length == 0 ? null : properties[0];
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
	return new IFluidTankProperties[] { properties };
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
	return tank.getTankProperties();
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return this.nigariTank.getTankProperties();
}
 

@Override
public IFluidTankProperties[] getTankProperties()
{
    return new FluidTankProperties[] { new FluidTankProperties(this.getFluid(), this.getCapacity()) };
}
 

public int getCapacity(ItemStack stack, @Nullable EntityPlayer player)
{
    if (LinkMode.fromStack(stack) == LinkMode.DISABLED)
    {
        return Configs.enderBucketCapacity;
    }

    // Linked to a tank

    if (OwnerData.canAccessSelectedModule(stack, ModuleType.TYPE_LINKCRYSTAL, player) == false)
    {
        return 0;
    }

    TargetData targetData = this.getLinkedTankTargetData(stack);
    IFluidHandler handler = this.getLinkedTank(stack);

    if (targetData != null && handler != null)
    {
        IFluidTankProperties[] tank = handler.getTankProperties();

        // If we have tank info, it is the easiest and simplest way to get the tank capacity
        if (tank != null && tank.length > 0 && tank[0] != null)
        {
            return tank[0].getCapacity();
        }

        // No tank info available, get the capacity via simulating filling

        FluidStack fluidStack = handler.drain(Integer.MAX_VALUE, false);

        // Tank has fluid
        if (fluidStack != null)
        {
            FluidStack fs = fluidStack.copy();
            fs.amount = Integer.MAX_VALUE;

            // Filled amount plus existing amount
            return handler.fill(fs, false) + fluidStack.amount;
        }
        // Tank has no fluid
        else
        {
            // Since we have no fluid stored, get the capacity via simulating filling water into the tank
            return handler.fill(new FluidStack(FluidRegistry.WATER, Integer.MAX_VALUE), false);
        }
    }

    return 0;
}
 

public int getCapacityAvailable(ItemStack stack, FluidStack fluidStackIn, EntityPlayer player)
{
    FluidStack existingFluidStack;

    // Linked to a tank
    if (LinkMode.fromStack(stack) == LinkMode.ENABLED)
    {
        IFluidHandler handler = this.getLinkedTank(stack);

        if (handler != null)
        {
            IFluidTankProperties[] tank = handler.getTankProperties();

            if (tank == null || tank.length < 1 || tank[0] == null)
            {
                return 0;
            }

            existingFluidStack = tank[0].getContents();

            if (fluidStackIn == null)
            {
                return tank[0].getCapacity() - (existingFluidStack != null ? existingFluidStack.amount : 0);
            }
            else
            {
                fluidStackIn = fluidStackIn.copy();
                fluidStackIn.amount = Integer.MAX_VALUE;

                return handler.fill(fluidStackIn, false);
            }
        }

        return 0;
    }

    // Not linked to a tank, get the bucket's internal free capacity
    existingFluidStack = this.getFluid(stack, player);

    if (existingFluidStack != null)
    {
        return this.getCapacity(stack, player) - existingFluidStack.amount;
    }

    return this.getCapacity(stack, player);
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return new IFluidTankProperties[]{};
}
 

@Override
public IFluidTankProperties[] getTankProperties(World world, BlockPos pos, IBlockState state) {
    return new IFluidTankProperties[]{};
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return block.getTankProperties(world, pos, world.getBlockState(pos));
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return properties;
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    return delegate.getTankProperties();
}
 

@Override
public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException {
    if (sender instanceof EntityPlayerMP) {
        EntityPlayerMP player = (EntityPlayerMP) sender;
        ItemStack stackInHand = player.inventory.getCurrentItem();
        if (stackInHand.isEmpty()) {
            throw new CommandException("gregtech.command.util.hand.no_item");
        }
        String registryName = stackInHand.getItem().getRegistryName().toString();
        ClickEvent itemNameEvent = new ClickEvent(Action.OPEN_URL, registryName);
        player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.item_id", registryName, stackInHand.getItemDamage())
            .setStyle(new Style().setClickEvent(itemNameEvent)));

        IElectricItem electricItem = stackInHand.getCapability(GregtechCapabilities.CAPABILITY_ELECTRIC_ITEM, null);
        IFluidHandlerItem fluidHandlerItem = stackInHand.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
        if (electricItem != null) {
            player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.electric",
                electricItem.getCharge(),
                electricItem.getMaxCharge(),
                electricItem.getTier(),
                Boolean.toString(electricItem.canProvideChargeExternally())));
        }

        if (fluidHandlerItem != null) {
            for (IFluidTankProperties properties : fluidHandlerItem.getTankProperties()) {
                FluidStack contents = properties.getContents();
                String fluidName = contents == null ? "empty" : contents.getFluid().getName();
                ClickEvent fluidClickEvent = new ClickEvent(Action.OPEN_URL, fluidName);
                player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.fluid",
                    fluidName,
                    contents == null ? 0 : contents.amount,
                    properties.getCapacity(),
                    Boolean.toString(properties.canFill()), Boolean.toString(properties.canDrain()))
                .setStyle(new Style().setClickEvent(fluidClickEvent)));
            }
        }

        if (stackInHand.getItem() instanceof MetaItem) {
            MetaItem<?> metaItem = (MetaItem<?>) stackInHand.getItem();
            MetaValueItem metaValueItem = metaItem.getItem(stackInHand);
            if (metaValueItem == null) {
                if (metaItem instanceof MaterialMetaItem) {
                    Material material = ((MaterialMetaItem) metaItem).getMaterial(stackInHand);
                    OrePrefix orePrefix = ((MaterialMetaItem) metaItem).getOrePrefix(stackInHand);
                    String oreDictName = new UnificationEntry(orePrefix, material).toString();
                    player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.material_meta_item", orePrefix, material)
                        .setStyle(new Style().setClickEvent(new ClickEvent(Action.OPEN_URL, oreDictName))));
                }
            } else {
                if (metaValueItem instanceof ToolMetaItem.MetaToolValueItem) {
                    IToolStats toolStats = ((MetaToolValueItem) metaValueItem).getToolStats();
                    player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.tool_stats", toolStats.getClass().getName()));
                }
                ClickEvent metaItemEvent = new ClickEvent(Action.OPEN_URL, metaValueItem.unlocalizedName);
                player.sendMessage(new TextComponentTranslation("gregtech.command.util.hand.meta_item", metaValueItem.unlocalizedName, metaValueItem)
                    .setStyle(new Style().setClickEvent(metaItemEvent)));
            }
        }
    } else {
        throw new CommandException("gregtech.command.util.hand.not_a_player");
    }
}
 

@Override
public IFluidTankProperties[] getTankProperties() {
    FluidTank fluidTank = getNetFluidTank();
    return fluidTank == null ? new IFluidTankProperties[0] : fluidTank.getTankProperties();
}