Struct Stone

pub struct Stone {
    pub template_id: StoneTemplateId,
    pub tier: StoneTier,
    pub level: i64,
    pub copies: i64,
    pub socket: Option<StoneSocketKey>,
}

The one instance a player owns of a catalog entry, plus its stock of raw copies.

template_id is the identity: at most one Stone per template per collection, so there is no separate instance id. The database key is (character_id, template_id) for the same reason.

level is the upgrade level and copies is the currency that buys it. The first copy becomes the instance at level 1 with zero copies banked; every later copy increments copies. The ladder in configs::stones::StonesSettings::upgrade_ladder says what each level costs. The first copy already carries the full mechanic — an upgrade only scales the number it applies.

Fields

template_id: StoneTemplateId

The catalog entry this is the player’s instance of, and its identity.

tier: StoneTier

level: i64

copies: i64

Raw copies banked against this stone, spendable on the next level. Never negative: a refused upgrade spends nothing.

socket: Option<StoneSocketKey>

Some while socketed. The stone stays in its collection either way — this is the whole of “inserted” and “removed”. One instance means one socket: the same template cannot sit in two slots.

Implementations

impl Stone

pub fn new(template_id: StoneTemplateId, tier: StoneTier) -> Self

The player’s first copy of template_id: level 1, nothing banked.

pub const fn is_socketed(&self) -> bool

pub const fn quality(&self) -> (StoneTier, i64)

Ranking key for “the best stone I own”: tier first, then level.

The two axes are not comparable on their own — a level-3 Common against a level-1 Legendary has no arithmetic answer — so the design picks one. Tier wins because it decides the stone’s gauge contribution and the shape of what it does; level only scales a magnitude inside that shape.

Trait Implementations

impl Clone for Stone

fn clone(&self) -> Stone

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Stone

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stone

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Stone> for JsValue

where Stone: Serialize,

fn from(value: Stone) -> Self

Converts to this type from the input type.

impl FromWasmAbi for Stone

where Self: DeserializeOwned,

type Abi = <JsType as FromWasmAbi>::Abi

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: Self::Abi) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for Stone

where Stone: Serialize,

type Abi = <JsType as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> Self::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl JsonSchema for Stone

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl OptionFromWasmAbi for Stone

where Self: DeserializeOwned,

fn is_none(js: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for Stone

where Stone: Serialize,

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl PartialEq for Stone

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

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<Stone>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl Serialize for Stone

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tsify for Stone

const DECL: &'static str = "/**\n * The one instance a player owns of a catalog entry, plus its stock of raw\n * copies.\n *\n * `template_id` is the identity: at most one `Stone` per template per\n * collection, so there is no separate instance id. The database key is\n * `(character_id, template_id)` for the same reason.\n *\n * `level` is the upgrade level and `copies` is the currency that buys it. The\n * first copy becomes the instance at level 1 with zero copies banked; every\n * later copy increments `copies`. The ladder in\n * `configs::stones::StonesSettings::upgrade_ladder` says what each level costs.\n * The first copy already carries the full mechanic \u{2014} an upgrade only scales the\n * number it applies.\n */\nexport interface Stone {\n /**\n * The catalog entry this is the player\\\'s instance of, and its identity.\n */\n template_id: StoneTemplateId;\n tier: StoneTier;\n level: number;\n /**\n * Raw copies banked against this stone, spendable on the next level. Never\n * negative: a refused upgrade spends nothing.\n */\n copies: number;\n /**\n * `Some` while socketed. The stone stays in its collection either way \u{2014}\n * this is the whole of \\\"inserted\\\" and \\\"removed\\\". One instance means one\n * socket: the same template cannot sit in two slots.\n */\n socket: StoneSocketKey | null;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl VectorFromWasmAbi for Stone

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[Self]>

impl VectorIntoWasmAbi for Stone

where Stone: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[Self]>) -> Self::Abi

impl WasmDescribe for Stone

fn describe()

impl WasmDescribeVector for Stone

fn describe_vector()

impl Eq for Stone

impl StructuralPartialEq for Stone