wowlab_engine_domain/targeting/support/

lower.rs

//! Lowering from canonical target semantics into the components the combat runtime executes.

use super::algebra::{
    ExecutableCandidateDomain, ExecutableLocation, ExecutableLocationAlgorithm,
    ExecutableSelection, ExecutableTargetAlgorithm, ExecutableTargetDirection,
    ExecutableTargetFallback, ExecutableTargetOperation, ExecutableTargetOperations,
    ExecutableTargetPlan, ExecutableTargetReference, TargetPlanAxis, TargetPlanGap,
};
use crate::{
    dbc::{
        ImplicitTargetCheck, ImplicitTargetDirection, ImplicitTargetObject,
        ImplicitTargetReference, ImplicitTargetSelection, SpellEffectImplicitTarget,
    },
    targeting::{TargetPlan, TargetPlanOperation, TargetSelector},
};

/// Lower every semantic axis independently into the runtime target algebra.
///
/// # Errors
///
/// Returns a gap when the runtime cannot represent a semantic operation or fallback.
pub fn lower_target_plan(plan: &TargetPlan) -> Result<ExecutableTargetPlan, TargetPlanGap> {
    let mut operations = ExecutableTargetOperations::default();

    for operation in plan.operations.into_array().into_iter().flatten() {
        operations.push(lower_operation(operation)?);
    }

    Ok(ExecutableTargetPlan {
        operations,
        fallback: lower_fallback(plan)?,
    })
}

/// Whether the canonical program emits a spatially multi-target actor selection.
#[must_use]
pub fn target_plan_is_multi_target(plan: &TargetPlan) -> bool {
    plan.operations
        .into_array()
        .into_iter()
        .flatten()
        .any(|operation| {
            let selector = match operation {
                TargetPlanOperation::Select(selector)
                | TargetPlanOperation::SelectAndAssignDestination(selector) => selector,
                TargetPlanOperation::AssignSource(_)
                | TargetPlanOperation::AssignDestination(_) => return false,
            };

            matches!(
                selector.algorithm,
                ImplicitTargetSelection::Area
                    | ImplicitTargetSelection::Cone
                    | ImplicitTargetSelection::Line
                    | ImplicitTargetSelection::Trajectory
            )
        })
}

fn lower_operation(
    operation: TargetPlanOperation,
) -> Result<ExecutableTargetOperation, TargetPlanGap> {
    match operation {
        TargetPlanOperation::AssignSource(selector) => Ok(ExecutableTargetOperation::AssignSource(
            lower_location(selector)?,
        )),
        TargetPlanOperation::AssignDestination(selector) => Ok(
            ExecutableTargetOperation::AssignDestination(lower_location(selector)?),
        ),
        TargetPlanOperation::Select(selector) => Ok(ExecutableTargetOperation::Select(
            lower_selection(selector)?,
        )),
        TargetPlanOperation::SelectAndAssignDestination(selector) => Ok(
            ExecutableTargetOperation::SelectAndAssignDestination(lower_selection(selector)?),
        ),
    }
}

fn lower_location(selector: TargetSelector) -> Result<ExecutableLocation, TargetPlanGap> {
    lower_check(selector)?;

    Ok(ExecutableLocation {
        reference: lower_reference(selector)?,
        algorithm: lower_location_algorithm(selector)?,
        direction: lower_direction(selector)?,
    })
}

fn lower_selection(selector: TargetSelector) -> Result<ExecutableSelection, TargetPlanGap> {
    Ok(ExecutableSelection {
        candidates: lower_candidate_domain(selector)?,
        reference: lower_reference(selector)?,
        algorithm: lower_selection_algorithm(selector)?,
        direction: lower_direction(selector)?,
        selector,
    })
}

fn lower_candidate_domain(
    selector: TargetSelector,
) -> Result<ExecutableCandidateDomain, TargetPlanGap> {
    lower_object(selector)?;
    lower_check(selector)?;

    Ok(ExecutableCandidateDomain::EnemyUnits)
}

fn lower_object(selector: TargetSelector) -> Result<(), TargetPlanGap> {
    match selector.object {
        ImplicitTargetObject::Unit | ImplicitTargetObject::UnitAndDestination => Ok(()),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Object,
            value.as_str(),
        )),
    }
}

fn lower_reference(selector: TargetSelector) -> Result<ExecutableTargetReference, TargetPlanGap> {
    match selector.reference {
        ImplicitTargetReference::Caster => Ok(ExecutableTargetReference::Caster),
        ImplicitTargetReference::Target => Ok(ExecutableTargetReference::ExplicitTarget),
        ImplicitTargetReference::Source => Ok(ExecutableTargetReference::Source),
        ImplicitTargetReference::Destination => Ok(ExecutableTargetReference::Destination),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Reference,
            value.as_str(),
        )),
    }
}

fn lower_location_algorithm(
    selector: TargetSelector,
) -> Result<ExecutableLocationAlgorithm, TargetPlanGap> {
    match selector.algorithm {
        ImplicitTargetSelection::Default => Ok(ExecutableLocationAlgorithm::Reference),
        ImplicitTargetSelection::Channel => Ok(ExecutableLocationAlgorithm::ChannelTarget),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Algorithm,
            value.as_str(),
        )),
    }
}

fn lower_selection_algorithm(
    selector: TargetSelector,
) -> Result<ExecutableTargetAlgorithm, TargetPlanGap> {
    match selector.algorithm {
        ImplicitTargetSelection::Default => Ok(ExecutableTargetAlgorithm::Single),
        ImplicitTargetSelection::Channel => Ok(ExecutableTargetAlgorithm::ChannelTarget),
        ImplicitTargetSelection::Area => Ok(ExecutableTargetAlgorithm::Radius),
        ImplicitTargetSelection::Cone => Ok(ExecutableTargetAlgorithm::Cone),
        ImplicitTargetSelection::Line => Ok(ExecutableTargetAlgorithm::Line),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Algorithm,
            value.as_str(),
        )),
    }
}

fn lower_check(selector: TargetSelector) -> Result<(), TargetPlanGap> {
    match selector.check {
        ImplicitTargetCheck::Default | ImplicitTargetCheck::Enemy => Ok(()),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Check,
            value.as_str(),
        )),
    }
}

fn lower_direction(selector: TargetSelector) -> Result<ExecutableTargetDirection, TargetPlanGap> {
    match selector.direction {
        ImplicitTargetDirection::None => Ok(ExecutableTargetDirection::None),
        ImplicitTargetDirection::Front => Ok(ExecutableTargetDirection::Front),
        ImplicitTargetDirection::Back => Ok(ExecutableTargetDirection::Back),
        ImplicitTargetDirection::Right => Ok(ExecutableTargetDirection::Right),
        ImplicitTargetDirection::Left => Ok(ExecutableTargetDirection::Left),
        ImplicitTargetDirection::FrontRight => Ok(ExecutableTargetDirection::FrontRight),
        ImplicitTargetDirection::BackRight => Ok(ExecutableTargetDirection::BackRight),
        ImplicitTargetDirection::BackLeft => Ok(ExecutableTargetDirection::BackLeft),
        ImplicitTargetDirection::FrontLeft => Ok(ExecutableTargetDirection::FrontLeft),
        ImplicitTargetDirection::Random => Ok(ExecutableTargetDirection::Random),
        value => Err(selector_gap(
            selector,
            TargetPlanAxis::Direction,
            value.as_str(),
        )),
    }
}

fn lower_fallback(plan: &TargetPlan) -> Result<ExecutableTargetFallback, TargetPlanGap> {
    use ImplicitTargetObject as Object;
    use SpellEffectImplicitTarget as Implicit;

    match (plan.fallback.implicit, plan.fallback.object) {
        (Implicit::Explicit, Object::Unit | Object::UnitAndDestination) => {
            Ok(ExecutableTargetFallback::ExplicitUnit)
        }
        (Implicit::None, Object::None | Object::Unit | Object::Destination)
        | (Implicit::Caster, Object::Unit)
        | (Implicit::Explicit, Object::None) => Ok(ExecutableTargetFallback::NoSelection),
        (Implicit::Explicit, Object::Destination) => {
            Ok(ExecutableTargetFallback::ExplicitDestination)
        }
        (_, object) => Err(gap(None, TargetPlanAxis::EffectFallback, object.as_str())),
    }
}

const fn selector_gap(
    selector: TargetSelector,
    axis: TargetPlanAxis,
    value: &'static str,
) -> TargetPlanGap {
    gap(selector.raw, axis, value)
}

const fn gap(selector: Option<i32>, axis: TargetPlanAxis, value: &'static str) -> TargetPlanGap {
    TargetPlanGap {
        selector,
        axis,
        value,
    }
}

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

    use super::*;
    use crate::{
        dbc::SpellEffectTargetSemantic,
        targeting::{TargetPlanOperations, TargetPlanProvenance, compile_dbc_target_plan},
    };

    #[gtest]
    #[rstest]
    #[case::blade_flurry(18, 16)]
    #[case::blade_rush(53, 16)]
    #[case::front_cone(24, 0)]
    #[case::channel_destination_area(76, 16)]
    #[case::channel_unit(77, 0)]
    fn composed_supported_axes_lower(#[case] target_a: i32, #[case] target_b: i32) {
        let plan = compile_dbc_target_plan(2, target_a, target_b).unwrap();

        lower_target_plan(&plan).unwrap();
    }

    #[gtest]
    #[rstest]
    #[case::front_right(41, ExecutableTargetDirection::FrontRight)]
    #[case::back_right(42, ExecutableTargetDirection::BackRight)]
    #[case::back_left(43, ExecutableTargetDirection::BackLeft)]
    #[case::front_left(44, ExecutableTargetDirection::FrontLeft)]
    #[case::front(47, ExecutableTargetDirection::Front)]
    #[case::back(48, ExecutableTargetDirection::Back)]
    #[case::right(49, ExecutableTargetDirection::Right)]
    #[case::left(50, ExecutableTargetDirection::Left)]
    #[case::random(72, ExecutableTargetDirection::Random)]
    fn directional_locations_lower_to_typed_runtime_axes(
        #[case] raw: i32,
        #[case] expected: ExecutableTargetDirection,
    ) {
        let plan = compile_dbc_target_plan(2, raw, 0).unwrap();
        let [
            Some(ExecutableTargetOperation::AssignDestination(location)),
            None,
        ] = lower_target_plan(&plan).unwrap().operations.into_array()
        else {
            panic!("expected one destination assignment");
        };

        expect_that!(location.direction, eq(expected));
    }

    #[gtest]
    #[rstest]
    #[case::raid(57, TargetPlanAxis::Check, "raid")]
    #[case::trajectory(89, TargetPlanAxis::Algorithm, "trajectory")]
    fn one_axis_reports_one_precise_gap(
        #[case] raw: i32,
        #[case] axis: TargetPlanAxis,
        #[case] value: &'static str,
    ) {
        let plan = compile_dbc_target_plan(2, raw, 0).unwrap();

        expect_that!(
            lower_target_plan(&plan),
            eq(Err(TargetPlanGap {
                selector: Some(raw),
                axis,
                value,
            }))
        );
    }

    #[gtest]
    #[rstest]
    #[case::blade_flurry(18, 16, true)]
    #[case::blade_rush(53, 16, true)]
    #[case::explicit_enemy(6, 0, false)]
    #[case::destination_only(53, 0, false)]
    fn multi_target_classification_comes_from_selection_operations(
        #[case] target_a: i32,
        #[case] target_b: i32,
        #[case] expected: bool,
    ) {
        let plan = compile_dbc_target_plan(2, target_a, target_b).unwrap();

        expect_that!(target_plan_is_multi_target(&plan), eq(expected));
    }

    #[gtest]
    #[rstest]
    #[case::no_actor_or_location(SpellEffectImplicitTarget::None, ImplicitTargetObject::None)]
    #[case::intrinsic_unit(SpellEffectImplicitTarget::None, ImplicitTargetObject::Unit)]
    #[case::intrinsic_destination(
        SpellEffectImplicitTarget::None,
        ImplicitTargetObject::Destination
    )]
    fn intrinsic_effect_fallbacks_do_not_require_an_explicit_actor(
        #[case] implicit: SpellEffectImplicitTarget,
        #[case] object: ImplicitTargetObject,
    ) {
        let plan = TargetPlan {
            operations: TargetPlanOperations::default(),
            fallback: SpellEffectTargetSemantic { implicit, object },
            provenance: TargetPlanProvenance::Dbc {
                target_a: 0,
                target_b: 0,
            },
        };

        expect_that!(
            lower_target_plan(&plan).unwrap().fallback,
            eq(ExecutableTargetFallback::NoSelection)
        );
    }
}