Struct Mag 

pub struct Mag {
    pub log10: f64,
}

Non-negative log-magnitude. Mag::ZERO == Mag { log10: -inf }, Mag::ONE == Mag { log10: 0.0 }. All other instances carry a finite log10.

Save compatibility

Serializes as a plain f64 when the value fits inside one (log10 < 300, well clear of overflow); otherwise as {"log10": <f64>}. Deserialization accepts BOTH shapes — so existing V4 saves with "cuques": 1.234e10 and "MulFactor": 7.0 continue to load correctly, no schema bump required. New saves use the struct form only when the value exceeds the f64 finite range.

Fields

log10: f64

Implementations

impl Mag

pub const ZERO: Mag

pub const ONE: Mag

pub fn from_f64(v: f64) -> Mag

Construct from an f64. Non-finite / negative inputs collapse to ZERO — there is no honest log-magnitude for them and silently turning a NaN into a zero is friendlier than panicking on a codepath the player never asked for.

pub fn to_f64(self) -> f64

Decode back to an f64. Clamps very-large log10 values to f64::MAX — losing precision in the high end is the price of asking for an f64; the Mag representation itself stays faithful. Use this at the display boundary or wherever a downstream API truly demands f64. Internal math should chain Mag ops.

pub fn is_zero(self) -> bool

pub fn mul(self, rhs: Mag) -> Mag

pub fn div(self, rhs: Mag) -> Mag

pub fn add(self, rhs: Mag) -> Mag

pub fn try_sub(self, rhs: Mag) -> Option<Mag>

Saturating subtraction: returns Some(self - rhs) when self >= rhs, otherwise None. Cuque spending uses this on purchase — the caller already gated on affordable, so None means a logic bug, not a regular game state.

pub fn saturating_sub(self, rhs: Mag) -> Mag

Saturating subtraction with floor at zero. Convenience for paths that don’t care about the underflow case (e.g. visual tween targets).

pub fn pow_i(self, n: i32) -> Mag

Raise to an integer power. pow(0) == ONE, pow(n) = self * self * …. Cheap: just multiplies the log by n.

0^n for any n != 0 returns ZERO. Mathematically 0^negative is undefined, but returning ZERO is the conservative choice for this codebase: it propagates “no contribution” downstream rather than producing an Infinity, which would reintroduce the bug class the Mag type exists to kill.

pub fn floor_u64(self) -> u64

Floored to_f64, useful for “how many of these can the player afford” math. Clamps to u64::MAX.

Trait Implementations

impl Add for Mag

type Output = Mag

The resulting type after applying the + operator.

fn add(self, rhs: Mag) -> Mag

Performs the + operation.

impl Clone for Mag

fn clone(&self) -> Mag

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mag

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

Formats the value using the given formatter.

impl Default for Mag

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Mag

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Div for Mag

type Output = Mag

The resulting type after applying the / operator.

fn div(self, rhs: Mag) -> Mag

Performs the / operation.

impl From<f64> for Mag

fn from(v: f64) -> Self

Converts to this type from the input type.

impl From<u32> for Mag

fn from(v: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Mag

fn from(v: u64) -> Self

Converts to this type from the input type.

impl Mul for Mag

type Output = Mag

The resulting type after applying the * operator.

fn mul(self, rhs: Mag) -> Mag

Performs the * operation.

impl PartialEq for Mag

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 PartialOrd for Mag

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Mag

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Copy for Mag