wowlab_engine_combat/context/hook/

rppm.rs

use wowlab_engine_rng as stochastic;
use wowlab_types::sim::SimTime;

use super::{ProcOps, proc_counters};
use crate::{context::HookCtx, state::LocalRppmIdx, systems};

impl ProcOps for HookCtx<'_> {
    fn roll_rppm(&mut self, idx: LocalRppmIdx) -> bool {
        let now_secs = self.now.as_secs_f64();
        let scaling = systems::current_rppm_scaling(&self.view().combat());

        if let Some(tracker) = self
            .instance
            .runtime
            .procs
            .rppm_trackers
            .get_mut(idx.as_usize())
        {
            stochastic::roll_rppm(tracker, now_secs, scaling, self.rng)
        } else {
            false
        }
    }

    /// Add one trigger event to an accumulated-threshold proc; `increment_scale` multiplies the tracker's uniform roll (plain callers pass `1.0`), returning `true` when the threshold procs.
    fn roll_threshold(
        &mut self,
        idx: crate::state::LocalThresholdIdx,
        increment_scale: f64,
    ) -> bool {
        let Some(tracker) = self
            .instance
            .runtime
            .procs
            .threshold_trackers
            .get_mut(idx.as_usize())
        else {
            return false;
        };

        if tracker.accumulated.is_nan() {
            tracker.accumulated = (self.rng)();
        }

        let increment = (self.rng)() * tracker.increment_max * increment_scale;

        stochastic::roll_threshold(tracker, increment)
    }

    /// Roll a shared proc system's RPPM tracker by its DBC driver spell id.
    ///
    /// The driver also owns its optional DBC proc-category recovery.
    ///
    /// Attempts inside that window do not advance the tracker. Successful rolls start recovery.
    fn roll_system_rppm(&mut self, binding: crate::SystemRppmBinding) -> bool {
        let Some(resolved) = self
            .program
            .system_rppm_bindings
            .get(binding.as_usize())
            .copied()
            .flatten()
        else {
            return false;
        };
        let Some(ready_at) = self
            .instance
            .runtime
            .procs
            .system_rppm_ready_at
            .get(binding.as_usize())
            .copied()
        else {
            return false;
        };

        if self.now < ready_at || !self.roll_rppm(resolved.tracker) {
            return false;
        }

        if resolved.recovery_ms > 0 {
            // BOUNDS: the binding was read successfully from the same finalized dense table above.
            self.instance.runtime.procs.system_rppm_ready_at[binding.as_usize()] = self
                .now
                .saturating_add(SimTime::from_millis(resolved.recovery_ms));
        }

        true
    }

    /// Whether a DBC proc driver is outside its `ProcCategoryRecovery` window.
    fn proc_category_ready(&self, binding: crate::ProcCategoryBinding) -> bool {
        self.instance
            .runtime
            .procs
            .proc_category_ready_at_dense
            .get(binding.as_usize())
            .is_none_or(|ready_at| self.now >= *ready_at)
    }

    /// Start the DBC `ProcCategoryRecovery` window for a proc driver.
    fn start_proc_category_cooldown(&mut self, binding: crate::ProcCategoryBinding) {
        let recovery_ms = self
            .program
            .proc_category_recovery_ms
            .get(binding.as_usize())
            .copied()
            .unwrap_or(0);

        if recovery_ms == 0 {
            return;
        }

        if let Some(ready_at) = self
            .instance
            .runtime
            .procs
            .proc_category_ready_at_dense
            .get_mut(binding.as_usize())
        {
            *ready_at = self.now.saturating_add(SimTime::from_millis(recovery_ms));
        }
    }

    fn roll_accumulating_proc(
        &mut self,
        binding: crate::ProcCounterBinding,
        chance_per_attempt: f64,
    ) -> bool {
        self.roll_attempt_proc(binding, |attempt| chance_per_attempt * f64::from(attempt))
    }

    /// Roll a driver-scoped proc whose chance is a function of its current attempt number.
    fn roll_attempt_proc(
        &mut self,
        binding: crate::ProcCounterBinding,
        chance_for_attempt: impl FnOnce(u32) -> f64,
    ) -> bool {
        let Some(attempts) = self
            .instance
            .runtime
            .procs
            .proc_counters
            .get_mut(binding.as_usize())
        else {
            return false;
        };
        let attempt = attempts.saturating_add(1);

        if stochastic::proc_chance(self.rng, chance_for_attempt(attempt)) {
            *attempts = 0;

            true
        } else {
            *attempts = attempt;

            false
        }
    }

    /// Add to a driver-scoped event counter and return its new value.
    fn add_proc_counter(&mut self, binding: crate::ProcCounterBinding, amount: u32) -> u32 {
        proc_counters::add(self, binding, amount)
    }

    /// Clear a driver-scoped event counter.
    fn reset_proc_counter(&mut self, binding: crate::ProcCounterBinding) {
        proc_counters::reset(self, binding);
    }

    /// Read a driver-scoped event counter without changing it.
    fn proc_counter(&self, binding: crate::ProcCounterBinding) -> u32 {
        proc_counters::get(self, binding)
    }

    /// Mark one or more driver-scoped flags and return `true` only on their first occurrence.
    fn mark_proc_flags_once(&mut self, binding: crate::ProcCounterBinding, flags: u32) -> bool {
        proc_counters::mark_once(self, binding, flags)
    }

    /// Consume from a driver-scoped event counter and return the remaining value.
    fn consume_proc_counter(&mut self, binding: crate::ProcCounterBinding, amount: u32) -> u32 {
        proc_counters::consume(self, binding, amount)
    }

    /// Advance a driver-scoped event counter and return `true` at the threshold.
    fn advance_proc_counter_by(
        &mut self,
        binding: crate::ProcCounterBinding,
        amount: u32,
        threshold: u32,
    ) -> bool {
        proc_counters::advance(self, binding, amount, threshold)
    }

    /// Advance a driver-scoped event counter by one and return `true` at the threshold.
    fn advance_proc_counter(&mut self, binding: crate::ProcCounterBinding, threshold: u32) -> bool {
        self.advance_proc_counter_by(binding, 1, threshold)
    }
}