Struct LoadoutSpec 

pub struct LoadoutSpec {

    pub inherit: Option<Base>,
    pub head: Option<ItemSpec>,
    pub neck: Option<ItemSpec>,
    pub shoulders: Option<ItemSpec>,
    pub chest: Option<ItemSpec>,
    pub gloves: Option<ItemSpec>,
    pub ring1: Option<ItemSpec>,
    pub ring2: Option<ItemSpec>,
    pub back: Option<ItemSpec>,
    pub belt: Option<ItemSpec>,
    pub legs: Option<ItemSpec>,
    pub feet: Option<ItemSpec>,
    pub tabard: Option<ItemSpec>,
    pub bag1: Option<ItemSpec>,
    pub bag2: Option<ItemSpec>,
    pub bag3: Option<ItemSpec>,
    pub bag4: Option<ItemSpec>,
    pub lantern: Option<ItemSpec>,
    pub glider: Option<ItemSpec>,
    pub active_hands: Option<Hands>,
    pub inactive_hands: Option<Hands>,
}

Core struct of loadout asset.

If you want programing API of loadout creation, use LoadoutBuilder instead.

For examples of assets, see assets/test/loadout/ok folder.

Fields

inherit: Option<Base>

head: Option<ItemSpec>

neck: Option<ItemSpec>

shoulders: Option<ItemSpec>

chest: Option<ItemSpec>

gloves: Option<ItemSpec>

ring1: Option<ItemSpec>

ring2: Option<ItemSpec>

back: Option<ItemSpec>

belt: Option<ItemSpec>

legs: Option<ItemSpec>

feet: Option<ItemSpec>

tabard: Option<ItemSpec>

bag1: Option<ItemSpec>

bag2: Option<ItemSpec>

bag3: Option<ItemSpec>

bag4: Option<ItemSpec>

lantern: Option<ItemSpec>

glider: Option<ItemSpec>

active_hands: Option<Hands>

inactive_hands: Option<Hands>

Implementations

impl LoadoutSpec

fn merge(self, base: Self) -> Self

Merges self with base. If some field exists in self it will be used, if no, it will be taken from base.

NOTE: it uses only inheritance chain from base without evaluating it. Inheritance chain from self is discarded.

Examples

You have your asset, let’s call it “a”. In this asset, you have inheritance from “b”. In asset “b” you inherit from “c”.

If you load your “a” into LoadoutSpec A, and “b” into LoadoutSpec B, and then merge A into B, you will get new LoadoutSpec that will inherit from “c”.

You have two assets, let’s call them “a” and “b”. “a” inherits from “n”, “b” inherits from “m”.

If you load “a” into A, “b” into B and then will try to merge them you will get new LoadoutSpec that will inherit from “m”. It’s error, because chain to “n” is lost!!!

Correct way to do this will be first evaluating at least “a” and then merge this new LoadoutSpec with “b”.

fn eval(self, rng: &mut impl Rng) -> Result<Self, SpecError>

Recursively evaluate all inheritance chain. For example with following structure.

A
inherit: B,
gloves: a,

B
inherit: C,
ring1: b,

C
inherit: None,
ring2: c

result will be

inherit: None,
gloves: a,
ring1: b,
ring2: c,

Trait Implementations

impl Clone for LoadoutSpec

fn clone(&self) -> LoadoutSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoadoutSpec

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

Formats the value using the given formatter.

impl Default for LoadoutSpec

fn default() -> LoadoutSpec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LoadoutSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.