rakata_generics/decoded/

utc.rs

//! Decoded view over [`Utc`].
//!
//! Mirrors the two-stage shape established by
//! [`UtiProjection`](super::uti::UtiProjection) /
//! [`UtiResolved`](super::uti::UtiResolved) in [`super::uti`]. The
//! projection wraps the source
//! [`Utc`] reference for file-native access; the resolved view adds the
//! resolved data the view's query methods read from. Coverage:
//! scalar-id resolutions (race, appearance, portrait, soundset,
//! alignment), typed [`DecodedClass`] variants over `ClassList`,
//! typed [`DecodedSpecialAbility`] variants over `SpecAbilityList`,
//! and typed [`DecodedFeat`] variants over `FeatList`.

use rakata_core::tables;
use rakata_formats::twoda::{TwoDa, TwoDaSource};

use crate::utc::{Utc, UtcClass, UtcEquipmentItem, UtcInventoryItem, UtcSpecialAbility};

/// One decoded entry from a UTC's `FeatList`, dispatched by matching
/// the `feat.2da` row's `label` cell against the set of vanilla feat
/// labels the corpus references.
///
/// Vanilla `FeatList` entries carry a single `Feat: u16` field, so
/// every typed variant has the same shape: a raw `feat_id` preserved
/// from the source GFF. Dispatch is by `label`, not by raw `feat_id`,
/// so a mod that re-numbers a vanilla feat still routes to its typed
/// variant.
///
/// Mod-added rows, vanilla feat rows the corpus never assigns, and
/// missing or out-of-range entries all surface as
/// [`DecodedFeat::Unknown`] carrying the raw id and the resolved
/// label (when reachable).
// CLIPPY: feat family prefixes (`ArmourProf`, `WeaponProf`,
// `WeaponFocus`, `WeaponSpec`, with `ForceJump`, `SneakAttack`,
// `DroidUpgrade`, etc. arriving in later commits) are load-bearing
// for grouping; the shared prefix is the feat family, not noise.
#[allow(clippy::enum_variant_names)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DecodedFeat {
    /// `feat.2da` label `ARMOUR_PROF_LIGHT`. Vanilla row 5.
    ArmourProfLight {
        /// Raw `feat_id` (the GFF integer the dispatch resolved from).
        feat_id: u16,
    },
    /// `feat.2da` label `ARMOUR_PROF_MEDIUM`. Vanilla row 6.
    ArmourProfMedium {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `ARMOUR_PROF_HEAVY`. Vanilla row 4.
    ArmourProfHeavy {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_PROF_BLASTER`. Vanilla row 39.
    WeaponProfBlaster {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_PROF_BLASTER_RIFLE`. Vanilla row 40.
    WeaponProfBlasterRifle {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_PROF_HEAVY_WEAPONS`. Vanilla row 42.
    WeaponProfHeavyWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_PROF_MELEE_WEAPONS`. Vanilla row 44.
    WeaponProfMeleeWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_PROF_LIGHTSABER`. Vanilla row 43.
    WeaponProfLightsaber {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_PROF_GRENADE` (the `XXXX_`
    /// prefix marks the feat as deprecated by Bioware; vanilla UTCs
    /// still load it). Vanilla row 41.
    WeaponProfGrenade {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_PROF_SIMPLE_WEAPONS`. Vanilla
    /// row 45.
    WeaponProfSimpleWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `PROFICIENCY_ALL`. Vanilla row 93. The
    /// catch-all proficiency granted to special and cutscene
    /// creatures.
    ProficiencyAll {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_FOCUS_BLASTER`. Vanilla row 32.
    WeaponFocusBlaster {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_FOCUS_BLASTER_RIFLE`. Vanilla row 33.
    WeaponFocusBlasterRifle {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_FOCUS_GRENADE`. Vanilla row 34.
    WeaponFocusGrenade {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_FOCUS_HEAVY_WEAPONS`. Vanilla row 35.
    WeaponFocusHeavyWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_FOCUS_LIGHTSABER`. Vanilla row 36.
    WeaponFocusLightsaber {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_FOCUS_MELEE_WEAPONS`. Vanilla row 37.
    WeaponFocusMeleeWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_FOCUS_SIMPLE_WEAPONS`. Vanilla
    /// row 38.
    WeaponFocusSimpleWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_SPEC_BLASTER`. Vanilla row 46.
    WeaponSpecBlaster {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_SPEC_BLASTER_RIFLE`. Vanilla row 47.
    WeaponSpecBlasterRifle {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_SPEC_GRENADE`. Vanilla row 48.
    WeaponSpecGrenade {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_SPEC_HEAVY_WEAPONS`. Vanilla row 49.
    WeaponSpecHeavyWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_SPEC_LIGHTSABER`. Vanilla row 50.
    WeaponSpecLightsaber {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WEAPON_SPEC_MELEE_WEAPONS`. Vanilla row 51.
    WeaponSpecMeleeWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_WEAPON_SPEC_SIMPLE_WEAPONS`. Vanilla
    /// row 52.
    WeaponSpecSimpleWeapons {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `POWER_ATTACK`. Vanilla row 28.
    PowerAttack {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_POWER_ATTACK`. Vanilla row 17.
    ImprovedPowerAttack {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_POWER_ATTACK`. Vanilla row 83.
    MasterPowerAttack {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `POWER_BLAST`. Vanilla row 29.
    PowerBlast {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_POWER_BLAST`. Vanilla row 18.
    ImprovedPowerBlast {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_POWER_BLAST`. Vanilla row 82.
    MasterPowerBlast {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `CRITICAL_STRIKE`. Vanilla row 8.
    CriticalStrike {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_CRITICAL_STRIKE`. Vanilla row 19.
    ImprovedCriticalStrike {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_CRITICAL_STRIKE`. Vanilla row 81.
    MasterCriticalStrike {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FLURRY`. Vanilla row 11.
    Flurry {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_FLURRY`. Vanilla row 91.
    ImprovedFlurry {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNIPER_SHOT`. Vanilla row 31.
    SniperShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_SNIPER_SHOT`. Vanilla row 20.
    ImprovedSniperShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_SNIPER_SHOT`. Vanilla row 77.
    MasterSniperShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `RAPID_SHOT`. Vanilla row 30.
    RapidShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_RAPID_SHOT`. Vanilla row 92.
    ImprovedRapidShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MULTI_SHOT`. Vanilla row 26.
    MultiShot {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WHIRLWIND_ATTACK`. Vanilla row 53.
    WhirlwindAttack {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `TWO_WEAPON_FIGHTING`. Vanilla row 3.
    TwoWeaponFighting {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `TWO_WEAPON_ADVANCED`. Vanilla row 9.
    TwoWeaponAdvanced {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `TWO_WEAPON_MASTERY`. Vanilla row 85.
    TwoWeaponMastery {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `JEDI_DEFENSE`. Vanilla row 55.
    JediDefense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `ADVANCED_JEDI_DEFENSE`. Vanilla row 1.
    AdvancedJediDefense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_JEDI_DEFENSE`. Vanilla row 24.
    MasterJediDefense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_FOCUS`. Vanilla row 88. Sense-school
    /// focus tier.
    ForceFocus {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_FOCUS_ADVANCED`. Vanilla row 89.
    ForceFocusAdvanced {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_FOCUS_MASTERY`. Vanilla row 90.
    ForceFocusMastery {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_FORCE_FOCUS_ALTER`. Vanilla row 86.
    /// Alter-school focus, deprecated by Bioware but still loaded.
    ForceFocusAlter {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_FORCE_FOCUS_CONTROL`. Vanilla row 87.
    /// Control-school focus, deprecated by Bioware but still loaded.
    ForceFocusControl {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_JUMP`. Vanilla row 101.
    ForceJump {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_JUMP_ADVANCED`. Vanilla row 102.
    ForceJumpAdvanced {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_JUMP_MASTERY`. Vanilla row 103.
    ForceJumpMastery {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_IMMUNITY_FEAR`. Vanilla row 98.
    ForceImmunityFear {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_IMMUNITY_STUN`. Vanilla row 99.
    ForceImmunityStun {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_IMMUNITY_PARALYSIS`. Vanilla row 100.
    ForceImmunityParalysis {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `BATTLE_MEDITATION`. Vanilla row 94. Bastila
    /// signature feat.
    BattleMeditation {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `FORCE_CAMOFLAGE`. Vanilla row 97. Spelling
    /// reflects the vanilla label, which is missing the second `u`.
    ForceCamoflage {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_1D6`. Vanilla row 60.
    SneakAttack1D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_2D6`. Vanilla row 61.
    SneakAttack2D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_3D6`. Vanilla row 62.
    SneakAttack3D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_4D6`. Vanilla row 63.
    SneakAttack4D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_5D6`. Vanilla row 64.
    SneakAttack5D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SNEAK_ATTACK_6D6`. Vanilla row 65.
    SneakAttack6D6 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `UNCANNY_DODGE_1`. Vanilla row 56.
    UncannyDodge1 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `UNCANNY_DODGE_2`. Vanilla row 57.
    UncannyDodge2 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `TOUGHNESS`. Vanilla row 84.
    Toughness {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_TOUGHNESS`. Vanilla row 123.
    ImprovedToughness {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_TOUGHNESS`. Vanilla row 124.
    MasterToughness {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `CONDITIONING`. Vanilla row 13.
    Conditioning {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPROVED_CONDITIONING`. Vanilla row 21.
    ImprovedConditioning {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_CONDITIONING`. Vanilla row 22.
    MasterConditioning {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPLANT_LEVEL_1`. Vanilla row 14.
    ImplantLevel1 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPLANT_LEVEL_2`. Vanilla row 15.
    ImplantLevel2 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `IMPLANT_LEVEL_3`. Vanilla row 16.
    ImplantLevel3 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `DROID_UPGRADE_1`. Vanilla row 78.
    DroidUpgrade1 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `DROID_UPGRADE_2`. Vanilla row 79.
    DroidUpgrade2 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `DROID_UPGRADE_3`. Vanilla row 80.
    DroidUpgrade3 {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `BLASTER_INTEGRATION`. Vanilla row 96. Droid
    /// combat integration upgrade.
    BlasterIntegration {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `LOGIC_UPGRADE_COMBAT`. Vanilla row 110.
    LogicUpgradeCombat {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `LOGIC_UPGRADE_TACTICIAN`. Vanilla row 111.
    LogicUpgradeTactician {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `DUELING`. Vanilla row 113.
    Dueling {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `ADVANCED_DUELING`. Vanilla row 114.
    AdvancedDueling {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_DUELING`. Vanilla row 115.
    MasterDueling {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `JEDI_SENSE`. Vanilla row 107. Padawan-tier
    /// danger sense feat.
    JediSense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `KNIGHT_SENSE`. Vanilla row 108.
    KnightSense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `MASTER_SENSE`. Vanilla row 109.
    MasterSense {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_GUARD_STANCE`. Vanilla row 54. Cut
    /// feat still wired into vanilla UTCs.
    GuardStance {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_ADVANCED_GUARD_STANCE`. Vanilla row 2.
    AdvancedGuardStance {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_MASTER_GUARD_STANCE`. Vanilla row 25.
    MasterGuardStance {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_SKILL_FOCUS_AWARENESS`. Vanilla row 72.
    /// Deprecated skill-focus feat still wired into a handful of
    /// vanilla UTCs.
    SkillFocusAwareness {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_SKILL_FOCUS_TREAT_INJURY`. Vanilla
    /// row 76.
    SkillFocusTreatInjury {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_SKILL_FOCUS_STEALTH`. Vanilla row 71.
    SkillFocusStealth {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `CAUTIOUS`. Vanilla row 7. Save bonus
    /// granted to specific encounter NPCs.
    Cautious {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `XXXX_PERCEPTIVE`. Vanilla row 27. Cut feat
    /// still wired into a handful of vanilla UTCs.
    Perceptive {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `EMPATHY`. Vanilla row 10.
    Empathy {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `GEAR_HEAD`. Vanilla row 12.
    GearHead {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `WOOKIE_ENDURANCE`. Vanilla row 95.
    WookieEndurance {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// `feat.2da` label `SCOUNDRELS_LUCK`. Vanilla row 104.
    ScoundrelsLuck {
        /// Raw `feat_id`.
        feat_id: u16,
    },
    /// Feat identity could not be matched to any typed variant.
    /// Carries the raw `feat_id` plus the resolved label when
    /// reachable so consumers can still display something useful for
    /// mod-added or untyped feats.
    Unknown {
        /// Raw `feat_id` from the GFF.
        feat_id: u16,
        /// Resolved `label` cell from `feat.2da` at row `feat_id`,
        /// or `None` when the table is unavailable, the row does not
        /// exist, or the label cell is missing.
        feat_label: Option<String>,
    },
}

impl DecodedFeat {
    /// Returns the raw `feat_id` regardless of variant.
    pub fn feat_id(&self) -> u16 {
        match self {
            Self::ArmourProfLight { feat_id }
            | Self::ArmourProfMedium { feat_id }
            | Self::ArmourProfHeavy { feat_id }
            | Self::WeaponProfBlaster { feat_id }
            | Self::WeaponProfBlasterRifle { feat_id }
            | Self::WeaponProfHeavyWeapons { feat_id }
            | Self::WeaponProfMeleeWeapons { feat_id }
            | Self::WeaponProfLightsaber { feat_id }
            | Self::WeaponProfGrenade { feat_id }
            | Self::WeaponProfSimpleWeapons { feat_id }
            | Self::ProficiencyAll { feat_id }
            | Self::WeaponFocusBlaster { feat_id }
            | Self::WeaponFocusBlasterRifle { feat_id }
            | Self::WeaponFocusGrenade { feat_id }
            | Self::WeaponFocusHeavyWeapons { feat_id }
            | Self::WeaponFocusLightsaber { feat_id }
            | Self::WeaponFocusMeleeWeapons { feat_id }
            | Self::WeaponFocusSimpleWeapons { feat_id }
            | Self::WeaponSpecBlaster { feat_id }
            | Self::WeaponSpecBlasterRifle { feat_id }
            | Self::WeaponSpecGrenade { feat_id }
            | Self::WeaponSpecHeavyWeapons { feat_id }
            | Self::WeaponSpecLightsaber { feat_id }
            | Self::WeaponSpecMeleeWeapons { feat_id }
            | Self::WeaponSpecSimpleWeapons { feat_id }
            | Self::PowerAttack { feat_id }
            | Self::ImprovedPowerAttack { feat_id }
            | Self::MasterPowerAttack { feat_id }
            | Self::PowerBlast { feat_id }
            | Self::ImprovedPowerBlast { feat_id }
            | Self::MasterPowerBlast { feat_id }
            | Self::CriticalStrike { feat_id }
            | Self::ImprovedCriticalStrike { feat_id }
            | Self::MasterCriticalStrike { feat_id }
            | Self::Flurry { feat_id }
            | Self::ImprovedFlurry { feat_id }
            | Self::SniperShot { feat_id }
            | Self::ImprovedSniperShot { feat_id }
            | Self::MasterSniperShot { feat_id }
            | Self::RapidShot { feat_id }
            | Self::ImprovedRapidShot { feat_id }
            | Self::MultiShot { feat_id }
            | Self::WhirlwindAttack { feat_id }
            | Self::TwoWeaponFighting { feat_id }
            | Self::TwoWeaponAdvanced { feat_id }
            | Self::TwoWeaponMastery { feat_id }
            | Self::JediDefense { feat_id }
            | Self::AdvancedJediDefense { feat_id }
            | Self::MasterJediDefense { feat_id }
            | Self::ForceFocus { feat_id }
            | Self::ForceFocusAdvanced { feat_id }
            | Self::ForceFocusMastery { feat_id }
            | Self::ForceFocusAlter { feat_id }
            | Self::ForceFocusControl { feat_id }
            | Self::ForceJump { feat_id }
            | Self::ForceJumpAdvanced { feat_id }
            | Self::ForceJumpMastery { feat_id }
            | Self::ForceImmunityFear { feat_id }
            | Self::ForceImmunityStun { feat_id }
            | Self::ForceImmunityParalysis { feat_id }
            | Self::BattleMeditation { feat_id }
            | Self::ForceCamoflage { feat_id }
            | Self::SneakAttack1D6 { feat_id }
            | Self::SneakAttack2D6 { feat_id }
            | Self::SneakAttack3D6 { feat_id }
            | Self::SneakAttack4D6 { feat_id }
            | Self::SneakAttack5D6 { feat_id }
            | Self::SneakAttack6D6 { feat_id }
            | Self::UncannyDodge1 { feat_id }
            | Self::UncannyDodge2 { feat_id }
            | Self::Toughness { feat_id }
            | Self::ImprovedToughness { feat_id }
            | Self::MasterToughness { feat_id }
            | Self::Conditioning { feat_id }
            | Self::ImprovedConditioning { feat_id }
            | Self::MasterConditioning { feat_id }
            | Self::ImplantLevel1 { feat_id }
            | Self::ImplantLevel2 { feat_id }
            | Self::ImplantLevel3 { feat_id }
            | Self::DroidUpgrade1 { feat_id }
            | Self::DroidUpgrade2 { feat_id }
            | Self::DroidUpgrade3 { feat_id }
            | Self::BlasterIntegration { feat_id }
            | Self::LogicUpgradeCombat { feat_id }
            | Self::LogicUpgradeTactician { feat_id }
            | Self::Dueling { feat_id }
            | Self::AdvancedDueling { feat_id }
            | Self::MasterDueling { feat_id }
            | Self::JediSense { feat_id }
            | Self::KnightSense { feat_id }
            | Self::MasterSense { feat_id }
            | Self::GuardStance { feat_id }
            | Self::AdvancedGuardStance { feat_id }
            | Self::MasterGuardStance { feat_id }
            | Self::SkillFocusAwareness { feat_id }
            | Self::SkillFocusTreatInjury { feat_id }
            | Self::SkillFocusStealth { feat_id }
            | Self::Cautious { feat_id }
            | Self::Perceptive { feat_id }
            | Self::Empathy { feat_id }
            | Self::GearHead { feat_id }
            | Self::WookieEndurance { feat_id }
            | Self::ScoundrelsLuck { feat_id }
            | Self::Unknown { feat_id, .. } => *feat_id,
        }
    }
}

/// Resolves a `feat.2da` row label for a UTC feat entry, then
/// dispatches into the typed [`DecodedFeat`] variant or `Unknown`.
///
/// Dispatch is by `label`, not by raw `feat_id`, so a mod that
/// re-numbers a vanilla feat still routes correctly. A missing
/// `feat.2da`, an out-of-range `feat_id`, an absent `label` cell, or
/// a label unknown to the dispatch table all surface as
/// [`DecodedFeat::Unknown`] carrying whichever raw fields and
/// resolved label could be recovered.
fn dispatch_feat(feat_id: u16, feat_table: Option<&TwoDa>) -> DecodedFeat {
    let label = feat_table.and_then(|table| {
        let row = usize::from(feat_id);
        if row >= table.rows.len() {
            return None;
        }
        table.cell(row, "label").map(str::to_string)
    });
    match label.as_deref() {
        // Armour proficiency.
        Some("ARMOUR_PROF_LIGHT") => DecodedFeat::ArmourProfLight { feat_id },
        Some("ARMOUR_PROF_MEDIUM") => DecodedFeat::ArmourProfMedium { feat_id },
        Some("ARMOUR_PROF_HEAVY") => DecodedFeat::ArmourProfHeavy { feat_id },
        // Weapon proficiency. XXXX_* labels are vanilla-deprecated
        // markers; the feats themselves still load.
        Some("WEAPON_PROF_BLASTER") => DecodedFeat::WeaponProfBlaster { feat_id },
        Some("WEAPON_PROF_BLASTER_RIFLE") => DecodedFeat::WeaponProfBlasterRifle { feat_id },
        Some("WEAPON_PROF_HEAVY_WEAPONS") => DecodedFeat::WeaponProfHeavyWeapons { feat_id },
        Some("WEAPON_PROF_MELEE_WEAPONS") => DecodedFeat::WeaponProfMeleeWeapons { feat_id },
        Some("WEAPON_PROF_LIGHTSABER") => DecodedFeat::WeaponProfLightsaber { feat_id },
        Some("XXXX_WEAPON_PROF_GRENADE") => DecodedFeat::WeaponProfGrenade { feat_id },
        Some("XXXX_WEAPON_PROF_SIMPLE_WEAPONS") => DecodedFeat::WeaponProfSimpleWeapons { feat_id },
        // Catch-all proficiency, granted to special / cutscene creatures.
        Some("PROFICIENCY_ALL") => DecodedFeat::ProficiencyAll { feat_id },
        // Weapon focus.
        Some("WEAPON_FOCUS_BLASTER") => DecodedFeat::WeaponFocusBlaster { feat_id },
        Some("WEAPON_FOCUS_BLASTER_RIFLE") => DecodedFeat::WeaponFocusBlasterRifle { feat_id },
        Some("XXXX_WEAPON_FOCUS_GRENADE") => DecodedFeat::WeaponFocusGrenade { feat_id },
        Some("WEAPON_FOCUS_HEAVY_WEAPONS") => DecodedFeat::WeaponFocusHeavyWeapons { feat_id },
        Some("WEAPON_FOCUS_LIGHTSABER") => DecodedFeat::WeaponFocusLightsaber { feat_id },
        Some("WEAPON_FOCUS_MELEE_WEAPONS") => DecodedFeat::WeaponFocusMeleeWeapons { feat_id },
        Some("XXXX_WEAPON_FOCUS_SIMPLE_WEAPONS") => {
            DecodedFeat::WeaponFocusSimpleWeapons { feat_id }
        }
        // Weapon specialization.
        Some("WEAPON_SPEC_BLASTER") => DecodedFeat::WeaponSpecBlaster { feat_id },
        Some("WEAPON_SPEC_BLASTER_RIFLE") => DecodedFeat::WeaponSpecBlasterRifle { feat_id },
        Some("XXXX_WEAPON_SPEC_GRENADE") => DecodedFeat::WeaponSpecGrenade { feat_id },
        Some("WEAPON_SPEC_HEAVY_WEAPONS") => DecodedFeat::WeaponSpecHeavyWeapons { feat_id },
        Some("WEAPON_SPEC_LIGHTSABER") => DecodedFeat::WeaponSpecLightsaber { feat_id },
        Some("WEAPON_SPEC_MELEE_WEAPONS") => DecodedFeat::WeaponSpecMeleeWeapons { feat_id },
        Some("XXXX_WEAPON_SPEC_SIMPLE_WEAPONS") => DecodedFeat::WeaponSpecSimpleWeapons { feat_id },
        // Power Attack ladder.
        Some("POWER_ATTACK") => DecodedFeat::PowerAttack { feat_id },
        Some("IMPROVED_POWER_ATTACK") => DecodedFeat::ImprovedPowerAttack { feat_id },
        Some("MASTER_POWER_ATTACK") => DecodedFeat::MasterPowerAttack { feat_id },
        // Power Blast ladder.
        Some("POWER_BLAST") => DecodedFeat::PowerBlast { feat_id },
        Some("IMPROVED_POWER_BLAST") => DecodedFeat::ImprovedPowerBlast { feat_id },
        Some("MASTER_POWER_BLAST") => DecodedFeat::MasterPowerBlast { feat_id },
        // Critical Strike ladder.
        Some("CRITICAL_STRIKE") => DecodedFeat::CriticalStrike { feat_id },
        Some("IMPROVED_CRITICAL_STRIKE") => DecodedFeat::ImprovedCriticalStrike { feat_id },
        Some("MASTER_CRITICAL_STRIKE") => DecodedFeat::MasterCriticalStrike { feat_id },
        // Flurry ladder.
        Some("FLURRY") => DecodedFeat::Flurry { feat_id },
        Some("IMPROVED_FLURRY") => DecodedFeat::ImprovedFlurry { feat_id },
        // Sniper Shot ladder.
        Some("SNIPER_SHOT") => DecodedFeat::SniperShot { feat_id },
        Some("IMPROVED_SNIPER_SHOT") => DecodedFeat::ImprovedSniperShot { feat_id },
        Some("MASTER_SNIPER_SHOT") => DecodedFeat::MasterSniperShot { feat_id },
        // Rapid Shot ladder.
        Some("RAPID_SHOT") => DecodedFeat::RapidShot { feat_id },
        Some("IMPROVED_RAPID_SHOT") => DecodedFeat::ImprovedRapidShot { feat_id },
        // Singletons (no improved or master tier in vanilla).
        Some("MULTI_SHOT") => DecodedFeat::MultiShot { feat_id },
        Some("WHIRLWIND_ATTACK") => DecodedFeat::WhirlwindAttack { feat_id },
        // Two-Weapon ladder.
        Some("TWO_WEAPON_FIGHTING") => DecodedFeat::TwoWeaponFighting { feat_id },
        Some("TWO_WEAPON_ADVANCED") => DecodedFeat::TwoWeaponAdvanced { feat_id },
        Some("TWO_WEAPON_MASTERY") => DecodedFeat::TwoWeaponMastery { feat_id },
        // Jedi defensive ladder.
        Some("JEDI_DEFENSE") => DecodedFeat::JediDefense { feat_id },
        Some("ADVANCED_JEDI_DEFENSE") => DecodedFeat::AdvancedJediDefense { feat_id },
        Some("MASTER_JEDI_DEFENSE") => DecodedFeat::MasterJediDefense { feat_id },
        // Force focus ladder (sense / alter / control schools).
        Some("FORCE_FOCUS") => DecodedFeat::ForceFocus { feat_id },
        Some("FORCE_FOCUS_ADVANCED") => DecodedFeat::ForceFocusAdvanced { feat_id },
        Some("FORCE_FOCUS_MASTERY") => DecodedFeat::ForceFocusMastery { feat_id },
        Some("XXXX_FORCE_FOCUS_ALTER") => DecodedFeat::ForceFocusAlter { feat_id },
        Some("XXXX_FORCE_FOCUS_CONTROL") => DecodedFeat::ForceFocusControl { feat_id },
        // Force jump ladder.
        Some("FORCE_JUMP") => DecodedFeat::ForceJump { feat_id },
        Some("FORCE_JUMP_ADVANCED") => DecodedFeat::ForceJumpAdvanced { feat_id },
        Some("FORCE_JUMP_MASTERY") => DecodedFeat::ForceJumpMastery { feat_id },
        // Force immunity trio.
        Some("FORCE_IMMUNITY_FEAR") => DecodedFeat::ForceImmunityFear { feat_id },
        Some("FORCE_IMMUNITY_STUN") => DecodedFeat::ForceImmunityStun { feat_id },
        Some("FORCE_IMMUNITY_PARALYSIS") => DecodedFeat::ForceImmunityParalysis { feat_id },
        // Force singletons.
        Some("BATTLE_MEDITATION") => DecodedFeat::BattleMeditation { feat_id },
        // Vanilla label is missing the second `u`; preserved verbatim.
        Some("FORCE_CAMOFLAGE") => DecodedFeat::ForceCamoflage { feat_id },
        // Sneak attack ladder. Per-tier variants rather than a
        // dice-count enum because the engine treats each tier as an
        // independent feat with its own prereq column.
        Some("SNEAK_ATTACK_1D6") => DecodedFeat::SneakAttack1D6 { feat_id },
        Some("SNEAK_ATTACK_2D6") => DecodedFeat::SneakAttack2D6 { feat_id },
        Some("SNEAK_ATTACK_3D6") => DecodedFeat::SneakAttack3D6 { feat_id },
        Some("SNEAK_ATTACK_4D6") => DecodedFeat::SneakAttack4D6 { feat_id },
        Some("SNEAK_ATTACK_5D6") => DecodedFeat::SneakAttack5D6 { feat_id },
        Some("SNEAK_ATTACK_6D6") => DecodedFeat::SneakAttack6D6 { feat_id },
        // Uncanny dodge tiers.
        Some("UNCANNY_DODGE_1") => DecodedFeat::UncannyDodge1 { feat_id },
        Some("UNCANNY_DODGE_2") => DecodedFeat::UncannyDodge2 { feat_id },
        // Toughness ladder.
        Some("TOUGHNESS") => DecodedFeat::Toughness { feat_id },
        Some("IMPROVED_TOUGHNESS") => DecodedFeat::ImprovedToughness { feat_id },
        Some("MASTER_TOUGHNESS") => DecodedFeat::MasterToughness { feat_id },
        // Conditioning ladder.
        Some("CONDITIONING") => DecodedFeat::Conditioning { feat_id },
        Some("IMPROVED_CONDITIONING") => DecodedFeat::ImprovedConditioning { feat_id },
        Some("MASTER_CONDITIONING") => DecodedFeat::MasterConditioning { feat_id },
        // Implant slot ladder.
        Some("IMPLANT_LEVEL_1") => DecodedFeat::ImplantLevel1 { feat_id },
        Some("IMPLANT_LEVEL_2") => DecodedFeat::ImplantLevel2 { feat_id },
        Some("IMPLANT_LEVEL_3") => DecodedFeat::ImplantLevel3 { feat_id },
        // Droid combat / logic upgrades.
        Some("DROID_UPGRADE_1") => DecodedFeat::DroidUpgrade1 { feat_id },
        Some("DROID_UPGRADE_2") => DecodedFeat::DroidUpgrade2 { feat_id },
        Some("DROID_UPGRADE_3") => DecodedFeat::DroidUpgrade3 { feat_id },
        Some("BLASTER_INTEGRATION") => DecodedFeat::BlasterIntegration { feat_id },
        Some("LOGIC_UPGRADE_COMBAT") => DecodedFeat::LogicUpgradeCombat { feat_id },
        Some("LOGIC_UPGRADE_TACTICIAN") => DecodedFeat::LogicUpgradeTactician { feat_id },
        // Dueling ladder.
        Some("DUELING") => DecodedFeat::Dueling { feat_id },
        Some("ADVANCED_DUELING") => DecodedFeat::AdvancedDueling { feat_id },
        Some("MASTER_DUELING") => DecodedFeat::MasterDueling { feat_id },
        // Sense ladder.
        Some("JEDI_SENSE") => DecodedFeat::JediSense { feat_id },
        Some("KNIGHT_SENSE") => DecodedFeat::KnightSense { feat_id },
        Some("MASTER_SENSE") => DecodedFeat::MasterSense { feat_id },
        // Deprecated guard stance ladder still wired into vanilla UTCs.
        Some("XXXX_GUARD_STANCE") => DecodedFeat::GuardStance { feat_id },
        Some("XXXX_ADVANCED_GUARD_STANCE") => DecodedFeat::AdvancedGuardStance { feat_id },
        Some("XXXX_MASTER_GUARD_STANCE") => DecodedFeat::MasterGuardStance { feat_id },
        // Deprecated skill focus feats still wired into vanilla UTCs.
        Some("XXXX_SKILL_FOCUS_AWARENESS") => DecodedFeat::SkillFocusAwareness { feat_id },
        Some("XXXX_SKILL_FOCUS_TREAT_INJURY") => DecodedFeat::SkillFocusTreatInjury { feat_id },
        Some("XXXX_SKILL_FOCUS_STEALTH") => DecodedFeat::SkillFocusStealth { feat_id },
        // Misc singletons (encounter-specific bonuses, racial feats,
        // and one or two deprecated rows still loaded by vanilla UTCs).
        Some("CAUTIOUS") => DecodedFeat::Cautious { feat_id },
        Some("XXXX_PERCEPTIVE") => DecodedFeat::Perceptive { feat_id },
        Some("EMPATHY") => DecodedFeat::Empathy { feat_id },
        Some("GEAR_HEAD") => DecodedFeat::GearHead { feat_id },
        Some("WOOKIE_ENDURANCE") => DecodedFeat::WookieEndurance { feat_id },
        Some("SCOUNDRELS_LUCK") => DecodedFeat::ScoundrelsLuck { feat_id },
        // Anything else (mod-added labels, vanilla rows the corpus
        // never assigns, or absent feat.2da) falls through to
        // Unknown carrying its resolved label when reachable.
        _ => DecodedFeat::Unknown {
            feat_id,
            feat_label: label,
        },
    }
}

/// File-native projection of a [`Utc`].
///
/// Wraps a reference to the source UTC. Unlike
/// [`UtiProjection`](super::uti::UtiProjection), UTC has no single
/// dispatch table that must resolve at projection time; the typed
/// list dispatch (feats, classes, spells) happens at resolve time
/// against their respective 2DAs. The projection still exists as the
/// stable handle that one or more [`UtcResolved`]s build from, which
/// matters for cross-scope analysis (mod conflict, vanilla vs modded,
/// save / module VFS scoping).
#[derive(Debug, Clone)]
pub struct UtcProjection<'a> {
    utc: &'a Utc,
}

/// Snapshot view over a [`Utc`], resolved against a per-scope context.
///
/// Built by [`UtcProjection::resolve`] (or [`Utc::resolve`] as a
/// single-scope shortcut). Carries the source [`Utc`] plus cached
/// scalar-id resolutions (race, appearance, portrait, soundset) and
/// the typed-variant projection of `ClassList`.
///
/// All query methods take `&self` and read from the cached resolution.
/// The resolved view does not retain the [`TwoDaSource`] borrow
/// once constructed; to query under a different scope, build a
/// fresh resolve again from the same projection.
#[derive(Debug)]
pub struct UtcResolved<'a> {
    utc: &'a Utc,
    race_info: Option<RaceInfo>,
    appearance_info: Option<AppearanceInfo>,
    portrait_info: Option<PortraitInfo>,
    soundset_info: Option<SoundsetInfo>,
    decoded_classes: Vec<DecodedClass>,
    decoded_special_abilities: Vec<DecodedSpecialAbility>,
    decoded_feats: Vec<DecodedFeat>,
}

/// One decoded class entry from a UTC's `ClassList`, with the typed
/// variant chosen by matching the `class_id` row's `label` cell in
/// `classes.2da`.
///
/// Vanilla K1 carries nine class kinds; each gets its own typed
/// variant. Mod-added or unrecognized rows surface as
/// [`DecodedClass::Unknown`] carrying the raw `class_id` and the
/// resolved label (when present) so callers can still display
/// something useful. Dispatch is by `label`, not by raw `class_id`,
/// so a mod that re-numbers a vanilla class still routes to its
/// typed variant.
///
/// Every variant carries `class_id` (the raw integer the GFF stored;
/// preserved so callers can recover the source-side row identity
/// even after dispatch), `level` (the entry's `class_level`), and
/// `powers` (the per-entry `Vec<u16>` of force-power ids that
/// resolve into `spells.2da`; left raw at this stage and typed in a
/// later commit).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DecodedClass {
    /// Vanilla `classes.2da` row label `Soldier` (vanilla row 0).
    Soldier {
        /// Raw `class_id` (the GFF integer the dispatch resolved from).
        class_id: i32,
        /// Raw `class_level` (entry's contribution to the character's
        /// total level).
        level: i16,
        /// Raw `Vec<u16>` of force-power ids indexing `spells.2da`.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `Scout` (vanilla row 1).
    Scout {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `Scoundrel` (vanilla row 2).
    Scoundrel {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `JediGuardian` (vanilla row 3).
    JediGuardian {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `JediConsular` (vanilla row 4).
    JediConsular {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `JediSentinel` (vanilla row 5).
    JediSentinel {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `CombatDroid` (vanilla row 6).
    CombatDroid {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `ExpertDroid` (vanilla row 7).
    ExpertDroid {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Vanilla `classes.2da` row label `Minion` (vanilla row 8).
    Minion {
        /// Raw `class_id`.
        class_id: i32,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
    /// Class identity could not be matched to any typed variant.
    /// Carries the raw fields plus the resolved label when reachable
    /// so consumers can still display something useful for mod-added
    /// or out-of-range classes.
    Unknown {
        /// Raw `class_id` from the GFF.
        class_id: i32,
        /// Resolved `label` cell from `classes.2da` at row `class_id`,
        /// or `None` when the table is unavailable, the row does not
        /// exist, or the label cell is missing.
        class_label: Option<String>,
        /// Raw `class_level`.
        level: i16,
        /// Raw force-power ids.
        powers: Vec<u16>,
    },
}

impl DecodedClass {
    /// Returns the raw `class_id` the dispatch resolved from,
    /// regardless of variant.
    pub fn class_id(&self) -> i32 {
        match self {
            Self::Soldier { class_id, .. }
            | Self::Scout { class_id, .. }
            | Self::Scoundrel { class_id, .. }
            | Self::JediGuardian { class_id, .. }
            | Self::JediConsular { class_id, .. }
            | Self::JediSentinel { class_id, .. }
            | Self::CombatDroid { class_id, .. }
            | Self::ExpertDroid { class_id, .. }
            | Self::Minion { class_id, .. }
            | Self::Unknown { class_id, .. } => *class_id,
        }
    }

    /// Returns the entry's `class_level` regardless of variant.
    pub fn level(&self) -> i16 {
        match self {
            Self::Soldier { level, .. }
            | Self::Scout { level, .. }
            | Self::Scoundrel { level, .. }
            | Self::JediGuardian { level, .. }
            | Self::JediConsular { level, .. }
            | Self::JediSentinel { level, .. }
            | Self::CombatDroid { level, .. }
            | Self::ExpertDroid { level, .. }
            | Self::Minion { level, .. }
            | Self::Unknown { level, .. } => *level,
        }
    }

    /// Returns the entry's raw force-power id slice regardless of
    /// variant.
    pub fn powers(&self) -> &[u16] {
        match self {
            Self::Soldier { powers, .. }
            | Self::Scout { powers, .. }
            | Self::Scoundrel { powers, .. }
            | Self::JediGuardian { powers, .. }
            | Self::JediConsular { powers, .. }
            | Self::JediSentinel { powers, .. }
            | Self::CombatDroid { powers, .. }
            | Self::ExpertDroid { powers, .. }
            | Self::Minion { powers, .. }
            | Self::Unknown { powers, .. } => powers,
        }
    }
}

/// Cached subset of a `racialtypes.2da` row, taken once at resolve
/// time so [`UtcResolved::race_label`] can answer without holding a
/// 2DA cache borrow.
#[derive(Debug, Clone, Default)]
struct RaceInfo {
    label: Option<String>,
}

/// Cached subset of an `appearance.2da` row.
#[derive(Debug, Clone, Default)]
struct AppearanceInfo {
    label: Option<String>,
}

/// Cached subset of a `portraits.2da` row.
#[derive(Debug, Clone, Default)]
struct PortraitInfo {
    label: Option<String>,
}

/// Cached subset of a `soundset.2da` row.
#[derive(Debug, Clone, Default)]
struct SoundsetInfo {
    label: Option<String>,
}

impl RaceInfo {
    fn from_row(table: &TwoDa, race_id: u8) -> Option<Self> {
        let row = usize::from(race_id);
        if row >= table.rows.len() {
            return None;
        }
        Some(Self {
            label: table.cell(row, "label").map(str::to_string),
        })
    }
}

impl AppearanceInfo {
    fn from_row(table: &TwoDa, appearance_id: u16) -> Option<Self> {
        let row = usize::from(appearance_id);
        if row >= table.rows.len() {
            return None;
        }
        Some(Self {
            label: table.cell(row, "label").map(str::to_string),
        })
    }
}

impl PortraitInfo {
    fn from_row(table: &TwoDa, portrait_id: u16) -> Option<Self> {
        let row = usize::from(portrait_id);
        if row >= table.rows.len() {
            return None;
        }
        Some(Self {
            label: table.cell(row, "label").map(str::to_string),
        })
    }
}

impl SoundsetInfo {
    fn from_row(table: &TwoDa, soundset_id: u16) -> Option<Self> {
        let row = usize::from(soundset_id);
        if row >= table.rows.len() {
            return None;
        }
        Some(Self {
            label: table.cell(row, "label").map(str::to_string),
        })
    }
}

/// One decoded entry from a UTC's `SpecAbilityList`, dispatched by
/// matching the `spells.2da` row's `label` cell against the small
/// set of vanilla special-ability ids the corpus references.
///
/// Vanilla K1 references exactly three rows from special-ability
/// entries (`SPECIAL_ABILITY_BODY_FUEL`, `SPECIAL_ABILITY_RAGE`,
/// `MONSTER_ABILITY_SLAM_ATTACK`); each gets a typed variant. The
/// `partymember.utc` template references a spell id that does not
/// resolve in vanilla `spells.2da` (see the "Vanilla Data Anomalies"
/// subsection of the UTC engine audit), and that falls into
/// [`DecodedSpecialAbility::Unknown`] alongside any mod-added rows.
///
/// Every variant carries `spell_id` (preserved so callers can
/// recover the source row id even after dispatch), `flags`
/// (`SpellFlags`), and `caster_level` (`SpellCasterLevel`). The
/// engine appends every list entry without deduplication, so a UTC
/// carrying N entries with the same `spell_id` surfaces as N
/// separate `DecodedSpecialAbility` values.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DecodedSpecialAbility {
    /// `spells.2da` label `SPECIAL_ABILITY_BODY_FUEL`. Stackable in
    /// vanilla -- the six Bastila variants each carry 99 entries.
    BodyFuel {
        /// Raw `spell_id`.
        spell_id: u16,
        /// Raw `SpellFlags`.
        flags: u8,
        /// Raw `SpellCasterLevel`.
        caster_level: u8,
    },
    /// `spells.2da` label `SPECIAL_ABILITY_RAGE`. Wookiee racial.
    Rage {
        /// Raw `spell_id`.
        spell_id: u16,
        /// Raw `SpellFlags`.
        flags: u8,
        /// Raw `SpellCasterLevel`.
        caster_level: u8,
    },
    /// `spells.2da` label `MONSTER_ABILITY_SLAM_ATTACK`. Monster
    /// classes (Wraids, Katarn, Korriban monsters).
    MonsterSlamAttack {
        /// Raw `spell_id`.
        spell_id: u16,
        /// Raw `SpellFlags`.
        flags: u8,
        /// Raw `SpellCasterLevel`.
        caster_level: u8,
    },
    /// Special ability could not be matched to a typed variant.
    /// Covers mod-added rows, vanilla anomalies (the `partymember`
    /// out-of-range `Spell = 299`), missing `spells.2da`, or any
    /// vanilla label not in the typed set.
    Unknown {
        /// Raw `spell_id` from the GFF.
        spell_id: u16,
        /// Resolved `label` cell from `spells.2da` at row `spell_id`,
        /// or `None` when the table is unavailable, the row does not
        /// exist, or the label cell is missing.
        spell_label: Option<String>,
        /// Raw `SpellFlags`.
        flags: u8,
        /// Raw `SpellCasterLevel`.
        caster_level: u8,
    },
}

impl DecodedSpecialAbility {
    /// Returns the raw `spell_id` regardless of variant.
    pub fn spell_id(&self) -> u16 {
        match self {
            Self::BodyFuel { spell_id, .. }
            | Self::Rage { spell_id, .. }
            | Self::MonsterSlamAttack { spell_id, .. }
            | Self::Unknown { spell_id, .. } => *spell_id,
        }
    }

    /// Returns `SpellFlags` regardless of variant.
    pub fn flags(&self) -> u8 {
        match self {
            Self::BodyFuel { flags, .. }
            | Self::Rage { flags, .. }
            | Self::MonsterSlamAttack { flags, .. }
            | Self::Unknown { flags, .. } => *flags,
        }
    }

    /// Returns `SpellCasterLevel` regardless of variant.
    pub fn caster_level(&self) -> u8 {
        match self {
            Self::BodyFuel { caster_level, .. }
            | Self::Rage { caster_level, .. }
            | Self::MonsterSlamAttack { caster_level, .. }
            | Self::Unknown { caster_level, .. } => *caster_level,
        }
    }
}

/// Resolves a `spells.2da` row label for a UTC special-ability entry,
/// then dispatches into the typed [`DecodedSpecialAbility`] variant
/// or `Unknown`. Dispatch is by `label` rather than by raw `spell_id`
/// so a mod that re-numbers a vanilla ability still routes correctly.
fn dispatch_special_ability(
    ability: &UtcSpecialAbility,
    spells_table: Option<&TwoDa>,
) -> DecodedSpecialAbility {
    let label = spells_table.and_then(|table| {
        let row = usize::from(ability.spell_id);
        if row >= table.rows.len() {
            return None;
        }
        table.cell(row, "label").map(str::to_string)
    });
    let spell_id = ability.spell_id;
    let flags = ability.spell_flags;
    let caster_level = ability.spell_caster_level;
    match label.as_deref() {
        Some("SPECIAL_ABILITY_BODY_FUEL") => DecodedSpecialAbility::BodyFuel {
            spell_id,
            flags,
            caster_level,
        },
        Some("SPECIAL_ABILITY_RAGE") => DecodedSpecialAbility::Rage {
            spell_id,
            flags,
            caster_level,
        },
        Some("MONSTER_ABILITY_SLAM_ATTACK") => DecodedSpecialAbility::MonsterSlamAttack {
            spell_id,
            flags,
            caster_level,
        },
        _ => DecodedSpecialAbility::Unknown {
            spell_id,
            spell_label: label,
            flags,
            caster_level,
        },
    }
}

/// Resolves a `classes.2da` row label for a UTC class entry, then
/// dispatches into the typed [`DecodedClass`] variant or `Unknown`.
///
/// Dispatch is by `label`, not by raw `class_id`, so a mod that
/// re-numbers a vanilla class still routes correctly. A missing
/// `classes.2da`, an out-of-range `class_id`, an absent `label` cell,
/// or a label unknown to the dispatch table all surface as
/// [`DecodedClass::Unknown`] carrying whichever raw fields and
/// resolved label could be recovered.
fn dispatch_class(class: &UtcClass, classes_table: Option<&TwoDa>) -> DecodedClass {
    let label = classes_table.and_then(|table| {
        let row = usize::try_from(class.class_id).ok()?;
        if row >= table.rows.len() {
            return None;
        }
        table.cell(row, "label").map(str::to_string)
    });
    let class_id = class.class_id;
    let level = class.class_level;
    let powers = class.powers.clone();
    match label.as_deref() {
        Some("Soldier") => DecodedClass::Soldier {
            class_id,
            level,
            powers,
        },
        Some("Scout") => DecodedClass::Scout {
            class_id,
            level,
            powers,
        },
        Some("Scoundrel") => DecodedClass::Scoundrel {
            class_id,
            level,
            powers,
        },
        Some("JediGuardian") => DecodedClass::JediGuardian {
            class_id,
            level,
            powers,
        },
        Some("JediConsular") => DecodedClass::JediConsular {
            class_id,
            level,
            powers,
        },
        Some("JediSentinel") => DecodedClass::JediSentinel {
            class_id,
            level,
            powers,
        },
        Some("CombatDroid") => DecodedClass::CombatDroid {
            class_id,
            level,
            powers,
        },
        Some("ExpertDroid") => DecodedClass::ExpertDroid {
            class_id,
            level,
            powers,
        },
        Some("Minion") => DecodedClass::Minion {
            class_id,
            level,
            powers,
        },
        // Anything else: mod-extended row, unrecognized vanilla
        // label, missing 2DA, out-of-range id. Preserve raw fields
        // plus the resolved label (when there is one) so consumers
        // can still display something useful.
        _ => DecodedClass::Unknown {
            class_id,
            class_label: label,
            level,
            powers,
        },
    }
}

impl<'a> UtcProjection<'a> {
    /// Returns a reference to the source UTC.
    pub fn as_utc(&self) -> &'a Utc {
        self.utc
    }

    /// Resolves this projection against the given context, building a
    /// [`UtcResolved`].
    ///
    /// Loads `racialtypes.2da`, `appearance.2da`, `portraits.2da`,
    /// `soundset.2da`, `classes.2da`, `spells.2da`, and `feat.2da`
    /// (each tolerated as missing) and caches the rows the UTC's id
    /// fields point at, plus the typed-variant dispatch of every
    /// `ClassList`, `SpecAbilityList`, and `FeatList` entry. Multiple
    /// resolutions can be built from one projection, each capturing its
    /// own per-scope resolved data. The projection itself is
    /// unchanged and remains reusable across calls.
    pub fn resolve(&self, cache: &mut impl TwoDaSource) -> UtcResolved<'a> {
        let race_info = cache
            .twoda(tables::RACIALTYPES)
            .and_then(|table| RaceInfo::from_row(table, self.utc.race_id));
        let appearance_info = cache
            .twoda(tables::APPEARANCE)
            .and_then(|table| AppearanceInfo::from_row(table, self.utc.appearance_id));
        let portrait_info = cache
            .twoda(tables::PORTRAITS)
            .and_then(|table| PortraitInfo::from_row(table, self.utc.portrait_id));
        let soundset_info = cache
            .twoda("soundset")
            .and_then(|table| SoundsetInfo::from_row(table, self.utc.soundset_id));
        let decoded_classes = {
            let classes_table = cache.twoda(tables::CLASSES);
            self.utc
                .classes
                .iter()
                .map(|class| dispatch_class(class, classes_table))
                .collect()
        };
        let decoded_special_abilities = {
            let spells_table = cache.twoda("spells");
            self.utc
                .special_abilities
                .iter()
                .map(|ability| dispatch_special_ability(ability, spells_table))
                .collect()
        };
        let decoded_feats = {
            let feat_table = cache.twoda(tables::FEAT);
            self.utc
                .feats
                .iter()
                .map(|feat_id| dispatch_feat(*feat_id, feat_table))
                .collect()
        };
        UtcResolved {
            utc: self.utc,
            race_info,
            appearance_info,
            portrait_info,
            soundset_info,
            decoded_classes,
            decoded_special_abilities,
            decoded_feats,
        }
    }
}

impl<'a> UtcResolved<'a> {
    /// Returns a reference to the source UTC.
    pub fn as_utc(&self) -> &'a Utc {
        self.utc
    }

    /// Returns the `label` cell from `racialtypes.2da` at the UTC's
    /// `race_id` row.
    ///
    /// Returns `None` when `racialtypes.2da` is unavailable, the
    /// `race_id` does not resolve to a row, or the cell is missing.
    pub fn race_label(&self) -> Option<&str> {
        self.race_info.as_ref()?.label.as_deref()
    }

    /// Returns the `label` cell from `appearance.2da` at the UTC's
    /// `appearance_id` row.
    ///
    /// Returns `None` when `appearance.2da` is unavailable, the
    /// `appearance_id` does not resolve to a row, or the cell is
    /// missing.
    pub fn appearance_label(&self) -> Option<&str> {
        self.appearance_info.as_ref()?.label.as_deref()
    }

    /// Returns the `label` cell from `portraits.2da` at the UTC's
    /// `portrait_id` row.
    ///
    /// Returns `None` when `portraits.2da` is unavailable, the
    /// `portrait_id` does not resolve to a row, or the cell is
    /// missing.
    pub fn portrait_label(&self) -> Option<&str> {
        self.portrait_info.as_ref()?.label.as_deref()
    }

    /// Returns the `label` cell from `soundset.2da` at the UTC's
    /// `soundset_id` row.
    ///
    /// Returns `None` when `soundset.2da` is unavailable, the
    /// `soundset_id` does not resolve to a row, or the cell is
    /// missing.
    pub fn soundset_label(&self) -> Option<&str> {
        self.soundset_info.as_ref()?.label.as_deref()
    }

    /// Returns the UTC's `alignment` (good / evil axis), clamped to
    /// the engine's hard maximum of `100`.
    ///
    /// The engine's UTC loader applies the same clamp on read (see
    /// `CSWSCreatureStats::ReadStatsFromGff` in the UTC engine audit),
    /// so any UTC carrying a raw value above `100` will display as
    /// `100` at runtime regardless of what the GFF says.
    pub fn alignment(&self) -> u8 {
        self.utc.alignment.min(100)
    }

    /// Returns the typed-variant decoded class entries as a borrowed
    /// slice.
    ///
    /// The order matches the source [`Utc::classes`] ordering;
    /// callers iterate or filter the slice. Multi-class characters
    /// surface as multiple entries in source order; the engine load
    /// path caps at two distinct class types per UTC, but this slice
    /// faithfully reflects whatever the GFF carries.
    pub fn classes(&self) -> &[DecodedClass] {
        &self.decoded_classes
    }

    /// Sums the `class_level` across every decoded class entry,
    /// regardless of typed variant or [`DecodedClass::Unknown`]
    /// status. Returns the character's effective total level.
    ///
    /// Computed in `i32` so accumulation of multiple class entries
    /// cannot overflow the `i16` per-entry level type.
    pub fn total_level(&self) -> i32 {
        self.decoded_classes
            .iter()
            .map(|class| i32::from(class.level()))
            .sum()
    }

    /// Returns `true` when any decoded class entry matches the given
    /// [`ClassKindFilter`].
    ///
    /// `Unknown` class entries never match a typed-variant filter;
    /// callers wanting to inspect unknown class kinds walk
    /// [`Self::classes`] directly.
    pub fn has_class(&self, filter: ClassKindFilter) -> bool {
        self.decoded_classes
            .iter()
            .any(|class| filter.matches(class))
    }

    /// Returns `true` when the character carries any Jedi class
    /// entry (`JediGuardian`, `JediConsular`, or `JediSentinel`).
    /// Convenience wrapper over
    /// `has_class(ClassKindFilter::AnyJedi)`.
    pub fn is_force_user(&self) -> bool {
        self.has_class(ClassKindFilter::AnyJedi)
    }

    /// Returns `true` when the character carries any droid class
    /// entry (`CombatDroid` or `ExpertDroid`). Convenience wrapper
    /// over `has_class(ClassKindFilter::AnyDroid)`.
    pub fn is_droid(&self) -> bool {
        self.has_class(ClassKindFilter::AnyDroid)
    }

    /// Returns the typed-variant decoded feat entries as a borrowed
    /// slice.
    ///
    /// The order matches the source [`Utc::feats`] ordering. The
    /// engine load path appends every entry without deduplication,
    /// so a UTC carrying duplicate `feat_id`s surfaces as N separate
    /// slots. Each entry carries the raw `feat_id` regardless of
    /// dispatch outcome; callers wanting the resolved label for an
    /// `Unknown` walk the slice directly.
    pub fn feats(&self) -> &[DecodedFeat] {
        &self.decoded_feats
    }

    /// Returns `true` when any decoded feat entry matches the given
    /// [`FeatKindFilter`].
    ///
    /// `Unknown` feat entries never match a typed-variant filter;
    /// callers wanting to inspect unknown feat labels walk
    /// [`Self::feats`] directly.
    pub fn has_feat(&self, filter: FeatKindFilter) -> bool {
        self.decoded_feats.iter().any(|feat| filter.matches(feat))
    }

    /// Returns the typed-variant decoded special-ability entries as
    /// a borrowed slice.
    ///
    /// The order matches the source [`Utc::special_abilities`]
    /// ordering. The engine load path appends every entry without
    /// deduplication (see the "Vanilla Data Anomalies" subsection of
    /// the UTC engine audit), so a UTC carrying duplicate entries of
    /// the same `spell_id` (e.g. the Bastila variants' 99 stacked
    /// `BodyFuel` entries) surfaces as N separate slots in this
    /// slice.
    pub fn special_abilities(&self) -> &[DecodedSpecialAbility] {
        &self.decoded_special_abilities
    }

    /// Returns the source UTC's `Equip_ItemList` as a borrowed slice,
    /// exposing slot id + UTI resref + drop flag per entry.
    ///
    /// Resolution of each `resref` to a [`UtiResolved`] is a
    /// cross-resource walk (it needs a resource tree to fetch the
    /// referenced UTI's bytes) and lives in the cross-resource lint
    /// scope rather than in the UTC decoded view. This accessor
    /// exists so consumers can route equipment access through the
    /// resolved view for API consistency with the rest of the query
    /// surface; the data itself is the raw [`UtcEquipmentItem`]
    /// slice from the source UTC.
    ///
    /// [`UtiResolved`]: super::uti::UtiResolved
    pub fn equipment(&self) -> &[UtcEquipmentItem] {
        &self.utc.equipment
    }

    /// Returns the source UTC's `ItemList` as a borrowed slice,
    /// exposing entry id + UTI resref + drop flag + grid position
    /// per entry.
    ///
    /// Same cross-resource caveat as [`Self::equipment`]: resolving
    /// each `resref` to a [`UtiResolved`] needs a resource tree
    /// and lives in cross-resource lint scope.
    ///
    /// [`UtiResolved`]: super::uti::UtiResolved
    pub fn inventory(&self) -> &[UtcInventoryItem] {
        &self.utc.inventory
    }
}

/// Categorical filter for [`UtcResolved::has_class`].
///
/// Each named variant maps to the matching [`DecodedClass`] typed
/// variant. The `AnyJedi` and `AnyDroid` variants are family filters
/// that match any of their member classes; they exist because "is
/// this a Jedi?" and "is this a droid?" are the two most-asked
/// high-level questions of a UTC's class identity.
///
/// [`DecodedClass::Unknown`] entries never match any filter. Callers
/// wanting to inspect mod-added classes walk [`UtcResolved::classes`]
/// directly.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ClassKindFilter {
    /// Matches [`DecodedClass::Soldier`].
    Soldier,
    /// Matches [`DecodedClass::Scout`].
    Scout,
    /// Matches [`DecodedClass::Scoundrel`].
    Scoundrel,
    /// Matches [`DecodedClass::JediGuardian`].
    JediGuardian,
    /// Matches [`DecodedClass::JediConsular`].
    JediConsular,
    /// Matches [`DecodedClass::JediSentinel`].
    JediSentinel,
    /// Matches [`DecodedClass::CombatDroid`].
    CombatDroid,
    /// Matches [`DecodedClass::ExpertDroid`].
    ExpertDroid,
    /// Matches [`DecodedClass::Minion`].
    Minion,
    /// Matches any of `JediGuardian`, `JediConsular`, `JediSentinel`.
    AnyJedi,
    /// Matches any of `CombatDroid`, `ExpertDroid`.
    AnyDroid,
}

impl ClassKindFilter {
    fn matches(self, class: &DecodedClass) -> bool {
        match self {
            Self::Soldier => matches!(class, DecodedClass::Soldier { .. }),
            Self::Scout => matches!(class, DecodedClass::Scout { .. }),
            Self::Scoundrel => matches!(class, DecodedClass::Scoundrel { .. }),
            Self::JediGuardian => matches!(class, DecodedClass::JediGuardian { .. }),
            Self::JediConsular => matches!(class, DecodedClass::JediConsular { .. }),
            Self::JediSentinel => matches!(class, DecodedClass::JediSentinel { .. }),
            Self::CombatDroid => matches!(class, DecodedClass::CombatDroid { .. }),
            Self::ExpertDroid => matches!(class, DecodedClass::ExpertDroid { .. }),
            Self::Minion => matches!(class, DecodedClass::Minion { .. }),
            Self::AnyJedi => matches!(
                class,
                DecodedClass::JediGuardian { .. }
                    | DecodedClass::JediConsular { .. }
                    | DecodedClass::JediSentinel { .. }
            ),
            Self::AnyDroid => matches!(
                class,
                DecodedClass::CombatDroid { .. } | DecodedClass::ExpertDroid { .. }
            ),
        }
    }
}

/// Family / aggregation filter for [`UtcResolved::has_feat`].
///
/// Each variant matches a ladder, family, or roll-up of typed
/// [`DecodedFeat`] variants. There's no 1:1 named filter per typed
/// feat because the vanilla feat set is too large for that to be
/// useful; callers wanting an exact-variant test should match on
/// [`DecodedFeat`] directly with `matches!`.
///
/// [`DecodedFeat::Unknown`] entries never match any filter. Callers
/// wanting to inspect mod-added feat labels walk [`UtcResolved::feats`]
/// directly.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FeatKindFilter {
    /// Any `ArmourProf*` variant.
    AnyArmourProficiency,
    /// Any `WeaponProf*` variant (including the deprecated `XXXX_`
    /// rows still loaded by vanilla UTCs) plus `ProficiencyAll`.
    AnyWeaponProficiency,
    /// Any `WeaponFocus*` variant.
    AnyWeaponFocus,
    /// Any `WeaponSpec*` variant.
    AnyWeaponSpecialization,
    /// `PowerAttack`, `ImprovedPowerAttack`, or `MasterPowerAttack`.
    AnyPowerAttack,
    /// `PowerBlast`, `ImprovedPowerBlast`, or `MasterPowerBlast`.
    AnyPowerBlast,
    /// `CriticalStrike`, `ImprovedCriticalStrike`, or
    /// `MasterCriticalStrike`.
    AnyCriticalStrike,
    /// `Flurry` or `ImprovedFlurry`.
    AnyFlurry,
    /// `SniperShot`, `ImprovedSniperShot`, or `MasterSniperShot`.
    AnySniperShot,
    /// `RapidShot` or `ImprovedRapidShot`.
    AnyRapidShot,
    /// `TwoWeaponFighting`, `TwoWeaponAdvanced`, or `TwoWeaponMastery`.
    AnyTwoWeapon,
    /// `JediDefense`, `AdvancedJediDefense`, or `MasterJediDefense`.
    AnyJediDefense,
    /// Any `ForceFocus*` variant (sense / alter / control schools).
    AnyForceFocus,
    /// `ForceJump`, `ForceJumpAdvanced`, or `ForceJumpMastery`.
    AnyForceJump,
    /// Any `ForceImmunity*` variant (fear / stun / paralysis).
    AnyForceImmunity,
    /// Any `SneakAttack*` variant (1D6 through 6D6).
    AnySneakAttack,
    /// `UncannyDodge1` or `UncannyDodge2`.
    AnyUncannyDodge,
    /// `Toughness`, `ImprovedToughness`, or `MasterToughness`.
    AnyToughness,
    /// `Conditioning`, `ImprovedConditioning`, or `MasterConditioning`.
    AnyConditioning,
    /// `ImplantLevel1`, `ImplantLevel2`, or `ImplantLevel3`.
    AnyImplant,
    /// `DroidUpgrade1`, `DroidUpgrade2`, or `DroidUpgrade3`.
    AnyDroidUpgrade,
    /// `Dueling`, `AdvancedDueling`, or `MasterDueling`.
    AnyDueling,
    /// `JediSense`, `KnightSense`, or `MasterSense`.
    AnySense,
    /// Any `*GuardStance` variant (deprecated by Bioware but still
    /// wired into vanilla UTCs).
    AnyGuardStance,
    /// Any `SkillFocus*` variant (deprecated by Bioware but still
    /// wired into a handful of vanilla UTCs).
    AnySkillFocus,
}

impl FeatKindFilter {
    fn matches(self, feat: &DecodedFeat) -> bool {
        match self {
            Self::AnyArmourProficiency => matches!(
                feat,
                DecodedFeat::ArmourProfLight { .. }
                    | DecodedFeat::ArmourProfMedium { .. }
                    | DecodedFeat::ArmourProfHeavy { .. }
            ),
            Self::AnyWeaponProficiency => matches!(
                feat,
                DecodedFeat::WeaponProfBlaster { .. }
                    | DecodedFeat::WeaponProfBlasterRifle { .. }
                    | DecodedFeat::WeaponProfHeavyWeapons { .. }
                    | DecodedFeat::WeaponProfMeleeWeapons { .. }
                    | DecodedFeat::WeaponProfLightsaber { .. }
                    | DecodedFeat::WeaponProfGrenade { .. }
                    | DecodedFeat::WeaponProfSimpleWeapons { .. }
                    | DecodedFeat::ProficiencyAll { .. }
            ),
            Self::AnyWeaponFocus => matches!(
                feat,
                DecodedFeat::WeaponFocusBlaster { .. }
                    | DecodedFeat::WeaponFocusBlasterRifle { .. }
                    | DecodedFeat::WeaponFocusGrenade { .. }
                    | DecodedFeat::WeaponFocusHeavyWeapons { .. }
                    | DecodedFeat::WeaponFocusLightsaber { .. }
                    | DecodedFeat::WeaponFocusMeleeWeapons { .. }
                    | DecodedFeat::WeaponFocusSimpleWeapons { .. }
            ),
            Self::AnyWeaponSpecialization => matches!(
                feat,
                DecodedFeat::WeaponSpecBlaster { .. }
                    | DecodedFeat::WeaponSpecBlasterRifle { .. }
                    | DecodedFeat::WeaponSpecGrenade { .. }
                    | DecodedFeat::WeaponSpecHeavyWeapons { .. }
                    | DecodedFeat::WeaponSpecLightsaber { .. }
                    | DecodedFeat::WeaponSpecMeleeWeapons { .. }
                    | DecodedFeat::WeaponSpecSimpleWeapons { .. }
            ),
            Self::AnyPowerAttack => matches!(
                feat,
                DecodedFeat::PowerAttack { .. }
                    | DecodedFeat::ImprovedPowerAttack { .. }
                    | DecodedFeat::MasterPowerAttack { .. }
            ),
            Self::AnyPowerBlast => matches!(
                feat,
                DecodedFeat::PowerBlast { .. }
                    | DecodedFeat::ImprovedPowerBlast { .. }
                    | DecodedFeat::MasterPowerBlast { .. }
            ),
            Self::AnyCriticalStrike => matches!(
                feat,
                DecodedFeat::CriticalStrike { .. }
                    | DecodedFeat::ImprovedCriticalStrike { .. }
                    | DecodedFeat::MasterCriticalStrike { .. }
            ),
            Self::AnyFlurry => {
                matches!(
                    feat,
                    DecodedFeat::Flurry { .. } | DecodedFeat::ImprovedFlurry { .. }
                )
            }
            Self::AnySniperShot => matches!(
                feat,
                DecodedFeat::SniperShot { .. }
                    | DecodedFeat::ImprovedSniperShot { .. }
                    | DecodedFeat::MasterSniperShot { .. }
            ),
            Self::AnyRapidShot => matches!(
                feat,
                DecodedFeat::RapidShot { .. } | DecodedFeat::ImprovedRapidShot { .. }
            ),
            Self::AnyTwoWeapon => matches!(
                feat,
                DecodedFeat::TwoWeaponFighting { .. }
                    | DecodedFeat::TwoWeaponAdvanced { .. }
                    | DecodedFeat::TwoWeaponMastery { .. }
            ),
            Self::AnyJediDefense => matches!(
                feat,
                DecodedFeat::JediDefense { .. }
                    | DecodedFeat::AdvancedJediDefense { .. }
                    | DecodedFeat::MasterJediDefense { .. }
            ),
            Self::AnyForceFocus => matches!(
                feat,
                DecodedFeat::ForceFocus { .. }
                    | DecodedFeat::ForceFocusAdvanced { .. }
                    | DecodedFeat::ForceFocusMastery { .. }
                    | DecodedFeat::ForceFocusAlter { .. }
                    | DecodedFeat::ForceFocusControl { .. }
            ),
            Self::AnyForceJump => matches!(
                feat,
                DecodedFeat::ForceJump { .. }
                    | DecodedFeat::ForceJumpAdvanced { .. }
                    | DecodedFeat::ForceJumpMastery { .. }
            ),
            Self::AnyForceImmunity => matches!(
                feat,
                DecodedFeat::ForceImmunityFear { .. }
                    | DecodedFeat::ForceImmunityStun { .. }
                    | DecodedFeat::ForceImmunityParalysis { .. }
            ),
            Self::AnySneakAttack => matches!(
                feat,
                DecodedFeat::SneakAttack1D6 { .. }
                    | DecodedFeat::SneakAttack2D6 { .. }
                    | DecodedFeat::SneakAttack3D6 { .. }
                    | DecodedFeat::SneakAttack4D6 { .. }
                    | DecodedFeat::SneakAttack5D6 { .. }
                    | DecodedFeat::SneakAttack6D6 { .. }
            ),
            Self::AnyUncannyDodge => matches!(
                feat,
                DecodedFeat::UncannyDodge1 { .. } | DecodedFeat::UncannyDodge2 { .. }
            ),
            Self::AnyToughness => matches!(
                feat,
                DecodedFeat::Toughness { .. }
                    | DecodedFeat::ImprovedToughness { .. }
                    | DecodedFeat::MasterToughness { .. }
            ),
            Self::AnyConditioning => matches!(
                feat,
                DecodedFeat::Conditioning { .. }
                    | DecodedFeat::ImprovedConditioning { .. }
                    | DecodedFeat::MasterConditioning { .. }
            ),
            Self::AnyImplant => matches!(
                feat,
                DecodedFeat::ImplantLevel1 { .. }
                    | DecodedFeat::ImplantLevel2 { .. }
                    | DecodedFeat::ImplantLevel3 { .. }
            ),
            Self::AnyDroidUpgrade => matches!(
                feat,
                DecodedFeat::DroidUpgrade1 { .. }
                    | DecodedFeat::DroidUpgrade2 { .. }
                    | DecodedFeat::DroidUpgrade3 { .. }
            ),
            Self::AnyDueling => matches!(
                feat,
                DecodedFeat::Dueling { .. }
                    | DecodedFeat::AdvancedDueling { .. }
                    | DecodedFeat::MasterDueling { .. }
            ),
            Self::AnySense => matches!(
                feat,
                DecodedFeat::JediSense { .. }
                    | DecodedFeat::KnightSense { .. }
                    | DecodedFeat::MasterSense { .. }
            ),
            Self::AnyGuardStance => matches!(
                feat,
                DecodedFeat::GuardStance { .. }
                    | DecodedFeat::AdvancedGuardStance { .. }
                    | DecodedFeat::MasterGuardStance { .. }
            ),
            Self::AnySkillFocus => matches!(
                feat,
                DecodedFeat::SkillFocusAwareness { .. }
                    | DecodedFeat::SkillFocusTreatInjury { .. }
                    | DecodedFeat::SkillFocusStealth { .. }
            ),
        }
    }
}

impl Utc {
    /// Builds a [`UtcProjection`] of this UTC.
    ///
    /// Unlike [`Uti::project`](crate::uti::Uti::project), UTC's
    /// projection takes no context: typed list dispatch happens at
    /// resolve time against per-list 2DAs (`classes.2da`, `feat.2da`,
    /// `spells.2da`) rather than against one dispatch table at
    /// projection time. The projection stays cheap and scope-free,
    /// ready to feed one or more resolutions.
    pub fn project(&self) -> UtcProjection<'_> {
        UtcProjection { utc: self }
    }

    /// Builds a [`UtcResolved`] of this UTC against the given 2DA
    /// cache. Single-scope shortcut equivalent to
    /// `self.project().resolve(cache)`.
    ///
    /// For multi-scope workflows (mod conflict analysis, vanilla vs
    /// modded diffs), call [`Utc::project`] once and
    /// [`UtcProjection::resolve`] per scope.
    pub fn resolve(&self, cache: &mut impl TwoDaSource) -> UtcResolved<'_> {
        self.project().resolve(cache)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::decoded::test_tables::TestTables;
    use rakata_formats::twoda::TwoDaRow;

    fn label_only_2da(rows: &[(usize, &str)]) -> TwoDa {
        let max_row = rows.iter().map(|(idx, _)| *idx).max().unwrap_or(0);
        let mut table_rows = Vec::with_capacity(max_row + 1);
        for row_index in 0..=max_row {
            let label = rows
                .iter()
                .find(|(idx, _)| *idx == row_index)
                .map(|(_, label)| (*label).to_string())
                .unwrap_or_default();
            table_rows.push(TwoDaRow {
                label: row_index.to_string(),
                cells: vec![label],
            });
        }
        TwoDa {
            headers: vec!["label".to_string()],
            rows: table_rows,
        }
    }

    fn add_2da_entry(tables: &mut TestTables, name: &str, table: &TwoDa) {
        tables.insert(name, table);
    }

    #[test]
    fn project_returns_projection_wrapping_source() {
        let utc = Utc::default();
        let projection = utc.project();
        assert!(std::ptr::eq(projection.as_utc(), &utc));
    }

    #[test]
    fn resolve_returns_a_view_wrapping_the_source() {
        let utc = Utc::default();
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(std::ptr::eq(resolved.as_utc(), &utc));
    }

    #[test]
    fn sugar_resolve_matches_project_then_resolve() {
        let utc = Utc::default();
        let mut sugar_tables = TestTables::new();
        let mut explicit_tables = TestTables::new();

        let sugar = utc.resolve(&mut sugar_tables);
        let explicit = utc.project().resolve(&mut explicit_tables);

        assert!(std::ptr::eq(sugar.as_utc(), explicit.as_utc()));
    }

    #[test]
    fn one_projection_feeds_independent_resolutions() {
        let utc = Utc::default();
        let projection = utc.project();

        let mut tables_a = TestTables::new();
        let mut tables_b = TestTables::new();

        let snap_a = projection.resolve(&mut tables_a);
        let snap_b = projection.resolve(&mut tables_b);

        assert!(std::ptr::eq(snap_a.as_utc(), &utc));
        assert!(std::ptr::eq(snap_b.as_utc(), &utc));
    }

    #[test]
    fn race_label_resolves_against_racialtypes_2da() {
        let utc = Utc {
            race_id: 6,
            ..Utc::default()
        };
        let racialtypes = label_only_2da(&[(6, "Human")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "racialtypes", &racialtypes);

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.race_label(), Some("Human"));
    }

    #[test]
    fn race_label_returns_none_when_race_id_is_out_of_range() {
        // racialtypes.2da has 2 rows, but utc.race_id = 99.
        let utc = Utc {
            race_id: 99,
            ..Utc::default()
        };
        let racialtypes = label_only_2da(&[(0, "Human"), (1, "Droid")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "racialtypes", &racialtypes);

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.race_label().is_none());
    }

    #[test]
    fn race_label_returns_none_when_racialtypes_unavailable() {
        let utc = Utc {
            race_id: 6,
            ..Utc::default()
        };
        // The source knows nothing about racialtypes.2da.
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.race_label().is_none());
    }

    #[test]
    fn appearance_portrait_soundset_labels_resolve_via_their_2das() {
        let utc = Utc {
            appearance_id: 12,
            portrait_id: 34,
            soundset_id: 56,
            ..Utc::default()
        };
        let appearance = label_only_2da(&[(12, "Male_Caucasian_Tough")]);
        let portraits = label_only_2da(&[(34, "po_pmhc01")]);
        let soundset = label_only_2da(&[(56, "n_default")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "appearance", &appearance);
        add_2da_entry(&mut tables, "portraits", &portraits);
        add_2da_entry(&mut tables, "soundset", &soundset);

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.appearance_label(), Some("Male_Caucasian_Tough"));
        assert_eq!(resolved.portrait_label(), Some("po_pmhc01"));
        assert_eq!(resolved.soundset_label(), Some("n_default"));
    }

    #[test]
    fn alignment_returns_raw_value_when_in_range() {
        let utc = Utc {
            alignment: 50,
            ..Utc::default()
        };
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.alignment(), 50);
    }

    #[test]
    fn alignment_clamps_at_one_hundred_to_match_engine_load_behavior() {
        // Engine's GoodEvil clamp ceiling is 100; a UTC carrying a
        // raw 200 displays as 100 at runtime regardless of what the
        // GFF says.
        let utc = Utc {
            alignment: 200,
            ..Utc::default()
        };
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.alignment(), 100);
    }

    // -- DecodedClass dispatch --

    fn class_entry(class_id: i32, level: i16, powers: Vec<u16>) -> UtcClass {
        UtcClass {
            class_id,
            class_level: level,
            powers,
        }
    }

    #[test]
    fn classes_dispatch_every_vanilla_label_to_its_typed_variant() {
        // Build a UTC carrying one entry per vanilla class id and a
        // classes.2da fixture whose labels match the vanilla layout.
        let utc = Utc {
            classes: vec![
                class_entry(0, 1, vec![]),
                class_entry(1, 1, vec![]),
                class_entry(2, 1, vec![]),
                class_entry(3, 1, vec![]),
                class_entry(4, 1, vec![]),
                class_entry(5, 1, vec![]),
                class_entry(6, 1, vec![]),
                class_entry(7, 1, vec![]),
                class_entry(8, 1, vec![]),
            ],
            ..Utc::default()
        };
        let classes = label_only_2da(&[
            (0, "Soldier"),
            (1, "Scout"),
            (2, "Scoundrel"),
            (3, "JediGuardian"),
            (4, "JediConsular"),
            (5, "JediSentinel"),
            (6, "CombatDroid"),
            (7, "ExpertDroid"),
            (8, "Minion"),
        ]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved
            .classes()
            .iter()
            .map(|class| match class {
                DecodedClass::Soldier { .. } => "Soldier",
                DecodedClass::Scout { .. } => "Scout",
                DecodedClass::Scoundrel { .. } => "Scoundrel",
                DecodedClass::JediGuardian { .. } => "JediGuardian",
                DecodedClass::JediConsular { .. } => "JediConsular",
                DecodedClass::JediSentinel { .. } => "JediSentinel",
                DecodedClass::CombatDroid { .. } => "CombatDroid",
                DecodedClass::ExpertDroid { .. } => "ExpertDroid",
                DecodedClass::Minion { .. } => "Minion",
                DecodedClass::Unknown { .. } => "<unknown>",
            })
            .collect();
        assert_eq!(
            kinds,
            vec![
                "Soldier",
                "Scout",
                "Scoundrel",
                "JediGuardian",
                "JediConsular",
                "JediSentinel",
                "CombatDroid",
                "ExpertDroid",
                "Minion",
            ]
        );
    }

    #[test]
    fn classes_dispatch_by_label_so_mod_renumbered_class_still_routes() {
        // Mod relocates JediGuardian to row 42 in classes.2da. The
        // UTC's class_id is 42; dispatch is by label, so it still
        // routes to DecodedClass::JediGuardian rather than Unknown.
        let utc = Utc {
            classes: vec![class_entry(42, 5, vec![])],
            ..Utc::default()
        };
        let classes = label_only_2da(&[(42, "JediGuardian")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        match &resolved.classes()[0] {
            DecodedClass::JediGuardian {
                class_id, level, ..
            } => {
                // class_id preserved from the source GFF, not from
                // any vanilla-default lookup.
                assert_eq!(*class_id, 42);
                assert_eq!(*level, 5);
            }
            other => panic!("expected JediGuardian, got {other:?}"),
        }
    }

    #[test]
    fn unknown_class_carries_resolved_label_when_2da_row_exists() {
        // Mod adds row 9 with a label our dispatch does not know.
        // Result is Unknown with the resolved label surfaced.
        let utc = Utc {
            classes: vec![class_entry(9, 3, vec![])],
            ..Utc::default()
        };
        let classes = label_only_2da(&[(9, "DarkJediMaster")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        match &resolved.classes()[0] {
            DecodedClass::Unknown {
                class_id,
                class_label,
                level,
                ..
            } => {
                assert_eq!(*class_id, 9);
                assert_eq!(class_label.as_deref(), Some("DarkJediMaster"));
                assert_eq!(*level, 3);
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn unknown_class_carries_no_label_when_class_id_is_out_of_range() {
        // class_id 99 has no row in the fixture; label resolution
        // yields None.
        let utc = Utc {
            classes: vec![class_entry(99, 1, vec![])],
            ..Utc::default()
        };
        let classes = label_only_2da(&[(0, "Soldier")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        match &resolved.classes()[0] {
            DecodedClass::Unknown {
                class_id,
                class_label,
                ..
            } => {
                assert_eq!(*class_id, 99);
                assert!(class_label.is_none());
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn unknown_class_carries_no_label_when_classes_2da_unavailable() {
        // The source knows nothing about classes.2da; every entry
        // surfaces as Unknown with no label.
        let utc = Utc {
            classes: vec![class_entry(3, 5, vec![])],
            ..Utc::default()
        };
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        match &resolved.classes()[0] {
            DecodedClass::Unknown {
                class_id,
                class_label,
                level,
                ..
            } => {
                assert_eq!(*class_id, 3);
                assert!(class_label.is_none());
                assert_eq!(*level, 5);
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn class_powers_preserve_source_order_per_entry() {
        let utc = Utc {
            classes: vec![class_entry(4, 6, vec![100, 200, 50, 200])],
            ..Utc::default()
        };
        let classes = label_only_2da(&[(4, "JediConsular")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        // Duplicates are preserved (vanilla data can stack the same
        // power id) and order matches the source Vec.
        assert_eq!(resolved.classes()[0].powers(), &[100, 200, 50, 200]);
    }

    #[test]
    fn total_level_sums_across_typed_and_unknown_entries() {
        // Multi-class character: typed JediGuardian (level 19) +
        // typed JediSentinel (level 3) + an Unknown mod-class (level
        // 4). Total is 19 + 3 + 4 = 26 regardless of dispatch outcome.
        let utc = Utc {
            classes: vec![
                class_entry(3, 19, vec![]),
                class_entry(5, 3, vec![]),
                class_entry(99, 4, vec![]),
            ],
            ..Utc::default()
        };
        let classes = label_only_2da(&[(0, ""), (3, "JediGuardian"), (5, "JediSentinel")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "classes", &classes);

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.total_level(), 26);
    }

    #[test]
    fn one_projection_yields_diverging_class_kinds_per_scope() {
        // Mod conflict scenario for class dispatch: same UTC,
        // class_id 3 labelled JediGuardian in vanilla but rebadged
        // as a custom name in the mod. The shared projection feeds
        // two resolutions; each reports its own dispatch outcome.
        let utc = Utc {
            classes: vec![class_entry(3, 10, vec![])],
            ..Utc::default()
        };

        let vanilla_classes = label_only_2da(&[(3, "JediGuardian")]);
        let mut vanilla_tables = TestTables::new();
        add_2da_entry(&mut vanilla_tables, "classes", &vanilla_classes);

        let mod_classes = label_only_2da(&[(3, "MandalorianWarrior")]);
        let mut mod_tables = TestTables::new();
        add_2da_entry(&mut mod_tables, "classes", &mod_classes);

        let projection = utc.project();

        let vanilla = projection.resolve(&mut vanilla_tables);
        let modded = projection.resolve(&mut mod_tables);

        assert!(matches!(
            vanilla.classes()[0],
            DecodedClass::JediGuardian { .. }
        ));
        match &modded.classes()[0] {
            DecodedClass::Unknown { class_label, .. } => {
                assert_eq!(class_label.as_deref(), Some("MandalorianWarrior"));
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    // -- Equipment / inventory passthroughs --

    #[test]
    fn equipment_and_inventory_passthrough_source_slices() {
        use rakata_core::ResRef;

        let equip_resref = ResRef::new("g_w_blstrpstl001").expect("valid resref");
        let inv_resref = ResRef::new("g_i_medeqpmnt01").expect("valid resref");
        let utc = Utc {
            equipment: vec![UtcEquipmentItem::new(2, equip_resref)],
            inventory: vec![UtcInventoryItem::new(0, inv_resref)],
            ..Utc::default()
        };
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.equipment().len(), 1);
        assert_eq!(resolved.equipment()[0].slot_id, 2);
        assert_eq!(resolved.equipment()[0].resref, equip_resref);
        assert_eq!(resolved.inventory().len(), 1);
        assert_eq!(resolved.inventory()[0].entry_id, 0);
        assert_eq!(resolved.inventory()[0].resref, inv_resref);
    }

    // -- DecodedSpecialAbility dispatch --

    fn ability_entry(spell_id: u16, flags: u8, caster_level: u8) -> UtcSpecialAbility {
        UtcSpecialAbility {
            spell_id,
            spell_flags: flags,
            spell_caster_level: caster_level,
        }
    }

    fn vanilla_spells_2da() -> TwoDa {
        // Vanilla rows the corpus actually references; the gaps in
        // between rows are populated with empty labels for fidelity.
        label_only_2da(&[
            (52, "SPECIAL_ABILITY_BODY_FUEL"),
            (63, "SPECIAL_ABILITY_RAGE"),
            (83, "MONSTER_ABILITY_SLAM_ATTACK"),
        ])
    }

    #[test]
    fn special_abilities_dispatch_three_vanilla_labels_to_typed_variants() {
        let utc = Utc {
            special_abilities: vec![
                ability_entry(52, 0, 1),
                ability_entry(63, 0, 1),
                ability_entry(83, 0, 1),
            ],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "spells", &vanilla_spells_2da());

        let resolved = utc.resolve(&mut tables);
        assert!(matches!(
            resolved.special_abilities()[0],
            DecodedSpecialAbility::BodyFuel { .. }
        ));
        assert!(matches!(
            resolved.special_abilities()[1],
            DecodedSpecialAbility::Rage { .. }
        ));
        assert!(matches!(
            resolved.special_abilities()[2],
            DecodedSpecialAbility::MonsterSlamAttack { .. }
        ));
    }

    #[test]
    fn special_abilities_preserve_stacked_duplicates() {
        // Mirrors the vanilla Bastila 99-stack pattern. The engine
        // loader appends every entry; the decoder must do the same.
        let utc = Utc {
            special_abilities: (0..5).map(|_| ability_entry(52, 0, 1)).collect(),
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "spells", &vanilla_spells_2da());

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.special_abilities().len(), 5);
        for entry in resolved.special_abilities() {
            assert!(matches!(entry, DecodedSpecialAbility::BodyFuel { .. }));
        }
    }

    #[test]
    fn out_of_range_spell_id_surfaces_as_unknown_with_no_label() {
        // The partymember.utc anomaly: spell_id 299 vs 132-row
        // vanilla spells.2da. Must round-trip as Unknown carrying
        // the raw id and no label.
        let utc = Utc {
            special_abilities: vec![ability_entry(299, 1, 1)],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "spells", &vanilla_spells_2da());

        let resolved = utc.resolve(&mut tables);
        match &resolved.special_abilities()[0] {
            DecodedSpecialAbility::Unknown {
                spell_id,
                spell_label,
                flags,
                caster_level,
            } => {
                assert_eq!(*spell_id, 299);
                assert!(spell_label.is_none());
                assert_eq!(*flags, 1);
                assert_eq!(*caster_level, 1);
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn empty_special_ability_list_decodes_to_empty_slice() {
        let utc = Utc::default();
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.special_abilities().is_empty());
    }

    // -- ClassKindFilter / high-level helpers --

    fn utc_with_classes(class_ids: &[i32]) -> Utc {
        Utc {
            classes: class_ids
                .iter()
                .map(|id| class_entry(*id, 1, vec![]))
                .collect(),
            ..Utc::default()
        }
    }

    fn vanilla_classes_2da() -> TwoDa {
        label_only_2da(&[
            (0, "Soldier"),
            (1, "Scout"),
            (2, "Scoundrel"),
            (3, "JediGuardian"),
            (4, "JediConsular"),
            (5, "JediSentinel"),
            (6, "CombatDroid"),
            (7, "ExpertDroid"),
            (8, "Minion"),
        ])
    }

    fn vanilla_class_cache(tables: &mut TestTables) {
        let classes = vanilla_classes_2da();
        add_2da_entry(tables, "classes", &classes);
    }

    #[test]
    fn is_force_user_matches_any_jedi_class() {
        for jedi_id in [3, 4, 5] {
            let utc = utc_with_classes(&[jedi_id]);
            let mut tables = TestTables::new();
            vanilla_class_cache(&mut tables);

            let resolved = utc.resolve(&mut tables);
            assert!(
                resolved.is_force_user(),
                "class_id {jedi_id} should be a force user"
            );
        }
    }

    #[test]
    fn is_force_user_false_for_non_jedi_classes() {
        for non_jedi_id in [0, 1, 2, 6, 7, 8] {
            let utc = utc_with_classes(&[non_jedi_id]);
            let mut tables = TestTables::new();
            vanilla_class_cache(&mut tables);

            let resolved = utc.resolve(&mut tables);
            assert!(
                !resolved.is_force_user(),
                "class_id {non_jedi_id} should not be a force user"
            );
        }
    }

    #[test]
    fn is_droid_matches_combat_and_expert_droid() {
        for droid_id in [6, 7] {
            let utc = utc_with_classes(&[droid_id]);
            let mut tables = TestTables::new();
            vanilla_class_cache(&mut tables);

            let resolved = utc.resolve(&mut tables);
            assert!(resolved.is_droid(), "class_id {droid_id} should be a droid");
        }
    }

    #[test]
    fn is_droid_false_for_organic_classes() {
        for organic_id in [0, 1, 2, 3, 4, 5, 8] {
            let utc = utc_with_classes(&[organic_id]);
            let mut tables = TestTables::new();
            vanilla_class_cache(&mut tables);

            let resolved = utc.resolve(&mut tables);
            assert!(
                !resolved.is_droid(),
                "class_id {organic_id} should not be a droid"
            );
        }
    }

    #[test]
    fn has_class_matches_specific_typed_variants() {
        let utc = utc_with_classes(&[0, 3]);
        let mut tables = TestTables::new();
        vanilla_class_cache(&mut tables);

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.has_class(ClassKindFilter::Soldier));
        assert!(resolved.has_class(ClassKindFilter::JediGuardian));
        assert!(!resolved.has_class(ClassKindFilter::Scout));
        assert!(!resolved.has_class(ClassKindFilter::Minion));
    }

    #[test]
    fn has_class_never_matches_unknown_entries() {
        // class_id 99 has no matching row; it surfaces as Unknown.
        // No typed-variant filter (or family filter) matches it.
        let utc = utc_with_classes(&[99]);
        let mut tables = TestTables::new();
        vanilla_class_cache(&mut tables);

        let resolved = utc.resolve(&mut tables);
        assert!(!resolved.has_class(ClassKindFilter::Soldier));
        assert!(!resolved.has_class(ClassKindFilter::AnyJedi));
        assert!(!resolved.has_class(ClassKindFilter::AnyDroid));
        assert!(!resolved.is_force_user());
        assert!(!resolved.is_droid());
    }

    #[test]
    fn empty_class_list_helpers_all_return_false() {
        let utc = Utc::default();
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(!resolved.is_force_user());
        assert!(!resolved.is_droid());
        assert!(!resolved.has_class(ClassKindFilter::JediGuardian));
    }

    #[test]
    fn empty_class_list_decodes_to_empty_classes_slice() {
        let utc = Utc::default();
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.classes().is_empty());
        assert_eq!(resolved.total_level(), 0);
    }

    #[test]
    fn one_projection_yields_diverging_race_labels_per_scope() {
        // Mod conflict scenario: same UTC bytes, two scopes whose
        // racialtypes.2da labels differ at the same row index. The
        // shared projection feeds two resolutions; each reports its
        // scope's resolved label.
        let utc = Utc {
            race_id: 6,
            ..Utc::default()
        };

        let vanilla_races = label_only_2da(&[(6, "Human")]);
        let mut vanilla_tables = TestTables::new();
        add_2da_entry(&mut vanilla_tables, "racialtypes", &vanilla_races);

        let mod_races = label_only_2da(&[(6, "Mandalorian")]);
        let mut mod_tables = TestTables::new();
        add_2da_entry(&mut mod_tables, "racialtypes", &mod_races);

        let projection = utc.project();

        let vanilla = projection.resolve(&mut vanilla_tables);
        let modded = projection.resolve(&mut mod_tables);

        assert_eq!(vanilla.race_label(), Some("Human"));
        assert_eq!(modded.race_label(), Some("Mandalorian"));
    }

    // -- DecodedFeat dispatch --

    fn weapon_feats_2da() -> TwoDa {
        label_only_2da(&[
            (4, "ARMOUR_PROF_HEAVY"),
            (5, "ARMOUR_PROF_LIGHT"),
            (6, "ARMOUR_PROF_MEDIUM"),
            (32, "WEAPON_FOCUS_BLASTER"),
            (33, "WEAPON_FOCUS_BLASTER_RIFLE"),
            (34, "XXXX_WEAPON_FOCUS_GRENADE"),
            (35, "WEAPON_FOCUS_HEAVY_WEAPONS"),
            (36, "WEAPON_FOCUS_LIGHTSABER"),
            (37, "WEAPON_FOCUS_MELEE_WEAPONS"),
            (38, "XXXX_WEAPON_FOCUS_SIMPLE_WEAPONS"),
            (39, "WEAPON_PROF_BLASTER"),
            (40, "WEAPON_PROF_BLASTER_RIFLE"),
            (41, "XXXX_WEAPON_PROF_GRENADE"),
            (42, "WEAPON_PROF_HEAVY_WEAPONS"),
            (43, "WEAPON_PROF_LIGHTSABER"),
            (44, "WEAPON_PROF_MELEE_WEAPONS"),
            (45, "XXXX_WEAPON_PROF_SIMPLE_WEAPONS"),
            (46, "WEAPON_SPEC_BLASTER"),
            (47, "WEAPON_SPEC_BLASTER_RIFLE"),
            (48, "XXXX_WEAPON_SPEC_GRENADE"),
            (49, "WEAPON_SPEC_HEAVY_WEAPONS"),
            (50, "WEAPON_SPEC_LIGHTSABER"),
            (51, "WEAPON_SPEC_MELEE_WEAPONS"),
            (52, "XXXX_WEAPON_SPEC_SIMPLE_WEAPONS"),
            (93, "PROFICIENCY_ALL"),
        ])
    }

    fn feat_kind_label(feat: &DecodedFeat) -> &'static str {
        match feat {
            DecodedFeat::ArmourProfLight { .. } => "ArmourProfLight",
            DecodedFeat::ArmourProfMedium { .. } => "ArmourProfMedium",
            DecodedFeat::ArmourProfHeavy { .. } => "ArmourProfHeavy",
            DecodedFeat::WeaponProfBlaster { .. } => "WeaponProfBlaster",
            DecodedFeat::WeaponProfBlasterRifle { .. } => "WeaponProfBlasterRifle",
            DecodedFeat::WeaponProfHeavyWeapons { .. } => "WeaponProfHeavyWeapons",
            DecodedFeat::WeaponProfMeleeWeapons { .. } => "WeaponProfMeleeWeapons",
            DecodedFeat::WeaponProfLightsaber { .. } => "WeaponProfLightsaber",
            DecodedFeat::WeaponProfGrenade { .. } => "WeaponProfGrenade",
            DecodedFeat::WeaponProfSimpleWeapons { .. } => "WeaponProfSimpleWeapons",
            DecodedFeat::ProficiencyAll { .. } => "ProficiencyAll",
            DecodedFeat::WeaponFocusBlaster { .. } => "WeaponFocusBlaster",
            DecodedFeat::WeaponFocusBlasterRifle { .. } => "WeaponFocusBlasterRifle",
            DecodedFeat::WeaponFocusGrenade { .. } => "WeaponFocusGrenade",
            DecodedFeat::WeaponFocusHeavyWeapons { .. } => "WeaponFocusHeavyWeapons",
            DecodedFeat::WeaponFocusLightsaber { .. } => "WeaponFocusLightsaber",
            DecodedFeat::WeaponFocusMeleeWeapons { .. } => "WeaponFocusMeleeWeapons",
            DecodedFeat::WeaponFocusSimpleWeapons { .. } => "WeaponFocusSimpleWeapons",
            DecodedFeat::WeaponSpecBlaster { .. } => "WeaponSpecBlaster",
            DecodedFeat::WeaponSpecBlasterRifle { .. } => "WeaponSpecBlasterRifle",
            DecodedFeat::WeaponSpecGrenade { .. } => "WeaponSpecGrenade",
            DecodedFeat::WeaponSpecHeavyWeapons { .. } => "WeaponSpecHeavyWeapons",
            DecodedFeat::WeaponSpecLightsaber { .. } => "WeaponSpecLightsaber",
            DecodedFeat::WeaponSpecMeleeWeapons { .. } => "WeaponSpecMeleeWeapons",
            DecodedFeat::WeaponSpecSimpleWeapons { .. } => "WeaponSpecSimpleWeapons",
            DecodedFeat::PowerAttack { .. } => "PowerAttack",
            DecodedFeat::ImprovedPowerAttack { .. } => "ImprovedPowerAttack",
            DecodedFeat::MasterPowerAttack { .. } => "MasterPowerAttack",
            DecodedFeat::PowerBlast { .. } => "PowerBlast",
            DecodedFeat::ImprovedPowerBlast { .. } => "ImprovedPowerBlast",
            DecodedFeat::MasterPowerBlast { .. } => "MasterPowerBlast",
            DecodedFeat::CriticalStrike { .. } => "CriticalStrike",
            DecodedFeat::ImprovedCriticalStrike { .. } => "ImprovedCriticalStrike",
            DecodedFeat::MasterCriticalStrike { .. } => "MasterCriticalStrike",
            DecodedFeat::Flurry { .. } => "Flurry",
            DecodedFeat::ImprovedFlurry { .. } => "ImprovedFlurry",
            DecodedFeat::SniperShot { .. } => "SniperShot",
            DecodedFeat::ImprovedSniperShot { .. } => "ImprovedSniperShot",
            DecodedFeat::MasterSniperShot { .. } => "MasterSniperShot",
            DecodedFeat::RapidShot { .. } => "RapidShot",
            DecodedFeat::ImprovedRapidShot { .. } => "ImprovedRapidShot",
            DecodedFeat::MultiShot { .. } => "MultiShot",
            DecodedFeat::WhirlwindAttack { .. } => "WhirlwindAttack",
            DecodedFeat::TwoWeaponFighting { .. } => "TwoWeaponFighting",
            DecodedFeat::TwoWeaponAdvanced { .. } => "TwoWeaponAdvanced",
            DecodedFeat::TwoWeaponMastery { .. } => "TwoWeaponMastery",
            DecodedFeat::JediDefense { .. } => "JediDefense",
            DecodedFeat::AdvancedJediDefense { .. } => "AdvancedJediDefense",
            DecodedFeat::MasterJediDefense { .. } => "MasterJediDefense",
            DecodedFeat::ForceFocus { .. } => "ForceFocus",
            DecodedFeat::ForceFocusAdvanced { .. } => "ForceFocusAdvanced",
            DecodedFeat::ForceFocusMastery { .. } => "ForceFocusMastery",
            DecodedFeat::ForceFocusAlter { .. } => "ForceFocusAlter",
            DecodedFeat::ForceFocusControl { .. } => "ForceFocusControl",
            DecodedFeat::ForceJump { .. } => "ForceJump",
            DecodedFeat::ForceJumpAdvanced { .. } => "ForceJumpAdvanced",
            DecodedFeat::ForceJumpMastery { .. } => "ForceJumpMastery",
            DecodedFeat::ForceImmunityFear { .. } => "ForceImmunityFear",
            DecodedFeat::ForceImmunityStun { .. } => "ForceImmunityStun",
            DecodedFeat::ForceImmunityParalysis { .. } => "ForceImmunityParalysis",
            DecodedFeat::BattleMeditation { .. } => "BattleMeditation",
            DecodedFeat::ForceCamoflage { .. } => "ForceCamoflage",
            DecodedFeat::SneakAttack1D6 { .. } => "SneakAttack1D6",
            DecodedFeat::SneakAttack2D6 { .. } => "SneakAttack2D6",
            DecodedFeat::SneakAttack3D6 { .. } => "SneakAttack3D6",
            DecodedFeat::SneakAttack4D6 { .. } => "SneakAttack4D6",
            DecodedFeat::SneakAttack5D6 { .. } => "SneakAttack5D6",
            DecodedFeat::SneakAttack6D6 { .. } => "SneakAttack6D6",
            DecodedFeat::UncannyDodge1 { .. } => "UncannyDodge1",
            DecodedFeat::UncannyDodge2 { .. } => "UncannyDodge2",
            DecodedFeat::Toughness { .. } => "Toughness",
            DecodedFeat::ImprovedToughness { .. } => "ImprovedToughness",
            DecodedFeat::MasterToughness { .. } => "MasterToughness",
            DecodedFeat::Conditioning { .. } => "Conditioning",
            DecodedFeat::ImprovedConditioning { .. } => "ImprovedConditioning",
            DecodedFeat::MasterConditioning { .. } => "MasterConditioning",
            DecodedFeat::ImplantLevel1 { .. } => "ImplantLevel1",
            DecodedFeat::ImplantLevel2 { .. } => "ImplantLevel2",
            DecodedFeat::ImplantLevel3 { .. } => "ImplantLevel3",
            DecodedFeat::DroidUpgrade1 { .. } => "DroidUpgrade1",
            DecodedFeat::DroidUpgrade2 { .. } => "DroidUpgrade2",
            DecodedFeat::DroidUpgrade3 { .. } => "DroidUpgrade3",
            DecodedFeat::BlasterIntegration { .. } => "BlasterIntegration",
            DecodedFeat::LogicUpgradeCombat { .. } => "LogicUpgradeCombat",
            DecodedFeat::LogicUpgradeTactician { .. } => "LogicUpgradeTactician",
            DecodedFeat::Dueling { .. } => "Dueling",
            DecodedFeat::AdvancedDueling { .. } => "AdvancedDueling",
            DecodedFeat::MasterDueling { .. } => "MasterDueling",
            DecodedFeat::JediSense { .. } => "JediSense",
            DecodedFeat::KnightSense { .. } => "KnightSense",
            DecodedFeat::MasterSense { .. } => "MasterSense",
            DecodedFeat::GuardStance { .. } => "GuardStance",
            DecodedFeat::AdvancedGuardStance { .. } => "AdvancedGuardStance",
            DecodedFeat::MasterGuardStance { .. } => "MasterGuardStance",
            DecodedFeat::SkillFocusAwareness { .. } => "SkillFocusAwareness",
            DecodedFeat::SkillFocusTreatInjury { .. } => "SkillFocusTreatInjury",
            DecodedFeat::SkillFocusStealth { .. } => "SkillFocusStealth",
            DecodedFeat::Cautious { .. } => "Cautious",
            DecodedFeat::Perceptive { .. } => "Perceptive",
            DecodedFeat::Empathy { .. } => "Empathy",
            DecodedFeat::GearHead { .. } => "GearHead",
            DecodedFeat::WookieEndurance { .. } => "WookieEndurance",
            DecodedFeat::ScoundrelsLuck { .. } => "ScoundrelsLuck",
            DecodedFeat::Unknown { .. } => "<unknown>",
        }
    }

    #[test]
    fn feats_dispatch_armour_proficiency_labels_to_typed_variants() {
        let utc = Utc {
            feats: vec![4, 5, 6],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &weapon_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec!["ArmourProfHeavy", "ArmourProfLight", "ArmourProfMedium"]
        );
    }

    #[test]
    fn feats_dispatch_weapon_proficiency_labels_to_typed_variants() {
        // Includes XXXX_*-prefixed deprecated variants that vanilla
        // UTCs still load (grenade, simple weapons).
        let utc = Utc {
            feats: vec![39, 40, 41, 42, 43, 44, 45, 93],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &weapon_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "WeaponProfBlaster",
                "WeaponProfBlasterRifle",
                "WeaponProfGrenade",
                "WeaponProfHeavyWeapons",
                "WeaponProfLightsaber",
                "WeaponProfMeleeWeapons",
                "WeaponProfSimpleWeapons",
                "ProficiencyAll",
            ]
        );
    }

    #[test]
    fn feats_dispatch_weapon_focus_labels_to_typed_variants() {
        let utc = Utc {
            feats: vec![32, 33, 34, 35, 36, 37, 38],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &weapon_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "WeaponFocusBlaster",
                "WeaponFocusBlasterRifle",
                "WeaponFocusGrenade",
                "WeaponFocusHeavyWeapons",
                "WeaponFocusLightsaber",
                "WeaponFocusMeleeWeapons",
                "WeaponFocusSimpleWeapons",
            ]
        );
    }

    fn combat_feats_2da() -> TwoDa {
        label_only_2da(&[
            (3, "TWO_WEAPON_FIGHTING"),
            (8, "CRITICAL_STRIKE"),
            (9, "TWO_WEAPON_ADVANCED"),
            (11, "FLURRY"),
            (17, "IMPROVED_POWER_ATTACK"),
            (18, "IMPROVED_POWER_BLAST"),
            (19, "IMPROVED_CRITICAL_STRIKE"),
            (20, "IMPROVED_SNIPER_SHOT"),
            (26, "MULTI_SHOT"),
            (28, "POWER_ATTACK"),
            (29, "POWER_BLAST"),
            (30, "RAPID_SHOT"),
            (31, "SNIPER_SHOT"),
            (53, "WHIRLWIND_ATTACK"),
            (77, "MASTER_SNIPER_SHOT"),
            (81, "MASTER_CRITICAL_STRIKE"),
            (82, "MASTER_POWER_BLAST"),
            (83, "MASTER_POWER_ATTACK"),
            (85, "TWO_WEAPON_MASTERY"),
            (91, "IMPROVED_FLURRY"),
            (92, "IMPROVED_RAPID_SHOT"),
        ])
    }

    fn long_tail_feats_2da() -> TwoDa {
        label_only_2da(&[
            (2, "XXXX_ADVANCED_GUARD_STANCE"),
            (7, "CAUTIOUS"),
            (10, "EMPATHY"),
            (12, "GEAR_HEAD"),
            (25, "XXXX_MASTER_GUARD_STANCE"),
            (27, "XXXX_PERCEPTIVE"),
            (54, "XXXX_GUARD_STANCE"),
            (71, "XXXX_SKILL_FOCUS_STEALTH"),
            (72, "XXXX_SKILL_FOCUS_AWARENESS"),
            (76, "XXXX_SKILL_FOCUS_TREAT_INJURY"),
            (78, "DROID_UPGRADE_1"),
            (79, "DROID_UPGRADE_2"),
            (80, "DROID_UPGRADE_3"),
            (95, "WOOKIE_ENDURANCE"),
            (96, "BLASTER_INTEGRATION"),
            (104, "SCOUNDRELS_LUCK"),
            (107, "JEDI_SENSE"),
            (108, "KNIGHT_SENSE"),
            (109, "MASTER_SENSE"),
            (110, "LOGIC_UPGRADE_COMBAT"),
            (111, "LOGIC_UPGRADE_TACTICIAN"),
            (113, "DUELING"),
            (114, "ADVANCED_DUELING"),
            (115, "MASTER_DUELING"),
        ])
    }

    #[test]
    fn feats_dispatch_long_tail_labels_to_typed_variants() {
        // Every remaining vanilla-corpus feat, in row-id order.
        // Together with the previous family dispatch tests, this
        // closes the gap on vanilla coverage.
        let utc = Utc {
            feats: vec![
                2, 7, 10, 12, 25, 27, 54, 71, 72, 76, 78, 79, 80, 95, 96, 104, 107, 108, 109, 110,
                111, 113, 114, 115,
            ],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &long_tail_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "AdvancedGuardStance",
                "Cautious",
                "Empathy",
                "GearHead",
                "MasterGuardStance",
                "Perceptive",
                "GuardStance",
                "SkillFocusStealth",
                "SkillFocusAwareness",
                "SkillFocusTreatInjury",
                "DroidUpgrade1",
                "DroidUpgrade2",
                "DroidUpgrade3",
                "WookieEndurance",
                "BlasterIntegration",
                "ScoundrelsLuck",
                "JediSense",
                "KnightSense",
                "MasterSense",
                "LogicUpgradeCombat",
                "LogicUpgradeTactician",
                "Dueling",
                "AdvancedDueling",
                "MasterDueling",
            ]
        );
    }

    fn survival_feats_2da() -> TwoDa {
        label_only_2da(&[
            (13, "CONDITIONING"),
            (14, "IMPLANT_LEVEL_1"),
            (15, "IMPLANT_LEVEL_2"),
            (16, "IMPLANT_LEVEL_3"),
            (21, "IMPROVED_CONDITIONING"),
            (22, "MASTER_CONDITIONING"),
            (56, "UNCANNY_DODGE_1"),
            (57, "UNCANNY_DODGE_2"),
            (60, "SNEAK_ATTACK_1D6"),
            (61, "SNEAK_ATTACK_2D6"),
            (62, "SNEAK_ATTACK_3D6"),
            (63, "SNEAK_ATTACK_4D6"),
            (64, "SNEAK_ATTACK_5D6"),
            (65, "SNEAK_ATTACK_6D6"),
            (84, "TOUGHNESS"),
            (123, "IMPROVED_TOUGHNESS"),
            (124, "MASTER_TOUGHNESS"),
        ])
    }

    #[test]
    fn feats_dispatch_survival_labels_to_typed_variants() {
        let utc = Utc {
            feats: vec![
                13, 14, 15, 16, 21, 22, 56, 57, 60, 61, 62, 63, 64, 65, 84, 123, 124,
            ],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &survival_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "Conditioning",
                "ImplantLevel1",
                "ImplantLevel2",
                "ImplantLevel3",
                "ImprovedConditioning",
                "MasterConditioning",
                "UncannyDodge1",
                "UncannyDodge2",
                "SneakAttack1D6",
                "SneakAttack2D6",
                "SneakAttack3D6",
                "SneakAttack4D6",
                "SneakAttack5D6",
                "SneakAttack6D6",
                "Toughness",
                "ImprovedToughness",
                "MasterToughness",
            ]
        );
    }

    fn force_feats_2da() -> TwoDa {
        label_only_2da(&[
            (1, "ADVANCED_JEDI_DEFENSE"),
            (24, "MASTER_JEDI_DEFENSE"),
            (55, "JEDI_DEFENSE"),
            (86, "XXXX_FORCE_FOCUS_ALTER"),
            (87, "XXXX_FORCE_FOCUS_CONTROL"),
            (88, "FORCE_FOCUS"),
            (89, "FORCE_FOCUS_ADVANCED"),
            (90, "FORCE_FOCUS_MASTERY"),
            (94, "BATTLE_MEDITATION"),
            (97, "FORCE_CAMOFLAGE"),
            (98, "FORCE_IMMUNITY_FEAR"),
            (99, "FORCE_IMMUNITY_STUN"),
            (100, "FORCE_IMMUNITY_PARALYSIS"),
            (101, "FORCE_JUMP"),
            (102, "FORCE_JUMP_ADVANCED"),
            (103, "FORCE_JUMP_MASTERY"),
        ])
    }

    #[test]
    fn feats_dispatch_force_jedi_labels_to_typed_variants() {
        let utc = Utc {
            feats: vec![
                1, 24, 55, 86, 87, 88, 89, 90, 94, 97, 98, 99, 100, 101, 102, 103,
            ],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &force_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "AdvancedJediDefense",
                "MasterJediDefense",
                "JediDefense",
                "ForceFocusAlter",
                "ForceFocusControl",
                "ForceFocus",
                "ForceFocusAdvanced",
                "ForceFocusMastery",
                "BattleMeditation",
                "ForceCamoflage",
                "ForceImmunityFear",
                "ForceImmunityStun",
                "ForceImmunityParalysis",
                "ForceJump",
                "ForceJumpAdvanced",
                "ForceJumpMastery",
            ]
        );
    }

    #[test]
    fn feats_dispatch_combat_ladders_to_typed_variants() {
        // Every combat-technique ladder, in feat_id order so the
        // expected list is easy to read.
        let utc = Utc {
            feats: vec![
                3, 8, 9, 11, 17, 18, 19, 20, 26, 28, 29, 30, 31, 53, 77, 81, 82, 83, 85, 91, 92,
            ],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &combat_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "TwoWeaponFighting",
                "CriticalStrike",
                "TwoWeaponAdvanced",
                "Flurry",
                "ImprovedPowerAttack",
                "ImprovedPowerBlast",
                "ImprovedCriticalStrike",
                "ImprovedSniperShot",
                "MultiShot",
                "PowerAttack",
                "PowerBlast",
                "RapidShot",
                "SniperShot",
                "WhirlwindAttack",
                "MasterSniperShot",
                "MasterCriticalStrike",
                "MasterPowerBlast",
                "MasterPowerAttack",
                "TwoWeaponMastery",
                "ImprovedFlurry",
                "ImprovedRapidShot",
            ]
        );
    }

    #[test]
    fn feats_dispatch_weapon_specialization_labels_to_typed_variants() {
        let utc = Utc {
            feats: vec![46, 47, 48, 49, 50, 51, 52],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &weapon_feats_2da());

        let resolved = utc.resolve(&mut tables);
        let kinds: Vec<&str> = resolved.feats().iter().map(feat_kind_label).collect();
        assert_eq!(
            kinds,
            vec![
                "WeaponSpecBlaster",
                "WeaponSpecBlasterRifle",
                "WeaponSpecGrenade",
                "WeaponSpecHeavyWeapons",
                "WeaponSpecLightsaber",
                "WeaponSpecMeleeWeapons",
                "WeaponSpecSimpleWeapons",
            ]
        );
    }

    #[test]
    fn feats_dispatch_by_label_so_mod_renumbered_feat_still_routes() {
        // Mod relocates ARMOUR_PROF_LIGHT to row 500 in feat.2da.
        // The UTC's feat_id is 500; dispatch is by label, so it
        // still routes to DecodedFeat::ArmourProfLight rather than
        // Unknown.
        let utc = Utc {
            feats: vec![500],
            ..Utc::default()
        };
        let feat = label_only_2da(&[(500, "ARMOUR_PROF_LIGHT")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &feat);

        let resolved = utc.resolve(&mut tables);
        match &resolved.feats()[0] {
            DecodedFeat::ArmourProfLight { feat_id } => {
                // feat_id preserved from the source GFF, not from
                // any vanilla-default lookup.
                assert_eq!(*feat_id, 500);
            }
            other => panic!("expected ArmourProfLight, got {other:?}"),
        }
    }

    #[test]
    fn feat_with_unknown_label_surfaces_as_unknown_carrying_resolved_label() {
        // Mod adds row 5000 with a label our dispatch does not know.
        // Result is Unknown with the resolved label surfaced.
        let utc = Utc {
            feats: vec![5000],
            ..Utc::default()
        };
        let feat = label_only_2da(&[(5000, "MOD_MYSTERY_FEAT")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &feat);

        let resolved = utc.resolve(&mut tables);
        match &resolved.feats()[0] {
            DecodedFeat::Unknown {
                feat_id,
                feat_label,
            } => {
                assert_eq!(*feat_id, 5000);
                assert_eq!(feat_label.as_deref(), Some("MOD_MYSTERY_FEAT"));
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn feat_decodes_to_unknown_with_no_label_when_id_out_of_range() {
        // feat.2da has 2 rows but the UTC carries feat_id 99. Label
        // resolution yields None; the raw id round-trips intact.
        let utc = Utc {
            feats: vec![99],
            ..Utc::default()
        };
        let feat = label_only_2da(&[(0, ""), (1, "ADVANCED_JEDI_DEFENSE")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &feat);

        let resolved = utc.resolve(&mut tables);
        match &resolved.feats()[0] {
            DecodedFeat::Unknown {
                feat_id,
                feat_label,
            } => {
                assert_eq!(*feat_id, 99);
                assert!(feat_label.is_none());
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    #[test]
    fn feat_decodes_to_unknown_with_no_label_when_feat_2da_unavailable() {
        // The source knows nothing about feat.2da; every entry surfaces
        // as Unknown with no label regardless of whether the id maps
        // to a typed variant under a resolved table.
        let utc = Utc {
            feats: vec![5, 93],
            ..Utc::default()
        };
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        for entry in resolved.feats() {
            match entry {
                DecodedFeat::Unknown { feat_label, .. } => assert!(feat_label.is_none()),
                other => panic!("expected Unknown without label, got {other:?}"),
            }
        }
    }

    #[test]
    fn empty_feat_list_decodes_to_empty_slice() {
        let utc = Utc::default();
        let mut tables = TestTables::new();

        let resolved = utc.resolve(&mut tables);
        assert!(resolved.feats().is_empty());
    }

    #[test]
    fn feat_id_accessor_returns_raw_id_regardless_of_variant() {
        let unknown = DecodedFeat::Unknown {
            feat_id: 84,
            feat_label: Some("TOUGHNESS".to_string()),
        };
        assert_eq!(unknown.feat_id(), 84);
        let typed = DecodedFeat::ArmourProfLight { feat_id: 5 };
        assert_eq!(typed.feat_id(), 5);
    }

    #[test]
    fn feats_preserve_stacked_duplicates_as_typed_variant_slots() {
        // Engine load path appends without dedup; UTC carrying the
        // same typed feat_id N times surfaces as N separate slots.
        let utc = Utc {
            feats: vec![5, 5, 5],
            ..Utc::default()
        };
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &weapon_feats_2da());

        let resolved = utc.resolve(&mut tables);
        assert_eq!(resolved.feats().len(), 3);
        for entry in resolved.feats() {
            assert!(matches!(entry, DecodedFeat::ArmourProfLight { feat_id: 5 }));
        }
    }

    #[test]
    fn one_projection_yields_diverging_feat_dispatch_per_scope() {
        // Mod conflict scenario: same UTC, feat_id 5 maps to vanilla
        // ARMOUR_PROF_LIGHT under one scope and a mod label under
        // another. Vanilla routes to a typed variant; the mod scope
        // falls into Unknown carrying the mod's label.
        let utc = Utc {
            feats: vec![5],
            ..Utc::default()
        };

        let mut vanilla_tables = TestTables::new();
        add_2da_entry(&mut vanilla_tables, "feat", &weapon_feats_2da());

        let mod_feat = label_only_2da(&[(5, "MOD_FIBER_ARMOUR")]);
        let mut mod_tables = TestTables::new();
        add_2da_entry(&mut mod_tables, "feat", &mod_feat);

        let projection = utc.project();

        let vanilla = projection.resolve(&mut vanilla_tables);
        let modded = projection.resolve(&mut mod_tables);

        assert!(matches!(
            vanilla.feats()[0],
            DecodedFeat::ArmourProfLight { feat_id: 5 }
        ));
        match &modded.feats()[0] {
            DecodedFeat::Unknown {
                feat_id,
                feat_label,
            } => {
                assert_eq!(*feat_id, 5);
                assert_eq!(feat_label.as_deref(), Some("MOD_FIBER_ARMOUR"));
            }
            other => panic!("expected Unknown, got {other:?}"),
        }
    }

    // -- FeatKindFilter --

    #[test]
    fn has_feat_matches_each_family_filter() {
        // One UTC carrying a representative feat per family, then
        // every family filter is asserted to flip.
        let mut tables = TestTables::new();
        // Merge fixtures so a single 2DA covers every label the
        // dispatch tests below need.
        let combined = label_only_2da(&[
            (5, "ARMOUR_PROF_LIGHT"),
            (28, "POWER_ATTACK"),
            (39, "WEAPON_PROF_BLASTER"),
            (32, "WEAPON_FOCUS_BLASTER"),
            (46, "WEAPON_SPEC_BLASTER"),
            (29, "POWER_BLAST"),
            (8, "CRITICAL_STRIKE"),
            (11, "FLURRY"),
            (31, "SNIPER_SHOT"),
            (30, "RAPID_SHOT"),
            (3, "TWO_WEAPON_FIGHTING"),
            (55, "JEDI_DEFENSE"),
            (88, "FORCE_FOCUS"),
            (101, "FORCE_JUMP"),
            (98, "FORCE_IMMUNITY_FEAR"),
            (60, "SNEAK_ATTACK_1D6"),
            (56, "UNCANNY_DODGE_1"),
            (84, "TOUGHNESS"),
            (13, "CONDITIONING"),
            (14, "IMPLANT_LEVEL_1"),
            (78, "DROID_UPGRADE_1"),
            (113, "DUELING"),
            (107, "JEDI_SENSE"),
            (54, "XXXX_GUARD_STANCE"),
            (72, "XXXX_SKILL_FOCUS_AWARENESS"),
        ]);
        add_2da_entry(&mut tables, "feat", &combined);

        let utc = Utc {
            feats: vec![
                5, 28, 39, 32, 46, 29, 8, 11, 31, 30, 3, 55, 88, 101, 98, 60, 56, 84, 13, 14, 78,
                113, 107, 54, 72,
            ],
            ..Utc::default()
        };
        let resolved = utc.resolve(&mut tables);

        let cases = [
            (FeatKindFilter::AnyArmourProficiency, true),
            (FeatKindFilter::AnyWeaponProficiency, true),
            (FeatKindFilter::AnyWeaponFocus, true),
            (FeatKindFilter::AnyWeaponSpecialization, true),
            (FeatKindFilter::AnyPowerAttack, true),
            (FeatKindFilter::AnyPowerBlast, true),
            (FeatKindFilter::AnyCriticalStrike, true),
            (FeatKindFilter::AnyFlurry, true),
            (FeatKindFilter::AnySniperShot, true),
            (FeatKindFilter::AnyRapidShot, true),
            (FeatKindFilter::AnyTwoWeapon, true),
            (FeatKindFilter::AnyJediDefense, true),
            (FeatKindFilter::AnyForceFocus, true),
            (FeatKindFilter::AnyForceJump, true),
            (FeatKindFilter::AnyForceImmunity, true),
            (FeatKindFilter::AnySneakAttack, true),
            (FeatKindFilter::AnyUncannyDodge, true),
            (FeatKindFilter::AnyToughness, true),
            (FeatKindFilter::AnyConditioning, true),
            (FeatKindFilter::AnyImplant, true),
            (FeatKindFilter::AnyDroidUpgrade, true),
            (FeatKindFilter::AnyDueling, true),
            (FeatKindFilter::AnySense, true),
            (FeatKindFilter::AnyGuardStance, true),
            (FeatKindFilter::AnySkillFocus, true),
        ];
        for (filter, expected) in cases {
            assert_eq!(
                resolved.has_feat(filter),
                expected,
                "filter {filter:?} expected {expected}"
            );
        }
    }

    #[test]
    fn has_feat_returns_false_for_empty_feat_list() {
        let utc = Utc::default();
        let mut tables = TestTables::new();
        let resolved = utc.resolve(&mut tables);
        for filter in [
            FeatKindFilter::AnyArmourProficiency,
            FeatKindFilter::AnyPowerAttack,
            FeatKindFilter::AnyForceJump,
            FeatKindFilter::AnySneakAttack,
        ] {
            assert!(!resolved.has_feat(filter));
        }
    }

    #[test]
    fn has_feat_never_matches_unknown_entries() {
        // A UTC carrying only mod-added feats (Unknown variants) is
        // never matched by any family filter, even ones whose name
        // intuitively suggests the mod's intent.
        let utc = Utc {
            feats: vec![5000],
            ..Utc::default()
        };
        let feat = label_only_2da(&[(5000, "MOD_POWER_ATTACK_REWORK")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &feat);
        let resolved = utc.resolve(&mut tables);

        assert!(matches!(resolved.feats()[0], DecodedFeat::Unknown { .. }));
        assert!(!resolved.has_feat(FeatKindFilter::AnyPowerAttack));
        assert!(!resolved.has_feat(FeatKindFilter::AnyArmourProficiency));
    }

    #[test]
    fn has_feat_distinguishes_specific_ladder_from_neighbour() {
        // A UTC with Power Attack but no Power Blast: AnyPowerAttack
        // flips on, AnyPowerBlast stays off. Same shape across
        // ladders, this just sanity-checks the matchers don't bleed.
        let utc = Utc {
            feats: vec![28],
            ..Utc::default()
        };
        let feat = label_only_2da(&[(28, "POWER_ATTACK")]);
        let mut tables = TestTables::new();
        add_2da_entry(&mut tables, "feat", &feat);
        let resolved = utc.resolve(&mut tables);

        assert!(resolved.has_feat(FeatKindFilter::AnyPowerAttack));
        assert!(!resolved.has_feat(FeatKindFilter::AnyPowerBlast));
        assert!(!resolved.has_feat(FeatKindFilter::AnyCriticalStrike));
        assert!(!resolved.has_feat(FeatKindFilter::AnyForceJump));
    }
}