Struct StoneInventory

pub struct StoneInventory {
    pub trigger_stones: Vec<Stone>,
    pub effect_stones: Vec<Stone>,
}

Everything a character owns in the stone system: the two collections, kept apart, plus the socket assignments carried by the stones themselves.

Fields

trigger_stones: Vec<Stone>

effect_stones: Vec<Stone>

Implementations

impl StoneInventory

pub fn collection(&self, kind: StoneKind) -> &Vec<Stone>

pub fn collection_mut(&mut self, kind: StoneKind) -> &mut Vec<Stone>

pub fn all(&self) -> impl Iterator<Item = (StoneKind, &Stone)>

pub fn kind_of(&self, template_id: StoneTemplateId) -> Option<StoneKind>

Which collection holds template_id, if any. The lookup runs across both collections precisely so a caller cannot address a Trigger Stone as if it were an Effect Stone; the two catalogs share no template id, so the answer is unambiguous.

pub fn get(&self, template_id: StoneTemplateId) -> Option<&Stone>

pub fn grant( &mut self, kind: StoneKind, template_id: StoneTemplateId, tier: StoneTier, )

Banks one raw copy of template_id in kind’s collection.

The first copy becomes the instance (level 1, nothing banked); every later one increments Stone::copies. This is the only way a stone enters the inventory, which is what keeps “one instance per template” an invariant rather than a convention — a second row for a template the player already owns is unreachable.

pub fn socketed(&self, key: StoneSocketKey) -> Option<&Stone>

The stone currently sitting in key, if any.

pub fn insert( &mut self, template_id: StoneTemplateId, key: StoneSocketKey, unlocked: bool, ) -> Result<(), StoneError>

Inserts the player’s instance of template_id into a socket. unlocked decides whether the socket is available yet — the schedule itself lives in config, so this type stays free of chapter arithmetic.

A template has exactly one instance, so socketing it twice is refused with StoneError::AlreadySocketed. An occupied socket is swapped, not refused: the sitting stone returns whole to the collection.

Stones may be changed at any time, including mid-fight, so there is no combat gate here or in the callers.

pub fn remove( &mut self, template_id: StoneTemplateId, ) -> Result<StoneSocketKey, StoneError>

Clears a stone’s socket. The stone is not moved, copied or re-created — it was in its collection all along — so nothing about it can be lost. Returns the socket it was freed from.

pub fn quick_equip( &mut self, item_type: ItemType, is_unlocked: &dyn Fn(StoneSocketSlot) -> bool, catalog_order: &dyn Fn(StoneKind) -> Vec<StoneTemplateId>, ) -> Vec<(StoneSocketSlot, StoneTemplateId)>

Fills every open and empty socket of item_type with the best stone the player is not already wearing, and returns the sockets it filled.

The caller supplies is_unlocked because the unlock schedule lives in config and this type stays free of chapter arithmetic.

Locked sockets are skipped and occupied ones are left alone — quick equip fills gaps, it does not re-shuffle a build. Only unsocketed stones are candidates, so quick-equipping one item never strips another, and the pool comes from StoneSocketSlot::accepts, which makes a wrong-collection pick inexpressible. An empty pool leaves the socket empty and is not an error.

Only EMPTY open sockets are filled, each with the BEST usable stone the player owns loose: highest Stone::quality — tier first, then level. catalog_order is the canonical catalog sequence, pre-filtered to active templates by the caller; it decides which templates are eligible at all and breaks ties between two stones of identical quality, so the pick is deterministic. An instance already socketed elsewhere is never taken.

pub fn upgrade_all( &mut self, kind: StoneKind, max_level: i64, cost: &dyn Fn(i64) -> Option<i64>, ) -> Vec<(StoneTemplateId, i64, i64)>

Raises every stone of kind as far as its banked copies reach, and returns (template, level before, level after) for each stone that moved.

This is the whole of UpgradeAllTriggerStones / UpgradeAllEffectStones (design v0.2 §9). cost is the ladder rung for a level (None past the cap), supplied by the caller for the same reason as quick_equip’s is_unlocked.

One catalog per call: the screen’s button raises the tab the player is looking at, so a Trigger upgrade must not quietly spend the copies banked against Effect stones.

One stone is taken up as many levels as it can afford in one call — the ladder is cheap at the bottom, so a fresh pile of copies is often worth several levels and stopping after one would make the button lie. Socketed and loose stones are treated identically: an upgrade never touches the socket.

pub fn upgrade( &mut self, template_id: StoneTemplateId, required: i64, max_level: i64, ) -> Result<i64, StoneError>

Spends required banked copies to take template_id up one level.

required is the rung of the config ladder for the level being bought (StonesSettings::upgrade_copies_required) — the cost is per level and this type never guesses it.

Copies are a count, so a copy earned at level 1 pays for level 4 like any other. Only level and copies move, leaving template_id, tier and socket untouched, so a socketed stone upgrades in place. Every refusal returns before the first mutation, so a short bank is left exactly as it was.

Trait Implementations

impl Clone for StoneInventory

fn clone(&self) -> StoneInventory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StoneInventory

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

Formats the value using the given formatter.

impl Default for StoneInventory

fn default() -> StoneInventory

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StoneInventory

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StoneInventory> for JsValue

where StoneInventory: Serialize,

fn from(value: StoneInventory) -> Self

Converts to this type from the input type.

impl FromWasmAbi for StoneInventory

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 StoneInventory

where StoneInventory: 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 StoneInventory

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 StoneInventory

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 StoneInventory

where StoneInventory: 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 StoneInventory

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

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<StoneInventory>

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 StoneInventory

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 StoneInventory

const DECL: &'static str = "/**\n * Everything a character owns in the stone system: the two collections, kept\n * apart, plus the socket assignments carried by the stones themselves.\n */\nexport interface StoneInventory {\n trigger_stones: Stone[];\n effect_stones: Stone[];\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 StoneInventory

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

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

impl VectorIntoWasmAbi for StoneInventory

where StoneInventory: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

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

impl WasmDescribe for StoneInventory

fn describe()

impl WasmDescribeVector for StoneInventory

fn describe_vector()

impl Eq for StoneInventory

impl StructuralPartialEq for StoneInventory