Struct UtiProperty 

pub struct UtiProperty {
    pub cost_table: u8,
    pub cost_value: u16,
    pub param1: u8,
    pub param1_value: u8,
    pub property_name: u16,
    pub subtype: u16,
    pub chance_appear: u8,
    pub useable: Option<bool>,
    pub uses_per_day: u8,
    pub upgrade_type: Option<u8>,
}

One entry of an item’s PropertiesList.

Fields

cost_table: u8

Cost table index (CostTable).

cost_value: u16

Cost table value (CostValue).

param1: u8

Parameter table index (Param1).

param1_value: u8

Parameter value (Param1Value).

property_name: u16

Property identifier (PropertyName).

subtype: u16

Property subtype (Subtype).

chance_appear: u8

Chance the property appears (ChanceAppear).

useable: Option<bool>

Usable flag (Useable), when the entry carries one.

uses_per_day: u8

Uses per day (UsesPerDay).

No vanilla .uti carries this label on any property entry, across all 993 of them, so the omission stands in for the absence and the model does not have to.

upgrade_type: Option<u8>

Upgrade type (UpgradeType), when the entry carries one.

Held optionally because absence and an explicit 0 are both real: of 2040 property entries in the install, 1118 omit the label, 890 carry a value and 32 carry a zero. An omission keyed on the engine’s own absent-value would drop those 32.

The entry says the engine stamps 0 and our reader hands back None, which the vocabulary cannot express in one place: Absent::Resolves has no substitute slot, because it was shaped for the case where our value is the engine’s. Recorded here until that is settled.

Implementations

impl UtiProperty

pub const SCHEMA: [Field; 10]

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.

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

Reads one element of a list of this type.

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

Writes one element of a list of this type.

Trait Implementations

impl Clone for UtiProperty

fn clone(&self) -> UtiProperty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UtiProperty

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

Formats the value using the given formatter.

impl Default for UtiProperty

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 HasSchema for UtiProperty

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 UtiProperty

fn eq(&self, other: &UtiProperty) -> 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 Eq for UtiProperty

impl StructuralPartialEq for UtiProperty