Enum CombatEventOrigin

pub enum CombatEventOrigin {
    Core,
    Proc,
}

Where one combat event came from.

Triggers fire on CombatEventOrigin::Core only. Without that boundary a modifier that grants a crit would re-enter the crit trigger that produced it and loop forever.

Events that are state transitions rather than combat actions (a global flip) carry no origin and can never be Core.

Variants

Core

A genuine combat action: an attack, a crit, a dodge, a heal, a mob death. Everything the fight engine itself produces is Core.

Proc

Produced by an Effect Stone or any other modifier. Never re-enters a trigger.

Implementations

impl CombatEventOrigin

pub fn is_core(self) -> bool

Whether triggers may react to an event with this origin.

pub fn merge(self, other: Self) -> Self

Provenance of work produced under both marks at once — the primitive’s own and the scope it ran inside. Marking only upgrades: once something is non-Core, nothing later in the cascade resets it to Core.

Trait Implementations

impl Clone for CombatEventOrigin

fn clone(&self) -> CombatEventOrigin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CombatEventOrigin

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

Formats the value using the given formatter.

impl Default for CombatEventOrigin

fn default() -> CombatEventOrigin

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CombatEventOrigin

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CombatEventOrigin

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

Formats the value using the given formatter.

impl From<CombatEventOrigin> for JsValue

where CombatEventOrigin: Serialize,

fn from(value: CombatEventOrigin) -> Self

Converts to this type from the input type.

impl FromStr for CombatEventOrigin

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<CombatEventOrigin, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl FromWasmAbi for CombatEventOrigin

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 Hash for CombatEventOrigin

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoWasmAbi for CombatEventOrigin

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

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 CombatEventOrigin

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 CombatEventOrigin

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

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

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<CombatEventOrigin>

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 CombatEventOrigin

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for CombatEventOrigin

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<CombatEventOrigin, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Tsify for CombatEventOrigin

const DECL: &'static str = "/**\n * Where one combat event came from.\n *\n * Triggers fire on [`CombatEventOrigin::Core`] only. Without that boundary a\n * modifier that grants a crit would re-enter the crit trigger that produced\n * it and loop forever.\n *\n * Events that are state transitions rather than combat actions (a global\n * flip) carry no origin and can never be Core.\n */\nexport type CombatEventOrigin = \"Core\" | \"Proc\";"

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 CombatEventOrigin

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

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

impl VectorIntoWasmAbi for CombatEventOrigin

where CombatEventOrigin: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

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

impl WasmDescribe for CombatEventOrigin

fn describe()

impl WasmDescribeVector for CombatEventOrigin

fn describe_vector()

impl Copy for CombatEventOrigin

impl Eq for CombatEventOrigin

impl StructuralPartialEq for CombatEventOrigin