Struct Item 

pub struct Item {
    pub id: u32,
    pub position: Vec3<f32>,
    pub creator_id: Uuid,
    pub item_type: String,
    pub max_capacity: u32,
    pub container: Option<Vec<Item>>,
    pub attributes: ValueContainer,
    pub dirty_flags: u8,
    pub dirty_attributes: FxHashSet<String>,
}

Fields

id: u32

The unique ID of the item

position: Vec3<f32>

The position in the map (if not on an entity).

creator_id: Uuid

Maps the item to a creator ID

item_type: String

The item’s type or identifier (e.g., “Potion”, “Sword”)

max_capacity: u32

Maximum capacity of this container/stack (e.g., max stack size for stackable items)

container: Option<Vec<Item>>

Container: Holds nested items if this item can act as a container

attributes: ValueContainer

Attributes: Dynamic properties of the item

dirty_flags: u8

Dirty flags for static attributes

dirty_attributes: FxHashSet<String>

Dirty dynamic attributes

Implementations

impl Item

pub fn new() -> Self

pub fn get_pos_xz(&self) -> Vec2<f32>

Get the XZ position.

pub fn set_position(&mut self, new_position: Vec3<f32>)

Set the position and mark it as dirty

pub fn set_max_capacity(&mut self, new_max_capacity: u32)

Set the position and mark it as dirty

pub fn is_container(&self) -> bool

Check if the item is a container or stackable

pub fn has_space(&self) -> bool

Check if there’s space in the container

pub fn add_to_container(&mut self, item: Item) -> Result<(), String>

Add an item to the container

pub fn remove_from_container(&mut self, item_id: u32) -> Result<Item, String>

Remove an item from the container by ID

pub fn set_attribute(&mut self, key: &str, value: Value)

Set a dynamic attribute and mark it as dirty

pub fn get_attribute(&self, key: &str) -> Option<&Value>

Get a dynamic attribute

pub fn get_attr_string(&self, key: &str) -> Option<String>

Get the given String

pub fn get_attr_uuid(&self, key: &str) -> Option<Uuid>

Get the given Uuid

pub fn mark_dirty_attribute(&mut self, key: &str)

Mark a dynamic attribute as dirty

pub fn mark_all_dirty(&mut self)

Mark all fields and attributes as dirty

pub fn clear_dirty(&mut self)

Clear all dirty flags and attributes

pub fn is_dirty(&self) -> bool

Check if the item is dirty

pub fn get_update(&self) -> ItemUpdate

Generate an ItemUpdate containing only dirty fields and attributes

pub fn apply_update(&mut self, update: ItemUpdate)

Apply an ItemUpdate to this item

Trait Implementations

impl Clone for Item

fn clone(&self) -> Item

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Item

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

Formats the value using the given formatter.

impl Default for Item

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Item

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Item

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

where __S: Serializer,

Serialize this value into the given Serde serializer.