essences/

mana.rs

use crate::prelude::*;

/// 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`]).
#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub struct ManaPool {
    /// Full pool size, from `mana_settings.pool`.
    pub max: f64,
    /// Points available right now.
    pub current: f64,
    /// Points restored per second of fight time, from `mana_settings.regen_per_second`.
    pub regen_per_second: f64,
    /// Ticker unit the pool was last accrued at (1 unit = 1 ms).
    pub updated_tick: u64,
}

impl PartialEq for ManaPool {
    fn eq(&self, other: &Self) -> bool {
        self.max.to_bits() == other.max.to_bits()
            && self.current.to_bits() == other.current.to_bits()
            && self.regen_per_second.to_bits() == other.regen_per_second.to_bits()
            && self.updated_tick == other.updated_tick
    }
}

impl Eq for ManaPool {}

impl ManaPool {
    /// A full pool at fight start.
    pub fn full(max: f64, regen_per_second: f64, current_tick: u64) -> Self {
        let max = if max.is_finite() && max > 0.0 {
            max
        } else {
            0.0
        };
        let regen_per_second = if regen_per_second.is_finite() && regen_per_second > 0.0 {
            regen_per_second
        } else {
            0.0
        };
        Self {
            max,
            current: max,
            regen_per_second,
            updated_tick: current_tick,
        }
    }

    /// 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 regen_to(&mut self, current_tick: u64) {
        let elapsed_ms = current_tick.saturating_sub(self.updated_tick);
        self.updated_tick = current_tick;
        if elapsed_ms == 0 || self.regen_per_second <= 0.0 {
            return;
        }
        let gained = self.regen_per_second * (elapsed_ms as f64) / 1000.0;
        self.current = (self.current + gained).min(self.max);
    }

    /// 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 try_spend(&mut self, cost: f64) -> bool {
        if !cost.is_finite() || cost <= 0.0 {
            return true;
        }
        if self.current + f64::EPSILON < cost {
            return false;
        }
        self.current = (self.current - cost).max(0.0);
        true
    }

    /// 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 ms_until_affordable(&self, cost: f64) -> Option<u64> {
        if !cost.is_finite() || cost <= self.current {
            return Some(0);
        }
        if self.regen_per_second <= 0.0 || cost > self.max {
            return None;
        }
        let ms = (cost - self.current) / self.regen_per_second * 1000.0;
        Some(ms.ceil().max(0.0) as u64)
    }

    /// Share of the pool that is currently missing, in `[0, 1]`. Feeds the
    /// "Отдача" stone (damage scaling on missing mana).
    pub fn missing_fraction(&self) -> f64 {
        if self.max <= 0.0 {
            return 0.0;
        }
        ((self.max - self.current) / self.max).clamp(0.0, 1.0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn full_pool_starts_at_max() {
        let pool = ManaPool::full(100.0, 5.0, 42);
        assert_eq!(pool.current, 100.0);
        assert_eq!(pool.max, 100.0);
        assert_eq!(pool.updated_tick, 42);
    }

    #[test]
    fn regen_accrues_by_elapsed_milliseconds_and_clamps() {
        let mut pool = ManaPool::full(100.0, 10.0, 0);
        assert!(pool.try_spend(50.0));
        assert_eq!(pool.current, 50.0);

        pool.regen_to(1_000);
        assert_eq!(pool.current, 60.0);

        pool.regen_to(100_000);
        assert_eq!(pool.current, 100.0);
    }

    #[test]
    fn spend_rejects_insufficient_mana_without_mutating() {
        let mut pool = ManaPool::full(10.0, 0.0, 0);
        assert!(pool.try_spend(10.0));
        assert_eq!(pool.current, 0.0);
        assert!(!pool.try_spend(1.0));
        assert_eq!(pool.current, 0.0);
    }

    #[test]
    fn wait_time_is_the_exact_refill_time() {
        let mut pool = ManaPool::full(100.0, 10.0, 0);
        assert!(pool.try_spend(100.0));

        // Already affordable.
        assert_eq!(pool.ms_until_affordable(0.0), Some(0));
        // 25 mana at 10/s = 2.5s.
        assert_eq!(pool.ms_until_affordable(25.0), Some(2_500));
        // Rounded up to the next whole millisecond.
        assert_eq!(pool.ms_until_affordable(0.0001), Some(1));
        // Never affordable: more than the whole pool.
        assert_eq!(pool.ms_until_affordable(101.0), None);

        // No regen: no amount of waiting helps.
        let no_regen = ManaPool::full(100.0, 0.0, 0);
        assert_eq!(no_regen.ms_until_affordable(150.0), None);
        assert_eq!(no_regen.ms_until_affordable(50.0), Some(0));
    }

    #[test]
    fn missing_fraction_tracks_spent_share() {
        let mut pool = ManaPool::full(200.0, 0.0, 0);
        assert_eq!(pool.missing_fraction(), 0.0);
        assert!(pool.try_spend(50.0));
        assert_eq!(pool.missing_fraction(), 0.25);
    }
}