forge/

paperdoll.rs

// #t(file: rust_alloc_in_loop) CLI display formatting, bounded by spell/aura count

//! Paperdoll subcommand: bootstrap a handler and dump the character sheet.

use anyhow::{Context, Result, anyhow, ensure};
use tabled::Tabled;
use wowlab_common::output;
use wowlab_engine_adapter_data::{LocalCsvResolver, OverlayResolver};
use wowlab_engine_application::{build_handler, simulate_intent};
use wowlab_engine_ports::{ContentCatalog, NoopProgress, Paperdoll, content_catalog};
use wowlab_fs::file;
use wowlab_types::{constants::MS_PER_SECOND, game::SpecId};

use crate::{
    constants::{default_data_dir, engine_dir},
    encounter_fixture::EncounterFixture,
    intent,
    run::{FightDurationSeconds, IterationCount, RunParameters},
    sim,
};

const PAPERDOLL_DURATION_S: u32 = 300;

#[derive(Debug, clap::Args)]
pub(crate) struct PaperdollArgs {
    /// Spec slug (e.g. "`outlaw_rogue`", "`fire_mage`").
    pub spec: String,

    /// Output raw JSON instead of formatted text.
    #[arg(long)]
    pub json: bool,

    /// Inspect one of the maintained encounter fixtures.
    #[arg(long, value_enum)]
    pub encounter_fixture: Option<EncounterFixture>,

    /// Generate a tracked spatial debugger under docs/multi-enemy-encounters.
    #[arg(long, requires = "encounter_fixture")]
    pub encounter_html: bool,

    /// Write a TRACE log of game-data resolution to a temporary file.
    #[arg(long)]
    pub trace: bool,
}

pub(crate) fn run(args: &PaperdollArgs) -> Result<()> {
    ensure!(
        !(args.json && args.encounter_fixture.is_some()),
        "--json cannot be combined with --encounter-fixture; fixture diagnostics are tabular"
    );
    let spec = SpecId::from_manifest_slug(&args.spec)
        .ok_or_else(|| anyhow!("Unknown spec slug: {}", args.spec))?;
    let trace_path = crate::trace::init_trace_log(args.trace, &args.spec)?;

    let slug = spec.slug();
    let rotation_id = format!("{slug}_assisted");
    let parameters = RunParameters::new(
        IterationCount::ONE,
        FightDurationSeconds::from_nonzero_const(PAPERDOLL_DURATION_S),
    );

    let data_dir = std::env::var("WOWLAB_DATA_DIR").unwrap_or_else(|_| default_data_dir());
    let rotation_path = engine_dir()
        .join("examples/rotations")
        .join(format!("{rotation_id}.json"));
    let rotation_script = file::read_text(&rotation_path)
        .with_context(|| format!("failed to read rotation {}", rotation_path.display()))?;

    let resolver = OverlayResolver::new(LocalCsvResolver::new(data_dir.as_str()))
        .with_rotation_script(&rotation_id, rotation_script);
    let resolver_dyn = wowlab_engine_ports::DynDataResolver::from_ref(&resolver);

    let rt = tokio::runtime::Runtime::new().context("failed to create tokio runtime")?;
    let catalog = content_catalog().context("engine content catalog is unavailable")?;
    let sim_config = rt.block_on(paperdoll_sim_config(
        args,
        spec,
        &rotation_id,
        parameters,
        resolver_dyn,
    ))?;
    let handler = rt
        .block_on(build_handler(catalog, &sim_config, resolver_dyn))
        .with_context(|| format!("failed to build handler for {slug}"))?;

    let encounter_debug = collect_encounter_debug(
        catalog,
        args.encounter_fixture,
        &sim_config,
        resolver_dyn,
        &rt,
        slug,
    )?;

    let pd = handler
        .paperdoll()
        .ok_or_else(|| anyhow::anyhow!("paperdoll not supported for {slug}"))?;

    if args.json {
        output::json(&pd);
    } else {
        print_paperdoll(&pd);
    }

    render_encounter_debug(args, encounter_debug.as_ref())?;

    if let Some(path) = trace_path {
        output::blank();
        output::detail(&format!("Trace log written to: {}", path.display()));
    }

    Ok(())
}

/// Uses comparison profile inputs when available so paperdoll and compare agree.
async fn paperdoll_sim_config(
    args: &PaperdollArgs,
    spec: SpecId,
    rotation_id: &str,
    parameters: RunParameters,
    resolver: &wowlab_engine_ports::DynDataResolver<'_>,
) -> Result<String> {
    if crate::simc::simc_profile_path(spec).is_some() {
        let config = crate::provider::ComparisonConfig {
            spec,
            parameters,
            race: None,
            bugs: true,
            simc_debug: false,
        };

        return crate::wowlab::wowlab_profile_config_with_fixture(
            &config,
            rotation_id,
            args.encounter_fixture,
            resolver,
        )
        .await;
    }

    let mut intent =
        intent::canonical_patchwerk_intent(spec, rotation_id, f64::from(PAPERDOLL_DURATION_S))
            .map_err(|message| anyhow!("failed to build paperdoll intent: {message}"))?;

    if let Some(fixture) = args.encounter_fixture {
        intent.encounter = fixture.definition()?;
    }

    wowlab_common::sim::intent::serialize_sim_config(&intent)
        .context("failed to serialize paperdoll intent")
}

fn render_encounter_debug(
    args: &PaperdollArgs,
    report: Option<&crate::encounter_debug::EncounterDebugReport>,
) -> Result<()> {
    let Some(report) = report else {
        return Ok(());
    };

    crate::encounter_debug::print_report(report);

    if args.encounter_html {
        let path = crate::encounter_html::write(report)?;

        output::blank();
        output::detail(&format!("Spatial debugger: {}", path.display()));
    }

    Ok(())
}

fn collect_encounter_debug(
    catalog: &ContentCatalog,
    fixture: Option<EncounterFixture>,
    sim_config: &str,
    resolver: &wowlab_engine_ports::DynDataResolver<'_>,
    runtime: &tokio::runtime::Runtime,
    spec_slug: &str,
) -> Result<Option<crate::encounter_debug::EncounterDebugReport>> {
    let Some(fixture) = fixture else {
        return Ok(None);
    };
    let chunk = sim::make_chunk("paperdoll-encounter-fixture", 1, None);
    let report = runtime
        .block_on(simulate_intent(
            catalog,
            sim_config,
            &chunk,
            crate::constants::DEFAULT_SEED,
            resolver,
            &NoopProgress,
        ))
        .with_context(|| format!("encounter fixture simulation failed for {spec_slug}"))?;
    let telemetry = sim::decode_telemetry(&report)?;

    runtime
        .block_on(crate::encounter_debug::build_report(
            fixture, &telemetry, resolver,
        ))
        .map(Some)
}

const MILLIS_PER_HOUR: u32 = 3_600_000;
const SECS_PER_MIN: f64 = 60.0;

fn fmt_duration_ms(ms: u32) -> String {
    if ms == 0 {
        return "instant".to_string();
    }

    if ms >= MILLIS_PER_HOUR {
        return "permanent".to_string();
    }

    let secs = f64::from(ms) / MS_PER_SECOND;

    if secs >= SECS_PER_MIN {
        format!("{:.0}m", secs / SECS_PER_MIN)
    } else if secs.fract().abs() < f64::EPSILON {
        format!("{secs:.0}s")
    } else {
        format!("{secs:.1}s")
    }
}

fn fmt_damage(info: &wowlab_types::game::DamageInfo) -> String {
    use wowlab_types::game::DamageKind;

    match &info.kind {
        DamageKind::None => "-".to_string(),
        DamageKind::Flat { amount } => format!("{amount:.0} flat"),
        DamageKind::ApCoefficient { coef, is_physical } => {
            let school = if *is_physical { "phys" } else { "magic" };

            format!("{coef:.3} AP ({school})")
        }
        DamageKind::SpCoefficient { coef, is_physical } => {
            let school = if *is_physical { "phys" } else { "magic" };

            format!("{coef:.3} SP ({school})")
        }
        _ => "?".to_string(),
    }
}

#[derive(Tabled)]
struct SpellRow {
    #[tabled(rename = "Spell")]
    name: String,
    #[tabled(rename = "ID")]
    id: u32,
    #[tabled(rename = "Cast")]
    cast: String,
    #[tabled(rename = "GCD")]
    gcd: String,
    #[tabled(rename = "Cost")]
    cost: String,
    #[tabled(rename = "Cooldown")]
    cooldown: String,
    #[tabled(rename = "Damage")]
    damage: String,
}

#[derive(Tabled)]
struct AuraRow {
    #[tabled(rename = "Aura")]
    name: String,
    #[tabled(rename = "ID")]
    id: u32,
    #[tabled(rename = "Duration")]
    duration: String,
    #[tabled(rename = "Stacks")]
    max_stacks: u8,
    #[tabled(rename = "Haste")]
    haste: String,
    #[tabled(rename = "Dmg Mult")]
    damage_mult: String,
    #[tabled(rename = "Periodic")]
    periodic: String,
}

fn aura_name(intro: &wowlab_types::game::SpecIntrospection, aura_id: u32) -> &str {
    intro
        .auras
        .iter()
        .find(|a| a.aura_id == aura_id)
        .map_or("?", |a| a.name.as_str())
}

fn fmt_resource(r: &wowlab_types::game::ResourceInfo) -> String {
    if r.regen > 0.0 {
        format!("max {:.0}, regen {:.1}/s", r.max, r.regen)
    } else {
        format!("max {:.0}", r.max)
    }
}

fn fmt_spell_cost(sp: &wowlab_types::game::SpellInfo) -> String {
    match (sp.resource_cost > 0.0, sp.secondary_resource_cost > 0.0) {
        (true, true) => format!(
            "{:.0} + {:.0} sec",
            sp.resource_cost, sp.secondary_resource_cost
        ),
        (true, false) => format!("{:.0}", sp.resource_cost),
        (false, true) => format!("{:.0} sec", sp.secondary_resource_cost),
        (false, false) => "-".into(),
    }
}

fn fmt_cooldown(sp: &wowlab_types::game::SpellInfo) -> String {
    let cooldown = sp.cooldown.as_ref().filter(|cd| cd.duration_secs > 0.0);

    cooldown.map_or_else(
        || "-".into(),
        |cd| {
            if cd.max_charges > 1 {
                format!("{:.0}s ({}ch)", cd.duration_secs, cd.max_charges)
            } else {
                format!("{:.0}s", cd.duration_secs)
            }
        },
    )
}

fn fmt_pct_or_dash(v: f64) -> String {
    if v > 0.0 {
        format!("+{v:.0}%")
    } else {
        "-".into()
    }
}

fn print_paperdoll(pd: &Paperdoll) {
    let s = &pd.stats;
    let intro = &pd.introspection;

    output::header("Character");
    output::kv("Attack Power", &format!("{:.0}", s.attack_power));
    output::kv("Spell Power", &format!("{:.0}", s.spell_power));
    output::kv("Crit", &format!("{:.2}%", s.crit_chance));
    output::kv("Haste", &format!("{:.2}%", s.haste));
    output::kv("Mastery", &format!("{:.2}%", s.mastery));
    output::kv("Versatility", &format!("{:.2}%", s.versatility));
    output::kv("Stamina", &format!("{:.0}", s.stamina));
    output::kv("Armor", &format!("{:.0}", s.armor));
    output::kv(
        &intro.resource_primary.name,
        &fmt_resource(&intro.resource_primary),
    );

    if let Some(ref sec) = intro.resource_secondary {
        output::kv(&sec.name, &fmt_resource(sec));
    }

    if !pd.precombat_aura_ids.is_empty() {
        output::blank();
        output::header("Precombat Auras");

        for &id in &pd.precombat_aura_ids {
            output::detail(&format!("{} ({id})", aura_name(intro, id)));
        }
    }

    if !pd.talent_ranks.is_empty() {
        output::blank();
        output::header("Talent Ranks");

        for &(id, rank) in &pd.talent_ranks {
            output::detail(&format!("{} ({id}) rank {rank}", aura_name(intro, id)));
        }
    }

    output::blank();
    output::header(&format!("Spells ({})", intro.spells.len()));
    output::table(intro.spells.iter().map(|sp| SpellRow {
        name: sp.name.clone(),
        id: sp.spell_id,
        cast: if sp.cast_time_ms == 0 {
            "instant".into()
        } else {
            fmt_duration_ms(sp.cast_time_ms)
        },
        gcd: if sp.off_gcd {
            "off-GCD".into()
        } else {
            fmt_duration_ms(sp.gcd_ms)
        },
        cost: fmt_spell_cost(sp),
        cooldown: fmt_cooldown(sp),
        damage: fmt_damage(&sp.damage),
    }));

    output::blank();
    output::header(&format!("Auras ({})", intro.auras.len()));
    output::table(intro.auras.iter().map(|a| AuraRow {
        name: a.name.clone(),
        id: a.aura_id,
        duration: fmt_duration_ms(a.base_duration_ms),
        max_stacks: a.max_stacks,
        haste: fmt_pct_or_dash(a.haste_buff_pct),
        damage_mult: if a.damage_mult_pct > 0.0 {
            format!("+{:.0}%", (a.damage_mult_pct - 1.0) * 100.0)
        } else {
            "-".into()
        },
        periodic: a.periodic.as_ref().map_or_else(
            || "-".into(),
            |p| format!("every {}", fmt_duration_ms(p.tick_ms)),
        ),
    }));

    if !intro.auto_attacks.is_empty() {
        output::blank();
        output::header("Auto Attacks");

        for aa in &intro.auto_attacks {
            let kind = if aa.is_pet { "pet" } else { "melee" };

            output::detail(&format!(
                "{kind} ({}) swing={} ap={:.2}",
                aa.spell_id,
                fmt_duration_ms(aa.swing_ms),
                aa.ap_coef
            ));
        }
    }

    for &(slot, spell_id) in &pd.item_use_spells {
        output::detail(&format!("on-use: {slot:?} -> spell {spell_id}"));
    }
}