wowlab_engine_combat/state/program/

effects.rs

// #t(file: rust_duplicate_strings) finalization bound diagnostics deliberately share the same invariant wording across finalized plans.
// #t(file: rust_similar_fns) actor-range indexing intentionally mirrors dependency plans while retaining effect-specific element types.
// #t(file: rust_similar_structs) the effect plan and dependency plan keep separate typed flattened actor storage across ownership boundaries.
// #t(file: rust_unchecked_indexing) construction indexes only dense arrays whose coordinates were produced from those exact finalized registries.

//! Finalized buff-effect capabilities, positional masks, and relevant-effect lists.

#[cfg(feature = "rotation-optimizations")]
mod active_aura;
mod bindings;
mod families;

use std::ops::Range;

use wowlab_engine_domain::{
    dbc::{
        MechanicMask, ModifierPropertyKind, ResolvedGameDataSemanticExt as _,
        SpellAuraInterruptFlags,
    },
    rotation::AuraSlotHandle,
};
use wowlab_engine_gamedata::ResolvedGameData;
use wowlab_types::sim::{ActorId, AuraKey, PetIdx};

use self::{
    bindings::{ActionSpellModifierBindings, RelevantEffectList},
    families::{family_indexes, single_family_index},
};
use super::BufferBindings;
use crate::state::{
    AuraData, BuffEffect, EffectConsumer, EffectFamily, LocalAuraIdx, MAX_AURA_BUFF_EFFECTS,
    PassiveDriverEffect,
};

#[rustfmt::skip]
#[cfg(feature = "rotation-optimizations")]
pub(crate) use active_aura::{ActiveAuraBreakPlans, ActiveAuraEffectPlan};

const _: () = assert!(
    MAX_AURA_BUFF_EFFECTS <= u16::BITS as usize,
    "aura effect positions must fit in each u16 consumer mask"
);
const AURA_ORDER_LOCAL_SHIFT: u32 = 48;
const AURA_ORDER_BINDING_SHIFT: u32 = 8;

/// Positional effect masks for one finalized aura's fixed effect array.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) struct AuraEffectMasks {
    general_totals: u16,
    dynamic_totals: u16,
    spell_modifiers: u16,
    costs: u16,
    timing: u16,
    targeting: u16,
    gates: u16,
    recharge_charges: u16,
    stats: u16,
    speed_projection: u16,
    snapshot_totals: u16,
    player_scaling: u16,
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct PlannedAuraEffects {
    pub(crate) key: AuraKey,
    pub(crate) handle: AuraSlotHandle,
    pub(crate) local: LocalAuraIdx,
    pub(crate) static_totals_mask: u16,
    pub(crate) dynamic_totals_mask: u16,
    pub(crate) dispel_type: i32,
    pub(crate) dispel_resistance_flat: f64,
    pub(crate) dispel_resistance_multiplier: f64,
    pub(crate) mechanic_mask: MechanicMask,
    pub(crate) granted_aura_state: Option<crate::state::AuraState>,
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct PlannedAuraEffect {
    pub(crate) key: AuraKey,
    pub(crate) handle: AuraSlotHandle,
    pub(crate) local: LocalAuraIdx,
    pub(crate) position: u8,
    pub(crate) order: u64,
    families: EffectFamily,
}

#[derive(Debug)]
struct ActorRanges<T> {
    entries: Box<[T]>,
    player: Range<usize>,
    external: Range<usize>,
    pets: Box<[Range<usize>]>,
    enemies: Box<[Range<usize>]>,
}

impl<T> ActorRanges<T> {
    fn for_actor(&self, actor: ActorId) -> &[T] {
        let range = match actor {
            ActorId::Player => Some(self.player.clone()),
            ActorId::External => Some(self.external.clone()),
            ActorId::Pet(pet) => self.pets.get(pet.as_usize()).cloned(),
            ActorId::Enemy(enemy) => self.enemies.get(enemy.as_usize()).cloned(),
        };

        range.map_or(&[], |range| {
            // BOUNDS: every actor range is assembled from offsets into this exact flattened array.
            &self.entries[range]
        })
    }

    fn maximum_actor_len(&self) -> usize {
        std::iter::once(&self.player)
            .chain(std::iter::once(&self.external))
            .chain(self.pets.iter())
            .chain(self.enemies.iter())
            .map(Range::len)
            .max()
            .unwrap_or(0)
    }
}

impl<T> Default for ActorRanges<T> {
    fn default() -> Self {
        Self {
            entries: Box::default(),
            player: 0..0,
            external: 0..0,
            pets: Box::default(),
            enemies: Box::default(),
        }
    }
}

type ActorEffectRanges = ActorRanges<PlannedAuraEffects>;
type ActorExactEffectRanges = ActorRanges<PlannedAuraEffect>;

#[derive(Debug, Default)]
struct ActorEffectBindings {
    all: ActorEffectRanges,
    static_totals: ActorEffectRanges,
    dynamic_totals: ActorEffectRanges,
    by_family: Box<[ActorExactEffectRanges]>,
    action_break: ActorEffectRanges,
    periodic_damage_break: ActorEffectRanges,
    direct_damage_break: ActorEffectRanges,
    aura_state: ActorEffectRanges,
    shapeshift: ActorEffectRanges,
    dispellable: ActorEffectRanges,
    mechanic: ActorEffectRanges,
}

impl AuraEffectMasks {
    pub(crate) const fn totals_relevant(self) -> bool {
        self.general_totals != 0
    }

    pub(crate) const fn snapshot_totals_relevant(self) -> bool {
        self.snapshot_totals != 0
    }

    pub(crate) const fn player_scaling_relevant(self) -> bool {
        self.player_scaling != 0
    }

    #[cfg(test)]
    pub(super) const fn mask(self, class: EffectConsumerClass) -> u16 {
        match class {
            EffectConsumerClass::GeneralTotals => self.general_totals,
            EffectConsumerClass::DynamicTotals => self.dynamic_totals,
            EffectConsumerClass::SpellModifiers => self.spell_modifiers,
            EffectConsumerClass::Costs => self.costs,
            EffectConsumerClass::Timing => self.timing,
            EffectConsumerClass::Targeting => self.targeting,
            EffectConsumerClass::Gates => self.gates,
            EffectConsumerClass::RechargeCharges => self.recharge_charges,
            EffectConsumerClass::Stats => self.stats,
            EffectConsumerClass::SpeedProjection => self.speed_projection,
        }
    }

    fn insert(&mut self, position: usize, consumers: EffectConsumer) {
        let bit = 1_u16 << position;

        if consumers.contains(EffectConsumer::GENERAL_TOTALS) {
            self.general_totals |= bit;
        }

        if consumers.contains(EffectConsumer::DYNAMIC_TOTALS) {
            self.dynamic_totals |= bit;
        }

        if consumers.contains(EffectConsumer::SPELL_MODIFIERS) {
            self.spell_modifiers |= bit;
        }

        if consumers.contains(EffectConsumer::COSTS) {
            self.costs |= bit;
        }

        if consumers.contains(EffectConsumer::TIMING) {
            self.timing |= bit;
        }

        if consumers.contains(EffectConsumer::TARGETING) {
            self.targeting |= bit;
        }

        if consumers.contains(EffectConsumer::GATES) {
            self.gates |= bit;
        }

        if consumers.contains(EffectConsumer::RECHARGE_CHARGES) {
            self.recharge_charges |= bit;
        }

        if consumers.contains(EffectConsumer::STATS) {
            self.stats |= bit;
        }

        if consumers.contains(EffectConsumer::SPEED_PROJECTION) {
            self.speed_projection |= bit;
        }

        if consumers.contains(EffectConsumer::SNAPSHOT_TOTALS) {
            self.snapshot_totals |= bit;
        }
    }

    fn insert_player_scaling(&mut self, position: usize, effect: &BuffEffect) {
        if matches!(
            effect,
            BuffEffect::Haste(..)
                | BuffEffect::HasteMult(..)
                | BuffEffect::HasteMultFromEffect { .. }
                | BuffEffect::SpellCastSpeed(..)
                | BuffEffect::AttackSpeed(..)
                | BuffEffect::Crit(..)
                | BuffEffect::CritFromEffect { .. }
                | BuffEffect::CritActive(..)
        ) {
            self.player_scaling |= 1_u16 << position;
        }
    }

    const fn mask_for_build(self, class: EffectConsumerClass) -> u16 {
        match class {
            EffectConsumerClass::GeneralTotals => self.general_totals,
            EffectConsumerClass::DynamicTotals => self.dynamic_totals,
            EffectConsumerClass::SpellModifiers => self.spell_modifiers,
            EffectConsumerClass::Costs => self.costs,
            EffectConsumerClass::Timing => self.timing,
            EffectConsumerClass::Targeting => self.targeting,
            EffectConsumerClass::Gates => self.gates,
            EffectConsumerClass::RechargeCharges => self.recharge_charges,
            EffectConsumerClass::Stats => self.stats,
            EffectConsumerClass::SpeedProjection => self.speed_projection,
        }
    }
}

const EFFECT_CONSUMER_CLASS_COUNT: usize = 10;
const EFFECT_FAMILY_COUNT: usize = 85;
const MODIFIER_PROPERTY_SLOT_COUNT: usize = ModifierPropertyKind::MaxTargets as usize + 1;
const FIXED_ACTOR_BUCKET_COUNT: usize = 2;
const PLAYER_BUCKET: usize = 0;
const EXTERNAL_BUCKET: usize = 1;
const PET_BUCKETS_START: usize = FIXED_ACTOR_BUCKET_COUNT;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub(crate) enum EffectConsumerClass {
    GeneralTotals,
    DynamicTotals,
    SpellModifiers,
    Costs,
    Timing,
    Targeting,
    Gates,
    RechargeCharges,
    Stats,
    SpeedProjection,
}

impl EffectConsumerClass {
    const ALL: [Self; EFFECT_CONSUMER_CLASS_COUNT] = [
        Self::GeneralTotals,
        Self::DynamicTotals,
        Self::SpellModifiers,
        Self::Costs,
        Self::Timing,
        Self::Targeting,
        Self::Gates,
        Self::RechargeCharges,
        Self::Stats,
        Self::SpeedProjection,
    ];

    const fn consumer(self) -> EffectConsumer {
        match self {
            Self::GeneralTotals => EffectConsumer::GENERAL_TOTALS,
            Self::DynamicTotals => EffectConsumer::DYNAMIC_TOTALS,
            Self::SpellModifiers => EffectConsumer::SPELL_MODIFIERS,
            Self::Costs => EffectConsumer::COSTS,
            Self::Timing => EffectConsumer::TIMING,
            Self::Targeting => EffectConsumer::TARGETING,
            Self::Gates => EffectConsumer::GATES,
            Self::RechargeCharges => EffectConsumer::RECHARGE_CHARGES,
            Self::Stats => EffectConsumer::STATS,
            Self::SpeedProjection => EffectConsumer::SPEED_PROJECTION,
        }
    }

    const fn index(self) -> usize {
        self as usize
    }
}

#[derive(Debug)]
pub(crate) struct EffectPlan {
    global_capabilities: EffectFamily,
    aura_masks: Box<[AuraEffectMasks]>,
    #[cfg(feature = "rotation-optimizations")]
    static_total_auras: ActiveAuraEffectPlan,
    #[cfg(feature = "rotation-optimizations")]
    dynamic_total_auras: ActiveAuraEffectPlan,
    #[cfg(feature = "rotation-optimizations")]
    break_auras: ActiveAuraBreakPlans,
    #[cfg(feature = "rotation-optimizations")]
    family_auras: Box<[ActiveAuraEffectPlan]>,
    relevant: [RelevantEffectList; EFFECT_CONSUMER_CLASS_COUNT],
    passive_by_family: Box<[Box<[usize]>]>,
    owner_duplicates: Box<[Box<[AuraSlotHandle]>]>,
    actor_bindings: ActorEffectBindings,
    action_spell_modifiers: ActionSpellModifierBindings,
}

impl EffectPlan {
    // #t(fn: rust_padding) rustfmt keeps the first inherent method adjacent to the impl opening.
    pub(crate) fn compile(auras: &[AuraData], passive_drivers: &[PassiveDriverEffect]) -> Self {
        let mut global_capabilities = EffectFamily::empty();
        let mut aura_masks = Vec::with_capacity(auras.len());
        #[cfg(feature = "rotation-optimizations")]
        let mut family_effect_masks = vec![vec![0_u16; auras.len()]; EFFECT_FAMILY_COUNT];
        let mut relevant_auras: [Vec<LocalAuraIdx>; EFFECT_CONSUMER_CLASS_COUNT] =
            std::array::from_fn(|_| Vec::new());
        let mut relevant_passives: [Vec<usize>; EFFECT_CONSUMER_CLASS_COUNT] =
            std::array::from_fn(|_| Vec::new());
        let mut passive_by_family = vec![Vec::new(); EFFECT_FAMILY_COUNT];

        for (raw_local, aura) in auras.iter().enumerate() {
            let local = LocalAuraIdx::new(
                u8::try_from(raw_local).expect("finalized aura count is validated below 256"),
            );
            let mut masks = AuraEffectMasks::default();

            for (position, effect) in aura.effects.iter().enumerate() {
                let Some(effect) = effect else {
                    continue;
                };
                let classification = effect.classification();

                global_capabilities |= classification.families();
                masks.insert(position, classification.consumers());
                masks.insert_player_scaling(position, effect);

                #[cfg(feature = "rotation-optimizations")]
                for family_index in family_indexes(classification.families()) {
                    family_effect_masks[family_index][raw_local] |= 1_u16 << position;
                }
            }

            for class in EffectConsumerClass::ALL {
                if masks.mask_for_build(class) != 0 {
                    // BOUNDS: EffectConsumerClass discriminants index the same fixed-count array.
                    relevant_auras[class.index()].push(local);
                }
            }

            aura_masks.push(masks);
        }

        for (index, driver) in passive_drivers.iter().enumerate() {
            let classification = driver.effect.classification();

            global_capabilities |= classification.families();

            for class in EffectConsumerClass::ALL {
                if classification.consumers().contains(class.consumer()) {
                    // BOUNDS: EffectConsumerClass discriminants index the same fixed-count array.
                    relevant_passives[class.index()].push(index);
                }
            }

            for family_index in family_indexes(classification.families()) {
                // BOUNDS: family_indexes yields only finalized EffectFamily bit positions.
                passive_by_family[family_index].push(index);
            }
        }

        let relevant = std::array::from_fn(|index| {
            // BOUNDS: from_fn supplies indexes within both same-length fixed-count arrays.
            let aura_locals = std::mem::take(&mut relevant_auras[index]).into_boxed_slice();
            let passive_driver_indexes = {
                // BOUNDS: from_fn supplies indexes within both same-length fixed-count arrays.
                std::mem::take(&mut relevant_passives[index]).into_boxed_slice()
            };

            RelevantEffectList {
                aura_locals,
                passive_driver_indexes,
            }
        });

        #[cfg(feature = "rotation-optimizations")]
        let static_total_auras = ActiveAuraEffectPlan::from_masks(
            aura_masks
                .iter()
                .map(|masks| masks.general_totals & !masks.dynamic_totals)
                .collect(),
        );
        #[cfg(feature = "rotation-optimizations")]
        let dynamic_total_auras = ActiveAuraEffectPlan::from_masks(
            aura_masks
                .iter()
                .map(|masks| masks.dynamic_totals)
                .collect(),
        );
        #[cfg(feature = "rotation-optimizations")]
        let break_auras = ActiveAuraBreakPlans::compile(auras);

        Self {
            global_capabilities,
            aura_masks: aura_masks.into_boxed_slice(),
            #[cfg(feature = "rotation-optimizations")]
            static_total_auras,
            #[cfg(feature = "rotation-optimizations")]
            dynamic_total_auras,
            #[cfg(feature = "rotation-optimizations")]
            break_auras,
            #[cfg(feature = "rotation-optimizations")]
            family_auras: family_effect_masks
                .into_iter()
                .map(ActiveAuraEffectPlan::from_masks)
                .collect(),
            relevant,
            passive_by_family: passive_by_family
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            owner_duplicates: (0..auras.len())
                .map(|_| Vec::new().into_boxed_slice())
                .collect(),
            actor_bindings: ActorEffectBindings {
                by_family: (0..EFFECT_FAMILY_COUNT)
                    .map(|_| ActorExactEffectRanges::default())
                    .collect(),
                ..ActorEffectBindings::default()
            },
            action_spell_modifiers: ActionSpellModifierBindings::default(),
        }
    }

    // #t(fn: rust_max_fn_lines) one cold transaction assembles all exact concrete aura/effect consumer slices from the same stable binding order.
    pub(crate) fn bind_aura_slots(
        &mut self,
        bindings: &BufferBindings,
        auras: &[AuraData],
        data: &ResolvedGameData,
        enemy_count: usize,
    ) {
        let bucket_count = FIXED_ACTOR_BUCKET_COUNT + PetIdx::MAX + enemy_count;
        let mut buckets = vec![Vec::new(); bucket_count];
        let mut family_buckets = vec![vec![Vec::new(); bucket_count]; EFFECT_FAMILY_COUNT];

        for (raw_local, aura) in auras.iter().enumerate() {
            let local = LocalAuraIdx::new(
                u8::try_from(raw_local).expect("finalized aura count is validated below 256"),
            );
            let masks = self.aura(local);

            for binding in bindings.aura_bindings() {
                if binding.local != local {
                    continue;
                }

                let key = binding.key;
                let handle = binding.handle;
                let spell = wowlab_types::sim::SpellIdx::from_raw(aura.aura_id);
                let props = data.spell_props_for_damage_plan(spell);

                let Some(bucket) = actor_bucket(key.affected(), enemy_count) else {
                    continue;
                };

                // BOUNDS: actor_bucket validates every returned index against bucket_count.

                buckets[bucket].push(PlannedAuraEffects {
                    key,
                    handle,
                    local,
                    static_totals_mask: masks.general_totals & !masks.dynamic_totals,
                    dynamic_totals_mask: masks.dynamic_totals,
                    dispel_type: props.dispel_type,
                    dispel_resistance_flat: props.dispel_resistance_flat,
                    dispel_resistance_multiplier: props.dispel_resistance_multiplier,
                    mechanic_mask: data.all_effect_mechanic_mask(spell),
                    granted_aura_state: aura.granted_aura_state,
                });

                for (position, effect) in aura.effects.iter().enumerate() {
                    let Some(effect) = effect else {
                        continue;
                    };
                    let effect_families = effect.classification().families();
                    let planned = PlannedAuraEffect {
                        key,
                        handle,
                        local,
                        position: u8::try_from(position)
                            .expect("fixed aura effect positions fit in u8"),
                        order: (u64::from(local.raw()) << AURA_ORDER_LOCAL_SHIFT)
                            | (u64::try_from(binding.index().as_usize())
                                .expect("binding ordinal fits in u64")
                                << AURA_ORDER_BINDING_SHIFT)
                            | u64::try_from(position).expect("effect position fits in u64"),
                        families: effect_families,
                    };

                    for family_index in family_indexes(effect_families) {
                        // BOUNDS: family_indexes and actor_bucket both validate their dimensions.
                        family_buckets[family_index][bucket].push(planned);
                    }
                }
            }
        }

        let static_totals = buckets
            .iter()
            .map(|bucket| {
                bucket
                    .iter()
                    .copied()
                    .filter(|entry| entry.static_totals_mask != 0)
                    .collect()
            })
            .collect();
        let dynamic_totals = buckets
            .iter()
            .map(|bucket| {
                bucket
                    .iter()
                    .copied()
                    .filter(|entry| entry.dynamic_totals_mask != 0)
                    .collect()
            })
            .collect();
        let select = |predicate: fn(&PlannedAuraEffects, &AuraData) -> bool| {
            buckets
                .iter()
                .map(|bucket| {
                    bucket
                        .iter()
                        .copied()
                        .filter(|entry| predicate(entry, finalized_aura(auras, entry.local)))
                        .collect::<Vec<_>>()
                })
                .collect::<Vec<_>>()
        };
        let action_break = select(|_, aura| {
            aura.interrupt_flags
                .contains(SpellAuraInterruptFlags::ACTION)
        });
        let periodic_damage_break = select(|_, aura| {
            aura.interrupt_flags
                .contains(SpellAuraInterruptFlags::DAMAGE)
        });
        let direct_damage_break = select(|_, aura| {
            aura.interrupt_flags.intersects(
                SpellAuraInterruptFlags::DAMAGE | SpellAuraInterruptFlags::NON_PERIODIC_DAMAGE,
            )
        });
        let mut aura_state = select(|_, aura| aura.granted_aura_state.is_some());

        for bucket in &mut aura_state {
            bucket.sort_unstable_by_key(|entry| {
                entry.granted_aura_state.map_or(0, |state| state as i32)
            });
        }

        let shapeshift = select(|_, aura| aura.shapeshift_form > 0);
        let mut dispellable = select(|entry, _| entry.dispel_type != 0);

        for bucket in &mut dispellable {
            bucket.sort_unstable_by_key(|entry| entry.dispel_type);
        }

        let mechanic = select(|entry, _| !entry.mechanic_mask.is_empty());

        self.owner_duplicates = (0..auras.len())
            .map(|raw_local| {
                let local = local_aura(raw_local);

                bindings
                    .aura_bindings()
                    .filter(|binding| {
                        binding.local == local && binding.key.affected() == ActorId::Player
                    })
                    .map(|binding| binding.handle)
                    .collect::<Vec<_>>()
                    .into_boxed_slice()
            })
            .collect();

        self.actor_bindings = ActorEffectBindings {
            all: flatten_actor_buckets(buckets),
            static_totals: flatten_actor_buckets(static_totals),
            dynamic_totals: flatten_actor_buckets(dynamic_totals),
            by_family: family_buckets
                .into_iter()
                .map(flatten_actor_buckets)
                .collect(),
            action_break: flatten_actor_buckets(action_break),
            periodic_damage_break: flatten_actor_buckets(periodic_damage_break),
            direct_damage_break: flatten_actor_buckets(direct_damage_break),
            aura_state: flatten_actor_buckets(aura_state),
            shapeshift: flatten_actor_buckets(shapeshift),
            dispellable: flatten_actor_buckets(dispellable),
            mechanic: flatten_actor_buckets(mechanic),
        };
    }

    /// Prebind each affected-spell property to entries that can modify that damage action.
    // #t(fn: rust_cyclomatic_complexity) cold finalization transaction explicitly binds each runtime consumer category.
    // #t(fn: rust_max_fn_lines) keeping the binding categories together preserves one auditable immutable-plan assembly boundary.
    pub(crate) fn bind_spell_modifier_actions(
        &mut self,
        damage: &super::DamagePlan,
        auras: &[AuraData],
        passive_drivers: &[PassiveDriverEffect],
    ) {
        let action_count = damage.action_locals().count();
        let binding_count = action_count.saturating_mul(MODIFIER_PROPERTY_SLOT_COUNT);
        let mut passive_indexes = vec![Vec::new(); binding_count];
        let mut player_auras = vec![Vec::new(); binding_count];
        let mut scoped_passive_indexes = vec![Vec::new(); action_count];
        let mut damage_passive_indexes = vec![Vec::new(); action_count];
        let mut cost_passive_indexes = vec![Vec::new(); action_count];

        for &passive_index in self.passive_family_indexes(EffectFamily::SPELL_MODIFIER) {
            let effect = &passive_drivers[passive_index].effect;
            let binding = damage
                .passive_buff_binding(passive_index)
                .expect("every finalized passive effect has a damage binding record");

            for action in damage.action_locals() {
                if spell_scoped_effect_applies_to_action(effect, binding, action, damage) {
                    scoped_passive_indexes[action.index()].push(passive_index);
                }

                if damage_scoped_effect_applies_to_action(effect, binding, action, damage) {
                    damage_passive_indexes[action.index()].push(passive_index);
                }

                if let Some(property) = action_modifier_property(effect)
                    && binding
                        .source_effect
                        .is_some_and(|source| damage.effect_affects_action(source, action))
                {
                    passive_indexes[spell_modifier_binding_index(action, property)]
                        .push(passive_index);
                }
            }
        }

        for family in [EffectFamily::CAST_TIME, EffectFamily::GLOBAL_COOLDOWN] {
            for &passive_index in self.passive_family_indexes(family) {
                let effect = &passive_drivers[passive_index].effect;
                let Some(property) = configured_timing_property(effect) else {
                    continue;
                };
                let binding = damage
                    .passive_buff_binding(passive_index)
                    .expect("every finalized passive effect has a damage binding record");

                for action in damage.action_locals() {
                    if binding.lists_action(action) {
                        passive_indexes[spell_modifier_binding_index(action, property)]
                            .push(passive_index);
                    }
                }
            }
        }

        for family in [
            EffectFamily::COOLDOWN_RECHARGE_RATE,
            EffectFamily::COOLDOWN_DURATION,
        ] {
            for &passive_index in self.passive_family_indexes(family) {
                let effect = &passive_drivers[passive_index].effect;
                let binding = damage
                    .passive_buff_binding(passive_index)
                    .expect("every finalized passive effect has a damage binding record");

                for action in damage.action_locals() {
                    if cooldown_effect_applies_to_action(effect, binding, action, damage) {
                        passive_indexes
                            [spell_modifier_binding_index(action, ModifierPropertyKind::Cooldown)]
                        .push(passive_index);
                    }
                }
            }
        }

        for &passive_index in self.passive_family_indexes(EffectFamily::RESOURCE_COST) {
            let effect = &passive_drivers[passive_index].effect;
            let binding = damage
                .passive_buff_binding(passive_index)
                .expect("every finalized passive effect has a damage binding record");

            for action in damage.action_locals() {
                if cost_effect_applies_to_action(effect, binding, action, damage) {
                    cost_passive_indexes[action.index()].push(passive_index);
                }
            }
        }

        let player_entries = self
            .actor_family_effects(ActorId::Player, EffectFamily::SPELL_MODIFIER)
            .to_vec();

        for entry in player_entries {
            let Some(effect) = auras
                .get(entry.local.as_usize())
                .and_then(|aura| aura.effects.get(usize::from(entry.position)))
                .and_then(Option::as_ref)
            else {
                continue;
            };
            let binding = damage
                .aura_buff_binding(entry.local, entry.position)
                .expect("every finalized aura effect has a damage binding record");

            for action in damage.action_locals() {
                if let Some(property) = action_modifier_property(effect)
                    && binding
                        .source_effect
                        .is_some_and(|source| damage.effect_affects_action(source, action))
                {
                    player_auras[spell_modifier_binding_index(action, property)].push(entry);
                }
            }
        }

        for family in [EffectFamily::CAST_TIME, EffectFamily::GLOBAL_COOLDOWN] {
            let player_entries = self.actor_family_effects(ActorId::Player, family).to_vec();

            for entry in player_entries {
                let Some(effect) = auras
                    .get(entry.local.as_usize())
                    .and_then(|aura| aura.effects.get(usize::from(entry.position)))
                    .and_then(Option::as_ref)
                else {
                    continue;
                };
                let Some(property) = configured_timing_property(effect) else {
                    continue;
                };
                let binding = damage
                    .aura_buff_binding(entry.local, entry.position)
                    .expect("every finalized aura effect has a damage binding record");

                for action in damage.action_locals() {
                    if binding.lists_action(action) {
                        player_auras[spell_modifier_binding_index(action, property)].push(entry);
                    }
                }
            }
        }

        for family in [
            EffectFamily::COOLDOWN_RECHARGE_RATE,
            EffectFamily::COOLDOWN_DURATION,
        ] {
            let player_entries = self.actor_family_effects(ActorId::Player, family).to_vec();

            for entry in player_entries {
                let effect = auras[entry.local.as_usize()].effects[usize::from(entry.position)]
                    .as_ref()
                    .expect("planned effect position remains occupied after finalization");
                let binding = damage
                    .aura_buff_binding(entry.local, entry.position)
                    .expect("every finalized aura effect has a damage binding record");

                for action in damage.action_locals() {
                    if cooldown_effect_applies_to_action(effect, binding, action, damage) {
                        player_auras
                            [spell_modifier_binding_index(action, ModifierPropertyKind::Cooldown)]
                        .push(entry);
                    }
                }
            }
        }

        let scoped_source = self
            .actor_bindings
            .by_family
            .get(
                single_family_index(EffectFamily::SPELL_MODIFIER)
                    .expect("spell modifiers occupy one finalized family"),
            )
            .expect("spell-modifier actor bindings are finalized");
        let mut scoped_actor_auras = Vec::with_capacity(action_count);
        let mut damage_actor_auras = Vec::with_capacity(action_count);
        let cost_source = self
            .actor_bindings
            .by_family
            .get(
                single_family_index(EffectFamily::RESOURCE_COST)
                    .expect("resource costs occupy one finalized family"),
            )
            .expect("resource-cost actor bindings are finalized");
        let mut cost_actor_auras = Vec::with_capacity(action_count);

        for action in damage.action_locals() {
            scoped_actor_auras.push(filter_actor_ranges(scoped_source, |entry| {
                let effect = auras[entry.local.as_usize()].effects[usize::from(entry.position)]
                    .as_ref()
                    .expect("planned effect position remains occupied after finalization");
                let binding = damage
                    .aura_buff_binding(entry.local, entry.position)
                    .expect("every finalized aura effect has a damage binding record");

                spell_scoped_effect_applies_to_action(effect, binding, action, damage)
            }));
            damage_actor_auras.push(filter_actor_ranges(scoped_source, |entry| {
                let effect = auras[entry.local.as_usize()].effects[usize::from(entry.position)]
                    .as_ref()
                    .expect("planned effect position remains occupied after finalization");
                let binding = damage
                    .aura_buff_binding(entry.local, entry.position)
                    .expect("every finalized aura effect has a damage binding record");

                damage_scoped_effect_applies_to_action(effect, binding, action, damage)
            }));
            cost_actor_auras.push(filter_actor_ranges(cost_source, |entry| {
                let effect = auras[entry.local.as_usize()].effects[usize::from(entry.position)]
                    .as_ref()
                    .expect("planned effect position remains occupied after finalization");
                let binding = damage
                    .aura_buff_binding(entry.local, entry.position)
                    .expect("every finalized aura effect has a damage binding record");

                cost_effect_applies_to_action(effect, binding, action, damage)
            }));
        }

        self.action_spell_modifiers = ActionSpellModifierBindings {
            passive_indexes: passive_indexes
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            #[cfg(feature = "rotation-optimizations")]
            player_aura_plans: player_auras
                .into_iter()
                .map(|entries| ActiveAuraEffectPlan::compile(&entries, auras.len()))
                .collect(),
            #[cfg(not(feature = "rotation-optimizations"))]
            player_auras: player_auras
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            scoped_passive_indexes: scoped_passive_indexes
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            #[cfg(feature = "rotation-optimizations")]
            scoped_aura_plans: scoped_actor_auras
                .iter()
                .map(|ranges| ActiveAuraEffectPlan::compile(&ranges.entries, auras.len()))
                .collect(),
            #[cfg(not(feature = "rotation-optimizations"))]
            scoped_actor_auras: scoped_actor_auras.into_boxed_slice(),
            damage_passive_indexes: damage_passive_indexes
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            #[cfg(feature = "rotation-optimizations")]
            damage_aura_plans: damage_actor_auras
                .iter()
                .map(|ranges| ActiveAuraEffectPlan::compile(&ranges.entries, auras.len()))
                .collect(),
            #[cfg(not(feature = "rotation-optimizations"))]
            damage_actor_auras: damage_actor_auras.into_boxed_slice(),
            cost_passive_indexes: cost_passive_indexes
                .into_iter()
                .map(Vec::into_boxed_slice)
                .collect(),
            #[cfg(feature = "rotation-optimizations")]
            cost_aura_plans: cost_actor_auras
                .iter()
                .map(|ranges| ActiveAuraEffectPlan::compile(&ranges.entries, auras.len()))
                .collect(),
            #[cfg(not(feature = "rotation-optimizations"))]
            cost_actor_auras: cost_actor_auras.into_boxed_slice(),
        };
    }

    /// Complete concrete aura-slot traversal reserved for reset/despawn lifecycle work.
    #[cfg(any(test, not(feature = "rotation-optimizations")))]
    pub(crate) fn lifecycle_actor_auras(&self, actor: ActorId) -> &[PlannedAuraEffects] {
        self.actor_bindings.all.for_actor(actor)
    }

    pub(crate) fn actor_family_effects(
        &self,
        actor: ActorId,
        family: EffectFamily,
    ) -> &[PlannedAuraEffect] {
        let Some(index) = single_family_index(family) else {
            return &[];
        };

        // BOUNDS: single_family_index validates the finalized family dimension.

        self.actor_bindings.by_family[index].for_actor(actor)
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) fn family_aura_plan(&self, family: EffectFamily) -> &ActiveAuraEffectPlan {
        let index = single_family_index(family).expect("effect family plan requires one family");

        &self.family_auras[index]
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) const fn static_total_aura_plan(&self) -> &ActiveAuraEffectPlan {
        &self.static_total_auras
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) const fn dynamic_total_aura_plan(&self) -> &ActiveAuraEffectPlan {
        &self.dynamic_total_auras
    }

    pub(crate) fn passive_family_indexes(&self, family: EffectFamily) -> &[usize] {
        single_family_index(family).map_or(&[], |index| {
            // BOUNDS: single_family_index validates the finalized family dimension.
            &self.passive_by_family[index]
        })
    }

    pub(crate) fn health_threshold_capacity(&self) -> usize {
        let index = single_family_index(EffectFamily::HEALTH_THRESHOLD_TRIGGER)
            .expect("health thresholds occupy one finalized family");
        let auras = &self.actor_bindings.by_family[index];
        let player = auras.for_actor(ActorId::Player).len().saturating_add(
            self.passive_family_indexes(EffectFamily::HEALTH_THRESHOLD_TRIGGER)
                .len(),
        );

        auras.maximum_actor_len().max(player)
    }

    pub(crate) fn spell_modifier_passive_indexes(
        &self,
        action: super::LocalDamageActionIdx,
        property: ModifierPropertyKind,
    ) -> &[usize] {
        self.action_spell_modifiers
            .passive_indexes
            .get(spell_modifier_binding_index(action, property))
            .map_or(&[], Box::as_ref)
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) fn spell_modifier_player_aura_plan(
        &self,
        action: super::LocalDamageActionIdx,
        property: ModifierPropertyKind,
    ) -> &ActiveAuraEffectPlan {
        self.action_spell_modifiers
            .player_aura_plans
            .get(spell_modifier_binding_index(action, property))
            .expect("finalized action/property has an active-aura effect plan")
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn spell_modifier_player_auras(
        &self,
        action: super::LocalDamageActionIdx,
        property: ModifierPropertyKind,
    ) -> &[PlannedAuraEffect] {
        self.action_spell_modifiers
            .player_auras
            .get(spell_modifier_binding_index(action, property))
            .map_or(&[], Box::as_ref)
    }

    pub(crate) fn scoped_spell_modifier_passive_indexes(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &[usize] {
        self.action_spell_modifiers
            .scoped_passive_indexes
            .get(action.index())
            .map_or(&[], Box::as_ref)
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) fn scoped_spell_modifier_aura_plan(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &ActiveAuraEffectPlan {
        self.action_spell_modifiers
            .scoped_aura_plans
            .get(action.index())
            .expect("finalized action has a scoped active-aura effect plan")
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn scoped_spell_modifier_actor_auras(
        &self,
        actor: ActorId,
        action: super::LocalDamageActionIdx,
    ) -> &[PlannedAuraEffect] {
        self.action_spell_modifiers
            .scoped_actor_auras
            .get(action.index())
            .map_or(&[], |ranges| ranges.for_actor(actor))
    }

    pub(crate) fn damage_spell_modifier_passive_indexes(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &[usize] {
        self.action_spell_modifiers
            .damage_passive_indexes
            .get(action.index())
            .map_or(&[], Box::as_ref)
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) fn damage_spell_modifier_aura_plan(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &ActiveAuraEffectPlan {
        self.action_spell_modifiers
            .damage_aura_plans
            .get(action.index())
            .expect("finalized action has a damage active-aura effect plan")
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn damage_spell_modifier_actor_auras(
        &self,
        actor: ActorId,
        action: super::LocalDamageActionIdx,
    ) -> &[PlannedAuraEffect] {
        self.action_spell_modifiers
            .damage_actor_auras
            .get(action.index())
            .map_or(&[], |ranges| ranges.for_actor(actor))
    }

    pub(crate) fn cost_modifier_passive_indexes(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &[usize] {
        self.action_spell_modifiers
            .cost_passive_indexes
            .get(action.index())
            .map_or(&[], Box::as_ref)
    }

    #[cfg(feature = "rotation-optimizations")]
    pub(crate) fn cost_modifier_aura_plan(
        &self,
        action: super::LocalDamageActionIdx,
    ) -> &ActiveAuraEffectPlan {
        self.action_spell_modifiers
            .cost_aura_plans
            .get(action.index())
            .expect("finalized action has a cost active-aura effect plan")
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn cost_modifier_actor_auras(
        &self,
        actor: ActorId,
        action: super::LocalDamageActionIdx,
    ) -> &[PlannedAuraEffect] {
        self.action_spell_modifiers
            .cost_actor_auras
            .get(action.index())
            .map_or(&[], |ranges| ranges.for_actor(actor))
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn action_break_auras(&self, actor: ActorId) -> &[PlannedAuraEffects] {
        self.actor_bindings.action_break.for_actor(actor)
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn damage_break_auras(
        &self,
        actor: ActorId,
        periodic: bool,
    ) -> &[PlannedAuraEffects] {
        if periodic {
            self.actor_bindings.periodic_damage_break.for_actor(actor)
        } else {
            self.actor_bindings.direct_damage_break.for_actor(actor)
        }
    }

    pub(crate) fn aura_state_auras(
        &self,
        actor: ActorId,
        required: crate::state::AuraState,
    ) -> &[PlannedAuraEffects] {
        let entries = self.actor_bindings.aura_state.for_actor(actor);
        let raw = required as i32;
        let state = |entry: &PlannedAuraEffects| {
            entry
                .granted_aura_state
                .map_or(0, |candidate| candidate as i32)
        };
        let start = entries.partition_point(|entry| state(entry) < raw);
        let end = entries.partition_point(|entry| state(entry) <= raw);

        // BOUNDS: both partition points were computed from this exact sorted actor slice.

        &entries[start..end]
    }

    pub(crate) fn shapeshift_auras(&self) -> &[PlannedAuraEffects] {
        self.actor_bindings.shapeshift.for_actor(ActorId::Player)
    }

    pub(crate) fn dispellable_auras(
        &self,
        actor: ActorId,
        dispel_type: i32,
    ) -> &[PlannedAuraEffects] {
        let entries = self.actor_bindings.dispellable.for_actor(actor);
        let start = entries.partition_point(|entry| entry.dispel_type < dispel_type);
        let end = entries.partition_point(|entry| entry.dispel_type <= dispel_type);

        // BOUNDS: both partition points were computed from this exact sorted actor slice.

        &entries[start..end]
    }

    pub(crate) fn mechanic_auras(&self, actor: ActorId) -> &[PlannedAuraEffects] {
        self.actor_bindings.mechanic.for_actor(actor)
    }

    pub(crate) fn owner_duplicate_handles(&self, local: LocalAuraIdx) -> &[AuraSlotHandle] {
        self.owner_duplicates
            .get(local.as_usize())
            .map_or(&[], Box::as_ref)
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn static_total_actor_effects(&self, actor: ActorId) -> &[PlannedAuraEffects] {
        self.actor_bindings.static_totals.for_actor(actor)
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    pub(crate) fn dynamic_total_actor_effects(&self, actor: ActorId) -> &[PlannedAuraEffects] {
        self.actor_bindings.dynamic_totals.for_actor(actor)
    }

    pub(crate) fn passive_driver_indexes(&self, class: EffectConsumerClass) -> &[usize] {
        &self.relevant(class).passive_driver_indexes
    }

    pub(crate) fn static_total_passive_driver_indexes(&self) -> &[usize] {
        self.passive_driver_indexes(EffectConsumerClass::GeneralTotals)
    }

    pub(crate) fn dynamic_total_passive_driver_indexes(&self) -> &[usize] {
        self.passive_driver_indexes(EffectConsumerClass::DynamicTotals)
    }

    pub(crate) fn aura(&self, local: LocalAuraIdx) -> AuraEffectMasks {
        // BOUNDS: local aura indices and this plan are produced from the same finalized slice.
        self.aura_masks[local.as_usize()]
    }

    pub(crate) const fn global_capabilities(&self) -> EffectFamily {
        self.global_capabilities
    }

    pub(crate) fn validate(&self, aura_count: usize, passive_count: usize) -> bool {
        self.aura_masks.len() == aura_count
            && self.owner_duplicates.len() == aura_count
            && self.optimized_plans_valid(aura_count, passive_count)
            && self.actor_bindings.by_family.len() == EFFECT_FAMILY_COUNT
            && self.actor_bindings.by_family.iter().all(|ranges| {
                ranges.entries.iter().all(|entry| {
                    entry.local.as_usize() < aura_count
                        && usize::from(entry.position) < MAX_AURA_BUFF_EFFECTS
                })
            })
            && [
                &self.actor_bindings.all,
                &self.actor_bindings.static_totals,
                &self.actor_bindings.dynamic_totals,
                &self.actor_bindings.action_break,
                &self.actor_bindings.periodic_damage_break,
                &self.actor_bindings.direct_damage_break,
                &self.actor_bindings.aura_state,
                &self.actor_bindings.shapeshift,
                &self.actor_bindings.dispellable,
                &self.actor_bindings.mechanic,
            ]
            .into_iter()
            .all(|ranges| {
                ranges
                    .entries
                    .iter()
                    .all(|entry| entry.local.as_usize() < aura_count)
            })
            && EffectConsumerClass::ALL.into_iter().all(|class| {
                let relevant = self.relevant(class);

                relevant
                    .aura_locals
                    .iter()
                    .all(|local| local.as_usize() < aura_count)
                    && relevant
                        .passive_driver_indexes
                        .iter()
                        .all(|index| *index < passive_count)
            })
            && self.passive_by_family.len() == EFFECT_FAMILY_COUNT
            && self
                .passive_by_family
                .iter()
                .flatten()
                .all(|index| *index < passive_count)
    }

    #[cfg(test)]
    pub(super) fn relevant_auras(&self, class: EffectConsumerClass) -> &[LocalAuraIdx] {
        &self.relevant(class).aura_locals
    }

    #[cfg(test)]
    pub(super) fn relevant_passives(&self, class: EffectConsumerClass) -> &[usize] {
        &self.relevant(class).passive_driver_indexes
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    #[expect(
        clippy::unused_self,
        reason = "feature variants share one validation API"
    )]
    const fn optimized_plans_valid(&self, _aura_count: usize, _passive_count: usize) -> bool {
        true
    }

    fn relevant(&self, class: EffectConsumerClass) -> &RelevantEffectList {
        // BOUNDS: EffectConsumerClass has exactly EFFECT_CONSUMER_CLASS_COUNT variants.
        &self.relevant[class.index()]
    }
}

fn spell_modifier_binding_index(
    action: super::LocalDamageActionIdx,
    property: ModifierPropertyKind,
) -> usize {
    action
        .index()
        .saturating_mul(MODIFIER_PROPERTY_SLOT_COUNT)
        .saturating_add(property as usize)
}

fn action_modifier_property(effect: &BuffEffect) -> Option<ModifierPropertyKind> {
    match effect {
        BuffEffect::SpellModifierFromEffect { property, .. }
        | BuffEffect::SpellTargetingFromEffect { property, .. } => Some(*property),
        BuffEffect::SpellCastTimeFromEffect { .. } => Some(ModifierPropertyKind::CastTime),
        BuffEffect::SpellGcdFromEffect { .. } => Some(ModifierPropertyKind::GlobalCooldown),
        BuffEffect::SpellDurationFromEffect { .. } => Some(ModifierPropertyKind::Duration),
        BuffEffect::SpellTickTimeFromEffect { .. } => Some(ModifierPropertyKind::TickTime),
        BuffEffect::ResistPushbackFromEffect { .. } => Some(ModifierPropertyKind::ResistPushback),
        _ => None,
    }
}

fn configured_timing_property(effect: &BuffEffect) -> Option<ModifierPropertyKind> {
    match effect {
        BuffEffect::CastTimePercent(..) | BuffEffect::CastTimePercentPerStack(..) => {
            Some(ModifierPropertyKind::CastTime)
        }
        BuffEffect::GcdPercent(..) => Some(ModifierPropertyKind::GlobalCooldown),
        _ => None,
    }
}

fn cooldown_effect_applies_to_action(
    effect: &BuffEffect,
    binding: &super::FinalizedBuffDamageBinding,
    action: super::LocalDamageActionIdx,
    damage: &super::DamagePlan,
) -> bool {
    match effect {
        BuffEffect::RechargeRatePercent(..) => binding.lists_action(action),
        BuffEffect::CooldownRechargeRateFromEffect { .. }
        | BuffEffect::CooldownDurationPercent { .. } => binding
            .source_effect
            .is_some_and(|source| damage.effect_affects_action(source, action)),
        BuffEffect::ChargeRechargeRateCategory { .. } => true,
        _ => false,
    }
}

fn cost_effect_applies_to_action(
    effect: &BuffEffect,
    binding: &super::FinalizedBuffDamageBinding,
    action: super::LocalDamageActionIdx,
    damage: &super::DamagePlan,
) -> bool {
    match effect {
        BuffEffect::ResourceCostPercent(..) => true,
        BuffEffect::SpellCostPercent(..) | BuffEffect::SpellCostFlat(..) => {
            binding.lists_action(action)
        }
        BuffEffect::SpellCostFromEffect { .. }
        | BuffEffect::AdditionalPowerCostFromEffect { .. } => binding
            .source_effect
            .is_some_and(|source| damage.effect_affects_action(source, action)),
        _ => false,
    }
}

fn spell_scoped_effect_applies_to_action(
    effect: &BuffEffect,
    binding: &super::FinalizedBuffDamageBinding,
    action: super::LocalDamageActionIdx,
    damage: &super::DamagePlan,
) -> bool {
    if matches!(effect, BuffEffect::SpellModifierFromEffect { .. }) {
        return false;
    }

    if effect.listed_spell_ids().is_some() {
        return binding.lists_action(action);
    }

    match effect {
        BuffEffect::SpellDamageFromEffect { .. }
        | BuffEffect::DamageTakenFromSourceSpells { .. }
        | BuffEffect::SpellCritChanceFromEffect { .. }
        | BuffEffect::SpellCritDamageFromEffect { .. } => binding
            .source_effect
            .is_some_and(|source| damage.effect_affects_action(source, action)),
        _ => true,
    }
}

fn damage_scoped_effect_applies_to_action(
    effect: &BuffEffect,
    binding: &super::FinalizedBuffDamageBinding,
    action: super::LocalDamageActionIdx,
    damage: &super::DamagePlan,
) -> bool {
    if !matches!(
        effect,
        BuffEffect::DamageMultSpells(..)
            | BuffEffect::DamageMultSpellsActive(..)
            | BuffEffect::SpellDamageFromEffect { .. }
            | BuffEffect::DamageMultSpellsLinear(..)
            | BuffEffect::DynamicDamageMultSpells(..)
            | BuffEffect::DamageToTargetAuraMechanicPercent { .. }
            | BuffEffect::DamageTakenFromSource(..)
            | BuffEffect::DamageTakenFromSourceSpells { .. }
            | BuffEffect::MechanicDamageTakenPercent { .. }
            | BuffEffect::CreatureAoeDamageAvoidance { .. }
            | BuffEffect::IncomingDamagePercent { .. }
            | BuffEffect::SpellCritChanceFromEffect { .. }
            | BuffEffect::SpellCritDamageFromEffect { .. }
            | BuffEffect::CritChanceSpells(..)
            | BuffEffect::CritDamageSpells(..)
    ) {
        return false;
    }

    spell_scoped_effect_applies_to_action(effect, binding, action, damage)
}

impl PlannedAuraEffect {
    pub(crate) const fn is_canonical_for(
        self,
        requested: EffectFamily,
        selected: EffectFamily,
    ) -> bool {
        let matching = self.families.intersection(requested).bits();

        matching != 0 && matching.trailing_zeros() == selected.bits().trailing_zeros()
    }
}

fn flatten_actor_buckets<T>(buckets: Vec<Vec<T>>) -> ActorRanges<T> {
    let mut entries = Vec::new();
    let mut ranges = Vec::with_capacity(buckets.len());

    for bucket in buckets {
        let start = entries.len();

        entries.extend(bucket);
        ranges.push(start..entries.len());
    }

    // BOUNDS: fixed player/external buckets are always created by bind_aura_slots.

    let player = ranges[PLAYER_BUCKET].clone();
    // BOUNDS: fixed player/external buckets are always created by bind_aura_slots.
    let external = ranges[EXTERNAL_BUCKET].clone();
    let enemies_start = PET_BUCKETS_START + PetIdx::MAX;
    // BOUNDS: ranges has one entry for every fixed pet bucket plus all enemy buckets.
    let pets = ranges[PET_BUCKETS_START..enemies_start]
        .to_vec()
        .into_boxed_slice();
    // BOUNDS: enemies_start follows the complete fixed bucket prefix.
    let enemies = ranges[enemies_start..].to_vec().into_boxed_slice();

    ActorRanges {
        entries: entries.into_boxed_slice(),
        player,
        external,
        pets,
        enemies,
    }
}

fn filter_actor_ranges<T>(
    source: &ActorRanges<T>,
    mut keep: impl FnMut(&T) -> bool,
) -> ActorRanges<T>
where
    T: Copy,
{
    let mut buckets =
        Vec::with_capacity(FIXED_ACTOR_BUCKET_COUNT + source.pets.len() + source.enemies.len());

    buckets.push(
        source.entries[source.player.clone()]
            .iter()
            .copied()
            .filter(&mut keep)
            .collect(),
    );
    buckets.push(
        source.entries[source.external.clone()]
            .iter()
            .copied()
            .filter(&mut keep)
            .collect(),
    );

    for range in source.pets.iter().chain(&source.enemies) {
        buckets.push(
            source.entries[range.start..range.end]
                .iter()
                .copied()
                .filter(&mut keep)
                .collect(),
        );
    }

    flatten_actor_buckets(buckets)
}

fn local_aura(raw: usize) -> LocalAuraIdx {
    LocalAuraIdx::new(u8::try_from(raw).expect("finalized aura count is validated below 256"))
}

fn finalized_aura(auras: &[AuraData], local: LocalAuraIdx) -> &AuraData {
    // BOUNDS: local aura identities are finalized against this exact definition slice.
    &auras[local.as_usize()]
}

fn actor_bucket(actor: ActorId, enemy_count: usize) -> Option<usize> {
    match actor {
        ActorId::Player => Some(PLAYER_BUCKET),
        ActorId::External => Some(EXTERNAL_BUCKET),
        ActorId::Pet(pet) => {
            (pet.as_usize() < PetIdx::MAX).then_some(PET_BUCKETS_START + pet.as_usize())
        }
        ActorId::Enemy(enemy) => (enemy.as_usize() < enemy_count)
            .then_some(PET_BUCKETS_START + PetIdx::MAX + enemy.as_usize()),
    }
}

#[cfg(test)]
#[path = "effects/tests.rs"]
mod tests;