Struct ManaPool

pub struct ManaPool {
    pub max: f64,
    pub current: f64,
    pub regen_per_second: f64,
    pub updated_tick: u64,
}

Fight-local mana of one combatant.

Character combatants (hero, party ally, human PvP opponent) carry Some; mobs carry None and are never mana-gated. The pool is refilled to max at every fight start and is not carried between fights — outside a fight there is no mana at all, so nothing can spend it.

current is a float because regen is a per-second rate applied on the millisecond fight clock; updated_tick makes the accrual drift-free and independent of the heartbeat cadence (see ManaPool::regen_to).

Fields

max: f64

Full pool size, from mana_settings.pool.

current: f64

Points available right now.

regen_per_second: f64

Points restored per second of fight time, from mana_settings.regen_per_second.

updated_tick: u64

Ticker unit the pool was last accrued at (1 unit = 1 ms).

Implementations

impl ManaPool

pub fn full(max: f64, regen_per_second: f64, current_tick: u64) -> Self

A full pool at fight start.

pub fn regen_to(&mut self, current_tick: u64)

Accrues regen for the time elapsed since the last accrual and clamps to max. Idempotent within one tick, so both the fight heartbeat and the cast path can call it freely.

pub fn try_spend(&mut self, cost: f64) -> bool

Spends cost if the pool covers it. Returns false (and changes nothing) when it does not — the caller must then wait, not cast.

pub fn ms_until_affordable(&self, cost: f64) -> Option<u64>

Milliseconds of fight time until the pool covers cost.

Some(0) when it already does. None when regen can never get there (no regen at all, or a cost above the whole pool) — the caller decides the fallback. This is what turns a starving ability’s wait into ONE scheduled retry instead of a 10 Hz poll of the actions queue.

pub fn missing_fraction(&self) -> f64

Share of the pool that is currently missing, in [0, 1]. Feeds the “Отдача” stone (damage scaling on missing mana).

Trait Implementations

impl Clone for ManaPool

fn clone(&self) -> ManaPool

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ManaPool

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ManaPool

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ManaPool> for JsValue

where ManaPool: Serialize,

fn from(value: ManaPool) -> Self

Converts to this type from the input type.

impl FromWasmAbi for ManaPool

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 ManaPool

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

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 ManaPool

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 ManaPool

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

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

where Self: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<ManaPool>

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 ManaPool

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 ManaPool

const DECL: &'static str = "/**\n * Fight-local mana of one combatant.\n *\n * Character combatants (hero, party ally, human PvP opponent) carry `Some`;\n * mobs carry `None` and are never mana-gated. The pool is refilled to `max` at\n * every fight start and is not carried between fights \u{2014} outside a fight there\n * is no mana at all, so nothing can spend it.\n *\n * `current` is a float because regen is a per-second rate applied on the\n * millisecond fight clock; `updated_tick` makes the accrual drift-free and\n * independent of the heartbeat cadence (see [`ManaPool::regen_to`]).\n */\nexport interface ManaPool {\n /**\n * Full pool size, from `mana_settings.pool`.\n */\n max: number;\n /**\n * Points available right now.\n */\n current: number;\n /**\n * Points restored per second of fight time, from `mana_settings.regen_per_second`.\n */\n regen_per_second: number;\n /**\n * Ticker unit the pool was last accrued at (1 unit = 1 ms).\n */\n updated_tick: number;\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 ManaPool

where Self: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

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

impl VectorIntoWasmAbi for ManaPool

where ManaPool: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

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

impl WasmDescribe for ManaPool

fn describe()

impl WasmDescribeVector for ManaPool

fn describe_vector()

impl Copy for ManaPool

impl Eq for ManaPool