flatland-presentation 0.2.36

//! Validate `sprite_modes` maps against gfx sprite sheets.

use crate::{SpriteCatalog, SpriteModeMap};

/// Mode ids used to validate an entity's `sprite_modes` (PNG sheet and/or baked paperdoll).
pub fn presentation_validation_mode_ids(
    catalog: &SpriteCatalog,
    tile_id: Option<&str>,
    paperdoll_ref: Option<&str>,
) -> Vec<String> {
    if let Some(skin) = paperdoll_ref.filter(|s| !s.is_empty()) {
        let sheet = format!("paperdoll.{skin}");
        let modes = catalog.mode_ids(&sheet);
        if !modes.is_empty() {
            return modes.to_vec();
        }
    }
    if let Some(tid) = tile_id.filter(|s| !s.is_empty()) {
        return crate::presentation_sheet_mode_ids(catalog, tid, paperdoll_ref);
    }
    Vec::new()
}

/// Validate `sprite_modes` values against PNG and/or paperdoll bake mode lists.
pub fn validate_sprite_modes_for_presentation(
    owner_label: &str,
    tile_id: Option<&str>,
    paperdoll_ref: Option<&str>,
    sprite_modes: &SpriteModeMap,
    catalog: &SpriteCatalog,
) -> Vec<String> {
    let mut errors = Vec::new();
    if sprite_modes.is_empty() {
        return errors;
    }
    let sheet_modes = presentation_validation_mode_ids(catalog, tile_id, paperdoll_ref);
    if sheet_modes.is_empty() {
        errors.push(format!(
            "{owner_label}: sprite_modes set but no modes found (tile_id={tile_id:?}, paperdoll_ref={paperdoll_ref:?})"
        ));
        return errors;
    }
    for (key, mode) in sprite_modes {
        if mode_exists_on_sheet(mode, &sheet_modes) {
            continue;
        }
        if npc_sheet_alias(key, &sheet_modes).is_some() {
            continue;
        }
        errors.push(format!(
            "{owner_label}: sprite_modes.{key} = '{mode}' not on presentation sheet (have: {})",
            sheet_modes.join(", ")
        ));
    }
    errors
}

/// Validate that every value in `sprite_modes` exists on the sheet for `tile_id`.
pub fn validate_sprite_mode_maps(
    owner_label: &str,
    tile_id: Option<&str>,
    sprite_modes: &SpriteModeMap,
    catalog: &SpriteCatalog,
) -> Vec<String> {
    let mut errors = Vec::new();
    let Some(tile_id) = tile_id.filter(|s| !s.is_empty()) else {
        if !sprite_modes.is_empty() {
            errors.push(format!(
                "{owner_label}: sprite_modes set but tile_id is missing"
            ));
        }
        return errors;
    };
    if sprite_modes.is_empty() {
        return errors;
    }
    let sheet_modes = catalog.mode_ids(tile_id);
    if sheet_modes.is_empty() {
        errors.push(format!(
            "{owner_label}: tile_id '{tile_id}' not found in sprite catalog or has no modes"
        ));
        return errors;
    }
    for (key, mode) in sprite_modes {
        if !mode_exists_on_sheet(mode, &sheet_modes) {
            errors.push(format!(
                "{owner_label}: sprite_modes.{key} = '{mode}' not on sheet '{tile_id}' (have: {})",
                sheet_modes.join(", ")
            ));
        }
    }
    errors
}

/// True when `mode` is on the sheet, or directional variants like `walk_north` exist for base `walk`.
pub fn mode_exists_on_sheet(mode: &str, sheet_modes: &[String]) -> bool {
    if sheet_modes.iter().any(|m| m == mode) {
        return true;
    }
    let prefix = format!("{mode}_");
    sheet_modes.iter().any(|m| m.starts_with(&prefix))
}

/// Canonical presentation key → first matching sheet mode id (shared with runtime resolve).
pub fn npc_sheet_alias(presentation_key: &str, sheet_modes: &[String]) -> Option<String> {
    let candidates: &[&str] = match presentation_key {
        "pursue" => &["chase", "alert", "run"],
        "running" => &["chase", "run"],
        "walking" => &["walk", "idle"],
        "combat" => &["combat", "attack", "idle"],
        "rest" => &["idle", "sleep", "rest"],
        "work" => &["work", "idle"],
        "patrol" => &["walk", "patrol", "idle"],
        "talking" => &["talk", "idle"],
        "chatting" => &["chat", "talk", "idle"],
        "idle" => &["idle"],
        "telegraph" => &["telegraph", "idle"],
        "harvesting" => &["harvest", "work", "idle"],
        "crafting" => &["craft", "work", "idle"],
        "sprinting" => &["run", "sprint", "chase"],
        _ => &[],
    };
    candidates
        .iter()
        .find(|c| mode_exists_on_sheet(c, sheet_modes))
        .map(|c| c.to_string())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::catalog::load_sprite_catalog;

    #[test]
    fn catches_unknown_mode() {
        let dir = crate::catalog::default_sprites_dir().expect("sprites dir");
        let catalog = load_sprite_catalog(&dir).expect("load");
        let mut map = SpriteModeMap::new();
        map.insert("available".into(), "bogus_mode_xyz".into());
        let errs = validate_sprite_mode_maps("item.test", Some("resource.oak_log"), &map, &catalog);
        assert_eq!(errs.len(), 1);
        assert!(errs[0].contains("bogus_mode_xyz"));
    }

    #[test]
    fn accepts_directional_prefix_for_base_mode() {
        let sheet_modes = vec!["idle_north".into(), "walk_south".into(), "combat".into()];
        assert!(mode_exists_on_sheet("idle", &sheet_modes));
        assert!(mode_exists_on_sheet("walk", &sheet_modes));
        assert!(mode_exists_on_sheet("combat", &sheet_modes));
        assert!(!mode_exists_on_sheet("run", &sheet_modes));
    }
}