Struct valence::prelude::Inventory

pub struct Inventory {
    pub readonly: bool,
    /* private fields */
}

Fields

readonly: bool

Makes an inventory read-only for clients. This will prevent adding or removing items. If this is a player inventory This will also make it impossible to drop items while not in the inventory (e.g. by pressing Q)

Implementations

impl Inventory

pub fn new(kind: InventoryKind) -> Inventory

pub fn with_title<'a, T>(kind: InventoryKind, title: T) -> Inventory

where T: IntoText<'a>,

pub fn slot(&self, idx: u16) -> &ItemStack

pub fn set_slot<I>(&mut self, idx: u16, item: I)

where I: Into<ItemStack>,

Sets the slot at the given index to the given item stack.

See also Inventory::replace_slot.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
assert_eq!(inv.slot(0).item, ItemKind::Diamond);

pub fn replace_slot<I>(&mut self, idx: u16, item: I) -> ItemStack

where I: Into<ItemStack>,

Replaces the slot at the given index with the given item stack, and returns the old stack in that slot.

See also Inventory::set_slot.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
let old = inv.replace_slot(0, ItemStack::new(ItemKind::IronIngot, 1, None));
assert_eq!(old.item, ItemKind::Diamond);

pub fn swap_slot(&mut self, idx_a: u16, idx_b: u16)

Swap the contents of two slots. If the slots are the same, nothing happens.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
assert!(inv.slot(1).is_empty());
inv.swap_slot(0, 1);
assert_eq!(inv.slot(1).item, ItemKind::Diamond);

pub fn set_slot_amount(&mut self, idx: u16, amount: i8)

Set the amount of items in the given slot without replacing the slot entirely. Valid values are 1-127, inclusive, and amount will be clamped to this range. If the slot is empty, nothing happens.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
inv.set_slot_amount(0, 64);
assert_eq!(inv.slot(0).count, 64);

pub fn slot_count(&self) -> u16

pub fn slots( &self, ) -> impl ExactSizeIterator + DoubleEndedIterator + FusedIterator + Clone

pub fn kind(&self) -> InventoryKind

pub fn title(&self) -> &Text

The text displayed on the inventory’s title bar.

let inv = Inventory::with_title(InventoryKind::Generic9x3, "Box of Holding");
assert_eq!(inv.title(), &Text::from("Box of Holding"));

pub fn set_title<'a, T>(&mut self, title: T)

where T: IntoText<'a>,

Set the text displayed on the inventory’s title bar.

To get the old title, use Inventory::replace_title.

let mut inv = Inventory::new(InventoryKind::Generic9x3);
inv.set_title("Box of Holding");

pub fn replace_title<'a, T>(&mut self, title: T) -> Text

where T: IntoText<'a>,

Replace the text displayed on the inventory’s title bar, and returns the old text.

pub fn first_empty_slot_in(&self, range: Range<u16>) -> Option<u16>

Returns the first empty slot in the given range, or None if there are no empty slots in the range.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
inv.set_slot(2, ItemStack::new(ItemKind::GoldIngot, 1, None));
inv.set_slot(3, ItemStack::new(ItemKind::IronIngot, 1, None));
assert_eq!(inv.first_empty_slot_in(0..6), Some(1));
assert_eq!(inv.first_empty_slot_in(2..6), Some(4));

pub fn first_empty_slot(&self) -> Option<u16>

Returns the first empty slot in the inventory, or None if there are no empty slots.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
inv.set_slot(2, ItemStack::new(ItemKind::GoldIngot, 1, None));
inv.set_slot(3, ItemStack::new(ItemKind::IronIngot, 1, None));
assert_eq!(inv.first_empty_slot(), Some(1));

pub fn first_slot_with_item_in( &self, item: ItemKind, stack_max: i8, range: Range<u16>, ) -> Option<u16>

Returns the first slot with the given ItemKind in the inventory where count < stack_max, or None if there are no empty slots.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
inv.set_slot(2, ItemStack::new(ItemKind::GoldIngot, 64, None));
inv.set_slot(3, ItemStack::new(ItemKind::IronIngot, 1, None));
inv.set_slot(4, ItemStack::new(ItemKind::GoldIngot, 1, None));
assert_eq!(
    inv.first_slot_with_item_in(ItemKind::GoldIngot, 64, 0..5),
    Some(4)
);

pub fn first_slot_with_item(&self, item: ItemKind, stack_max: i8) -> Option<u16>

Returns the first slot with the given ItemKind in the inventory where count < stack_max, or None if there are no empty slots.

let mut inv = Inventory::new(InventoryKind::Generic9x1);
inv.set_slot(0, ItemStack::new(ItemKind::Diamond, 1, None));
inv.set_slot(2, ItemStack::new(ItemKind::GoldIngot, 64, None));
inv.set_slot(3, ItemStack::new(ItemKind::IronIngot, 1, None));
inv.set_slot(4, ItemStack::new(ItemKind::GoldIngot, 1, None));
assert_eq!(inv.first_slot_with_item(ItemKind::GoldIngot, 64), Some(4));

Trait Implementations

impl Clone for Inventory

fn clone(&self) -> Inventory

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for Inventory

where Inventory: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_component_hooks(_hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Debug for Inventory

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.