Sylpheed/crates/sylpheed-formats/examples/paint_order_audit.rs

//! Does the DERIVED paint order reproduce the ones measured from the game?
//!
//! `compose` uses a measured order for the three builds that have one and falls
//! back to `derived_paint_order` (a sort on each sprite's layer key) everywhere
//! else. The doc comment claims the derived order "reproduces both measured
//! orders up to ties" — this checks that claim against all three, and says what
//! the ties actually cost.
//!
//!     cargo run -p sylpheed-formats --example paint_order_audit -- <GP_TITLE.pak>
use sylpheed_formats::{pak, ui_layout};

fn measured(names: &[&str]) -> Option<(&'static str, Vec<usize>)> {
    const TITLE: [&str; 24] = [
        "ptlogo1.t32",
        "ptlogo2.t32",
        "ptlogo1.t32",
        "ptlogo2.t32",
        "ptlogo1.t32",
        "ptlogo2.t32",
        "pteff01.t32",
        "ptlogo_tm.t32",
        "pteff00.prm",
        "ptbase2.t32",
        "pteff04.t32",
        "ptloop01.rat",
        "ptloop02.rat",
        "pteff02.prm",
        "ptlogo_back2eff1.t32",
        "ptlogo_back2eff2.t32",
        "ptlogo_back2eff3.t32",
        "ptlogo_back2eff4.t32",
        "ptlogo_back2eff5.t32",
        "ptlogo_back2.t32",
        "ptlogo_back2eff.t32",
        "ptcopyright.t32",
        "ptlogoall_eff.t32",
        "ptlogoall_eff2.t32",
    ];
    const SPLASH: [&str; 7] = [
        "palogo_eff0.prm",
        "palogo_gamearts.t32",
        "palogo_gamearts_eff.t32",
        "palogo_seta.t32",
        "palogo_seta_eff.t32",
        "palogo_anima.t32",
        "palogo_anima_eff.t32",
    ];
    const MENU: [&str; 16] = [
        "pteff00.prm",
        "ptbase.t32",
        "pteff05.t32",
        "ptloop01.rat",
        "ptloop02.rat",
        "pteff02.prm",
        "ptframe1.t32",
        "ptframe2.t32",
        "pteff10.t32",
        "pteff12.t32",
        "ptbtn01.rat",
        "ptbtn02.rat",
        "ptbtn03.rat",
        "ptbtn04.rat",
        "ptbtn05.rat",
        "ptmsg.t32",
    ];
    if names == TITLE {
        return Some((
            "title",
            vec![
                9, 11, 12, 10, 13, 6, 20, 19, 14, 15, 18, 16, 17, 0, 2, 4, 7, 1, 3, 5, 22, 23, 21,
                8,
            ],
        ));
    }
    if names == SPLASH {
        return Some(("splash", vec![0, 2, 4, 6, 1, 3, 5]));
    }
    if names == MENU {
        return Some((
            "main menu",
            vec![1, 3, 4, 2, 5, 8, 9, 6, 7, 15, 10, 11, 12, 13, 14, 0],
        ));
    }
    None
}

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: paint_order_audit <pak>");
    let ar = pak::PakArchive::open(&path).expect("open pak");
    let mut checked = 0;
    let entries: Vec<_> = ar.entries().to_vec();
    for (i, e) in entries.iter().enumerate() {
        let Ok(bytes) = ar.read(e) else { continue };
        let Some(build) = ui_layout::parse_build(&bytes) else {
            continue;
        };
        let names: Vec<&str> = build.elements.iter().map(|e| e.name.as_str()).collect();
        // Every build: how exposed is it to tie-breaking? A tie between
        // OVERLAPPING elements is where a derived order can go visibly wrong.
        let keys_all: Vec<u32> = build
            .elements
            .iter()
            .map(|e| ui_layout::sprite_layer_key(&build, &bytes, e).unwrap_or(u32::MAX))
            .collect();
        let mut tie_pairs = 0;
        for a in 0..keys_all.len() {
            for b in (a + 1)..keys_all.len() {
                if keys_all[a] == keys_all[b] && keys_all[a] != u32::MAX {
                    tie_pairs += 1;
                }
            }
        }
        // Of the tied pairs, how many OVERLAP? Only those can paint visibly
        // differently under an arbitrary tie-break. Rect from the declared
        // pivot (= half the sprite for a .t32) at the resting placement.
        let rect = |e: &ui_layout::Element| -> Option<(i32, i32, i32, i32)> {
            let kf = e.rest()?;
            let (w, h) = ((e.pivot_x * 2) as i32, (e.pivot_y * 2) as i32);
            if w == 0 || h == 0 {
                return None;
            }
            Some((kf.x, kf.y, w, h))
        };
        let mut tie_overlap = 0;
        for a in 0..keys_all.len() {
            for b in (a + 1)..keys_all.len() {
                if keys_all[a] != keys_all[b] || keys_all[a] == u32::MAX {
                    continue;
                }
                let (Some(ra), Some(rb)) = (rect(&build.elements[a]), rect(&build.elements[b]))
                else {
                    continue;
                };
                let ox = (ra.0 + ra.2).min(rb.0 + rb.2) - ra.0.max(rb.0);
                let oy = (ra.1 + ra.3).min(rb.1 + rb.3) - ra.1.max(rb.1);
                if ox > 0 && oy > 0 {
                    tie_overlap += 1;
                }
            }
        }
        let Some((label, want)) = measured(&names) else {
            println!(
                "entry {i:2}  (no measured order)  {} elements, {tie_pairs} tied pairs, \
{tie_overlap} of them OVERLAPPING",
                build.elements.len()
            );
            // Name them: these are the only pairs whose order can show.
            for a in 0..keys_all.len() {
                for b in (a + 1)..keys_all.len() {
                    if keys_all[a] != keys_all[b] || keys_all[a] == u32::MAX {
                        continue;
                    }
                    let (Some(ra), Some(rb)) = (rect(&build.elements[a]), rect(&build.elements[b]))
                    else {
                        continue;
                    };
                    let ox = (ra.0 + ra.2).min(rb.0 + rb.2) - ra.0.max(rb.0);
                    let oy = (ra.1 + ra.3).min(rb.1 + rb.3) - ra.1.max(rb.1);
                    if ox > 0 && oy > 0 {
                        println!("      overlapping tie: [{a}] {} x [{b}] {}  key {}  rect {:?} / {:?}  overlap {}x{}",
                            build.elements[a].name, build.elements[b].name, keys_all[a], ra, rb, ox, oy);
                    }
                }
            }
            continue;
        };
        checked += 1;
        let got = ui_layout::derived_paint_order(&build, &bytes);
        let keys: Vec<u32> = build
            .elements
            .iter()
            .map(|e| ui_layout::sprite_layer_key(&build, &bytes, e).unwrap_or(u32::MAX))
            .collect();
        let exact = got == want;
        // How many adjacent pairs in the MEASURED order does derived get wrong,
        // and of those, how many are between elements sharing a layer key (a
        // tie the sort cannot resolve) versus a genuine key-order conflict?
        let pos_got: Vec<usize> = {
            let mut p = vec![0; got.len()];
            for (r, &e) in got.iter().enumerate() {
                p[e] = r;
            }
            p
        };
        let (mut inv, mut tied) = (0, 0);
        for a in 0..want.len() {
            for b in (a + 1)..want.len() {
                let (x, y) = (want[a], want[b]);
                if pos_got[x] > pos_got[y] {
                    inv += 1;
                    if keys[x] == keys[y] {
                        tied += 1;
                    }
                }
            }
        }
        println!("entry {i:2}  {label:10}  {} elements", want.len());
        println!(
            "   derived == measured : {}",
            if exact { "YES" } else { "NO" }
        );
        println!("   inverted pairs      : {inv}  (of which same-layer-key ties: {tied})");
        if !exact {
            println!("   measured: {want:?}");
            println!("   derived : {got:?}");
            println!("   keys    : {keys:?}");
        }
    }
    println!("\n{checked} build(s) with a measured order were checked");
}