kiln/src/map_file.rs

use std::collections::HashMap;
use serde::Deserialize;
use eframe::egui::Color32;
use crate::game::{Archetype, Board, Glyph, ObjectDef, Player, PortalDef};

/// The top-level deserialization type for a `.toml` map file.
///
/// This struct mirrors the TOML file structure exactly and is used only
/// during loading — it is immediately converted into a [`Board`] via
/// [`From<MapFile>`] and then discarded. It is never used at runtime.
///
/// See `maps/start.toml` for a complete example of the file format.
#[derive(Deserialize)]
pub struct MapFile {
    /// The `[map]` section: name, dimensions, player start position.
    pub map: MapHeader,
    /// The `[palette]` section: maps single-character keys to tile definitions.
    /// Each entry defines both the visual ([`Glyph`]) and the [`Archetype`]
    /// for all cells that use that character in the grid.
    pub palette: HashMap<String, PaletteEntry>,
    /// The `[grid]` section: the multi-line string that defines cell layout.
    pub grid: GridData,
    /// Any `[[objects]]` entries. Optional; defaults to empty.
    #[serde(default)]
    pub objects: Vec<ObjectDef>,
    /// Any `[[portals]]` entries. Optional; defaults to empty.
    #[serde(default)]
    pub portals: Vec<PortalDef>,
}

/// The `[map]` header section of a map file.
#[derive(Deserialize)]
pub struct MapHeader {
    /// Human-readable name for this board, e.g. `"Opening Room"`.
    /// Not yet displayed anywhere at runtime.
    #[allow(dead_code)]
    pub name: String,
    /// Width of the board in cells. Must match the length of every row in
    /// `[grid] content`.
    pub width: usize,
    /// Height of the board in cells. Must match the number of rows in
    /// `[grid] content`.
    pub height: usize,
    /// Starting position of the player as `[x, y]` (0-indexed, origin
    /// top-left). This field will become optional once the player is a
    /// scripted object rather than a hardcoded entity.
    pub player_start: [i32; 2],
}

/// One entry in the `[palette]` table.
///
/// Each palette entry is keyed by a single character (e.g. `"#"` or `" "`).
/// That character is used in the `[grid]` content string to place tiles.
/// The entry defines both how the tile looks (`ch`, `fg`, `bg`) and which
/// [`Archetype`] it uses for behavior.
///
/// Note that `ch` (the display character) does not have to match the palette
/// key. The key is just a label for the grid; `ch` is what actually gets
/// rendered. This allows, for example, using `"W"` as the palette key for a
/// wall tile that displays as `#`.
#[derive(Deserialize)]
pub struct PaletteEntry {
    /// The archetype name for this tile, e.g. `"wall"` or `"empty"`.
    /// Parsed via [`Archetype::try_from`]; unknown names produce an
    /// [`Archetype::ErrorBlock`] cell and a logged warning.
    pub archetype: String,
    /// The character displayed in this cell.
    pub ch: char,
    /// Foreground color as an `"#RRGGBB"` hex string.
    pub fg: String,
    /// Background color as an `"#RRGGBB"` hex string.
    pub bg: String,
}

/// The `[grid]` section of a map file.
///
/// `content` is a TOML multi-line string. Each line is one row of the board;
/// each character in a line is looked up in the palette to determine the
/// tile for that cell. TOML automatically strips the newline immediately
/// following the opening `"""`, so no special handling is needed for a
/// leading blank line.
#[derive(Deserialize)]
pub struct GridData {
    /// The raw grid content. Split by [`str::lines`] during loading.
    pub content: String,
}

/// Parses an `"#RRGGBB"` hex color string into a [`Color32`].
/// Returns black on any parse failure.
fn parse_color(hex: &str) -> Color32 {
    let hex = hex.trim_start_matches('#');
    if hex.len() != 6 {
        return Color32::BLACK;
    }
    let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
    let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
    let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
    Color32::from_rgb(r, g, b)
}

/// Converts a parsed map file into a runtime [`Board`].
///
/// The conversion proceeds in two passes:
///
/// 1. **Palette pass** — each entry is parsed into a `(Glyph, Archetype)` pair
///    and stored in a temporary `HashMap` keyed by the palette character.
///    Unknown archetype names produce an [`Archetype::ErrorBlock`] and a
///    logged warning so malformed maps are visible in-game.
///
/// 2. **Grid pass** — `grid.content` is split into lines; each character
///    is looked up in the palette map and pushed directly into `cells`.
///    Unknown characters are silently skipped, so a malformed grid will
///    result in a `cells` vec shorter than `width * height`.
impl From<MapFile> for Board {
    fn from(mf: MapFile) -> Self {
        let w = mf.map.width;
        let h = mf.map.height;

        // Pass 1: build a char → (Glyph, Archetype) lookup from the palette.
        let mut palette: HashMap<char, (Glyph, Archetype)> = HashMap::new();

        for (key, entry) in &mf.palette {
            let key_char = key.chars().next().unwrap_or(' ');
            // Unknown archetype names fall back to ErrorBlock so the error is
            // visible in-game rather than silently producing empty tiles.
            match Archetype::try_from(entry.archetype.as_str()) {
                Ok(archetype) => {
                    let glyph = Glyph { ch: entry.ch, fg: parse_color(&entry.fg), bg: parse_color(&entry.bg) };
                    palette.insert(key_char, (glyph, archetype));
                }
                Err(e) => {
                    // Be sure to log and ignore the default glyph for an unknown archetype
                    eprintln!("{e}");
                    palette.insert(key_char, (Archetype::ErrorBlock.default_glyph(), Archetype::ErrorBlock));
                }
            }
        }

        // Pass 2: walk the grid string and build cells.
        let mut cells: Vec<(Glyph, Archetype)> = Vec::with_capacity(w * h);
        for line in mf.grid.content.lines() {
            for ch in line.chars() {
                if let Some(&cell) = palette.get(&ch) {
                    cells.push(cell);
                }
            }
        }

        Board {
            width: w,
            height: h,
            cells,
            player: Player {
                x: mf.map.player_start[0],
                y: mf.map.player_start[1],
            },
            objects: mf.objects,
            portals: mf.portals,
        }
    }
}

/// Loads a map file from disk and returns a ready-to-use [`Board`].
///
/// Reads the file at `path`, deserializes it as TOML into a [`MapFile`],
/// then converts it via [`From<MapFile>`]. Propagates both I/O errors and
/// TOML parse errors through the `Box<dyn Error>` return.
///
/// Called from `main()` before the window is created so that board
/// dimensions are available for window sizing.
pub fn load(path: &str) -> Result<Board, Box<dyn std::error::Error>> {
    let content = std::fs::read_to_string(path)?;
    let map_file: MapFile = toml::from_str(&content)?;
    Ok(Board::from(map_file))
}