benilla-octo/crates/benilla-formats/examples/liquid_scan.rs

//! `cargo run -p benilla-formats --example liquid_scan -- [map]` — pick ADT tiles by the liquid
//! property a test needs, instead of by the tile a test used to name.
//!
//! The realm reships most of `World\Maps\` (its `Azeroth_33_33.adt` is 1947378 bytes against
//! 1.12's 1911729), so a test that picked a tile as an *example* of a property — a river mouth
//! with two stacked MCLQ blocks, ocean whose depth bytes span the ramp rather than pinning at 255,
//! lava that must tile across a chunk seam — can lose its example without losing the property.
//! This walks a whole map and reports which tiles still have each, so a re-recorded test names a
//! tile that was chosen rather than inherited.
//!
//! Raw `benilla_adt` only: the kind is the majority non-dry nibble over drawn cells, which is what
//! `liquid::build_liquid_mesh` does, and its mesh is not needed to find candidates.
use std::collections::BTreeMap;

use anyhow::Result;
use benilla_adt::{parse_adt, MclqChunk, McnkChunk, ParsedAdt};

const GRID: usize = 9;
const CELLS: usize = 8;
const DRY_NIBBLE: u8 = 0x0f;

/// 0 Still, 1 Ocean, 2 Magma, as `LiquidKind::from_adt_nibble` reads it; `None` when nothing draws.
fn block_class(lq: &MclqChunk) -> Option<u8> {
    if lq.vertices.len() < GRID * GRID || lq.tile_flags.len() < CELLS * CELLS {
        return None;
    }
    let mut counts = [0u32; 16];
    let mut drawn = 0;
    for &f in &lq.tile_flags {
        let n = f & 0x0f;
        if n == DRY_NIBBLE {
            continue;
        }
        counts[n as usize] += 1;
        drawn += 1;
    }
    if drawn == 0 {
        return None;
    }
    let nib = counts
        .iter()
        .enumerate()
        .max_by_key(|(_, &c)| c)
        .map(|(n, _)| n as u8)?;
    match nib & 3 {
        0 => Some(0),
        1 => Some(1),
        2 => Some(2),
        _ => None,
    }
}

fn name(c: u8) -> &'static str {
    ["Still", "Ocean", "Magma"][c as usize]
}

/// Which 8×8 cells a block draws.
fn wet(lq: &MclqChunk) -> Vec<bool> {
    lq.tile_flags
        .iter()
        .map(|f| f & 0x0f != DRY_NIBBLE)
        .collect()
}

/// One two-block chunk: its index, the two blocks' classes, and whether they are disjoint.
type Pair = (usize, u8, u8, bool);

struct Tile {
    /// Chunks with two blocks, and the pair's classes.
    pairs: Vec<Pair>,
    /// Depth bytes seen per class.
    mid: BTreeMap<u8, usize>,
    pinned: BTreeMap<u8, usize>,
    classes: BTreeMap<u8, usize>,
    /// Chunks carrying magma, for the seam test.
    magma_chunks: usize,
}

fn scan(root: &[McnkChunk]) -> Tile {
    let mut t = Tile {
        pairs: Vec::new(),
        mid: BTreeMap::new(),
        pinned: BTreeMap::new(),
        classes: BTreeMap::new(),
        magma_chunks: 0,
    };
    for (i, m) in root.iter().enumerate() {
        let classes: Vec<Option<u8>> = m.liquids.iter().map(block_class).collect();
        if classes.contains(&Some(2)) {
            t.magma_chunks += 1;
        }
        for c in classes.iter().flatten() {
            *t.classes.entry(*c).or_default() += 1;
        }
        if m.liquids.len() == 2 {
            if let (Some(a), Some(b)) = (classes[0], classes[1]) {
                // Disjoint is what `liquid_at`'s lowest-wins resolve needs.
                let (wa, wb) = (wet(&m.liquids[0]), wet(&m.liquids[1]));
                let disjoint = wa.iter().zip(&wb).all(|(x, y)| !(*x && *y));
                t.pairs.push((i, a, b, disjoint));
            }
        }
        for (lq, class) in m.liquids.iter().zip(&classes) {
            let Some(c) = class else { continue };
            for v in &lq.vertices {
                let b = v.depth_byte();
                if (42..=200).contains(&b) {
                    *t.mid.entry(*c).or_default() += 1;
                }
                if b == u8::MAX {
                    *t.pinned.entry(*c).or_default() += 1;
                }
            }
        }
    }
    t
}

fn main() -> Result<()> {
    let data = benilla_formats::wow_data().expect("set WOW_DATA");
    let map = std::env::args().nth(1).unwrap_or_else(|| "Azeroth".into());
    let mut chain = benilla_formats::Chain::open(&data)?;

    let mut best_pairs: Vec<(String, usize, Vec<Pair>)> = Vec::new();
    let mut best_ocean: Vec<(String, usize, usize)> = Vec::new();
    let mut best_magma: Vec<(String, usize)> = Vec::new();

    for ty in 0..64u32 {
        for tx in 0..64u32 {
            let path = format!("World\\Maps\\{map}\\{map}_{tx}_{ty}.adt");
            if !chain.contains(&path) {
                continue;
            }
            let Ok(bytes) = chain.read_file(&path) else {
                continue;
            };
            let Ok(ParsedAdt::Root(root)) = parse_adt(&mut std::io::Cursor::new(&bytes[..])) else {
                continue;
            };
            let t = scan(&root.mcnk_chunks);
            let tile = format!("{map}_{tx}_{ty}");
            if !t.pairs.is_empty() {
                best_pairs.push((tile.clone(), t.pairs.len(), t.pairs.clone()));
            }
            if let Some(&mid) = t.mid.get(&1) {
                best_ocean.push((tile.clone(), mid, *t.pinned.get(&1).unwrap_or(&0)));
            }
            if t.magma_chunks > 0 {
                best_magma.push((tile, t.magma_chunks));
            }
        }
    }

    println!(
        "== tiles with a two-block chunk ({} tiles) ==",
        best_pairs.len()
    );
    best_pairs.sort_by_key(|(_, n, _)| std::cmp::Reverse(*n));
    for (tile, n, pairs) in best_pairs.iter().take(12) {
        let kinds: Vec<String> = pairs
            .iter()
            .take(4)
            .map(|(i, a, b, d)| {
                format!(
                    "chunk {i}: {}+{}{}",
                    name(*a),
                    name(*b),
                    if *d { "" } else { " OVERLAP" }
                )
            })
            .collect();
        println!("  {tile}: {n} chunks  {}", kinds.join(", "));
    }

    println!("== ocean tiles by mid-band depth bytes (42..=200) ==");
    best_ocean.sort_by_key(|(_, mid, _)| std::cmp::Reverse(*mid));
    for (tile, mid, pinned) in best_ocean.iter().take(12) {
        println!("  {tile}: mid {mid}, pinned {pinned}");
    }

    println!("== magma tiles by chunk count ==");
    best_magma.sort_by_key(|(_, n)| std::cmp::Reverse(*n));
    for (tile, n) in best_magma.iter().take(12) {
        println!("  {tile}: {n} chunks");
    }
    Ok(())
}