Struct SavedItem 

pub struct SavedItem {

    pub template_resref: ResRef,
    pub body_variation: Option<u8>,
    pub texture_var: Option<u8>,
    pub infinite: Option<bool>,
    pub slot_id: i32,
    pub common: GitObjectPlacement,
    pub add_cost: u32,
    pub base_item: i32,
    pub charges: u8,
    pub cost: u32,
    pub deleting: bool,
    pub description_identified: GffLocalizedString,
    pub description: GffLocalizedString,
    pub droppable: bool,
    pub identified: bool,
    pub localized_name: GffLocalizedString,
    pub max_charges: u8,
    pub model_variation: u8,
    pub new_item: bool,
    pub non_equippable: bool,
    pub pickpocketable: bool,
    pub plot: bool,
    pub properties: Vec<GitItemProperty>,
    pub stack_size: u16,
    pub stolen: bool,
    pub tag: String,
    pub upgrades: u32,
}

One item as stored in a save.

Fields

template_resref: ResRef

Blueprint this item came from (TemplateResRef).

On the saved type rather than the templated arm alone, because the three nested item lists reach this type directly and the baseline carries the label at all four paths.

Written only where it holds something: no saved entry in the corpus carries the label, so emitting a blank would put a field on every one that never had it.

body_variation: Option<u8>

Body variation (BodyVariation), absent on most entries.

texture_var: Option<u8>

Texture variation (TextureVar), absent on most entries.

infinite: Option<bool>

Whether the stack never depletes (Infinite), absent on most entries.

slot_id: i32

Equipment slot, when the list this came out of keys by slot.

The element’s own struct id rather than a label, and no field in the file repeats it. Only Equip_ItemList reads it as data; the five other lists carrying this type key by a constant or by position, and leave it zero. Carried here because a writer that cannot reproduce it moves every equipped item to slot zero.

common: GitObjectPlacement

The block both forms carry, which the list declares as its element.

No #[gff]: the arm contributes its parts to the split, and the element is this block, so declaring it here too would make one label two declarations. The arm’s own codec reads and writes it.

add_cost: u32

Additional cost (AddCost).

base_item: i32

Base item row (BaseItem).

charges: u8

Remaining charges (Charges).

cost: u32

Base cost (Cost).

deleting: bool

Pending-deletion flag (DELETING).

description_identified: GffLocalizedString

Identified description (DescIdentified).

description: GffLocalizedString

Unidentified description (Description).

droppable: bool

Droppable flag (Dropable).

identified: bool

Identified flag (Identified).

localized_name: GffLocalizedString

Localized name (LocalizedName).

max_charges: u8

Maximum charges (MaxCharges).

model_variation: u8

Model variation (ModelVariation).

new_item: bool

Newly-acquired flag (NewItem).

non_equippable: bool

Non-equippable flag (NonEquippable).

pickpocketable: bool

Pickpocketable flag (Pickpocketable).

plot: bool

Plot-item flag (Plot).

properties: Vec<GitItemProperty>

Item properties (PropertiesList). The element shape matches a blueprint’s field for field, so this reuses UtiProperty and its conversions rather than re-deriving the same reads. Element ids are the index here, unlike a blueprint .uti’s own properties list, which writes zero throughout. Which list owns it decides, not the element type.

stack_size: u16

Stack size (StackSize).

stolen: bool

Stolen flag (Stolen).

tag: String

Object tag (Tag).

upgrades: u32

Upgrade bitfield (Upgrades).

Implementations

impl SavedItem

pub const SCHEMA: [Field; 25]

This view’s schema, one entry per declared field.

pub const PARTS: &'static [&'static [Field]]

This type’s schema in parts, which is what a container holding it references.

Own fields first, then one part per flattened child in the order they are declared.

pub fn read_declared(root: &GffStruct) -> Self

Reads every declared field off root.

Absent fields take the entry’s own answer, so a fallback is derived from the declaration rather than restated beside it.

A field declaring a hand-written read is left at that answer for the view to overwrite.

pub fn write_declared(&self, root: &mut GffStruct)

Writes every declared field onto root, leaving out the ones their entry says the engine’s own writer leaves out.

A field declaring a hand-written write is not touched here.

impl SavedItem

pub fn read_element(structure: &GffStruct) -> Self

Reads one element, with the block the list declares as its element.

pub fn write_element(&self, structure: &mut GffStruct)

Writes one element, the common block included.

Trait Implementations

impl Clone for SavedItem

fn clone(&self) -> SavedItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SavedItem

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

Formats the value using the given formatter.

impl Default for SavedItem

fn default() -> Self

What a file omitting every label loads to, which is what makes an authored file land in a known state rather than at zero.

impl GitElement for SavedItem

fn read(structure: &GffStruct) -> Self

Reads one element.

fn write(&self, id: i32) -> GffStruct

Writes one element into a struct carrying the list’s own id.

impl HasSchema for SavedItem

fn schema() -> &'static [Field]

The root field schema for this resource type.

fn parts() -> &'static [&'static [Field]]

The same schema in parts, own fields first.

impl PartialEq for SavedItem

fn eq(&self, other: &SavedItem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SavedItem