wowlab_engine_combat/

targeting.rs

//! Deterministic selector, filter, and spatial target-shape resolution.

use wowlab_engine_domain::targeting::{
    CandidateFilter, ChainTargetOrigin, ExecutableTargetDirection, ResolvedTargetShape,
    SingleTargetSelector, TargetShapeError,
};
use wowlab_engine_ports::SpatialEnvelope;
use wowlab_types::sim::{
    ActorId, EnemyIdx, GEOMETRY_EPSILON, Position2, SimTime, SpatialLayerId, SpatialTransform,
};

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

mod chain;
mod program;

use chain::{radius_envelope, resolve_chain};
pub(crate) use program::resolve_spell_targets_into;
#[cfg(test)]
use program::spell_target_shapes_with_resolved_geometry;
#[cfg(test)]
pub(crate) use program::{spell_target_shapes, spell_target_shapes_with_destination};

const DIRECTIONAL_SUMMON_DEFAULT_DISTANCE: f64 = 3.0;
pub(crate) const TARGET_WORKSPACE_EXHAUSTED: &str = "finalized target workspace depth exhausted";

pub(crate) fn take_target_workspace(state: &mut CombatInstance) -> Option<TargetWorkspace> {
    let mut workspace = state.runtime.scratch.target_workspaces.pop()?;

    workspace.clear();

    Some(workspace)
}

pub(crate) fn restore_target_workspace(state: &mut CombatInstance, mut workspace: TargetWorkspace) {
    workspace.clear();
    assert!(
        state.runtime.scratch.target_workspaces.len()
            < state.runtime.scratch.target_workspaces.capacity(),
        "restoring target scratch exceeds the finalized workspace pool"
    );
    state.runtime.scratch.target_workspaces.push(workspace);
}

#[derive(Clone, Copy)]
enum RuntimeTargetAnchor {
    Source,
    ExplicitTarget,
    Location(SpatialTransform),
}

#[derive(Clone, Copy)]
struct TargetProgramState {
    source: RuntimeTargetAnchor,
    destination: Option<RuntimeTargetAnchor>,
}

#[derive(Clone, Copy, Default)]
struct TargetProgramPositions {
    source: Option<SpatialTransform>,
    explicit_target: Option<SpatialTransform>,
}

impl TargetProgramState {
    const fn with_destination(destination: Option<SpatialTransform>) -> Self {
        Self {
            source: RuntimeTargetAnchor::Source,
            destination: match destination {
                Some(location) => Some(RuntimeTargetAnchor::Location(location)),
                None => None,
            },
        }
    }
}

impl Default for TargetProgramState {
    fn default() -> Self {
        Self {
            source: RuntimeTargetAnchor::Source,
            destination: None,
        }
    }
}

#[derive(Clone, Copy)]
struct ResolutionContext<'a> {
    program: &'a crate::state::CombatProgram,
    filter: &'a CandidateFilter,
    now: SimTime,
    line_of_sight: LineOfSightPolicy,
}

#[derive(Clone, Copy)]
struct ChainGeometry {
    origin: ChainTargetOrigin,
    jump_radius: f64,
    max_hits: u8,
}

#[derive(Clone, Copy)]
struct ConeGeometry {
    range: f64,
    half_angle: f64,
    heading_offset: f64,
}

#[derive(Clone, Copy)]
struct LineGeometry {
    range: f64,
    half_width: f64,
    heading_offset: f64,
}

#[derive(Clone, Copy)]
// #t(rust_similar_structs) mutable runtime geometry and finalized target execution metadata belong to different lifecycle stages
struct EffectGeometry {
    radius: f64,
    range: f64,
    cone_half_angle: f64,
    face_explicit_target: bool,
}

#[derive(Clone, Copy)]
struct EffectGeometryInput {
    radius: f64,
    range: f64,
}

#[derive(Clone, Copy)]
struct SpellTargetShapeInput {
    anchor: EnemyIdx,
    destination: Option<SpatialTransform>,
    positions: TargetProgramPositions,
    geometry: EffectGeometryInput,
}

#[derive(Debug, Default, Eq, PartialEq)]
struct ResolutionDiagnostics {
    #[cfg(test)]
    broad_phase_candidates: usize,
    #[cfg(test)]
    metadata_checks: usize,
    #[cfg(test)]
    exact_geometry_checks: usize,
    #[cfg(test)]
    line_of_sight_checks: usize,
}

impl ResolutionDiagnostics {
    fn record_broad_phase(&mut self, count: usize) {
        let _ = self;
        let _ = count;

        #[cfg(test)]
        {
            self.broad_phase_candidates += count;
        }
    }

    fn record_metadata_check(&mut self) {
        let _ = self;

        #[cfg(test)]
        {
            self.metadata_checks += 1;
        }
    }

    fn record_exact_geometry(&mut self, count: usize) {
        let _ = self;
        let _ = count;

        #[cfg(test)]
        {
            self.exact_geometry_checks += count;
        }
    }

    fn record_line_of_sight_check(&mut self) {
        let _ = self;

        #[cfg(test)]
        {
            self.line_of_sight_checks += 1;
        }
    }
}

/// Spell-specific line-of-sight policy applied after metadata and exact geometry.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub(crate) enum LineOfSightPolicy {
    Required,
    IgnoreObstructions,
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct SpellTargetRequest {
    pub(crate) source: ActorId,
    pub(crate) source_position: Option<SpatialTransform>,
    pub(crate) anchor: EnemyIdx,
    pub(crate) geometry_effect: crate::state::program::LocalDamageEffectIdx,
    pub(crate) impact_action: crate::state::program::LocalDamageActionIdx,
    pub(crate) target: crate::state::program::FinalizedTargetExecution,
    pub(crate) max_targets: Option<u8>,
    pub(crate) destination: Option<SpatialTransform>,
}

impl LineOfSightPolicy {
    /// Resolve the DBC `IgnoreLineOfSight` attribute into target-selection behavior.
    #[must_use]
    pub(crate) const fn from_ignores_line_of_sight(ignores_line_of_sight: bool) -> Self {
        if ignores_line_of_sight {
            Self::IgnoreObstructions
        } else {
            Self::Required
        }
    }
}

/// Resolve a combat target shape into its deterministic hit order.
///
/// # Errors
///
/// Returns [`TargetShapeError`] when the shape, anchor, source, or spatial query is invalid.
// #t(fn: rust_large_fn_params) the explicit program/instance lifecycle borrows accompany the independent typed targeting inputs.
#[expect(
    clippy::too_many_arguments,
    reason = "the targeting boundary keeps independent typed query inputs explicit"
)]
pub(crate) fn resolve_targets_into(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    source: ActorId,
    shape: &ResolvedTargetShape,
    filter: &CandidateFilter,
    line_of_sight: LineOfSightPolicy,
    now: SimTime,
    workspace: &mut TargetWorkspace,
) -> Result<(), TargetShapeError> {
    shape.validate(state.enemies().len())?;
    let mut diagnostics = ResolutionDiagnostics::default();

    workspace.clear();

    resolve_targets_diagnosed(
        state,
        source,
        shape,
        ResolutionContext {
            program,
            filter,
            now,
            line_of_sight,
        },
        &mut diagnostics,
        workspace,
    );

    Ok(())
}

fn resolve_targets_diagnosed(
    state: &CombatInstance,
    source: ActorId,
    shape: &ResolvedTargetShape,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    match shape {
        ResolvedTargetShape::Single(selector) => {
            if let Some(target) =
                select_one(state, source, *selector, context, diagnostics, workspace)
            {
                workspace.push_target(target);
            }
        }
        ResolvedTargetShape::RadiusFromSource { .. }
        | ResolvedTargetShape::RadiusFromTarget { .. }
        | ResolvedTargetShape::RadiusAtLocation { .. } => {
            resolve_radius_shape(state, source, shape, context, diagnostics, workspace);
        }
        ResolvedTargetShape::Cone { .. }
        | ResolvedTargetShape::ConeFromTarget { .. }
        | ResolvedTargetShape::ConeAtLocation { .. }
        | ResolvedTargetShape::ConeTowardTarget { .. } => {
            resolve_cone_shape(state, source, shape, context, diagnostics, workspace);
        }
        ResolvedTargetShape::Line { .. }
        | ResolvedTargetShape::LineTowardTarget { .. }
        | ResolvedTargetShape::LineAtLocation { .. } => {
            resolve_line_shape(state, source, shape, context, diagnostics, workspace);
        }
        ResolvedTargetShape::Chain {
            anchor,
            origin,
            jump_radius,
            max_hits,
        } => resolve_chain(
            state,
            source,
            *anchor,
            ChainGeometry {
                origin: *origin,
                jump_radius: *jump_radius,
                max_hits: *max_hits,
            },
            context,
            diagnostics,
            workspace,
        ),
        ResolvedTargetShape::Explicit(enemies) => {
            for enemy in enemies.as_slice().iter().copied() {
                if metadata_eligible_counted(
                    context.program,
                    state,
                    enemy,
                    context.filter,
                    diagnostics,
                ) && visible_counted(
                    context.program,
                    state,
                    source,
                    enemy,
                    context.line_of_sight,
                    diagnostics,
                ) {
                    workspace.push_target(enemy);
                }
            }
        }
    }
}

fn resolve_radius_shape(
    state: &CombatInstance,
    source: ActorId,
    shape: &ResolvedTargetShape,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let (origin, radius) = match shape {
        ResolvedTargetShape::RadiusFromSource { radius } => {
            let Some(origin) = state.actor_transform(source) else {
                return;
            };

            (origin, *radius)
        }
        ResolvedTargetShape::RadiusFromTarget { anchor, radius } => {
            let Some(anchor) = select_one(state, source, *anchor, context, diagnostics, workspace)
            else {
                return;
            };
            let Some(origin) = state.actor_transform(ActorId::Enemy(anchor)) else {
                return;
            };

            (origin, *radius)
        }
        ResolvedTargetShape::RadiusAtLocation { location, radius } => (*location, *radius),
        _ => return,
    };

    resolve_radius_at(
        state,
        source,
        origin,
        radius,
        context,
        diagnostics,
        workspace,
    );
}

fn resolve_cone_shape(
    state: &CombatInstance,
    source: ActorId,
    shape: &ResolvedTargetShape,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let (origin, geometry) = match shape {
        ResolvedTargetShape::Cone {
            range,
            half_angle,
            heading_offset,
        } => {
            let Some(origin) = state.actor_transform(source) else {
                return;
            };

            (
                origin,
                ConeGeometry {
                    range: *range,
                    half_angle: *half_angle,
                    heading_offset: *heading_offset,
                },
            )
        }
        ResolvedTargetShape::ConeFromTarget {
            anchor,
            range,
            half_angle,
            heading_offset,
        } => {
            let Some(anchor) = select_one(state, source, *anchor, context, diagnostics, workspace)
            else {
                return;
            };
            let Some(origin) = state.actor_transform(ActorId::Enemy(anchor)) else {
                return;
            };

            (
                origin,
                ConeGeometry {
                    range: *range,
                    half_angle: *half_angle,
                    heading_offset: *heading_offset,
                },
            )
        }
        ResolvedTargetShape::ConeAtLocation {
            location,
            range,
            half_angle,
            heading_offset,
        } => (
            *location,
            ConeGeometry {
                range: *range,
                half_angle: *half_angle,
                heading_offset: *heading_offset,
            },
        ),
        ResolvedTargetShape::ConeTowardTarget {
            anchor,
            range,
            half_angle,
            heading_offset,
        } => {
            let Some(origin) = state.actor_transform(source) else {
                return;
            };
            let Some(anchor) = select_one(state, source, *anchor, context, diagnostics, workspace)
            else {
                return;
            };
            let Some(target) = state.actor_transform(ActorId::Enemy(anchor)) else {
                return;
            };

            (
                SpatialTransform {
                    heading: heading_toward(origin.position, target.position),
                    ..origin
                },
                ConeGeometry {
                    range: *range,
                    half_angle: *half_angle,
                    heading_offset: *heading_offset,
                },
            )
        }
        _ => return,
    };

    resolve_cone_at(
        state,
        source,
        origin,
        geometry,
        context,
        diagnostics,
        workspace,
    );
}

fn resolve_line_shape(
    state: &CombatInstance,
    source: ActorId,
    shape: &ResolvedTargetShape,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let (origin, geometry) = match shape {
        ResolvedTargetShape::Line {
            range,
            half_width,
            heading_offset,
        } => {
            let Some(origin) = state.actor_transform(source) else {
                return;
            };

            (
                origin,
                LineGeometry {
                    range: *range,
                    half_width: *half_width,
                    heading_offset: *heading_offset,
                },
            )
        }
        ResolvedTargetShape::LineTowardTarget {
            anchor,
            range,
            half_width,
            heading_offset,
        } => {
            let Some(origin) = state.actor_transform(source) else {
                return;
            };
            let Some(anchor) = select_one(state, source, *anchor, context, diagnostics, workspace)
            else {
                return;
            };
            let Some(target) = state.actor_transform(ActorId::Enemy(anchor)) else {
                return;
            };

            (
                SpatialTransform {
                    heading: heading_toward(origin.position, target.position),
                    ..origin
                },
                LineGeometry {
                    range: *range,
                    half_width: *half_width,
                    heading_offset: *heading_offset,
                },
            )
        }
        ResolvedTargetShape::LineAtLocation {
            location,
            range,
            half_width,
            heading_offset,
        } => (
            *location,
            LineGeometry {
                range: *range,
                half_width: *half_width,
                heading_offset: *heading_offset,
            },
        ),
        _ => return,
    };

    resolve_line_at(
        state,
        source,
        origin,
        geometry,
        context,
        diagnostics,
        workspace,
    );
}

// #t(fn: rust_large_fn_params) target resolution keeps program, geometry, diagnostics, and caller-owned scratch as independent borrows.
fn resolve_radius_at(
    state: &CombatInstance,
    source: ActorId,
    origin: SpatialTransform,
    radius: f64,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    fill_spatial_candidates(
        state,
        origin.layer,
        radius_envelope(origin.position, radius),
        diagnostics,
        workspace,
    );
    workspace.retain_candidates(|enemy| {
        metadata_eligible_counted(context.program, state, enemy, context.filter, diagnostics)
    });
    diagnostics.record_exact_geometry(workspace.candidate_count());
    workspace.retain_candidates(|enemy| {
        state
            .actor_transform(ActorId::Enemy(enemy))
            .is_some_and(|target| {
                target.layer == origin.layer
                    && origin.position.distance(target.position) <= radius + GEOMETRY_EPSILON
            })
    });
    append_visible_candidates(state, source, context, diagnostics, workspace);
}

// #t(fn: rust_large_fn_params) target resolution keeps program, geometry, diagnostics, and caller-owned scratch as independent borrows.
fn resolve_cone_at(
    state: &CombatInstance,
    source: ActorId,
    origin: SpatialTransform,
    geometry: ConeGeometry,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let heading = origin.heading + geometry.heading_offset;

    fill_spatial_candidates(
        state,
        origin.layer,
        radius_envelope(origin.position, geometry.range),
        diagnostics,
        workspace,
    );
    workspace.retain_candidates(|enemy| {
        metadata_eligible_counted(context.program, state, enemy, context.filter, diagnostics)
    });
    diagnostics.record_exact_geometry(workspace.candidate_count());
    workspace.retain_candidates(|enemy| {
        state
            .actor_transform(ActorId::Enemy(enemy))
            .is_some_and(|target| {
                target.layer == origin.layer
                    && point_in_cone(
                        target.position,
                        origin.position,
                        heading,
                        geometry.half_angle,
                        geometry.range,
                    )
            })
    });
    append_visible_candidates(state, source, context, diagnostics, workspace);
}

// #t(fn: rust_large_fn_params) target resolution keeps program, geometry, diagnostics, and caller-owned scratch as independent borrows.
fn resolve_line_at(
    state: &CombatInstance,
    source: ActorId,
    origin: SpatialTransform,
    geometry: LineGeometry,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let heading = origin.heading + geometry.heading_offset;

    fill_spatial_candidates(
        state,
        origin.layer,
        radius_envelope(origin.position, geometry.range),
        diagnostics,
        workspace,
    );
    workspace.retain_candidates(|enemy| {
        metadata_eligible_counted(context.program, state, enemy, context.filter, diagnostics)
    });
    diagnostics.record_exact_geometry(workspace.candidate_count());
    workspace.retain_candidates(|enemy| {
        state
            .actor_transform(ActorId::Enemy(enemy))
            .is_some_and(|target| {
                target.layer == origin.layer
                    && point_in_line(
                        target.position,
                        origin.position,
                        heading,
                        geometry.range,
                        geometry.half_width,
                    )
            })
    });
    append_visible_candidates(state, source, context, diagnostics, workspace);
}

fn heading_toward(origin: Position2, target: Position2) -> f64 {
    (target.y - origin.y).atan2(target.x - origin.x)
}

fn direction_angle(
    direction: ExecutableTargetDirection,
    rng: Option<&mut dyn FnMut() -> f64>,
) -> Result<f64, TargetShapeError> {
    use std::f64::consts::{FRAC_PI_2, FRAC_PI_4, PI, TAU};

    const THREE_QUARTER_TURN: f64 = 3.0 * FRAC_PI_4;

    Ok(match direction {
        ExecutableTargetDirection::None | ExecutableTargetDirection::Front => 0.0,
        ExecutableTargetDirection::Back => PI,
        ExecutableTargetDirection::Right => -FRAC_PI_2,
        ExecutableTargetDirection::Left => FRAC_PI_2,
        ExecutableTargetDirection::FrontRight => -FRAC_PI_4,
        ExecutableTargetDirection::BackRight => -THREE_QUARTER_TURN,
        ExecutableTargetDirection::BackLeft => THREE_QUARTER_TURN,
        ExecutableTargetDirection::FrontLeft => FRAC_PI_4,
        ExecutableTargetDirection::Random => {
            rng.ok_or_else(TargetShapeError::missing_direction_rng)?() * TAU
        }
    })
}

fn point_in_line(
    point: Position2,
    origin: Position2,
    heading: f64,
    range: f64,
    half_width: f64,
) -> bool {
    let dx = point.x - origin.x;
    let dy = point.y - origin.y;
    let forward = dx * heading.cos() + dy * heading.sin();
    let lateral = -dx * heading.sin() + dy * heading.cos();
    let distance_sq = dx * dx + dy * dy;

    forward >= -GEOMETRY_EPSILON
        && distance_sq <= range * range + GEOMETRY_EPSILON
        && lateral.abs() <= half_width + GEOMETRY_EPSILON
}

fn point_in_cone(
    point: Position2,
    apex: Position2,
    heading: f64,
    half_angle: f64,
    range: f64,
) -> bool {
    let distance = apex.distance(point);

    if distance > range + GEOMETRY_EPSILON {
        return false;
    }

    if distance <= GEOMETRY_EPSILON {
        return true;
    }

    let angle = (point.y - apex.y).atan2(point.x - apex.x);
    let mut delta = (angle - heading) % std::f64::consts::TAU;

    if delta > std::f64::consts::PI {
        delta -= std::f64::consts::TAU;
    }

    if delta < -std::f64::consts::PI {
        delta += std::f64::consts::TAU;
    }

    delta.abs() <= half_angle + GEOMETRY_EPSILON
}

// #t(fn: rust_max_fn_lines) exhaustive selector semantics and their deterministic tie-breaking remain auditable in one match.
fn select_one(
    state: &CombatInstance,
    source: ActorId,
    selector: SingleTargetSelector,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) -> Option<EnemyIdx> {
    match selector {
        SingleTargetSelector::Current => state
            .current_target()
            .filter(|enemy| {
                metadata_eligible_counted(
                    context.program,
                    state,
                    *enemy,
                    context.filter,
                    diagnostics,
                )
            })
            .filter(|enemy| {
                visible_counted(
                    context.program,
                    state,
                    source,
                    *enemy,
                    context.line_of_sight,
                    diagnostics,
                )
            }),
        SingleTargetSelector::Primary => if metadata_eligible_counted(
            context.program,
            state,
            EnemyIdx::PRIMARY,
            context.filter,
            diagnostics,
        ) {
            {
                visible_counted(
                    context.program,
                    state,
                    source,
                    EnemyIdx::PRIMARY,
                    context.line_of_sight,
                    diagnostics,
                )
            }
        } else {
            false
        }
        .then_some(EnemyIdx::PRIMARY),
        SingleTargetSelector::Explicit(enemy) => {
            if metadata_eligible_counted(context.program, state, enemy, context.filter, diagnostics)
            {
                visible_counted(
                    context.program,
                    state,
                    source,
                    enemy,
                    context.line_of_sight,
                    diagnostics,
                )
            } else {
                false
            }
            .then_some(enemy)
        }
        SingleTargetSelector::Nearest => {
            let origin = state.actor_transform(source)?;
            let count = state.spatial_query().actors_by_distance_into(
                origin.layer,
                origin.position,
                None,
                workspace.candidate_storage(),
            );

            workspace.set_candidate_count(count);

            (0..workspace.candidate_count()).find_map(|index| {
                let enemy = workspace.candidate_at(index)?;

                diagnostics.record_broad_phase(1);

                if !metadata_eligible_counted(
                    context.program,
                    state,
                    enemy,
                    context.filter,
                    diagnostics,
                ) {
                    return None;
                }

                diagnostics.record_exact_geometry(1);

                visible_counted(
                    context.program,
                    state,
                    source,
                    enemy,
                    context.line_of_sight,
                    diagnostics,
                )
                .then_some(enemy)
            })
        }
        SingleTargetSelector::Farthest => {
            let origin = state.actor_transform(source)?;

            fill_layer_candidates(state, origin.layer, diagnostics, workspace);
            workspace.retain_candidates(|enemy| {
                metadata_eligible_counted(
                    context.program,
                    state,
                    enemy,
                    context.filter,
                    diagnostics,
                )
            });

            diagnostics.record_exact_geometry(workspace.candidate_count());

            workspace
                .candidates()
                .iter()
                .copied()
                .filter(|enemy| {
                    visible_counted(
                        context.program,
                        state,
                        source,
                        *enemy,
                        context.line_of_sight,
                        diagnostics,
                    )
                })
                .max_by(|left, right| {
                    let left_distance = state
                        .actor_transform(ActorId::Enemy(*left))
                        .map(|transform| origin.position.distance(transform.position))
                        .unwrap_or_default();
                    let right_distance = state
                        .actor_transform(ActorId::Enemy(*right))
                        .map(|transform| origin.position.distance(transform.position))
                        .unwrap_or_default();

                    left_distance
                        .total_cmp(&right_distance)
                        .then_with(|| right.cmp(left))
                })
        }
        SingleTargetSelector::LowestHealth => {
            let origin = state.actor_transform(source)?;

            fill_layer_candidates(state, origin.layer, diagnostics, workspace);
            workspace.retain_candidates(|enemy| {
                metadata_eligible_counted(
                    context.program,
                    state,
                    enemy,
                    context.filter,
                    diagnostics,
                )
            });

            workspace
                .candidates()
                .iter()
                .copied()
                .filter(|enemy| {
                    visible_counted(
                        context.program,
                        state,
                        source,
                        *enemy,
                        context.line_of_sight,
                        diagnostics,
                    )
                })
                .min_by(|left, right| {
                    let left_health = state
                        .enemy_health_fraction(context.program, *left, context.now)
                        .unwrap_or(1.0);
                    let right_health = state
                        .enemy_health_fraction(context.program, *right, context.now)
                        .unwrap_or(1.0);

                    left_health
                        .total_cmp(&right_health)
                        .then_with(|| left.cmp(right))
                })
        }
    }
}

fn metadata_eligible_counted(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    enemy: EnemyIdx,
    filter: &CandidateFilter,
    diagnostics: &mut ResolutionDiagnostics,
) -> bool {
    diagnostics.record_metadata_check();

    metadata_eligible(program, state, enemy, filter)
}

fn metadata_eligible(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    enemy: EnemyIdx,
    filter: &CandidateFilter,
) -> bool {
    if !state.is_valid_target(enemy) {
        return false;
    }

    program.enemy_definition(enemy).is_some_and(|definition| {
        filter.matches(
            definition.group_id(),
            definition.enemy_tags(),
            definition.group_tags(),
        )
    })
}

fn visible_counted(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    source: ActorId,
    enemy: EnemyIdx,
    line_of_sight: LineOfSightPolicy,
    diagnostics: &mut ResolutionDiagnostics,
) -> bool {
    match line_of_sight {
        LineOfSightPolicy::Required => {
            diagnostics.record_line_of_sight_check();

            state.has_line_of_sight(program, source, enemy)
        }
        LineOfSightPolicy::IgnoreObstructions => state
            .actor_transform(source)
            .zip(state.actor_transform(ActorId::Enemy(enemy)))
            .is_some_and(|(source, target)| source.layer == target.layer),
    }
}

fn append_visible_candidates(
    state: &CombatInstance,
    source: ActorId,
    context: ResolutionContext<'_>,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let count = workspace.candidate_count();

    for index in 0..count {
        let Some(enemy) = workspace.candidate_at(index) else {
            continue;
        };

        if visible_counted(
            context.program,
            state,
            source,
            enemy,
            context.line_of_sight,
            diagnostics,
        ) && !workspace.contains_target(enemy)
        {
            workspace.push_target(enemy);
        }
    }
}

fn fill_layer_candidates(
    state: &CombatInstance,
    layer: SpatialLayerId,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let count = state
        .spatial_query()
        .candidates_on_layer_into(layer, workspace.candidate_storage());

    workspace.set_candidate_count(count);
    diagnostics.record_broad_phase(count);
}

fn fill_spatial_candidates(
    state: &CombatInstance,
    layer: SpatialLayerId,
    envelope: SpatialEnvelope,
    diagnostics: &mut ResolutionDiagnostics,
    workspace: &mut TargetWorkspace,
) {
    let count = state.spatial_query().candidates_in_envelope_into(
        layer,
        envelope,
        workspace.candidate_storage(),
    );

    workspace.set_candidate_count(count);
    diagnostics.record_broad_phase(count);
}

#[cfg(test)]
mod tests;