Struct Inventory 

pub struct Inventory<K, S, U>
where
    S: SlotType,
    U: Default,
{
    pub content: Vec<Option<ItemInstance<K, U>>>,
    pub slot_restriction: Vec<Option<S>>,
    pub move_to_front: MoveToFrontMode,
    pub sizing_mode: InventorySizingMode,
}

Generics

• K: Item Type
• S: Type of inventory location
• U: Custom item data

Fields

content: Vec<Option<ItemInstance<K, U>>>

The contents of the Inventory. None values indicate empty but existing inventory slots.

slot_restriction: Vec<Option<S>>

Restricts what kind of item can go in different slots. This is not compatible with InventorySizingMode::Dynamic.

Maps to the inventory content using the index. None values indicate that there are no restrictions for that slot.

move_to_front: MoveToFrontMode

Configures how item deletion is handled.

sizing_mode: InventorySizingMode

Configures if the inventory resizes when item are inserted/removed or not.

Implementations

impl<K, S, U> Inventory<K, S, U>

where S: SlotType, U: Default,

pub fn new( content: Vec<Option<ItemInstance<K, U>>>, slot_restriction: Vec<Option<S>>, move_to_front: MoveToFrontMode, sizing_mode: InventorySizingMode, ) -> Inventory<K, S, U>

Constructs a new Inventory.

impl<K, S, U> Inventory<K, S, U>

where K: PartialEq + Clone + Debug + Hash + Eq, S: SlotType, U: Default + Clone + Debug + PartialEq,

pub fn new_fixed(count: usize) -> Inventory<K, S, U>

Creates a new Inventory with a fixed slot count.

pub fn new_dynamic(minimum: usize, maximum: usize) -> Inventory<K, S, U>

Creates a new dynamically sized Inventory. A minimum of minimum slots are garanteed to be present at all time. The quantity of slots will not go over maximum.

pub fn use_item(&mut self, idx: usize) -> Result<Option<usize>, ItemError<K, U>>

Will attempt to decrease the durability of the item at the specified index. If the item has no durability value (None) or a non zero durability, it will return this value. If the item has a durability of 0 when using it, it will break and ItemError::ItemDestroyed will be returned.

pub fn consume(&mut self, idx: usize) -> Result<usize, ItemError<K, U>>

Decreases the stack size by one and returns the current value. Once the stack size hits zero, it will return ItemError::StackConsumed.

pub fn has_space(&self) -> bool

Looks if there is enough space to add another item stack.

pub fn transfer<U2>( &mut self, from_idx: usize, target: &mut Inventory<K, S, U>, to_idx: usize, quantity: usize, _with_overflow: bool, item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Transfers a specified quantity of item from one slot of this inventory to a specified slot of the provided target inventory. with_overflow indicates if the item can be spread out in free slots in case that the target slot does not have enough free space.

Errors: See Transform::delete and Transform::insert_into.

pub fn transfer_stack<U2>( &mut self, from_idx: usize, target: &mut Inventory<K, S, U>, to_idx: usize, with_overflow: bool, item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Transfers a whole stack from the specified slot into a specified slot of the provided target directory. with_overflow indicates if the item can be spread out in free slots in case that the target slot does not have enough free space.

Errors: See Transform::delete and Transform::insert_into.

pub fn move_item<U2>( &mut self, from_idx: usize, to_idx: usize, quantity: usize, _with_overflow: bool, item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Moves a specified quantity of item from a slot to another. with_overflow indicates if the item can be spread out in free slots in case that the target slot does not have enough free space.

Errors: See Inventory::delete and Inventory::insert_into.

pub fn move_stack<U2>( &mut self, from_idx: usize, to_idx: usize, with_overflow: bool, item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Moves a full stack of item from a slot to another. with_overflow indicates if the item can be spread out in free slots in case that the target slot does not have enough free space.

Errors:

• SlotEmpty: Nothing is present in the specified slot.

pub fn delete( &mut self, idx: usize, quantity: usize, ) -> Result<ItemInstance<K, U>, ItemError<K, U>>

Deletes a specified quantity of item from the specified slot.

Errors:

• NotEnoughQuantity: Not enough items are present in the item stack.
• SlotEmpty: Nothing is present in the specified slot.

pub fn delete_stack( &mut self, idx: usize, ) -> Result<ItemInstance<K, U>, ItemError<K, U>>

Deletes a full stack of item at the provided index and returns it.

Errors: See Transform::delete.

pub fn delete_key( &mut self, key: &K, quantity: usize, ) -> Result<ItemInstance<K, U>, ItemError<K, U>>

Deletes items by matching the key until the deleted quantity reaches the specified quantity.

Errors:

• NotEnoughQuantity: Not enough items with the specified key are present in the inventory.

pub fn has_quantity(&self, key: &K, quantity: usize) -> bool

Checks if the total quantity of items of the specified key are present in the inventory.

pub fn has(&self, key: &K) -> bool

Checks if the inventory contains at least one ItemInstance of the specified key.

pub fn get(&self, idx: usize) -> &Option<ItemInstance<K, U>>

Gets an immutable reference to the ItemInstance at the specified index.

pub fn get_mut(&mut self, idx: usize) -> Option<&mut ItemInstance<K, U>>

Gets a mutable reference to the ItemInstance at the specified index.

pub fn get_key(&self, key: &K) -> impl Iterator<Item = &ItemInstance<K, U>>

Finds the item instances using the specified key. Returns an iterator of immutable references.

pub fn get_key_mut( &mut self, key: &K, ) -> impl Iterator<Item = &mut ItemInstance<K, U>>

Finds the item instances using the specified key. Returns an iterator of mutable references.

pub fn insert_into<U2>( &mut self, idx: usize, item: ItemInstance<K, U>, _item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Inserts the ItemInstance into the specified index.

It will eventually attempt to merge stacks together, but this is not implemented yet.

Errors:

• SlotOccupied: The slot is currently occupied by another item type.

pub fn insert<U2>( &mut self, item: ItemInstance<K, U>, item_defs: &ItemDefinitions<K, S, U2>, ) -> Result<(), ItemError<K, U>>

where U2: Default,

Inserts the ItemInstance at the first available inventory space. If the inventory is dynamically size, it will attempt to create a slot and insert into it.

It will eventually attempt to merge stacks together, but this is not implemented yet.

Errors:

• InventoryFull: The inventory is full and no more space can be created.

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

Returns the first empty slot if any is available.

Trait Implementations

impl<K, S, U> Clone for Inventory<K, S, U>

where K: Clone, S: Clone + SlotType, U: Clone + Default,

fn clone(&self) -> Inventory<K, S, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, S, U> Debug for Inventory<K, S, U>

where K: Debug, S: Debug + SlotType, U: Debug + Default,

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

Formats the value using the given formatter.

impl<'de, K, S, U> Deserialize<'de> for Inventory<K, S, U>

where S: SlotType + Deserialize<'de>, U: Default + Deserialize<'de>, K: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Inventory<K, S, U>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, S, U> Serialize for Inventory<K, S, U>

where S: SlotType + Serialize, U: Default + Serialize, K: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.