wowlab_engine_domain/dbc/semantics/

spell_targets.rs

//! Composition of implicit selectors into explicit and required cast-target masks.

use wowlab_types::data::{SpellDataFlat, SpellEffect};

use super::{
    ImplicitTargetCheck, ImplicitTargetObject, ImplicitTargetReference, ImplicitTargetSemantic,
    SpellCastTargetFlags, SpellEffectAttributes, SpellEffectImplicitTarget,
    implicit_target_semantic, spell_effect_target_semantic,
};

const TRAJECTORY_TARGET: i32 = 89;
const DO_NOT_FAIL_IF_NO_TARGET_WORD: usize = 13;
const DO_NOT_FAIL_IF_NO_TARGET_MASK: i32 = 1 << 15;

/// Explicit and required target masks calculated from effect selectors and restrictions.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SpellTargetMasks {
    pub explicit: SpellCastTargetFlags,
    pub required: SpellCastTargetFlags,
}

#[derive(Clone, Copy, Debug, Default)]
struct LocationState {
    source_set: bool,
    destination_set: bool,
}

fn trajectory_mask(locations: LocationState) -> SpellCastTargetFlags {
    let mut mask = SpellCastTargetFlags::empty();

    if !locations.source_set {
        mask |= SpellCastTargetFlags::SOURCE_LOCATION;
    }

    if !locations.destination_set {
        mask |= SpellCastTargetFlags::DEST_LOCATION;
    }

    mask
}

const fn checked_unit_mask(check: ImplicitTargetCheck) -> SpellCastTargetFlags {
    match check {
        ImplicitTargetCheck::Enemy => SpellCastTargetFlags::UNIT_ENEMY,
        ImplicitTargetCheck::Ally => SpellCastTargetFlags::UNIT_ALLY,
        ImplicitTargetCheck::Party => SpellCastTargetFlags::UNIT_PARTY,
        ImplicitTargetCheck::Raid => SpellCastTargetFlags::UNIT_RAID,
        ImplicitTargetCheck::Passenger => SpellCastTargetFlags::UNIT_PASSENGER,
        _ => SpellCastTargetFlags::UNIT,
    }
}

const fn object_mask(object: ImplicitTargetObject) -> SpellCastTargetFlags {
    match object {
        ImplicitTargetObject::Destination => SpellCastTargetFlags::DEST_LOCATION,
        ImplicitTargetObject::UnitAndDestination => SpellCastTargetFlags::from_bits_retain(
            SpellCastTargetFlags::DEST_LOCATION.bits() | SpellCastTargetFlags::UNIT.bits(),
        ),
        ImplicitTargetObject::CorpseAlly => SpellCastTargetFlags::CORPSE_ALLY,
        ImplicitTargetObject::CorpseEnemy => SpellCastTargetFlags::CORPSE_ENEMY,
        ImplicitTargetObject::Corpse => SpellCastTargetFlags::CORPSE_MASK,
        ImplicitTargetObject::Unit => SpellCastTargetFlags::UNIT,
        ImplicitTargetObject::GameObject => SpellCastTargetFlags::GAMEOBJECT,
        ImplicitTargetObject::GameObjectItem => SpellCastTargetFlags::GAMEOBJECT_ITEM,
        ImplicitTargetObject::Item => SpellCastTargetFlags::ITEM,
        ImplicitTargetObject::Source => SpellCastTargetFlags::SOURCE_LOCATION,
        ImplicitTargetObject::None => SpellCastTargetFlags::empty(),
    }
}

const fn explicit_object_mask(target: ImplicitTargetSemantic) -> SpellCastTargetFlags {
    match target.object {
        ImplicitTargetObject::GameObject => SpellCastTargetFlags::GAMEOBJECT,
        ImplicitTargetObject::GameObjectItem => SpellCastTargetFlags::GAMEOBJECT_ITEM,
        ImplicitTargetObject::Unit
        | ImplicitTargetObject::UnitAndDestination
        | ImplicitTargetObject::Destination => checked_unit_mask(target.check),
        _ => SpellCastTargetFlags::empty(),
    }
}

fn reference_mask(
    target: ImplicitTargetSemantic,
    locations: LocationState,
) -> SpellCastTargetFlags {
    match target.reference {
        ImplicitTargetReference::Source if !locations.source_set => {
            SpellCastTargetFlags::SOURCE_LOCATION
        }
        ImplicitTargetReference::Destination if !locations.destination_set => {
            SpellCastTargetFlags::DEST_LOCATION
        }
        ImplicitTargetReference::Target => explicit_object_mask(target),
        _ => SpellCastTargetFlags::empty(),
    }
}

fn record_provided_location(target: ImplicitTargetSemantic, locations: &mut LocationState) {
    match target.object {
        ImplicitTargetObject::Source => locations.source_set = true,
        ImplicitTargetObject::Destination | ImplicitTargetObject::UnitAndDestination => {
            locations.destination_set = true;
        }
        _ => {}
    }
}

fn selector_mask(raw: i32, locations: &mut LocationState) -> SpellCastTargetFlags {
    let Some(target) = implicit_target_semantic(raw).copied() else {
        return SpellCastTargetFlags::empty();
    };
    let mask = if raw == TRAJECTORY_TARGET {
        trajectory_mask(*locations)
    } else {
        reference_mask(target, *locations)
    };

    record_provided_location(target, locations);

    mask
}

fn effect_target_mask(
    target_a: i32,
    target_b: i32,
    locations: &mut LocationState,
) -> SpellCastTargetFlags {
    selector_mask(target_a, locations) | selector_mask(target_b, locations)
}

fn selector_object_mask(raw: i32) -> SpellCastTargetFlags {
    implicit_target_semantic(raw).map_or_else(SpellCastTargetFlags::empty, |target| {
        object_mask(target.object)
    })
}

fn remove_provided_objects(
    mut missing: SpellCastTargetFlags,
    provided: SpellCastTargetFlags,
    locations: LocationState,
) -> SpellCastTargetFlags {
    if provided.intersects(SpellCastTargetFlags::UNIT_MASK) {
        missing.remove(SpellCastTargetFlags::UNIT_MASK);
    }

    if provided.intersects(SpellCastTargetFlags::CORPSE_MASK) {
        missing.remove(SpellCastTargetFlags::UNIT_MASK | SpellCastTargetFlags::CORPSE_MASK);
    }

    if provided.contains(SpellCastTargetFlags::GAMEOBJECT_ITEM) {
        missing.remove(
            SpellCastTargetFlags::GAMEOBJECT_ITEM
                | SpellCastTargetFlags::GAMEOBJECT
                | SpellCastTargetFlags::ITEM,
        );
    }

    if provided.contains(SpellCastTargetFlags::GAMEOBJECT) {
        missing.remove(SpellCastTargetFlags::GAMEOBJECT_MASK);
    }

    if provided.contains(SpellCastTargetFlags::ITEM) {
        missing.remove(SpellCastTargetFlags::ITEM | SpellCastTargetFlags::GAMEOBJECT_ITEM);
    }

    if locations.destination_set || provided.contains(SpellCastTargetFlags::DEST_LOCATION) {
        missing.remove(SpellCastTargetFlags::DEST_LOCATION);
    }

    if locations.source_set || provided.contains(SpellCastTargetFlags::SOURCE_LOCATION) {
        missing.remove(SpellCastTargetFlags::SOURCE_LOCATION);
    }

    missing
}

fn missing_effect_mask(
    effect: &SpellEffect,
    target_mask: SpellCastTargetFlags,
    locations: LocationState,
) -> SpellCastTargetFlags {
    let Some(targeting) = spell_effect_target_semantic(effect.effect) else {
        return SpellCastTargetFlags::empty();
    };

    if targeting.implicit != SpellEffectImplicitTarget::Explicit {
        return SpellCastTargetFlags::empty();
    }

    let provided = target_mask
        | selector_object_mask(effect.implicit_target_a)
        | selector_object_mask(effect.implicit_target_b);

    remove_provided_objects(object_mask(targeting.object), provided, locations)
}

fn strip_unreachable_fallbacks(
    spell: &SpellDataFlat,
    mut mask: SpellCastTargetFlags,
) -> SpellCastTargetFlags {
    if spell.range_max_0 <= 0.0 && spell.range_max_1 <= 0.0 {
        mask.remove(
            SpellCastTargetFlags::UNIT_MASK
                | SpellCastTargetFlags::GAMEOBJECT
                | SpellCastTargetFlags::CORPSE_MASK
                | SpellCastTargetFlags::DEST_LOCATION,
        );
    }

    mask
}

fn authored_masks(spell: &SpellDataFlat) -> SpellTargetMasks {
    let explicit = SpellCastTargetFlags::from_dbc(spell.target_flags);
    let optional = spell
        .attributes
        .get(DO_NOT_FAIL_IF_NO_TARGET_WORD)
        .is_some_and(|word| word & DO_NOT_FAIL_IF_NO_TARGET_MASK != 0);

    SpellTargetMasks {
        explicit,
        required: if optional {
            SpellCastTargetFlags::empty()
        } else {
            explicit
        },
    }
}

/// Calculate Trinity-style explicit and required masks from effect A/B selectors and authored flags.
#[must_use]
pub fn spell_target_masks(spell: &SpellDataFlat) -> SpellTargetMasks {
    let mut locations = LocationState::default();
    let mut masks = authored_masks(spell);

    for effect in spell.effects.iter().filter(|effect| effect.effect != 0) {
        let mut target_mask = effect_target_mask(
            effect.implicit_target_a,
            effect.implicit_target_b,
            &mut locations,
        );
        let missing = missing_effect_mask(effect, target_mask, locations);

        target_mask |= strip_unreachable_fallbacks(spell, missing);
        masks.explicit |= target_mask;
        let attributes = SpellEffectAttributes::from_dbc(effect.effect_attributes);

        if !attributes.contains(SpellEffectAttributes::DONT_FAIL_SPELL_ON_TARGETING_FAILURE) {
            masks.required |= target_mask;
        }
    }

    masks
}

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

    use super::*;

    fn spell_with_target(effect: i32, target: i32) -> SpellDataFlat {
        let mut spell = SpellDataFlat::default();

        spell.effects.push(SpellEffect {
            effect,
            implicit_target_a: target,
            ..SpellEffect::default()
        });

        spell
    }

    #[gtest]
    fn caster_selector_does_not_require_an_explicit_target() {
        expect_that!(
            spell_target_masks(&spell_with_target(6, 1)),
            eq(SpellTargetMasks::default())
        );
    }

    #[gtest]
    fn enemy_selector_requires_a_hostile_unit() {
        let masks = spell_target_masks(&spell_with_target(2, 6));

        expect_that!(masks.explicit, eq(SpellCastTargetFlags::UNIT_ENEMY));
        expect_that!(masks.required, eq(SpellCastTargetFlags::UNIT_ENEMY));
    }
}