wowlab_engine_combat/systems/

mastery.rs

//! Per-spec mastery: each spec's [`MasteryFn`] returns a hit's mastery damage multiplier.

use wowlab_engine_domain::dbc::SpellSchoolMask;
use wowlab_types::{
    combat::DamageSchool,
    constants::HUNDRED,
    sim::{ActorId, EnemyIdx, SpellIdx},
};

use crate::state::{CombatInstance, CombatProgram};

#[derive(Debug)]
pub struct MasteryCtx<'a> {
    pub program: &'a CombatProgram,
    pub instance: &'a CombatInstance,
    pub spell_id: u32,
    pub(crate) spell_action: crate::state::program::LocalDamageActionIdx,
    pub school: DamageSchool,
    pub mastery: f64,
    pub player_crit_pct: f64,
    pub mastery_spell: SpellIdx,
    pub(crate) mastery_action: Option<crate::state::program::LocalDamageActionIdx>,
    pub is_periodic: bool,
    pub is_pet: bool,
    pub source: ActorId,
    /// Hostile target used by target-specific mastery clauses.
    /// Reflected hits re-executed against their caster have no hostile target.
    pub target: Option<EnemyIdx>,
    pub now: wowlab_types::sim::SimTime,
}

#[derive(Clone, Copy, Debug)]
pub struct MasteryEvent {
    pub action: crate::DamageActionId,
    pub school: DamageSchool,
    pub mastery: f64,
    pub player_crit_pct: f64,
    pub mastery_action: crate::DamageActionId,
    pub is_periodic: bool,
    pub is_pet: bool,
    pub source: ActorId,
    pub target: Option<EnemyIdx>,
    pub now: wowlab_types::sim::SimTime,
}

impl MasteryCtx<'_> {
    /// Builds a mastery hook context from finalized generated action coordinates.
    #[must_use]
    pub fn new<'a>(
        program: &'a CombatProgram,
        instance: &'a CombatInstance,
        event: MasteryEvent,
    ) -> Option<MasteryCtx<'a>> {
        Some(MasteryCtx {
            program,
            instance,
            spell_id: event.action.spell_id(),
            spell_action: program.damage.validated_action_id(event.action)?,
            school: event.school,
            mastery: event.mastery,
            player_crit_pct: event.player_crit_pct,
            mastery_spell: SpellIdx::from_raw(event.mastery_action.spell_id()),
            mastery_action: Some(program.damage.validated_action_id(event.mastery_action)?),
            is_periodic: event.is_periodic,
            is_pet: event.is_pet,
            source: event.source,
            target: event.target,
            now: event.now,
        })
    }

    /// Number of registered temporary weapon imbues currently active.
    #[must_use]
    pub fn active_weapon_imbue_count(&self) -> usize {
        self.program
            .weapon_imbue_bindings
            .iter()
            .filter(|binding| self.instance.buffer.weapon_imbue_at(binding.slot).is_active != 0)
            .count()
    }

    /// Whether the exact source/target aura instance is active for this hit.
    #[must_use]
    pub fn is_aura_active(&self, local: crate::LocalAuraIdx) -> bool {
        super::auras::is_aura_active(
            &crate::context::CombatView::new(self.program, self.instance),
            local,
            self.source,
            self.target,
        )
    }

    /// Live effect points for the mastery spell's effect.
    #[must_use]
    pub fn points(&self, effect: u8) -> f64 {
        self.mastery_action
            .and_then(|action| self.program.damage.action_effect(action, effect))
            .map_or(0.0, |effect| {
                self.program
                    .damage
                    .live_effect_points_local(effect, self.mastery)
            })
    }

    /// `1 + live_effect_points / 100`.
    #[must_use]
    pub fn bonus(&self, effect: u8) -> f64 {
        1.0 + self.points(effect) / HUNDRED
    }

    /// Whether the hit's spell carries the given `SpellLabel` id.
    #[must_use]
    pub fn spell_has_label(&self, label: i32) -> bool {
        self.program
            .damage
            .action_at(self.spell_action)
            .labels
            .contains(&label)
    }

    /// Whether the hit's DBC school mask contains `school`.
    #[must_use]
    pub fn has_school(&self, school: DamageSchool) -> bool {
        let expected = SpellSchoolMask::from(school);

        self.program
            .damage
            .action_at(self.spell_action)
            .school_mask
            .contains(expected)
    }

    /// Is the hit's spell inside the mastery effect's affect list? `effect` is 1-based.
    #[must_use]
    pub fn affects_spell(&self, effect: u8) -> bool {
        self.mastery_action
            .and_then(|mastery| self.program.damage.action_effect(mastery, effect))
            .is_some_and(|source| {
                self.program
                    .damage
                    .effect_affects_action(source, self.spell_action)
            })
    }

    /// Whether a finalized authored effect's affect list includes this hit's action.
    #[must_use]
    pub fn effect_affects_spell(&self, effect: crate::DamageEffectId) -> bool {
        self.program
            .damage
            .effect_id_plan(effect)
            .is_some_and(|(source, _)| {
                self.program
                    .damage
                    .effect_affects_action(source, self.spell_action)
            })
    }

    /// [`Self::bonus`] only when the mastery effect's affect list includes this hit's spell.
    #[must_use]
    pub fn affected_spell_bonus(&self, effect: u8) -> f64 {
        if self.affects_spell(effect) {
            self.bonus(effect)
        } else {
            1.0
        }
    }

    /// [`Self::bonus`] for the first listed effect whose affect list includes this hit's spell.
    #[must_use]
    pub fn affected_bonus_any(&self, effects: &[u8]) -> f64 {
        effects
            .iter()
            .copied()
            .find(|&effect| self.affects_spell(effect))
            .map_or(1.0, |effect| self.bonus(effect))
    }

    /// Select the direct or periodic mastery effect list and apply the first matching bonus.
    #[must_use]
    pub fn direct_or_periodic_affected_bonus_any(
        &self,
        direct_effects: &[u8],
        periodic_effects: &[u8],
    ) -> f64 {
        if self.is_periodic {
            self.affected_bonus_any(periodic_effects)
        } else {
            self.affected_bonus_any(direct_effects)
        }
    }

    /// [`Self::bonus`] only when the hit is dealt by a pet, else `1.0`.
    #[must_use]
    pub fn pet_bonus(&self, effect: u8) -> f64 {
        if self.is_pet { self.bonus(effect) } else { 1.0 }
    }

    /// Exact target-health fraction (`1.0` = full) from canonical encounter state.
    #[must_use]
    pub fn target_health_pct(&self) -> f64 {
        self.target
            .and_then(|target| {
                self.instance
                    .enemy_health_fraction(self.program, target, self.now)
            })
            .unwrap_or(1.0)
    }

    /// Number of currently active temporary guardians.
    #[must_use]
    pub fn active_guardian_count(&self) -> usize {
        self.instance
            .runtime
            .companions
            .guardians
            .iter()
            .flatten()
            .count()
    }
}

pub type MasteryFn = fn(&MasteryCtx<'_>) -> f64;

/// Mastery that does not modify direct damage (proc- or pet-based); the mechanic lives elsewhere.
#[must_use]
pub const fn no_damage_bonus(_ctx: &MasteryCtx<'_>) -> f64 {
    1.0
}

/// Neutral `mastery_crit_damage` hook (no crit-damage bonus).
#[must_use]
pub const fn no_crit_damage(_ctx: &MasteryCtx<'_>) -> f64 {
    0.0
}