wowlab_engine_combat/systems/buffs/

planned.rs

// #t(file: rust_duplicate_strings) finalized binding and occupied-slot invariants intentionally use one stable diagnostic at every traversal entry point.
// #t(file: rust_unchecked_indexing) all direct indexes consume coordinates compiled from the same immutable passive, aura, and effect registries.

use wowlab_engine_domain::dbc::SpellEffectAttributes;

use crate::{
    context::ActorView,
    state::{BuffEffect, EffectFamily},
};

pub(crate) fn dbc_effect_points(
    program: &crate::state::CombatProgram,
    _state: &crate::state::CombatInstance,
    source: crate::state::program::LocalDamageEffectIdx,
    stacks: f64,
) -> f64 {
    let attributes = SpellEffectAttributes::from_dbc(program.damage.effect_at(source).attributes);

    if attributes.contains(SpellEffectAttributes::SUPPRESS_POINTS_STACKING) {
        1.0
    } else {
        stacks
    }
}

/// Visit only finalized aura/effect entries carrying the requested runtime family.
pub(crate) fn for_each_planned_actor_effect(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(f64, &BuffEffect),
) {
    if family.bits().is_power_of_two() {
        if view.actor == wowlab_types::sim::ActorId::Player {
            for &index in view.program.effects.passive_family_indexes(family) {
                visit(1.0, &view.program.passive_driver_effects[index].effect);
            }
        }

        for_each_planned_actor_aura_effect_single_family(
            view,
            family,
            |_, _, _, stacks, effect| {
                visit(stacks, effect);
            },
        );

        return;
    }

    if view.actor == wowlab_types::sim::ActorId::Player {
        for_each_planned_player_passive_effect(view.program, family, &mut visit);
    }

    for_each_planned_actor_aura_effect(view, family, |_, _, stacks, effect| {
        visit(stacks, effect);
    });
}

/// Visit effects together with the dense damage coordinates frozen for their exact slot.
pub(crate) fn for_each_planned_actor_effect_damage_binding(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    if family.bits().is_power_of_two() {
        if view.actor == wowlab_types::sim::ActorId::Player {
            for &index in view.program.effects.passive_family_indexes(family) {
                let effect = &view.program.passive_driver_effects[index].effect;
                let binding = view
                    .program
                    .damage
                    .passive_buff_binding(index)
                    .expect("every finalized passive effect has a damage binding record");

                visit(1.0, effect, binding);
            }
        }

        for_each_planned_actor_aura_effect_single_family(
            view,
            family,
            |_, local, position, stacks, effect| {
                let binding = view
                    .program
                    .damage
                    .aura_buff_binding(local, position)
                    .expect("every finalized aura effect has a damage binding record");

                visit(stacks, effect, binding);
            },
        );

        return;
    }

    if view.actor == wowlab_types::sim::ActorId::Player {
        for_each_planned_player_passive_effect_binding(view.program, family, &mut visit);
    }

    for_each_planned_actor_aura_effect_inner(view, family, |_, local, position, stacks, effect| {
        let binding = view
            .program
            .damage
            .aura_buff_binding(local, position)
            .expect("every finalized aura effect has a damage binding record");

        visit(stacks, effect, binding);
    });
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_active_bound_action_effect(
    view: ActorView<'_>,
    passive_indexes: &[usize],
    aura_plan: &crate::state::program::ActiveAuraEffectPlan,
    mut visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    if view.actor == wowlab_types::sim::ActorId::Player {
        for &index in passive_indexes {
            let effect = &view.program.passive_driver_effects[index].effect;
            let binding = view
                .program
                .damage
                .passive_buff_binding(index)
                .expect("every finalized passive effect has a damage binding record");

            visit(1.0, effect, binding);
        }
    }

    for_each_active_aura_effect_plan(view, aura_plan, aura_plan, &mut visit);
}

#[cfg(not(feature = "rotation-optimizations"))]
fn for_each_active_bound_action_effect(
    view: ActorView<'_>,
    passive_indexes: &[usize],
    aura_entries: &[crate::state::program::PlannedAuraEffect],
    mut visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    if view.actor == wowlab_types::sim::ActorId::Player {
        for &index in passive_indexes {
            let effect = &view.program.passive_driver_effects[index].effect;
            let binding = view
                .program
                .damage
                .passive_buff_binding(index)
                .expect("every finalized passive effect has a damage binding record");

            visit(1.0, effect, binding);
        }
    }

    for entry in aura_entries {
        wowlab_types::bench_metrics::record_aura_slot_visit();
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() {
            continue;
        }

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

        visit(f64::from(slot.stacks), effect, binding);
    }
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_active_bound_action_effect_union(
    view: ActorView<'_>,
    left_passives: &[usize],
    right_passives: &[usize],
    left_auras: &crate::state::program::ActiveAuraEffectPlan,
    right_auras: &crate::state::program::ActiveAuraEffectPlan,
    mut visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    if view.actor == wowlab_types::sim::ActorId::Player {
        let mut left = 0;
        let mut right = 0;

        while left < left_passives.len() || right < right_passives.len() {
            let index = match (left_passives.get(left), right_passives.get(right)) {
                (Some(&left_index), Some(&right_index)) if left_index < right_index => {
                    left += 1;

                    left_index
                }
                (Some(&left_index), Some(&right_index)) if right_index < left_index => {
                    right += 1;

                    right_index
                }
                (Some(&index), Some(_)) => {
                    left += 1;
                    right += 1;

                    index
                }
                (Some(&index), None) => {
                    left += 1;

                    index
                }
                (None, Some(&index)) => {
                    right += 1;

                    index
                }
                (None, None) => break,
            };
            let effect = &view.program.passive_driver_effects[index].effect;
            let binding = view
                .program
                .damage
                .passive_buff_binding(index)
                .expect("every finalized passive effect has a damage binding record");

            visit(1.0, effect, binding);
        }
    }

    for_each_active_aura_effect_plan(view, left_auras, right_auras, &mut visit);
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_active_aura_effect_plan(
    view: ActorView<'_>,
    left: &crate::state::program::ActiveAuraEffectPlan,
    right: &crate::state::program::ActiveAuraEffectPlan,
    visit: &mut impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    let mut visit_binding = |local: crate::state::LocalAuraIdx,
                             handle: wowlab_engine_domain::rotation::AuraSlotHandle,
                             mut mask: u16| {
        let slot = view.instance.buffer.aura_at(handle);

        debug_assert!(
            slot.is_occupied(),
            "active aura intersection contains only occupied concrete bindings"
        );

        let aura = view.program.aura(local);

        while mask != 0 {
            let position =
                u8::try_from(mask.trailing_zeros()).expect("u16 effect mask positions fit in u8");

            mask &= mask - 1;
            wowlab_types::bench_metrics::record_aura_slot_visit();
            let effect = aura.effects[usize::from(position)]
                .as_ref()
                .expect("active-aura effect plan references an occupied effect");
            let damage_binding = view
                .program
                .damage
                .aura_buff_binding(local, position)
                .expect("every finalized aura effect has a damage binding record");

            visit(f64::from(slot.stacks), effect, damage_binding);
        }
    };

    if std::ptr::eq(left, right) {
        for &(local, mask) in left.masks() {
            view.instance
                .for_each_active_aura_local(view.actor, local, |binding| {
                    visit_binding(local, binding.handle, mask);
                });
        }

        return;
    }

    view.instance.for_each_active_aura_intersection(
        view.actor,
        (left.relevant_locals(), right.relevant_locals()),
        |local, binding| {
            visit_binding(local, binding.handle, left.mask(local) | right.mask(local));
        },
    );
}

pub(crate) fn for_each_active_spell_modifier_for_action(
    view: ActorView<'_>,
    action: crate::state::program::LocalDamageActionIdx,
    property: wowlab_engine_domain::dbc::ModifierPropertyKind,
    visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    debug_assert_eq!(
        view.actor,
        wowlab_types::sim::ActorId::Player,
        "affected-spell property modifiers resolve through the canonical player owner"
    );

    #[cfg(feature = "rotation-optimizations")]
    for_each_active_bound_action_effect(
        view,
        view.program
            .effects
            .spell_modifier_passive_indexes(action, property),
        view.program
            .effects
            .spell_modifier_player_aura_plan(action, property),
        visit,
    );

    #[cfg(not(feature = "rotation-optimizations"))]
    for_each_active_bound_action_effect(
        view,
        view.program
            .effects
            .spell_modifier_passive_indexes(action, property),
        view.program
            .effects
            .spell_modifier_player_auras(action, property),
        visit,
    );
}

pub(crate) fn for_each_active_scoped_spell_modifier_for_action(
    view: ActorView<'_>,
    action: crate::state::program::LocalDamageActionIdx,
    visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    #[cfg(feature = "rotation-optimizations")]
    for_each_active_bound_action_effect(
        view,
        view.program
            .effects
            .scoped_spell_modifier_passive_indexes(action),
        view.program.effects.scoped_spell_modifier_aura_plan(action),
        visit,
    );

    #[cfg(not(feature = "rotation-optimizations"))]
    for_each_active_bound_action_effect(
        view,
        view.program
            .effects
            .scoped_spell_modifier_passive_indexes(action),
        view.program
            .effects
            .scoped_spell_modifier_actor_auras(view.actor, action),
        visit,
    );
}

#[cfg(feature = "rotation-optimizations")]
pub(crate) fn for_each_active_damage_modifier_for_actions(
    view: ActorView<'_>,
    profile_action: crate::state::program::LocalDamageActionIdx,
    effect_action: crate::state::program::LocalDamageActionIdx,
    visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    for_each_active_bound_action_effect_union(
        view,
        view.program
            .effects
            .damage_spell_modifier_passive_indexes(profile_action),
        view.program
            .effects
            .damage_spell_modifier_passive_indexes(effect_action),
        view.program
            .effects
            .damage_spell_modifier_aura_plan(profile_action),
        view.program
            .effects
            .damage_spell_modifier_aura_plan(effect_action),
        visit,
    );
}

#[cfg(not(feature = "rotation-optimizations"))]
pub(crate) fn for_each_active_damage_modifier_for_action(
    view: ActorView<'_>,
    action: crate::state::program::LocalDamageActionIdx,
    visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    for_each_active_bound_action_effect(
        view,
        view.program
            .effects
            .damage_spell_modifier_passive_indexes(action),
        view.program
            .effects
            .damage_spell_modifier_actor_auras(view.actor, action),
        visit,
    );
}

pub(crate) fn for_each_active_cost_modifier_for_action(
    view: ActorView<'_>,
    action: crate::state::program::LocalDamageActionIdx,
    visit: impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    #[cfg(feature = "rotation-optimizations")]
    for_each_active_bound_action_effect(
        view,
        view.program.effects.cost_modifier_passive_indexes(action),
        view.program.effects.cost_modifier_aura_plan(action),
        visit,
    );

    #[cfg(not(feature = "rotation-optimizations"))]
    for_each_active_bound_action_effect(
        view,
        view.program.effects.cost_modifier_passive_indexes(action),
        view.program
            .effects
            .cost_modifier_actor_auras(view.actor, action),
        visit,
    );
}

fn for_each_planned_player_passive_effect_binding(
    program: &crate::state::CombatProgram,
    family: EffectFamily,
    visit: &mut impl FnMut(f64, &BuffEffect, &crate::state::program::FinalizedBuffDamageBinding),
) {
    let mut cursors = [0_usize; u128::BITS as usize];

    loop {
        let mut selected_entry = None::<(usize, usize)>;
        let mut bits = family.bits();

        while bits != 0 {
            let bit = bits.trailing_zeros() as usize;
            let selected = EffectFamily::from_bits_retain(1_u128 << bit);
            let indexes = program.effects.passive_family_indexes(selected);
            // BOUNDS: trailing_zeros on a nonzero u128 produces an index below u128::BITS.
            let cursor = &mut cursors[bit];

            bits &= bits - 1;

            while let Some(&index) = indexes.get(*cursor) {
                // BOUNDS: effect-plan family indexes are finalized from this passive registry.
                let effect = &program.passive_driver_effects[index].effect;
                let matching = effect.classification().families().intersection(family);

                if matching.bits().trailing_zeros() as usize == bit {
                    if selected_entry.is_none_or(|(current, _)| index < current) {
                        selected_entry = Some((index, bit));
                    }

                    break;
                }

                *cursor += 1;
            }
        }

        let Some((index, bit)) = selected_entry else {
            break;
        };

        // BOUNDS: selected bits originate from the same bounded u128 family mask.

        cursors[bit] += 1;
        // BOUNDS: selected entries originate from finalized passive family index slices.
        let effect = &program.passive_driver_effects[index].effect;
        let binding = program
            .damage
            .passive_buff_binding(index)
            .expect("every finalized passive effect has a damage binding record");

        visit(1.0, effect, binding);
    }
}

/// Visit finalized aura effects while retaining their exact fixed-slot coordinate.
pub(crate) fn for_each_planned_actor_aura_effect_binding(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(wowlab_types::sim::AuraKey, crate::state::LocalAuraIdx, u8, f64, &BuffEffect),
) {
    for_each_planned_actor_aura_effect_inner(
        view,
        family,
        |key, local, position, stacks, effect| {
            visit(key, local, position, stacks, effect);
        },
    );
}

fn for_each_planned_player_passive_effect(
    program: &crate::state::CombatProgram,
    family: EffectFamily,
    visit: &mut impl FnMut(f64, &BuffEffect),
) {
    let mut cursors = [0_usize; u128::BITS as usize];

    loop {
        let mut selected_entry = None::<(usize, usize)>;
        let mut bits = family.bits();

        while bits != 0 {
            let bit = bits.trailing_zeros() as usize;
            let selected = EffectFamily::from_bits_retain(1_u128 << bit);
            let indexes = program.effects.passive_family_indexes(selected);
            // BOUNDS: EffectFamily bits and cursor storage share the u128 bit width.
            let cursor = &mut cursors[bit];

            bits &= bits - 1;

            while let Some(&index) = indexes.get(*cursor) {
                // BOUNDS: passive family indexes are compiled from this exact driver slice.
                let effect = &program.passive_driver_effects[index].effect;
                let matching = effect.classification().families().intersection(family);

                if matching.bits().trailing_zeros() as usize == bit {
                    if selected_entry.is_none_or(|(current, _)| index < current) {
                        selected_entry = Some((index, bit));
                    }

                    break;
                }

                *cursor += 1;
            }
        }

        let Some((index, bit)) = selected_entry else {
            break;
        };

        // BOUNDS: selected bits come from the same u128 family mask as cursor storage.

        cursors[bit] += 1;
        // BOUNDS: passive family indexes are compiled from this exact driver slice.
        visit(1.0, &program.passive_driver_effects[index].effect);
    }
}

pub(crate) fn for_each_planned_actor_aura_effect(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(wowlab_types::sim::AuraKey, crate::state::LocalAuraIdx, f64, &BuffEffect),
) {
    for_each_planned_actor_aura_effect_inner(view, family, |key, local, _, stacks, effect| {
        visit(key, local, stacks, effect);
    });
}

fn for_each_planned_actor_aura_effect_inner(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(wowlab_types::sim::AuraKey, crate::state::LocalAuraIdx, u8, f64, &BuffEffect),
) {
    if family.bits().is_power_of_two() {
        for_each_planned_actor_aura_effect_single_family(view, family, visit);

        return;
    }

    let mut cursors = [0_usize; u128::BITS as usize];

    loop {
        let mut selected_entry = None::<(&crate::state::program::PlannedAuraEffect, usize)>;
        let mut bits = family.bits();

        while bits != 0 {
            let bit = bits.trailing_zeros() as usize;
            let selected = EffectFamily::from_bits_retain(1_u128 << bit);
            let entries = view
                .program
                .effects
                .actor_family_effects(view.actor, selected);
            // BOUNDS: EffectFamily bits and cursor storage share the u128 bit width.
            let cursor = &mut cursors[bit];

            bits &= bits - 1;

            while let Some(entry) = entries.get(*cursor) {
                if entry.is_canonical_for(family, selected) {
                    if selected_entry.is_none_or(|(current, _)| entry.order < current.order) {
                        selected_entry = Some((entry, bit));
                    }

                    break;
                }

                *cursor += 1;
            }
        }

        let Some((entry, bit)) = selected_entry else {
            break;
        };

        // BOUNDS: selected bits come from the same u128 family mask as cursor storage.

        cursors[bit] += 1;

        wowlab_types::bench_metrics::record_aura_slot_visit();
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() {
            continue;
        }

        // BOUNDS: exact effect positions are compiled from this aura's fixed array.

        let effect = view.program.aura(entry.local).effects[usize::from(entry.position)]
            .as_ref()
            .expect("planned effect position remains occupied after finalization");

        visit(
            entry.key,
            entry.local,
            entry.position,
            f64::from(slot.stacks),
            effect,
        );
    }
}

fn for_each_planned_actor_aura_effect_single_family(
    view: ActorView<'_>,
    family: EffectFamily,
    mut visit: impl FnMut(wowlab_types::sim::AuraKey, crate::state::LocalAuraIdx, u8, f64, &BuffEffect),
) {
    #[cfg(feature = "rotation-optimizations")]
    {
        let plan = view.program.effects.family_aura_plan(family);

        view.instance.for_each_active_aura_intersection(
            view.actor,
            (plan.relevant_locals(), &[]),
            |local, binding| {
                let slot = view.instance.buffer.aura_at(binding.handle);
                let aura = view.program.aura(local);
                let mut mask = plan.mask(local);

                debug_assert!(
                    slot.is_occupied(),
                    "active aura intersection contains only occupied concrete bindings"
                );

                while mask != 0 {
                    let position = u8::try_from(mask.trailing_zeros())
                        .expect("u16 effect mask positions fit in u8");

                    mask &= mask - 1;
                    wowlab_types::bench_metrics::record_aura_slot_visit();
                    let effect = aura.effects[usize::from(position)]
                        .as_ref()
                        .expect("family aura plan references an occupied effect");

                    visit(binding.key, local, position, f64::from(slot.stacks), effect);
                }
            },
        );
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    for entry in view
        .program
        .effects
        .actor_family_effects(view.actor, family)
    {
        wowlab_types::bench_metrics::record_aura_slot_visit();
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() {
            continue;
        }

        // BOUNDS: exact effect positions are compiled from this aura's fixed array.

        let effect = view.program.aura(entry.local).effects[usize::from(entry.position)]
            .as_ref()
            .expect("planned effect position remains occupied after finalization");

        visit(
            entry.key,
            entry.local,
            entry.position,
            f64::from(slot.stacks),
            effect,
        );
    }
}

pub(crate) fn for_each_planned_player_effect(
    program: &crate::state::CombatProgram,
    instance: &crate::state::CombatInstance,
    family: EffectFamily,
    visit: impl FnMut(f64, &BuffEffect),
) {
    for_each_planned_actor_effect(
        ActorView::new(program, instance, wowlab_types::sim::ActorId::Player),
        family,
        visit,
    );
}

pub(crate) fn for_each_planned_target_effect(
    program: &crate::state::CombatProgram,
    instance: &crate::state::CombatInstance,
    target: wowlab_types::sim::EnemyIdx,
    family: EffectFamily,
    visit: impl FnMut(f64, &BuffEffect),
) {
    for_each_planned_actor_effect(
        ActorView::new(program, instance, wowlab_types::sim::ActorId::Enemy(target)),
        family,
        visit,
    );
}