Struct ArtifactCollection

pub struct ArtifactCollection {
    pub artifacts: Vec<Artifact>,
    pub equipped: Option<ArtifactTemplateId>,
    pub stones: Vec<ArtifactStone>,
}

Everything a character owns in the artifact system.

Fields

artifacts: Vec<Artifact>

equipped: Option<ArtifactTemplateId>

The single worn artifact. None before the vertical opens — that player plays exactly as before, because every artifact read starts here or at an empty artifacts.

stones: Vec<ArtifactStone>

Owned artifact stones, each carrying its own socket assignment. Not owned by any artifact: this is what makes the stones survive a swap.

Implementations

impl ArtifactCollection

pub fn get(&self, template_id: ArtifactTemplateId) -> Option<&Artifact>

pub fn stone( &self, template_id: ArtifactStoneTemplateId, ) -> Option<&ArtifactStone>

pub fn socketed(&self, socket: ArtifactSocketSlot) -> Option<&ArtifactStone>

The stone sitting in socket, if any.

pub fn grant_artifact(&mut self, template_id: ArtifactTemplateId)

Grants one artifact copy without performing an upgrade.

The first grant creates the level-1 instance. Every duplicate only increments its raw-copy bank, including when the artifact is already at the level cap.

The very first artifact a player owns is also WORN. Exactly one artifact is worn at a time, so a collection that owns something and wears nothing is not a state the player can produce — Self::equip has no “take off” counterpart. Leaving the slot empty read as a bug on the artifact screen, which then had no worn artifact to open on. This never overrides a choice: it fires only while Self::equipped is None.

pub fn upgrade_artifact( &mut self, template_id: ArtifactTemplateId, required: i64, max_level: i64, ) -> Result<i64, ArtifactError>

Spends exactly one configured rung and raises an artifact one level.

All refusal checks happen before either field changes, so an unknown artifact, a capped artifact or a short copy bank is atomic.

pub fn equip( &mut self, template_id: ArtifactTemplateId, ) -> Result<(), ArtifactError>

Wears template_id. Exactly one artifact is worn at a time, so this replaces whatever was worn before; the previous one keeps paying its ownership bonus and loses only its World Law.

Socketed stones are deliberately not read here — that is the whole of “stones transfer to the new artifact”.

pub fn grant_stone(&mut self, template_id: ArtifactStoneTemplateId)

Banks one raw copy of an artifact stone. The first copy becomes the instance at level 1; later copies raise ArtifactStone::copies, which the player spends through an explicit upgrade — same shape as crate::stones::StoneInventory::grant.

pub fn insert_stone( &mut self, template_id: ArtifactStoneTemplateId, socket: ArtifactSocketSlot, expected: ArtifactSocketSlot, unlocked: bool, ) -> Result<(), ArtifactError>

Puts the player’s instance of template_id into socket.

expected is the socket the stone’s catalog entry declares — a stone fits one socket and no other, which is how the two columns are kept apart. unlocked is the chapter gate; the schedule itself is config, so this type stays free of chapter arithmetic.

pub fn set_law_target( &mut self, template_id: ArtifactStoneTemplateId, law: Option<LawTemplateId>, is_law_socket: bool, slotted: bool, ) -> Result<(), ArtifactError>

Points a right-column stone at one law, or clears its choice (None).

slotted is “this law is owned and currently sitting in a core slot”, decided by the caller: the law lives in CoresState, which this type deliberately knows nothing about. is_law_socket is the stone’s own column, read from its catalog entry.

The one check that is NOT made here is a Real/Fantasy match against the socket. The three Law sockets are Visible / Hidden / Bridge, and “visible” is a phase, not a side: the same law is the visible one while its side is up and the hidden one while it is down (post-merge plan §8). So every slotted law is a legal target for every Law socket, and which half of the fight the stone speaks in is decided by the flip, not by validation.

pub fn forget_law_target(&mut self, law: LawTemplateId) -> bool

Drops every stone’s choice of law. Called when the law leaves its slot, so no stone is ever left pointing at a law that is not on a core.

Returns whether anything changed, so the caller can skip a write.

pub fn remove_stone( &mut self, template_id: ArtifactStoneTemplateId, ) -> Result<ArtifactSocketSlot, ArtifactError>

Clears a stone’s socket. The stone stays in the collection with its level and copies intact.

pub fn upgrade_stone( &mut self, template_id: ArtifactStoneTemplateId, required: i64, max_level: i64, ) -> Result<i64, ArtifactError>

Spends required banked copies to take an artifact stone up one level.

An upgrade only scales the rule’s magnitude — the rule itself came whole with the first copy (design §3), so nothing here touches the socket, the template or anything a rule reads besides level.

Trait Implementations

impl Clone for ArtifactCollection

fn clone(&self) -> ArtifactCollection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ArtifactCollection

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

Formats the value using the given formatter.

impl Default for ArtifactCollection

fn default() -> ArtifactCollection

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ArtifactCollection

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ArtifactCollection> for JsValue

where ArtifactCollection: Serialize,

fn from(value: ArtifactCollection) -> Self

Converts to this type from the input type.

impl FromWasmAbi for ArtifactCollection

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 ArtifactCollection

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

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 ArtifactCollection

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 ArtifactCollection

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

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

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<ArtifactCollection>

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 ArtifactCollection

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 ArtifactCollection

const DECL: &'static str = "/**\n * Everything a character owns in the artifact system.\n */\nexport interface ArtifactCollection {\n artifacts: Artifact[];\n /**\n * The single worn artifact. `None` before the vertical opens \u{2014} that player\n * plays exactly as before, because every artifact read starts here or at an\n * empty `artifacts`.\n */\n equipped: ArtifactTemplateId | null;\n /**\n * Owned artifact stones, each carrying its own socket assignment. Not owned\n * by any artifact: this is what makes the stones survive a swap.\n */\n stones: ArtifactStone[];\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 ArtifactCollection

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

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

impl VectorIntoWasmAbi for ArtifactCollection

where ArtifactCollection: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

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

impl WasmDescribe for ArtifactCollection

fn describe()

impl WasmDescribeVector for ArtifactCollection

fn describe_vector()

impl Eq for ArtifactCollection

impl StructuralPartialEq for ArtifactCollection