@Override public ItemStack getResult(ItemStack cast, Fluid fluid) { ItemStack output = new ItemStack(bucket); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(output); assert fluidHandler != null; fluidHandler.fill(getFluid(cast, fluid), true); return fluidHandler.getContainer(); }
/** * Checks if the given stack can store blood */ public static boolean canStoreBlood(@Nonnull ItemStack stack) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(stack); return handler != null && handler.fill(new FluidStack(ModFluids.blood, 1000), false) > 0; }
public static int fill(@Nonnull ItemStack stack, int amount, boolean doFill) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(stack); if (handler != null) { return handler.fill(new FluidStack(ModFluids.blood, amount), doFill); } return 0; }
@Nonnull public static ItemStack getFilledBambucket(@Nonnull FluidStack fluidStack) { Fluid fluid = fluidStack.getFluid(); if (FluidRegistry.getBucketFluids().contains(fluid)){ ItemStack filledBucket = new ItemStack(ModItems.BAMBUCKET); IFluidHandlerItem cap = filledBucket.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); cap.fill(fluidStack, true); return filledBucket; } return ItemStack.EMPTY; }
@Nullable public static ItemStack getContainer(FluidStack fluidStack) { ItemStack[] containers = { new ItemStack(Items.GLASS_BOTTLE), new ItemStack(Items.BUCKET) }; for (ItemStack container : containers) { IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(container); if (fluidHandler != null && fluidHandler.fill(fluidStack, true) > 0) { return fluidHandler.getContainer(); } } return null; } }
protected ItemStack getFluidBucket(FluidStack fluidStack) { ItemStack itemStack = new ItemStack(Items.BUCKET); IFluidHandlerItem fluidHandler = itemStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); fluidHandler.fill(new FluidStack(fluidStack, Fluid.BUCKET_VOLUME), true); return fluidHandler.getContainer(); }
@Override @Nonnull public ItemStack getCraftingResult(@Nonnull InventoryCrafting inv) { ItemStack potionStack = ItemStack.EMPTY; IFluidHandlerItem handler = null; for (int i = 0; i < inv.getSizeInventory(); ++i) { ItemStack stack = inv.getStackInSlot(i); if (!stack.isEmpty()) { if (isPotion(stack)) { potionStack = stack.copy(); } else if (handler == null) { handler = FluidUtil.getFluidHandler(stack.copy()); } } } if (potionStack.isEmpty() || handler == null) { return ItemStack.EMPTY; } FluidStack potionFluid = TFFluids.getPotionFluid(CoreProps.BOTTLE_VOLUME, potionStack); if (handler.fill(potionFluid, false) < CoreProps.BOTTLE_VOLUME) { return ItemStack.EMPTY; } handler.fill(potionFluid, true); return handler.getContainer().copy(); }
@Nullable public static BottlerRecipe createFillingRecipe(Fluid res, ItemStack empty) { ItemStack filled = empty.copy(); filled.setCount(1); IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(filled); if (fluidHandler == null) { return null; } int fillAmount = fluidHandler.fill(new FluidStack(res, Integer.MAX_VALUE), true); if (fillAmount > 0) { return new BottlerRecipe(empty, new FluidStack(res, fillAmount), fluidHandler.getContainer(), true); } return null; }
@Override public void onWornTick(ItemStack stack, EntityLivingBase player) { World world = player.world; if (ServerHelper.isClientWorld(world) || !isActive(stack)) { return; } Iterable<ItemStack> equipment = Iterables.concat(player.getEquipmentAndArmor(), BaublesHelper.getBaubles(player)); for (ItemStack equipmentStack : equipment) { if (equipmentStack.equals(stack) || equipmentStack.getItem() == Items.BUCKET) { continue; } if (FluidHelper.isFluidHandler(equipmentStack)) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(equipmentStack); if (handler != null && getFluid(stack) != null) { drain(stack, handler.fill(new FluidStack(getFluid(stack), Math.min(getFluidAmount(stack), Fluid.BUCKET_VOLUME)), true), true); } } } }
@Override public void onUpdate(ItemStack stack, World world, Entity entity, int slot, boolean isSelected) { if (ServerHelper.isClientWorld(world) || CoreUtils.isFakePlayer(entity) || !isActive(stack)) { return; } Iterable<ItemStack> equipment = Iterables.concat(entity.getEquipmentAndArmor(), BaublesHelper.getBaubles(entity)); for (ItemStack equipmentStack : equipment) { if (equipmentStack.equals(stack) || equipmentStack.getItem() == Items.BUCKET) { continue; } if (FluidHelper.isFluidHandler(equipmentStack)) { IFluidHandlerItem handler = FluidUtil.getFluidHandler(equipmentStack); if (handler != null && getFluid(stack) != null) { drain(stack, handler.fill(new FluidStack(getFluid(stack), Math.min(getFluidAmount(stack), Fluid.BUCKET_VOLUME)), true), true); } } } }
@SideOnly(Side.CLIENT) @Override public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> subItems) { if (this.isInCreativeTab(tab)) { // empty subItems.add(new ItemStack(this)); // filled for (Fluid fluid : FluidRegistry.getRegisteredFluids().values()) { ItemStack itemStack = new ItemStack(this); IFluidHandlerItem fluidHandler = new FluidHandlerItemForestry(itemStack, type); if (fluidHandler.fill(new FluidStack(fluid, Fluid.BUCKET_VOLUME), true) == Fluid.BUCKET_VOLUME) { ItemStack filled = fluidHandler.getContainer(); subItems.add(filled); } } } }
/** * Fill all the Blood Extractors on a player's hotbar for a given fluid amount. * It will fill Blood Extractors until the predefined blood amount is depleted. * (It fills on at a time). * @param player The player to the the Blood Extractors for. * @param minimumMB The minimum amount to fill. (inclusive) * @param maximumMB The maximum amount to fill. (exclusive) */ public void fillForAllBloodExtractors(EntityPlayer player, int minimumMB, int maximumMB) { int toFill = minimumMB + itemRand.nextInt(Math.max(1, maximumMB - minimumMB)); PlayerInventoryIterator it = new PlayerInventoryIterator(player); while(it.hasNext() && toFill > 0) { ItemStack itemStack = it.next(); if(!itemStack.isEmpty() && itemStack.getItem() == BloodExtractor.getInstance()) { IFluidHandlerItem fluidHandler = FluidUtil.getFluidHandler(itemStack); toFill -= fluidHandler.fill(new FluidStack(Blood.getInstance(), toFill), true); it.replace(fluidHandler.getContainer()); } } }
@Override public void getSubItems(@Nullable final CreativeTabs tab, final NonNullList<ItemStack> subItems) { if (!this.isInCreativeTab(tab)) return; subItems.add(empty); for (final Fluid fluid : FluidRegistry.getRegisteredFluids().values()) { // Add all fluids that the bucket can be filled with final FluidStack fs = new FluidStack(fluid, getCapacity()); final ItemStack stack = new ItemStack(this); if (!stack.hasTagCompound()) stack.setTagCompound(new NBTTagCompound()); final IFluidHandlerItem fluidHandler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (fluidHandler != null && fluidHandler.fill(fs, true) == fs.amount) { final ItemStack filled = fluidHandler.getContainer(); subItems.add(filled); } } }
private boolean fillHandler() { IFluidHandlerItem handler = inventory[1].getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); int filled = tank.getFluid() == null ? 0 : handler.fill(new FluidStack(tank.getFluid(), Math.min(tank.getFluidAmount(), Fluid.BUCKET_VOLUME)), true); IFluidTankProperties[] tankProperties = handler.getTankProperties(); if (tankProperties == null || tankProperties.length < 1) { return true; } if (filled > 0) { tank.drain(filled, true); inventory[1] = handler.getContainer(); return tankProperties[0].getContents() != null && tankProperties[0].getContents().amount >= tankProperties[0].getCapacity(); } return true; }
public static @Nonnull FluidAndStackResult tryFillContainer(@Nonnull ItemStack target, @Nullable FluidStack source) { if (target.isEmpty() || source == null || source.getFluid() == null || source.amount <= 0) { return new FluidAndStackResult(ItemStack.EMPTY, null, target, source); } ItemStack filledStack = target.copy(); filledStack.setCount(1); IFluidHandlerItem handler = getFluidHandlerCapability(filledStack); if (handler == null) { return new FluidAndStackResult(ItemStack.EMPTY, null, target, source); } int filledAmount = handler.fill(source.copy(), true); if (filledAmount <= 0 || filledAmount > source.amount) { return new FluidAndStackResult(ItemStack.EMPTY, null, target, source); } filledStack = handler.getContainer(); FluidStack resultFluid = source.copy(); resultFluid.amount = filledAmount; ItemStack remainderStack = target.copy(); remainderStack.shrink(1); FluidStack remainderFluid = source.copy(); remainderFluid.amount -= filledAmount; if (remainderFluid.amount <= 0) { remainderFluid = null; } return new FluidAndStackResult(filledStack, resultFluid, remainderStack, remainderFluid); }
private boolean canStartHandler() { if (!FluidHelper.isFluidHandler(inventory[1])) { hasFluidHandler = false; return false; } if (energyStorage.getEnergyStored() <= 0) { return false; } if (!inventory[2].isEmpty()) { ContainerOverride override = TransposerManager.getContainerOverride(inventory[1]); if (override == null || !inventory[2].isItemEqual(override.getOutput())) { return false; } } IFluidHandlerItem handler = inventory[1].getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (handler == null) { return false; } if (!extractMode) { return tank.getFluid() != null && tank.getFluidAmount() > 0 && handler.fill(new FluidStack(tank.getFluid(), Math.min(tank.getFluidAmount(), Fluid.BUCKET_VOLUME)), false) > 0; } else { return tank.fill(handler.drain(Math.min(tank.getSpace(), Fluid.BUCKET_VOLUME), false), false) > 0; } }
@Override public boolean itemInteractionForEntity(ItemStack stack, EntityPlayer player, EntityLivingBase target, EnumHand hand) { FluidStack fluidStack = getFluid(stack); if(fluidStack != null) return false; ItemStack newStack = new ItemStack(this, 1); if (!newStack.hasTagCompound()) newStack.setTagCompound(new NBTTagCompound()); IFluidHandlerItem cap = newStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (target instanceof EntityCow && !target.isChild()) { cap.fill(new FluidStack(FluidRegistry.getFluid("milk"), Fluid.BUCKET_VOLUME), true); player.playSound(SoundEvents.ENTITY_COW_MILK, 1.0F, 1.0F); if (!player.inventory.addItemStackToInventory(newStack)) player.dropItem(newStack, false); stack.shrink(1); return true; } if (target instanceof EntityBeetle) { cap.fill(new FluidStack(FluidRegistry.getFluid("beetle_juice"), Fluid.BUCKET_VOLUME), true); player.playSound(SoundEvents.ITEM_BUCKET_FILL, 1.0F, 1.0F); if (!player.inventory.addItemStackToInventory(newStack)) player.dropItem(newStack, false); stack.shrink(1); return true; } return false; }
@Override @SideOnly(Side.CLIENT) public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> subItems) { if(tab != GregTechAPI.TAB_GREGTECH && tab != CreativeTabs.SEARCH) return; for (T enabledItem : metaItems.valueCollection()) { if (!enabledItem.isVisible()) continue; ItemStack itemStack = enabledItem.getStackForm(); subItems.add(itemStack.copy()); IElectricItem electricItem = itemStack.getCapability(GregtechCapabilities.CAPABILITY_ELECTRIC_ITEM, null); if (electricItem != null) { electricItem.charge(Long.MAX_VALUE, Integer.MAX_VALUE, true, false); subItems.add(itemStack); } if (tab == CreativeTabs.SEARCH && itemStack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) { for (Fluid fluid : FluidRegistry.getRegisteredFluids().values()) { ItemStack containerStack = itemStack.copy(); IFluidHandlerItem fluidContainer = containerStack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); fluidContainer.fill(new FluidStack(fluid, Integer.MAX_VALUE), true); if (fluidContainer.drain(Integer.MAX_VALUE, false) == null) continue; //do not add empty containers multiple times subItems.add(fluidContainer.getContainer()); } } } }
@Override public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) { TileEntity tileEntity = worldIn.getTileEntity(pos); if (tileEntity == null) createNewTileEntity(worldIn, getMetaFromState(state)); // Is player handling a fluid container? ItemStack stack = playerIn.getHeldItem(hand).copy(); stack.setCount(1); if (stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) { // Gets handler capability from container IFluidHandlerItem bucket = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); if (tileEntity.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, facing)) { FluidTank tank = (FluidTank) tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, facing); int filled = bucket.fill(tank.getFluid(), true); if (filled != 0) { playerIn.getHeldItem(hand).splitStack(1); playerIn.inventory.addItemStackToInventory(bucket.getContainer()); tank.drain(filled, true); return true; } return false; } return false; } playerIn.openGui(FoodCraftReloadedMod.INSTANCE, EnumGui.SMELTING_PRESSURE_COOKER.ordinal(), worldIn, pos.getX(), pos.getY(), pos.getZ()); return true; }