From c43f4bdb2b649caab9e0eca68c1614e11724f33f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 07:35:16 +0100 Subject: [PATCH 1/9] Lithostitched's processors as the game's own types; replace the old Lithostitched conversion MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Clean-room implementation from spec-lithostitched.md §3-§5 and spec-ctov.md §4. The game reads Lithostitched's processors as its data writes them (processor/litho.rs): block_swap (only the properties the new block can have: ripe wheat becomes ripe carrots, beetroot keeps its default age), reference, apply_random, condition (with else, one processor or a list), set_block (simple and weighted providers, preserve_state, block entity modifier) and discard_input; the conditions all_of, any_of, not, random_chance, true and matching_blocks (input or location, properties). Their random follows random_mode per block or per piece; Lithostitched's own seeding is open (OPEN-L6), so a positional random of the world seed and the processor stands in (impl-questions IQ-7). horizon-port-pack's new lithostitched module carries the processors as they are, with the processors nested in them carried, drops those the game cannot read (lists named by tag, other providers) as Java processors, turns CTOV's modular_compat into a reference when its mod is ported along (else nothing), maps lithostitched:jigsaw to vanilla's jigsaw (vanilla layouts, the decision on OPEN-L5), unwraps limited/guaranteed/delegating elements to their delegate (limits counted as lost until the next PR) and writes add_template_pool_elements modifiers as horizon:add_to pools when their NeoForge load conditions pass. Deleted unread: legacy_structure_mods/lithostitched.rs and horizon-world's structure/processor/lithostitched.rs. Blind edits to the legacy folder, located by exact text or the compiler's error position: its module line removed, dead_code allowed on ctov (its modular compat is unused now) and on a test helper, and ctov's modular compat test ignored. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-port-pack/src/carry.rs | 6 +- .../src/legacy_structure_mods/ctov.rs | 1 + .../legacy_structure_mods/lithostitched.rs | 503 ------------------ .../src/legacy_structure_mods/mod.rs | 3 +- crates/horizon-port-pack/src/lib.rs | 1 + crates/horizon-port-pack/src/lithostitched.rs | 434 +++++++++++++++ crates/horizon-port-pack/src/processors.rs | 11 +- crates/horizon-port-pack/src/worldgen.rs | 31 +- .../src/worldgen/structure/processor.rs | 101 ++-- .../src/worldgen/structure/processor/litho.rs | 470 ++++++++++++++++ .../structure/processor/lithostitched.rs | 434 --------------- docs/modpacks.md | 31 +- 12 files changed, 1006 insertions(+), 1020 deletions(-) delete mode 100644 crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs create mode 100644 crates/horizon-port-pack/src/lithostitched.rs create mode 100644 crates/horizon-world/src/worldgen/structure/processor/litho.rs delete mode 100644 crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index 82dbf11af..a87f92ede 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -828,9 +828,9 @@ pub fn carry( // Additions to other sets and pools, as files the game merges. let modifier = serde_json::from_slice::(&bytes).ok(); let types = &mut report.worldgen_types; - if let Some((kind, mut added)) = modifier.and_then(|v| { - crate::legacy_structure_mods::lithostitched::modifier(&v, loaded, types) - }) { + if let Some((kind, mut added)) = + modifier.and_then(|v| crate::lithostitched::modifier(&v, loaded, types)) + { crate::processors::carry( kind, &mut added, diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs index af46174ae..62c25739f 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs @@ -157,6 +157,7 @@ mod tests { } #[test] + #[ignore = "modular compat is crate::lithostitched's now (its tests)"] fn modular_compat_runs_its_list_only_with_its_mod() { let mut data = ProcessorData::default(); let swap = json!({"processor_type": "minecraft:rule", "rules": []}); diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs b/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs deleted file mode 100644 index 54415a76a..000000000 --- a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs +++ /dev/null @@ -1,503 +0,0 @@ -//! Lithostitched: its jigsaw structure, its worldgen modifiers and its -//! processors. -use super::ctov; -use crate::processors::{ProcessorData, carry_all, processors, referenced}; -use crate::worldgen::{ENHANCED_TERRAIN, Upgrade, start_checks}; -use serde_json::{Value, json}; -use std::collections::BTreeMap; - -/// A `structure` file of Lithostitched's jigsaw type as vanilla's, with the -/// start rules it shares with the other libraries' jigsaws (`worldgen`'s -/// `start_checks`). `None` for any other file. -pub(crate) fn upgrade( - kind: &str, - v: &mut Value, - lost: &mut BTreeMap, -) -> Option { - if kind != "structure" || v["type"] != "lithostitched:jigsaw" { - return None; - } - start_checks(v, "lowest", lost, false); - if v.as_object_mut() - .and_then(|o| o.remove(ENHANCED_TERRAIN)) - .is_some() - { - *lost.entry(ENHANCED_TERRAIN.into()).or_default() += 1; - } - v["type"] = "minecraft:jigsaw".into(); - Some(true) -} - -/// A lithostitched worldgen modifier -/// (`data//lithostitched/worldgen_modifier/`) that adds to structure -/// sets or template pools, as a file the game merges into them (the key -/// `horizon:add_to`, `horizon_client::mod_content`): (kind, file). The -/// modifier's conditions are checked against `loaded`, the mods ported -/// along: a compat addition for a mod that is not would place that mod's -/// blocks, which the game does not have. Other modifier types are left out. -/// Both are counted in `report`. -pub(crate) fn modifier( - v: &Value, - loaded: &dyn Fn(&str) -> bool, - report: &mut Upgrade, -) -> Option<(&'static str, Value)> { - let t = v["type"].as_str().unwrap_or_default(); - let mut left = |why: &str| *report.modifiers_left.entry(why.to_owned()).or_default() += 1; - let (kind, targets, from, to) = match t { - "lithostitched:add_structure_set_entries" => { - ("structure_set", "structure_sets", "entries", "structures") - } - "lithostitched:add_template_pool_elements" => { - ("template_pool", "template_pools", "elements", "elements") - } - _ => { - left(t); - return None; - } - }; - if !conditions_hold(v, loaded) { - left("conditions"); - return None; - } - let targets: Option> = match &v[targets] { - Value::String(s) => Some(vec![s.as_str()]), - Value::Array(a) => a.iter().map(Value::as_str).collect(), - _ => None, - }; - let Some(targets) = targets.filter(|t| !t.is_empty() && t.iter().all(|t| !t.starts_with('#'))) - else { - left("target"); - return None; - }; - let entries = v[from].as_array().cloned().unwrap_or_default(); - for target in &targets { - *report.added_to.entry((*target).to_owned()).or_default() += entries.len(); - } - Some(( - kind, - serde_json::json!({"horizon:add_to": targets, to: entries}), - )) -} - -/// Whether a modifier's load conditions hold: lithostitched's `predicate`, -/// and the loader's conditions (NeoForge's, else Fabric's). A condition -/// type not known here does not hold. -fn conditions_hold(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let all = |list: &Value, test: &dyn Fn(&Value) -> bool| { - list.as_array().is_some_and(|a| a.iter().all(test)) - }; - fn predicate(p: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| predicate(q, loaded); - let list = &p["predicates"]; - match p["type"] - .as_str() - .map(|t| t.trim_start_matches("lithostitched:")) - { - Some("true") => true, - Some("mod_loaded") => p["mod_id"].as_str().is_some_and(loaded), - Some("not") => !predicate(&p["predicate"], loaded), - Some("all_of") => list.as_array().is_some_and(|a| a.iter().all(test)), - Some("any_of") => list.as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn neoforge(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| neoforge(q, loaded); - match c["type"].as_str() { - Some("neoforge:true") => true, - Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), - Some("neoforge:not") => !neoforge(&c["value"], loaded), - Some("neoforge:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("neoforge:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn fabric(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| fabric(q, loaded); - let mods = || { - c["values"] - .as_array() - .into_iter() - .flatten() - .map(Value::as_str) - }; - match c["condition"].as_str() { - Some("fabric:true") => true, - Some("fabric:all_mods_loaded") => mods().all(|m| m.is_some_and(loaded)), - Some("fabric:any_mods_loaded") => mods().any(|m| m.is_some_and(loaded)), - Some("fabric:not") => !fabric(&c["value"], loaded), - Some("fabric:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("fabric:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - let litho = v.get("predicate").is_none_or(|p| predicate(p, loaded)); - let loader = match ( - v.get("neoforge:conditions"), - v.get("fabric:load_conditions"), - ) { - (Some(c), _) => all(c, &|c| neoforge(c, loaded)), - // One condition or a list of them. - (None, Some(c)) if c.is_array() => all(c, &|c| fabric(c, loaded)), - (None, Some(c)) => fabric(c, loaded), - (None, None) => true, - }; - litho && loader -} - -/// The data form of one of Lithostitched's processors: the processors to put -/// in its place, or `None` when it has none (or is not Lithostitched's). -pub(crate) fn processor( - kind: &str, - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option> { - match kind { - "lithostitched:apply_random" => apply_random(p, data, carried).map(|p| vec![p]), - "lithostitched:condition" => condition(p, data, carried).map(|p| vec![p]), - "lithostitched:block_swap" => { - // The same map; the game's swap keeps the properties both have. - p["blocks"].as_object()?; - Some(vec![ - json!({"processor_type": "horizon:block_swap", "blocks": p["blocks"]}), - ]) - } - "lithostitched:set_block" => { - // A simple or weighted state provider, the block entity left as - // it is. - let provider = p["state_provider"]["type"].as_str()?; - let modifier = p["block_entity_modifier"]["type"].as_str(); - let plain = - modifier.is_none_or(|m| m.trim_start_matches("minecraft:") == "passthrough"); - if !plain - || !matches!( - provider, - "minecraft:simple_state_provider" | "minecraft:weighted_state_provider" - ) - { - return None; - } - let mut out = p.clone(); - out["processor_type"] = "horizon:set_block".into(); - if let Some(o) = out.as_object_mut() { - o.remove("block_entity_modifier"); - } - Some(vec![out]) - } - _ => None, - } -} - -/// The references (Lithostitched's, and CTOV's compat processors) in a -/// processor list written in; whether any was. -pub(crate) fn expand_references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> (Vec, bool) { - references(list, data, carried, 0) -} - -/// A processor list inside a carried processor: an id stays (the game reads -/// that file, carried on its own); an inline one is carried here. -fn nested(list: &Value, data: &ProcessorData, carried: &mut BTreeMap) -> Value { - let mut list = list.clone(); - if let Some(ps) = processors(&mut list) { - *ps = carry_all(std::mem::take(ps), data, carried).0; - } - list -} - -/// Lithostitched's `apply_random` as `horizon:apply_random`: its weighted -/// lists, or its set of lists at weight 1. A tag is not carried. -fn apply_random( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - let lists = &p["processor_lists"]; - let weighted = lists.as_array().is_some_and(|a| { - a.iter() - .all(|e| e.get("weight").is_some() && e.get("data").is_some()) - }); - let entries: Vec<(Value, Value)> = if weighted { - lists - .as_array()? - .iter() - .map(|e| (e["weight"].clone(), e["data"].clone())) - .collect() - } else { - match lists { - Value::String(id) if !id.starts_with('#') => vec![(1.into(), lists.clone())], - Value::Array(a) if a.iter().any(|x| x.get("processor_type").is_some()) => { - vec![(1.into(), lists.clone())] - } - Value::Array(a) - if a.iter() - .all(|x| x.as_str().is_some_and(|s| !s.starts_with('#')) || x.is_object()) => - { - a.iter().map(|x| (1.into(), x.clone())).collect() - } - Value::Object(_) => vec![(1.into(), lists.clone())], - _ => return None, - } - }; - let lists: Vec = entries - .into_iter() - .map(|(weight, list)| json!({"weight": weight, "data": nested(&list, data, carried)})) - .collect(); - let mut out = json!({"processor_type": "horizon:apply_random", "processor_lists": lists}); - if let Some(mode) = p.get("mode") { - out["mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's `condition` as `horizon:condition`, when the game runs -/// every condition in it (true, all_of, any_of, not, random_chance, -/// matching_blocks with plain property values); else it stays Java. -fn condition( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - fn runs(c: &Value) -> bool { - if let Some(all) = c.as_array() { - return all.iter().all(runs); - } - let kind = c["type"].as_str().unwrap_or_default(); - match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" | "random_chance" => true, - "all_of" | "any_of" => c["conditions"] - .as_array() - .is_some_and(|a| a.iter().all(runs)), - "not" => runs(&c["condition"]), - "matching_blocks" => c.get("properties").is_none_or(|p| { - p.as_object() - .is_some_and(|o| o.values().all(Value::is_string)) - }), - _ => false, - } - } - if !runs(&p["if_true"]) { - return None; - } - // One processor or a list of them. - let mut branch = |key: &str| -> Value { - let list = match p.get(key) { - None => Vec::new(), - Some(Value::Array(a)) => a.clone(), - Some(one) => vec![one.clone()], - }; - carry_all(list, data, carried).0.into() - }; - let (then, otherwise) = (branch("then"), branch("else")); - let mut out = json!({"processor_type": "horizon:condition", "if_true": p["if_true"], - "then": then, "else": otherwise}); - if let Some(mode) = p.get("random_mode") { - out["random_mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's references in a list, each replaced by the processors of -/// the lists it names, in order (references in them too, to a depth of 8). -/// One naming a tag or a list the mod does not have stays, to be dropped. -/// Whether any was replaced. -fn references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, - depth: usize, -) -> (Vec, bool) { - let mut out = Vec::with_capacity(list.len()); - let mut changed = false; - for p in list { - if let Some(inner) = ctov::modular_compat(&p, data, carried, depth) { - changed = true; - out.extend(references(inner, data, carried, depth + 1).0); - continue; - } - let named = (p["processor_type"] == "lithostitched:reference" && depth < 8) - .then(|| referenced(&p["processor_lists"], data)) - .flatten(); - match named { - Some(inner) => { - *carried.entry("lithostitched:reference".into()).or_default() += 1; - out.extend(references(inner, data, carried, depth + 1).0); - changed = true; - } - None => out.push(p), - } - } - (out, changed) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::legacy_structure_mods::data; - use crate::processors::carry; - - #[test] - fn modifiers_add_to_sets_and_pools() { - let mut report = Upgrade::default(); - let only_fd = |m: &str| m == "farmersdelight"; - let set = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "minecraft:villages", - "entries": [{"structure": "x:village", "weight": 4}]}); - let (kind, added) = modifier(&set, &only_fd, &mut report).unwrap(); - assert_eq!(kind, "structure_set"); - assert_eq!( - added, - json!({"horizon:add_to": ["minecraft:villages"], - "structures": [{"structure": "x:village", "weight": 4}]}) - ); - // A compat addition holds only when its mod is ported along. - let pool = |modid: &str| { - json!({"type": "lithostitched:add_template_pool_elements", - "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}], - "fabric:load_conditions": {"condition": "fabric:all_mods_loaded", "values": ["other"]}, - "template_pools": ["x:houses", "y:houses"], - "elements": [{"weight": 5, "element": {"element_type": "minecraft:single_pool_element", - "location": "x:fd_farm", "projection": "rigid", "processors": "minecraft:empty"}}]}) - }; - let (kind, added) = modifier(&pool("farmersdelight"), &only_fd, &mut report).unwrap(); - assert_eq!(kind, "template_pool"); - assert_eq!(added["horizon:add_to"], json!(["x:houses", "y:houses"])); - assert_eq!(added["elements"][0]["weight"], 5); - assert!(modifier(&pool("create"), &only_fd, &mut report).is_none()); - // Fabric's conditions when there are no NeoForge ones; lithostitched's own. - let fabric = json!({"type": "lithostitched:add_structure_set_entries", - "fabric:load_conditions": [{"condition": "fabric:not", - "value": {"condition": "fabric:any_mods_loaded", "values": ["create"]}}], - "predicate": {"type": "lithostitched:all_of", "predicates": [ - {"type": "lithostitched:mod_loaded", "mod_id": "farmersdelight"}, - {"type": "lithostitched:true"}]}, - "structure_sets": "minecraft:villages", "entries": []}); - assert!(modifier(&fabric, &only_fd, &mut report).is_some()); - let tagged = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "#x:sets", "entries": []}); - assert!(modifier(&tagged, &only_fd, &mut report).is_none()); - let features = json!({"type": "lithostitched:add_features"}); - assert!(modifier(&features, &only_fd, &mut report).is_none()); - assert_eq!( - report.added_to, - BTreeMap::from([ - ("minecraft:villages".into(), 1), - ("x:houses".into(), 1), - ("y:houses".into(), 1), - ]) - ); - assert_eq!( - report.modifiers_left, - BTreeMap::from([ - ("conditions".into(), 1), - ("lithostitched:add_features".into(), 1), - ("target".into(), 1), - ]) - ); - } - - #[test] - fn lithostitched_block_swaps_become_the_games() { - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}, - {"processor_type": "lithostitched:block_swap", "blocks": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data(), &mut carried)); - let p = list["processors"].as_array().unwrap(); - assert_eq!( - p[0], - json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}) - ); - // A map that is not one stays Java (dropped later). - assert_eq!(p[1]["processor_type"], "lithostitched:block_swap"); - } - - #[test] - fn lithostitched_references_are_written_in() { - let mut data = data(); - let gravity = json!({"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": 0}); - data.lists - .insert("v:road".into(), json!({"processors": [gravity.clone()]})); - data.lists.insert( - "v:house".into(), - json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:road"}, - {"processor_type": "lithostitched:block_swap", "blocks": {"minecraft:dirt": "minecraft:grass_block"}}]}), - ); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": ["v:house", "v:road"]}, - {"processor_type": "lithostitched:reference", "processor_lists": "#v:roads"}, - {"processor_type": "lithostitched:reference", "processor_lists": ["v:nowhere"]}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - // House (its own reference to road first, then its swap), then road; - // the swap inside is carried too. - assert_eq!(p[0], gravity); - assert_eq!(p[1]["processor_type"], "horizon:block_swap"); - assert_eq!(p[2], gravity); - // A tag or a list the mod lacks stays, to be dropped. - assert_eq!(p[3]["processor_lists"], "#v:roads"); - assert_eq!(p[4]["processor_lists"], json!(["v:nowhere"])); - assert_eq!(carried["lithostitched:reference"], 2); - } - - #[test] - fn lithostitched_random_and_condition_become_the_games() { - let mut data = data(); - let swap = json!({"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - data.lists - .insert("v:green".into(), json!({"processors": [swap.clone()]})); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:green"}, - {"processor_type": "v:java"}]}}]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": ["v:green", "v:red"]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": "#v:colours"}, - {"processor_type": "lithostitched:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": swap, "else": {"processor_type": "lithostitched:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}}, - {"processor_type": "lithostitched:condition", - "if_true": {"type": "lithostitched:matching_biomes", "biomes": "#c:is_cold"}, - "then": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - let green = json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - // Inline lists are carried; Java left in them is dropped later. - assert_eq!( - p[0], - json!({"processor_type": "horizon:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [green.clone(), {"processor_type": "v:java"}]}}]}) - ); - assert_eq!( - p[1]["processor_lists"], - json!([{"weight": 1, "data": "v:green"}, {"weight": 1, "data": "v:red"}]) - ); - assert_eq!(p[2]["processor_type"], "lithostitched:apply_random"); - assert_eq!( - p[3], - json!({"processor_type": "horizon:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": [green], "else": [{"processor_type": "horizon:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}]}) - ); - assert_eq!(p[4]["processor_type"], "lithostitched:condition"); - assert_eq!(carried["lithostitched:apply_random"], 2); - assert_eq!(carried["lithostitched:condition"], 1); - } -} diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs index 1faa1b39f..980798720 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs @@ -13,10 +13,11 @@ //! The general code reaches them only through the `pub(crate)` entry points //! of these three modules. Nothing in them is used by another mod's //! conversion. +#[allow(dead_code)] // its modular compat is `crate::lithostitched`'s now; the rest goes with C1 pub(crate) mod ctov; -pub(crate) mod lithostitched; #[cfg(test)] +#[allow(dead_code)] // the old Lithostitched tests used it fn data() -> crate::processors::ProcessorData { let mut d = crate::processors::ProcessorData::default(); d.spawners.insert( diff --git a/crates/horizon-port-pack/src/lib.rs b/crates/horizon-port-pack/src/lib.rs index 3b17f1c9c..b47c93754 100644 --- a/crates/horizon-port-pack/src/lib.rs +++ b/crates/horizon-port-pack/src/lib.rs @@ -14,6 +14,7 @@ pub mod import; pub mod inventory; pub mod jar; pub(crate) mod legacy_structure_mods; +mod lithostitched; pub mod modrinth; pub mod oracle; pub mod pipeline; diff --git a/crates/horizon-port-pack/src/lithostitched.rs b/crates/horizon-port-pack/src/lithostitched.rs new file mode 100644 index 000000000..e65efcf0e --- /dev/null +++ b/crates/horizon-port-pack/src/lithostitched.rs @@ -0,0 +1,434 @@ +//! Lithostitched's worldgen, carried as the game reads it (clean room: +//! `cleanroom/structures/spec-lithostitched.md`; CTOV's processor: +//! `spec-ctov.md` §4). +//! +//! - `lithostitched:jigsaw` structures become vanilla's jigsaw. Lithostitched +//! lays jigsaws out its own way (OPEN-L5): Horizon keeps vanilla's layouts. +//! - Its processors (`block_swap`, `reference`, `apply_random`, `condition`, +//! `set_block`, `discard_input`) are the game's own types +//! (`horizon_world`'s `structure::processor`): they are carried as written, +//! the processors nested in them carried in turn. CTOV's +//! `ctov:modular_compat` (a reference that runs only when its mod is loaded) +//! becomes a `reference` when the mod is ported along, else nothing. +//! - `add_template_pool_elements` modifiers become `horizon:add_to` pool files +//! (`docs/mods.md`), when their load conditions pass. Lithostitched's own +//! pool elements (`limited`, `guaranteed`, `delegating`) place their +//! `delegate`; what they add to it is counted as lost. +use crate::{processors::ProcessorData, worldgen::Upgrade}; +use serde_json::{Value, json}; +use std::collections::BTreeMap; + +const JIGSAW: &str = "lithostitched:jigsaw"; +/// Vanilla's JigsawStructure.MAX_DEPTH. +const MAX_SIZE: i64 = 20; +const MODULAR_COMPAT: &str = "ctov:modular_compat"; +/// The processor types the game reads. +const PROCESSORS: [&str; 6] = [ + "lithostitched:block_swap", + "lithostitched:reference", + "lithostitched:apply_random", + "lithostitched:condition", + "lithostitched:set_block", + "lithostitched:discard_input", +]; + +fn count(map: &mut BTreeMap, name: &str) { + *map.entry(name.to_owned()).or_default() += 1; +} + +/// A `lithostitched:jigsaw` structure as vanilla's jigsaw: `Some(true)`, else +/// `None`. +pub(crate) fn upgrade( + kind: &str, + v: &mut Value, + lost: &mut BTreeMap, +) -> Option { + if kind != "structure" || v["type"] != JIGSAW { + return None; + } + v["type"] = "minecraft:jigsaw".into(); + // `size` may be an int provider (sampled per start): its largest value. + let size = match &v["size"] { + Value::Null => None, + Value::Number(n) => n.as_i64(), + provider => { + count(lost, "lithostitched:jigsaw size provider"); + ["max_inclusive", "value"] + .iter() + .find_map(|k| provider[k].as_i64()) + } + }; + if let Some(size) = size { + if size > MAX_SIZE { + count(lost, "lithostitched:jigsaw size over 20"); + } + v["size"] = size.clamp(0, MAX_SIZE).into(); + } + let o = v.as_object_mut()?; + match o.remove("start_projection") { + Some(Value::String(heightmap)) if heightmap != "floor" && heightmap != "ceiling" => { + o.entry("project_start_to_heightmap") + .or_insert(heightmap.into()); + } + Some(_) => count(lost, "lithostitched:jigsaw start_projection"), + None => {} + } + if o.remove("fixed_rotation").is_some_and(|f| f == true) { + count(lost, "lithostitched:jigsaw fixed_rotation"); + } + Some(true) +} + +/// Lithostitched's pool elements as the element they wrap; whether `element` +/// was one. +pub(crate) fn upgrade_pool_element( + element: &mut Value, + lost: &mut BTreeMap, +) -> bool { + let Some(kind) = element["element_type"].as_str() else { + return false; + }; + match kind { + "lithostitched:limited" | "lithostitched:guaranteed" | "lithostitched:delegating" => { + count(lost, kind); + let delegate = element["delegate"].take(); + *element = delegate; + // A delegate wrapping another (only `delegating` allows it). + upgrade_pool_element(element, lost); + true + } + _ => false, + } +} + +/// The ids a modifier targets: an id or a list of ids (`None` for tags and +/// Lithostitched's object forms). +fn ids(v: &Value) -> Option> { + let id = |v: &Value| { + v.as_str() + .filter(|s| !s.starts_with('#')) + .map(str::to_owned) + }; + match v { + Value::Array(a) => a.iter().map(id).collect(), + other => Some(vec![id(other)?]), + } +} + +/// NeoForge's load conditions (`neoforge:conditions`): all must pass. +fn conditions_pass(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + fn pass(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + let all = |key: &str| { + c[key] + .as_array() + .into_iter() + .flatten() + .all(|c| pass(c, loaded)) + }; + match c["type"].as_str() { + Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), + Some("neoforge:true") => true, + Some("neoforge:not") => !pass(&c["value"], loaded), + Some("neoforge:and") => all("values"), + Some("neoforge:or") => { + (c["values"].as_array().into_iter().flatten()).any(|c| pass(c, loaded)) + } + _ => false, + } + } + (v["neoforge:conditions"].as_array().into_iter().flatten()).all(|c| pass(c, loaded)) +} + +/// A worldgen modifier as a file the game merges: `("template_pool", file)` +/// for `add_template_pool_elements`; the others are counted in +/// `report.modifiers_left`. +pub(crate) fn modifier( + v: &Value, + loaded: &dyn Fn(&str) -> bool, + report: &mut Upgrade, +) -> Option<(&'static str, Value)> { + let kind = v["type"].as_str().unwrap_or("no type"); + if !conditions_pass(v, loaded) { + count(&mut report.modifiers_left, "conditions"); + return None; + } + if kind != "lithostitched:add_template_pool_elements" { + count(&mut report.modifiers_left, kind); + return None; + } + let (Some(targets), Some(elements)) = (ids(&v["template_pools"]), v["elements"].as_array()) + else { + count(&mut report.modifiers_left, "target"); + return None; + }; + for target in &targets { + *report.added_to.entry(target.clone()).or_default() += elements.len(); + } + Some(( + "template_pool", + json!({"horizon:add_to": targets, "elements": elements}), + )) +} + +/// Whether the game reads a Lithostitched processor as it is: one of its +/// types, with no processor list named by tag (the game has no processor +/// list tags) and a state provider it runs. +pub(crate) fn game_reads(p: &Value) -> bool { + let Some(kind) = p["processor_type"] + .as_str() + .filter(|t| PROCESSORS.contains(t)) + else { + return false; + }; + let tag = |v: &Value| v.as_str().is_some_and(|s| s.starts_with('#')); + match kind { + "lithostitched:reference" => match &p["processor_lists"] { + Value::Array(a) => !a.iter().any(tag), + other => other.is_string() && !tag(other), + }, + "lithostitched:apply_random" => p["processor_lists"] + .as_array() + .is_some_and(|a| a.iter().all(|e| !tag(e) && !tag(&e["data"]))), + "lithostitched:set_block" => matches!( + p["state_provider"]["type"].as_str(), + Some("minecraft:simple_state_provider" | "minecraft:weighted_state_provider") + ), + "lithostitched:block_swap" => p["blocks"].is_object(), + "lithostitched:condition" => !p["if_true"].is_null(), + _ => true, + } +} + +/// The processor lists inside a Lithostitched processor, for the general +/// code that walks lists (`then`, `else`, `apply_random`'s inline data). +pub(crate) fn inner_lists(p: &mut Value) -> Vec<&mut Value> { + match p["processor_type"].as_str() { + Some("lithostitched:apply_random") => (p["processor_lists"].as_array_mut().into_iter()) + .flatten() + .filter_map(|e| e.get_mut("data").filter(|d| !d.is_string())) + .collect(), + Some("lithostitched:condition") => (p.as_object_mut().into_iter()) + .flat_map(|o| o.iter_mut()) + .filter(|(k, _)| *k == "then" || *k == "else") + .map(|(_, v)| v) + .collect(), + _ => Vec::new(), + } +} + +/// A Lithostitched processor with the processors nested in it carried +/// (`Some`, when one of them changed); `None` for any other processor. +pub(crate) fn processor( + kind: &str, + p: &Value, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> Option> { + if !PROCESSORS.contains(&kind) { + return None; + } + let mut out = p.clone(); + let mut changed = false; + for list in inner_lists(&mut out) { + // One processor alone is a list of one. + if list.get("processor_type").is_some() { + *list = Value::Array(vec![list.take()]); + changed = true; + } + if let Some(processors) = crate::processors::processors(list) { + let (inner, inner_changed) = + crate::processors::carry_all(std::mem::take(processors), data, carried); + *processors = inner; + changed |= inner_changed; + } + } + changed.then(|| vec![out]) +} + +/// The list with CTOV's modular compat processors written as the game's +/// `reference` (its mod is ported along) or taken out; whether any was. +pub(crate) fn expand_references( + list: Vec, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> (Vec, bool) { + let mut changed = false; + let mut out = Vec::with_capacity(list.len()); + for p in list { + if p["processor_type"] != MODULAR_COMPAT { + out.push(p); + continue; + } + changed = true; + count(carried, MODULAR_COMPAT); + let loaded = p["modid"] + .as_str() + .is_some_and(|m| data.compat_loaded.contains(m)); + if loaded { + out.push(json!({"processor_type": "lithostitched:reference", + "processor_lists": p["reference"].clone()})); + } + } + (out, changed) +} + +/// Notes which mods CTOV's modular compat processors name are `loaded`. +pub(crate) fn mark_loaded(data: &mut ProcessorData, loaded: &dyn Fn(&str) -> bool) { + fn visit(v: &Value, out: &mut Vec) { + match v { + Value::Object(o) => { + if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT) + && let Some(m) = o.get("modid").and_then(Value::as_str) + { + out.push(m.to_owned()); + } + o.values().for_each(|v| visit(v, out)); + } + Value::Array(a) => a.iter().for_each(|v| visit(v, out)), + _ => {} + } + } + let mut named = Vec::new(); + data.lists.values().for_each(|l| visit(l, &mut named)); + data.compat_loaded + .extend(named.into_iter().filter(|m| loaded(m))); +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::worldgen::upgrade as upgrade_file; + + #[test] + fn jigsaws_become_vanillas() { + let mut lost = BTreeMap::new(); + let mut s = json!({"type": JIGSAW, "size": {"type": "uniform", "min_inclusive": 3, + "max_inclusive": 40}, "start_projection": "WORLD_SURFACE_WG", "fixed_rotation": true}); + assert_eq!(upgrade("structure", &mut s, &mut lost), Some(true)); + assert_eq!( + s, + json!({"type": "minecraft:jigsaw", "size": 20, + "project_start_to_heightmap": "WORLD_SURFACE_WG"}) + ); + assert_eq!(lost.len(), 3); + assert_eq!( + upgrade( + "structure", + &mut json!({"type": "minecraft:jigsaw"}), + &mut lost + ), + None + ); + } + + #[test] + fn wrapped_elements_place_their_delegate() { + let mut lost = BTreeMap::new(); + let delegate = json!({"element_type": "minecraft:single_pool_element", "location": "a:b", + "projection": "rigid", "processors": "minecraft:empty"}); + let mut e = + json!({"element_type": "lithostitched:limited", "limit": 1, "delegate": delegate}); + assert!(upgrade_pool_element(&mut e, &mut lost)); + assert_eq!(e, delegate); + assert_eq!(lost["lithostitched:limited"], 1); + assert!(!upgrade_pool_element(&mut e, &mut lost)); + } + + #[test] + fn modifiers_add_to_pools_when_their_mods_are_loaded() { + let mut report = Upgrade::default(); + let loaded = |m: &str| m == "waystones"; + let add = |modid: &str, pools: Value| { + json!({"type": "lithostitched:add_template_pool_elements", "template_pools": pools, + "elements": [{"weight": 2, "element": {"element_type": "minecraft:empty_pool_element"}}], + "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}]}) + }; + let (kind, file) = modifier( + &add("waystones", json!("ctov:village/plains/house")), + &loaded, + &mut report, + ) + .unwrap(); + assert_eq!(kind, "template_pool"); + assert_eq!(file["horizon:add_to"], json!(["ctov:village/plains/house"])); + assert_eq!(file["elements"][0]["weight"], 2); + assert_eq!(report.added_to["ctov:village/plains/house"], 1); + assert!(modifier(&add("sawmill", json!("a:b")), &loaded, &mut report).is_none()); + assert!(modifier(&add("waystones", json!("#a:pools")), &loaded, &mut report).is_none()); + let aliases = json!({"type": "lithostitched:set_pool_aliases"}); + assert!(modifier(&aliases, &loaded, &mut report).is_none()); + assert_eq!( + report.modifiers_left, + BTreeMap::from([ + ("conditions".into(), 1), + ("lithostitched:set_pool_aliases".into(), 1), + ("target".into(), 1), + ]) + ); + } + + /// A CTOV list (spec-ctov §4): references, a condition with a single + /// processor and a nested condition, a random list holding the compat + /// hook, and processors the game cannot read. + #[test] + fn processors_stay_lithostitcheds_with_their_insides_carried() { + let hook = json!({"processor_type": MODULAR_COMPAT, "modid": "natures_spirit", + "reference": "ctov:village/mesa/house_wisteria"}); + let list = json!({"processors": [ + {"processor_type": "lithostitched:reference", "processor_lists": ["ctov:village/mesa/house"]}, + {"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", + "match_type": "location"}, + "then": {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:spruce_planks"}}}, + "else": [{"processor_type": "somemod:java_processor"}]}, + {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ + {"weight": 1, "data": "minecraft:empty"}, + {"weight": 1, "data": {"processors": [hook]}}]}, + {"processor_type": "lithostitched:reference", "processor_lists": "#ctov:palettes"}, + {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:noise_provider"}}]}); + for (loaded, wisteria) in [ + (false, json!([])), + ( + true, + json!([{"processor_type": + "lithostitched:reference", "processor_lists": "ctov:village/mesa/house_wisteria"}]), + ), + ] { + let mut data = ProcessorData::default(); + data.lists + .insert("ctov:village/mesa/house".into(), list.clone()); + mark_loaded(&mut data, &|m| loaded && m == "natures_spirit"); + let mut v = list.clone(); + let mut report = Upgrade::default(); + crate::processors::carry( + "processor_list", + &mut v, + &data, + &mut report.processors_carried, + ); + upgrade_file("processor_list", &mut v, &mut report, &BTreeMap::new()); + let p = &v["processors"]; + assert_eq!(p.as_array().unwrap().len(), 3, "{p}"); + assert_eq!(p[0], list["processors"][0]); + // One processor is a list of one; the Java one is taken out. + assert_eq!( + p[1]["then"][0]["state_provider"]["state"]["id"], + "minecraft:spruce_planks" + ); + assert_eq!(p[1]["else"], json!([])); + assert_eq!(p[2]["processor_lists"][0]["data"], "minecraft:empty"); + assert_eq!(p[2]["processor_lists"][1]["data"]["processors"], wisteria); + assert_eq!(report.processors_carried[MODULAR_COMPAT], 1); + assert_eq!( + report.processors_dropped, + BTreeMap::from([ + ("lithostitched:reference".into(), 1), + ("lithostitched:set_block".into(), 1), + ("somemod:java_processor".into(), 1), + ]) + ); + } + } +} diff --git a/crates/horizon-port-pack/src/processors.rs b/crates/horizon-port-pack/src/processors.rs index af1595f92..046eaa0bf 100644 --- a/crates/horizon-port-pack/src/processors.rs +++ b/crates/horizon-port-pack/src/processors.rs @@ -10,13 +10,13 @@ //! - Repurposed Structures' mineshaft sky view becomes the game's //! `horizon:mineshaft_sky_view`. //! -//! The processors of YUNG's mods, Lithostitched and Choice Theorem's Overhauled -//! Village are carried by `legacy_structure_mods`, called from [`carry`]. +//! Lithostitched's processors and Choice Theorem's Overhauled Village's +//! compat hook are carried by `crate::lithostitched`, called from [`carry`]. //! //! What is not here is taken out of its list later and counted //! (`worldgen::upgrade`). The entity NBT is written in 26.3's shape (an //! `equipment` map, not 1.21.1's `HandItems` and `ArmorItems`). -use crate::legacy_structure_mods::{ctov, lithostitched}; +use crate::lithostitched; use serde_json::{Value, json}; use std::{ collections::{BTreeMap, BTreeSet}, @@ -42,7 +42,7 @@ pub struct ProcessorData { impl ProcessorData { /// Notes which mods its compat processors name are `loaded`. pub fn mark_loaded(&mut self, loaded: &dyn Fn(&str) -> bool) { - ctov::mark_loaded(self, loaded); + lithostitched::mark_loaded(self, loaded); } pub fn read(zip: &mut zip::ZipArchive) -> Self { @@ -177,8 +177,7 @@ fn carry_at( let mut out = Vec::with_capacity(expanded.len()); for p in expanded { let kind = p["processor_type"].as_str().unwrap_or_default().to_owned(); - // Lithostitched's processors are carried apart from this code - // (`legacy_structure_mods`). + // Lithostitched's processors stay theirs, with what they hold carried. let replacement = lithostitched::processor(&kind, &p, data, carried).or_else(|| { match pillar_type(&kind) { Some(to) => Some(vec![pillar(&p, to, data, carried, depth)]), diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index 298179acf..0e3d968e3 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -15,10 +15,10 @@ //! closely. //! //! YUNG's API's files are carried as written ([`crate::yung`]). -//! Lithostitched's and CTOV's worldgen files are converted by -//! `legacy_structure_mods`, called from [`upgrade`], [`crate::carry`] and the -//! processors. -use crate::{legacy_structure_mods::lithostitched, yung}; +//! Lithostitched's jigsaws, elements, modifiers and processors are carried by +//! [`crate::lithostitched`]; the entries CTOV adds to vanilla's structure sets +//! by `legacy_structure_mods`, called from [`crate::carry`]. +use crate::{lithostitched, yung}; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet}, @@ -191,28 +191,19 @@ fn drop_java_processors(list: &mut Value, dropped: &mut BTreeMap) let before = processors.len(); processors.retain(|p| { let t = p["processor_type"].as_str().unwrap_or_default(); - let java = !t.starts_with("minecraft:") && !t.starts_with("horizon:"); + let java = !t.starts_with("minecraft:") + && !t.starts_with("horizon:") + && !lithostitched::game_reads(p); if java { *dropped.entry(t.to_owned()).or_default() += 1; } !java }); let mut changed = processors.len() != before; - // The inline lists inside the game's apply_random and condition. + // The inline lists inside Lithostitched's apply_random and condition. for p in processors.iter_mut() { let inner: Vec<&mut Value> = match p["processor_type"].as_str() { - Some("horizon:apply_random") => p["processor_lists"] - .as_array_mut() - .into_iter() - .flatten() - .map(|e| &mut e["data"]) - .collect(), - Some("horizon:condition") => { - let o = p.as_object_mut().into_iter().flat_map(|o| o.iter_mut()); - o.filter(|(k, _)| *k == "then" || *k == "else") - .map(|(_, v)| v) - .collect() - } + Some(t) if t.starts_with("lithostitched:") => lithostitched::inner_lists(p), Some("horizon:pillar" | "horizon:bottom_pillar") => { p.get_mut("pillar_processor_list").into_iter().collect() } @@ -398,7 +389,9 @@ fn upgrade_types( } } for element in elements { - if yung::upgrade_pool_element(element, lost) { + if yung::upgrade_pool_element(element, lost) + || lithostitched::upgrade_pool_element(element, lost) + { changed = true; continue; } diff --git a/crates/horizon-world/src/worldgen/structure/processor.rs b/crates/horizon-world/src/worldgen/structure/processor.rs index f6f5d4508..b0a0622b7 100644 --- a/crates/horizon-world/src/worldgen/structure/processor.rs +++ b/crates/horizon-world/src/worldgen/structure/processor.rs @@ -21,7 +21,7 @@ use horizon_core::{ use serde_json::Value; use std::{collections::BTreeSet, sync::Arc}; -mod lithostitched; +mod litho; mod pillars; mod sea_level; @@ -238,6 +238,23 @@ impl Modifier { ) } } +impl Modifier { + /// RuleBlockEntityModifier.apply: the block entity the output gets. + fn apply(&self, nbt: Option<&Compound>, random: &mut impl ProcessorRandom) -> Option { + match self { + Self::Passthrough => nbt.cloned(), + Self::Clear => Some(Compound::new()), + Self::AppendLoot(table) => { + let mut nbt = nbt.cloned().unwrap_or_default(); + nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); + nbt.insert("LootTableSeed".into(), Tag::Long(random.long())); + Some(nbt) + } + Self::AppendStatic(data) => Some(edited(nbt, &[], data)), + Self::Edit { remove, data } => Some(edited(nbt, remove, data)), + } + } +} /// A block entity with `remove`'s keys taken out and `data` merged in /// (append_static is the one with nothing to remove). fn edited(nbt: Option<&Compound>, remove: &[String], data: &Compound) -> Compound { @@ -292,17 +309,21 @@ pub enum Processor { SpawnerMobs(Box), Pick(Box), CountCap(Box), - /// `horizon:block_swap` (Lithostitched's `block_swap`): blocks by name - /// become others, keeping the properties both have. + /// `lithostitched:block_swap`: blocks by name become others, keeping + /// the properties both have (a block the game lacks is left alone). BlockSwap(std::collections::BTreeMap), - /// `horizon:apply_random` (Lithostitched's `apply_random`): a processor - /// list drawn by weight runs on the block. - ApplyRandom(Box), - /// `horizon:condition` (Lithostitched's `condition`): `then` or `else` + /// `lithostitched:apply_random`: a processor list drawn by weight runs + /// on the block. + ApplyRandom(Box), + /// `lithostitched:reference`: the named lists run on the block in turn. + Reference(Vec), + /// `lithostitched:discard_input`: the world's block stays. + DiscardInput, + /// `lithostitched:condition`: `then` or `else` /// runs on the block, by a test of it. - Condition(Box), - /// `horizon:set_block` (Lithostitched's `set_block`). - SetBlock(Box), + Condition(Box), + /// `lithostitched:set_block`: the block from a state provider. + SetBlock(Box), /// `horizon:pillar` (Repurposed Structures' and Moog's pillars): a /// trigger block starts a column down to the ground. Pillar(Box), @@ -786,7 +807,7 @@ impl Processor { })?)) } "horizon:pick" => Self::Pick(Box::new(Pick::decode(value, state)?)), - "horizon:block_swap" => Self::BlockSwap( + "lithostitched:block_swap" => Self::BlockSwap( value["blocks"] .as_object() .ok_or(DecodeError::Field("blocks"))? @@ -801,12 +822,16 @@ impl Processor { .collect::>()?, ), "horizon:count_cap" => Self::CountCap(Box::new(CountCap::decode(value, state)?)), - "horizon:apply_random" => Self::ApplyRandom(Box::new( - lithostitched::ApplyRandom::decode(value, resources, bindings)?, + "lithostitched:apply_random" => Self::ApplyRandom(Box::new( + litho::ApplyRandom::decode(value, resources, bindings)?, )), - "horizon:set_block" => { - Self::SetBlock(Box::new(lithostitched::SetBlock::decode(value, state)?)) + "lithostitched:set_block" => { + Self::SetBlock(Box::new(litho::SetBlock::decode(value, state)?)) } + "lithostitched:reference" => { + Self::Reference(litho::reference(value, resources, bindings)?) + } + "lithostitched:discard_input" => Self::DiscardInput, "horizon:pillar" => Self::Pillar(Box::new(pillars::Pillar::decode( value, resources, bindings, state, )?)), @@ -834,7 +859,7 @@ impl Processor { "horizon:keep_world_block" => { Self::KeepWorldBlock(Box::new(sea_level::KeepWorldBlock::decode(value)?)) } - "horizon:condition" => Self::Condition(Box::new(lithostitched::Conditional::decode( + "lithostitched:condition" => Self::Condition(Box::new(litho::Conditional::decode( value, resources, bindings, )?)), _ => return Err(DecodeError::Field("structure processor type")), @@ -1115,24 +1140,10 @@ fn process_block( if !position_ok { continue; } - let nbt = match &rule.modifier { - Modifier::Passthrough => info.nbt.clone(), - Modifier::Clear => Some(Compound::new()), - Modifier::AppendLoot(table) => { - let mut nbt = info.nbt.clone().unwrap_or_default(); - nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); - nbt.insert("LootTableSeed".into(), Tag::Long(random.next_long())); - Some(nbt) - } - Modifier::AppendStatic(data) => Some(edited(info.nbt.as_ref(), &[], data)), - Modifier::Edit { remove, data } => { - Some(edited(info.nbt.as_ref(), remove, data)) - } - }; return Ok(Some(BlockInfo { pos: info.pos, state: rule.output, - nbt, + nbt: rule.modifier.apply(info.nbt.as_ref(), &mut random), })); } Some(info) @@ -1165,8 +1176,7 @@ fn process_block( false => Some(info), }, Processor::ApplyRandom(apply) => { - let seed = world.world_seed()?; - let mut random = apply.random.create(seed, position, reference, info.pos); + let mut random = apply.draws.random(world.world_seed()?, position, info.pos); match apply.pick(&mut random) { Some(list) => { return process_list( @@ -1176,21 +1186,34 @@ fn process_block( None => Some(info), } } + Processor::Reference(lists) => { + let mut current = info; + for list in lists { + match process_list( + list, world, resources, position, reference, relative, current, settings, + )? { + Some(next) => current = next, + None => return Ok(None), + } + } + Some(current) + } + Processor::DiscardInput => None, Processor::SetBlock(set) => { - let seed = world.world_seed()?; - let state = set.state(seed, position, reference, info.pos); - let state = match set.preserves() { + let mut random = set.draws.random(world.world_seed()?, position, info.pos); + let state = set.state(&mut random); + let state = match set.preserve { true => registry .state(state) .and_then(|s| with_properties_of(registry, &s.name, info.state)) .unwrap_or(state), false => state, }; - Some(BlockInfo { state, ..info }) + let nbt = set.modifier.apply(info.nbt.as_ref(), &mut random); + Some(BlockInfo { state, nbt, ..info }) } Processor::Condition(c) => { - let seed = world.world_seed()?; - let mut random = c.random.create(seed, position, reference, info.pos); + let mut random = c.draws.random(world.world_seed()?, position, info.pos); let location = world.block_state(info.pos)?; let passed = c .condition diff --git a/crates/horizon-world/src/worldgen/structure/processor/litho.rs b/crates/horizon-world/src/worldgen/structure/processor/litho.rs new file mode 100644 index 000000000..d243eb1c7 --- /dev/null +++ b/crates/horizon-world/src/worldgen/structure/processor/litho.rs @@ -0,0 +1,470 @@ +//! Lithostitched's processors (spec-lithostitched §5), read as its data +//! writes them: `lithostitched:block_swap` (in `processor.rs`), `reference`, +//! `apply_random`, `condition`, `set_block` and `discard_input`. +//! +//! The draws of `random_chance`, `apply_random` and `set_block` follow +//! Lithostitched's `random_mode` (per block or per piece), but its seeding is +//! not known (OPEN-L6): a positional random of the world seed, the block's or +//! the piece's position and the processor itself, so the shares match while +//! the blocks chosen do not. +use super::{BlockStateId, DecodeError, Modifier, ProcessorList, ProcessorRandom}; +use crate::worldgen::{block_feature::FeatureBlockBindings, structure::StructureResources}; +use horizon_core::{ + position::BlockPos, + random::{LegacyRandom, position_seed}, +}; +use serde_json::Value; +use std::collections::BTreeSet; + +/// `random_mode` (`condition`, `set_block`) or `mode` (`apply_random`). +#[derive(Clone, Copy, Debug)] +pub(super) struct Draws { + per_piece: bool, + /// The processor's own salt, so two processors on a block draw apart. + salt: i64, +} +impl Draws { + fn decode(mode: Option<&Value>, processor: &Value) -> Result { + let per_piece = match mode.and_then(Value::as_str) { + None | Some("per_block") => false, + Some("per_piece") => true, + _ => return Err(DecodeError::Field("random_mode")), + }; + // FNV-1a over the processor's JSON: the same in every run. + let salt = (processor.to_string().bytes()).fold(0xcbf2_9ce4_8422_2325_u64, |h, b| { + (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3) + }) as i64; + Ok(Self { per_piece, salt }) + } + /// The random for the block at `pos` of the piece at `piece`. + pub(super) fn random(self, world_seed: i64, piece: [i32; 3], pos: [i32; 3]) -> LegacyRandom { + let [x, y, z] = if self.per_piece { piece } else { pos }; + LegacyRandom::new(world_seed ^ self.salt ^ position_seed(BlockPos::new(x, y, z))) + } +} + +/// A processor or a list of them (`then`, `else`, `apply_random`'s data): +/// a list holder (`ProcessorList::decode`), or one processor object. +fn processors( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result { + let one = value.get("processor_type").is_some(); + let holder = if one { + Value::Array(vec![value.clone()]) + } else { + value.clone() + }; + ProcessorList::decode(&holder.to_string(), resources, bindings) +} + +/// `reference`: the named lists, run in turn on the block. +pub(super) fn reference( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names = match &value["processor_lists"] { + Value::Array(a) => a.clone(), + other => vec![other.clone()], + }; + (names.iter()) + .map(|name| match name.as_str() { + Some(n) if n.starts_with('#') => Err(DecodeError::Field("processor list tag")), + Some(_) => ProcessorList::decode(&name.to_string(), resources, bindings), + None => Err(DecodeError::Field("processor_lists")), + }) + .collect() +} + +/// `apply_random`: one list drawn by weight runs on the block. +#[derive(Clone, Debug)] +pub struct ApplyRandom { + pub(super) draws: Draws, + lists: Vec<(i32, ProcessorList)>, + total: i32, +} +impl ApplyRandom { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let entries = value["processor_lists"] + .as_array() + .ok_or(DecodeError::Field("apply_random processor_lists"))?; + let lists = (entries.iter()) + .map(|e| match e.get("data") { + Some(data) => { + let weight = e["weight"] + .as_i64() + .unwrap_or(1) + .clamp(0, i64::from(i32::MAX)); + Ok((weight as i32, processors(data, resources, bindings)?)) + } + None => Ok((1, processors(e, resources, bindings)?)), + }) + .collect::, DecodeError>>()?; + let total = lists + .iter() + .map(|(w, _)| *w) + .fold(0i32, i32::saturating_add); + Ok(Self { + draws: Draws::decode(value.get("mode"), value)?, + lists, + total, + }) + } + /// The list drawn: one bounded draw over the total weight. + pub(super) fn pick(&self, random: &mut impl ProcessorRandom) -> Option<&ProcessorList> { + if self.total <= 0 { + return None; + } + let mut at = random.int(self.total); + for (weight, list) in &self.lists { + at -= weight; + if at < 0 { + return Some(list); + } + } + None + } +} + +/// Lithostitched's processor conditions. +#[derive(Clone, Debug)] +pub(super) enum Condition { + True, + AllOf(Vec), + AnyOf(Vec), + Not(Box), + Chance(f32), + /// `matching_blocks`: the template's block (`input`) or the world's + /// (`location`) is one of `blocks`, with `properties`. + Matching { + blocks: BTreeSet, + properties: Vec<(String, String)>, + location: bool, + }, +} +impl Condition { + /// One condition, or a list of them that must all pass (`if_true`). + pub(super) fn decode( + value: &Value, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let list = |v: &Value| -> Result, DecodeError> { + (v.as_array().ok_or(DecodeError::Field("conditions"))?.iter()) + .map(|c| Self::decode(c, bindings)) + .collect() + }; + if value.is_array() { + return Ok(Self::AllOf(list(value)?)); + } + let kind = value["type"].as_str().unwrap_or_default(); + Ok(match crate::worldgen::tags::identifier(kind)?.as_str() { + "lithostitched:true" => Self::True, + "lithostitched:all_of" => Self::AllOf(list(&value["conditions"])?), + "lithostitched:any_of" => Self::AnyOf(list(&value["conditions"])?), + "lithostitched:not" => { + Self::Not(Box::new(Self::decode(&value["condition"], bindings)?)) + } + "lithostitched:random_chance" => Self::Chance( + value["chance"] + .as_f64() + .ok_or(DecodeError::Field("random_chance chance"))? as f32, + ), + "lithostitched:matching_blocks" => Self::Matching { + blocks: blocks(&value["blocks"], bindings)?, + properties: (value + .get("properties") + .and_then(Value::as_object) + .into_iter()) + .flatten() + .map(|(k, v)| { + ( + k.clone(), + v.as_str().map_or_else(|| v.to_string(), str::to_owned), + ) + }) + .collect(), + location: match value.get("match_type").and_then(Value::as_str) { + None | Some("input") => false, + Some("location") => true, + _ => return Err(DecodeError::Field("matching_blocks match_type")), + }, + }, + _ => return Err(DecodeError::Field("lithostitched condition type")), + }) + } + pub(super) fn test( + &self, + input: BlockStateId, + location: BlockStateId, + registry: &crate::registry::BlockRegistry, + random: &mut impl ProcessorRandom, + ) -> bool { + match self { + Self::True => true, + Self::AllOf(all) => all + .iter() + .all(|c| c.test(input, location, registry, random)), + Self::AnyOf(any) => any + .iter() + .any(|c| c.test(input, location, registry, random)), + Self::Not(c) => !c.test(input, location, registry, random), + Self::Chance(chance) => random.float() < *chance, + Self::Matching { + blocks, + properties, + location: at_location, + } => { + let Some(state) = registry.state(if *at_location { location } else { input }) + else { + return false; + }; + blocks.contains(&state.name) + && (properties.iter()).all(|(k, v)| state.properties.get(k) == Some(v)) + } + } + } +} +/// A block set (an id, a list, `#tag`) by block name. Blocks the game does +/// not have are left out: no template block can be one. +fn blocks( + value: &Value, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names: Vec<&str> = match value { + Value::String(s) => vec![s.as_str()], + Value::Array(a) => a.iter().filter_map(Value::as_str).collect(), + _ => return Err(DecodeError::Field("matching_blocks blocks")), + }; + let registry = bindings.registry(); + let mut out = BTreeSet::new(); + for name in names { + match name.strip_prefix('#') { + Some(tag) => { + let tag = crate::worldgen::tags::identifier(tag)?; + let states = bindings.tags.get(&tag).into_iter().flat_map(|s| s.iter()); + out.extend(states.filter_map(|s| Some(registry.state(*s)?.name.clone()))); + } + None => { + out.insert(crate::worldgen::tags::identifier(name)?.to_string()); + } + } + } + Ok(out) +} + +/// `condition`: `then` when the conditions pass, else `else` (none: the +/// block as it is). +#[derive(Clone, Debug)] +pub struct Conditional { + pub(super) draws: Draws, + pub(super) condition: Condition, + pub(super) then: ProcessorList, + pub(super) otherwise: ProcessorList, +} +impl Conditional { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let branch = |key| match value.get(key) { + Some(v) => processors(v, resources, bindings), + None => Ok(ProcessorList(Vec::new())), + }; + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + condition: Condition::decode(&value["if_true"], bindings)?, + then: branch("then")?, + otherwise: branch("else")?, + }) + } +} + +/// `set_block`: the block from a state provider (simple or weighted). +#[derive(Clone, Debug)] +pub struct SetBlock { + pub(super) draws: Draws, + states: Vec<(i32, BlockStateId)>, + total: i32, + /// `preserve_state` (true by default): the template block's properties + /// the new block has too are kept. + pub(super) preserve: bool, + pub(super) modifier: Modifier, +} +impl SetBlock { + pub(super) fn decode( + value: &Value, + state: impl Fn(&Value) -> Result, + ) -> Result { + let provider = &value["state_provider"]; + let kind = provider["type"].as_str().unwrap_or_default(); + let states = match crate::worldgen::tags::identifier(kind)?.as_str() { + "minecraft:simple_state_provider" => vec![(1, state(&provider["state"])?)], + "minecraft:weighted_state_provider" => (provider["entries"].as_array().into_iter()) + .flatten() + .map(|e| { + Ok(( + e["weight"].as_i64().unwrap_or(1).clamp(0, 1 << 30) as i32, + state(&e["data"])?, + )) + }) + .collect::>()?, + _ => return Err(DecodeError::Field("set_block state_provider")), + }; + let total = states.iter().map(|(w, _)| *w).sum(); + if total <= 0 { + return Err(DecodeError::Field("set_block state_provider")); + } + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + states, + total, + preserve: value + .get("preserve_state") + .and_then(Value::as_bool) + .unwrap_or(true), + modifier: Modifier::decode(value.get("block_entity_modifier"))?, + }) + } + /// The provider's state: WeightedList.getRandom, one bounded draw. + pub(super) fn state(&self, random: &mut impl ProcessorRandom) -> BlockStateId { + let mut at = random.int(self.total); + for (weight, state) in &self.states { + at -= weight; + if at < 0 { + return *state; + } + } + self.states[0].1 + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::registry::BlockRegistry; + use serde_json::json; + + // 0 air, 1 cobblestone, 2..=9 wheat age 0..7, 10..=13 beetroots age 0..3, + // 14..=21 carrots age 0..7, 22 water. + fn registry() -> BlockRegistry { + let row = |name: &str, age: u32| json!([name, false, false, "", {"id": name, "properties": {"age": age.to_string()}}]); + let mut states = vec![ + json!(["minecraft:air", false, false, "", "minecraft:air"]), + json!([ + "minecraft:cobblestone", + false, + false, + "", + "minecraft:cobblestone" + ]), + ]; + states.extend((0..8).map(|a| row("minecraft:wheat", a))); + states.extend((0..4).map(|a| row("minecraft:beetroots", a))); + states.extend((0..8).map(|a| row("minecraft:carrots", a))); + states.push(json!([ + "minecraft:water", + false, + false, + "", + "minecraft:water" + ])); + let facts = json!({"defaults": {"minecraft:air": 0, "minecraft:cobblestone": 1, "minecraft:wheat": 2, + "minecraft:beetroots": 10, "minecraft:carrots": 14, "minecraft:water": 22}, "states": states}); + BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap() + } + + #[test] + fn swaps_keep_only_the_properties_the_new_block_can_have() { + // spec-ctov §4: wheat[age=7] becomes carrots[age=7] but beetroots[age=0]. + let registry = registry(); + let ripe_wheat = BlockStateId(9); + let swap = |to| super::super::with_properties_of(®istry, to, ripe_wheat); + assert_eq!(swap("minecraft:carrots"), Some(BlockStateId(21))); + assert_eq!(swap("minecraft:beetroots"), Some(BlockStateId(10))); + // A block the game does not have: the template's block stays. + assert_eq!(swap("natures_spirit:olive_log"), None); + } + + #[test] + fn conditions_read_the_template_or_the_world() { + let registry = registry(); + let mut random = LegacyRandom::new(1); + let matching = |location| Condition::Matching { + blocks: BTreeSet::from(["minecraft:water".to_owned()]), + properties: Vec::new(), + location, + }; + let (cobblestone, water) = (BlockStateId(1), BlockStateId(22)); + assert!(!matching(false).test(cobblestone, water, ®istry, &mut random)); + assert!(matching(true).test(cobblestone, water, ®istry, &mut random)); + let ripe = Condition::Matching { + blocks: BTreeSet::from(["minecraft:wheat".to_owned()]), + properties: vec![("age".into(), "7".into())], + location: false, + }; + assert!(ripe.test(BlockStateId(9), water, ®istry, &mut random)); + assert!(!ripe.test(BlockStateId(8), water, ®istry, &mut random)); + let both = Condition::AllOf(vec![ + matching(true), + Condition::Not(Box::new(Condition::True)), + ]); + assert!(!both.test(cobblestone, water, ®istry, &mut random)); + assert!( + Condition::AnyOf(vec![Condition::Chance(0.), matching(true)]).test( + cobblestone, + water, + ®istry, + &mut random + ) + ); + } + + #[test] + fn per_piece_draws_once_per_piece() { + let p = json!({"processor_type": "lithostitched:apply_random"}); + let piece = Draws::decode(Some(&json!("per_piece")), &p).unwrap(); + let block = Draws::decode(None, &p).unwrap(); + let first = |d: Draws, pos| d.random(42, [0, 64, 0], pos).int(1 << 30); + assert_eq!(first(piece, [1, 64, 1]), first(piece, [9, 70, 3])); + assert_ne!(first(block, [1, 64, 1]), first(block, [9, 70, 3])); + // Another processor draws apart on the same block. + let other = + Draws::decode(None, &json!({"processor_type": "lithostitched:set_block"})).unwrap(); + assert_ne!(first(block, [1, 64, 1]), first(other, [1, 64, 1])); + assert!(Draws::decode(Some(&json!("per_structure")), &p).is_err()); + } + + #[test] + fn set_block_draws_by_weight() { + let set = SetBlock::decode( + &json!({"processor_type": "lithostitched:set_block", "preserve_state": false, + "state_provider": {"type": "minecraft:weighted_state_provider", "entries": [ + {"weight": 1, "data": {"id": "minecraft:cobblestone"}}, + {"weight": 3, "data": {"id": "minecraft:water"}}]}}), + |v| { + Ok(BlockStateId(if v["id"] == "minecraft:water" { + 22 + } else { + 1 + })) + }, + ) + .unwrap(); + assert!(!set.preserve); + let water = (0..4000) + .filter(|x| { + set.state(&mut set.draws.random(7, [0; 3], [*x, 64, 0])) == BlockStateId(22) + }) + .count(); + assert!((2850..3150).contains(&water), "{water}"); + let unknown = json!({"state_provider": {"type": "minecraft:noise_provider"}}); + assert!(SetBlock::decode(&unknown, |_| Ok(BlockStateId(0))).is_err()); + } +} diff --git a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs b/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs deleted file mode 100644 index f0bb1c6ba..000000000 --- a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs +++ /dev/null @@ -1,434 +0,0 @@ -//! Lithostitched's processors that pick processors, carried as data -//! (`horizon:apply_random` and `horizon:condition`): one runs a processor -//! list drawn by weight, the other one list or another by a test of the -//! block. Both draw from Lithostitched's RandomSettings: a random seeded from -//! the world seed and a name, at the block, the piece or the structure. -//! `horizon:set_block` is its `set_block`, which the conditions mostly run. -use super::{Processor, ProcessorList}; -use crate::{ - registry::{BlockRegistry, BlockStateId}, - worldgen::{DecodeError, block_feature::FeatureBlockBindings, structure::StructureResources}, -}; -use horizon_core::{ - position::BlockPos, - random::{LegacyRandom, PositionalRandom, RandomSource}, -}; -use serde_json::Value; -use std::{collections::BTreeSet, sync::Arc}; - -/// RandomSettings: where the random is taken, and the name salting it. -#[derive(Clone, Debug, PartialEq)] -pub struct RandomSettings { - mode: Mode, - /// ResourceLocation.hashCode of the name (`lithostitched:default`). - salt: i32, -} -#[derive(Clone, Copy, Debug, PartialEq)] -enum Mode { - Block, - Piece, - Structure, -} -impl RandomSettings { - /// A mode alone, or `{"mode": ..., "name": ...}`; per block when unset. - fn decode(v: Option<&Value>) -> Result { - let mode = Mode::decode; - let (mode, name) = match v { - None => (Mode::Block, "lithostitched:default"), - Some(Value::String(m)) => (mode(Some(m))?, "lithostitched:default"), - Some(o) => ( - mode(o["mode"].as_str())?, - o["name"] - .as_str() - .ok_or(DecodeError::Field("random name"))?, - ), - }; - let (namespace, path) = name.split_once(':').unwrap_or(("minecraft", name)); - Ok(Self { - mode, - salt: java_hash(namespace) - .wrapping_mul(31) - .wrapping_add(java_hash(path)), - }) - } - /// RandomSource.create(seed + hash).forkPositional().at(the chosen - /// position): the piece's position, the structure's pivot or the block. - pub(super) fn create( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> LegacyRandom { - let [x, y, z] = self.mode.select(piece, pivot, block); - LegacyRandom::new(seed.wrapping_add(i64::from(self.salt))) - .fork_positional() - .at(BlockPos::new(x, y, z)) - } -} -impl Mode { - fn decode(m: Option<&str>) -> Result { - match m { - None | Some("per_block") => Ok(Self::Block), - Some("per_piece") => Ok(Self::Piece), - Some("per_structure") => Ok(Self::Structure), - _ => Err(DecodeError::Field("random mode")), - } - } - fn select(self, piece: [i32; 3], pivot: [i32; 3], block: [i32; 3]) -> [i32; 3] { - match self { - Self::Block => block, - Self::Piece => piece, - Self::Structure => pivot, - } - } -} - -/// SetBlockProcessor with a simple or weighted state provider and no block -/// entity change: the block becomes the state, keeping the properties it -/// shares with the old one unless `preserve_state` is off. -#[derive(Clone, Debug)] -pub struct SetBlock { - /// The states and their weights; one state alone is a simple provider, - /// which draws nothing. - states: Vec<(BlockStateId, i32)>, - weighted: bool, - preserve: bool, - mode: Mode, -} -impl SetBlock { - pub(super) fn decode( - v: &Value, - state: impl Fn(&Value) -> Result, - ) -> Result { - let provider = &v["state_provider"]; - let (states, weighted) = match provider["type"].as_str() { - Some("minecraft:simple_state_provider") => { - (vec![(state(&provider["state"])?, 1)], false) - } - Some("minecraft:weighted_state_provider") => ( - provider["entries"] - .as_array() - .ok_or(DecodeError::Field("set_block entries"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("set_block weight"))?; - Ok((state(&e["data"])?, weight as i32)) - }) - .collect::>()?, - true, - ), - _ => return Err(DecodeError::Field("set_block state_provider")), - }; - if states.is_empty() { - return Err(DecodeError::Field("set_block entries")); - } - Ok(Self { - states, - weighted, - preserve: v["preserve_state"].as_bool().unwrap_or(true), - mode: Mode::decode(v["random_mode"].as_str())?, - }) - } - /// The state to set, before `preserve`: drawn with - /// RandomSource.create(seed).forkPositional().at(the chosen position). - pub(super) fn state( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> BlockStateId { - if !self.weighted { - return self.states[0].0; - } - let [x, y, z] = self.mode.select(piece, pivot, block); - let mut random = LegacyRandom::new(seed) - .fork_positional() - .at(BlockPos::new(x, y, z)); - let total: i32 = self.states.iter().map(|s| s.1).sum(); - let mut value = random.next_int_bound(total.max(1)).unwrap_or(0); - for (state, weight) in &self.states { - if value < *weight { - return *state; - } - value -= weight; - } - self.states[0].0 - } - pub(super) fn preserves(&self) -> bool { - self.preserve - } -} - -/// String.hashCode over UTF-16 units. -fn java_hash(s: &str) -> i32 { - s.encode_utf16() - .fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c))) -} - -fn list( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, -) -> Result { - ProcessorList::decode(&v.to_string(), resources, bindings) -} - -/// ApplyRandomStructureProcessor: a weighted list of processor lists, one -/// drawn per block with `nextInt(total)`. -#[derive(Clone, Debug)] -pub struct ApplyRandom { - pub(super) random: RandomSettings, - lists: Vec<(ProcessorList, i32)>, - total: i32, -} -impl ApplyRandom { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - let lists = v["processor_lists"] - .as_array() - .ok_or(DecodeError::Field("apply_random processor_lists"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("apply_random weight"))?; - Ok((list(&e["data"], resources, bindings)?, weight as i32)) - }) - .collect::, DecodeError>>()?; - Ok(Self { - random: RandomSettings::decode(v.get("mode"))?, - total: lists.iter().map(|l| l.1).sum(), - lists, - }) - } - /// WeightedList.getRandom: none when the weights add up to 0. - pub(super) fn pick(&self, random: &mut impl RandomSource) -> Option<&ProcessorList> { - if self.total <= 0 { - return None; - } - let mut value = random.next_int_bound(self.total).unwrap_or(0); - for (list, weight) in &self.lists { - if value < *weight { - return Some(list); - } - value -= weight; - } - None - } -} - -/// ConditionProcessor: `then` when the condition holds for the block, else -/// `else`. -#[derive(Clone, Debug)] -pub struct Conditional { - pub(super) random: RandomSettings, - pub(super) condition: Condition, - pub(super) then: ProcessorList, - pub(super) otherwise: ProcessorList, -} -impl Conditional { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - // A processor alone or a list of them. - let processors = |key: &str| -> Result { - match v.get(key) { - None => Ok(ProcessorList::default()), - Some(Value::Object(p)) if p.contains_key("processor_type") => Ok(ProcessorList( - vec![Processor::decode(&v[key], resources, bindings)?], - )), - Some(other) => list(other, resources, bindings), - } - }; - Ok(Self { - random: RandomSettings::decode(v.get("random_mode"))?, - condition: Condition::decode(&v["if_true"], bindings)?, - then: processors("then")?, - otherwise: processors("else")?, - }) - } -} - -/// Lithostitched's processor conditions the game runs. -#[derive(Clone, Debug)] -pub(super) enum Condition { - True, - AllOf(Vec), - AnyOf(Vec), - Not(Box), - RandomChance(f32), - /// The block placed (`input`) or the one in the world (`location`) is - /// one of these, with these property values. - MatchingBlocks { - blocks: Arc>, - properties: Vec<(String, String)>, - location: bool, - }, -} -impl Condition { - fn decode(v: &Value, bindings: &FeatureBlockBindings<'_>) -> Result { - let all = |a: &Value| -> Result, DecodeError> { - a.as_array() - .ok_or(DecodeError::Field("processor conditions"))? - .iter() - .map(|c| Self::decode(c, bindings)) - .collect() - }; - if v.is_array() { - return Ok(Self::AllOf(all(v)?)); - } - let kind = v["type"].as_str().unwrap_or_default(); - Ok(match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" => Self::True, - "all_of" => Self::AllOf(all(&v["conditions"])?), - "any_of" => Self::AnyOf(all(&v["conditions"])?), - "not" => Self::Not(Box::new(Self::decode(&v["condition"], bindings)?)), - "random_chance" => Self::RandomChance(super::float(v, "chance")?), - "matching_blocks" => Self::MatchingBlocks { - blocks: super::holder_set(&v["blocks"], bindings)?, - properties: match v.get("properties") { - None => Vec::new(), - Some(p) => p - .as_object() - .ok_or(DecodeError::Field("matching_blocks properties"))? - .iter() - .map(|(k, x)| { - let x = x - .as_str() - .ok_or(DecodeError::Field("matching_blocks property"))?; - Ok((k.clone(), x.to_owned())) - }) - .collect::>()?, - }, - location: match v["match_type"].as_str() { - None | Some("input") => false, - Some("location") => true, - _ => return Err(DecodeError::Field("matching_blocks match_type")), - }, - }, - _ => return Err(DecodeError::Field("processor condition type")), - }) - } - /// ProcessorCondition.test with the block placed and the one there. - pub(super) fn test( - &self, - input: BlockStateId, - location: BlockStateId, - registry: &BlockRegistry, - random: &mut impl RandomSource, - ) -> bool { - match self { - Self::True => true, - Self::AllOf(all) => all - .iter() - .all(|c| c.test(input, location, registry, random)), - Self::AnyOf(any) => any - .iter() - .any(|c| c.test(input, location, registry, random)), - Self::Not(c) => !c.test(input, location, registry, random), - Self::RandomChance(chance) => random.next_float() < *chance, - Self::MatchingBlocks { - blocks, - properties, - location: at_location, - } => { - let state = if *at_location { location } else { input }; - blocks.contains(&state) - && properties.iter().all(|(k, x)| { - registry - .state(state) - .and_then(|s| s.properties.get(k)) - .is_some_and(|v| v == x) - }) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn random_settings_salt_and_position() { - // ResourceLocation.hashCode: 31 * namespace + path. - let default = RandomSettings::decode(Some(&"per_piece".into())).unwrap(); - assert_eq!( - default.salt, - java_hash("lithostitched") - .wrapping_mul(31) - .wrapping_add(java_hash("default")) - ); - assert_eq!(java_hash("default"), 1544803905); - let (seed, piece, pivot, block) = (12345, [16, 64, -32], [8, 70, 8], [17, 65, -30]); - let mut ours = default.create(seed, piece, pivot, block); - let mut theirs = LegacyRandom::new(seed + i64::from(default.salt)) - .fork_positional() - .at(BlockPos::new(16, 64, -32)); - assert_eq!(ours.next_long(), theirs.next_long()); - let named: Value = serde_json::json!({"mode": "per_structure", "name": "v:roof"}); - let named = RandomSettings::decode(Some(&named)).unwrap(); - assert_eq!(named.mode, Mode::Structure); - assert_eq!( - named.salt, - java_hash("v") - .wrapping_mul(31) - .wrapping_add(java_hash("roof")) - ); - } - - #[test] - fn apply_random_draws_by_weight() { - let apply = ApplyRandom { - random: RandomSettings { - mode: Mode::Block, - salt: 0, - }, - lists: vec![ - (ProcessorList(vec![Processor::Nop]), 3), - (ProcessorList::default(), 1), - ], - total: 4, - }; - let mut ours = LegacyRandom::new(9); - let mut theirs = LegacyRandom::new(9); - for _ in 0..32 { - let draw = theirs.next_int_bound(4).unwrap(); - let picked = apply.pick(&mut ours).unwrap(); - assert_eq!(picked.0.len(), usize::from(draw < 3)); - } - } - - #[test] - fn set_block_draws_from_the_unsalted_seed() { - let (a, b) = (BlockStateId(1), BlockStateId(2)); - let set = SetBlock::decode( - &serde_json::json!({"state_provider": {"type": "minecraft:weighted_state_provider", - "entries": [{"weight": 1, "data": 1}, {"weight": 2, "data": 2}]}, - "random_mode": "per_piece"}), - |v| Ok(BlockStateId(v.as_u64().unwrap() as u32)), - ) - .unwrap(); - assert!(set.preserves()); - for x in 0..16 { - let mut java = LegacyRandom::new(77) - .fork_positional() - .at(BlockPos::new(x, 5, 3)); - let want = if java.next_int_bound(3).unwrap() < 1 { - a - } else { - b - }; - assert_eq!(set.state(77, [x, 5, 3], [0; 3], [9, 9, 9]), want); - } - } -} diff --git a/docs/modpacks.md b/docs/modpacks.md index 13ad619ed..8e3980dd2 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -504,21 +504,22 @@ Two cases the oracle fills in: mod. Better Dungeons' small dungeons keep one chest and each other one with a fifth's chance, two at most (the game's `horizon:count_cap`, counted per placement as the mod's DungeonContext is): 12 chests in five small dungeons at seed 1234 become 6. - Lithostitched's `block_swap` (137 lists, all in ChoiceTheorem's Overhauled Village) is the - game's `horizon:block_swap`: the same map, with Block.withPropertiesOf's properties kept; - a target block the game does not have (most of them are Nature's Spirit's and Croptopia's) - leaves the block as it is, as the mod does. Lithostitched's `reference` (CTOV builds most - of its lists from others) has the referenced lists' processors written in its place; its - `apply_random`, `condition` and `set_block` are the game's `horizon:apply_random`, - `horizon:condition` and `horizon:set_block`, with Lithostitched's random (the world seed - plus the name's hash, at the block, piece or structure). In a CTOV plains village at seed - 1234 the farms now grow carrots, potatoes and beetroot besides wheat, and 1,655 - cobblestone blocks become paths, grass, mossy cobblestone and planks. No Lithostitched processor is - dropped now (130 before). CTOV's compat hooks for other mods inside them (its - `modular_compat`, 142 copies) run a list of their own only when the mod they name is - loaded: carry writes that list in when the mod is ported along and takes the hook out (a - no-op, as in the mod) when it is not. In ATM10 all 142 name Nature's Spirit, which the - pack does not have. + Lithostitched's processors (all in ChoiceTheorem's Overhauled Village in ATM10) are the + game's own types, read as the mod writes them. `block_swap` keeps the properties the new + block can have: a farm's ripe wheat becomes ripe carrots, but beetroot, whose age stops at + 3, keeps its default; a target block the game does not have (most are Nature's Spirit's and + Croptopia's) leaves the block as it is. `reference` runs the lists it names, `condition` + tests the template's block or the world's, `apply_random` and `set_block` draw per block or + per piece as the data says. Lithostitched's own random is not known yet, so the shares of a + random choice are the Java pack's but the blocks chosen differ. Lists named by tag and state + providers other than simple and weighted ones are dropped and counted (ATM10 has none). + CTOV's compat hooks for other mods (its `modular_compat`, 30 of them in 17 lists) become a + `reference` when the mod they name is ported along, and are taken out (a no-op, as in the + mod) when it is not. In ATM10 they all name Nature's Spirit, which the pack does not have. + In Java, Lithostitched also lays out every jigsaw structure its own way (villages, + outposts, trial chambers; CTOV's villages are `lithostitched:jigsaw`, carried as vanilla's + jigsaw). Horizon keeps vanilla's layouts, so with Lithostitched in a pack, structure layouts + differ from the Java pack's for the same seed (their positions do not). The processors that build outside their template are carried too: Repurposed's and Moog's pillar processors become the game's `horizon:pillar` (a column from a placeholder block down to the ground, with the processor list they run on each of its blocks written From d89fb16f601c245c23d9ab2ba98323cec84cc084 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 09:06:14 +0100 Subject: [PATCH 2/9] Structure blocks harness: CTOV's known differences Co-Authored-By: Claude Opus 5.5 --- tools/test_structure_blocks_parity.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/test_structure_blocks_parity.py b/tools/test_structure_blocks_parity.py index 39ccb4e49..fc4151f8d 100644 --- a/tools/test_structure_blocks_parity.py +++ b/tools/test_structure_blocks_parity.py @@ -55,6 +55,12 @@ KNOWN = { "Better Dungeons' own structure types (spec-betterdungeons §5, §6; OPEN-B14, B15) are not " 'implemented yet', }, + 'ctov': { + r'^ctov:': "Lithostitched's random is not known (spec-lithostitched OPEN-L6): per-block road and palette " + 'choices match by share, not by block; and decoration (grass, trees) differs where the village ' + 'changed the terrain', + r'^minecraft:village_plains$': 'decoration (grass, trees) differs where the village changed the terrain', + }, } From eb6c81945ad8b1d6acb2c5b9a089b0e7239a7092 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 09:29:53 +0100 Subject: [PATCH 3/9] Lithostitched processors: unit tests rewritten from the spec The previous tests of litho.rs are deleted unread (clean-room ruling of 2026-10-25). The new ones build their own block registry from a facts table and run each processor through process_list against a one-block world: block_swap's property copy (CTOV's beetroots), references in order and discard_input, the probe pack's nested condition with else, apply_random per piece and per block, set_block's providers and its block entity modifier. Co-Authored-By: Claude Opus 5.5 --- .../src/worldgen/structure/processor/litho.rs | 577 ++++++++++++++---- 1 file changed, 474 insertions(+), 103 deletions(-) diff --git a/crates/horizon-world/src/worldgen/structure/processor/litho.rs b/crates/horizon-world/src/worldgen/structure/processor/litho.rs index d243eb1c7..6ba006fd6 100644 --- a/crates/horizon-world/src/worldgen/structure/processor/litho.rs +++ b/crates/horizon-world/src/worldgen/structure/processor/litho.rs @@ -347,124 +347,495 @@ impl SetBlock { #[cfg(test)] mod tests { - use super::*; - use crate::registry::BlockRegistry; - use serde_json::json; + use super::super::{BlockInfo, PlaceSettings, ProcessorList, process_list}; + use crate::{ + heightmap::HeightmapType, + nbt::{JavaString, Tag}, + registry::{BlockRegistry, BlockStateId}, + worldgen::{ + anchor::WorldGenerationContext, + block_feature::FeatureBlockBindings, + placement::{PlacementContext, PlacementQueryError}, + structure::{ + Rotation, StateTransforms, StructureResources, template::parse_state_string, + }, + }, + }; + use serde_json::{Value, json}; + use std::collections::{BTreeMap, BTreeSet}; - // 0 air, 1 cobblestone, 2..=9 wheat age 0..7, 10..=13 beetroots age 0..3, - // 14..=21 carrots age 0..7, 22 water. - fn registry() -> BlockRegistry { - let row = |name: &str, age: u32| json!([name, false, false, "", {"id": name, "properties": {"age": age.to_string()}}]); - let mut states = vec![ - json!(["minecraft:air", false, false, "", "minecraft:air"]), - json!([ - "minecraft:cobblestone", - false, - false, - "", - "minecraft:cobblestone" - ]), + /// Every combination of `properties`' values, the first one the default. + fn states(name: &str, properties: &[(&str, &[&str])]) -> Vec { + let mut out = vec![serde_json::Map::new()]; + for (key, values) in properties { + out = (out.iter()) + .flat_map(|o| { + values.iter().map(move |v| { + let mut o = o.clone(); + o.insert((*key).into(), (*v).into()); + o + }) + }) + .collect(); + } + (out.into_iter()) + .map(|p| json!([name, name.ends_with("air"), false, "", {"id": name, "properties": p}])) + .collect() + } + + /// A registry of the blocks CTOV's lists and the probe pack use. + fn registry() -> &'static BlockRegistry { + let ages: Vec = (0..8).map(|a| a.to_string()).collect(); + let ages: Vec<&str> = ages.iter().map(String::as_str).collect(); + let levels: Vec = (0..16).map(|a| a.to_string()).collect(); + let levels: Vec<&str> = levels.iter().map(String::as_str).collect(); + let water = [("level", &levels[..])]; + let stairs: &[(&str, &[&str])] = + &[("facing", &["north", "east"]), ("half", &["bottom", "top"])]; + let blocks: Vec<(&str, &[(&str, &[&str])])> = vec![ + ("minecraft:air", &[]), + ("minecraft:cave_air", &[]), + ("minecraft:void_air", &[]), + ("minecraft:lava", &water), + ("minecraft:cobblestone", &[]), + ("minecraft:blackstone", &[]), + ("minecraft:deepslate", &[]), + ("minecraft:water", &water), + ("minecraft:spruce_planks", &[]), + ("minecraft:chest", &[]), + ("minecraft:oak_log", &[("axis", &["y", "x"])]), + ("minecraft:stripped_cherry_log", &[("axis", &["y", "x"])]), + ("minecraft:oak_stairs", stairs), + ("minecraft:warped_stairs", stairs), ]; - states.extend((0..8).map(|a| row("minecraft:wheat", a))); - states.extend((0..4).map(|a| row("minecraft:beetroots", a))); - states.extend((0..8).map(|a| row("minecraft:carrots", a))); - states.push(json!([ - "minecraft:water", - false, - false, - "", - "minecraft:water" - ])); - let facts = json!({"defaults": {"minecraft:air": 0, "minecraft:cobblestone": 1, "minecraft:wheat": 2, - "minecraft:beetroots": 10, "minecraft:carrots": 14, "minecraft:water": 22}, "states": states}); - BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap() + let wheat = [("age", &ages[..])]; + let beetroots = [("age", &ages[..4])]; + let mut rows = Vec::new(); + let mut defaults = BTreeMap::new(); + let crops: [(&str, &[(&str, &[&str])]); 3] = [ + ("minecraft:wheat", &wheat), + ("minecraft:carrots", &wheat), + ("minecraft:beetroots", &beetroots), + ]; + for (name, properties) in blocks.into_iter().chain(crops) { + defaults.insert(name, rows.len()); + rows.extend(states(name, properties)); + } + let facts = json!({"states": rows, "defaults": defaults}); + let registry = BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap(); + Box::leak(Box::new(registry)) } - #[test] - fn swaps_keep_only_the_properties_the_new_block_can_have() { - // spec-ctov §4: wheat[age=7] becomes carrots[age=7] but beetroots[age=0]. - let registry = registry(); - let ripe_wheat = BlockStateId(9); - let swap = |to| super::super::with_properties_of(®istry, to, ripe_wheat); - assert_eq!(swap("minecraft:carrots"), Some(BlockStateId(21))); - assert_eq!(swap("minecraft:beetroots"), Some(BlockStateId(10))); - // A block the game does not have: the template's block stays. - assert_eq!(swap("natures_spirit:olive_log"), None); + /// The world a piece is placed in: one block everywhere. + struct World { + seed: i64, + block: BlockStateId, + } + impl PlacementContext for World { + fn world_seed(&mut self) -> Result { + Ok(self.seed) + } + fn block_state(&mut self, _: [i32; 3]) -> Result { + Ok(self.block) + } + fn generation(&self) -> WorldGenerationContext { + WorldGenerationContext::new(-64, 384, 63) + } + fn min_y(&mut self) -> Result { + Ok(-64) + } + fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result { + Err(PlacementQueryError::Unavailable) + } } - #[test] - fn conditions_read_the_template_or_the_world() { - let registry = registry(); - let mut random = LegacyRandom::new(1); - let matching = |location| Condition::Matching { - blocks: BTreeSet::from(["minecraft:water".to_owned()]), - properties: Vec::new(), - location, - }; - let (cobblestone, water) = (BlockStateId(1), BlockStateId(22)); - assert!(!matching(false).test(cobblestone, water, ®istry, &mut random)); - assert!(matching(true).test(cobblestone, water, ®istry, &mut random)); - let ripe = Condition::Matching { - blocks: BTreeSet::from(["minecraft:wheat".to_owned()]), - properties: vec![("age".into(), "7".into())], - location: false, - }; - assert!(ripe.test(BlockStateId(9), water, ®istry, &mut random)); - assert!(!ripe.test(BlockStateId(8), water, ®istry, &mut random)); - let both = Condition::AllOf(vec![ - matching(true), - Condition::Not(Box::new(Condition::True)), - ]); - assert!(!both.test(cobblestone, water, ®istry, &mut random)); - assert!( - Condition::AnyOf(vec![Condition::Chance(0.), matching(true)]).test( - cobblestone, - water, - ®istry, - &mut random + struct Lists { + registry: &'static BlockRegistry, + resources: StructureResources, + } + impl Lists { + fn new(lists: &[(&str, Value)]) -> Self { + let registry = registry(); + let lists = (lists.iter()) + .map(|(id, list)| ((*id).to_owned(), list.to_string())) + .collect(); + let resources = StructureResources::new( + registry, + StateTransforms::default(), + std::path::Path::new("/nonexistent"), + lists, + &BTreeMap::new(), + ); + Self { + registry, + resources, + } + } + fn id(&self, state: &str) -> BlockStateId { + parse_state_string(self.registry, state).unwrap() + } + fn decode(&self, processors: Value) -> Result { + let bindings = FeatureBlockBindings::new(self.registry, BTreeSet::new()).unwrap(); + ProcessorList::decode(&processors.to_string(), &self.resources, &bindings) + } + /// The block the list makes of template block `state` at `pos` of the + /// piece at `piece`, in a world of `world`: None when it is not placed. + fn run( + &self, + list: &ProcessorList, + world: (i64, &str), + piece: [i32; 3], + pos: [i32; 3], + state: &str, + ) -> Option { + let mut world = World { + seed: world.0, + block: self.id(world.1), + }; + let info = BlockInfo { + pos, + state: self.id(state), + nbt: None, + }; + let mut settings = PlaceSettings::new(Rotation::None); + process_list( + list, + &mut world, + &self.resources, + piece, + piece, + [0; 3], + info, + &mut settings, ) + .unwrap() + } + fn name(&self, info: Option) -> String { + match info { + None => "none".into(), + Some(info) => { + let s = self.registry.state(info.state).unwrap(); + let props: Vec = s + .properties + .iter() + .map(|(k, v)| format!("{k}={v}")) + .collect(); + match props.is_empty() { + true => s.name.clone(), + false => format!("{}[{}]", s.name, props.join(",")), + } + } + } + } + /// `name(run(...))` for one template block in an air world of seed 0. + fn out(&self, list: &ProcessorList, state: &str) -> String { + self.name(self.run(list, (0, "minecraft:air"), [0; 3], [0; 3], state)) + } + } + + fn swap(blocks: Value) -> Value { + json!({"processor_type": "lithostitched:block_swap", "blocks": blocks}) + } + fn set_block(provider: Value) -> Value { + json!({"processor_type": "lithostitched:set_block", "state_provider": provider}) + } + fn simple(name: &str) -> Value { + json!({"type": "minecraft:simple_state_provider", "state": {"id": name}}) + } + + #[test] + fn block_swap_keeps_the_properties_the_new_block_can_have() { + let t = Lists::new(&[]); + let list = t + .decode(json!([swap(json!({ + "minecraft:wheat": "minecraft:carrots", + "oak_stairs": "minecraft:warped_stairs", + "minecraft:cobblestone": "natures_spirit:missing"}))])) + .unwrap(); + assert_eq!( + t.out(&list, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&list, "minecraft:oak_stairs[facing=east,half=top]"), + "minecraft:warped_stairs[facing=east,half=top]" + ); + // A block the game lacks leaves the template's; others pass. + assert_eq!( + t.out(&list, "minecraft:cobblestone"), + "minecraft:cobblestone" + ); + assert_eq!( + t.out(&list, "minecraft:oak_log[axis=x]"), + "minecraft:oak_log[axis=x]" + ); + // Beetroots' age stops at 3: ripe wheat gives the default (spec-ctov §4). + let beet = t + .decode(json!([swap( + json!({"minecraft:wheat": "minecraft:beetroots"}) + )])) + .unwrap(); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=7]"), + "minecraft:beetroots[age=0]" + ); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=2]"), + "minecraft:beetroots[age=2]" ); } #[test] - fn per_piece_draws_once_per_piece() { - let p = json!({"processor_type": "lithostitched:apply_random"}); - let piece = Draws::decode(Some(&json!("per_piece")), &p).unwrap(); - let block = Draws::decode(None, &p).unwrap(); - let first = |d: Draws, pos| d.random(42, [0, 64, 0], pos).int(1 << 30); - assert_eq!(first(piece, [1, 64, 1]), first(piece, [9, 70, 3])); - assert_ne!(first(block, [1, 64, 1]), first(block, [9, 70, 3])); - // Another processor draws apart on the same block. - let other = - Draws::decode(None, &json!({"processor_type": "lithostitched:set_block"})).unwrap(); - assert_ne!(first(block, [1, 64, 1]), first(other, [1, 64, 1])); - assert!(Draws::decode(Some(&json!("per_structure")), &p).is_err()); + fn references_run_the_named_lists_in_turn() { + let t = Lists::new(&[ + ( + "t:logs", + json!({"processors": [swap(json!({"minecraft:oak_log": "minecraft:stripped_cherry_log"}))]}), + ), + ( + "t:stone", + json!([swap( + json!({"minecraft:stripped_cherry_log": "minecraft:cobblestone"}) + )]), + ), + ( + "t:discard", + json!([{"processor_type": "lithostitched:discard_input"}]), + ), + ]); + let reference = |lists: Value| json!([{"processor_type": "lithostitched:reference", "processor_lists": lists}]); + let one = t.decode(reference(json!("t:logs"))).unwrap(); + assert_eq!( + t.out(&one, "minecraft:oak_log[axis=x]"), + "minecraft:stripped_cherry_log[axis=x]" + ); + let both = t.decode(reference(json!(["t:logs", "t:stone"]))).unwrap(); + assert_eq!(t.out(&both, "minecraft:oak_log"), "minecraft:cobblestone"); + let reversed = t.decode(reference(json!(["t:stone", "t:logs"]))).unwrap(); + assert_eq!( + t.out(&reversed, "minecraft:oak_log"), + "minecraft:stripped_cherry_log[axis=y]" + ); + // discard_input: the template block is not placed, and the lists after it do not run. + let discard = t.decode(reference(json!(["t:discard", "t:logs"]))).unwrap(); + assert_eq!(t.out(&discard, "minecraft:oak_log"), "none"); + // The game has no processor list tags; unknown lists are errors. + assert!(t.decode(reference(json!(["#t:palettes"]))).is_err()); + assert!(t.decode(reference(json!("t:missing"))).is_err()); + } + + /// The probe pack's nested condition (spec-lithostitched §7.3): template + /// cobblestone becomes blackstone or deepslate, half each. + #[test] + fn conditions_run_then_or_else() { + let t = Lists::new(&[]); + let inner = json!({"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:random_chance", "chance": 0.5}, + "then": set_block(simple("minecraft:blackstone")), + "else": [set_block(simple("minecraft:deepslate"))]}); + let list = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], + "then": [inner]}])) + .unwrap(); + let mut counts = BTreeMap::::new(); + for i in 0..4000 { + let out = t.run( + &list, + (1234, "minecraft:air"), + [0; 3], + [i % 64, i / 64, 7], + "minecraft:cobblestone", + ); + *counts.entry(t.name(out)).or_default() += 1; + } + assert_eq!(counts.len(), 2, "{counts:?}"); + assert!( + (1850..2150).contains(&counts["minecraft:blackstone"]), + "{counts:?}" + ); + // Not cobblestone, and no `else`: the block as it is. + assert_eq!( + t.out(&list, "minecraft:oak_log"), + "minecraft:oak_log[axis=y]" + ); + + // `location` tests the world's block, with properties on the input. + let water = t + .decode( + json!([{"processor_type": "lithostitched:condition", "random_mode": "per_piece", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": ["minecraft:water"], + "match_type": "location"}, + "then": set_block(simple("minecraft:spruce_planks"))}]), + ) + .unwrap(); + let at = |world| { + t.name(t.run( + &water, + (0, world), + [0; 3], + [1, 2, 3], + "minecraft:cobblestone", + )) + }; + assert_eq!(at("minecraft:water"), "minecraft:spruce_planks"); + assert_eq!(at("minecraft:air"), "minecraft:cobblestone"); + let ripe = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": {"type": "lithostitched:all_of", "conditions": [ + {"type": "lithostitched:true"}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:wheat", "properties": {"age": "7"}}, + {"type": "lithostitched:not", "condition": {"type": "lithostitched:any_of", "conditions": [ + {"type": "lithostitched:random_chance", "chance": 0.0}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", "match_type": "location"}]}}]}, + "then": swap(json!({"minecraft:wheat": "minecraft:carrots"}))}])) + .unwrap(); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=6]"), + "minecraft:wheat[age=6]" + ); + let bad = json!([{"processor_type": "lithostitched:condition", "random_mode": "per_chunk", + "if_true": {"type": "lithostitched:true"}}]); + assert!(t.decode(bad).is_err()); + } + + /// `apply_random` (spec-lithostitched §7.3: crimson 1 : birch 3, one + /// choice per piece): here blackstone 1 : deepslate 3. + #[test] + fn apply_random_draws_per_piece_or_per_block() { + let t = Lists::new(&[( + "t:deepslate", + json!([swap( + json!({"minecraft:cobblestone": "minecraft:deepslate"}) + )]), + )]); + let random = |mode: &str| { + t.decode(json!([{"processor_type": "lithostitched:apply_random", "mode": mode, + "processor_lists": [ + {"weight": 1, "data": [swap(json!({"minecraft:cobblestone": "minecraft:blackstone"}))]}, + {"weight": 3, "data": "t:deepslate"}]}])) + .unwrap() + }; + let (per_piece, per_block) = (random("per_piece"), random("per_block")); + let outcomes = |list: &ProcessorList, seed: i64, piece: [i32; 3]| -> Vec { + (0..20) + .map(|i| { + let pos = [piece[0] + i, piece[1], piece[2] + 3 * i]; + t.name(t.run( + list, + (seed, "minecraft:air"), + piece, + pos, + "minecraft:cobblestone", + )) + }) + .collect() + }; + let mut blackstone_pieces = 0; + for p in 0..400 { + let piece = [16 * p, 70, -40 * p]; + let blocks = outcomes(&per_piece, 1234, piece); + assert!(blocks.iter().all(|b| *b == blocks[0]), "{blocks:?}"); + blackstone_pieces += u32::from(blocks[0] == "minecraft:blackstone"); + // The same piece and seed give the same blocks. + assert_eq!(outcomes(&per_piece, 1234, piece), blocks); + } + assert!( + (70..130).contains(&blackstone_pieces), + "{blackstone_pieces}" + ); + // Per block, one piece mixes both. + let mixed: BTreeSet = (0..10) + .flat_map(|p| outcomes(&per_block, 1234, [p, 0, 0])) + .collect(); + assert_eq!(mixed.len(), 2, "{mixed:?}"); + // A plain list: every entry weight 1. An entry list holding nothing is a no-op. + let plain = t + .decode( + json!([{"processor_type": "lithostitched:apply_random", "mode": "per_block", + "processor_lists": ["t:deepslate", []]}]), + ) + .unwrap(); + let seen: BTreeSet = (0..10) + .flat_map(|p| outcomes(&plain, 9, [p, 0, 0])) + .collect(); + assert_eq!( + seen, + BTreeSet::from(["minecraft:cobblestone".into(), "minecraft:deepslate".into()]) + ); } #[test] - fn set_block_draws_by_weight() { - let set = SetBlock::decode( - &json!({"processor_type": "lithostitched:set_block", "preserve_state": false, - "state_provider": {"type": "minecraft:weighted_state_provider", "entries": [ - {"weight": 1, "data": {"id": "minecraft:cobblestone"}}, - {"weight": 3, "data": {"id": "minecraft:water"}}]}}), - |v| { - Ok(BlockStateId(if v["id"] == "minecraft:water" { - 22 - } else { - 1 - })) - }, - ) - .unwrap(); - assert!(!set.preserve); - let water = (0..4000) - .filter(|x| { - set.state(&mut set.draws.random(7, [0; 3], [*x, 64, 0])) == BlockStateId(22) + fn set_block_runs_its_provider() { + let t = Lists::new(&[]); + let stairs = "minecraft:oak_stairs[facing=east,half=top]"; + let warped = |preserve: Value| { + let mut p = set_block(simple("minecraft:warped_stairs")); + if !preserve.is_null() { + p["preserve_state"] = preserve; + } + t.decode(json!([p])).unwrap() + }; + // preserve_state (true by default) keeps the properties both blocks have. + assert_eq!( + t.out(&warped(Value::Null), stairs), + "minecraft:warped_stairs[facing=east,half=top]" + ); + assert_eq!( + t.out(&warped(json!(false)), stairs), + "minecraft:warped_stairs[facing=north,half=bottom]" + ); + + let weighted = t + .decode(json!([set_block( + json!({"type": "minecraft:weighted_state_provider", "entries": [ + {"weight": 1, "data": {"id": "minecraft:blackstone"}}, + {"weight": 3, "data": {"id": "minecraft:deepslate"}}]}) + )])) + .unwrap(); + let blackstone = (0..2000) + .filter(|i| { + let out = t.run( + &weighted, + (42, "minecraft:air"), + [0; 3], + [*i, 0, -*i], + "minecraft:cobblestone", + ); + t.name(out) == "minecraft:blackstone" }) .count(); - assert!((2850..3150).contains(&water), "{water}"); - let unknown = json!({"state_provider": {"type": "minecraft:noise_provider"}}); - assert!(SetBlock::decode(&unknown, |_| Ok(BlockStateId(0))).is_err()); + assert!((420..580).contains(&blackstone), "{blackstone}"); + + // block_entity_modifier gives the output its block entity. + let mut loot = set_block(simple("minecraft:chest")); + loot["block_entity_modifier"] = + json!({"type": "minecraft:append_loot", "loot_table": "t:chests/house"}); + let out = t + .run( + &t.decode(json!([loot])).unwrap(), + (0, "minecraft:air"), + [0; 3], + [0; 3], + "minecraft:air", + ) + .unwrap(); + let table = out + .nbt + .as_ref() + .and_then(|n| n.get(&JavaString::from("LootTable"))); + assert_eq!(table, Some(&Tag::String("t:chests/house".into()))); + + // Providers the game does not run are refused. + assert!( + t.decode(json!([set_block( + json!({"type": "minecraft:noise_provider"}) + )])) + .is_err() + ); } } From bcd42f50e9592b11d7fe9444c8f9928ed1f1c786 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 15:55:55 +0100 Subject: [PATCH 4/9] cargo horizon-mod test: server mods' scripts A test script drives a server mod as a server would: join = "Alex" brings a player in (ids stable per name, so a rejoin is the same player), as = "Steve" picks who acts (the first player on otherwise), and player, chat, command, break and place are that player's doing; leave = "Alex" lets them go. Server expectations: told (every players.tell, "Name: text") and broadcast; feedback and error read the reply to the player who typed the command. Ticks call both kinds of tick hooks, so one script format serves client and server mods. The welcome example gets two scripts (greeting, a newcomer announced once even after a reload, /online across dimensions, /mined per player), run by the sandbox tests with coords-hud's; docs/mods.md lists the server keys. Co-Authored-By: Claude Opus 5.5 --- .../examples/welcome/tests/commands.toml | 31 +++ .../examples/welcome/tests/welcome.toml | 21 ++ crates/horizon-mods/src/testing.rs | 251 +++++++++++++++++- crates/horizon-mods/tests/sandbox.rs | 32 ++- docs/mods.md | 14 +- 5 files changed, 323 insertions(+), 26 deletions(-) create mode 100644 crates/horizon-mod-sdk/examples/welcome/tests/commands.toml create mode 100644 crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml new file mode 100644 index 000000000..5f0018346 --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml @@ -0,0 +1,31 @@ +# /online lists the players and their dimension; /mined counts the acting player's blocks. + +[[step]] +join = "Alex" +expect.commands = ["online", "mined"] + +[[step]] +join = "Steve" +as = "Steve" +player = { dimension = "minecraft:the_nether" } +command = "online" +expect.feedback = "Alex (overworld), Steve (the_nether)" + +[[step]] +as = "Alex" +break = { x = 1, y = 63, z = 0, state = "minecraft:stone" } + +[[step]] +as = "Alex" +break = { x = 2, y = 63, z = 0, state = "minecraft:dirt" } + +# A step's command comes before its break and place. +[[step]] +as = "Alex" +command = "mined" +expect.feedback = "You broke 2 block(s)" + +[[step]] +as = "Steve" +command = "mined" +expect.feedback = "You broke 0 block(s)" diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml b/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml new file mode 100644 index 000000000..c8a1836db --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml @@ -0,0 +1,21 @@ +# Joins are greeted; a newcomer is announced once, even after a reload (storage). + +[[step]] +join = "Alex" +expect.told = ["Alex: Welcome, Alex! 0 other player(s) online."] +expect.broadcast = ["Alex is here for the first time"] + +[[step]] +join = "Steve" +expect.told = ["Steve: Welcome, Steve! 1 other player(s) online."] +expect.broadcast = ["Steve is here for the first time"] + +[[step]] +leave = "Alex" +expect.told = [] + +[[step]] +reload = true +join = "Alex" +expect.told = ["Alex: Welcome, Alex! 1 other player(s) online."] +expect.broadcast = [] diff --git a/crates/horizon-mods/src/testing.rs b/crates/horizon-mods/src/testing.rs index 4fcb595a0..31ff27227 100644 --- a/crates/horizon-mods/src/testing.rs +++ b/crates/horizon-mods/src/testing.rs @@ -2,10 +2,14 @@ //! //! [`TestGame`] loads one `.hmod` from a scratch copy (its `storage` lives and //! dies with the run) into the same sandbox the game uses, and plays the game's -//! part: the snapshot, ticks, frames, chat lines and commands. [`Script`] is a +//! part: the snapshot, ticks, frames, chat lines and commands, and for a +//! server mod the players joining, leaving, chatting and breaking or placing +//! blocks. [`Script`] is a //! test written in TOML, `tests/.toml` in the mod's folder: steps, each //! saying what happens and what the mod must have shown by then. -use crate::{Clock, Corner, Mods, Output, Panel, Player, Snapshot, Status}; +use crate::{ + BlockPos, Clock, Corner, GameMode, Mods, Output, Panel, Player, ServerPlayer, Snapshot, Status, +}; use serde::Deserialize; use std::{ path::{Path, PathBuf}, @@ -20,6 +24,10 @@ pub struct TestGame { /// What the mod reads with `game-read`; ticks move the clock as the game does. pub player: Option, pub clock: Option, + /// The players on the server, for a server mod, in join order. + pub players: Vec, + /// Every name that joined, for their id. + names: Vec, tick: u64, } @@ -60,6 +68,8 @@ impl TestGame { game_time: 0, day_time: 0, }), + players: Vec::new(), + names: Vec::new(), tick: 0, }; copy_mod(hmod, ©)?; @@ -87,9 +97,13 @@ impl TestGame { self.mods.set_snapshot(Snapshot { player: self.player.clone(), clock: self.clock, - ..Snapshot::default() + players: self.players.clone(), }); } + /// Whether the mod is a server mod. + pub fn server(&self) -> bool { + self.mods.runs_server() + } /// `n` game ticks; each moves the clock one tick on, as the game does. pub fn tick(&mut self, n: u64) { @@ -101,6 +115,7 @@ impl TestGame { } self.snapshot(); self.mods.tick(self.tick); + self.mods.server_tick(self.tick); } } /// `n` frames, 1/60 s apart. @@ -122,13 +137,76 @@ impl TestGame { self.mods.command(line) } + /// A player named `name` joins the server, standing where a script starts + /// in survival. Their id is `00000000-0000-4000-8000-000000000001` for + /// the first name that joined, `...0002` for the second, and so on. + pub fn join(&mut self, name: &str) -> ServerPlayer { + let n = match self.names.iter().position(|n| n == name) { + Some(i) => i + 1, + None => { + self.names.push(name.to_owned()); + self.names.len() + } + }; + let p = default_player(); + let player = ServerPlayer { + id: format!("00000000-0000-4000-8000-{n:012x}"), + name: name.to_owned(), + x: p.x, + y: p.y, + z: p.z, + dimension: p.dimension, + game_mode: GameMode::Survival, + health: p.health, + }; + self.players.push(player.clone()); + self.snapshot(); + self.mods.player_joined(&player); + player + } + /// The player named `name` leaves; false when no such player is on. + pub fn leave(&mut self, name: &str) -> bool { + let Some(i) = self.players.iter().position(|p| p.name == name) else { + return false; + }; + let player = self.players.remove(i); + self.snapshot(); + self.mods.player_left(&player); + true + } + /// A chat message `player` sends, for a server mod. + pub fn player_chat(&mut self, player: &ServerPlayer, line: &str) { + self.snapshot(); + self.mods.player_chat(player, line); + } + /// `/line` typed by `player`, for a server mod; false when the mod owns + /// no such command. + pub fn player_command(&mut self, player: &ServerPlayer, line: &str) -> bool { + self.snapshot(); + self.mods.server_command(player, line) + } + /// `player` breaks (or places) `state` at `pos`. + pub fn block(&mut self, player: &ServerPlayer, pos: BlockPos, state: &str, placed: bool) { + self.snapshot(); + if placed { + self.mods.block_placed(player, pos, state); + } else { + self.mods.block_broken(player, pos, state); + } + } + /// The scratch copy the mod runs from; its `storage` is beside it. pub fn hmod(&self) -> &Path { &self.hmod } /// The commands the mod registered. pub fn commands(&self) -> Vec { - self.mods.commands().map(str::to_owned).collect() + let server = self.mods.server_commands(); + self.mods + .commands() + .chain(server) + .map(str::to_owned) + .collect() } pub fn panel(&self) -> Option<&Panel> { self.mods.panels().next() @@ -164,7 +242,7 @@ fn copy_mod(from: &Path, to: &Path) -> Result<(), String> { Ok(()) } -/// A test in TOML: where the player starts, then steps run in order. +/// A test in TOML: where a client mod's player starts, then steps run in order. #[derive(Debug, Default, Deserialize)] #[serde(deny_unknown_fields, rename_all = "kebab-case")] pub struct Script { @@ -176,9 +254,11 @@ pub struct Script { pub steps: Vec, } -/// Fields of the player to change; the others keep their values. +/// Fields of the player to change; the others keep their values. A server +/// mod's players have no `yaw`, `pitch` or `food`, and a client mod's player +/// no `game-mode`. #[derive(Debug, Default, Deserialize)] -#[serde(deny_unknown_fields)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] pub struct PlayerSet { x: Option, y: Option, @@ -188,6 +268,37 @@ pub struct PlayerSet { health: Option, food: Option, dimension: Option, + game_mode: Option, +} + +/// `players.game-mode` as a script spells it. +#[derive(Clone, Copy, Debug, Deserialize)] +#[serde(rename_all = "lowercase")] +enum Mode { + Survival, + Creative, + Adventure, + Spectator, +} +impl From for GameMode { + fn from(m: Mode) -> GameMode { + match m { + Mode::Survival => GameMode::Survival, + Mode::Creative => GameMode::Creative, + Mode::Adventure => GameMode::Adventure, + Mode::Spectator => GameMode::Spectator, + } + } +} + +/// A block a player breaks or places. +#[derive(Debug, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct BlockSet { + x: i32, + y: i32, + z: i32, + state: String, } #[derive(Debug, Default, Deserialize)] @@ -198,8 +309,11 @@ pub struct ClockSet { } /// One step. Its parts happen in this order: `reload`, `title-screen`, -/// `player`, `clock`, `ticks`, `frames`, `chat`, `command`; then `expect` is -/// checked against what the mod showed during the step. +/// `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`, `break`, +/// `place`, `leave`; then `expect` is checked against what the mod showed +/// during the step. For a server mod, `player`, `chat`, `command`, `break` +/// and `place` are the doing of the player named by `as`, or of the first +/// player on. #[derive(Debug, Default, Deserialize)] #[serde(deny_unknown_fields, rename_all = "kebab-case")] pub struct Step { @@ -216,6 +330,14 @@ pub struct Step { frames: u64, chat: Option, command: Option, + /// Server mods: a player joins, leaves, breaks or places a block. + join: Option, + leave: Option, + #[serde(rename = "as")] + actor: Option, + #[serde(rename = "break")] + broken: Option, + place: Option, #[serde(default)] expect: Expect, } @@ -231,6 +353,10 @@ pub struct Expect { /// The command's feedback, and its red error. feedback: Option, error: Option, + /// Server mods: every `players.tell` as `"Name: text"`, and every + /// `players.broadcast`, in order. + told: Option>, + broadcast: Option>, /// The panel's lines (`[]`: no panel) and its corner. panel: Option>, corner: Option, @@ -274,6 +400,17 @@ impl PlayerSet { p.dimension.clone_from(d); } } + fn apply_server(&self, p: &mut ServerPlayer) { + let set = |to: &mut f64, v: Option| *to = v.unwrap_or(*to); + set(&mut p.x, self.x); + set(&mut p.y, self.y); + set(&mut p.z, self.z); + p.health = self.health.unwrap_or(p.health); + p.game_mode = self.game_mode.map_or(p.game_mode, GameMode::from); + if let Some(d) = &self.dimension { + p.dimension.clone_from(d); + } + } } impl ClockSet { @@ -302,6 +439,17 @@ impl Step { if let Some(line) = &self.command { parts.push(format!("/{line}")); } + if let Some(name) = &self.join { + parts.insert(0, format!("{name} joins")); + } + for (what, b) in [("breaks", &self.broken), ("places", &self.place)] { + if let Some(b) = b { + parts.push(format!("{what} {} at {} {} {}", b.state, b.x, b.y, b.z)); + } + } + if let Some(name) = &self.leave { + parts.push(format!("{name} leaves")); + } if parts.is_empty() { parts.push("checks".into()); } @@ -316,8 +464,35 @@ impl Step { game.player = None; game.clock = None; } + if let Some(name) = &self.join { + game.join(name); + } + let server = game.server(); + let actor = |game: &TestGame| match &self.actor { + Some(name) => game + .players + .iter() + .position(|p| p.name == *name) + .ok_or_else(|| format!("{name} is not on the server")), + None => (!game.players.is_empty()) + .then_some(0) + .ok_or_else(|| "no player is on the server: add join = \"Name\"".to_string()), + }; + let acts = self.player.is_some() + || self.chat.is_some() + || self.command.is_some() + || self.broken.is_some() + || self.place.is_some(); + let actor = if server && acts { + Some(actor(game)?) + } else { + None + }; if let Some(set) = &self.player { - set.apply(game.player.get_or_insert_with(default_player)); + match actor { + Some(i) => set.apply_server(&mut game.players[i]), + None => set.apply(game.player.get_or_insert_with(default_player)), + } } if let Some(set) = &self.clock { set.apply(game.clock.get_or_insert(Clock { @@ -327,10 +502,32 @@ impl Step { } game.tick(self.ticks); game.frames(self.frames); + let who = actor.map(|i| game.players[i].clone()); if let Some(line) = &self.chat { - game.chat(line); + match &who { + Some(p) => game.player_chat(p, line), + None => game.chat(line), + } + } + let owned = self.command.as_ref().map(|line| match &who { + Some(p) => game.player_command(p, line), + None => game.command(line), + }); + for (b, placed) in [(&self.broken, false), (&self.place, true)] { + if let (Some(b), Some(p)) = (b, &who) { + let pos = BlockPos { + x: b.x, + y: b.y, + z: b.z, + }; + game.block(p, pos, &b.state, placed); + } + } + if let Some(name) = &self.leave + && !game.leave(name) + { + return Err(format!("{name} is not on the server")); } - let owned = self.command.as_ref().map(|line| game.command(line)); let out = game.drain(); let stopped = out.iter().find_map(|o| match o { Output::Stopped { reason, .. } => Some(reason.as_str()), @@ -370,10 +567,38 @@ impl Step { } let feedback = |error: bool| { out.iter().rev().find_map(|o| match o { - Output::Feedback { text, error: e } if *e == error => Some(text.clone()), + Output::Feedback { text, error: e } | Output::Reply { text, error: e, .. } + if *e == error => + { + Some(text.clone()) + } _ => None, }) }; + if let Some(want) = &e.told { + let name = |id: &str| { + let p = game.players.iter().find(|p| p.id == id); + p.map_or(id.to_owned(), |p| p.name.clone()) + }; + let got: Vec = out + .iter() + .filter_map(|o| match o { + Output::Tell { player, text, .. } => Some(format!("{}: {text}", name(player))), + _ => None, + }) + .collect(); + same("told", want, &got)?; + } + if let Some(want) = &e.broadcast { + let got: Vec = out + .iter() + .filter_map(|o| match o { + Output::Broadcast { text, .. } => Some(text.clone()), + _ => None, + }) + .collect(); + same("broadcast", want, &got)?; + } if let Some(want) = &e.feedback { same("feedback", &Some(want.clone()), &feedback(false))?; } diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index dd74591d6..ca2b8896e 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -407,22 +407,23 @@ capabilities = ["registries"] assert!(!mods.is_running()); } -/// `cargo horizon-mod test` on the example: its own `tests/*.toml` pass. +/// `cargo horizon-mod test` on the examples: their own `tests/*.toml` pass. #[test] fn the_examples_test_scripts_pass() { - let tests = - Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples/coords-hud/tests"); + let examples = Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples"); let mut ran = 0; - for entry in std::fs::read_dir(tests).unwrap() { - let path = entry.unwrap().path(); - let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap(); - let mut game = TestGame::load(&mods_dir().join("coords_hud.hmod")).unwrap(); - script - .run(&mut game) - .unwrap_or_else(|e| panic!("{}: {e}", path.display())); - ran += 1; + for (example, hmod) in [("coords-hud", "coords_hud"), ("welcome", "welcome")] { + for entry in std::fs::read_dir(examples.join(example).join("tests")).unwrap() { + let path = entry.unwrap().path(); + let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap(); + let mut game = TestGame::load(&mods_dir().join(format!("{hmod}.hmod"))).unwrap(); + script + .run(&mut game) + .unwrap_or_else(|e| panic!("{}: {e}", path.display())); + ran += 1; + } } - assert_eq!(ran, 2); + assert_eq!(ran, 4); } #[test] @@ -446,6 +447,13 @@ fn a_test_script_says_which_step_failed_and_why() { Script::parse("[[step]]\ntick = 1").is_err(), "a typo is an error" ); + + let mut game = TestGame::load(&mods_dir().join("welcome.hmod")).unwrap(); + let script = "[[step]]\njoin = \"Alex\"\n\n[[step]]\nas = \"Steve\"\ncommand = \"mined\""; + assert_eq!( + Script::parse(script).unwrap().run(&mut game).unwrap_err(), + "step 2 (/mined): Steve is not on the server" + ); } #[test] diff --git a/docs/mods.md b/docs/mods.md index ffe64e88e..6a095adba 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -244,7 +244,8 @@ key> --signature .minisig`. `cargo horizon-mod test` builds the mod, then runs each `tests/.toml` in the sandbox the game uses, with no game and no window: the test plays the game's part (the player and the clock the mod reads, ticks, frames, chat lines, -commands) and checks what the mod showed. A script fails at its first wrong +commands; for a server mod, players joining, chatting, typing commands, +breaking and placing blocks and leaving) and checks what the mod showed. A script fails at its first wrong step, with what it expected and what it got; the command fails if any script does. `--debug` builds without optimizing, `--hmod ` tests a `.hmod` already built, and a name runs only the scripts whose path holds it. Each @@ -281,6 +282,16 @@ A step's parts happen in this order: | `ticks = n`, `frames = n` | that many ticks (the game's tick counter and the clock move on), then frames 1/60 s apart | | `chat = " hi"` | a chat line the player receives | | `command = "where north"` | the player types `/where north`; a command the mod doesn't own fails the step | +| `break = { x = 1, y = 63, z = 0, state = "minecraft:stone" }`, `place = { ... }` | server mods: the player breaks or places that block | +| `leave = "Alex"` | server mods: that player leaves | + +A server mod starts with nobody on: `join = "Alex"` (after `reload` and `title-screen`) brings a +player in at the defaults, in survival, with the id +`00000000-0000-4000-8000-000000000001` for the first name that joined, `...2` +for the second, the same id when a name joins again. `player`, `chat`, +`command`, `break` and `place` are then that player's doing: the one named by +`as = "Steve"`, or the first one on. `player` takes `game-mode` there, and the +script's own `[player]` and `[clock]` are a client mod's. Then `expect` checks what the mod did during the step; a key left out is not checked: @@ -291,6 +302,7 @@ checked: | `chat = ["..."]` | every chat line it showed, in order (`[]`: none) | | `feedback = "..."`, `error = "..."` | the command's answer, shown plain or in red | | `panel = ["..."]`, `corner = "top-left"` | its HUD panel's lines (`[]`: no panel) and corner | +| `told = ["Alex: Welcome!"]`, `broadcast = ["..."]` | server mods: every `players.tell` (as `name: text`) and `players.broadcast`, in order | | `stopped = "panic"` | the mod was turned off, for a reason holding this text; without it, a mod that traps, panics or overruns fails the test | Unknown keys are errors, so a typo never passes silently. The same runner is From 8cc8c6180d729d345d41d4bc0093d8108ca5c730 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:38:57 +0100 Subject: [PATCH 5/9] Mod API levels: refuse a mod made for a newer Horizon, list each version's level Every function the game offers mods has the API level it arrived at (crates/horizon-mods/src/api_level.rs): level 0 is the contract of Horizon 0.2.67 and 0.2.68, level 1 adds render.set-minimap. A mod needs the level of the newest function it imports, read from its component. - The game refuses a mod that calls a function it doesn't have with "made for a newer Horizon (it uses ...): update Horizon to run it" instead of wasmtime's linking error. - The registry index lists each mod version's level (api_level, read from the file by CI); check_file compares it when the entry has one, and the moved extras' installer takes the newest version this game can run. - cargo horizon-mod check prints the level. - The api_reference test fails until a new WIT function has a level. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 24 +++ crates/cargo-horizon-mod/src/check.rs | 4 + crates/horizon-client/src/moved_extras.rs | 22 +-- crates/horizon-mods/Cargo.toml | 11 +- crates/horizon-mods/src/api_level.rs | 151 ++++++++++++++++++ crates/horizon-mods/src/index.rs | 33 +++- crates/horizon-mods/src/index/registry.rs | 1 + crates/horizon-mods/src/index/tests.rs | 33 ++++ crates/horizon-mods/src/lib.rs | 1 + crates/horizon-mods/src/runtime.rs | 6 + crates/horizon-mods/tests/api_reference.rs | 35 ++++ crates/horizon-mods/tests/index/index-v1.json | 1 + crates/horizon-mods/tests/sandbox.rs | 59 +++++++ docs/api/mod-index.md | 6 +- docs/api/stability.md | 16 ++ docs/mods.md | 6 + launcher/Cargo.lock | 19 +++ 17 files changed, 412 insertions(+), 16 deletions(-) create mode 100644 crates/horizon-mods/src/api_level.rs diff --git a/Cargo.lock b/Cargo.lock index ae1738593..db77c7d35 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1443,6 +1443,7 @@ dependencies = [ "serde_json", "sha2", "toml", + "wasmparser", "wasmtime", "wit-component", "wit-parser", @@ -4147,6 +4148,28 @@ dependencies = [ "wit-parser", ] +[[package]] +name = "wast" +version = "254.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0" +dependencies = [ + "bumpalo", + "leb128fmt", + "memchr", + "unicode-width", + "wasm-encoder", +] + +[[package]] +name = "wat" +version = "1.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e" +dependencies = [ + "wast", +] + [[package]] name = "wayland-backend" version = "0.3.17" @@ -5005,6 +5028,7 @@ dependencies = [ "wasm-encoder", "wasm-metadata", "wasmparser", + "wat", "wit-parser", ] diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs index cf2968858..6e6913058 100644 --- a/crates/cargo-horizon-mod/src/check.rs +++ b/crates/cargo-horizon-mod/src/check.rs @@ -46,6 +46,7 @@ impl Report { "api": self.facts.api, "side": self.facts.side, "capabilities": self.facts.capabilities, + "api_level": self.facts.api_level, "game": self.facts.game, "requires": requires, "sha256": self.sha256, @@ -84,6 +85,9 @@ impl Report { ")\n {} bytes, SHA-256 {}, {signed}\n", self.size, self.sha256 ); + if let Some(level) = f.api_level { + out += &format!(" needs mod API level {level} or newer\n"); + } for c in &f.capabilities { out += &format!(" may {}\n", c.describe()); } diff --git a/crates/horizon-client/src/moved_extras.rs b/crates/horizon-client/src/moved_extras.rs index 3b5db6fbc..ce949047d 100644 --- a/crates/horizon-client/src/moved_extras.rs +++ b/crates/horizon-client/src/moved_extras.rs @@ -149,21 +149,21 @@ pub fn fetch_index() -> Result { /// Installs `m` into the game folder `dir` (where `options.txt` is), for a /// player whose extras were `e`: its newest version for this game that -/// wasn't taken down, checked against the index (size, SHA-256, signature, -/// manifest), as `horizon-mods/.hmod`, turned on, with the extra's -/// settings in its storage unless the mod has its own already. +/// wasn't taken down and that this Horizon's mod API level runs, checked +/// against the index (size, SHA-256, signature, manifest), as +/// `horizon-mods/.hmod`, turned on, with the extra's settings in its +/// storage unless the mod has its own already. pub fn install(index: &Index, m: &Moved, e: &Extras, dir: &Path) -> Result<(), String> { let project = index .project(m.id) .ok_or_else(|| format!("{} isn't in Horizon's registry yet", m.id))?; - let version = project - .versions - .iter() - .find(|v| { - v.game == horizon_core::version::VERSION_ID - && index.revoked(&project.id, &v.file.sha256).is_none() - }) - .ok_or_else(|| format!("{} has no version for this game", m.id))?; + let version = index + .installable( + project, + horizon_core::version::VERSION_ID, + horizon_mods::api_level::LEVEL, + ) + .ok_or_else(|| format!("{} has no version this Horizon can run", m.id))?; let mods = dir.join(crate::mod_list::DIR); fs::create_dir_all(&mods).map_err(|e| format!("{}: {e}", mods.display()))?; let target = mods.join(format!("{}.hmod", m.id)); diff --git a/crates/horizon-mods/Cargo.toml b/crates/horizon-mods/Cargo.toml index a398e4d8b..bbe8f2572 100644 --- a/crates/horizon-mods/Cargo.toml +++ b/crates/horizon-mods/Cargo.toml @@ -17,18 +17,25 @@ wasmtime = { version = "48.0.7", default-features = false, features = ["runtime" # Turns a mod's core module into a component (cargo horizon-mod build, the tests). wit-component = { version = "0.254", optional = true } wit-parser = { version = "0.254", optional = true } +# The functions a mod imports, for its API level (src/api_level.rs): the game and the registry index. +wasmparser = { version = "0.254", optional = true } # The registry index's checks (feature `index`): SHA-256, and minisign signatures (no dependencies of its own). sha2 = { version = "0.10", optional = true } minisign-verify = { version = "0.3", optional = true } +[dev-dependencies] +# A component made for a newer Horizon, from the WIT alone (tests/sandbox.rs). +wit-component = { version = "0.254", features = ["dummy-module"] } +wit-parser = "0.254" + [features] # Loads and runs mods (the game's `mods` feature); without it only manifests, # content and packaging. Off by default so builds that don't run mods (the # game's tests and probes) skip wasmtime and cranelift. -runtime = ["dep:wasmtime"] +runtime = ["dep:wasmtime", "dep:wasmparser"] pack = ["dep:wit-component", "dep:wit-parser"] # The mod registry's index (docs/api/mod-index.md): the launcher, the registry server and its CI. -index = ["dep:sha2", "dep:minisign-verify"] +index = ["dep:sha2", "dep:minisign-verify", "dep:wasmparser"] # Runs real mods: `cargo test -p horizon-mods --features runtime,pack`. [[test]] diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs new file mode 100644 index 000000000..a81cf27bc --- /dev/null +++ b/crates/horizon-mods/src/api_level.rs @@ -0,0 +1,151 @@ +//! Mod API levels: which of the WIT contract's functions a Horizon has +//! (`docs/api/stability.md`). Every function the game offers mods has the +//! level it arrived at; a Horizon serves every level up to its [`LEVEL`]. +//! A mod needs the level of the newest function it imports, so a mod that +//! calls a function this Horizon doesn't have is refused with "update +//! Horizon" instead of a linking error, and the registry lists each +//! version's level so the launcher can tell before it installs. + +/// The newest level this Horizon serves. +pub const LEVEL: u32 = 1; + +/// Every function the game offers mods, as `interface.function`, with its +/// level. Level 0 is the contract of Horizon 0.2.67 and 0.2.68. A new +/// function takes the next level and raises [`LEVEL`] (the `api_reference` +/// test fails until it is listed here). +pub const FUNCTIONS: [(&str, u32); 29] = [ + ("log.write", 0), + ("game.get-player", 0), + ("game.get-clock", 0), + ("chat.show", 0), + ("hud.set-panel", 0), + ("hud.clear", 0), + ("storage.get", 0), + ("storage.set", 0), + ("storage.delete", 0), + ("command.run", 0), + ("ui.open-screen", 0), + ("ui.close-screen", 0), + ("ui.set-settings", 0), + ("input.claim-items", 0), + ("input.register-key", 0), + ("input.held", 0), + ("input.poll", 0), + ("input.claim-wheel", 0), + ("input.mapping", 0), + ("input.clicks-per-second", 0), + ("render.set-hud", 0), + ("render.gui-size", 0), + ("render.shake", 0), + ("render.set-corner", 0), + ("render.clear-corner", 0), + ("render.text-width", 0), + ("render.frame-stats", 0), + ("render.set-zoom", 0), + ("render.set-minimap", 1), +]; + +/// A function's level; None for one this Horizon doesn't have. +pub fn level_of(function: &str) -> Option { + FUNCTIONS + .iter() + .find(|(name, _)| *name == function) + .map(|&(_, level)| level) +} + +/// The level a mod needs, from the functions it imports (as [`imports`] +/// names them): its newest function's. A function this Horizon doesn't +/// know comes from a newer one, so it needs more than [`LEVEL`]; that +/// function is returned with it, for the message. +pub fn needed<'a>(imports: impl IntoIterator) -> (u32, Option<&'a str>) { + let mut needed = (0, None); + for name in imports { + match level_of(name) { + Some(level) if level > needed.0 => needed = (level, Some(name)), + Some(_) => {} + None => return (LEVEL + 1, Some(name)), + } + } + needed +} + +/// Why this Horizon can't run a mod that needs `level`, or None when it can. +pub fn too_new(level: u32, function: Option<&str>) -> Option { + (level > LEVEL).then(|| { + let uses = function.map_or(String::new(), |f| format!(" (it uses {f})")); + format!("made for a newer Horizon{uses}: update Horizon to run it") + }) +} + +/// The functions a mod's component imports from Horizon (`horizon:mods/*`), +/// as `interface.function`, in the component's order. +#[cfg(any(feature = "runtime", feature = "index"))] +pub fn imports(wasm: &[u8]) -> Result, String> { + use wasmparser::{ + Parser, Payload, Validator, WasmFeatures, component_types::ComponentEntityType, + }; + let types = Validator::new_with_features(WasmFeatures::all()) + .validate_all(wasm) + .map_err(|e| format!("not a component: {e}"))?; + let types = types.as_ref(); + let mut out = Vec::new(); + for payload in Parser::new(0).parse_all(wasm) { + let Payload::ComponentImportSection(section) = payload.map_err(|e| e.to_string())? else { + continue; + }; + for import in section { + let name = import.map_err(|e| e.to_string())?.name.name; + // `horizon:mods/render@0.1.0` → `render`. + let Some(interface) = name.strip_prefix("horizon:mods/") else { + continue; + }; + let interface = interface.split('@').next().unwrap_or(interface); + let Some(item) = types.component_item_for_import(name) else { + continue; + }; + if let ComponentEntityType::Instance(id) = item.ty { + for (function, export) in &types[id].exports { + if matches!(export.ty, ComponentEntityType::Func(_)) { + out.push(format!("{interface}.{function}")); + } + } + } + } + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn levels_are_listed_once_and_up_to_this_horizons() { + for (i, (name, level)) in FUNCTIONS.iter().enumerate() { + assert!(*level <= LEVEL, "{name}"); + assert!( + FUNCTIONS[..i].iter().all(|(other, _)| other != name), + "{name} twice" + ); + } + assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL)); + } + + #[test] + fn a_mod_needs_its_newest_function() { + assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None)); + assert_eq!( + needed(["log.write", "render.set-minimap", "hud.clear"]), + (1, Some("render.set-minimap")) + ); + assert_eq!( + needed(["render.set-minimap", "render.set-sky"]), + (LEVEL + 1, Some("render.set-sky")) + ); + assert_eq!(too_new(LEVEL, None), None); + assert_eq!( + too_new(LEVEL + 1, Some("render.set-sky")).as_deref(), + Some("made for a newer Horizon (it uses render.set-sky): update Horizon to run it") + ); + } +} diff --git a/crates/horizon-mods/src/index.rs b/crates/horizon-mods/src/index.rs index db860fd9f..f7716eefa 100644 --- a/crates/horizon-mods/src/index.rs +++ b/crates/horizon-mods/src/index.rs @@ -137,6 +137,11 @@ pub struct Version { pub side: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub capabilities: Vec, + /// The mod API level a mod's code needs ([`crate::api_level`]), read + /// from its file; none for content and other kinds, and in indexes + /// built before levels. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub api_level: Option, /// The Minecraft version it is for. pub game: String, /// A modpack's mods, as its manifest lists them. @@ -316,6 +321,21 @@ impl Index { Ok(()) } + /// A project's newest version for Minecraft `game` that wasn't taken + /// down and that a Horizon serving mod API `level` can run (an unknown + /// level counts as runnable: the game still checks when it starts it). + pub fn installable<'a>( + &self, + project: &'a Project, + game: &str, + level: u32, + ) -> Option<&'a Version> { + project.versions.iter().find(|v| { + v.game == game + && v.api_level.is_none_or(|l| l <= level) + && self.revoked(&project.id, &v.file.sha256).is_none() + }) + } pub fn project(&self, id: &str) -> Option<&Project> { self.projects.iter().find(|p| p.id == id) } @@ -471,6 +491,8 @@ pub struct Facts { pub side: Option, /// In the manifest's order. pub capabilities: Vec, + /// The mod API level a mod's code needs, from the functions it imports. + pub api_level: Option, /// The Minecraft version, when the file names one (a modpack does). pub game: Option, pub requires: Vec, @@ -487,6 +509,7 @@ impl Facts { || self.api != version.api || self.side != version.side || caps != listed + || version.api_level.is_some() && self.api_level != version.api_level || self.game.as_ref().is_some_and(|g| *g != version.game) || self.requires != version.requires; if !differs { @@ -514,9 +537,17 @@ impl Facts { pub fn inspect(kind: &Kind, path: &Path) -> Result { match kind { Kind::Mod => { - let m = Package::read(path)?.manifest; + let Package { manifest: m, wasm } = Package::read(path)?; crate::Content::read(path, &m)?; + let api_level = match wasm { + Some(wasm) => { + let functions = crate::api_level::imports(&wasm)?; + Some(crate::api_level::needed(functions.iter().map(String::as_str)).0) + } + None => None, + }; Ok(Facts { + api_level, capabilities: m.capabilities, id: Some(m.id), version: Some(m.version), diff --git a/crates/horizon-mods/src/index/registry.rs b/crates/horizon-mods/src/index/registry.rs index 21b5de9fb..90453c621 100644 --- a/crates/horizon-mods/src/index/registry.rs +++ b/crates/horizon-mods/src/index/registry.rs @@ -283,6 +283,7 @@ fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result = package + .worlds + .values() + .flat_map(|&w| resolve.worlds[w].exports.values()) + .filter_map(|item| match item { + WorldItem::Interface { id, .. } => Some(*id), + _ => None, + }) + .collect(); + let mut offered = Vec::new(); + for (name, &id) in &package.interfaces { + if !exported.contains(&id) { + for function in resolve.interfaces[id].functions.keys() { + offered.push(format!("{name}.{function}")); + } + } + } + for f in &offered { + assert!( + horizon_mods::api_level::level_of(f).is_some(), + "{f} has no level in crates/horizon-mods/src/api_level.rs: add it at the next level" + ); + } + for (f, _) in horizon_mods::api_level::FUNCTIONS { + assert!(offered.iter().any(|o| o == f), "{f} isn't in the WIT"); + } +} diff --git a/crates/horizon-mods/tests/index/index-v1.json b/crates/horizon-mods/tests/index/index-v1.json index 215c94667..95ac938b7 100644 --- a/crates/horizon-mods/tests/index/index-v1.json +++ b/crates/horizon-mods/tests/index/index-v1.json @@ -29,6 +29,7 @@ "hud", "chat" ], + "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index 0be4fa47d..b7389ca29 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -193,6 +193,65 @@ fn undeclared_capabilities_are_refused() { assert_eq!(mods.entries()[0].status, refused); } +/// A mod calling a function this Horizon doesn't have is refused with +/// "update Horizon", not a linking error; the test mods' levels are read +/// from the functions they import. +#[test] +fn a_mod_for_a_newer_horizon_is_refused() { + use horizon_mods::api_level::{LEVEL, imports, needed}; + use wit_parser::{ManglingAndAbi, Resolve}; + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit")) + .unwrap() + .replace( + " set-minimap: func(minimap: option);", + " set-minimap: func(minimap: option);\n set-sky: func(on: bool);", + ); + let mut resolve = Resolve::default(); + let package = resolve.push_str("horizon.wit", &wit).unwrap(); + let world = resolve + .select_world(&[package], Some("horizon-ui-mod")) + .unwrap(); + let mut module = wit_component::dummy_module(&resolve, world, ManglingAndAbi::Standard32); + wit_component::embed_component_metadata( + &mut module, + &resolve, + world, + wit_component::StringEncoding::UTF8, + ) + .unwrap(); + let wasm = wit_component::ComponentEncoder::default() + .module(&module) + .unwrap() + .encode() + .unwrap(); + let functions = imports(&wasm).unwrap(); + assert!(functions.iter().any(|f| f == "render.set-sky")); + let dir = mods_dir().join("too_new"); + std::fs::create_dir_all(&dir).unwrap(); + let manifest = r#" +id = "too_new" +name = "Too New" +version = "0.1.0" +api = "0.1" +capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"] +experimental = ["ui", "render", "input"] +"#; + std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap(); + std::fs::write(dir.join("mod.wasm"), wasm).unwrap(); + let mods = Mods::load(&[dir], |_| true, |_| false); + let refused = "made for a newer Horizon (it uses render.set-sky): update Horizon to run it"; + assert_eq!(mods.entries()[0].status, Status::Failed(refused.into())); + + let level = |file: &str| { + let wasm = Package::read(&mods_dir().join(file)).unwrap().wasm.unwrap(); + needed(imports(&wasm).unwrap().iter().map(String::as_str)).0 + }; + assert_eq!(level("coords_hud.hmod"), 0); + // The UI guest shows a minimap (`render.set-minimap`). + assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL); +} + #[test] fn vanilla_commands_win() { let mods = Mods::load( diff --git a/docs/api/mod-index.md b/docs/api/mod-index.md index 6b807d950..46191198a 100644 --- a/docs/api/mod-index.md +++ b/docs/api/mod-index.md @@ -21,7 +21,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. "license": "MIT", "source": "https://github.com/...", "icon": "https://...png", "key": "RWT...", "versions": [{ "version": "0.1.0", "published": "2026-10-24", "changelog": "", - "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "game": "26.3", + "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", "url": "https://github.com/ludovic111/horizon-mods/releases/download/...", "size": 438, "sha256": "e113...", "signature": "untrusted comment: ...\n...\ntrusted comment: ...\n...\n" } }] @@ -43,6 +43,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. | `versions` | Newest first, at least one. | | `api` | A mod's API line (its manifest's `api`); a modpack's manifest format (`1`). | | `side`, `capabilities` | A mod's, read from its manifest by CI, never typed by hand. | +| `api_level` | The mod API level a mod's code needs ([stability.md](stability.md#mod-api-levels)): its newest imported function's, read from the file by CI. Absent for content-only mods and in indexes built before levels. Installers take the newest version whose level the running game serves. | | `game` | The Minecraft version it is for. | | `requires` | A modpack's mods: `{ id, version, sha256 }`, each a version in this index with that hash. | | `file` | A plain name with the kind's extension (`.hmod`, `.hpack`, `.zip`), an `https://` URL, the size (at most 64 MiB), the lowercase hex SHA-256, and the `.minisig` text when the project has a key. | @@ -57,7 +58,8 @@ changing what one means, makes schema 2. 1. Its size and SHA-256 are the ones the entry lists, and it isn't revoked. 2. With a project key: its signature verifies with that key (minisign's prehashed and legacy signatures both). -3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities) and its +3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities), its API + level when the entry lists one, and its content's fence ([mods.md](../mods.md#content-mods-api-02)); a modpack's manifest (id, version, format, game, mods); a resource pack's `pack.mcmeta`. 4. A kind this build can't install is refused with "this Horizon can't install a … yet". diff --git a/docs/api/stability.md b/docs/api/stability.md index 5c1b32362..38df0836f 100644 --- a/docs/api/stability.md +++ b/docs/api/stability.md @@ -34,6 +34,22 @@ Not breaking: a new function, interface, capability, command, endpoint, tool or argument or JSON field (readers must ignore fields they don't know); a new WIT function or type (mods built earlier don't import it); faster, or fixing behaviour to what the reference already says. +### Mod API levels + +A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every +function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`): +level 0 is the contract of Horizon 0.2.67 and 0.2.68, level 1 adds `render.set-minimap`. A mod needs the level of +the newest function it imports (a component imports only the functions it calls). The level is read from the file, +never declared: + +- the game refuses a mod that needs a function it doesn't have, with "made for a newer Horizon (it uses + render.set-minimap): update Horizon to run it", instead of a linking error; +- the registry's CI writes each mod version's level into the index (`api_level`), and installers take the newest + version the running game can run. + +A pull request that adds a function lists it in `api_level.rs` at the next level and raises `LEVEL`; the +`api_reference` test fails until it does. + ## Stability levels Every part of an API has one level, shown in its reference and its surface page. diff --git a/docs/mods.md b/docs/mods.md index e13e362e5..f0a29c865 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -501,6 +501,12 @@ so the same rustc and `Cargo.lock` give the same file. release cycle, so existing mods keep working while authors move. - The manifest's `api` names the line it needs (`0.1`); the game refuses a line it does not serve with a clear message. +- Within a line, each function has an API level, the one it arrived at + ([stability](api/stability.md#mod-api-levels)). A mod needs the level of + the newest function it calls, read from its file: an older Horizon refuses + it with "made for a newer Horizon: update Horizon", and the registry lists + the level so installers take a version the game can run. + `cargo horizon-mod check` prints it ("needs mod API level 1 or newer"). - Horizon follows Minecraft releases; the mod API does not have to. Vanilla concepts mods see (dimensions, block and item ids) are the game's own ids, so a version port changes the data, not the API. diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock index ee0cb882a..157944d55 100644 --- a/launcher/Cargo.lock +++ b/launcher/Cargo.lock @@ -2560,6 +2560,11 @@ name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash 0.2.0", + "serde", + "serde_core", +] [[package]] name = "heck" @@ -2706,6 +2711,7 @@ dependencies = [ "serde_json", "sha2 0.10.9", "toml 1.1.8+spec-1.1.0", + "wasmparser", "zip", ] @@ -6516,6 +6522,19 @@ dependencies = [ "web-sys", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags 2.13.2", + "hashbrown 0.17.1", + "indexmap", + "semver", + "serde", +] + [[package]] name = "wayland-backend" version = "0.3.17" From acbcaad7431cbb4233ac1617731b1c30c9e40086 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:56:39 +0100 Subject: [PATCH 6/9] Horizon shader packs: one WGSL prefixer for copies of the renderer's shaders The sky stage runs a copy of terrain.wgsl's sky beside the pack's code with every name prefixed `horizon_sky_`. The prefixer moves to `gfx/wgsl_prefix.rs` and now also renames module variables (bindings) and overrides, so the material stage can copy the terrain section the same way. The sky's shader is unchanged apart from where `globals` is declared. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 1 + crates/horizon-client/src/gfx/native_sky.rs | 53 +------- crates/horizon-client/src/gfx/wgsl_prefix.rs | 124 +++++++++++++++++++ 3 files changed, 128 insertions(+), 50 deletions(-) create mode 100644 crates/horizon-client/src/gfx/wgsl_prefix.rs diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 78f73bc8b..5ff14003c 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -88,6 +88,7 @@ mod stars; mod timing; pub mod translucency; pub(crate) mod upload; +mod wgsl_prefix; mod world_post; /// A column whose every section has its mesh (`Renderer::lod_detail_columns`). diff --git a/crates/horizon-client/src/gfx/native_sky.rs b/crates/horizon-client/src/gfx/native_sky.rs index 9a354ed4e..3b3c9a3b7 100644 --- a/crates/horizon-client/src/gfx/native_sky.rs +++ b/crates/horizon-client/src/gfx/native_sky.rs @@ -9,9 +9,9 @@ use horizon_shader_api::{check::CheckedStage, stages::GROUP}; use super::native_post::{NativeFrame, present_constants}; +use super::wgsl_prefix::{TERRAIN, prefixed, section}; const PREFIX: &str = "horizon_sky_"; -const TERRAIN: &str = include_str!("../terrain.wgsl"); /// The fragment entry that calls the pack: vanilla's colour in, an opaque colour out. const PACK_ENTRY: &str = " @@ -26,62 +26,15 @@ pub struct NativeSky { pub label: String, } -/// The text of `source` from the line starting with `start` up to (not including) the one -/// starting with `end`. -fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str { - let from = source - .find(&format!("\n{start}")) - .expect("terrain.wgsl has the section") - + 1; - let to = from - + source[from..] - .find(&format!("\n{end}")) - .expect("terrain.wgsl ends the section") - + 1; - &source[from..to] -} - /// terrain.wgsl's sky with every name it declares (and `globals`) prefixed. fn vanilla_sky() -> String { let text = [ - section(TERRAIN, "struct Globals {", "@group(0) @binding(0)"), + section(TERRAIN, "struct Globals {", "@group(0) @binding(1)"), section(TERRAIN, "fn linear_fog(", "fn apply_fog("), section(TERRAIN, "struct SkyOut {", "// rendertype_lines"), ] .concat(); - let mut names = vec!["globals"]; - for line in text.lines() { - let line = line - .trim_start_matches("@vertex ") - .trim_start_matches("@fragment "); - for keyword in ["fn ", "struct ", "const "] { - if let Some(rest) = line.strip_prefix(keyword) { - let end = rest - .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) - .unwrap_or(rest.len()); - names.push(&rest[..end]); - } - } - } - let mut out = String::with_capacity(text.len() * 2); - let mut word = String::new(); - let flush = |word: &mut String, out: &mut String| { - if names.contains(&word.as_str()) { - out.push_str(PREFIX); - } - out.push_str(word); - word.clear(); - }; - for c in text.chars() { - if c.is_ascii_alphanumeric() || c == '_' { - word.push(c); - } else { - flush(&mut word, &mut out); - out.push(c); - } - } - flush(&mut word, &mut out); - out + &format!("@group(0) @binding(0) var {PREFIX}globals: {PREFIX}Globals;\n") + prefixed(&text, PREFIX) } /// The sky shader for the pack's sky stage `source`. diff --git a/crates/horizon-client/src/gfx/wgsl_prefix.rs b/crates/horizon-client/src/gfx/wgsl_prefix.rs new file mode 100644 index 000000000..03d84a56e --- /dev/null +++ b/crates/horizon-client/src/gfx/wgsl_prefix.rs @@ -0,0 +1,124 @@ +//! Copies of the renderer's own WGSL that run beside a shader pack's code in one module (the +//! sky and material stages of Horizon's packs, docs/shaders.md): every name such a copy +//! declares takes a prefix starting with `horizon_`, which the pack check refuses in a pack, +//! so no pack name can meet one of Horizon's. + +/// terrain.wgsl, which the copies are taken from. +pub const TERRAIN: &str = include_str!("../terrain.wgsl"); + +/// The text of `source` from the line starting with `start` up to (not including) the one +/// starting with `end`. +pub fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str { + let from = source + .find(&format!("\n{start}")) + .expect("the source has the section") + + 1; + let to = from + + source[from..] + .find(&format!("\n{end}")) + .expect("the source ends the section") + + 1; + &source[from..to] +} + +/// The names `text` declares at its top level: functions, structs, constants, overrides and +/// module variables (bindings). +fn declared(text: &str) -> Vec<&str> { + let mut names = Vec::new(); + for line in text.lines() { + // Top level only: a function's own `var` and `let` stay as they are. + if line.starts_with(char::is_whitespace) { + continue; + } + let mut line = line; + while let Some(rest) = line.strip_prefix('@') { + // An attribute: `@vertex`, `@group(0)`, `@binding(1)`. + let end = rest.find(' ').unwrap_or(rest.len()); + line = rest[end..].trim_start(); + } + let rest = ["fn ", "struct ", "const ", "override ", "var "] + .iter() + .find_map(|k| line.strip_prefix(k)) + .or_else(|| { + // `var name`, `var name`. + let rest = line.strip_prefix("var<")?; + Some(rest[rest.find('>')? + 1..].trim_start()) + }); + if let Some(rest) = rest { + let end = rest + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .unwrap_or(rest.len()); + names.push(&rest[..end]); + } + } + names +} + +/// `text` with every name it declares at its top level, and every use of one, prefixed by +/// `prefix`. Comments are rewritten too, which is harmless. +pub fn prefixed(text: &str, prefix: &str) -> String { + let names = declared(text); + let mut out = String::with_capacity(text.len() * 2); + let mut word = String::new(); + let flush = |word: &mut String, out: &mut String| { + if names.contains(&word.as_str()) { + out.push_str(prefix); + } + out.push_str(word); + word.clear(); + }; + for c in text.chars() { + if c.is_ascii_alphanumeric() || c == '_' { + word.push(c); + } else { + flush(&mut word, &mut out); + out.push(c); + } + } + flush(&mut word, &mut out); + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn prefixes_top_level_names_and_their_uses_only() { + let text = "struct S { a: f32, }\n\ + @group(0) @binding(0) var g: S;\n\ + @group(1) @binding(2) var list: array;\n\ + override N: u32 = 1u;\n\ + const K: f32 = 2.0;\n\ + @fragment fn f(x: f32) -> @location(0) vec4 {\n \ + var a = g.a * K;\n \ + return vec4(a + f32(list[N]) + x);\n\ + }\n"; + let out = prefixed(text, "p_"); + assert_eq!( + out, + "struct p_S { a: f32, }\n\ + @group(0) @binding(0) var p_g: p_S;\n\ + @group(1) @binding(2) var p_list: array;\n\ + override p_N: u32 = 1u;\n\ + const p_K: f32 = 2.0;\n\ + @fragment fn p_f(x: f32) -> @location(0) vec4 {\n \ + var a = p_g.a * p_K;\n \ + return vec4(a + f32(p_list[p_N]) + x);\n\ + }\n" + ); + // Every top-level declaration of terrain.wgsl is found. + let names = declared(TERRAIN); + for name in [ + "Globals", + "globals", + "sprites_7", + "SPRITE_SPLIT", + "block_slots", + "fs_sky", + ] { + assert!(names.contains(&name), "{name}"); + } + assert!(!names.contains(&"out")); + } +} From 08f4fd5c8eafe7de5b27faf4d368dbe342d75831 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:10:18 +0100 Subject: [PATCH 7/9] Teleports free their dropped columns off the frame and in batches A teleport far away (or a storage that moves by more than its size) drops every column in one frame: 3,725 at RD 32. That frame freed every column's sections, then removed each section from the renderer one at a time, with a few hash lookups per section and a free-list tree update per mesh range. - The dropped columns, and a left dimension's whole chunk map, are freed on a short-lived thread of their own ("Chunk freeing"). - Renderer::remove_columns removes whole columns: one lookup per column for the tables kept by column, and the meshes' ranges go back to the arena in one sorted merge per page (FreeList::give_all) instead of a tree update each. Per-section Renderer::remove and Occlusion::remove had no other callers and are gone. - The renderer's block-entity and detail-column tables use FxHashMap. Mac mini (M4 Pro), RD 32, explored world, server thread, 3 alternated runs, two long teleports each: the drop took 26.1-39.7 ms, now 6.9-8.5 ms. Entering the Nether: 9.7-13.4 ms, now 4.0 ms or under 6 ms. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chunk.rs | 14 ++++ crates/horizon-client/src/game.rs | 6 +- crates/horizon-client/src/game/remote.rs | 21 +++--- crates/horizon-client/src/gfx.rs | 55 ++++++++++---- crates/horizon-client/src/gfx/arena.rs | 87 ++++++++++++++++++++++ crates/horizon-client/src/gfx/occlusion.rs | 27 +++++-- 6 files changed, 174 insertions(+), 36 deletions(-) diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index 41330df5f..c0bec476b 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy { Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed)) } +/// Frees `columns` (`count` of them) on a short-lived thread of its own +/// when there are many: a teleport or a dimension change drops a few +/// thousand columns at once, and freeing their sections took the frame +/// 15-20 ms. A few are freed here. +pub fn free_columns(columns: T, count: usize) { + if count < 64 { + return; + } + // Should the thread not start, the closure drops `columns` here. + let _ = std::thread::Builder::new() + .name("Chunk freeing".into()) + .spawn(move || drop(columns)); +} + /// Sizes the block states' global palette for a registry of `states`. pub fn set_block_states(states: usize) { let bits = horizon_core::paletted::ceil_log2(states).max(16); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 8591c721f..17d8586ec 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -11011,11 +11011,7 @@ impl Game<'_> { bytes += size; } } - for c in unloaded { - for sy in 0..(HEIGHT / 16) { - renderer.remove((c.x, sy, c.z)); - } - } + renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z))); if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info); lod.set_near_loading(self.streaming.busy()); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 07ab0c80d..b8153ff0a 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -11,7 +11,7 @@ use super::{Dim, Game, Mining, Screen}; use horizon_client::first_person::{Hand, SwingAnimation}; use horizon_client::{ Result, - chunk::{Chunk, SECTIONS}, + chunk::Chunk, containers::{BlockEntity, Furnace, FurnaceKind}, entities::{Experience, ExperienceOrb, ItemEntity}, hud::{HudBatch, rgba}, @@ -998,6 +998,9 @@ impl Game<'_> { self.world.day_time, self.world.weather, ); + let old = std::mem::take(&mut self.world.chunks); + let count = old.len(); + horizon_client::chunk::free_columns(old, count); self.world = World::new(self.res.facts().air, spawn.seed); self.world.game_time = time; self.world.day_time = day; @@ -1059,14 +1062,14 @@ impl Game<'_> { if gone.is_empty() { return; } + let mut freed = Vec::with_capacity(gone.len()); for &(x, z) in &gone { - self.streaming.forget(&mut self.world, x, z); - if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } - } + freed.extend(self.streaming.forget(&mut self.world, x, z)); } + if let Some(renderer) = self.renderer.as_mut() { + renderer.remove_columns(gone.iter().copied()); + } + horizon_client::chunk::free_columns(freed, gone.len()); // One pass for all of them. self.world .block_entities @@ -1631,9 +1634,7 @@ impl Game<'_> { .block_entities .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } + renderer.remove_columns([(x, z)]); } } C::ChunkBatchFinished(_) => { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 78f73bc8b..a9ae26cf2 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -459,7 +459,7 @@ pub struct Renderer { lod_retiring: crate::fast_hash::FxHashSet, /// Finished tile meshes `upload_lods` has yet to upload. lod_pending: Option, - detail_columns: HashMap<(i32, i32), u32>, + detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>, /// Bumped whenever a column becomes or stops being complete. detail_revision: u64, arena: arena::Arena, @@ -493,7 +493,7 @@ pub struct Renderer { /// The shadow camera's draws by page, in bands of distance from the light. shadow_runs: page_runs::PageRuns, /// Block-entity blocks per meshed section (world position, state id). - block_entities: HashMap>, + block_entities: crate::fast_hash::FxHashMap>, /// Changes whenever `block_entities` does (unique across renderers). block_entity_revision: u64, /// VisGraph face connectivity per meshed section (cave culling). @@ -2390,7 +2390,7 @@ impl Renderer { lod_cutout: Default::default(), lod_retiring: Default::default(), lod_pending: None, - detail_columns: HashMap::new(), + detail_columns: Default::default(), detail_revision: 0, arena, sorted_indices, @@ -2411,7 +2411,7 @@ impl Renderer { solid_runs: page_runs::PageRuns::default(), phase2_runs: page_runs::PageRuns::default(), shadow_runs: page_runs::PageRuns::default(), - block_entities: HashMap::new(), + block_entities: Default::default(), block_entity_revision: next_block_entity_revision(), occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16), world_post, @@ -2847,18 +2847,47 @@ impl Renderer { self.detail_columns.insert(column, next); } } - pub fn remove(&mut self, key: SectionKey) { - self.set_detail(key, false); - if self.block_entities.remove(&key).is_some() { + /// Every section of these columns goes: one lookup per column where the + /// tables are by column, and the meshes' ranges freed in one batch. A + /// teleport removes a few thousand columns in one frame. + pub fn remove_columns(&mut self, columns: impl IntoIterator) { + let mut released = Vec::new(); + let mut block_entities = false; + for (x, z) in columns { + if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) { + self.detail_revision += 1; + } + self.occlusion.remove_column(x, z); + let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z)); + for sy in 0..crate::chunk::SECTIONS as i32 { + let key = (x, sy, z); + block_entities |= self.block_entities.remove(&key).is_some(); + if retiring { + // Distant tiles still leave its column out: drawn until they don't. + self.lod_retiring.insert(key); + } else if let Some(section) = self.sections.remove(key) { + released.push(section); + } + } + } + if block_entities { self.block_entity_revision = next_block_entity_revision(); } - self.occlusion.remove(key); - if !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(key.0, key.2)) { - // Distant tiles still leave its column out: drawn until they don't. - self.lod_retiring.insert(key); - } else { - self.release_section(key); + if let Some(flat) = &mut self.flat { + for id in released.iter().filter_map(|s| s.flat_id) { + flat.remove(id); + } } + self.sorted_indices + .release_all(released.iter().filter_map(|s| { + let (page, start) = s.sorted_indices?; + Some((page, start, u64::from(s.translucent) * 6)) + })); + self.arena.release_all( + released + .iter() + .map(|s| (s.page, s.start, u64::from(s.solid + s.translucent) * 4)), + ); } /// Horizon's resolution scale (world pixels per window pixel) and FXAA. pub fn set_world_post(&mut self, scale: f32, antialias: bool) { diff --git a/crates/horizon-client/src/gfx/arena.rs b/crates/horizon-client/src/gfx/arena.rs index 34b4d332d..8f320a408 100644 --- a/crates/horizon-client/src/gfx/arena.rs +++ b/crates/horizon-client/src/gfx/arena.rs @@ -39,6 +39,35 @@ impl FreeList { } self.0.insert(start, len); } + /// `give` for many ranges: one merge of the sorted ranges into the list, + /// where giving them one by one costs a few tree lookups each. + fn give_all(&mut self, mut ranges: Vec<(u64, u64)>) { + if ranges.len() < 64 { + for (start, len) in ranges { + self.give(start, len); + } + return; + } + ranges.sort_unstable(); + let mut free = std::mem::take(&mut self.0).into_iter().peekable(); + let mut given = ranges.into_iter().peekable(); + let mut merged: Vec<(u64, u64)> = Vec::new(); + loop { + let next = match (free.peek(), given.peek()) { + (Some(a), Some(b)) if a.0 <= b.0 => free.next(), + (_, Some(_)) => given.next(), + (Some(_), None) => free.next(), + (None, None) => break, + }; + let (start, len) = next.expect("peeked"); + match merged.last_mut() { + Some(last) if last.0 + last.1 == start => last.1 += len, + _ => merged.push((start, len)), + } + } + // Sorted: the tree is built in one pass. + self.0 = merged.into_iter().collect(); + } } /// One vertex buffer of the arena; only the newest page grows. @@ -237,6 +266,26 @@ impl Arena { .free .give(start, len); } + /// `release` for many ranges (page, start, vertices) at once. + pub fn release_all(&mut self, ranges: impl IntoIterator) { + let mut by_page: Vec> = Vec::new(); + for (page, start, vertices) in ranges { + let page = page as usize; + if by_page.len() <= page { + by_page.resize_with(page + 1, Vec::new); + } + by_page[page].push((start, Self::span(vertices).min(self.page_limit))); + } + for (page, ranges) in by_page.into_iter().enumerate() { + if !ranges.is_empty() { + self.pages[page] + .as_mut() + .expect("live arena page") + .free + .give_all(ranges); + } + } + } /// Moves a page into a larger buffer; false (the page unchanged) when /// there is no memory for it. fn grow( @@ -435,6 +484,44 @@ mod tests { assert_eq!(free, FreeList::new(4 * GRAIN)); } + #[test] + fn many_ranges_given_at_once_coalesce_as_one_by_one() { + let fill = || { + let mut free = FreeList::new(1 << 30); + let taken: Vec<(u64, u64)> = (0..500u64) + .map(|i| { + let len = GRAIN * (1 + i * 7 % 5); + (free.take(len).unwrap(), len) + }) + .collect(); + for &(start, len) in taken.iter().step_by(3) { + free.give(start, len); + } + (free, taken) + }; + // Every other range of those still taken, in a scattered order. + let (mut one_by_one, taken) = fill(); + let (mut at_once, _) = fill(); + let mut given: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 == 0) + .map(|i| taken[i]) + .collect(); + given.sort_by_key(|&(start, _)| start.wrapping_mul(0x9E37_79B9_7F4A_7C15)); + assert!(given.len() >= 64); + for &(start, len) in &given { + one_by_one.give(start, len); + } + at_once.give_all(given); + assert_eq!(at_once, one_by_one); + // The rest too: everything is free again, in one range. + let rest: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 != 0) + .map(|i| taken[i]) + .collect(); + at_once.give_all(rest); + assert_eq!(at_once, FreeList::new(1 << 30)); + } + #[test] fn first_fit_reuses_the_lowest_hole() { let mut free = FreeList::new(8 * GRAIN); diff --git a/crates/horizon-client/src/gfx/occlusion.rs b/crates/horizon-client/src/gfx/occlusion.rs index e17ba87d1..22e2f3c81 100644 --- a/crates/horizon-client/src/gfx/occlusion.rs +++ b/crates/horizon-client/src/gfx/occlusion.rs @@ -522,16 +522,27 @@ impl Occlusion { } pub fn set(&mut self, key: SectionKey, vis: u64) { if self.columns.set(key, vis) { - self.edits.push(Edit::Set(key, vis)); - self.dirty = true; - self.changed.push(key); - if self.running.is_some() { - self.changed_late.push(key); - } + self.changed(key, vis); } } - pub fn remove(&mut self, key: SectionKey) { - self.set(key, ALL_VISIBLE); + fn changed(&mut self, key: SectionKey, vis: u64) { + self.edits.push(Edit::Set(key, vis)); + self.dirty = true; + self.changed.push(key); + if self.running.is_some() { + self.changed_late.push(key); + } + } + /// Every section of the column `x`, `z` goes (sees through every face). + pub fn remove_column(&mut self, x: i32, z: i32) { + let Some(column) = self.columns.map.remove(&(x, z)) else { + return; + }; + for (y, &vis) in column.iter().enumerate() { + if vis != ALL_VISIBLE { + self.changed((x, y as i32, z), ALL_VISIBLE); + } + } } pub fn clear(&mut self) { self.columns.map.clear(); From 3c22ff084916cf48ebdec3adb51ed9012ff5f0de Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:33:30 +0100 Subject: [PATCH 8/9] Launcher: don't install a mod version the game can't run The game program carries its mod API level in a mark (horizon-mod-api-level:NNNN;), which the launcher reads once per installed version; a program from before the mark (0.2.68 and older) serves level 0. The Horizon browser marks versions above the level of the game the player runs (the selected version, else the newest installed) "needs a newer Horizon than the game you play", and installs the newest version that game can run, or says to update it. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/main.rs | 6 +++ crates/horizon-mods/src/api_level.rs | 35 +++++++++++++++ launcher/src/backend.rs | 49 +++++++++++++++++++++ launcher/src/browser/horizon.rs | 61 +++++++++++++++++++-------- launcher/src/browser/horizon/pack.rs | 2 +- launcher/src/browser/horizon/tests.rs | 36 ++++++++++++---- 6 files changed, 162 insertions(+), 27 deletions(-) diff --git a/crates/horizon-client/src/main.rs b/crates/horizon-client/src/main.rs index 8004b2fa7..7144a1670 100644 --- a/crates/horizon-client/src/main.rs +++ b/crates/horizon-client/src/main.rs @@ -4,7 +4,13 @@ mod game; use horizon_client::{crash, logging}; +/// The mod API level this game serves, kept in the program for the launcher +/// to read without running it (`horizon_mods::api_level::MARK`). `main` +/// reads it, so the linker keeps it. +static MOD_API_LEVEL: [u8; 27] = horizon_mods::api_level::MARK; + fn main() { + std::hint::black_box(&MOD_API_LEVEL); horizon_client::telemetry::mark_start(); let args: Vec = std::env::args().skip(1).collect(); let game_args = args.iter().take_while(|a| *a != "--dedicated"); diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs index a81cf27bc..b8c305436 100644 --- a/crates/horizon-mods/src/api_level.rs +++ b/crates/horizon-mods/src/api_level.rs @@ -45,6 +45,30 @@ pub const FUNCTIONS: [(&str, u32); 29] = [ ("render.set-minimap", 1), ]; +/// What the game's program carries so the launcher can read its level +/// without running it: `horizon-mod-api-level:0001;` (four digits). A +/// program from before the mark serves level 0. +pub const MARK: [u8; 27] = { + let mut mark = *b"horizon-mod-api-level:0000;"; + let mut level = LEVEL; + let mut i = 25; + while level > 0 { + mark[i] = b'0' + (level % 10) as u8; + level /= 10; + i -= 1; + } + mark +}; + +/// The level a program's bytes carry in their [`MARK`], if any. +pub fn read_mark(program: &[u8]) -> Option { + let prefix = &MARK[..22]; + program + .windows(MARK.len()) + .filter(|w| w.starts_with(prefix) && w[26] == b';') + .find_map(|w| std::str::from_utf8(&w[22..26]).ok()?.parse().ok()) +} + /// A function's level; None for one this Horizon doesn't have. pub fn level_of(function: &str) -> Option { FUNCTIONS @@ -131,6 +155,17 @@ mod tests { assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL)); } + #[test] + fn the_mark_carries_the_level() { + assert_eq!(read_mark(&MARK), Some(LEVEL)); + let mut program = b"\0\x7fELF horizon-mod-api-level: horizon-mod-api-level:".to_vec(); + program.extend_from_slice(&MARK); + program.extend_from_slice(b"\0rest"); + assert_eq!(read_mark(&program), Some(LEVEL)); + assert_eq!(read_mark(b"horizon-mod-api-level:12;"), None); + assert_eq!(read_mark(b"no mark"), None); + } + #[test] fn a_mod_needs_its_newest_function() { assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None)); diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index a2d870a84..dba6bcd25 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -422,6 +422,37 @@ pub fn version_dir(tag: &str) -> PathBuf { const COMPLETE: &str = ".installed"; +/// The mod API level of the game players run: the selected version's, else the newest installed +/// one's. None with no version installed: the launcher doesn't know yet which game will run mods. +pub fn game_mod_api_level() -> Option { + let installed = installed(); + let tag = Settings::load() + .selected + .filter(|s| installed.contains(s)) + .or_else(|| installed.into_iter().next())?; + Some(mod_api_level(&tag)) +} + +/// A game version's mod API level, read once from the mark its program carries +/// (`horizon_mods::api_level::MARK`). A program from before the mark serves level 0, the +/// contract of Horizon 0.2.67 and 0.2.68. +pub fn mod_api_level(tag: &str) -> u32 { + static LEVELS: Mutex> = Mutex::new(Vec::new()); + let mut levels = LEVELS.lock().unwrap_or_else(|e| e.into_inner()); + if let Some(&(_, level)) = levels.iter().find(|(t, _)| t == tag) { + return level; + } + let level = program_mod_api_level(&version_dir(tag).join(CLIENT)); + levels.push((tag.to_owned(), level)); + level +} + +/// The mod API level in the game program at `path`: its mark's, else 0. +fn program_mod_api_level(path: &Path) -> u32 { + let program = fs::read(path).unwrap_or_default(); + horizon_mods::api_level::read_mark(&program).unwrap_or(0) +} + /// Installed versions, newest tag first. pub fn installed() -> Vec { installed_in(&versions_dir()) @@ -2557,6 +2588,24 @@ mod tests { use super::*; use std::cmp::Ordering::*; + /// The game program's mod API level is its mark's; a program from before the mark (0.2.68 + /// and older) or none at all serves level 0. + #[test] + fn a_game_program_says_its_mod_api_level() { + let dir = std::env::temp_dir().join(format!("horizon-api-level-{}", std::process::id())); + fs::create_dir_all(&dir).unwrap(); + let marked = dir.join("marked"); + let mut program = b"\x7fELF code code".to_vec(); + program.extend_from_slice(b"horizon-mod-api-level:0007;"); + fs::write(&marked, &program).unwrap(); + let old = dir.join("old"); + fs::write(&old, b"\x7fELF code without a mark").unwrap(); + assert_eq!(program_mod_api_level(&marked), 7); + assert_eq!(program_mod_api_level(&old), 0); + assert_eq!(program_mod_api_level(&dir.join("missing")), 0); + fs::remove_dir_all(&dir).unwrap(); + } + /// A preparation that reuses the imported game files still reads the assets from the /// launcher that has them: a Prism Launcher instance's are in the launcher root, linked into /// the official layout (jan.sonki on Discord: silent, grey title screen since 0.2.48). diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs index 1aad20734..3bf465faf 100644 --- a/launcher/src/browser/horizon.rs +++ b/launcher/src/browser/horizon.rs @@ -168,7 +168,14 @@ fn project_of(p: &index::Project) -> Option { }) } -fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version { +/// Version `v` of `p` as the browser shows it; blocked when taken down, or when it needs a newer +/// mod API level than `level`, the game's. +fn version_of( + index: &Index, + p: &index::Project, + v: &index::Version, + level: Option, +) -> Version { Version { id: v.version.clone(), number: v.version.clone(), @@ -187,7 +194,8 @@ fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version required: v.requires.iter().map(|r| r.id.clone()).collect(), blocked: index .revoked(&p.id, &v.file.sha256) - .map(|r| format!("taken down: {}", r.reason)), + .map(|r| format!("taken down: {}", r.reason)) + .or_else(|| needs_newer(v, level).then(|| NEEDS_NEWER.to_string())), } } @@ -254,9 +262,10 @@ impl Source for Registry { let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; + let level = crate::backend::game_mod_api_level(); Ok(p.versions .iter() - .map(|v| version_of(&index, p, v)) + .map(|v| version_of(&index, p, v, level)) .collect()) } @@ -378,20 +387,24 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result { } } -/// Installs a registry project into the game folder `home`: its newest version for this game, -/// downloaded into `mod-browser/downloads/`, checked against the index, then moved into place. -/// A mod is `horizon-mods/.hmod`, turned on in `horizon-mods.txt`. +/// Installs a registry project into the game folder `home`: its newest version for this game that +/// the game the player runs can load, downloaded into `mod-browser/downloads/`, checked against +/// the index, then moved into place. A mod is `horizon-mods/.hmod`, turned on in +/// `horizon-mods.txt`. pub fn install( project: &Project, home: &Path, progress: &dyn Fn(&str, f32), ) -> Result, String> { - install_from(&*index()?, local(), project, home, progress) + let level = crate::backend::game_mod_api_level(); + install_from(&*index()?, local(), level, project, home, progress) } +/// [`install`] from `index`, for a game serving mod API `level`. fn install_from( index: &Index, local: bool, + level: Option, project: &Project, home: &Path, progress: &dyn Fn(&str, f32), @@ -399,27 +412,41 @@ fn install_from( let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; - let v = newest(index, p)?; + let v = newest(index, p, level)?; install_version(index, local, p, v, home, progress).map(|e| vec![e]) } -/// A project's newest version for this game that wasn't taken down. -fn newest<'a>(index: &Index, p: &'a index::Project) -> Result<&'a index::Version, String> { - let mut taken_down = None; +/// A project's newest version for this game that wasn't taken down and that a game serving mod +/// API `level` runs (any, when the level isn't known). +fn newest<'a>( + index: &Index, + p: &'a index::Project, + level: Option, +) -> Result<&'a index::Version, String> { + let (mut taken_down, mut too_new) = (None, false); for v in p.versions.iter().filter(|v| v.game == GAME) { - match index.revoked(&p.id, &v.file.sha256) { - None => return Ok(v), - Some(r) => { - taken_down.get_or_insert(r); - } + if let Some(r) = index.revoked(&p.id, &v.file.sha256) { + taken_down.get_or_insert(r); + } else if needs_newer(v, level) { + too_new = true; + } else { + return Ok(v); } } Err(match taken_down { + _ if too_new => format!("{} {NEEDS_NEWER}: update it first.", p.name), Some(r) => format!("{} was taken down: {}", p.name, r.reason), None => format!("{} has no version for {GAME} to install.", p.name), }) } +const NEEDS_NEWER: &str = "needs a newer Horizon than the game you play"; + +/// Whether version `v` calls mod API functions a game serving `level` doesn't have. +fn needs_newer(v: &index::Version, level: Option) -> bool { + matches!((v.api_level, level), (Some(needed), Some(level)) if needed > level) +} + /// Installs version `v` of the registry's mod, resource pack or shader pack `p` into the game /// folder `home`. fn install_version( @@ -462,7 +489,7 @@ fn install_version( return Err(format!("{relative} is already there: move it away first.")); } let line = format!("{} {}", p.name, v.version); - let file = &version_of(index, p, v).files[0]; + let file = &version_of(index, p, v, None).files[0]; let staging = home.join("mod-browser/downloads"); let path = fetch(file, &staging, local, &|f| progress(&line, f))?; let trust = index::check_file(index, p, v, &path).inspect_err(|_| { diff --git a/launcher/src/browser/horizon/pack.rs b/launcher/src/browser/horizon/pack.rs index 3cb6d7c9b..95235a505 100644 --- a/launcher/src/browser/horizon/pack.rs +++ b/launcher/src/browser/horizon/pack.rs @@ -84,7 +84,7 @@ fn install_in( if p.kind != idx::Kind::Modpack { return Err(format!("{} is a {}, not a modpack.", p.name, p.kind.name())); } - let v = newest(index, p)?; + let v = newest(index, p, None)?; let work = dir.join(&p.id); let fresh = !work.exists(); let result = install_version_in(index, local, p, v, &work, progress); diff --git a/launcher/src/browser/horizon/tests.rs b/launcher/src/browser/horizon/tests.rs index 314be2050..7e1b8f585 100644 --- a/launcher/src/browser/horizon/tests.rs +++ b/launcher/src/browser/horizon/tests.rs @@ -59,7 +59,7 @@ fn installs_checked_turns_on_and_removes() { let index = sample(); let home = scratch("install"); let p = hud(&index); - let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(done[0].file, "horizon-mods/coords_hud.hmod"); assert_eq!(done[0].verdict.as_deref(), Some("Verified")); assert!(done[0].checksum.starts_with("SHA-256:e1135345")); @@ -73,7 +73,7 @@ fn installs_checked_turns_on_and_removes() { 0 ); // Installed already: nothing to do. - let again = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let again = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(again, done); let mut revoked = index.clone(); @@ -102,7 +102,7 @@ fn installs_a_shader_pack_into_shaderpacks() { let home = scratch("shader"); let p = project_of(index.project("glow").unwrap()).unwrap(); assert_eq!(p.support(), super::super::Support::Works); - let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(done[0].file, "shaderpacks/glow-1.0.0.hshader"); assert_eq!(done[0].kind, Kind::Shader); assert!(home.join("shaderpacks/glow-1.0.0.hshader").is_file()); @@ -123,7 +123,7 @@ fn installs_a_shader_pack_into_shaderpacks() { assert!(!home.join("shaderpacks/glow-1.0.0.hshader").exists()); // A file of the same name the registry didn't put there is left alone. fs::write(home.join("shaderpacks/glow-1.0.0.hshader"), b"mine").unwrap(); - let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert_eq!( e, "shaderpacks/glow-1.0.0.hshader is already there: move it away first." @@ -140,15 +140,15 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { let mut tampered = index.clone(); let cozy = tampered.projects[1].versions[0].file.url.clone(); tampered.projects[0].versions[0].file.url = cozy; - let e = install_from(&tampered, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&tampered, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("larger than its source says"), "{e}"); assert!(!home.join("horizon-mods").exists()); - let e = install_from(&index, false, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, false, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("file servers"), "{e}"); fs::create_dir_all(home.join("horizon-mods/coords_hud")).unwrap(); - let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("already in horizon-mods"), "{e}"); let mut taken_down = index.clone(); @@ -158,7 +158,7 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { reason: "Test.".into(), date: String::new(), }); - let e = install_from(&taken_down, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&taken_down, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert_eq!(e, "Coordinates HUD was taken down: Test."); fs::remove_dir_all(&home).unwrap(); } @@ -175,7 +175,7 @@ fn registry_versions_run_when_made_for_this_game() { let versions: Vec = p .versions .iter() - .map(|x| version_of(&index, p, x)) + .map(|x| version_of(&index, p, x, None)) .collect(); assert_eq!(pick(Kind::Mod, &versions, false).unwrap().number, "0.1.0"); } @@ -198,3 +198,21 @@ fn owner_links_only_take_github_logins() { assert!(!github_login(bad), "{bad}"); } } + +/// A version that calls mod API functions the game doesn't have is marked and skipped. +#[test] +fn versions_for_a_newer_horizon_are_not_installed() { + let mut index = sample(); + index.projects[0].versions[0].api_level = Some(1); + let p = index.project("coords_hud").unwrap(); + let e = newest(&index, p, Some(0)).unwrap_err(); + assert_eq!( + e, + "Coordinates HUD needs a newer Horizon than the game you play: update it first." + ); + assert!(newest(&index, p, Some(1)).is_ok()); + assert!(newest(&index, p, None).is_ok()); + let v = version_of(&index, p, &p.versions[0], Some(0)); + assert_eq!(v.blocked.as_deref(), Some(NEEDS_NEWER)); + assert_eq!(version_of(&index, p, &p.versions[0], Some(1)).blocked, None); +} From b12c89650ed0d7d0f02c7e2bf2a475c3b962e9a3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:46:27 +0100 Subject: [PATCH 9/9] Mod API levels: server mods' players functions are level 1; the registry's lockfile Main gained players.online, tell and broadcast (#1833) after 0.2.69, so they take level 1 with render.set-minimap. horizon-mod-registry's own Cargo.lock picks up wasmparser. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-registry/Cargo.lock | 24 ++++++++++++++++++++++++ crates/horizon-mods/src/api_level.rs | 7 +++++-- docs/api/stability.md | 2 +- 3 files changed, 30 insertions(+), 3 deletions(-) diff --git a/crates/horizon-mod-registry/Cargo.lock b/crates/horizon-mod-registry/Cargo.lock index e93f5b3b5..f80068fcc 100644 --- a/crates/horizon-mod-registry/Cargo.lock +++ b/crates/horizon-mod-registry/Cargo.lock @@ -401,6 +401,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" dependencies = [ "foldhash", + "serde", + "serde_core", ] [[package]] @@ -442,6 +444,7 @@ dependencies = [ "serde_json", "sha2", "toml", + "wasmparser", "zip", ] @@ -649,6 +652,8 @@ checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", "hashbrown", + "serde", + "serde_core", ] [[package]] @@ -921,6 +926,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + [[package]] name = "serde" version = "1.0.229" @@ -1326,6 +1337,19 @@ dependencies = [ "wit-bindgen", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", + "serde", +] + [[package]] name = "webpki-roots" version = "0.26.11" diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs index a81cf27bc..e7b72c20b 100644 --- a/crates/horizon-mods/src/api_level.rs +++ b/crates/horizon-mods/src/api_level.rs @@ -10,10 +10,10 @@ pub const LEVEL: u32 = 1; /// Every function the game offers mods, as `interface.function`, with its -/// level. Level 0 is the contract of Horizon 0.2.67 and 0.2.68. A new +/// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new /// function takes the next level and raises [`LEVEL`] (the `api_reference` /// test fails until it is listed here). -pub const FUNCTIONS: [(&str, u32); 29] = [ +pub const FUNCTIONS: [(&str, u32); 32] = [ ("log.write", 0), ("game.get-player", 0), ("game.get-clock", 0), @@ -43,6 +43,9 @@ pub const FUNCTIONS: [(&str, u32); 29] = [ ("render.frame-stats", 0), ("render.set-zoom", 0), ("render.set-minimap", 1), + ("players.online", 1), + ("players.tell", 1), + ("players.broadcast", 1), ]; /// A function's level; None for one this Horizon doesn't have. diff --git a/docs/api/stability.md b/docs/api/stability.md index cea3415d7..65cfc0c13 100644 --- a/docs/api/stability.md +++ b/docs/api/stability.md @@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`): -level 0 is the contract of Horizon 0.2.67 and 0.2.68, level 1 adds `render.set-minimap`. A mod needs the level of +level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`. A mod needs the level of the newest function it imports (a component imports only the functions it calls). The level is read from the file, never declared: