Struct ShoesToken 

pub struct ShoesToken {

    pub reference: Option<ReferenceTo<Self>>,
    pub upstep: Option<Choose<u8, MaxEnum>>,
    pub name: Option<(String, String)>,
    pub material_size: Option<u32>,
    pub adjective: Option<String>,
    pub metal_armor_levels: Option<()>,
    pub chain_metal_text: Option<()>,
    pub soft: Option<()>,
    pub hard: Option<()>,
    pub metal: Option<()>,
    pub barred: Option<()>,
    pub scaled: Option<()>,
    pub leather: Option<()>,
    pub shaped: Option<()>,
    pub structural_elasticity_chain_all: Option<()>,
    pub structural_elasticity_chain_metal: Option<()>,
    pub structural_elasticity_woven_thread: Option<()>,
    pub layer_size: Option<u32>,
    pub layer_permit: Option<u32>,
    pub layer: Option<LayerEnum>,
    pub coverage: Option<u8>,
    pub armorlevel: Option<u8>,
}

Fields

reference: Option<ReferenceTo<Self>>

Argument 1 of [ITEM_SHOES:...]

upstep: Option<Choose<u8, MaxEnum>>

Length of gloves or footwear, counted in [LIMB] body parts towards the torso. A value of 1 lets gloves cover the lower arms, a value of 2 stretches a boot all the way over the upper leg and so on.

Regardless of the value, none of these items can ever extend to cover the upper or lower body. Shields also have this token, but it only seems to affect weight.

name: Option<(String, String)>

What this item will be called in-game.

material_size: Option<u32>

How much material is needed to make the item. Most important with bars. The number of bars required to make the item is the value divided by three.

adjective: Option<String>

Adjective preceding the material name (e.g. “large copper dagger”).

metal_armor_levels: Option<()>

Metal versions of this item count as one ARMORLEVEL higher and thus won’t be worn by random peasants. This tag will not work unless ARMORLEVEL is explicitly declared: if you leave out ARMORLEVEL, even metal armor will default to level 0.

chain_metal_text: Option<()>

Metal versions of this item will have “chain” added between the material and item name.

soft: Option<()>

Clothiers can make this item from all kinds of cloth. If paired with [LEATHER], the item has an equal chance of being either in randomly generated outfits. Further uses of this tag are unknown.

hard: Option<()>

Default state in the absence of a [SOFT] token. Actual effects unknown.

metal: Option<()>

Item can be made from metal. Overrides [SOFT] and [LEATHER] in randomly generated outfits, if the ARMORLEVEL permits. Civilizations with [WOOD_ARMOR] will make this item out of wood instead.

barred: Option<()>

Craftsmen can make this item from bones. Randomly generated outfits don’t include bone armor.

scaled: Option<()>

Craftsmen can make this item from shells. Randomly generated outfits don’t include shell armor.

leather: Option<()>

Leatherworkers can make this item from leather. If paired with [SOFT], this item has an equal chance of being either in randomly generated outfits.

shaped: Option<()>

Only one shaped piece of clothing can be worn on a single body slot at a time.

structural_elasticity_chain_all: Option<()>

Increases the *_STRAIN_AT_YIELD properties of the armor’s material to 50000, if lower. This makes the garment flex and give way instead of shattering under force. Strong materials that resist cutting will blunt edged attacks into bone-crushing hits instead.

structural_elasticity_chain_metal: Option<()>

Increases the *_STRAIN_AT_YIELD properties of the armor’s material to 50000, but only if the garment is made from metal.

structural_elasticity_woven_thread: Option<()>

Reduces the armor material’s SHEAR_YIELD to 20000, SHEAR_FRACTURE to 30000 and increases the *_STRAIN_AT_YIELD properties to 50000, but only if the garment is made from cloth. This makes the item very weak against edged attacks, even if the thread material is normally very strong.

layer_size: Option<u32>

The item’s bulkiness when worn. Aside from the layer limitations, it’s a big contributor to the thickness and weight (and therefore price) of the garment. See Armor for more on item sizes and layering. Defaults to 10.

layer_permit: Option<u32>

The maximum amount of garments that can fit underneath this garment. See Armor for more on item sizes and layering. Defaults to 10.

layer: Option<LayerEnum>

Where the item goes in relation to other clothes. Socks cannot be worn on top of boots!

The LAYER_PERMIT of the highest layer is used on a given section of the body - you can fit a lot of shirts and other undergarments underneath a robe, but not if you wear a leather jerkin on top of it, and you can still wear a cloak over the whole ensemble. Defaults to UNDER.

coverage: Option<u8>

How often the garment gets in the way of a contaminant or an attack. Armor with a 5% coverage value, for example, will be near useless because 95% of attacks will bypass it completely. Temperature effects and armor thickness are also influenced. Defaults to 100.

armorlevel: Option<u8>

The garment’s general purpose. Defaults to 1 for shields, 0 for everything else. Class 0 items are claimed and used by civilians as ordinary clothing and are subject to wear.

Trait Implementations

impl Clone for ShoesToken

fn clone(&self) -> ShoesToken

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShoesToken

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

Formats the value using the given formatter.

impl Default for ShoesToken

fn default() -> ShoesToken

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ShoesToken

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ShoesToken

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

fn get_reference(&self) -> Option<ReferenceTo<Self>>

fn get_ref_type() -> &'static str

impl Serialize for ShoesToken

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TokenDeserialize for ShoesToken

fn deserialize_general_token( cursor: &mut TreeCursor, source: &str, diagnostics: &mut DiagnosticsInfo, new_self: Box<Self>, ) -> (LoopControl, Box<Self>)

fn get_allowed_tokens() -> Option<Vec<String>>

fn deserialize_tokens( cursor: &mut TreeCursor, source: &str, diagnostics: &mut DiagnosticsInfo, ) -> Result<Box<Self>, ()>

fn get_vec_loopcontrol() -> LoopControl

Should return Continue in most cases, DoNothing in case of String, i32, Tuples and type likes that

impl Eq for ShoesToken

impl StructuralPartialEq for ShoesToken