yog_cli/content/pipeline/source/

mod.rs

//! The Rust the build generates for a mod's content (`yog-content.g.rs`).

mod blocks;
mod register;
mod script;

pub(in crate::content) use script::ys_source;

pub(in crate::content) use register::included;

use yog_ids::code_set;

use crate::content::formats::defs::Defs;
use crate::content::formats::recipe::registration::Recipe;
use crate::content::pipeline::entry::{BlockProps, Entry};
use crate::content::pipeline::files::{BodyFile, BookFile, EntityFile, FontFile};
use crate::content::pipeline::outputs::write_tags;
use crate::content::{Compiled, GENERATED_FILE, GENERATED_SCRIPT, formats::table};
use std::collections::HashMap;
use std::fmt::Write;
use std::path::Path;
use yog_codegen::{Header, Regenerate};
use yog_codegen_rust::Rust;
use yog_ids::Format;

/// [`yog_registry::REGISTRATIONS_FILE`]: what the mod registers at the
/// game's start, each with a hash of what can't change while it runs — a
/// block's properties and states, not its model, name or tags (the game
/// reloads those).
pub(in crate::content) fn registrations(
    entries: &[Entry],
    entities: &[EntityFile],
    dimensions: &[(String, Vec<u8>)],
    defs: &Defs,
) -> String {
    fn hash(text: &str) -> String {
        // FNV-1a: the same on every build of the CLI.
        const OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
        const PRIME: u64 = 0x0100_0000_01b3;
        let h = text
            .bytes()
            .fold(OFFSET, |h, b| (h ^ u64::from(b)).wrapping_mul(PRIME));
        format!("{h:016x}")
    }
    let mut lines = Vec::new();
    for e in entries {
        let what = match e.kind {
            Format::Block => {
                // Its tool tags and level are data (tags), reloaded with the rest.
                let b = BlockProps {
                    tools: Vec::new(),
                    tool_level: None,
                    ..e.block.clone()
                };
                format!("{b:?} {:?} {:?}", e.item, e.requires)
            }
            _ => format!("{:?} {:?}", e.item, e.requires),
        };
        lines.push(format!("{} {} {}", e.kind.noun(), e.id, hash(&what)));
    }
    for e in entities {
        lines.push(format!(
            "{} {} {}",
            yog_ids::kind::ENTITY,
            e.id,
            hash(&format!("{:?}", e.data))
        ));
    }
    for (id, data) in dimensions {
        lines.push(format!(
            "{} {id} {}",
            yog_ids::kind::DIMENSION,
            hash(&format!("{data:?}"))
        ));
    }
    for g in &defs.sound_groups {
        lines.push(format!(
            "{} {} {}",
            yog_ids::kind::SOUND_GROUP,
            g.id,
            hash(&format!("{g:?}"))
        ));
    }
    for m in &defs.tool_materials {
        lines.push(format!(
            "{} {} {}",
            yog_ids::kind::TOOL_MATERIAL,
            m.id,
            hash(&format!("{m:?}"))
        ));
    }
    for m in &defs.armor_materials {
        lines.push(format!(
            "{} {} {}",
            yog_ids::kind::ARMOR_MATERIAL,
            m.id,
            hash(&format!("{m:?}"))
        ));
    }
    lines.sort();
    lines.join("\n") + "\n"
}

/// Whether any `src/**/*.rs` has `content!(` — the include of the generated code.
pub(in crate::content) fn mentions_content_macro(dir: &Path) -> bool {
    let Ok(entries) = std::fs::read_dir(dir) else {
        return false;
    };
    entries.flatten().any(|e| {
        let p = e.path();
        if p.is_dir() {
            mentions_content_macro(&p)
        } else {
            p.extension().is_some_and(|x| x == "rs")
                && std::fs::read_to_string(&p).is_ok_and(|t| t.contains("content!("))
        }
    })
}

/// `ruby_ore`, `ores/ruby` → `ores_ruby`; a Rust keyword gets `r#`.
pub(in crate::content) fn rust_ident(path: &str) -> String {
    let mut s: String = path
        .chars()
        .map(|c| {
            if c.is_ascii_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '_'
            }
        })
        .collect();
    if s.starts_with(|c: char| c.is_ascii_digit()) {
        s.insert(0, '_');
    }
    s
}

pub(in crate::content) fn float(n: f64) -> String {
    let s = format!("{n:?}");
    if s.contains('.') || s.contains('e') {
        s
    } else {
        format!("{s}.0")
    }
}

/// `name`, unique among those `used` so far: `ruby`, then `ruby_2`.
fn unique_ident(used: &mut HashMap<String, usize>, name: String) -> String {
    let n = used.entry(name.clone()).or_insert(0);
    *n += 1;
    if *n > 1 { format!("{name}_{n}") } else { name }
}

/// `pub struct <name>` with a `pub const <PATH>: &str = "<id>"` per id —
/// what a mod's code names its content by. Nothing for no ids.
fn id_consts<'a>(doc: &str, name: &str, ids: impl Iterator<Item = &'a str>) -> String {
    let ids: Vec<&str> = ids.collect();
    if ids.is_empty() {
        return String::new();
    }
    let mut code = format!(
        "\n/// {doc}\n#[allow(dead_code)]\npub struct {name};\n\n#[allow(dead_code, clippy::all)]\nimpl {name} {{\n"
    );
    let mut used: HashMap<String, usize> = HashMap::new();
    for id in ids {
        let ident = unique_ident(
            &mut used,
            rust_ident(yog_ids::split(id).1).to_ascii_uppercase(),
        );
        let _ = writeln!(code, "    pub const {ident}: &'static str = {id:?};");
    }
    code.push_str("}\n");
    code
}

/// What the generated code is made of: every kind of content the build read.
pub(in crate::content) struct Content<'a> {
    pub(crate) entries: &'a [Entry],
    pub(crate) recipes: &'a [Recipe],
    pub(crate) books: &'a [BookFile],
    pub(crate) bodies: &'a [BodyFile],
    pub(crate) entities: &'a [EntityFile],
    pub(crate) fonts: &'a [FontFile],
    pub(crate) defs: &'a Defs,
    pub(crate) textures: &'a std::collections::BTreeSet<String>,
}

impl Content<'_> {
    /// Whether the content registers anything: its code's `register` must run.
    pub(in crate::content) fn registers_anything(&self) -> bool {
        let d = self.defs;
        self.entries.iter().any(|e| e.auto)
            || !self.recipes.is_empty()
            || !self.books.is_empty()
            || !self.bodies.is_empty()
            || !self.entities.is_empty()
            || !self.fonts.is_empty()
            || !d.sound_groups.is_empty()
            || !d.tool_materials.is_empty()
            || !d.armor_materials.is_empty()
            || !d.biome_features.is_empty()
            || !d.dimensions.is_empty()
            || !d.loot_modifiers.is_empty()
            || !d.definitions.is_empty()
    }
}

/// A set of the content's ids the mod's code names its content by: its
/// name (`Entities`), what it holds, its ids — the same in each language
/// the code is generated in.
pub(in crate::content) struct IdSet<'a> {
    pub(in crate::content) name: &'static str,
    pub(in crate::content) doc: String,
    pub(in crate::content) ids: Vec<&'a str>,
}

/// The sets of ids beside the blocks' and items' (whose Rust has their
/// definitions too).
fn id_sets<'a>(c: &'a Content) -> Vec<IdSet<'a>> {
    let mut sets = vec![
        IdSet {
            name: code_set::ENTITIES,
            doc: "The entity types of `content/` (`.yentity`), by id.".into(),
            ids: c.entities.iter().map(|e| e.id.as_str()).collect(),
        },
        IdSet {
            name: code_set::ADVANCEMENTS,
            doc: "The advancements of `content/` (`.ydef` kind `advancement`), by id\n/// (`yog_api::advancements::grant`/`done`).".into(),
            ids: c.defs.advancements.iter().map(String::as_str).collect(),
        },
    ];
    for (model, name, what) in [
        (true, code_set::MODELS, "models (`.ymodel`)"),
        (false, code_set::ANIMS, "animations (`.yanim`)"),
    ] {
        sets.push(IdSet {
            name,
            doc: format!("The {what} of `content/`, by id (`yog_api::body::model`/`clip`)."),
            ids: c
                .bodies
                .iter()
                .filter(|b| b.model == model)
                .map(|b| b.id.as_str())
                .collect(),
        });
    }
    sets.push(IdSet {
        name: code_set::TEXTURES,
        doc: "The textures of `resources/` (`.ytexture`), by id — what the mod's code draws."
            .into(),
        ids: c.textures.iter().map(String::as_str).collect(),
    });
    sets
}

/// Every set of the content's ids, the blocks' and items' first: what the
/// mod's Yog Script names its content by.
pub(in crate::content) fn all_id_sets<'a>(c: &'a Content) -> Vec<IdSet<'a>> {
    let mut sets: Vec<IdSet> = [
        (Format::Block, code_set::BLOCKS, "blocks (`.yblock`)"),
        (Format::Item, code_set::ITEMS, "items (`.yitem`)"),
    ]
    .into_iter()
    .map(|(format, name, what)| IdSet {
        name,
        doc: format!("The {what} of `content/`, by id."),
        ids: c
            .entries
            .iter()
            .filter(|e| e.kind == format)
            .map(|e| e.id.as_str())
            .collect(),
    })
    .collect();
    sets.extend(id_sets(c));
    sets
}

/// The content's code, part by part.
pub(in crate::content) fn rust_source(c: &Content) -> Source {
    let mut parts: Vec<(String, String)> = Vec::new();
    let mut part = |name: &str, code: String| {
        if !code.trim().is_empty() {
            parts.push((
                name.to_string(),
                format!("{}{code}", GENERATED_HEADER.comment::<Rust>()),
            ));
        }
    };
    for set in id_sets(c) {
        part(
            &set.name.to_ascii_lowercase(),
            id_consts(&set.doc, set.name, set.ids.into_iter()),
        );
    }
    let idents = blocks::entry_idents(c.entries);
    for (name, code) in blocks::entries_code(c.entries, &idents) {
        part(&name, code);
    }
    part("register", register::register_code(c, &idents));
    part("tables", c.defs.tables.iter().map(table::rust).collect());
    let mut root = GENERATED_HEADER.comment::<Rust>();
    for (name, _) in &parts {
        let _ = writeln!(
            root,
            "include!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/generated/{GENERATED_PARTS_DIR}/{name}.g.rs\"));"
        );
    }
    Source { root, parts }
}

/// Writes `compiled.source` to [`GENERATED_FILE`] (only when it changed);
/// deletes it when the mod has no content files.
pub fn write_source(root: &Path, compiled: &Compiled) -> Result<(), String> {
    write_tags(root, compiled)?;
    let out = root.join(GENERATED_FILE);
    let dir = out.parent().unwrap_or(root);
    let parts_dir = dir.join(GENERATED_PARTS_DIR);
    let Some(source) = &compiled.source else {
        crate::files::remove(&out);
        crate::files::remove(&parts_dir);
        return write_script(root, None);
    };
    std::fs::create_dir_all(&parts_dir).map_err(|e| format!("{}: {e}", parts_dir.display()))?;
    let wanted: Vec<std::path::PathBuf> = source
        .parts
        .iter()
        .map(|(name, _)| parts_dir.join(format!("{name}.g.rs")))
        .collect();
    for ((_, code), file) in source.parts.iter().zip(&wanted) {
        crate::write_if_changed(file, code)?;
    }
    // Parts the content no longer has.
    for entry in std::fs::read_dir(&parts_dir)
        .map_err(|e| format!("{}: {e}", parts_dir.display()))?
        .flatten()
    {
        if !wanted.contains(&entry.path()) {
            crate::files::remove(&entry.path());
        }
    }
    crate::write_if_changed(&out, &source.root)?;
    write_script(root, compiled.script.as_deref())?;
    for (path, bytes) in &compiled.data_files {
        let file = dir.join(path);
        if std::fs::read(&file).ok().as_deref() != Some(bytes.as_slice()) {
            if let Some(parent) = file.parent() {
                std::fs::create_dir_all(parent)
                    .map_err(|e| format!("{}: {e}", parent.display()))?;
            }
            std::fs::write(&file, bytes).map_err(|e| format!("{}: {e}", file.display()))?;
        }
    }
    Ok(())
}

/// Writes the content's Yog Script ([`GENERATED_SCRIPT`]) when it has
/// one (only when it changed), deletes it when it hasn't.
fn write_script(root: &Path, script: Option<&str>) -> Result<(), String> {
    let file = root.join(GENERATED_SCRIPT);
    match script {
        Some(code) => crate::write_if_changed(&file, code),
        None => {
            crate::files::remove(&file);
            Ok(())
        }
    }
}

/// The generated files' header; `yog_api::content!()` includes them.
const GENERATED_HEADER: Header = Header {
    tool: "`yog build`",
    source: "content/**",
    regenerate: Regenerate::EveryBuild,
};

/// Where the content's code goes besides the root file, under
/// `obj/generated/`: one file a part (`items.g.rs`, `register.g.rs`, …).
pub const GENERATED_PARTS_DIR: &str = "content";

/// The content's code: the root file ([`GENERATED_FILE`]), which only
/// includes the parts, and the parts — (name, code) each.
#[derive(Debug, Clone, Default)]
pub struct Source {
    /// The root file's code.
    pub root: String,
    /// Each part: its file's name and its code.
    pub parts: Vec<(String, String)>,
}

impl Source {
    /// Part `name`'s code (`"items"`).
    #[cfg(test)]
    pub(crate) fn part(&self, name: &str) -> &str {
        self.parts
            .iter()
            .find(|(n, _)| n == name)
            .map_or("", |(_, c)| c.as_str())
    }

    /// Every part's code, for tests that look for a line wherever it is.
    #[cfg(test)]
    pub(crate) fn all(&self) -> String {
        self.parts.iter().map(|(_, c)| c.as_str()).collect()
    }
}