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 01/70] 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 02/70] 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 03/70] 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 04/70] 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 bd09f8b03eb2338086a7c0a1fe49c19e0c37fc7e Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:36:11 +0000 Subject: [PATCH 05/70] Migrate player integration coverage to server-thread hosting Co-Authored-By: OpenAI Codex GPT-6.1 --- AGENTS.md | 8 +- .../src/bin/horizon-ctl/main.rs | 7 +- crates/horizon-client/src/game.rs | 3 + crates/horizon-client/src/game/agent.rs | 3 + crates/horizon-client/src/game/control.rs | 57 ++++ crates/horizon-client/src/game/creatures.rs | 3 + crates/horizon-client/src/game/integrated.rs | 6 + .../src/game/remote_projectiles.rs | 3 +- docs/architecture.md | 2 +- docs/parity-workflow.md | 46 +++ docs/validation/server-thread-migration.md | 297 ++++++++++++++++++ .../dev/horizonlab/parity/ParityFont.java | 40 ++- .../parity/VanillaPackScreenOracle.java | 2 +- .../parity/VanillaTabListOracle.java | 26 +- tests/test_game_home.py | 1 + tests/test_integration_env.py | 50 +++ tools/agent_control_e2e.py | 2 + tools/integration_env.py | 54 ++++ tools/lan_e2e.py | 296 +++++++++++++---- tools/oracle_harness.py | 5 +- tools/test_command_exec_parity.py | 5 +- tools/test_dedicated_server_parity.py | 12 +- tools/test_dispenser_parity.py | 5 +- tools/test_friends.py | 47 ++- tools/test_friends_integration_parity.py | 30 ++ tools/test_lan_integration_parity.py | 14 + tools/test_online_mode_parity.py | 4 +- tools/test_pack_screen_parity.py | 2 +- tools/test_tab_list_parity.py | 2 +- 29 files changed, 932 insertions(+), 100 deletions(-) create mode 100644 docs/validation/server-thread-migration.md create mode 100644 tests/test_integration_env.py create mode 100644 tools/integration_env.py create mode 100644 tools/test_friends_integration_parity.py create mode 100644 tools/test_lan_integration_parity.py diff --git a/AGENTS.md b/AGENTS.md index a72c6723a..c8bfcdb34 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -66,7 +66,7 @@ cargo build --profile fast -p horizon-client # optimized, quick to link: python3 tools/parity.py --changed origin/main # the harnesses your branch can affect (CI's parity job) python3 tools/parity.py --changed-files paths.txt --list # which harnesses cover these files, without running them python3 tools/parity.py mob_ai sculk # named harnesses -python3 tools/lan_e2e.py --check chest # two real games over LAN (host in-frame); --server-thread for the host on its server thread +python3 tools/lan_e2e.py --check chest # two real games over LAN (server-thread host); --in-frame compares the fallback python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end ``` @@ -156,7 +156,7 @@ python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end exactly as a LAN guest or a dedicated server's player does. This is what players run. Open `[server-thread]` issues list the gaps left. 2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks - the world itself, one level that follows the player (`fn enter_dimension`). Most harnesses test this path. + the world itself, one level that follows the player (`fn enter_dimension`). Deterministic rule fixtures still use this path; player-facing integration uses the default server thread. LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths when you touch player-facing gameplay: @@ -164,8 +164,8 @@ when you touch player-facing gameplay: ```sh cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T # server thread cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame # in-frame -python3 tools/lan_e2e.py --check # host in-frame, guest is a server client -python3 tools/lan_e2e.py --server-thread --check # host on its server thread (portals, levels, distance, lava need it) +python3 tools/lan_e2e.py --check # host on its server thread, guest is a server client +python3 tools/lan_e2e.py --in-frame --check # comparison (portals, levels, distance, lava need server-thread mode) python3 tools/parity.py dedicated_server server_entities server_player_damage ``` diff --git a/crates/horizon-client/src/bin/horizon-ctl/main.rs b/crates/horizon-client/src/bin/horizon-ctl/main.rs index 402808e81..33ea1f870 100644 --- a/crates/horizon-client/src/bin/horizon-ctl/main.rs +++ b/crates/horizon-client/src/bin/horizon-ctl/main.rs @@ -610,12 +610,17 @@ mod tests { #[test] fn unreachable_games_fail_with_status_3() { - let mut s = Session::new(std::env::temp_dir().join("horizon-ctl-nobody.sock"), None); + let home = + std::env::temp_dir().join(format!("horizon-ctl-unreachable-{}", std::process::id())); + std::fs::create_dir_all(&home).unwrap(); + let mut s = Session::new(home.join("nobody.sock"), None); + s.home = home.clone(); let f = s.run(&["state".to_owned()]).unwrap_err(); assert_eq!(f.status, UNREACHABLE); assert_eq!(f.reply["kind"], "connection"); let f = s.run(&["sleep".to_owned(), "x".to_owned()]).unwrap_err(); assert_eq!(f.status, USAGE); + std::fs::remove_dir_all(home).unwrap(); } #[test] diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index a246afebc..5901c3362 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4073,6 +4073,9 @@ impl Game<'_> { self.with_level(|b, level, ticks| b.notify_written(level, ticks, position, flags)); } fn tick(&mut self) -> Result<()> { + if self.agent.hold_server { + return Ok(()); + } self.tick_debug_keys()?; self.tick_debug_charts(); if self.remote.is_some() { diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 57c12da97..935717eb5 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -300,6 +300,8 @@ struct Glide { pub(super) struct Agent { task: Option, glide: Option, + /// Control-fixture barrier: hold simulation and packet handling, not transport threads. + pub hold_server: bool, } pub(super) enum Handled { @@ -662,6 +664,7 @@ impl Game<'_> { }); if let Some(chat) = &self.ui.chat_screen { v["chat_input"] = json!(chat.input.value); + v["chat_suggestions"] = json!(chat.suggestions_visible()); } if self.title.is_some() { v["menu"] = self.title_value(); diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index a0d8987d8..a7312c99b 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -11,6 +11,9 @@ use winit::{event::MouseButton, event_loop::ActiveEventLoop, keyboard::KeyCode}; const HELP: &[&str] = &[ "status game, player, streaming and renderer state", + "simulation authoritative projectiles in the owner's level", + "server-hold on|off hold simulation and player packets at a control-fixture barrier", + "stall MILLISECONDS stall the window thread (0..5000), leaving transport alive", "key KEY down|up|tap|repeat press, release or auto-repeat a key (w a s d space shift ctrl e q esc f3 1-9 arrows ...)", "release release every key and mouse button", "mouse left|right|middle down|up|click", @@ -238,6 +241,47 @@ impl Game<'_> { } "sculk" => Ok(Some(self.sculk_command(&words)?)), "status" => Ok(Some(self.control_status())), + "stall" => { + let millis: u64 = arg(1)?.parse()?; + if millis > 5000 { + return Err("stall is limited to 5000 milliseconds".into()); + } + std::thread::sleep(Duration::from_millis(millis)); + ok() + } + "simulation" => { + self.require_world()?; + let value = if let Some(server) = &self.integrated { + server + .call(|g| { + g.in_owner_level(|g| { + json!({ "game_time": g.world.game_time, "projectiles": g.projectiles_status() }) + }) + }) + .ok_or("the integrated server stopped")? + } else { + json!({ "game_time": self.world.game_time, "projectiles": self.projectiles_status() }) + }; + Ok(Some(value)) + } + "server-hold" => { + self.require_world()?; + let held = match arg(1)? { + "on" => true, + "off" => false, + _ => return Err("server-hold on|off".into()), + }; + if let Some(server) = &self.integrated { + server + .call(move |g| g.agent.hold_server = held) + .ok_or("the integrated server stopped")?; + } else if self.remote.is_some() { + return Err("server-hold requires the world's host".into()); + } else { + self.agent.hold_server = held; + } + ok() + } "pad" => Ok(Some(self.pad_command(&words)?)), "key" => { let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?; @@ -496,10 +540,23 @@ impl Game<'_> { "mobs" => { self.require_world()?; let radius: f64 = words.get(1).map_or(Ok(64.0), |r| r.parse())?; + if let Some(server) = &self.integrated { + let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + let value = server + .call(move |g| g.in_owner_level(|g| g.control_mobs_at(radius, center))) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_mobs(radius))) } "hurtlog" => { self.require_world()?; + if let Some(server) = &self.integrated { + let value = server + .call(|g| g.control_hurt_log()) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_hurt_log())) } "resume" => { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index c4779dbf7..60f3d57db 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -316,6 +316,9 @@ impl Game<'_> { /// The `mobs` command: nearby mobs with position, health and running goals. pub(super) fn control_mobs(&self, radius: f64) -> serde_json::Value { let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + self.control_mobs_at(radius, center) + } + pub(super) fn control_mobs_at(&self, radius: f64, center: Vec3) -> serde_json::Value { let list: Vec = self .mobs .iter() diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index d4726f2f1..21e46f51e 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -360,6 +360,12 @@ impl Game<'_> { let mut next = Instant::now(); while !flags.stop.load(Ordering::Relaxed) { self.run_tasks(); + if self.agent.hold_server { + // Keep servicing control requests so the fixture can release the barrier. + // Unlike /tick freeze, no player's queued packets are applied here. + self.wait_for_next_server_tick(&mut next, true); + continue; + } let paused = flags.paused.load(Ordering::Relaxed); if paused { // Only the connections run. diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index bc6d0b13e..e70426a4a 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -272,7 +272,8 @@ impl Game<'_> { out.push(json!({"id": t.id, "kind": "minecraft:trident", "position": at(t.position)})); } for p in &self.creatures.projectiles { - out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position)})); + out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position), "velocity": at(p.velocity), + "player_owned": p.owner == Some(horizon_client::mobs::Who::Player)})); } for (kind, p, _) in self.potions.thrown_entities() { out.push(json!({"kind": kind, "position": at(p)})); diff --git a/docs/architecture.md b/docs/architecture.md index f95073e57..0350bd1ea 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -51,7 +51,7 @@ file selects ~103. | 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` | | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser | | 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle | -| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e --server-thread` (portals, levels, distance, lava) | +| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e` (server-thread by default; portals, levels, distance, lava) | | 38 | Command parsing (34) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) | | 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) | | 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet | diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index f9f222071..3834234c9 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -77,3 +77,49 @@ On ludodesktop, source `~/code/horizon-parity/env.sh` first: it sets the ALSA bu ## Reading vanilla Besides the Vineflower sources in `.local/minecraft//sources/`, `tools/rea_vanilla.py` queries the shipped bytecode through REA (callers through lambdas, overloads, a second decompiler); see [decompilation status](decompilation-status.md#querying-the-shipped-bytecode-with-rea). + +## Player-facing integration and deterministic fixtures + +`python3 tools/lan_e2e.py` runs every LAN check with an integrated server thread, +the same path as normal single player. `python3 tools/test_friends.py --client +target/fast/horizon-client --relay target/fast/horizon-relay --baseline` covers +plain LAN, direct invitations, a local relay and ended invitations in that mode. +Both accept `--in-frame` for comparison and retain `--server-thread` for existing +callers. Run Linux games under `xvfb-run -a` when no display is available. Each +process gets scratch game, launcher, XDG data and config homes; telemetry, audio +and launcher self-update are disabled. + +`lan_integration` and `friends_integration` register these suites with the normal +`parity.py` selection used by CI. Their traced imports and Cargo artifacts select +them when the drivers or game implementation change. LAN writes `results.json` +with the host mode and each result beside its screenshots and logs. A skipped +case is recorded explicitly and does not count as passing coverage. + +The game-binary fixture audit keeps these complementary direct rule tests: + +- `command_harness.rs`: command feedback, styled spans and result callbacks, + held player position, explicit ticks and portal completion matching + `VanillaCommandExecOracle`. LAN `commands`, `feedback`, `styles`, `levels` and + `portals` cover command input, packet feedback and travel across the boundary. +- `dispense_fixture.rs`: seeded synthetic worlds, block/event traces, item + use/mining and combat hooks matching `VanillaDispenserOracle`. These isolate + rule results and RNG order; LAN machines, crafting, clicks, fireball, mining + and combat exercise real input and server handling separately. The new + `dispenser_input_host` / `dispenser_input_guest` checks press a button and + verify authoritative inventory consumption and exactly one drop on both clients. +- `sculk_fixture.rs`: scripted events and exact per-tick sculk/warden traces + matching `VanillaSculkOracle`; introducing wall-clock network ticks would + destroy that deterministic oracle contract. `sculk_input_host` and + `sculk_input_guest` separately exercise real footsteps reaching a sensor; + failures remain visible rather than changing the oracle trace. +- `net_harness.rs`: already a real network client of a dedicated server; keep + its handshake, world loading, chat and command packet assertions. + +Library probes, `lan_bot`'s protocol hub fixture, generation/save tests and +streaming/mesh tests remain fast deterministic coverage. They do not become +full game launches. Setup and authoritative reads use the owning server; +interactions stay on the client. `server-hold on|off` provides a prediction-test +barrier between server ticks, including player packet handling, while transport +threads and control calls remain responsive. `stall MILLISECONDS` stalls only +the window to test recovery from a hung frame without process signals interrupting +socket reads. Neither mechanism changes normal gameplay. diff --git a/docs/validation/server-thread-migration.md b/docs/validation/server-thread-migration.md new file mode 100644 index 000000000..62c1609b7 --- /dev/null +++ b/docs/validation/server-thread-migration.md @@ -0,0 +1,297 @@ +# Server-thread integration coverage migration: validation ledger + +Tested on 2026-10-24, Linux / NVIDIA Vulkan, with Java 25 and the pinned 26.3 +resources and jars. Base: `e423e570c`. Player integration uses real Horizon +clients under Xvfb and real control sockets. The migrated game drivers use fresh +temporary game, launcher and XDG data/config homes; telemetry, audio and launcher +self-update are disabled. No player data or prepared resources are committed. +An interrupted historical-world generator initially inherited the harness +environment instead of those per-game homes. It wrote only to ignored `.local` +fixture folders; it was stopped, and subsequent validation uses the already +prepared historical worlds. That setup mistake is not counted as a passing run. + +## Before editing + +Open PR searches for server-thread, integration, LAN and friends work found no +overlapping migration. The full original LAN suite was started with +`--server-thread` against a build of the unchanged base before repository edits. + +| Run | Hosting | Result | +| --- | --- | --- | +| Original full LAN attempt | Server thread | 58 checks reported: 39 passed, 18 failed, deflection skipped; the runner then aborted at `light` with an uncaught `TypeError`. | +| Original remaining 45 checks | Server thread | 31 passed, 14 failed, no skips. Used the unchanged loaded driver and original executable. | +| Friends, including `--baseline` | Server thread | Plain LAN, direct invitation, local relay and ended-invite rejection passed. | + +Together the two LAN invocations attempted all 103 original checks. The initial +`sign` case left its editor open, breaking the later death-screen assertion. +`predict` suspended the whole host process; resuming it interrupted a socket +read (`Interrupted system call`), disconnected the guest and caused later +session failures. The remaining run also exposed sign placement outside reach +and cascading dead-player failures. These are recorded failures, not passes. + +## Infrastructure changes validated during migration + +- Close the sign editor after the original placement check. Give the two-player + sign case a reachable arena and wait for placement data/feedback before typing. + Observe the submitted text on both clients within the existing assertion budget. + The revised sign case passed three consecutive server-thread reruns. +- Release held input, close screens and respawn dead players before independent + cases. Keep every case's death, menu and held-action assertions inside the case. +- Replace process signals with a server barrier for prediction and an intentional + window-thread stall for frame-recovery tests. Prediction still tests immediate + client prediction, authoritative agreement, iron-door rejection and exactly-once + sound; it also asserts that the server clock did not advance at the barrier. +- Route mob/projectile/hurt-log inspection to the owning server. Deflection runs + in the default suite rather than reporting an in-frame-only skip as a pass. +- Record skipped checks explicitly as uncovered, and record ordinary case errors + without aborting the rest of the suite. Write mode and results to `results.json`. +- Serialize the two CI integration entry points on the shared GPU. An earlier + concurrent comparison failed to start a graphics device because of GPU memory + exhaustion; it was rerun serially, without changing a gameplay timeout. + +## Post-migration runs + +The first complete server-thread migration run, before the case-cleanup fixes, +ran all 103 original cases: 88 passed and 15 failed. Failures were `deflect`, +`light`, `swings`, `cracks`, `effects`, `portals`, `flight`, `boats`, `minecarts`, +`frames`, `hands`, `riding`, `mounts`, `contacts` and `absorption`. Many followed +the host's deflection damage/death. They are not used as evidence of a clean suite. + +The next complete default server-thread run executed all 107 cases (the original +103 plus four separate host/guest sensor and dispenser input cases): **97 passed, +10 failed, zero skipped**. Failures were `commands`, `deflect`, `swings`, `flight`, +`boats`, `minecarts`, `keepinv`, `fishing`, `sculk_input_host` and +`sculk_input_guest`. Lighting passed this run; earlier lighting failures are not +claimed as a persistent blocker. + +A subsequent input-timing correction runs the existing double-jump key/wait +sequence through one `horizon-ctl script` process, preserving the seven-tick +flight window. A targeted server-thread rerun passed flight for both players, +swings, boats and minecarts. Command completion still failed: the observable +suggestion list did not appear within the existing two-tick budget. The in-frame +rerun passed flight and failed completion in the same way. Passing isolated +swings/vehicle cases does not clear the unexplained failures in the full sequence. +The full-run inventory retention and fishing failures also remain unresolved. + +Friends passed plain LAN, direct invitation, local relay and ended-invite checks +both after making server-thread hosting the default and with explicit `--in-frame`. + +Targeted in-frame comparisons passed chest, sign placement, prediction, clock +recovery, lighting and deflection. The revised two-player sign case and both +new dispenser input cases passed too. Command completion failed twice: Tab after +`/gamem` left `/gamem` unchanged. The host's sculk input passed; the guest's failed. + +Targeted server-thread checks passed prediction and both new dispenser input +cases. Dispensing checks authoritative inventory consumption and exactly one +matching item on each client. Both sensor cases confirmed movement on the client +and server, but the sensor stayed inactive. Deflection still failed the original +no-fireball-damage assertion after allowing the click through a normal client +input tick. An experimental frozen-world synchronization approach also failed +and is not part of the final implementation. + +## Deterministic rule and source checks + +`python3 tools/parity.py command_exec dispenser sculk --timeout 1500 --jobs 2`: + +| Direct fixture | Result | +| --- | --- | +| Command execution | 781/781 command/callback records match the vanilla oracle. | +| Dispenser and related rule calls | 6000 cases match; no difference groups. | +| Sculk | 435 scenarios match every compared tick. | + +All three harnesses passed. Their seeded rule calls and controlled ticks remain +direct; they do not claim client/server boundary coverage. The existing +`net_harness.rs` remains a real dedicated-server client fixture. + +The first quick self-check passed 289 Python tests, rustfmt and Clippy. Rust tests +reported 1081 passed, one failed and 26 ignored: the shared prepared resource +folder lacked `registries.json`. The pinned local datagen report was copied into +a private ignored resource copy; the failed +`mod_content::tests::content_root_loads_with_every_table` test then passed. +The focused environment/parity-runner/self-check Python tests passed (38 tests). + +The full `python3 tools/pr_ready.py --base origin/main` completed: 1205 Rust tests +and 291 Python tests passed, as did rustfmt, Clippy and documentation checks. +Its parity phase failed after the historical-world setup interruption described +above, so the overall self-check is **not green**. A subsequent `parity.py --changed origin/main --timeout 1500` selected 160 +harnesses, 151 requiring runs. Three completed and passed (`firework_tooltip`, +`held_drop`, `interaction_input`). Both integration wrappers exceeded that +invocation's 25-minute per-harness deadline: friends was waiting for the shared +GPU lock, and LAN was still executing cases. Automatic retries were stopped and +the detached game processes cleaned up. The remaining affected harnesses did not +complete. This is incomplete validation, not a passing corrected parity gate; +compilation is not a substitute for the gameplay failures above. + +The final source self-check, `python3 tools/pr_ready.py --quick`, passed 1205 Rust +tests, 291 Python tests, rustfmt, Clippy and documentation checks. After correcting +the integration build arguments to name each binary (so traced selection includes +`game.rs` and `game/integrated.rs`), the named client/control/relay build and 38 +focused Python tests passed. Dependency extraction from the real Cargo dep-info +confirmed both game files are selected. + +## Limitations recorded before the follow-up fixes + +These were the remaining blockers when this ledger was first written; the +completion runs below record their status after the follow-up fixes. + +- Server-player footsteps do not reach sculk sensors. `tick_entity_events` in + `game/sculk.rs` emits player motion events from `Game.player`; the integrated + server's players live in its guest hub. The in-frame host passes and its guest + fails too, separating this shared server-player gap from the deterministic rule + oracle. A fix needs per-player event identity/state rather than weakening the test. +- The server-thread host takes fireball damage in deflection; the equivalent + in-frame check passes. Client-visible and authoritative projectile state diverge + during the synchronization investigation. No gameplay fix is included. +- Command completion fails in both modes as described above; it is not reported + as a passing fallback comparison. +- Full-sequence swings, vehicle, inventory-retention and fishing failures need + further fixture/state investigation. Swings and both vehicles passed isolated + reruns; that evidence does not establish a gameplay defect or a full-suite pass. + +No failing case is skipped, expectation relaxed, or existing timeout increased to +hide these results. At that stage the PR stayed draft with these coverage blockers. + +## Combined validation before the gameplay split (2026-10-25) + +Merged `main` at `bd591f985` and resolved the overlapping motion, projectile and +test-driver changes. The shared projectile inertia helper retains main's custom +acceleration power, with a regression test. Integration environments now call +`lab.game_env`; the friends entry point delegates its actual launches to that +isolated driver. The dedicated-server process keeps one environment argument, +and the control-tool connection test uses a scratch home rather than reading +the player's No AI setting. + +The first complete run after that merge executed **119 cases: 114 passed, +five failed, zero skipped**. Failures were `swings`, `flight`, `boats`, +`minecarts` and `keepinv`. All the additional regression cases from main passed. +Command completion, deflection, fishing and both sensor/dispenser input roles +also passed in that full sequence. + +The failures exposed fixture setup, input cadence and an off-hand clearing bug: + +- Aim at the hoe target's top face, observe that target, then send a normal + mouse click. Keep the exact one-swing/farmland assertion. A subsequent full + repeat passed flight and both vehicle checks but still failed the hoe case; + it was stopped after identifying the root cause rather than counted as green. + The earlier explosion case leaves an off-hand shield, and `/clear` omitted + that slot. Vanilla correctly blocks hoe use with that shield. Follow + `Inventory.clearOrCountMatchingItems`, `getContainerSize`, `getItem` and its + equipment-slot mapping: clear off-hand items and visit armor feet to head. + New oracle cases cover off-hand counting, partial/full removal and limited + armor-slot ordering. The explosion-then-swings sequence passes after this fix. +- Keep the original double-jump key sequence and seven-tick flight rule; run + this tick-sensitive case at four ticks per second so IPC scheduling on a busy + machine cannot stretch the input past that window. Restore 20 TPS afterward. +- Deliver the original ten vehicle punches and two-tick waits over one control + connection. Separate process launches had stretched the gaps to ten ticks, + letting the vehicle's damage decay before the next hit. +- Protect inactive inventory-test players after the low-health totem case, + assert that the active player is alive before the intended death, and provide + a full floor under scattered death drops. A targeted retry with the old small + platform lost a helmet over its edge; both players' exact drop/retention + assertions passed with the larger floor. + +Targeted server-thread reruns passed all five corrected cases, plus totems, +fishing and both sensor input roles. Friends passed plain LAN, direct invites, +the local relay and ended-invite rejection. The six focused parity harnesses +passed: `command_exec`, `dispenser`, `sculk`, `dedicated_server`, +`server_entities` and `server_player_damage`. + +The normal-runner full repeat also exposed an XP observation race: the guest +had already collected all 21 points before the two-tick in-flight snapshot +(`seen=0`, with the correct XP gain and no remaining orbs). Freeze spawning, +step two world ticks, observe the tracked orbs, then unfreeze for the original +pickup assertions. The targeted check passed with three visible orbs and +exactly 21 points; the full runner restarted with that correction. + +That repeat passed the former XP, swings, flight, boat and minecart failures, +but its level-ticking subcase found a wandering pig on a neighboring block at +Y=66 instead of the landing floor at Y=65. The armor stand landed correctly. +This subcase measures falling and simultaneous level ticking. Each level now +gets a full clear landing/walking area, retaining the pigs' normal AI. A +hazard-then-levels rerun confirmed that both pigs and armor stands land at the +expected heights with distinct entity IDs across levels. + +The broader parity invocation completed **116/117 runs passed**. The remaining +`tab_list` comparison matched 998/1000 lists and all 400 skin images. Both +list mismatches contained `Ⅻ`: the oracle's bitmap-only font setup used the +missing glyph instead of vanilla's Unicode fallback. Load the full default font +reference chain from the prepared assets with vanilla's provider definitions +and default option filters. Prefetch the fake skin lookups together before the +unchanged one-second observation window, retaining deliberately pending cases. +A fresh rerun passed **1000/1000 lists, 3510 frames and 400/400 skin images**, +with zero oracle errors. Fresh secure-chat and dimension-player parity reruns +passed after the command fix as well. The extended command oracle matched all +**843 command/callback records**. + +Rechecking the shared font helper passed eight of nine additional harnesses; +`pack_screen` matched 2778/3000 cases with its old bitmap-only oracle. Its +newline/control glyph metrics also require the Unicode fallback (the newline +advance is 9 with the full font, 6 with the bitmap-only setup). Give this oracle +the same full default font and prepared asset root. A fresh rerun matched +**3000/3000 pack screens**, with zero oracle errors and unchanged comparisons. + +The source self-check passed **1237 Rust tests and 270 Python tests**, rustfmt, +Clippy and doc tests. The private resource copy contains both pinned reports +and a regular `facts.json`, as required by the resource-isolation regression. +Prepared historical test worlds were copied into the ignored fixture cache +where available; they are not player saves or committed resources. + +The final in-frame comparison passed **14/14 cases, zero skipped**: commands, +deflection, both sensor roles, flight, swings, boats, minecarts, chest, prediction, +signs, both dispenser roles and inventory retention. A separate in-frame XP +comparison passed with three visible orbs and exactly 21 points. Friends and +the dedicated-server harness passed through the normal parity runner. + +The final normal-runner server-thread LAN repeat passed **119/119 cases, +zero skipped**, in 1940 seconds. This full sequence includes all earlier failure +cases, both sensor/dispenser roles and the additional regressions from main. +The final full `python3 tools/pr_ready.py` gate passed against merge base +`bd591f985`: **1237 Rust tests, 270 Python tests**, rustfmt, Clippy, public-tree +checks and documentation tests. Its parity stage selected **118 affected +harnesses**; 117 had current content-matched passing records and the remaining +harness passed during the gate. No failed or skipped harness remained. +The gate reported the existing scope warning (35 files, 584 lines of code); +the combined migration exceeded the suggested 500-line size. At that point +the combined PR was marked ready for review. The split below supersedes that +readiness status and the earlier description block. + + +## Gameplay fixes split into independent PRs (2026-10-25) + +At the user's request, the three gameplay fixes were removed from this PR's +net diff and opened independently against `main`: + +- [#1903](https://github.com/ludovic111/horizon/pull/1903): `/clear` off-hand + handling and vanilla inventory-slot order, including the added command-oracle + cases. The independent branch matches **843/843 command/callback records**. +- [#1904](https://github.com/ludovic111/horizon/pull/1904): connected-client + fireball motion and authoritative corrections, including the acceleration + regression and a focused `remote_fireball` integration harness. The new + harness fails on unchanged main in both hosting modes and passes with only + that gameplay fix applied. +- [#1905](https://github.com/ludovic111/horizon/pull/1905): per-player sculk + emission and history, including a focused `server_player_sculk` integration + harness. Without the fix, both server-thread players and the in-frame guest + fail while the in-frame host passes. With only this fix, **4/4 cases** pass, + along with **435/435 vanilla scenarios matching on every tick**. + +Each independent branch passes the quick source self-check using +`lab.game_env()` scratch homes (287 Python tests; 1241 Rust tests for clear +and sculk, 1242 for fireballs; formatting, Clippy and doc tests). Their broader +parity selections are listed for CI, rather than claimed as standalone full +parity passes. + +The migration was merged with main at `8177a6f45` before removing the fixes. +Its test migration, fixture synchronization, isolated environments, control +inspection and font-oracle corrections remain. The **119/119 full LAN pass** +and full affected-parity readiness result above belong to the combined +pre-extraction snapshot `cc9410b6`; they do not establish that the migration +alone passes after the gameplay code has been removed. This PR stays draft +until the three dependencies land and its full integration suite is rerun. + +The post-split migration quick source gate passes **1241 Rust tests and 290 +Python tests**, formatting, Clippy, public-tree and doc checks. It lists **70 +affected parity harnesses** for CI. Full post-split integration validation is +pending the three gameplay dependencies; no replacement full-suite pass is +claimed here. diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java index 09e9911d6..3390b37f6 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java @@ -10,6 +10,8 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Path; import java.util.ArrayList; import java.util.List; +import java.util.HashSet; +import java.util.Set; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GlyphSource; import net.minecraft.client.gui.font.glyphs.BakedGlyph; @@ -31,9 +33,13 @@ import net.minecraft.util.RandomSource; */ public final class ParityFont { public static ResourceManager resources() throws Exception { + return resources(Path.of("/nonexistent-horizon-assets")); + } + + public static ResourceManager resources(Path assets) throws Exception { var method = net.minecraft.client.resources.ClientPackSource.class.getDeclaredMethod("createVanillaPackSource", Path.class); method.setAccessible(true); - var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, Path.of("/nonexistent-horizon-assets")); + var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, assets); return pack.asResourceManager(); } @@ -50,6 +56,38 @@ public final class ParityFont { } } } + return create(providers); + } + + /** The full default font, including references and the external Unihex fallback. */ + public static Font createDefault(ResourceManager resources) throws Exception { + List providers = new ArrayList<>(); + loadProviders(resources, Identifier.withDefaultNamespace("default"), providers, new HashSet<>()); + return create(providers); + } + + private static void loadProviders(ResourceManager resources, Identifier font, List providers, + Set visiting) throws Exception { + if (!visiting.add(font)) throw new IllegalArgumentException("Cyclic font reference: " + font); + var file = font.withPath("font/" + font.getPath() + ".json"); + try (var reader = new InputStreamReader(resources.open(file), StandardCharsets.UTF_8)) { + var json = JsonParser.parseReader(reader).getAsJsonObject(); + for (var element : json.getAsJsonArray("providers")) { + var conditional = GlyphProviderDefinition.Conditional.CODEC.parse(JsonOps.INSTANCE, element).getOrThrow(); + if (!conditional.filter().apply(Set.of())) continue; + var definition = conditional.definition().unpack(); + if (definition.left().isPresent()) { + providers.add(definition.left().orElseThrow().load(resources)); + } else { + loadProviders(resources, definition.right().orElseThrow().id(), providers, visiting); + } + } + } finally { + visiting.remove(font); + } + } + + private static Font create(List providers) { GlyphSource source = new GlyphSource() { @Override public BakedGlyph getGlyph(int codepoint) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java index 9b3509e94..d3513d3ac 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java @@ -370,7 +370,7 @@ public final class VanillaPackScreenOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - font = ParityFont.create(ParityFont.resources()); + font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); Minecraft mc = alloc(Minecraft.class); put(mc, Minecraft.class, "font", font); put(mc, Minecraft.class, "lastInputType", InputType.MOUSE); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java index b48d45041..532c8823c 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java @@ -230,7 +230,7 @@ public final class VanillaTabListOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - Font font = ParityFont.create(ParityFont.resources()); + Font font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); var gson = new Gson(); var out = new StringBuilder(); for (String line : Files.readAllLines(Path.of(args[0]))) { @@ -284,6 +284,8 @@ public final class VanillaTabListOracle { put(mc, Minecraft.class, "user", user); var skins = skinManager(c); put(mc, Minecraft.class, "skinManager", skins); + var profiles = new ArrayList(); + var lookups = new ArrayList>(); for (var p : c.getAsJsonArray("players")) { var o = p.getAsJsonObject(); var uuid = UUID.fromString(o.get("uuid").getAsString()); @@ -296,12 +298,22 @@ public final class VanillaTabListOracle { : new Property("textures", t.get("value").getAsString(), sig.getAsString())); } var profile = new GameProfile(uuid, o.get("name").getAsString(), new PropertyMap(properties)); - // Let the lookup's unpacking and downloads run before the first frame, - // as they would have by the time a player list shows. - try { - skins.get(profile).get(1, java.util.concurrent.TimeUnit.SECONDS); - } catch (java.util.concurrent.TimeoutException pending) { - } + profiles.add(profile); + lookups.add(skins.get(profile)); + } + // Start every lookup before waiting: intentionally pending fake + // downloads must not add a second for each player in the list. + // Keep the same observation window and leave those futures pending. + try { + CompletableFuture.allOf(lookups.toArray(CompletableFuture[]::new)) + .get(1, java.util.concurrent.TimeUnit.SECONDS); + } catch (java.util.concurrent.TimeoutException pending) { + } + int profileIndex = 0; + for (var p : c.getAsJsonArray("players")) { + var o = p.getAsJsonObject(); + var profile = profiles.get(profileIndex++); + var uuid = profile.id(); var info = new PlayerInfo(profile, false); put(info, PlayerInfo.class, "gameMode", GameType.byId(o.get("gameMode").getAsInt())); put(info, PlayerInfo.class, "latency", o.get("latency").getAsInt()); diff --git a/tests/test_game_home.py b/tests/test_game_home.py index b4d9e017f..b0561a9a2 100644 --- a/tests/test_game_home.py +++ b/tests/test_game_home.py @@ -29,6 +29,7 @@ EXEMPT = { "build_release.py": "builds and packs the release", "release_train.py": "release bookkeeping", "pr_ready.py": "runs cargo checks and parity.py", + "test_friends_integration_parity.py": "builds binaries; test_friends.Game isolates every game through integration_env", "port_harness.py": "ports Java code, starts no game", } diff --git a/tests/test_integration_env.py b/tests/test_integration_env.py new file mode 100644 index 000000000..07ba97a1b --- /dev/null +++ b/tests/test_integration_env.py @@ -0,0 +1,50 @@ +"""Automated game runs must never inherit a real player's data directories.""" +import json +import os +from pathlib import Path +import sys +import tempfile +import unittest + +from tools.integration_env import game_environment, run_game, require_server_reports + + +class IntegrationEnvironmentTests(unittest.TestCase): + def test_all_data_homes_and_network_settings_are_overridden(self): + keys = ('HORIZON_HOME', 'HORIZON_LAUNCHER_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME') + with tempfile.TemporaryDirectory() as root: + env = game_environment({**dict.fromkeys(keys, '/real/player'), 'DISPLAY': ':123'}, root) + homes = [Path(env[key]) for key in keys] + self.assertEqual(len(set(homes)), 4) + self.assertTrue(all(p.is_dir() and p.is_relative_to(root) for p in homes)) + self.assertEqual(env['DISPLAY'], ':123') + self.assertEqual(env['HORIZON_TELEMETRY_URL'], 'off') + self.assertEqual(env['HORIZON_LAUNCHER_NO_SELF_UPDATE'], '1') + self.assertEqual(env['HORIZON_NO_AUDIO'], '1') + + def test_each_fixture_process_gets_fresh_homes_and_cleanup(self): + script = ('import json, os; from pathlib import Path; ' + 'homes = [os.environ[k] for k in ' + '("HORIZON_HOME", "HORIZON_LAUNCHER_HOME", "XDG_DATA_HOME", "XDG_CONFIG_HOME")]; ' + 'assert all(Path(p).is_dir() for p in homes); print(json.dumps(homes))') + runs = [json.loads(run_game([sys.executable, '-c', script], env=os.environ, + capture_output=True, text=True, check=True).stdout) for _ in range(2)] + self.assertFalse(set(runs[0]) & set(runs[1])) + self.assertTrue(all(not Path(p).exists() for homes in runs for p in homes)) + + +class PreparedReportTests(unittest.TestCase): + def test_partial_report_install_shadows_complete_fallback(self): + with tempfile.TemporaryDirectory() as root: + resources = Path(root) / 'horizon-client' / '26.3' + fallback = Path(root) / 'datagen' / 'out' / 'reports' + resources.mkdir(parents=True) + fallback.mkdir(parents=True) + for name in ('registries.json', 'commands.json'): + (fallback / name).write_text('{}') + self.assertEqual(require_server_reports(resources).resolve(), fallback) + (resources / 'registries.json').write_text('{}') + with self.assertRaisesRegex(ValueError, 'installed together'): + require_server_reports(resources) + (resources / 'commands.json').write_text('{}') + self.assertEqual(require_server_reports(resources), resources) diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 7f0c52bce..116aed49b 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -75,6 +75,8 @@ def game_env(screen, home=None): extra['HORIZON_HOME'] = home if sys.platform == 'darwin': return lab.game_env(**extra) + if not shutil.which('vscreen') and os.environ.get('DISPLAY'): + return lab.game_env(**extra) env = lab.game_env(VSCREEN=screen, **extra) subprocess.run(['vscreen', 'up'], env=env, check=False, capture_output=True) text = subprocess.run(['vscreen', 'env'], env=env, capture_output=True, text=True, check=True).stdout diff --git a/tools/integration_env.py b/tools/integration_env.py new file mode 100644 index 000000000..ed7122c1e --- /dev/null +++ b/tools/integration_env.py @@ -0,0 +1,54 @@ +"""Per-process scratch data for game integration tests (never a player's home).""" +from pathlib import Path +from contextlib import contextmanager +import os +import subprocess +import tempfile + +try: + from . import lab +except ImportError: + import lab + + +def game_environment(base, root): + root = Path(root) + env = dict(base, HORIZON_TELEMETRY_URL='off') + for key, folder in [('HORIZON_HOME', 'home'), ('HORIZON_LAUNCHER_HOME', 'launcher'), + ('XDG_DATA_HOME', 'data'), ('XDG_CONFIG_HOME', 'config')]: + path = root / folder + path.mkdir(parents=True, exist_ok=True) + env[key] = str(path) + return lab.game_env(env) + + +def run_game(command, **kwargs): + """Run a headless game fixture with the same isolation as real-client tests.""" + with tempfile.TemporaryDirectory(prefix='hz-fixture-') as root: + kwargs['env'] = game_environment(kwargs.pop('env', os.environ), root) + if any(key in kwargs['env'] for key in + ('HORIZON_COMMAND_SCRIPT', 'HORIZON_DISPENSE_FIXTURE', 'HORIZON_SCULK_FIXTURE')): + # These compare seeded rule/callback traces, not the client/server boundary. + command = [*command, '--in-frame'] + return subprocess.run(command, **kwargs) + + +@contextmanager +def suite_lock(): + """Real-client CI suites share a GPU, even when parity.py runs harnesses in parallel.""" + import fcntl + with (Path(tempfile.gettempdir()) / 'horizon-integration-gpu.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + yield + + +def require_server_reports(resources): + """Match Builtin.find: a registry report shadows later fallback directories.""" + resources = Path(resources) + reports = next((p for p in (resources, resources / '../../datagen/out/reports', + resources / '../datagen/out/reports') + if (p / 'registries.json').is_file()), None) + if reports is None or not (reports / 'commands.json').is_file(): + raise ValueError(f'incomplete prepared resources in {resources}: registries.json and ' + 'commands.json must be installed together; prepare the pinned resources again') + return reports diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index f79e07033..ec3b58913 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -1,7 +1,8 @@ #!/usr/bin/env python3 """LAN multiplayer end to end: a host opens its world to LAN and a guest joins, both real games. -Two Horizon clients run side by side under horizon-ctl, each in its own scratch folder. The host +The host uses its integrated server thread by default; --in-frame compares the fallback, and +--server-thread remains accepted. Two Horizon clients run under horizon-ctl in scratch folders. The host creates a survival world and opens it to LAN with commands allowed; the guest connects to it by address. The script then checks, from both sides, what a guest's game used to get wrong (#366): @@ -268,7 +269,6 @@ import math import os import re import shutil -import signal import subprocess import sys import tempfile @@ -280,11 +280,12 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from agent_control_e2e import Cli, Failed, game_env # noqa: E402 import lab # noqa: E402 +from integration_env import game_environment, require_server_reports # noqa: E402 ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' -# The host plays single player on its server thread (--server-thread). -SERVER_THREAD = False +# Match normal single player; --in-frame is the comparison path. +SERVER_THREAD = True CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] @@ -298,6 +299,7 @@ class Game: os.symlink(resources, self.work / '.local/horizon-client' / lab.VERSION) self.socket = self.work / 'c.sock' env = game_env(os.environ.get('VSCREEN', 'lan-e2e'), home=self.work / 'home') + env = game_environment(env, self.work) self.d = Cli(ctl, self.socket, self.work, env) self.d.name = name @@ -323,6 +325,28 @@ class Game: def wait(self, ticks): self.d('wait', ticks=ticks) + def script(self, lines): + """Keep tick-sensitive input in one ctl process, through the normal control commands.""" + result = subprocess.run(self.d.base + ['script'], input='\n'.join(lines) + '\n', + cwd=self.work, env=self.d.env, capture_output=True, text=True, + timeout=600) + replies = [json.loads(line) for line in result.stdout.splitlines() if line.strip()] + ticks = [r['ticks'] for r in replies if 'ticks' in r] + print(f'[{self.name}] script {lines} -> {replies[-1] if replies else result.stderr[:400]}; ticks={ticks}') + assert result.returncode == 0 and replies and not any('error' in r for r in replies), result.stdout + return replies[-1] + + def until(self, observe, predicate, ticks=100): + """Wait for an observable answer, within the existing tick budget.""" + last = observe() + for _ in range(ticks): + if predicate(last): + return last + self.wait(1) + last = observe() + assert predicate(last), f'{self.name}: state did not arrive within {ticks} ticks: {last}' + return last + def close(self): try: self.d('quit') @@ -530,6 +554,8 @@ def check_sign(host, guest, out): host.shot(out, 'sign') assert placed and 'sign' in placed, f'the guest placed {placed}' host_unaffected(host, "the guest's sign") + guest.raw('key', 'esc', 'tap') + guest.raw('wait-for', 'screen', 'playing') return placed @@ -674,7 +700,7 @@ def check_levels(host, guest, out): for name, step in LEVEL_STEPS: try: steps[name] = step(host, guest, out) - except (Failed, AssertionError, StopIteration, KeyError) as e: + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: steps[name], failed = repr(e), failed + [name] for g in (host, guest): back_to_game(g) @@ -747,10 +773,12 @@ def level_ticking(host, guest, out): has its own id across the levels.""" gx, gy, gz = pos_of(guest) hx, hy, hz = pos_of(host) - # A floor of its own beside the host (earlier checks may have broken the open one there). - bx, by, bz = int(hx // 1), int(hy // 1), int(hz // 1) - host('command', command=f'fill {bx - 4} {by - 1} {bz - 4} {bx + 4} {by - 1} {bz - 2} minecraft:stone') - host('command', command=f'fill {bx - 4} {by} {bz - 4} {bx + 4} {by + 4} {bz - 2} minecraft:air') + # Clear the whole walking area in each level: normal pig AI can leave a + # narrow landing strip during the fall/observation window. + for game, x, y, z in ((host, hx, hy, hz), (guest, gx, gy, gz)): + bx, by, bz = int(x // 1), int(y // 1), int(z // 1) + game('command', command=f'fill {bx - 12} {by - 1} {bz - 12} {bx + 12} {by - 1} {bz + 12} minecraft:stone') + game('command', command=f'fill {bx - 12} {by} {bz - 12} {bx + 12} {by + 6} {bz + 12} minecraft:air') guest('command', command=f'summon minecraft:pig {gx + 2.5:.2f} {gy + 3:.2f} {gz:.2f}') guest('command', command=f'summon minecraft:armor_stand {gx - 2.5:.2f} {gy + 3:.2f} {gz:.2f}') host('command', command=f'summon minecraft:pig {hx + 2.5:.2f} {hy + 3:.2f} {hz - 3:.2f}') @@ -762,6 +790,7 @@ def level_ticking(host, guest, out): mobs = [m for m in g.raw('mobs', 8)['near'] if m['kind'] == 'minecraft:pig'] stands = [o for o in g('status')['objects'] if o['kind'] == 'minecraft:armor_stand'] seen[name] = {'pigs': [(m['id'], round(m['pos'][1], 2)) for m in mobs], + 'pig_positions': [m['pos'] for m in mobs], 'stands': [(o['id'], round(o['position'][1], 2)) for o in stands], 'floor': floor} finally: guest('command', command='kill @e[type=!minecraft:player,distance=..8]') @@ -1979,12 +2008,11 @@ def chat_input(game): def complete(guest, text): """Opens the chat on `/`, types `text` and presses Tab: the input after it.""" guest.raw('key', 'slash', 'tap') - guest.wait(3) + guest.until(lambda: guest('screen').get('screen'), lambda s: s == 'chat', ticks=3) guest.raw('type', text) - guest.wait(2) + guest.until(lambda: guest('screen').get('chat_suggestions'), bool, ticks=2) guest.raw('key', 'tab', 'tap') - guest.wait(2) - return chat_input(guest) + return guest.until(lambda: chat_input(guest), lambda value: value != '/' + text, ticks=2) def check_commands(host, guest, out): @@ -2394,7 +2422,8 @@ def check_predict(host, guest, out): seen = {} creaks = lambda game: sum(n for s, n in game('status')['heard'].items() if 'door' in s) heard = {'guest': creaks(guest), 'host': creaks(host)} - os.kill(host.pid, signal.SIGSTOP) + host.raw('server-hold', 'on') + held_at = host.raw('simulation')['game_time'] try: guest.raw('interact', *wood) seen['guest_frozen'] = (state(guest, wood), state(guest, (wood[0], wood[1] + 1, wood[2]))) @@ -2402,8 +2431,9 @@ def check_predict(host, guest, out): seen['guest_heard_frozen'] = creaks(guest) - heard['guest'] guest.raw('interact', *iron) seen['guest_iron_frozen'] = state(guest, iron) + assert host.raw('simulation')['game_time'] == held_at, 'server barrier advanced the world' finally: - os.kill(host.pid, signal.SIGCONT) + host.raw('server-hold', 'off') guest.wait(20) seen['guest_after'] = state(guest, wood) seen['host_after'] = state(host, wood) @@ -2515,7 +2545,11 @@ def check_swings(host, guest, out): guest.wait(10) guest.raw('select', 'minecraft:wooden_hoe') before = guest('state')['swings'] - guest.raw('interact', *soil) + guest.raw('look-at', soil[0] + 0.5, soil[1] + 1, soil[2] + 0.5) + guest.wait(1) + target = guest('state')['looking_at']['block'] + assert target and target['pos'] == list(soil) and target['face'] == 'up', target + guest.raw('mouse', 'right', 'click') guest.wait(10) hoe = {'swings': guest('state')['swings'] - before, 'soil': host.raw('block', *soil)['block']} guest('command', command=f'setblock {soil[0]} {soil[1]} {soil[2]} minecraft:stone') @@ -2622,16 +2656,22 @@ def check_xp(host, guest, out): x, y, z = pos_of(guest) # Three orbs of 7 points 4 blocks east of the guest (out of reach, within the 8 blocks orbs # follow from): they fly to the guest. + # Freeze setup so command/IPC latency cannot let all three be collected + # before the two-tick in-flight observation. + host('command', command='tick freeze') for _ in range(3): guest('command', command=f'summon minecraft:experience_orb {x + 4:.2f} {y + 0.5:.2f} {z:.2f} {{Value:7s}}') + host('command', command='tick step 2') guest.wait(2) seen = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) guest.shot(out, 'xp-orbs') + host('command', command='tick unfreeze') guest.wait(60) xp = guest('state')['player']['xp'] host_xp = host('state')['player']['xp'] left = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) finally: + host('command', command='tick unfreeze') host('command', command='gamemode survival') # Back where it stood: a spectator sinks (Player.travel keeps 0.6 of its fall speed each tick, # about 0.2 blocks from standing), and a later check that makes it survival again would land @@ -2657,9 +2697,7 @@ def check_time(host, guest, out): guest.wait(20) # A stalled game runs at most 10 missed ticks when it wakes (DeltaTracker); the server's # game time, sent every second, moves the guest's clock on (ClientClockManager.tick). - os.kill(guest.pid, signal.SIGSTOP) - time.sleep(4) - os.kill(guest.pid, signal.SIGCONT) + guest.raw('stall', 4000) guest.wait(60) stalled = times() detail = {'paused': paused, 'after_stall': stalled} @@ -3112,12 +3150,10 @@ def same_light(host, guest, lo, hi, what, ticks=100): def check_flight(host, guest, out): def double_jump(game): # LocalPlayer.aiStep: a second jump press within 7 ticks of the first toggles flight. + lines = [] for hold in (1, 4): - game.raw('key', 'space', 'down') - game.wait(hold) - game.raw('key', 'space', 'up') - game.wait(2) - game.wait(10) + lines += ['key space down', f'wait {hold}', 'key space up', 'wait 2'] + game.script(lines + ['wait 10']) return game('state')['player'] def set_mode(game, mode): @@ -3132,6 +3168,9 @@ def check_flight(host, guest, out): players = [('guest', guest)] + ([('host', host)] if SERVER_THREAD else []) seen = {} + # The rule is seven simulation ticks, independent of wall time. A slow + # server clock leaves enough time to deliver the key events even on busy CI. + host('command', command='tick rate 4') try: for name, game in players: set_mode(game, 'creative') @@ -3145,6 +3184,7 @@ def check_flight(host, guest, out): 'stayed': round(later['position'][1] - up['position'][1], 2), 'survival_flying': fell['flying']} finally: + host('command', command='tick rate 20') for _, game in players: game('command', command='gamemode survival') for name, s in seen.items(): @@ -3659,15 +3699,16 @@ def leave_vehicle(player, kind): def break_vehicle(player, vehicle_id, kind): """Hit it with fists until it breaks: VehicleEntity.tick takes 1 off its damage every tick.""" - for _ in range(10): - here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] - if not here: - return - vp = here[0]['position'] - player.raw('look-at', f'{vp[0]:.2f}', f'{vp[1] + 0.3:.2f}', f'{vp[2]:.2f}') - player.raw('mouse', 'left', 'click') - player.wait(2) - raise AssertionError(f'ten hits left the {kind} in place') + here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] + if not here: + return + vp = here[0]['position'] + # Keep the original ten hits/two-tick spacing in one connection. Starting + # several ctl processes per hit lets the vehicle's damage decay between hits. + player.script([f'look-at {vp[0]:.2f} {vp[1] + 0.3:.2f} {vp[2]:.2f}', + *[line for _ in range(10) for line in ('mouse left click', 'wait 2')]]) + assert not any(o['id'] == vehicle_id for o in player('status')['objects']), \ + f'ten hits left the {kind} in place' def check_boats(host, guest, out): @@ -4311,10 +4352,8 @@ def check_deflect(host, guest, out): (Player.attack: AIM_DEFLECT on #redirectable_projectile; Ghast.isReflectedFireball). The ghast is caged (a window toward the host); the game runs at 4 ticks a second, and once the fireball is within 4.5 blocks the host looks at the ghast and clicks.""" - if SERVER_THREAD: - # The fireball's position and the host's hurts are read from the host's own level. - return 'skipped (in-frame only)' - x, y, z = (int(v // 1) for v in pos_of(host)) + back = pos_of(host) + x, y, z = (int(v // 1) for v in back) guest('command', command='gamemode creative') host('command', command='gamemode survival') host('command', command='difficulty normal') @@ -4335,23 +4374,36 @@ def check_deflect(host, guest, out): try: deadline = time.monotonic() + 120 while time.monotonic() < deadline: - balls = [q for q in host.raw('status')['projectiles'] if q['kind'] == 'LargeFireball'] + # Aim and click at the projectile the client actually sees. Holding + # non-player simulation keeps the reach window open while ordinary + # player input and its attack packet cross the connection. + balls = [q for q in host('status')['projectiles'] if q['kind'] == 'LargeFireball'] near = min((math.dist(q['position'], eye) for q in balls), default=None) if near is not None and near < 4.5: + ball = min(balls, key=lambda q: math.dist(q['position'], eye)) + host('command', command='tick freeze') + held_tick = host.raw('simulation')['game_time'] g = [m['pos'] for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast')][0] - host.raw('look-at', f'{g[0]:.2f}', f'{g[1] + 2:.2f}', f'{g[2]:.2f}') - host.raw('mouse', 'left', 'down') - host.raw('mouse', 'left', 'up') + host.script([f'look-at {g[0]:.2f} {g[1] + 2:.2f} {g[2]:.2f}', + 'wait 1', 'mouse left click', 'wait 1']) + host.until(lambda: host.raw('simulation')['projectiles'], + lambda qs: any(q.get('id') == ball['id'] and q.get('player_owned') for q in qs), + ticks=60) + assert host.raw('simulation')['game_time'] == held_tick, 'the deflection barrier advanced simulation' + host('command', command='tick unfreeze') turned = near break host('command', command='tick rate 20') host.wait(60) ghast = [m for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast') and m['health'] > 0] - hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == 'host' for h in pl['hurts'] + hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == (host.player if SERVER_THREAD else 'host') for h in pl['hurts'] if 'fireball' in h['source'] or 'explosion' in h['source']] finally: + host('command', command='tick unfreeze') host('command', command='tick rate 20') host('command', command='kill @e[type=minecraft:ghast]') + host('command', command=f'tp @s {back[0]} {back[1]} {back[2]}') + host.until(lambda: pos_of(host), lambda p: math.dist(p, back) < 0.1) host('command', command=f'fill {gx - 3} {gy - 1} {gz - 3} {gx + 24} {gy + 8} {gz + 3} minecraft:air') guest('command', command='gamemode survival') assert turned is not None, f'no fireball came within 4.5 blocks (nearest {near})' @@ -4537,8 +4589,22 @@ def run(ctl, out, resources, checks): guest.shot(out, 'joined') for name in checks: try: - results[name] = {'pass': True, 'detail': CHECK_FNS[name](host, guest, out)} - except (Failed, AssertionError, StopIteration, KeyError) as e: + # Cases assert their own deaths, menus and held actions before returning. + # Do not let those states turn later independent cases into false failures. + for game in (host, guest): + game.raw('release') + back_to_game(game) + state = game('state') + assert state.get('player') is not None, f'{game.name} lost its session before {name}: {state}' + if state.get('screen') == 'dead' or state['player']['health'] <= 0: + game.raw('respawn') + game.until(lambda: game('state'), + lambda s: s.get('screen') == 'playing' and s['player']['health'] > 0, + ticks=40) + detail = CHECK_FNS[name](host, guest, out) + skipped = isinstance(detail, str) and detail.startswith('skipped') + results[name] = {'pass': not skipped, 'skipped': skipped, 'detail': detail} + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: results[name] = {'pass': False, 'detail': repr(e)} for g in (host, guest): back_to_game(g) @@ -4557,14 +4623,19 @@ def main(): parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build with the fast profile)') parser.add_argument('--check', action='append', choices=CHECKS, help='run only these checks (repeatable)') parser.add_argument('--out', default=str(ROOT / '.local/lan-e2e'), help='screenshots and game logs go here') - parser.add_argument('--server-thread', action='store_true', help="the host's world runs on its server thread") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') args = parser.parse_args() global SERVER_THREAD SERVER_THREAD = args.server_thread if args.bin_dir: bins = Path(args.bin_dir).resolve() else: - subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bins'], + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '--bin', 'horizon-client', '--bin', 'horizon-ctl'], cwd=ROOT, check=True) meta = json.loads(subprocess.run(['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=ROOT, capture_output=True, text=True, check=True).stdout) @@ -4572,9 +4643,16 @@ def main(): resources = lab.RESOURCES.resolve() if not (resources / 'horizon-resources.json').exists(): sys.exit(f'no prepared resources in {resources}') - out = Path(args.out) + try: + require_server_reports(resources) + except ValueError as error: + sys.exit(str(error)) + out = Path(args.out).resolve() out.mkdir(parents=True, exist_ok=True) + print(f'LAN host mode: {"server-thread" if SERVER_THREAD else "in-frame"}') results = run(bins / 'horizon-ctl', out, resources, args.check or CHECKS) + (out / 'results.json').write_text(json.dumps({'mode': 'server-thread' if SERVER_THREAD else 'in-frame', + 'checks': results}, indent=2) + '\n') print(json.dumps(results, indent=1)) sys.exit(0 if results and all(r['pass'] for r in results.values()) else 1) @@ -4631,16 +4709,33 @@ def check_keep_inventory(host, guest, out): neither; with it on, nothing drops and it respawns with both (#1284).""" hx, hy, hz = (int(v // 1) for v in pos_of(host)) seen = {} + # Totem coverage leaves both players near one health. Protect the waiting + # player from residual fire/damage while the other player's death is tested. + for game in (host, guest): + game('command', command='gamemode creative') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') host('command', command=f'setworldspawn {hx} {hy} {hz}') host('command', command='gamerule respawn_radius 0') + # Keep the inactive player alive and away from the death drops. Earlier + # fixtures may leave a personal respawn point or an unsafe waiting position. + host('command', command=f'fill {hx - 6} {hy - 1} {hz - 6} {hx + 6} {hy - 1} {hz + 6} minecraft:stone') + host('command', command=f'fill {hx - 6} {hy} {hz - 6} {hx + 6} {hy + 3} {hz + 6} minecraft:air') + for game, dz in ((host, -3), (guest, 3)): + waiting = (hx - 3.5, hy, hz + dz + 0.5) + game('command', command=f'spawnpoint @s {hx} {hy} {hz}') + game('command', command=f'tp @s {waiting[0]} {waiting[1]} {waiting[2]}') + game.until(lambda: pos_of(game), lambda p: math.dist(p, waiting) < 0.1) try: for keep in ('false', 'true'): host('command', command=f'gamerule keep_inventory {keep}') for game, dz in ((host, -3), (guest, 3)): # 14 blocks from the world spawn: nothing dropped is picked up on respawning. x, z = hx + 14, hz + dz - host('command', command=f'fill {x - 2} {hy - 1} {z - 1} {x + 2} {hy - 1} {z + 1} minecraft:stone') - host('command', command=f'fill {x - 2} {hy} {z - 1} {x + 2} {hy + 2} {z + 1} minecraft:air') + # Death drops scatter several blocks before landing. Keep the + # entire observation area solid so they cannot fall off a ledge. + host('command', command=f'fill {x - 6} {hy - 1} {z - 6} {x + 6} {hy - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 6} {hy} {z - 6} {x + 6} {hy + 3} {z + 6} minecraft:air') host('command', command='kill @e[type=minecraft:item]') game('command', command='gamemode survival') game('command', command='clear @s') @@ -4648,8 +4743,10 @@ def check_keep_inventory(host, guest, out): game('command', command='item replace entity @s armor.head with minecraft:iron_helmet') game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5}') game.wait(20) + assert game('state').get('screen') == 'playing', f'{game.name} died during setup' game('command', command='kill @s') game.wait(30) + assert game('state').get('screen') == 'dead', f'{game.name} did not die' dropped = sorted((e['item']['item'], e['item']['count']) for e in game.raw('entities', 8, 'minecraft:item')['entities']) game.shot(out, f'keepinv-{keep}') @@ -4659,12 +4756,14 @@ def check_keep_inventory(host, guest, out): seen[f'{game.name}-keep-{keep}'] = { 'dropped': dropped, 'kept': {item: server_count(game, item) for item in ('diamond', 'iron_helmet')}} + game('command', command='gamemode creative') finally: host('command', command='gamerule keep_inventory false') host('command', command='gamerule respawn_radius 10') host('command', command='kill @e[type=minecraft:item]') for game in (host, guest): game('command', command='clear @s') + game('command', command='gamemode survival') face_each_other(host, guest) for case, s in seen.items(): want = ({'dropped': [], 'kept': {'diamond': 7, 'iron_helmet': 1}} if case.endswith('true') else @@ -4682,6 +4781,16 @@ def check_signs(host, guest, out): seen = {} for game, other, dz in ((host, guest, -2), (guest, host, 2)): spot = (hx + 2, hy, hz + dz) + for viewer in (game, other): + back_to_game(viewer) + # Earlier death/travel checks leave the players at different spawn points. + # Give this placement case its own floor, line of sight and reachable target. + host('command', command=f'fill {spot[0] - 3} {hy - 1} {spot[2] - 1} {spot[0] + 3} {hy - 1} {spot[2] + 1} minecraft:stone') + host('command', command=f'fill {spot[0] - 3} {hy} {spot[2] - 1} {spot[0] + 3} {hy + 3} {spot[2] + 1} minecraft:air') + for viewer, dx in ((game, -2), (other, 2)): + at = (spot[0] + dx + 0.5, hy, spot[2] + 0.5) + viewer('command', command=f'tp @s {at[0]} {at[1]} {at[2]}') + viewer.until(lambda: pos_of(viewer), lambda p: math.dist(p, at) < 0.1) game('command', command=f'setblock {spot[0]} {spot[1] - 1} {spot[2]} minecraft:stone') game('command', command=f'setblock {spot[0]} {spot[1]} {spot[2]} minecraft:air') game('command', command='gamemode survival') @@ -4689,7 +4798,12 @@ def check_signs(host, guest, out): game('command', command='give @s minecraft:oak_sign 1') game.wait(10) game.raw('place', *spot, '--item', 'minecraft:oak_sign') - game.wait(10) + game.until(lambda: game('state').get('screen'), lambda s: s == 'sign', ticks=10) + # Drain the placement's initial block-entity data before typing. The + # reply travels on the same connection after that data, unlike a local + # screen check which may see the editor before the initial data arrives. + server_reply(game, f'data get block {spot[0]} {spot[1]} {spot[2]} front_text.messages', + 'following block data') opened = {g.name: g('state').get('screen') for g in (game, other)} game.shot(out, 'signs-editor') lines = [f'{game.name} wrote', 'line two'] @@ -4697,11 +4811,13 @@ def check_signs(host, guest, out): game.raw('key', 'enter', 'tap') game.raw('type', lines[1]) game.raw('key', 'esc', 'tap') - game.wait(20) + game.until(lambda: game('state').get('screen'), lambda s: s == 'playing', ticks=20) back_to_game(other) + shown = {g.name: g.until(lambda: (g.raw('block', *spot).get('sign') or {}).get('front'), + lambda front: front == lines + ['', ''], ticks=20) + for g in (game, other)} seen[game.name] = {'opened': opened, - 'shown': {g.name: (g.raw('block', *spot).get('sign') or {}).get('front') - for g in (game, other)}} + 'shown': shown} other.shot(out, 'signs-shown') for name, s in seen.items(): other = 'guest' if name == 'host' else 'host' @@ -5052,8 +5168,12 @@ def check_fishing(host, guest, out): tracked to the clients as a fishing bobber under its owner), lands on the ground and reels back in; cast into open water with Lure III, a fish bites and reeling in during the bite catches it for 1 (#1348).""" + # Both players need a safe floor for the entire other player's fishing wait. + apart(host, guest) hx, hy, hz = (int(v // 1) for v in pos_of(host)) host('command', command='weather clear') + for game in (host, guest): + game('command', command='effect give @s minecraft:instant_health 1 5 true') seen = {} try: for game, other, dz in ((host, guest, -5), (guest, host, 5)): @@ -5369,12 +5489,8 @@ def check_digging(host, guest, out): before = heard('minecraft:block.stone.break') guest.raw('look-at', *at(stone)) guest.raw('mouse', 'left', 'down') - time.sleep(0.4) - os.kill(guest.pid, signal.SIGSTOP) - try: - time.sleep(1.0) - finally: - os.kill(guest.pid, signal.SIGCONT) + guest.wait(8) + guest.raw('stall', 1000) resumed = {'guest': guest.raw('block', *stone).get('block'), 'server': host.raw('block', *stone).get('block'), 'mining': guest('state').get('mining')} # Let go once it breaks: past it the crosshair reaches the floor. @@ -5534,6 +5650,68 @@ CHECKS += ['knockback'] CHECK_FNS.update(knockback=check_knockback) + +def check_fixture_input(host, guest, out, kind, role): + """Complement seeded rules with real client input and authoritative observations.""" + player = host if role == 'host' else guest + hx, y, hz = (int(v // 1) for v in pos_of(host)) + x, z = hx + 6, hz + (-8 if role == 'host' else 8) + sensor, dispenser, button = (x + 3, y, z + 1), (x, y, z + 3), (x, y, z + 2) + player('command', command='gamemode survival') + player('command', command='item replace entity @s weapon.mainhand with minecraft:air') + host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 5} {y - 1} {z + 5} minecraft:stone') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + start = (x + 0.5, y, z + 0.5) + player('command', command=f'tp @s {start[0]} {start[1]} {start[2]} 0 0') + player.until(lambda: pos_of(player), lambda p: math.dist(p, start) < 0.1) + player.raw('look', 0, 0) + try: + if kind == 'sculk': + player.wait(2) # finish setup movement before installing the listener + host.raw('setblock', *sensor, 'minecraft:sculk_sensor') + phase = lambda: host.raw('getblock', *sensor)['block'] + host.until(phase, lambda state: 'sculk_sensor_phase=inactive' in state) + player.wait(10) + assert 'sculk_sensor_phase=inactive' in phase(), 'setup activated the sensor before player input' + player.raw('key', 'w', 'down') + try: + player.wait(15) # defined input duration; no wall-clock simulation sleep + finally: + player.raw('key', 'w', 'up') + moved = {'client': math.dist(pos_of(player), start), + 'server': math.dist(server_player(host, player)['position'], start)} + assert all(d > 1 for d in moved.values()), f'{role} did not walk on both sides: {moved}' + active = host.until(phase, lambda state: 'sculk_sensor_phase=active' in state, ticks=85) + for viewer in (host, guest): + viewer.until(lambda: state_of(viewer, sensor, 'sculk_sensor_phase'), lambda v: v == 'active') + return {'moved': moved, 'phase': active} + host.raw('setblock', *dispenser, 'minecraft:dispenser[facing=east]') + host.raw('container', *dispenser, 'minecraft:diamond', 1) + host.raw('setblock', *button, 'minecraft:stone_button[face=wall,facing=north]') + player.until(lambda: player.raw('block', *button)['block'], lambda v: v == 'minecraft:stone_button') + player.raw('interact', *button) + slots = host.until(lambda: host.raw('container', *dispenser)['slots'], lambda v: all(s is None for s in v)) + dropped = {} + for viewer in (host, guest): + dropped[viewer.name] = viewer.until( + lambda: [e for e in viewer.raw('entities', 24, 'minecraft:item')['entities'] + if e.get('item', {}).get('item') == 'minecraft:diamond' + and math.dist(e['pos'], (x + 1.5, y + 0.5, z + 3.5)) < 3], + lambda drops: len(drops) == 1 and drops[0]['item']['count'] == 1) + player.shot(out, f'{kind}-input') + return {'slots': slots, 'drops': dropped} + finally: + player.raw('key', 'w', 'up') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + + +for _kind in ('sculk', 'dispenser'): + for _role in ('host', 'guest'): + _name = f'{_kind}_input_{_role}' + CHECKS.append(_name) + CHECK_FNS[_name] = lambda h, g, o, kind=_kind, role=_role: check_fixture_input(h, g, o, kind, role) + + def check_hero_trading(host, guest, out): """Villager.updateSpecialPrices keeps the trading player's Hero effect: the offer sent to the client and the server's payment consumption agree, independently of the other player's effect.""" diff --git a/tools/oracle_harness.py b/tools/oracle_harness.py index 92e2a26a2..787c8a293 100644 --- a/tools/oracle_harness.py +++ b/tools/oracle_harness.py @@ -9,13 +9,16 @@ import subprocess try: from . import lab, test_rust_parity as base, test_model_baking_parity as baking + from .integration_env import run_game except ImportError: import lab, test_rust_parity as base, test_model_baking_parity as baking + from integration_env import run_game def run_logged(command, build, name, timeout=900, **kwargs): with (build / (name + '.log')).open('w') as log: - subprocess.run([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + runner([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, stdout=log, stderr=subprocess.STDOUT, **kwargs) diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py index 877bd0b38..5761ef485 100644 --- a/tools/test_command_exec_parity.py +++ b/tools/test_command_exec_parity.py @@ -25,9 +25,11 @@ import sys try: from . import lab, test_rust_parity as base + from .integration_env import run_game from . import command_exec_corpus as corpus_module except ImportError: import lab + from integration_env import run_game import test_rust_parity as base import command_exec_corpus as corpus_module @@ -55,7 +57,8 @@ def main(): def run(command, name, **kw): with (build / (name + '.log')).open('w', encoding='utf-8') as log: - result = subprocess.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + result = runner(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) if result.returncode: tail = (build / (name + '.log')).read_text(errors='replace')[-3000:] sys.exit(f'{name} failed ({result.returncode}):\n{tail}') diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index 49a934987..ee0eb46f5 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -65,13 +65,16 @@ import struct import subprocess import sys import threading +import tempfile import time import zlib try: from . import lab, oracle_harness as oh, test_rust_parity as base + from .integration_env import game_environment, run_game from .lab import free_port # the other server harnesses import it from here except ImportError: + from integration_env import game_environment, run_game import lab import oracle_harness as oh import test_rust_parity as base @@ -124,9 +127,11 @@ class Server: self.log_path = directory.parent / f'{log_name}.log' self.log = self.log_path.open('w', encoding='utf-8') self.lines = [] - self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE, + self.scratch = tempfile.TemporaryDirectory(prefix='hz-server-') + env = game_environment(os.environ, self.scratch.name) + self.process = subprocess.Popen(list(map(str, command)), cwd=directory, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, - encoding='utf-8', errors='replace', env=lab.game_env()) + encoding='utf-8', errors='replace') self.reader = threading.Thread(target=self._read, daemon=True) self.reader.start() @@ -163,6 +168,7 @@ class Server: self.process.wait() self.reader.join(timeout=10) self.log.close() + self.scratch.cleanup() def settle(server, ticks=600, timeout=600): @@ -359,7 +365,7 @@ def horizon_client_joins(vanilla_server, binary, world, build, reference): server.wait_for(r'Done \(') env = lab.game_env(HORIZON_NET_REPORT=report) with (build / 'horizon-client-run.log').open('w') as log: - subprocess.run([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, + run_game([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, '--server', f'127.0.0.1:{port}', '--name', PLAYER]], cwd=client_dir, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) server.wait_for(r'left the game', timeout=30) diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py index a6d1f429a..04f599e34 100644 --- a/tools/test_dispenser_parity.py +++ b/tools/test_dispenser_parity.py @@ -17,7 +17,9 @@ import random import subprocess try: from . import block_update_harness as h, lab, test_rust_parity as base + from .integration_env import run_game except ImportError: + from integration_env import run_game import block_update_harness as h import lab import test_rust_parity as base @@ -349,7 +351,8 @@ def voice(line): def run(command, **kwargs): - done = subprocess.run(command, capture_output=True, text=True, **kwargs) + runner = run_game if str(command[0]).endswith('/horizon-client') else subprocess.run + done = runner(command, capture_output=True, text=True, **kwargs) if done.returncode: print((done.stdout + done.stderr)[-4000:]) raise SystemExit(f'{command[0]} failed') diff --git a/tools/test_friends.py b/tools/test_friends.py index cc5d15b92..fd3d626a9 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -15,8 +15,9 @@ is off: nothing leaves the machine. python3 tools/test_friends.py --client target/fast/horizon-client --relay target/fast/horizon-relay -`--server-thread` runs the host's world on its integrated server's own -thread (the window is a client of it, as Open to LAN publishes it). +The host runs on its integrated server thread by default (the window is a +client of it). `--in-frame` compares the fallback; `--server-thread` is accepted +for compatibility. `--role host|guest` runs one side only (two machines, e.g. over a tailnet): the host prints the code, the guest takes it with `--code` (`--relay-url` @@ -36,8 +37,10 @@ import urllib.request try: from . import lab + from .integration_env import game_environment, require_server_reports except ImportError: import lab + from integration_env import game_environment, require_server_reports ROOT = Path(__file__).resolve().parents[1] @@ -84,7 +87,7 @@ class Game: prefix = [] extra = [] # The host's world on its server thread (`--server-thread`), else in the window. - server_thread = False + server_thread = True def __init__(self, client, resources, work, name, env): # Either way explicitly, whatever the game's default. @@ -96,7 +99,8 @@ class Game: self.process = subprocess.Popen(Game.prefix + [ str(client), '--resources', str(resources), '--render-distance', '2', '--test-terrain', '--control-socket', str(self.endpoint), '--timeout-seconds', '600', - ] + Game.extra, cwd=self.home, env=lab.game_env(HORIZON_HOME=self.home, **env), + ] + Game.extra, cwd=self.home, + env={**game_environment({**os.environ, **env}, self.home), 'HORIZON_HOME': str(self.home)}, stdout=self.log, stderr=subprocess.STDOUT) wait_for(self.endpoint, 'screen', lambda v: v['screen'] == 'title', 120, f'{name} title') @@ -149,10 +153,11 @@ def play_together(host, guest, name, round_index): before = guest_pos(host, name) guest('look 0 0') guest('key w down') - time.sleep(1.5) - guest('key w up') - host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, - 20, 'guest movement on the host') + try: + host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, + 20, 'guest movement on the host') + finally: + guest('key w up') # The host moves; the guest sees the host's player there. hp = host('status')['player']['position'] target = [hp[0] + 3.0, hp[1], hp[2] + 1.0] @@ -179,10 +184,11 @@ def play_together(host, guest, name, round_index): guest.wait('status', lambda v: v['target']['pos'] == block, 10, 'the guest aiming at the block') # Held for a few ticks, as a player clicks (creative breaks at once). guest('mouse left down') - time.sleep(0.25) - guest('mouse left up') - host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, - 'the guest breaking the block, on the host') + try: + host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, + 'the guest breaking the block, on the host') + finally: + guest('mouse left up') guest.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, 'the broken block on the guest') @@ -250,7 +256,7 @@ def full(args, work): join(guest, code, 'Guest') play_together(host, guest, 'Guest', 1) assert host('friends status')['direct'] == 1, host('friends status') - print('code alone: chat, movement and blocks both ways, no server involved') + print('code alone: chat, movement and blocks both ways, no relay involved') leave(host, guest, 'Guest') host('friends stop') assert host('friends status')['code'] is None @@ -316,8 +322,8 @@ def one_side(args, work): if args.role == 'host': code = host_world(game) print(f'CODE {code}', flush=True) - game.wait('lan status', lambda v: v['guests'], args.wait, 'a guest') - game.wait('lan status', lambda v: not v['guests'], args.wait, 'the guest leaving') + game.wait('lan status', lambda v: any(g['name'] == 'Remote' for g in v['guests']), args.wait, 'a guest') + game.wait('lan status', lambda v: all(g['name'] != 'Remote' for g in v['guests']), args.wait, 'the guest leaving') print(f'host: {game("friends status")}') else: join(game, args.code, 'Remote') @@ -347,16 +353,25 @@ def main(): parser.add_argument('--hold', type=float, default=0, help='guest: stay this many seconds before leaving') parser.add_argument('--baseline', action='store_true', help='first run the same checks over plain LAN') parser.add_argument('--offscreen', action='store_true', help='run the games without a window') - parser.add_argument('--server-thread', action='store_true', help="the host's world on its server thread") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') parser.add_argument('--xvfb', action='store_true', help='run the games under xvfb-run (headless Linux)') args = parser.parse_args() Game.prefix = ['xvfb-run', '-a'] if args.xvfb else [] Game.extra = ['--offscreen'] if args.offscreen else [] Game.server_thread = args.server_thread args.client, args.resources = args.client.resolve(), args.resources.resolve() + try: + require_server_reports(args.resources) + except ValueError as error: + parser.error(str(error)) # Short: Unix socket paths are limited to about 100 bytes. with tempfile.TemporaryDirectory(prefix='hzf-', dir='/tmp') as directory: work = Path(directory) + print(f'Friends host mode: {"server-thread" if Game.server_thread else "in-frame"}') if args.role: return one_side(args, work) assert args.relay, 'give --relay (the relay binary, run locally for the relay half)' diff --git a/tools/test_friends_integration_parity.py b/tools/test_friends_integration_parity.py new file mode 100644 index 000000000..c97787803 --- /dev/null +++ b/tools/test_friends_integration_parity.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +"""Real clients over LAN, direct invitations and a local relay, with a server-thread host. + +Registered with parity.py so changes to the drivers and the game binary select +this integration coverage in CI as well as the deterministic library probes. +""" +import json +from pathlib import Path +import subprocess +import sys + +import lab +import test_friends +from integration_env import suite_lock + + +if __name__ == '__main__': + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '-p', 'horizon-relay', '--bin', 'horizon-client', '--bin', 'horizon-ctl', + '--bin', 'horizon-relay'], cwd=lab.ROOT, check=True) + metadata = json.loads(subprocess.check_output( + ['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=lab.ROOT, text=True)) + bins = Path(metadata['target_directory']) / 'fast' + sys.argv = [sys.argv[0], '--client', str(bins / 'horizon-client'), + '--relay', str(bins / 'horizon-relay'), '--baseline', + *(['--offscreen'] if sys.platform == 'darwin' else [])] + with suite_lock(): + # The wrapper only selects binaries; test_friends isolates each game + # through integration_env and lab.game_env. + test_friends.main() diff --git a/tools/test_lan_integration_parity.py b/tools/test_lan_integration_parity.py new file mode 100644 index 000000000..773a7cd82 --- /dev/null +++ b/tools/test_lan_integration_parity.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +"""Register the real-client LAN suite with parity.py's traced harness selection. + +The assertions live in lan_e2e; this is integration coverage, alongside the +fast vanilla differential probes. The host uses the normal server thread. +Linux runners need a display (for example xvfb-run -a). +""" +import lan_e2e +from integration_env import suite_lock + + +if __name__ == '__main__': + with suite_lock(): + lan_e2e.main() diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py index d03838bf3..8096efd80 100644 --- a/tools/test_online_mode_parity.py +++ b/tools/test_online_mode_parity.py @@ -50,11 +50,13 @@ import urllib.parse try: from . import lab, oracle_harness as oh, test_rust_parity as base from .test_dedicated_server_parity import Server, free_port + from .integration_env import run_game except ImportError: import lab import oracle_harness as oh import test_rust_parity as base from test_dedicated_server_parity import Server, free_port + from integration_env import run_game NAME = 'online-mode-parity' PLAYER = 'Tester' @@ -185,7 +187,7 @@ def run_client(binary, build, port, label, token, discovery): if token: command += ['--session-file', session_file(directory, token)] with (build / f'client-{label}.log').open('w') as log: - subprocess.run([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, + run_game([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) got = json.loads(report.read_text()) got['session file left'] = (directory / 'session.json').exists() diff --git a/tools/test_pack_screen_parity.py b/tools/test_pack_screen_parity.py index 1f3f03ede..77249ec5e 100644 --- a/tools/test_pack_screen_parity.py +++ b/tools/test_pack_screen_parity.py @@ -147,7 +147,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaPackScreenOracle'))], 'compile-java') run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaPackScreenOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', lab.RESOURCES / 'assets'], 'vanilla') lib.cargo_example('horizon-client', 'pack_screen_fixture', lib.RESOURCES, inputs, build / 'rust.jsonl') vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()] rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()] diff --git a/tools/test_tab_list_parity.py b/tools/test_tab_list_parity.py index 4075859e7..3d7c84d62 100644 --- a/tools/test_tab_list_parity.py +++ b/tools/test_tab_list_parity.py @@ -240,7 +240,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaTabListOracle', 'VanillaSkinImageOracle'))], 'compile-java') run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTabListOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', resources / 'assets'], 'vanilla') run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe', '--', 'tab_list_fixture', resources, inputs, build / 'rust.jsonl'], 'rust') images = build / 'skins.txt'; images.write_text(''.join(i + '\n' for i in skin_images(args.images))) From e50a4c6443ef1a8dcb997ef79fc47ab759c36f04 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 20:57:18 +0100 Subject: [PATCH 06/70] Play no place sound when a block item placement is refused Clicking with a torch or flower into a space that is already taken (or where the block cannot stand) made the server-thread client play the block's place sound when the server resent the refused target. BlockItem.place returns FAIL before playSound when canPlace() is false, and the client only hears its own predicted placement, so clear the pending place sound when no placement was predicted. --- crates/horizon-client/src/game/remote.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 03b48df3d..97edae862 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3905,6 +3905,10 @@ impl Game<'_> { if let Some(placed) = &placed { self.predict_place(placed, seq); self.with_hand(hand, Game::consume_held); + } else if let Some(r) = self.remote.as_mut() { + // BlockItem.place plays its sound only once the block is set: the + // server's resend of the target it refused is no placement. + r.placing = None; } if reacts || placed.is_some() { self.with_hand(hand, Game::swing_arm); From 785e83feebb6bfcff4a28585113161e26f484af6 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 21:31:31 +0100 Subject: [PATCH 07/70] Firework explosions hurt nearby players, not only the boosted one FireworkRocketEntity.dealExplosionDamage hurts every LivingEntity within 5 blocks that the rocket can see (its feet or its middle, ClipContext COLLIDER with no fluids), besides the entity it is attached to. Horizon only hurt the attached player and the nearby mobs, so a rocket bursting next to a player on foot did nothing to them, in both single player modes. The player (unless it is the attached one) and every guest in the level now take damageAmount * sqrt((5 - distanceTo) / 5) as fireworks damage, with the armor wear of hurtServer. distanceTo is a float, as vanilla computes it, for the mobs too. --- crates/horizon-client/src/game/fireworks.rs | 82 +++++++++++++++++---- crates/horizon-client/src/game/lan_mobs.rs | 14 +++- 2 files changed, 79 insertions(+), 17 deletions(-) diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs index 7838c9590..2c98a12ad 100644 --- a/crates/horizon-client/src/game/fireworks.rs +++ b/crates/horizon-client/src/game/fireworks.rs @@ -71,6 +71,12 @@ impl Rocket { (self.position, self.velocity) } } +/// `damageAmount * (float)Math.sqrt((5.0 - this.distanceTo(target)) / 5.0)`, +/// `distanceTo` being a float. +fn blast_damage(damage: f32, distance_sqr: f64) -> f32 { + let distance = distance_sqr.sqrt() as f32; + damage * ((5.0 - f64::from(distance)) / 5.0).sqrt() as f32 +} pub(super) fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { // The item's default component: flight 1, no explosions. stack @@ -251,21 +257,24 @@ impl Game<'_> { let at = [r.position.x, r.position.y, r.position.z]; if !r.explosions.is_empty() { let damage = 5.0 + r.explosions.len() as f32 * 2.0; - // The player it boosts takes the full damage, a guest as well. - if r.attached { - match r.guest { - None => self.hurt_player_by("minecraft:fireworks", damage), - Some(conn) => { - if let Some(mut host) = self.lan.take() { - self.as_guest(&mut host, conn, |g| { - g.hurt_player_by("minecraft:fireworks", damage); - }); - self.lan = Some(host); - } - } - } - } let from = r.position; + // `attachedToEntity` takes the full damage, a guest as well; every + // other player in range and in sight takes the blast. + let boosted = r.guest.filter(|_| r.attached); + if r.attached && boosted.is_none() { + self.rocket_hurt_player(damage); + } else { + self.rocket_blast_player(from, damage); + } + if let Some(conn) = boosted + && let Some(mut host) = self.lan.take() + { + self.as_guest(&mut host, conn, |g| g.rocket_hurt_player(damage)); + self.lan = Some(host); + } + // Every other player in the level (LAN guests, the players of a + // server thread), each swapped in as the player. + self.each_guest_hit_except(boosted, |g| g.rocket_blast_player(from, damage)); let hits: Vec<(u32, f32)> = { let world = self.mob_world_base(&[]); self.mobs @@ -285,7 +294,7 @@ impl Game<'_> { ); world.clear_between(from, to, false) }); - sees.then(|| (m.id, damage * ((5.0 - d2.sqrt()) / 5.0).sqrt() as f32)) + sees.then(|| (m.id, blast_damage(damage, d2))) }) .collect() }; @@ -307,6 +316,49 @@ impl Game<'_> { self.particles .fireworks(at, v, r.explosions.clone(), camera); } + /// `dealExplosionDamage` on a player that is not the rocket's + /// `attachedToEntity`: within 5 blocks, when the rocket sees its feet or + /// its middle (`ClipContext.Block.COLLIDER`, no fluids). + fn rocket_blast_player(&mut self, from: Vec3, damage: f32) { + let Some(p) = self.player.as_ref() else { + return; + }; + let feet = p.position; + let d2 = (feet.x - from.x).powi(2) + (feet.y - from.y).powi(2) + (feet.z - from.z).powi(2); + if d2 > 25.0 { + return; + } + let height = f64::from(p.dimensions.height); + let sees = { + let world = self.mob_world_base(&[]); + (0..2).any(|step| { + let to = Vec3::new(feet.x, feet.y + height * 0.5 * f64::from(step), feet.z); + world.clear_between(from, to, false) + }) + }; + if sees { + self.rocket_hurt_player(blast_damage(damage, d2)); + } + } + /// `hurtServer` with `damageSources().fireworks`: armor absorbs it and + /// wears (`hurtArmor`); creative and spectator players are immune. + fn rocket_hurt_player(&mut self, amount: f32) { + if self.creative || self.spectator() { + return; + } + let hurt = if let Some(p) = self.player.as_mut() + && !p.health.dead_or_dying() + && let Some(id) = self.motion.health.damage.id("minecraft:fireworks") + { + p.hurt(&self.motion.health, self.world.health_rules, id, amount) + .unwrap_or(false) + } else { + false + }; + if hurt { + self.hurt_armor(amount); + } + } /// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera, /// lit at the rocket's light probe. pub(super) fn rocket_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index be277b6e0..ee38869a4 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -119,7 +119,17 @@ impl Game<'_> { /// Runs `f` as each guest in play here, for what strikes every player in /// an area (`Level.getEntities`), not only the window's own. - pub(super) fn each_guest_hit(&mut self, mut f: impl FnMut(&mut Self)) { + pub(super) fn each_guest_hit(&mut self, f: impl FnMut(&mut Self)) { + self.each_guest_hit_except(None, f); + } + + /// [`Self::each_guest_hit`] leaving out the guest `except` (the one a + /// firework rocket is attached to, which it hurts on its own). + pub(super) fn each_guest_hit_except( + &mut self, + except: Option, + mut f: impl FnMut(&mut Self), + ) { let Some(mut host) = self.lan.take() else { return; }; @@ -127,7 +137,7 @@ impl Game<'_> { .hub .guests .iter() - .filter(|g| host.hub.here(g) && g.loaded && !g.dead) + .filter(|g| host.hub.here(g) && g.loaded && !g.dead && Some(g.conn) != except) .map(|g| g.conn) .collect(); for conn in conns { From 21019afc2bdfe37454fbe05a609de7ccffc8c5b4 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 22:18:14 +0100 Subject: [PATCH 08/70] Vehicle storage menus edit the vehicle's own items A chest minecart, hopper minecart or chest boat's menu edits a stand-in container, which is meant to be copied back to the vehicle when the menu closes. close_container took the open container before calling close_cart_container, which then found nothing open and copied nothing: items taken out came back on the next open, and items put in vanished. Copy the stand-in back from the key close_container took. A server player's clicks in such a menu copy it back at once, since the menu is the vehicle's own inventory (ContainerEntity, AbstractMinecartContainer and ChestBoat implement the container the menu reads and writes). --- crates/horizon-client/src/game.rs | 3 +- crates/horizon-client/src/game/lan_actions.rs | 4 ++ crates/horizon-client/src/game/minecarts.rs | 37 +++++++++++++------ 3 files changed, 31 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1e6158bc4..021d8fa32 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -5472,6 +5472,8 @@ impl Game<'_> { self.craft_size = 2; self.craft_table = None; if let Some(key) = self.container.take() { + // A cart's or chest boat's items go back to it. + self.close_cart_container(key); self.container_opener_event(key, false); self.post_block_game_event( "minecraft:container_close", @@ -5511,7 +5513,6 @@ impl Game<'_> { self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } self.close_ender_chest(); - self.close_cart_container(); } /// `quickMoveStack` of the open plain menu for a shift-click. fn inventory_quick_move(&mut self, slot: usize) -> bool { diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 9d4d868e0..cd7d8035b 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1138,6 +1138,10 @@ impl Game<'_> { { self.container_changed(key); } + // A vehicle's menu edits the vehicle's own items. + if let Some(Slots::Block(key)) = slots { + self.store_cart_items(key); + } self.drop_guest_items(host, gi, drops); } S::ContainerClose(p) => { diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 6b8b51dde..004b72ebf 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -1117,22 +1117,35 @@ impl Game<'_> { self.swing_arm(); true } - /// Closing a cart's container copies the items back. - pub(super) fn close_cart_container(&mut self) { - let Some(key) = self.container.filter(|k| k.1 == CART_KEY_Y) else { - return; - }; - let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) else { + /// Closing the cart's container open under `key` copies the items back. + pub(super) fn close_cart_container(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + self.store_cart_items(key); + self.world.block_entities.remove(&key); + if let Some(c) = self.carts.iter().find(|c| c.id as i32 == key.2) + && c.kind == CartKind::Chest + { + let at = [c.position.x, c.position.y, c.position.z]; + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio + .play("minecraft:block.chest.close", Some(at), 0.5, pitch); + } + } + /// The menu of a chest or hopper minecart or a chest boat works on the + /// vehicle's own items (`ContainerEntity`): the placeholder under `key` + /// that the menu edits is copied back to the vehicle. + pub(super) fn store_cart_items(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&key) else { return; }; + let items = items.clone(); if let Some(c) = self.carts.iter_mut().find(|c| c.id as i32 == key.2) { c.items = items; - let at = [c.position.x, c.position.y, c.position.z]; - if c.kind == CartKind::Chest { - let pitch = self.world.random.next_float() * 0.1 + 0.9; - self.audio - .play("minecraft:block.chest.close", Some(at), 0.5, pitch); - } } else if let Some(b) = self.boats.iter_mut().find(|b| b.id as i32 == key.2) { b.items = items; } From f988ed417a70f61f285cadf00cc627afb56a0128 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 21:41:32 +0100 Subject: [PATCH 09/70] Drop a pending server trip when its player is teleported within the level A server's player sent into another level waits on a trip until the chunks around its target load, and the server leaves its body alone and skips its portal checks until then. A /tp within the level while the arrival was still loading left that trip behind: its target lost its loading tickets and never finished, so Nether, End and gateway portals stopped taking the player until they went back to the abandoned spot. ServerPlayer.teleport within a level places the player at once, so the pending arrival is now abandoned. server-dimension-players gains the case: sent far into the Nether, teleported back near the origin before the far chunks load, then an End portal there. --- crates/horizon-client/src/game/commands.rs | 6 ++++++ tools/test_server_dimension_players_parity.py | 5 +++++ 2 files changed, 11 insertions(+) diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 69c06d97e..585f8f357 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1094,6 +1094,12 @@ impl Game<'_> { Target::Player => { // ServerPlayer.teleport: removeVehicle before placing the player. self.stop_riding(); + // A server's player teleported within their level is placed + // there at once: the arrival they were waiting for elsewhere + // in it (whose chunks lose their tickets) is abandoned. + if let Some(conn) = self.lan_acting { + self.server_trips.retain(|trip| !trip.is(conn)); + } if let Some(p) = self.player.as_mut() { p.position = v; p.velocity = Vec3::new(0.0, 0.0, 0.0); diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py index b1efc4378..7ce04cb3f 100644 --- a/tools/test_server_dimension_players_parity.py +++ b/tools/test_server_dimension_players_parity.py @@ -41,6 +41,11 @@ SCRIPT = [ # Through an End portal (Entity.handlePortal), and back by command. ('bob-portal', ['cmd Bob setblock 2 101 3 minecraft:end_portal', 'cmd Bob tp @s 2.5 101 3.5']), ('bob-portal-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), + # Sent far into the Nether, then teleported within it before the far chunks load: a portal there + # still takes him (the abandoned arrival does not hold him). + ('bob-retarget', [f'cmd Bob execute in {NETHER} run tp @s 8192.5 100 0.5', 'cmd Bob tp @s 0.5 100 0.5']), + ('bob-retarget-portal', ['cmd Bob setblock 0 101 3 minecraft:end_portal', 'cmd Bob tp @s 0.5 101 3.5']), + ('bob-retarget-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), ] STEP_SECONDS = 5.0 From 2c0d9cc30efe46a2d1c39c9d06cb86b825ff840b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 21:37:13 +0100 Subject: [PATCH 10/70] Tick End gateways' server copies on a server without a window A used End gateway never worked again on the server thread or on a dedicated server. TheEndGatewayBlockEntity's server ticker (portalTick) ran only inside the client block-entity pass, which returns at once when there is no renderer, so the 40 tick cooldown that EndGatewayBlock.entityInside starts (triggerCooldown) never ran out. A Game without a renderer now runs portalTick on the gateways it keeps a server copy of, in block-ticking chunks as Level.tickBlockEntities does, and sends triggerCooldown's block event every 2400 ticks of age. --- .../src/game/block_entity_anims.rs | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs index 619fcd009..6df2ff02a 100644 --- a/crates/horizon-client/src/game/block_entity_anims.rs +++ b/crates/horizon-client/src/game/block_entity_anims.rs @@ -171,6 +171,11 @@ impl Game<'_> { /// client tick (`ClientLevel.tickBlockEntities`). pub(super) fn tick_block_entity_anims(&mut self) { let Some(r) = &self.renderer else { + // A server has no window, but its gateways still run their + // server ticker. + if self.remote.is_none() { + self.tick_gateway_servers(); + } return; }; // Sorted by position: the order they tick in, and a quick lookup. @@ -330,6 +335,31 @@ impl Game<'_> { } self.be_anims.present = positions; } + /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the + /// gateways a server keeps a copy of, in block-ticking chunks + /// (`Level.tickBlockEntities`): the cooldown an entry started runs out, + /// and every 2400 ticks `triggerCooldown` sends its block event. + fn tick_gateway_servers(&mut self) { + let levels = self.tickets.levels(); + let mut positions: Vec<[i32; 3]> = self + .be_anims + .gateway_servers + .keys() + .copied() + .filter(|p| levels.block_ticking_at(p[0], p[2])) + .collect(); + positions.sort_unstable(); + for pos in positions { + let triggered = self + .be_anims + .gateway_servers + .get_mut(&pos) + .is_some_and(EndGateway::portal_tick); + if triggered { + self.block_entity_event(pos, 1, 0); + } + } + } /// `EndGatewayBlock.entityInside` on the server: whether the gateway at /// `pos` let the entity in (`triggerCooldown`, with its block event). pub(super) fn gateway_enter(&mut self, pos: [i32; 3]) -> bool { From c7432c21e152dfc566580a40917d092c227ac197 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 22:39:25 +0100 Subject: [PATCH 11/70] Check a server player's moves with the box of its pose A player sprint-swimming up under a ceiling was sent back every tick on the server thread (and for LAN guests): the server never updated the player's pose, and handlePlayerPositionChange's collision check always used a standing 1.8-block box, so the 0.6-block swimming box the client moved with looked like it entered the ceiling. Player.tick ends with updatePlayerPose, and the check uses getBoundingBox, so run updatePlayerPose in the server player's tick and check moves with the pose's dimensions. Fixes #1899. --- crates/horizon-client/src/game/lan_actions.rs | 3 +++ crates/horizon-client/src/lan/hub.rs | 19 +++++++++++++------ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 9d4d868e0..6dfc68c08 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -2111,6 +2111,9 @@ impl Game<'_> { let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); + // Player.tick ends with updatePlayerPose: a swimmer, or a player + // crawling under a block, takes the short box its moves are checked with. + let _ = w.update_player_pose(); let mut events = std::mem::take(&mut w.player.events); // WitherRoseBlock.entityInside along those moves. for event in &events { diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index b462536b9..910911d80 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -2175,17 +2175,24 @@ impl Hub { if g.spectator() || g.sleeping { return (false, false); } - let height = if g.fall_flying { - 0.6 + // getBoundingBox: the box of the body's pose (swimming and crawling + // are 0.6 tall), so a swimmer under a ceiling isn't sent back. + let (half, height) = if g.fall_flying { + (0.3, 0.6) + } else if let Some(m) = &g.motion { + ( + f64::from(m.dimensions.width) / 2.0, + f64::from(m.dimensions.height), + ) } else if g.sneaking { - 1.5 + (0.3, 1.5) } else { - 1.8 + (0.3, 1.8) }; let at = |p: [f64; 3]| { Aabb::new( - Vec3::new(p[0] - 0.3, p[1], p[2] - 0.3), - Vec3::new(p[0] + 0.3, p[1] + height, p[2] + 0.3), + Vec3::new(p[0] - half, p[1], p[2] - half), + Vec3::new(p[0] + half, p[1] + height, p[2] + half), ) }; let (old, new) = (at(g.position), at(to)); From bbc57aa838c52a7120722a0bf4ea2df2f644c473 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 21:59:37 +0100 Subject: [PATCH 12/70] Save furnace, brewing stand and crafter edits made through a server menu A server player's clicks in a furnace, brewing stand or crafter menu wrote the block entity's slots but never marked it changed, so the chunk was not saved: an idle furnace (nothing burning, so its own tick changes nothing) given or emptied through its menu rolled back on reopen or chunk unload, losing or duplicating the items. Comparators kept the old reading too. When the click changed the container's slots, call container_changed (BlockEntity.setChanged, reached through Slot.setChanged in vanilla's AbstractContainerMenu.doClick and quickMoveStack), as chest-like menus already do. --- crates/horizon-client/src/game/lan_crafting.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index f74935522..d3c4b1825 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -291,6 +291,11 @@ impl Game<'_> { let at = host.hub.guests[gi].position; self.award_furnace_recipes(pos, at); } + // Slot.setChanged on a changed container slot: BlockEntity.setChanged, + // so the chunk is saved and comparators read the block again. + if (0..items.len()).any(|k| menu.slot(k) != items[k].as_ref()) { + self.container_changed(pos); + } host.play.entry(conn).or_default().crafting.machine = Some((p.container, menu)); host.hub.inventory_clicked(conn, p, &self.world, &changed); true From a6548089c4677e1cf11a03a6f52cff63ba116f2b Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Sun, 25 Oct 2026 23:09:19 +0100 Subject: [PATCH 13/70] Count the death roll in ticks so the dead camera eases instead of shaking The camera's death roll and zoom (GameRenderer.bobHurt, Camera.modifyFovBasedOnDeathOrFluid) read deathTime + partialTick. Horizon derived deathTime from the wall clock since the death message, which the server thread path never set: there deathTime stayed 0, so every frame used 0 + partialTick and the view rolled from 0 to 0.2 degrees and snapped back twenty times a second (with a matching zoom pulse) instead of settling at vanilla's 3.6 degrees. In frame, the wall-clock ticks were not in step with the frame's partial tick either. deathTime is now the tick counter LivingEntity.tickDeath keeps: the in-frame tick already counted it, and the server thread path now resets it when the death screen opens and counts it once per client tick. horizon-ctl state reports it as player.death_time. --- crates/horizon-client/src/game/agent.rs | 2 ++ crates/horizon-client/src/game/fov.rs | 14 +++++++------- crates/horizon-client/src/game/remote.rs | 7 +++++++ 3 files changed, 16 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 0d2d218ab..79d13be84 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -476,6 +476,8 @@ impl Game<'_> { "absorption": p.health.absorption(), // The hurt animation's ticks left (the camera's hurt tilt). "hurt_time": p.health.hurt_animation_time, + // LivingEntity.deathTime while dead (the camera's death roll). + "death_time": self.death_time(), "air": p.air, "food": p.health.food.food, "saturation": p.health.food.saturation, diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index 27d3fb61e..95e2e1e6e 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -64,14 +64,14 @@ impl Game<'_> { }); self.view.tick(eye, target); } - /// The player's `deathTime` while dead or dying. - fn death_time(&self) -> Option { + /// The player's `deathTime` while dead or dying: whole ticks counted by + /// `LivingEntity.tickDeath`, so `deathTime + partialTicks` in + /// `Camera.extractRenderState` rises smoothly across frames. + pub(super) fn death_time(&self) -> Option { let p = self.player.as_ref()?; - p.health.dead_or_dying().then(|| { - self.ui - .died_at - .map_or(0, |t| (t.elapsed().as_secs_f32() * 20.0) as i32) - }) + p.health + .dead_or_dying() + .then(|| self.ui.death_time.min(i32::MAX as u32) as i32) } /// The fluid at the camera, as `Camera.getFluidInCamera` reports it. pub(super) fn camera_fluid(&self, camera: [f64; 3]) -> CameraFluid { diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 03b48df3d..4d48e7af5 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -2155,6 +2155,7 @@ impl Game<'_> { self.apply_remote_health(); if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -2171,6 +2172,7 @@ impl Game<'_> { // screen, whatever health was last sent. if me && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -3137,6 +3139,11 @@ impl Game<'_> { ); let was_flying = player.flying; self.sync_player_body(); + // LivingEntity.tickDeath: the local player counts its deathTime once + // per client tick while dead (the camera's death roll and zoom). + if self.screen == Screen::Dead { + self.ui.death_time = self.ui.death_time.saturating_add(1); + } let Some(player) = self.player.as_mut() else { return Ok(()); }; From 97e78e0f11565ab89a7017b82784a56e4e47431a Mon Sep 17 00:00:00 2001 From: some-du6e <103129948+some-du6e@users.noreply.github.com> Date: Sun, 25 Oct 2026 17:22:32 -0600 Subject: [PATCH 14/70] horizon-prepare: find 26.3 in ATLauncher's and the CurseForge app's folders ATLauncher saves Mojang's version JSON as is in configs/json/minecraft and the client jar as the library net.minecraft:client:, with the libraries at their version JSON paths and the assets and Java runtimes in Mojang's layouts. horizon-prepare now reads that layout, in the chosen folder, the launcher above a chosen instances/ folder, or, with no folder chosen, ATLauncher's default folder on each system after the official launcher's, then the CurseForge app's Install folder. The lock's pins gate it as before, and nothing is downloaded. The error names every folder looked in and the launchers Horizon reads. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-prepare/src/artifacts.rs | 275 +++++++++++++++++++++--- crates/horizon-prepare/src/lib.rs | 2 +- crates/horizon-prepare/src/sounds.rs | 20 +- 3 files changed, 258 insertions(+), 39 deletions(-) diff --git a/crates/horizon-prepare/src/artifacts.rs b/crates/horizon-prepare/src/artifacts.rs index 805dd80d4..1348361de 100644 --- a/crates/horizon-prepare/src/artifacts.rs +++ b/crates/horizon-prepare/src/artifacts.rs @@ -1,5 +1,5 @@ //! The player's own game files: the pinned version JSON, client jar and libraries from their -//! official launcher install, and the server jar they downloaded, each checked against +//! official launcher or ATLauncher install, and the server jar they downloaded, each checked against //! research-lock.json before it is copied to `.local/minecraft/` (tools/lab.py's //! `prepare`, which the Python preparer ran first), then checked again on every run //! (tools/test_rust_parity.py's `verify_artifacts`). @@ -12,9 +12,10 @@ use std::path::{Component, Path, PathBuf}; const LAUNCHER_HINT: &str = "Horizon does not download the game: play {version} once in the launcher you play \ -Minecraft Java Edition with (the official launcher, Prism Launcher, MultiMC...) so it downloads \ -the game's files, then rerun. If that launcher keeps them in another folder, pass \ ---minecraft-dir or set HORIZON_MINECRAFT_DIR."; +Minecraft Java Edition with so it downloads the game's files, then rerun. Horizon reads the \ +official launcher's folder, ATLauncher's and the CurseForge app's; for Prism Launcher, MultiMC, \ +the Modrinth App or GDLauncher, prepare from the Horizon launcher, which finds their files. If your launcher keeps \ +them in another folder, pass --minecraft-dir or set HORIZON_MINECRAFT_DIR."; const SERVER_HINT: &str = "Horizon does not download the game: download the {version} server jar yourself (minecraft.net/download/server \ while {version} is the current release, otherwise the downloads.server.url in your launcher's \ versions/{version}/{version}.json), then pass --server-jar PATH or set HORIZON_SERVER_JAR."; @@ -23,11 +24,6 @@ fn hint(text: &str, version: &str) -> String { text.replace("{version}", version) } -/// What to do when the player's launcher install lacks the pinned version's files. -pub(crate) fn launcher_hint(version: &str) -> String { - hint(LAUNCHER_HINT, version) -} - /// research-lock.json and the folder the pinned version's files go to. pub struct Lock { pub json: Value, @@ -134,6 +130,134 @@ pub fn minecraft_dir(chosen: Option<&Path>) -> PathBuf { } } +/// One launcher's copy of the pinned version: its version JSON (Mojang's file, checked by its +/// sha1), the client jar, and the folder holding its `libraries` (at the version JSON's paths) +/// and `assets`. +pub struct GameFiles { + pub folder: PathBuf, + pub manifest: PathBuf, + pub client: PathBuf, + /// Mojang's Java runtimes the launcher downloaded (java::minecraft_runtimes). + pub runtimes: PathBuf, + /// The folders looked in, each with its launcher, when none held the version. + searched: Vec<(&'static str, PathBuf)>, +} + +impl GameFiles { + /// What to do when these files are missing, with the folders looked in. + pub(crate) fn hint(&self, version: &str) -> String { + let mut text = hint(LAUNCHER_HINT, version); + if !self.searched.is_empty() { + text += &format!(" Horizon looked for {version} in:"); + for (launcher, folder) in &self.searched { + text += &format!("\n {} ({launcher})", folder.display()); + } + } + text + } +} + +/// The layouts horizon-prepare reads in `folder`: the official launcher's, then ATLauncher's, +/// which saves Mojang's version JSON as is in `configs/json/minecraft` and the client jar as +/// the library `net.minecraft:client:` (its `InstanceInstaller`). +fn layouts(folder: &Path, version: &str) -> [GameFiles; 2] { + let files = |manifest: String, client: String, runtimes: &str| GameFiles { + folder: folder.to_path_buf(), + manifest: folder.join(manifest), + client: folder.join(client), + runtimes: folder.join(runtimes), + searched: Vec::new(), + }; + let v = version; + [ + files( + format!("versions/{v}/{v}.json"), + format!("versions/{v}/{v}.jar"), + "runtime", + ), + files( + format!("configs/json/minecraft/{v}.json"), + format!("libraries/net/minecraft/client/{v}/client-{v}.jar"), + "runtimes/minecraft", + ), + ] +} + +/// The launchers whose folders are looked in when none is chosen: the official launcher's +/// (`minecraft_dir`), ATLauncher's, then the CurseForge app's `Install` folder, where it runs +/// the official launcher (its default modding folder, `curseforge/minecraft`, is in the home +/// folder on Windows and in Documents elsewhere). ATLauncher keeps its files in its working folder: +/// where its Windows installer puts it, inside the macOS app, and the folders its Linux +/// packages and Flatpak start it in. +fn launcher_folders() -> Vec<(&'static str, PathBuf)> { + let mut folders = vec![("the official launcher", minecraft_dir(None))]; + let atlauncher: Vec = if cfg!(target_os = "macos") { + let app = Path::new("Applications/ATLauncher.app/Contents/Java"); + vec![Path::new("/").join(app), home().join(app)] + } else if cfg!(windows) { + std::env::var_os("APPDATA") + .map(|d| PathBuf::from(d).join("ATLauncher")) + .into_iter() + .collect() + } else { + let data = std::env::var_os("XDG_DATA_HOME") + .filter(|d| !d.is_empty()) + .map_or_else(|| home().join(".local/share"), PathBuf::from); + vec![ + data.join("atlauncher"), + home().join(".var/app/com.atlauncher.ATLauncher/data"), + ] + }; + folders.extend(atlauncher.into_iter().map(|dir| ("ATLauncher", dir))); + let curseforge = if cfg!(windows) { "" } else { "Documents" }; + folders.push(( + "the CurseForge app", + home().join(curseforge).join("curseforge/minecraft/Install"), + )); + folders +} + +/// The pinned version's files in the chosen folder (`--minecraft-dir`, HORIZON_MINECRAFT_DIR), +/// or the launcher above it when an instance folder (`instances/`) is chosen; with no +/// folder chosen, in the first launcher folder that has them. When none does, the official +/// layout of the first folder is returned, for the errors to name, with the folders looked in. +pub fn game_files(chosen: Option<&Path>, version: &str) -> GameFiles { + let chosen = chosen + .filter(|d| !d.as_os_str().is_empty()) + .map(Path::to_path_buf) + .or_else(|| std::env::var_os("HORIZON_MINECRAFT_DIR").map(PathBuf::from)) + .filter(|d| !d.as_os_str().is_empty()) + .map(|d| expand_user(&d)); + let folders = match chosen { + Some(dir) => { + let launcher = dir + .ancestors() + .find(|a| a.file_name().is_some_and(|n| n == "instances")) + .and_then(Path::parent) + .map(Path::to_path_buf); + let mut folders = vec![("the folder chosen", dir)]; + folders.extend(launcher.map(|dir| ("the launcher above it", dir))); + folders + } + None => launcher_folders(), + }; + // A folder with both files first: a version JSON left without its jar is used, for the + // error to name the jar, only when no folder has both. + let complete = |files: &GameFiles| files.manifest.is_file() && files.client.is_file(); + let partial = |files: &GameFiles| files.manifest.is_file(); + for found in [complete, partial] { + let mut all = folders + .iter() + .flat_map(|(_, folder)| layouts(folder, version)); + if let Some(files) = all.find(found) { + return files; + } + } + let [mut files, _] = layouts(&folders[0].1, version); + files.searched = folders; + files +} + /// Copy one file from the player's install, checked like a download; an existing verified /// copy is kept. pub(crate) fn import_copy( @@ -170,17 +294,14 @@ pub(crate) fn import_copy( Ok(destination.to_path_buf()) } -/// The pinned version JSON from the launcher's versions/ directory. The launcher's copy wins -/// over the cached one so the manifest matches the asset index installed alongside it. -pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result { +/// The pinned version JSON from the launcher's install. The launcher's copy wins over the +/// cached one so the manifest matches the asset index installed alongside it. +pub(crate) fn import_manifest(lock: &Lock, files: &GameFiles) -> Result { let version = &lock.version; let destination = lock.directory.join("manifest.json"); - let source = minecraft - .join("versions") - .join(version) - .join(format!("{version}.json")); + let source = &files.manifest; if source.is_file() { - let manifest = read_json(&source)?; + let manifest = read_json(source)?; let downloads = manifest.get("downloads"); let sha1 = |side: &str| { downloads @@ -197,7 +318,7 @@ pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result Result, log: Log, ) -> Result<(), String> { - let minecraft = minecraft_dir(minecraft); - let version = &lock.version; - let manifest = import_manifest(lock, &minecraft)?; + let files = game_files(minecraft, &lock.version); + let minecraft = &files.folder; + let manifest = import_manifest(lock, &files)?; let client = import_copy( - &minecraft - .join("versions") - .join(version) - .join(format!("{version}.jar")), + &files.client, &lock.directory.join("jars/client.jar"), lock.pin("client_sha1")?, "sha1", - &hint(LAUNCHER_HINT, version), + &files.hint(&lock.version), )?; let downloads = manifest.get("downloads"); if downloads.and_then(|d| d.get("client_mappings")).is_some() @@ -560,7 +678,7 @@ pub fn import( for (name, artifact) in client_library_artifacts(&manifest)? { let (path, sha1) = artifact_fields(artifact)?; let relative = safe_relative(path).ok_or("Unsafe library path")?; - let source = launcher_library(&minecraft, name, &relative); + let source = launcher_library(minecraft, name, &relative); let destination = lock.directory.join("libraries/client").join(&relative); if runs_without(name) && !source.is_file() && !destination.exists() { log(&format!( @@ -574,7 +692,7 @@ pub fn import( &destination, sha1, "sha1", - &hint(LAUNCHER_HINT, version), + &files.hint(&lock.version), )?); } write_import_metadata( @@ -1208,6 +1326,103 @@ mod tests { assert!(prepare().unwrap_err().starts_with("Missing ")); } + /// ATLauncher keeps Mojang's version JSON in `configs/json/minecraft` and the client jar as + /// a library; its folder, or one of its instances, prepares like the official launcher's, + /// with the same pins. + #[test] + fn an_atlauncher_install_prepares() { + let fixture = Imports::new(); + let old = fixture.imported(&fixture.source); + let atlauncher = fixture.directory.join("ATLauncher"); + let put = |path: &str, data: &[u8]| { + let path = atlauncher.join(path); + fs::create_dir_all(path.parent().unwrap()).unwrap(); + fs::write(path, data).unwrap(); + }; + let client = fs::read(old.join("jars/client.jar")).unwrap(); + put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client); + put("libraries/client.jar", b"client library"); + put("instances/Minecraft99/instance.json", b"{}"); + // A version JSON left without its jar does not hide the launcher's complete copy. + put("instances/Minecraft99/versions/9.9/9.9.json", b"{}"); + let manifest = fs::read_to_string(old.join("manifest.json")).unwrap(); + let manifest = manifest.replacen('{', r#"{"javaVersion":{"majorVersion":25},"#, 1); + put("configs/json/minecraft/9.9.json", manifest.as_bytes()); + let pinned = digest(&atlauncher.join("configs/json/minecraft/9.9.json"), "sha1").unwrap(); + let lock_path = fixture.target.join("research-lock.json"); + let text = fs::read_to_string(&lock_path).unwrap(); + let old_sha1 = digest(&old.join("manifest.json"), "sha1").unwrap(); + fs::write(&lock_path, text.replace(&old_sha1, &pinned)).unwrap(); + let lock = Lock::read(&fixture.target).unwrap(); + let server = old.join("jars/server.jar"); + let prepare = |dir: &Path| { + let _ = fs::remove_dir_all(&lock.directory); + import(&fixture.target, &lock, Some(dir), Some(&server), &|_| {}) + }; + + for chosen in [atlauncher.clone(), atlauncher.join("instances/Minecraft99")] { + prepare(&chosen).unwrap(); + let artifacts = verify(&lock).unwrap(); + assert_eq!(fs::read(&artifacts.jars["client"]).unwrap(), client); + assert_eq!( + client_libraries(&lock, &artifacts.manifest).unwrap().len(), + 1 + ); + } + let files = game_files(Some(&atlauncher), "9.9"); + assert_eq!(files.runtimes, atlauncher.join("runtimes/minecraft")); + + // The pins gate it as they gate the official layout. + put( + "libraries/net/minecraft/client/9.9/client-9.9.jar", + b"other", + ); + assert!(prepare(&atlauncher) + .unwrap_err() + .contains("is not the pinned file")); + put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client); + put( + "configs/json/minecraft/9.9.json", + manifest.replace(',', ", ").as_bytes(), + ); + assert!(prepare(&atlauncher) + .unwrap_err() + .contains("does not know yet")); + } + + /// With no launcher's files in the chosen folder, the error names where Horizon looked and + /// the launchers it reads. + #[test] + fn the_error_names_the_folders_looked_in() { + let fixture = Imports::new(); + let empty = fixture.directory.join("instances/empty"); + fs::create_dir_all(&empty).unwrap(); + let lock = Lock::read(&fixture.target).unwrap(); + let error = import(&fixture.target, &lock, Some(&empty), None, &|_| {}).unwrap_err(); + assert!(error.starts_with(&format!( + "Missing {}", + empty.join("versions/9.9/9.9.json").display() + ))); + assert!(error.contains("Horizon looked for 9.9 in:"), "{error}"); + assert!(error.contains(&format!("\n {} (the folder chosen)", empty.display()))); + assert!(error.contains(&format!( + "\n {} (the launcher above it)", + fixture.directory.display() + ))); + assert!(error.contains("ATLauncher")); + } + + #[test] + fn every_launcher_horizon_reads_is_looked_in() { + let launchers: Vec<_> = launcher_folders() + .into_iter() + .map(|(name, _)| name) + .collect(); + for name in ["the official launcher", "ATLauncher", "the CurseForge app"] { + assert!(launchers.contains(&name), "{name}"); + } + } + #[test] fn runs_without_only_netty_native_transports() { assert!(runs_without( diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index c7e443c7d..912fc4a9d 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -407,7 +407,7 @@ pub fn prepare(options: &Options, log: Log) -> Result { // Java first: nothing below can finish without it, and the player should hear it at once. let mut homes: Vec = options.java_home.iter().cloned().collect(); homes.extend(java::minecraft_runtimes( - &artifacts::minecraft_dir(options.minecraft_dir.as_deref()).join("runtime"), + &artifacts::game_files(options.minecraft_dir.as_deref(), &lock.version).runtimes, )); let jdk = java::find(lock.java_major, &homes)?; if options.import && !artifacts::reuse_imported(root, log)? { diff --git a/crates/horizon-prepare/src/sounds.rs b/crates/horizon-prepare/src/sounds.rs index 15d4a7a08..2de43fe17 100644 --- a/crates/horizon-prepare/src/sounds.rs +++ b/crates/horizon-prepare/src/sounds.rs @@ -1,5 +1,5 @@ //! The pinned version's sounds, title panorama, Unifont glyphs and built-in resource packs -//! from the player's own official launcher install, each object checked against the asset index's SHA-1, copied into +//! from the player's own launcher install, each object checked against the asset index's SHA-1, copied into //! `.local/horizon-client//assets` where the game reads them (tools/fetch_sounds.py and //! the tools/lab.py functions it called). Nothing is downloaded. @@ -17,10 +17,10 @@ use std::path::{Path, PathBuf}; fn launcher_assets( lock: &Lock, manifest: &Value, - minecraft: &Path, + files: &artifacts::GameFiles, log: Log, ) -> Result<(PathBuf, PathBuf), String> { - let assets = minecraft.join("assets"); + let assets = files.folder.join("assets"); let info = manifest .get("assetIndex") .ok_or("The version JSON has no assetIndex")?; @@ -39,7 +39,7 @@ fn launcher_assets( return Err(format!( "Missing {}. {}", index.display(), - artifacts::launcher_hint(version) + files.hint(version) )); } let checksum = digest(&index, "sha1")?; @@ -208,9 +208,9 @@ fn copy_assets( required: &[&str], ) -> Result { let lock = Lock::read(root)?; - let minecraft = artifacts::minecraft_dir(minecraft); - let manifest = artifacts::import_manifest(&lock, &minecraft)?; - let (store, index) = launcher_assets(&lock, &manifest, &minecraft, log)?; + let files = artifacts::game_files(minecraft, &lock.version); + let manifest = artifacts::import_manifest(&lock, &files)?; + let (store, index) = launcher_assets(&lock, &manifest, &files, log)?; let id = manifest .get("id") .and_then(Value::as_str) @@ -566,7 +566,11 @@ mod tests { for missing in ["store", "install", "last-object"] { let f = Fixture::new(&format!("optional-panorama-{missing}")); // The JARs and manifest were imported earlier; the launcher need not remain. - artifacts::import_manifest(&Lock::read(&f.root).unwrap(), &f.minecraft).unwrap(); + artifacts::import_manifest( + &Lock::read(&f.root).unwrap(), + &artifacts::game_files(Some(&f.minecraft), "9.9"), + ) + .unwrap(); let target = f.root.join(".local/horizon-client/9.9/assets"); for name in PANORAMA { let path = target.join(name); From 920a728989a59e1ea36c2309ba8e0aca8d6ad9a4 Mon Sep 17 00:00:00 2001 From: socksprox Date: Mon, 26 Oct 2026 00:56:00 +0100 Subject: [PATCH 15/70] World text parity: same-frame glyph uploads, display lines, name-tag colours Atlas patches rasterized while building world text (display text, name tags, sign glyphs, map items) drained into the HUD batch before entity_geometry ran, uploading a frame late: for that frame the quads sampled unwritten atlas cells, so text flickered or showed the wrong glyphs whenever content changed or new text entered view. Display text also lined up 10 px apart where vanilla's lineHeight is 9, its background quad stopped a pixel short of vanilla's -1..width+1 fill, and name tags used 0x7F where renderNameTag's colours are 0x20FFFFFF (discrete) and 0x80FFFFFF (see-through). lightCoordsWithEmission floors only the block channel at 2 and leaves the sky alone, and a discrete name's background draws lit in the normal pass rather than unlit. Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- crates/horizon-client/src/game.rs | 6 +++-- crates/horizon-client/src/game/names.rs | 26 +++++++++++++------ .../horizon-client/src/game/text_displays.rs | 8 +++--- 3 files changed, 26 insertions(+), 14 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1e6158bc4..e40b93586 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -10090,8 +10090,6 @@ impl Game<'_> { Vec::new() }; let mut hud = horizon_client::spans::time("hud", || self.hud(size)); - // Map textures changed since the last drawn frame (game/maps.rs). - hud.patches.append(&mut self.map_patches); // LevelLoadingScreen (Reason.OTHER) draws the title's panorama. let title = self.title.is_some() || self.loading_reason() == Some(horizon_client::level_loading::Reason::Other); @@ -10193,6 +10191,10 @@ impl Game<'_> { } else { self.shader_pack_inputs(camera, alpha as f32) }; + // Map textures and font glyphs changed while building this frame's + // geometry (game/maps.rs, world text) upload with this batch; draining + // map_patches any earlier leaves them a frame behind. + hud.patches.append(&mut self.map_patches); let frame = Frame { weather: &weather, weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32), diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index 7655fb489..d62e064f7 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -252,17 +252,27 @@ impl Game<'_> { out: &mut Vec, see_through: &mut Vec, ) { - // The text alpha that goes with getBackgroundOpacity(0.25): - // max((0.25 + 0.75) / 2, 0.5), as ARGB.color (the floor of 255 times it). - const FADED: u32 = 0x7F; + // renderNameTag's text colours: a discrete name's faded 0x20FFFFFF, + // the see-through copy's 0x80FFFFFF. + const DISCRETE: u32 = 0x20; + const FADED: u32 = 0x80; for tag in self.name_tags(camera, alpha) { let o = tag.at - camera; if tag.discrete { - self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out); + self.name_tag_quads( + o, + &tag.lines, + DISCRETE, + true, + 0, + vertex_light(tag.light), + out, + ); continue; } - // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2). - let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2); + // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2): the block + // channel at least 2, the sky channel unchanged. + let lit = (tag.light & 0xF0) | (tag.light & 15).max(2); self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out); // RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap. self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through); @@ -270,7 +280,7 @@ impl Game<'_> { } /// The lines of one name tag, `o` from the camera: the text at /// `text_alpha` in its layer, on the translucent black background - /// (unlit, a hair behind) when `background`. + /// (in `text_layer` like the glyphs, a hair behind) when `background`. #[allow(clippy::too_many_arguments)] fn name_tag_quads( &self, @@ -342,7 +352,7 @@ impl Game<'_> { [white.u0, white.v0, white.u1, white.v1], BACKGROUND, true, - 2, + text_layer, ); } let mut x = x0; diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index f6c946bcc..45191e15e 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -198,7 +198,7 @@ impl Game<'_> { Lines { lines, width } }); let width = *width; - let height = lines.len() as f32 * 10.0 - 1.0; + let height = lines.len() as f32 * 9.0 - 1.0; matrix *= glam::Mat4::from_translation(glam::Vec3::new(1.0 - width / 2.0, -height, 0.0)); let mut batch = HudBatch::new([1, 1]); @@ -212,8 +212,8 @@ impl Game<'_> { atlas, -1.0, -1.0, - width + 1.0, - height + 1.0, + width + 2.0, + height + 2.0, rgba( (bg >> 16) as u8, (bg >> 8) as u8, @@ -233,7 +233,7 @@ impl Game<'_> { atlas, line, x, - i as f32 * 10.0, + i as f32 * 9.0, rgba(255, 255, 255, d.opacity as u8), d.flags & 1 != 0, ); From 31eecdc271750def0532029e62ef007878762c01 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 01:03:25 +0100 Subject: [PATCH 16/70] Compute a firework's blast distance in floats, as Entity.distanceTo does Entity.distanceTo casts each offset to float and sums the squares in floats; taking the double distance and rounding it gave a slightly different damage at the edge of rounding. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/fireworks.rs | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs index 2c98a12ad..e6b4eb136 100644 --- a/crates/horizon-client/src/game/fireworks.rs +++ b/crates/horizon-client/src/game/fireworks.rs @@ -71,10 +71,16 @@ impl Rocket { (self.position, self.velocity) } } -/// `damageAmount * (float)Math.sqrt((5.0 - this.distanceTo(target)) / 5.0)`, -/// `distanceTo` being a float. -fn blast_damage(damage: f32, distance_sqr: f64) -> f32 { - let distance = distance_sqr.sqrt() as f32; +/// `damageAmount * (float)Math.sqrt((5.0 - this.distanceTo(target)) / 5.0)` +/// from the rocket at `from` to a target at `to`; `Entity.distanceTo` sums +/// the squared offsets in floats. +fn blast_damage(damage: f32, from: Vec3, to: Vec3) -> f32 { + let (x, y, z) = ( + (from.x - to.x) as f32, + (from.y - to.y) as f32, + (from.z - to.z) as f32, + ); + let distance = f64::from(x * x + y * y + z * z).sqrt() as f32; damage * ((5.0 - f64::from(distance)) / 5.0).sqrt() as f32 } pub(super) fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { @@ -294,7 +300,7 @@ impl Game<'_> { ); world.clear_between(from, to, false) }); - sees.then(|| (m.id, blast_damage(damage, d2))) + sees.then(|| (m.id, blast_damage(damage, from, m.position))) }) .collect() }; @@ -337,7 +343,7 @@ impl Game<'_> { }) }; if sees { - self.rocket_hurt_player(blast_damage(damage, d2)); + self.rocket_hurt_player(blast_damage(damage, from, feet)); } } /// `hurtServer` with `damageSources().fireworks`: armor absorbs it and From bb3a289caaa091b9ffd910e51780bacb31f0ac4c Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 01:07:48 +0100 Subject: [PATCH 17/70] Read the click's changed slots for the machine's setChanged The menu op already lists the slots the click changed; a container slot among them is the Slot.setChanged that saves the block entity. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/lan_crafting.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index d3c4b1825..db6235c4d 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -293,7 +293,7 @@ impl Game<'_> { } // Slot.setChanged on a changed container slot: BlockEntity.setChanged, // so the chunk is saved and comparators read the block again. - if (0..items.len()).any(|k| menu.slot(k) != items[k].as_ref()) { + if changed.iter().any(|&s| s < items.len()) { self.container_changed(pos); } host.play.entry(conn).or_default().crafting.machine = Some((p.container, menu)); From 467413df5bc20568bc825f65431e322150c6f059 Mon Sep 17 00:00:00 2001 From: DanielGodriNeto Date: Sun, 25 Oct 2026 20:47:24 -0300 Subject: [PATCH 18/70] fix(benchmark): wait for the post-teleport load before measuring wait_loaded declared a scene loaded during the idle second right after a teleport, so village and mountain were measured with 0 chunks. Port the guard from tools/perf_bench.py: counts must change once (or stay full for 5 s) and resident chunks must reach 80% of the view circle. Co-Authored-By: Claude --- crates/horizon-client/src/benchmark.rs | 31 ++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/crates/horizon-client/src/benchmark.rs b/crates/horizon-client/src/benchmark.rs index bcb94589c..12e38e78a 100644 --- a/crates/horizon-client/src/benchmark.rs +++ b/crates/horizon-client/src/benchmark.rs @@ -323,10 +323,15 @@ const QUIET_MESHES_PER_S: f64 = 100.0; /// happened (`tools/perf_bench.py`'s `wait_loaded`). With `status.streaming`, the sections are /// drawn once no stage has held work for half a second: blocks changing after the load (fluids /// settling, random ticks) only remesh in bursts. Without it, meshing has to go quiet. +/// +/// Right after a teleport (and at spawn) the game reports nothing queued and steady counts for over +/// a second before it starts loading: the counts must change once, or stay full for 5 s, and the +/// resident chunks reach [`view_chunks`], before "steady" means loaded. fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result { let deadline = Instant::now() + LOAD_LIMIT; let (mut last, mut changed, mut meshing) = (None, Instant::now(), Instant::now()); let mut previous: Option<(Instant, f64)> = None; + let (mut first, mut moved, began) = (None, false, Instant::now()); while Instant::now() < deadline { let s = control.status(); let now = Instant::now(); @@ -339,6 +344,19 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result 0 + && resident >= min_chunks + && now - began > Duration::from_secs(5)); + if min_chunks > 0 && (!moved || resident < min_chunks) { + (last, changed, previous, meshing) = (None, now, None, now); + thread::sleep(Duration::from_millis(50)); + continue; + } if last != Some(counts) { (last, changed) = (Some(counts), now); } @@ -370,6 +388,12 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result u64 { + (0.8 * std::f64::consts::PI * (distance * distance) as f64) as u64 +} + /// Vanilla's yaw facing from `start` to `end`. fn yaw(start: [f64; 3], end: [f64; 3]) -> f64 { (-(end[0] - start[0])).atan2(end[2] - start[2]).to_degrees() @@ -420,6 +444,13 @@ mod tests { assert!(scenes("nether").is_none()); } + #[test] + fn view_chunks_matches_perf_bench() { + assert_eq!(view_chunks(12), 361); + assert_eq!(view_chunks(32), 2573); + assert_eq!(view_chunks(0), 0); + } + #[test] fn yaw_matches_vanilla() { // South (+Z) is 0, west (-X) 90, east (+X) -90. From 258dd8561df05c8493a14d63d4eaa89074bb780b Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 03:34:33 +0300 Subject: [PATCH 19/70] Frames: one scan for breaking progress, and no name formatting per crack `entity_geometry` ran `cracks()` twice per frame: once for the block-entity pass that draws `render_breaking`, once for the overlay near the end of the same function. Each run walked `mining` and the `destroying` map, and formatted `block/destroy_stage_` for every crack it found before looking that string up in the atlas. The list is computed once, at the top of the function, and the passes read it. The ten stage names are a const table, so a crack costs one lookup and no allocation. Nothing between the two passes touches `mining` or `destroying`, which are only read there, so the list the second pass used to rebuild was always identical to the first one. No behaviour change: the same ten sprite names, and a stage above 9 still finds no sprite and skips the crack. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/game.rs | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 1e6158bc4..bfc90f1ec 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -6750,6 +6750,9 @@ impl Game<'_> { ) -> Vec { self.prepare_entity_culling(camera); self.prepare_trims(); + // One scan for both passes that draw them (block entities below and the + // overlay near the end of this function). + let cracks = self.cracks(camera); let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront { self.yaw + 180.0 } else { @@ -6964,7 +6967,7 @@ impl Game<'_> { .block_entity_render() .render(&scene, visible, &mut out); } - for (pos, stage) in self.cracks(camera) { + for &(pos, stage) in &cracks { let state = self.world.block(pos[0], pos[1], pos[2]); self.res .block_entity_render() @@ -7089,7 +7092,7 @@ impl Game<'_> { &mut out, ); // Breaking progress overlays (destroy_stage_0..9): ours and the other players'. - for (pos, stage) in self.cracks(camera) { + for &(pos, stage) in &cracks { let o = (glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])) - camera) .as_vec3(); @@ -7137,6 +7140,20 @@ impl Game<'_> { /// other players' (`renderBlockDestroyAnimation`: within 32 blocks of the camera, the /// furthest progress on each block). fn cracks(&self, camera: glam::DVec3) -> Vec<([i32; 3], [f32; 2])> { + // `destroy_stage_0` .. `destroy_stage_9`: the sprite name by stage, so the + // lookup does not format a string per crack. + const DESTROY_STAGES: [&str; 10] = [ + "block/destroy_stage_0", + "block/destroy_stage_1", + "block/destroy_stage_2", + "block/destroy_stage_3", + "block/destroy_stage_4", + "block/destroy_stage_5", + "block/destroy_stage_6", + "block/destroy_stage_7", + "block/destroy_stage_8", + "block/destroy_stage_9", + ]; let mut stages: Vec<([i32; 3], u32)> = Vec::new(); let mut add = |pos: [i32; 3], stage: u32| match stages.iter_mut().find(|c| c.0 == pos) { Some(c) => c.1 = c.1.max(stage), @@ -7162,11 +7179,8 @@ impl Game<'_> { d.length_squared() <= 1024.0 }) .filter_map(|(pos, stage)| { - let r = self - .gui - .atlas - .sprites - .get(&format!("block/destroy_stage_{stage}"))?; + let name = DESTROY_STAGES.get(stage as usize)?; + let r = self.gui.atlas.sprites.get(*name)?; Some((pos, [r.u0, r.v0])) }) .collect() From 5e2871dbfd892a9d50c185cb5e5cf5b17013114c Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 01:39:30 +0000 Subject: [PATCH 20/70] Show critical-hit particles on server clients Queue successful mob and player crit animations until the hub can send them to the attacker and tracking clients. Cover falling, grounded and refused attacks in both host modes. Fixes #1898. Co-Authored-By: OpenCode (agentrouter/gpt-6.1-sol) --- crates/horizon-client/src/game.rs | 10 ++- crates/horizon-client/src/game/lan.rs | 31 ++++++++ crates/horizon-client/src/game/lan_pvp.rs | 22 ++++++ crates/horizon-client/src/game/levels.rs | 3 + crates/horizon-client/src/lan/containers.rs | 15 ++++ tools/lan_e2e.py | 88 +++++++++++++++++++++ 6 files changed, 165 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f9f2a0363..f34eef456 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1555,6 +1555,8 @@ struct Game<'a> { /// position) for the guests. lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + /// Successful crits (attacking guest, hit entity), queued while the hub is taken. + lan_critical_hits: Vec<(Option, i32)>, /// Global level events for every guest (`ServerLevel.globalLevelEvent`). lan_global_events: Vec<(i32, [i32; 3], i32)>, /// `ContainerOpenersCounter`: how many players (the host and the guests) @@ -7437,10 +7439,9 @@ impl Game<'_> { self.stats .custom("damage_dealt", (actual * 10.0).round() as i32); if crit { - self.particles.tracking_emitter( - horizon_client::particles::ParticleOptions::simple( - horizon_client::particles::ParticleType::Crit, - ), + self.critical_hit( + self.lan_acting, + self.mobs[index].id as i32, feet, width, height, @@ -12118,6 +12119,7 @@ impl<'a> Game<'a> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), lan_global_events: Vec::new(), lid_openers: HashMap::new(), lan_acting: None, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index ee7477f28..e2b853b07 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -634,6 +634,7 @@ impl Game<'_> { self.world.light_log = None; self.audio.capture = None; self.lan_events.clear(); + self.lan_critical_hits.clear(); self.streaming.extra.clear(); if announce { self.system_message(Text::translate( @@ -1162,8 +1163,30 @@ impl Game<'_> { self.lan_entity_events.push((id, event, at)); } } + /// `ServerPlayer.crit`: this window's emitter, and an animation for the + /// attacker's client and observers once the hub is back in place. + pub(super) fn critical_hit( + &mut self, + attacker: Option, + id: i32, + feet: [f64; 3], + width: f64, + height: f64, + ) { + use horizon_client::particles::{ParticleOptions, ParticleType}; + self.particles.tracking_emitter( + ParticleOptions::simple(ParticleType::Crit), + feet, + width, + height, + ); + if self.audio.capture.is_some() { + self.lan_critical_hits.push((attacker, id)); + } + } /// Send the tick's level events, sounds and mob animations. fn lan_flush_effects(&mut self, host: &mut LanHost) { + let critical_hits = std::mem::take(&mut self.lan_critical_hits); for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) { if kind == 2001 { host.broken @@ -1236,6 +1259,14 @@ impl Game<'_> { seen.insert(m.id, (m.hurt_time, dead, swing)); } host.mob_state.insert(self.dim, seen); + for (attacker, target) in critical_hits { + let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| { + host.hub.guest(conn).map(|g| g.entity_id) + }) else { + continue; + }; + host.hub.critical_hit(attacker, target); + } } /// Keep the chunks around every guest loaded. diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 467c4537c..c7c6b6525 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -32,6 +32,8 @@ pub(super) enum Victim { /// The attacker's side of the hit. pub(super) struct Strike { + /// The attacking guest, kept after their turn through `as_guest` ends. + attacker: Option, amount: f32, scale: f32, crit: bool, @@ -119,6 +121,7 @@ impl Game<'_> { } self.swing_arm(); Some(Strike { + attacker: self.lan_acting, amount, scale, crit, @@ -250,6 +253,25 @@ impl Game<'_> { Victim::Host => land(self), Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false), }; + if hurt && s.crit { + let target = match victim { + Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)), + Victim::Guest(conn) => host + .hub + .guest(conn) + .and_then(|g| g.motion.as_deref().map(|p| (g.entity_id, p))), + }; + if let Some((id, p)) = target { + let d = p.dimensions; + self.critical_hit( + s.attacker, + id, + [p.position.x, p.position.y, p.position.z], + f64::from(d.width), + f64::from(d.height), + ); + } + } let sound = match (hurt, s.crit, s.scale > 0.9) { (false, ..) => "minecraft:entity.player.attack.nodamage", (true, true, _) => "minecraft:entity.player.attack.crit", diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 588f425a4..65bf4940f 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -73,6 +73,7 @@ pub(super) struct Parked { lan_events: Vec<(i32, [i32; 3], i32, Option)>, lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + lan_critical_hits: Vec<(Option, i32)>, /// Only the per-level parts of these are used (`swap_level`). anims: BlockEntityAnims, raiding: Raiding, @@ -150,6 +151,7 @@ impl Game<'_> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), anims: Default::default(), raiding: Default::default(), sculk: Default::default(), @@ -197,6 +199,7 @@ impl Game<'_> { swap(&mut self.lan_events, &mut p.lan_events); swap(&mut self.lan_block_events, &mut p.lan_block_events); swap(&mut self.lan_entity_events, &mut p.lan_entity_events); + swap(&mut self.lan_critical_hits, &mut p.lan_critical_hits); let (a, b) = (&mut self.be_anims, &mut p.anims); swap(&mut a.chests, &mut b.chests); swap(&mut a.books, &mut b.books); diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs index 7e150e7bd..002f95cbb 100644 --- a/crates/horizon-client/src/lan/containers.rs +++ b/crates/horizon-client/src/lan/containers.rs @@ -120,6 +120,21 @@ impl Hub { ); } + /// `ServerPlayer.crit`: send the victim's animation to the players tracking + /// the attacker and the attacker themselves (`sendToTrackingPlayersAndSelf`). + pub fn critical_hit(&self, attacker: i32, target: i32) { + let body = C::Animate(play::Animate { + id: target, + action: 1, + }) + .encode(); + for g in self.guests.iter().filter(|g| { + self.here(g) && (g.entity_id == attacker || g.tracker.is_tracking(attacker)) + }) { + g.sender.send(body.clone()); + } + } + /// `ServerLevel.broadcastDamageEvent`: the clients around show the hurt /// entity's flash and hear its hurt sound. pub fn damage_event( diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 0ec7218d8..84e03fe03 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -6398,5 +6398,93 @@ CHECKS += ['sprint-fov'] CHECK_FNS['sprint-fov'] = check_sprint_fov +def check_critical_hits(host, guest, out): + """#1898: a real falling melee hit emits crits on the attacker and observer. + Grounded hits and refused falling hits emit none, against mobs and players. + """ + x, y, z = map(math.floor, pos_of(host)) + target = [x + 2.5, y, z + 0.5] + tag = 'critical_hit_particles' + seen = {} + host('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 6} {y - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 3} {y} {z - 3} {x + 6} {y + 5} {z + 6} minecraft:air') + host('command', command='time set midnight') + host('command', command='gamerule natural_health_regeneration false') + try: + for label, player, other in (('host', host, guest), ('guest', guest, host)): + for kind in ('zombie', 'player'): + for hit in ('grounded', 'critical', 'refused'): + case = f'{label}-{kind}-{hit}' + for game in (player, other): + game('command', command='gamemode survival') + game('command', command='clear @s') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + other_at = target if kind == 'player' else [x + 0.5, y, z + 4.5] + other('command', command=f'tp @s {other_at[0]} {other_at[1]} {other_at[2]}') + host('command', command=f'gamerule pvp {str(hit != "refused").lower()}') + mob_id = None + if kind == 'zombie': + host('command', command=f'summon minecraft:zombie {target[0]} {y} {target[2]} ' + f'{{NoAI:1b,PersistenceRequired:1b,Invulnerable:{int(hit == "refused")}b,Tags:["{tag}"]}}') + player.wait(20) # full attack charge and paired entities + if kind == 'zombie': + mob = next(m for m in player.raw('mobs', 16)['near'] + if m['kind'] == 'minecraft:zombie' and math.dist(m['pos'], target) < 0.1) + mob_id = mob['id'] + assert mob_seen(other, mob_id), f'{case}: observer has not paired the zombie' + health_before = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sound = 'minecraft:entity.player.attack.crit' + sounds_before = {side: heard(g, sound) for side, g in (('own', player), ('other', other))} + + def strike(): + if hit != 'grounded': + player.raw('key', 'space', 'down') + player.wait(1) + player.raw('key', 'space', 'up') + body = None + for _ in range(15): + body = player('state')['player'] + # Let the server record the fall before the attack packet. + if not body['on_ground'] and body['velocity'][1] < -0.2: + break + player.wait(1) + assert body and not body['on_ground'] and body['velocity'][1] < -0.2, \ + f'{case}: jump never reached its falling phase: {body}' + player.raw('look-at', target[0], y + 1, target[2]) + player.raw('mouse', 'left', 'click') + + particles = sparked(player, other, ['crit'], strike) + player.shot(out, f'critical-hits-{kind}-{hit}-{label}') + player.wait(10) # finish the three-tick emitter and health replication + health_after = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sounds = {side: heard(g, sound) - sounds_before[side] + for side, g in (('own', player), ('other', other))} + seen[case] = {'particles': particles, 'crit_sounds': sounds, + 'health': [health_before, health_after]} + host('command', command=f'kill @e[tag={tag}]') + assert (health_after == health_before) if hit == 'refused' else (health_after < health_before), \ + f'{case}: unexpected damage: {seen[case]}' + assert all(n == int(hit == 'critical') for n in sounds.values()), \ + f'{case}: the server did not recognize the expected crit: {seen[case]}' + wrong = {case: result for case, result in seen.items() + if any((n <= 0 if case.endswith('-critical') else n != 0) + for n in result['particles'].values())} + assert not wrong, f'critical-hit particles: {wrong}' + return seen + finally: + host('command', command=f'kill @e[tag={tag}]') + host('command', command='gamerule pvp true') + host('command', command='gamerule natural_health_regeneration true') + host('command', command='time set day') + for game in (host, guest): + game.raw('key', 'space', 'up') + + +CHECKS += ['critical-hits'] +CHECK_FNS['critical-hits'] = check_critical_hits + + if __name__ == '__main__': main() From 15d99a6856190bc6fe9447a7b5990a9a55a59192 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 02:11:48 +0000 Subject: [PATCH 21/70] Start bat animation clocks on server clients Fixes #2000. Co-Authored-By: OpenCode GPT-6.1 Sol --- .../examples/probe/entity_anim_fixture.rs | 26 ++++--- crates/horizon-client/src/game/lan.rs | 7 ++ crates/horizon-client/src/game/remote.rs | 3 + .../src/game/remote_mob_data.rs | 71 ++++++++++++++++++- crates/horizon-client/src/mobs/bat.rs | 4 ++ .../parity/VanillaEntityAnimOracle.java | 32 ++++++++- tools/test_entity_model_parity.py | 8 +++ 7 files changed, 140 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs index 0a2e2951f..0a3df9e0d 100644 --- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs +++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs @@ -9,7 +9,7 @@ use horizon_client::mesher::Vertex; use horizon_client::mobs::{ Mob, MobData, MobTypes, Part, Species, allay, anim::{self, Poses, State}, - aquatic, body_anim as b_anim, equine, guardian, + aquatic, bat, body_anim as b_anim, equine, guardian, keyframes::AnimationState, render, shulker, sniffer, species, tame, }; @@ -108,6 +108,22 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) { let flag = |k: &str| case[k].as_bool().unwrap_or(false); let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32; match species { + Species::Bat => { + mob.extra.flag = flag("isResting"); + mob.anim.states[0].started = case["flyAnimationState"].as_f64().map(|v| v as f32); + mob.anim.states[1].started = case["restAnimationState"].as_f64().map(|v| v as f32); + if let Some(ticks) = case["@batTicks"].as_array() { + for (i, flags) in ticks.iter().enumerate() { + mob.age = i as u32 + 1; + bat::set_resting(mob, flags.as_i64().unwrap_or(0) & 1 != 0); + if flag("@batInFrame") { + bat::tick(mob); + } else { + bat::setup_animation_states(mob); + } + } + } + } Species::Sheep => mob.extra.anim_ticks = num("eatTick") as i32, Species::Guardian | Species::ElderGuardian => { mob.anim.v[guardian::TAIL] = num("tailAnimation"); @@ -456,14 +472,6 @@ pub fn main() -> horizon_client::Result<()> { roll_amount: num("rollAmount"), }, ), - Species::Bat => b_anim::bat( - p, - s, - flag("isResting"), - &started("flyAnimationState"), - &started("restAnimationState"), - &animations, - ), Species::Armadillo => b_anim::armadillo( p, s, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..7e66a1e35 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -194,6 +194,13 @@ fn mob_meta( let e = &m.extra; let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}")); match kind { + // Bat.DATA_ID_FLAGS: resting in bit 0, flying by default. + "minecraft:bat" => { + if e.flag { + meta.push((16, serializer::BYTE, Value::Byte(1))); + } + defaults.push((16, serializer::BYTE, Value::Byte(0))); + } // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared. "minecraft:sheep" => { let value = (e.color & 15) | if e.sheared { 16 } else { 0 }; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 2d5ee9dc1..7850df1f7 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3444,6 +3444,9 @@ impl Game<'_> { if m.species() == horizon_client::mobs::Species::Rabbit { horizon_client::mobs::rabbit::post_tick(m); } + if m.species() == horizon_client::mobs::Species::Bat { + horizon_client::mobs::bat::setup_animation_states(m); + } } for o in self.orbs.iter_mut().filter(|_| running) { o.previous = o.position; diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index da786c1b9..6fde27e52 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -4,7 +4,7 @@ //! own simulation, which a client of a server doesn't run. use super::Game; use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; -use horizon_client::mobs::{Mob, Species, tame}; +use horizon_client::mobs::{Mob, Species, bat, tame}; use horizon_protocol::entity_data::Value; use horizon_protocol::registry::Builtin; @@ -46,6 +46,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin) { _ => {} } match (species, *index, value) { + // Bat.DATA_ID_FLAGS: resting in bit 0. + (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0), // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared. (Species::Sheep, 18, Value::Byte(wool)) => { m.extra.color = (*wool & 15) as u8; @@ -121,6 +123,10 @@ pub(super) fn client_defaults(m: &mut Mob) { if matches!(m.species(), Species::Wolf | Species::Cat) { m.extra.color = tame::RED; } + if m.species() == Species::Bat { + // Bat's constructor sets resting only on the server; the data default is 0. + bat::set_resting(m, false); + } } #[cfg(test)] @@ -169,6 +175,69 @@ mod tests { assert!(!calf.is_baby()); } + #[test] + fn bat_flags_select_continuous_client_clocks_without_changing_motion() { + use horizon_client::mobs::{MobTypes, anim, keyframes::Animation}; + use horizon_core::geometry::Vec3; + use serde_json::json; + use std::{collections::HashMap, fs, sync::Arc}; + + // Original minimal resources keep this regression runnable without vanilla data. + let root = + std::env::temp_dir().join(format!("horizon-bat-animation-{}", std::process::id())); + fs::create_dir(&root).unwrap(); + fs::write(root.join("entity-types.json"), r#"{"minecraft:bat": {}}"#).unwrap(); + fs::write( + root.join("entity-models.json"), + r#"{"minecraft:bat#main": {"children": {"right_wing": {}, "head": {}}}}"#, + ) + .unwrap(); + let mut types = MobTypes::load(&root).unwrap(); + fs::remove_dir_all(root).unwrap(); + let position = Vec3::new(1.0, 2.25, 3.0); + let velocity = Vec3::new(0.2, 0.3, 0.4); + let mut m = Mob::new( + 1, + Arc::new(types.types.remove("minecraft:bat").unwrap()), + position, + 0.0, + ); + assert!(bat::resting(&m)); + client_defaults(&mut m); + assert!(!bat::resting(&m)); + m.velocity = velocity; + m.age = 1; + bat::setup_animation_states(&mut m); + m.age = 4; + apply(&mut m, &[(16, s::BYTE, Value::Byte(2))]); + bat::setup_animation_states(&mut m); + assert_eq!(m.anim.states[0].started, Some(1.0)); + + let curve = Animation::parse(&json!({"length": 1, "looping": true, + "bones": {"right_wing": [{"target": "rotation", "keyframes": + [[0,[0,0,0],[0,0,0],"linear"],[1,[0,1,0],[0,1,0],"linear"]]}]}})); + let animations = HashMap::from([("BatAnimation.BAT_FLYING".into(), curve)]); + let wing = |partial| { + let mut poses = anim::Poses::new(&m.kind.model); + anim::setup(&m, &anim::state(&m, partial), &mut poses, &animations); + poses.get("right_wing")[4] + }; + assert!(wing(0.5) > wing(0.0)); + + m.age = 5; + apply(&mut m, &[(16, s::BYTE, Value::Byte(3))]); + bat::setup_animation_states(&mut m); + assert!(bat::resting(&m)); + assert_eq!(m.anim.states[0].started, None); + assert_eq!(m.anim.states[1].started, Some(5.0)); + m.age = 7; + apply(&mut m, &[(16, s::BYTE, Value::Byte(0))]); + bat::setup_animation_states(&mut m); + assert_eq!(m.anim.states[0].started, Some(7.0)); + assert_eq!(m.anim.states[1].started, None); + assert_eq!((m.position, m.velocity), (position, velocity)); + } + #[test] fn a_wolf_takes_its_owner_flags_and_collar() { let Some(mut m) = mob("minecraft:wolf") else { diff --git a/crates/horizon-client/src/mobs/bat.rs b/crates/horizon-client/src/mobs/bat.rs index 9f38e9e60..ca5efa4a2 100644 --- a/crates/horizon-client/src/mobs/bat.rs +++ b/crates/horizon-client/src/mobs/bat.rs @@ -132,6 +132,10 @@ pub fn tick(m: &mut Mob) { } else { m.velocity.y *= 0.6; } + setup_animation_states(m); +} +/// `Bat.setupAnimationStates`: client visuals, without changing server motion. +pub fn setup_animation_states(m: &mut Mob) { let age = m.age as f32; if resting(m) { m.anim.states[0].stop(); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java index dc5f8c8df..9f7a63a67 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java @@ -223,7 +223,9 @@ public final class VanillaEntityAnimOracle { } /** Render-state values vanilla derives from entity state; the case gives the entity-side input. */ - private static void hooks(EntityRenderState state, JsonObject kase) { + private static void hooks(EntityRenderState state, JsonObject kase) throws Exception { + if (state instanceof net.minecraft.client.renderer.entity.state.BatRenderState bat && kase.has("@batTicks")) + batHistory(bat, kase.getAsJsonArray("@batTicks")); if (state instanceof net.minecraft.client.renderer.entity.state.SheepRenderState sheep && kase.has("eatTick")) { // Sheep.getHeadEatPositionScale / getHeadEatAngleScale at partial tick 0. int t = kase.get("eatTick").getAsInt(); @@ -242,6 +244,34 @@ public final class VanillaEntityAnimOracle { phantom.flapTime = kase.get("flapOffset").getAsFloat() + phantom.ageInTicks; } + /** Only the server's flags are supplied; the shipped Bat starts/stops its own clocks. */ + private static final class AnimationBat extends net.minecraft.world.entity.ambient.Bat { + int flags; + AnimationBat() { super(null, null); } + @Override public boolean isResting() { return (flags & 1) != 0; } + } + + private static void batHistory(net.minecraft.client.renderer.entity.state.BatRenderState state, JsonArray ticks) throws Exception { + // Allocate without a world, as the other controlled entity oracles do. + var allocator = Class.forName("sun.misc.Unsafe"); + var field = allocator.getDeclaredField("theUnsafe"); + field.setAccessible(true); + var bat = (AnimationBat) allocator.getMethod("allocateInstance", Class.class).invoke(field.get(null), AnimationBat.class); + var type = net.minecraft.world.entity.ambient.Bat.class; + type.getField("flyAnimationState").set(bat, new net.minecraft.world.entity.AnimationState()); + type.getField("restAnimationState").set(bat, new net.minecraft.world.entity.AnimationState()); + var setup = type.getDeclaredMethod("setupAnimationStates"); + setup.setAccessible(true); + for (var flags : ticks) { + bat.tickCount++; + bat.flags = flags.getAsInt(); + setup.invoke(bat); + } + state.isResting = bat.isResting(); + state.flyAnimationState.copyFrom(bat.flyAnimationState); + state.restAnimationState.copyFrom(bat.restAnimationState); + } + public static void main(String[] args) throws Exception { SharedConstants.tryDetectVersion(); Bootstrap.bootStrap(); diff --git a/tools/test_entity_model_parity.py b/tools/test_entity_model_parity.py index 0cfc509f3..11d3f7cbc 100644 --- a/tools/test_entity_model_parity.py +++ b/tools/test_entity_model_parity.py @@ -276,6 +276,14 @@ def species_cases(layer, base_cases): for extra in SPECIES.get(name, []): for index in (2, 3, 6): yield {**base_cases[index], **extra} + if name == 'bat': + # Entity clocks, rather than injected render clocks: flight, rest, transitions and + # unrelated flag bits. Exercise the in-frame tick and server-client visual update. + for flags in ([0] * 4, [1] * 4, [0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 1], [2, 3, 2, 2]): + for in_frame in (False, True): + for partial in (0.0, 0.5): + yield {**base_cases[0], 'ageInTicks': len(flags) + partial, + '@batTicks': flags, '@batInFrame': in_frame} def compare_vertices(v, r, args, stats): From 4cc134d08a52c94b88bcf4dbbdfee70b14ddde2f Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 02:13:12 +0000 Subject: [PATCH 22/70] Fix passenger walk animation in shared render state Zero passenger walk position and speed like vanilla LivingEntityRenderer, covering local and remote riders. Extend entity model parity with moving passenger and on-foot render-state cases. Fixes #1962 Co-Authored-By: Codex GPT-6.1 Sol --- .../examples/probe/entity_anim_fixture.rs | 22 +++++++++++++++++-- crates/horizon-client/src/mobs/anim.rs | 7 +++--- .../parity/VanillaEntityAnimOracle.java | 13 +++++++++++ tools/test_entity_model_parity.py | 13 +++++++++++ 4 files changed, 50 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs index 0a2e2951f..124ddbe03 100644 --- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs +++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs @@ -377,7 +377,7 @@ pub fn main() -> horizon_client::Result<()> { mob.extra.age = -24000; } mob.age = f("ageInTicks") as u32; - let state = State { + let mut state = State { pos: f("walkAnimationPos"), speed: f("walkAnimationSpeed"), age: f("ageInTicks"), @@ -389,6 +389,20 @@ pub fn main() -> horizon_client::Result<()> { }; let mut poses = Poses::new(&model); entity_state(&mut mob, def.species, case); + if let Some(ticks) = case["@walkTicks"].as_array() { + for speed in ticks { + mob.previous_limb_speed = mob.limb_speed; + mob.limb_speed += (speed.as_f64().unwrap() as f32 - mob.limb_speed) * 0.4; + mob.limb_position += mob.limb_speed; + } + if !case["@alive"].as_bool().unwrap() { + mob.health = 0.0; + } + let extracted = anim::state(&mob, f("@partial")); + state.pos = extracted.pos; + state.speed = extracted.speed; + } + let flag = |k: &str| case[k].as_bool().unwrap_or(false); let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32; let started = |k: &str| AnimationState { @@ -590,7 +604,11 @@ pub fn main() -> horizon_client::Result<()> { } _ => anim::setup(&mob, s, p, &animations), } - out.push_str(&format!("{}\n", emit(&model, &mut poses, case, layer))); + let mut result = emit(&model, &mut poses, case, layer); + if case["@walkTicks"].is_array() { + result["walk"] = json!([state.pos, state.speed]); + } + out.push_str(&format!("{result}\n")); } fs::write(&args[2], out)?; Ok(()) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index b2158132b..8639c8a9b 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -189,14 +189,15 @@ pub fn state(m: &Mob, alpha: f32) -> State { swing += 1.0; } let swing = m.anim.attack_anim_o + swing * alpha; - let alive = m.alive(); + // LivingEntityRenderer.extractRenderState: riding motion is not walking. + let walking = m.alive() && !m.extra.passenger; State { - pos: if alive { + pos: if walking { m.limb_position - m.limb_speed * (1.0 - alpha) } else { 0.0 }, - speed: if alive { + speed: if walking { (m.previous_limb_speed + (m.limb_speed - m.previous_limb_speed) * alpha).min(1.0) } else { 0.0 diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java index dc5f8c8df..80bd0bf14 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaEntityAnimOracle.java @@ -282,6 +282,19 @@ public final class VanillaEntityAnimOracle { state.getClass(); for (var entry : kase.entrySet()) if (!entry.getKey().startsWith("@")) set(state, entry.getKey(), entry.getValue()); + if (kase.has("@walkTicks")) { + var walk = new net.minecraft.world.entity.WalkAnimationState(); + for (var speed : kase.getAsJsonArray("@walkTicks")) + walk.update(speed.getAsFloat(), 0.4F, 1.0F); + // LivingEntity.calculateEntityAnimation stops passengers/dead entities; + // LivingEntityRenderer.extractRenderState also zeros both fields. + if (kase.get("isPassenger").getAsBoolean() || !kase.get("@alive").getAsBoolean()) + walk.stop(); + float partial = kase.get("@partial").getAsFloat(); + set(state, "walkAnimationPos", gson.toJsonTree(walk.position(partial))); + set(state, "walkAnimationSpeed", gson.toJsonTree(walk.speed(partial))); + result.add("walk", gson.toJsonTree(new float[]{walk.position(partial), walk.speed(partial)})); + } hooks(state, kase); if (state instanceof net.minecraft.client.renderer.entity.state.ArmedEntityRenderState armed && armed.swingAnimation > 0) armed.currentSwing = new net.minecraft.world.entity.LivingEntity.SwingDescription(net.minecraft.world.InteractionHand.MAIN_HAND, net.minecraft.world.item.component.SwingAnimation.DEFAULT, 6); diff --git a/tools/test_entity_model_parity.py b/tools/test_entity_model_parity.py index 0cfc509f3..ca0585bcf 100644 --- a/tools/test_entity_model_parity.py +++ b/tools/test_entity_model_parity.py @@ -164,6 +164,15 @@ def cases(layer, model=None): cases_out = [{**c, **DEFAULTS.get(name, {})} for c in cases_out] yield from cases_out yield from species_cases(layer, cases_out) + # Exercise render-state extraction with a live walk clock, including the + # first mounted frame. Existing setupAnim cases bypass anim::state. + if name == 'skeleton': + for passenger in [False, True]: + for alive in [False, True]: + for partial in [0.0, 0.5, 1.0]: + yield {**cases_out[2], 'isPassenger': passenger, + '@walkTicks': [0.5, 1.0, 0.75], + '@alive': alive, '@partial': partial} part = model and scaled_part(model) if part: for index, scale in enumerate(PART_SCALES): @@ -379,6 +388,10 @@ def main(): skipped.add(layer); continue checked += 1 bad = [] + if 'walk' in v: + for a, b in zip(v['walk'], r['walk']): + if abs(a - b) > args.tolerance * (1.0 + abs(a)): + bad.append(('@walk', f'{v["walk"]} != {r["walk"]}')) for path, expected in v['parts'].items(): got = r['parts'].get(path) if got is None: From 9572330ee4402a5cc68af36e59505a009fdfbfed Mon Sep 17 00:00:00 2001 From: vlesmentie <129341611+vlesmentie@users.noreply.github.com> Date: Sun, 25 Oct 2026 23:24:25 -0300 Subject: [PATCH 23/70] A villager's new profession rolls its trades Villager.setVillagerData sets offers to null when the profession changes, and getOffers rolls the new profession's trades on the next look. set_profession cleared the offers but left unset false, so ensure_offers never rolled new ones: a villager that took a placed workstation after losing its first wore the new profession but only shook its head. It now marks the offers unset, as vanilla's null. Fixes #1998. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mobs/villager.rs | 68 +++++++++++++++++++++- 1 file changed, 67 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs index 575fafaed..148034323 100644 --- a/crates/horizon-client/src/mobs/villager.rs +++ b/crates/horizon-client/src/mobs/villager.rs @@ -284,12 +284,14 @@ pub fn xp(m: &Mob) -> i32 { m.extra.trade.as_ref().map_or(0, |t| t.xp) } /// `Villager.setVillagerData(withProfession)`: a new profession forgets the -/// offers. +/// offers (`offers = null`), so the next `getOffers` rolls the new +/// profession's trades. pub fn set_profession(m: &mut Mob, profession: u8) { if m.extra.variant2 != profession { m.extra.variant2 = profession; if let Some(t) = m.extra.trade.as_mut() { t.offers.clear(); + t.unset = true; } } } @@ -846,6 +848,70 @@ pub fn read_nbt(m: &mut Mob, tag: &horizon_world::nbt::Tag) { mod tests { use super::*; + fn villager() -> Mob { + use crate::mobs::{Anim, Brain, Flags, MobType, Part, Species}; + use std::{collections::HashMap, sync::Arc}; + let kind = Arc::new(MobType { + id: "minecraft:villager".into(), + species: Species::Villager, + width: 0.6, + height: 1.95, + eye_height: 1.62, + category: "misc".into(), + max_health: 20.0, + speed: 0.5, + flying_speed: 0.02, + attack_damage: 0.0, + attack_knockback: 0.0, + follow_range: 48.0, + step_height: 0.6, + armor: 0.0, + armor_toughness: 0.0, + knockback_resistance: 0.0, + jump_strength: 0.42, + attributes: Arc::default(), + gravity: 0.08, + safe_fall_distance: 3.0, + fall_damage_multiplier: 1.0, + water_efficiency: 0.0, + water_slowdown: 0.8, + air_speed: 0.02, + baby_scale: 0.5, + head_rot_speed: 10.0, + max_head_x_rot: 40.0, + max_head_y_rot: 75.0, + ambient_interval: 80, + flags: Flags::default(), + model: Arc::new(Part::parse("root", &serde_json::json!({}))), + layers: HashMap::new(), + texture: String::new(), + brain: Brain::Passive, + anim: Anim::Villager, + sounds: [""; 3], + step_sound: None, + food: Arc::default(), + tempt: Arc::default(), + }); + Mob::new(1, kind, horizon_core::geometry::Vec3::ZERO, 0.0) + } + #[test] + fn a_new_profession_rolls_new_offers() { + let mut m = villager(); + set_profession(&mut m, 1); + // Offers made for the first profession. + m.extra.trade.get_or_insert_default().unset = false; + // The same profession keeps them. + set_profession(&mut m, 1); + assert!(!m.extra.trade.as_ref().unwrap().unset); + // A new one forgets them (offers = null), so the next getOffers + // (ensure_offers) rolls the new profession's trades. + set_profession(&mut m, 2); + let t = m.extra.trade.as_ref().unwrap(); + assert!(t.offers.is_empty()); + assert!(t.unset); + assert_eq!(m.extra.variant2, 2); + } + fn stack(item: &str, count: u32) -> ItemStack { ItemStack::new(item, count) } From 2631eca00b66b81ea5582b5421a7ed6c30197b7b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 03:32:44 +0100 Subject: [PATCH 24/70] Drop the migration's validation ledger from the docs It records an agent's runs and diagnoses, which the pull request and its branch history already keep; docs/ is for how the project works. Co-Authored-By: Claude Opus 5.5 --- docs/validation/server-thread-migration.md | 297 --------------------- 1 file changed, 297 deletions(-) delete mode 100644 docs/validation/server-thread-migration.md diff --git a/docs/validation/server-thread-migration.md b/docs/validation/server-thread-migration.md deleted file mode 100644 index 62c1609b7..000000000 --- a/docs/validation/server-thread-migration.md +++ /dev/null @@ -1,297 +0,0 @@ -# Server-thread integration coverage migration: validation ledger - -Tested on 2026-10-24, Linux / NVIDIA Vulkan, with Java 25 and the pinned 26.3 -resources and jars. Base: `e423e570c`. Player integration uses real Horizon -clients under Xvfb and real control sockets. The migrated game drivers use fresh -temporary game, launcher and XDG data/config homes; telemetry, audio and launcher -self-update are disabled. No player data or prepared resources are committed. -An interrupted historical-world generator initially inherited the harness -environment instead of those per-game homes. It wrote only to ignored `.local` -fixture folders; it was stopped, and subsequent validation uses the already -prepared historical worlds. That setup mistake is not counted as a passing run. - -## Before editing - -Open PR searches for server-thread, integration, LAN and friends work found no -overlapping migration. The full original LAN suite was started with -`--server-thread` against a build of the unchanged base before repository edits. - -| Run | Hosting | Result | -| --- | --- | --- | -| Original full LAN attempt | Server thread | 58 checks reported: 39 passed, 18 failed, deflection skipped; the runner then aborted at `light` with an uncaught `TypeError`. | -| Original remaining 45 checks | Server thread | 31 passed, 14 failed, no skips. Used the unchanged loaded driver and original executable. | -| Friends, including `--baseline` | Server thread | Plain LAN, direct invitation, local relay and ended-invite rejection passed. | - -Together the two LAN invocations attempted all 103 original checks. The initial -`sign` case left its editor open, breaking the later death-screen assertion. -`predict` suspended the whole host process; resuming it interrupted a socket -read (`Interrupted system call`), disconnected the guest and caused later -session failures. The remaining run also exposed sign placement outside reach -and cascading dead-player failures. These are recorded failures, not passes. - -## Infrastructure changes validated during migration - -- Close the sign editor after the original placement check. Give the two-player - sign case a reachable arena and wait for placement data/feedback before typing. - Observe the submitted text on both clients within the existing assertion budget. - The revised sign case passed three consecutive server-thread reruns. -- Release held input, close screens and respawn dead players before independent - cases. Keep every case's death, menu and held-action assertions inside the case. -- Replace process signals with a server barrier for prediction and an intentional - window-thread stall for frame-recovery tests. Prediction still tests immediate - client prediction, authoritative agreement, iron-door rejection and exactly-once - sound; it also asserts that the server clock did not advance at the barrier. -- Route mob/projectile/hurt-log inspection to the owning server. Deflection runs - in the default suite rather than reporting an in-frame-only skip as a pass. -- Record skipped checks explicitly as uncovered, and record ordinary case errors - without aborting the rest of the suite. Write mode and results to `results.json`. -- Serialize the two CI integration entry points on the shared GPU. An earlier - concurrent comparison failed to start a graphics device because of GPU memory - exhaustion; it was rerun serially, without changing a gameplay timeout. - -## Post-migration runs - -The first complete server-thread migration run, before the case-cleanup fixes, -ran all 103 original cases: 88 passed and 15 failed. Failures were `deflect`, -`light`, `swings`, `cracks`, `effects`, `portals`, `flight`, `boats`, `minecarts`, -`frames`, `hands`, `riding`, `mounts`, `contacts` and `absorption`. Many followed -the host's deflection damage/death. They are not used as evidence of a clean suite. - -The next complete default server-thread run executed all 107 cases (the original -103 plus four separate host/guest sensor and dispenser input cases): **97 passed, -10 failed, zero skipped**. Failures were `commands`, `deflect`, `swings`, `flight`, -`boats`, `minecarts`, `keepinv`, `fishing`, `sculk_input_host` and -`sculk_input_guest`. Lighting passed this run; earlier lighting failures are not -claimed as a persistent blocker. - -A subsequent input-timing correction runs the existing double-jump key/wait -sequence through one `horizon-ctl script` process, preserving the seven-tick -flight window. A targeted server-thread rerun passed flight for both players, -swings, boats and minecarts. Command completion still failed: the observable -suggestion list did not appear within the existing two-tick budget. The in-frame -rerun passed flight and failed completion in the same way. Passing isolated -swings/vehicle cases does not clear the unexplained failures in the full sequence. -The full-run inventory retention and fishing failures also remain unresolved. - -Friends passed plain LAN, direct invitation, local relay and ended-invite checks -both after making server-thread hosting the default and with explicit `--in-frame`. - -Targeted in-frame comparisons passed chest, sign placement, prediction, clock -recovery, lighting and deflection. The revised two-player sign case and both -new dispenser input cases passed too. Command completion failed twice: Tab after -`/gamem` left `/gamem` unchanged. The host's sculk input passed; the guest's failed. - -Targeted server-thread checks passed prediction and both new dispenser input -cases. Dispensing checks authoritative inventory consumption and exactly one -matching item on each client. Both sensor cases confirmed movement on the client -and server, but the sensor stayed inactive. Deflection still failed the original -no-fireball-damage assertion after allowing the click through a normal client -input tick. An experimental frozen-world synchronization approach also failed -and is not part of the final implementation. - -## Deterministic rule and source checks - -`python3 tools/parity.py command_exec dispenser sculk --timeout 1500 --jobs 2`: - -| Direct fixture | Result | -| --- | --- | -| Command execution | 781/781 command/callback records match the vanilla oracle. | -| Dispenser and related rule calls | 6000 cases match; no difference groups. | -| Sculk | 435 scenarios match every compared tick. | - -All three harnesses passed. Their seeded rule calls and controlled ticks remain -direct; they do not claim client/server boundary coverage. The existing -`net_harness.rs` remains a real dedicated-server client fixture. - -The first quick self-check passed 289 Python tests, rustfmt and Clippy. Rust tests -reported 1081 passed, one failed and 26 ignored: the shared prepared resource -folder lacked `registries.json`. The pinned local datagen report was copied into -a private ignored resource copy; the failed -`mod_content::tests::content_root_loads_with_every_table` test then passed. -The focused environment/parity-runner/self-check Python tests passed (38 tests). - -The full `python3 tools/pr_ready.py --base origin/main` completed: 1205 Rust tests -and 291 Python tests passed, as did rustfmt, Clippy and documentation checks. -Its parity phase failed after the historical-world setup interruption described -above, so the overall self-check is **not green**. A subsequent `parity.py --changed origin/main --timeout 1500` selected 160 -harnesses, 151 requiring runs. Three completed and passed (`firework_tooltip`, -`held_drop`, `interaction_input`). Both integration wrappers exceeded that -invocation's 25-minute per-harness deadline: friends was waiting for the shared -GPU lock, and LAN was still executing cases. Automatic retries were stopped and -the detached game processes cleaned up. The remaining affected harnesses did not -complete. This is incomplete validation, not a passing corrected parity gate; -compilation is not a substitute for the gameplay failures above. - -The final source self-check, `python3 tools/pr_ready.py --quick`, passed 1205 Rust -tests, 291 Python tests, rustfmt, Clippy and documentation checks. After correcting -the integration build arguments to name each binary (so traced selection includes -`game.rs` and `game/integrated.rs`), the named client/control/relay build and 38 -focused Python tests passed. Dependency extraction from the real Cargo dep-info -confirmed both game files are selected. - -## Limitations recorded before the follow-up fixes - -These were the remaining blockers when this ledger was first written; the -completion runs below record their status after the follow-up fixes. - -- Server-player footsteps do not reach sculk sensors. `tick_entity_events` in - `game/sculk.rs` emits player motion events from `Game.player`; the integrated - server's players live in its guest hub. The in-frame host passes and its guest - fails too, separating this shared server-player gap from the deterministic rule - oracle. A fix needs per-player event identity/state rather than weakening the test. -- The server-thread host takes fireball damage in deflection; the equivalent - in-frame check passes. Client-visible and authoritative projectile state diverge - during the synchronization investigation. No gameplay fix is included. -- Command completion fails in both modes as described above; it is not reported - as a passing fallback comparison. -- Full-sequence swings, vehicle, inventory-retention and fishing failures need - further fixture/state investigation. Swings and both vehicles passed isolated - reruns; that evidence does not establish a gameplay defect or a full-suite pass. - -No failing case is skipped, expectation relaxed, or existing timeout increased to -hide these results. At that stage the PR stayed draft with these coverage blockers. - -## Combined validation before the gameplay split (2026-10-25) - -Merged `main` at `bd591f985` and resolved the overlapping motion, projectile and -test-driver changes. The shared projectile inertia helper retains main's custom -acceleration power, with a regression test. Integration environments now call -`lab.game_env`; the friends entry point delegates its actual launches to that -isolated driver. The dedicated-server process keeps one environment argument, -and the control-tool connection test uses a scratch home rather than reading -the player's No AI setting. - -The first complete run after that merge executed **119 cases: 114 passed, -five failed, zero skipped**. Failures were `swings`, `flight`, `boats`, -`minecarts` and `keepinv`. All the additional regression cases from main passed. -Command completion, deflection, fishing and both sensor/dispenser input roles -also passed in that full sequence. - -The failures exposed fixture setup, input cadence and an off-hand clearing bug: - -- Aim at the hoe target's top face, observe that target, then send a normal - mouse click. Keep the exact one-swing/farmland assertion. A subsequent full - repeat passed flight and both vehicle checks but still failed the hoe case; - it was stopped after identifying the root cause rather than counted as green. - The earlier explosion case leaves an off-hand shield, and `/clear` omitted - that slot. Vanilla correctly blocks hoe use with that shield. Follow - `Inventory.clearOrCountMatchingItems`, `getContainerSize`, `getItem` and its - equipment-slot mapping: clear off-hand items and visit armor feet to head. - New oracle cases cover off-hand counting, partial/full removal and limited - armor-slot ordering. The explosion-then-swings sequence passes after this fix. -- Keep the original double-jump key sequence and seven-tick flight rule; run - this tick-sensitive case at four ticks per second so IPC scheduling on a busy - machine cannot stretch the input past that window. Restore 20 TPS afterward. -- Deliver the original ten vehicle punches and two-tick waits over one control - connection. Separate process launches had stretched the gaps to ten ticks, - letting the vehicle's damage decay before the next hit. -- Protect inactive inventory-test players after the low-health totem case, - assert that the active player is alive before the intended death, and provide - a full floor under scattered death drops. A targeted retry with the old small - platform lost a helmet over its edge; both players' exact drop/retention - assertions passed with the larger floor. - -Targeted server-thread reruns passed all five corrected cases, plus totems, -fishing and both sensor input roles. Friends passed plain LAN, direct invites, -the local relay and ended-invite rejection. The six focused parity harnesses -passed: `command_exec`, `dispenser`, `sculk`, `dedicated_server`, -`server_entities` and `server_player_damage`. - -The normal-runner full repeat also exposed an XP observation race: the guest -had already collected all 21 points before the two-tick in-flight snapshot -(`seen=0`, with the correct XP gain and no remaining orbs). Freeze spawning, -step two world ticks, observe the tracked orbs, then unfreeze for the original -pickup assertions. The targeted check passed with three visible orbs and -exactly 21 points; the full runner restarted with that correction. - -That repeat passed the former XP, swings, flight, boat and minecart failures, -but its level-ticking subcase found a wandering pig on a neighboring block at -Y=66 instead of the landing floor at Y=65. The armor stand landed correctly. -This subcase measures falling and simultaneous level ticking. Each level now -gets a full clear landing/walking area, retaining the pigs' normal AI. A -hazard-then-levels rerun confirmed that both pigs and armor stands land at the -expected heights with distinct entity IDs across levels. - -The broader parity invocation completed **116/117 runs passed**. The remaining -`tab_list` comparison matched 998/1000 lists and all 400 skin images. Both -list mismatches contained `Ⅻ`: the oracle's bitmap-only font setup used the -missing glyph instead of vanilla's Unicode fallback. Load the full default font -reference chain from the prepared assets with vanilla's provider definitions -and default option filters. Prefetch the fake skin lookups together before the -unchanged one-second observation window, retaining deliberately pending cases. -A fresh rerun passed **1000/1000 lists, 3510 frames and 400/400 skin images**, -with zero oracle errors. Fresh secure-chat and dimension-player parity reruns -passed after the command fix as well. The extended command oracle matched all -**843 command/callback records**. - -Rechecking the shared font helper passed eight of nine additional harnesses; -`pack_screen` matched 2778/3000 cases with its old bitmap-only oracle. Its -newline/control glyph metrics also require the Unicode fallback (the newline -advance is 9 with the full font, 6 with the bitmap-only setup). Give this oracle -the same full default font and prepared asset root. A fresh rerun matched -**3000/3000 pack screens**, with zero oracle errors and unchanged comparisons. - -The source self-check passed **1237 Rust tests and 270 Python tests**, rustfmt, -Clippy and doc tests. The private resource copy contains both pinned reports -and a regular `facts.json`, as required by the resource-isolation regression. -Prepared historical test worlds were copied into the ignored fixture cache -where available; they are not player saves or committed resources. - -The final in-frame comparison passed **14/14 cases, zero skipped**: commands, -deflection, both sensor roles, flight, swings, boats, minecarts, chest, prediction, -signs, both dispenser roles and inventory retention. A separate in-frame XP -comparison passed with three visible orbs and exactly 21 points. Friends and -the dedicated-server harness passed through the normal parity runner. - -The final normal-runner server-thread LAN repeat passed **119/119 cases, -zero skipped**, in 1940 seconds. This full sequence includes all earlier failure -cases, both sensor/dispenser roles and the additional regressions from main. -The final full `python3 tools/pr_ready.py` gate passed against merge base -`bd591f985`: **1237 Rust tests, 270 Python tests**, rustfmt, Clippy, public-tree -checks and documentation tests. Its parity stage selected **118 affected -harnesses**; 117 had current content-matched passing records and the remaining -harness passed during the gate. No failed or skipped harness remained. -The gate reported the existing scope warning (35 files, 584 lines of code); -the combined migration exceeded the suggested 500-line size. At that point -the combined PR was marked ready for review. The split below supersedes that -readiness status and the earlier description block. - - -## Gameplay fixes split into independent PRs (2026-10-25) - -At the user's request, the three gameplay fixes were removed from this PR's -net diff and opened independently against `main`: - -- [#1903](https://github.com/ludovic111/horizon/pull/1903): `/clear` off-hand - handling and vanilla inventory-slot order, including the added command-oracle - cases. The independent branch matches **843/843 command/callback records**. -- [#1904](https://github.com/ludovic111/horizon/pull/1904): connected-client - fireball motion and authoritative corrections, including the acceleration - regression and a focused `remote_fireball` integration harness. The new - harness fails on unchanged main in both hosting modes and passes with only - that gameplay fix applied. -- [#1905](https://github.com/ludovic111/horizon/pull/1905): per-player sculk - emission and history, including a focused `server_player_sculk` integration - harness. Without the fix, both server-thread players and the in-frame guest - fail while the in-frame host passes. With only this fix, **4/4 cases** pass, - along with **435/435 vanilla scenarios matching on every tick**. - -Each independent branch passes the quick source self-check using -`lab.game_env()` scratch homes (287 Python tests; 1241 Rust tests for clear -and sculk, 1242 for fireballs; formatting, Clippy and doc tests). Their broader -parity selections are listed for CI, rather than claimed as standalone full -parity passes. - -The migration was merged with main at `8177a6f45` before removing the fixes. -Its test migration, fixture synchronization, isolated environments, control -inspection and font-oracle corrections remain. The **119/119 full LAN pass** -and full affected-parity readiness result above belong to the combined -pre-extraction snapshot `cc9410b6`; they do not establish that the migration -alone passes after the gameplay code has been removed. This PR stays draft -until the three dependencies land and its full integration suite is rerun. - -The post-split migration quick source gate passes **1241 Rust tests and 290 -Python tests**, formatting, Clippy, public-tree and doc checks. It lists **70 -affected parity harnesses** for CI. Full post-split integration validation is -pending the three gameplay dependencies; no replacement full-suite pass is -claimed here. From 51911080f0ef023f347f6133e3a2dc8531c486a4 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 05:58:53 +0300 Subject: [PATCH 25/70] Mob models: one skip lookup per part, not one per polygon Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/render.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index cb21cec8c..4188c9c85 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -946,7 +946,11 @@ fn draw_normals( return; } let normals = normals.part(p); - for poly in part.polygons.iter().filter(|_| !poses.skips(part)) { + // `skips` is a name lookup: asking once per part, not once per polygon. + if poses.skips(part) { + return; + } + for poly in &part.polygons { let normal = poly.vertex_normal(normals); for v in poly.vertices { let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); From dcc5899692842530d24647072c6208278bd4e932 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 06:00:36 +0300 Subject: [PATCH 26/70] Name tags: collect the ridden mobs once, not per tag Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/game/names.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index f249bd01f..9ede507e3 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -86,6 +86,10 @@ impl Game<'_> { .iter() .filter_map(|m| Some((m, m.custom_name.clone()?, false))); let players = players.into_iter().map(|(m, name)| (m, name, true)); + // Who is riding whom: asked once per tag below, and rescanning every mob + // for each tag made this quadratic in the number of loaded mobs. + let ridden: std::collections::HashSet = + self.mobs.iter().filter_map(|o| o.extra.mount).collect(); for (m, name, player) in named.chain(players) { if !m.alive() { continue; @@ -134,7 +138,7 @@ impl Game<'_> { invisible_to_viewer: invisible, hud_hidden: self.ui.hide_gui, is_camera: false, - is_vehicle: self.mobs.iter().any(|o| o.extra.mount == Some(m.id)), + is_vehicle: ridden.contains(&m.id), }; // MobRenderer.shouldShowName: a visible name, or the mob under the // crosshair; players (LivingEntityRenderer) need neither. From d41aa95dbd6cde12ed4d6bb78141e91f8c21b28d Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 06:04:06 +0300 Subject: [PATCH 27/70] Mob models: one Poses per mob per frame, not one per equipment layer Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/anim.rs | 21 ++++++++++++--------- crates/horizon-client/src/mobs/render.rs | 20 ++++++++++++++++---- 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index b2158132b..81faa3a02 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -102,7 +102,7 @@ impl AnimState { pub fn end_tick(&mut self, _swinging: bool) {} } /// Part poses for one draw, keyed by part name. -#[derive(Clone)] +#[derive(Clone, Default)] pub struct Poses { map: HashMap, dummy: [f32; 9], @@ -113,20 +113,23 @@ pub struct Poses { } impl Poses { pub fn new(model: &Part) -> Self { - let mut map = HashMap::new(); + let mut poses = Self::default(); + poses.reset(model); + poses + } + /// Refills this for another model, keeping the map and the sets' capacity: + /// a mob draws its body and every equipment layer each frame. + pub fn reset(&mut self, model: &Part) { fn walk(p: &Part, map: &mut HashMap) { map.insert(p.name.clone(), p.pose); for c in &p.children { walk(c, map); } } - walk(model, &mut map); - Self { - map, - dummy: [0.0; 9], - skipped: Default::default(), - hidden: Default::default(), - } + self.map.clear(); + self.skipped.clear(); + self.hidden.clear(); + walk(model, &mut self.map); } pub fn get(&mut self, name: &str) -> &mut [f32; 9] { match self.map.get_mut(name) { diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index cb21cec8c..5c01f3f2f 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -1089,6 +1089,9 @@ fn render_visible( } } } + // One Poses for every layer: a humanoid with armour redraws five to seven + // models, and each used to allocate its own maps. + let mut layer_poses = Poses::default(); for layer in all_layers { let Some(part) = m.kind.layer(&layer.model).cloned() else { continue; @@ -1096,8 +1099,8 @@ fn render_visible( let Some(uv) = atlas(&layer.texture) else { continue; }; - let mut poses = Poses::new(&part); - anim::setup(m, &s, &mut poses, &data.animations); + layer_poses.reset(&part); + anim::setup(m, &s, &mut layer_poses, &data.animations); if matches!(m.species(), Species::Villager | Species::ZombieVillager) && let Some((folder, variant)) = layer .texture @@ -1108,7 +1111,7 @@ fn render_visible( data.villager_hats .read() .unwrap_or_else(std::sync::PoisonError::into_inner) - .apply(folder, variant, profession, &mut poses); + .apply(folder, variant, profession, &mut layer_poses); } let light = if layer.full_bright { 240 | 240 << 8 @@ -1123,7 +1126,16 @@ fn render_visible( None => overlay, }; let start = out.len(); - draw(&part, base, &poses, uv, layer.color, light, overlay, out); + draw( + &part, + base, + &layer_poses, + uv, + layer.color, + light, + overlay, + out, + ); if layer.full_bright && m.species() != Species::Warden { for vertex in &mut out[start..] { vertex.normal = [0; 4]; From 03a3c48a71bb472ae036561e72f5628b2788649d Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 04:18:54 +0000 Subject: [PATCH 28/70] Fix Peaceful removal of existing hostile mobs Apply the vanilla Mob.checkDespawn Peaceful gate before persistence and player distance checks. Extend the mob AI parity harness with difficulty, persistence, name-tag and NoAI regressions and allowed-type controls. Fixes #1942 Co-Authored-By: OpenAI Codex (GPT-6.1 Sol) --- .../examples/probe/mob_ai_probe.rs | 9 ++++++++- crates/horizon-client/src/mobs/ai.rs | 4 ++++ .../horizonlab/parity/VanillaMobAiOracle.java | 7 +++++++ tools/test_mob_ai_parity.py | 16 ++++++++++++++++ 4 files changed, 35 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index 49f56c250..ecdf02901 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -49,6 +49,7 @@ struct Scenario { name: String, ticks: i32, time: i64, + difficulty: u8, rain: bool, thunder: bool, origin: [i32; 2], @@ -85,11 +86,13 @@ fn parse(text: &str) -> Vec { "scenario" => { s.name = f[1].to_owned(); s.time = 6000; + s.difficulty = 2; for kv in &f[2..] { let (k, v) = kv.split_once('=').unwrap_or((kv, "")); match k { "ticks" => s.ticks = v.parse().unwrap(), "time" => s.time = v.parse().unwrap(), + "difficulty" => s.difficulty = v.parse().unwrap(), "rain" => s.rain = true, "thunder" => s.thunder = true, "levelseed" => {} @@ -954,6 +957,10 @@ pub fn main() -> horizon_client::Result<()> { for flag in &spec.flags { match flag.as_str() { "persistent" => m.persistent = true, + "named" => { + m.custom_name = Some("Peaceful regression".into()); + m.persistent = true; + } "ridden" => { m.extra.head = Some("minecraft:red_harness".into()); m.rider = Some(horizon_client::mobs::equine::Rider::default()); @@ -1090,7 +1097,7 @@ pub fn main() -> horizon_client::Result<()> { block_tags: &items.block_tags, biomes: &biomes, mob_griefing: true, - difficulty: LocalDifficulty::new(2, world.day_time, 0, 0.0), + difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0), end: false, world_seed: 0, // FlatLevelSource.getSeaLevel. diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index c9bc15fda..8335cb745 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -1024,6 +1024,10 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool { if m.species() == Species::Mannequin { return true; } + // Mob.checkDespawn discards disallowed types even when persistent or NoAI. + if w.difficulty.effective == 0.0 && !super::spawn_rules::allowed_in_peaceful(m.species()) { + return false; + } let Some(p) = w.nearest_player else { return true; }; diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java index eb5235adf..0345a4bc6 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -159,6 +159,7 @@ public final class VanillaMobAiOracle { static final class Scenario { String name; int ticks; + int difficulty = 2; long time = 6000; boolean rain, thunder; int originX, originZ; @@ -204,6 +205,7 @@ public final class VanillaMobAiOracle { switch (kv[0]) { case "ticks" -> s.ticks = Integer.parseInt(kv[1]); case "time" -> s.time = Long.parseLong(kv[1]); + case "difficulty" -> s.difficulty = Integer.parseInt(kv[1]); case "rain" -> s.rain = true; case "thunder" -> s.thunder = true; case "levelseed" -> s.levelSeed = Long.parseLong(kv[1]); @@ -494,6 +496,7 @@ public final class VanillaMobAiOracle { } void run(Scenario s, ServerLevel level) throws Exception { + this.setDifficulty(net.minecraft.world.Difficulty.byId(s.difficulty), true); out.println("== " + s.name); var clock = level.registryAccess().lookupOrThrow(Registries.WORLD_CLOCK).getOrThrow(WorldClocks.OVERWORLD); this.clockManager().setTotalTicks(clock, s.time); @@ -553,6 +556,10 @@ public final class VanillaMobAiOracle { String v = kv.length > 1 ? kv[1] : ""; switch (kv[0]) { case "persistent" -> mob.setPersistenceRequired(); + case "named" -> { + mob.setCustomName(net.minecraft.network.chat.Component.literal("Peaceful regression")); + mob.setPersistenceRequired(); + } case "ridden" -> mob.setItemSlot(net.minecraft.world.entity.EquipmentSlot.BODY, new net.minecraft.world.item.ItemStack(BuiltInRegistries.ITEM.getValue( net.minecraft.resources.Identifier.parse("minecraft:red_harness")))); diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index 87a7a1403..7aaa597e1 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -311,6 +311,22 @@ def scenarios(): add('villager_golem_panic', 100, ['fill -2 -60 -3 4 -60 4 minecraft:oak_fence', 'fill -1 -60 -2 3 -60 3 minecraft:air', 'player 14.5 -60 0.5'] + golem_callers[:3] + ['mob minecraft:zombie 6.5 -60 0.5 90 86 persistent noai'], 'time=18000') + # Mob.checkDespawn removes disallowed types before persistence/NoAI checks. + # Keep the non-Peaceful controls and the allowed hostile/neutral exceptions. + for difficulty in range(4): + for flags in ('', 'persistent', 'named', 'noai', 'persistent noai'): + suffix = flags.replace(' ', '_') or 'ordinary' + add(f'peaceful_zombie_{difficulty}_{suffix}', 1, [ + 'player 6.5 -60 0.5', + f'mob minecraft:zombie 0.5 -60 0.5 0 1 {flags}', + ], f'difficulty={difficulty} time=18000') + for species in ('skeleton', 'creeper', 'slime', 'warden', 'wither', + 'piglin', 'shulker', 'bee', 'wolf', 'iron_golem', 'cow'): + add(f'peaceful_type_{species}', 1, [ + 'player 6.5 -60 0.5', + f'mob minecraft:{species} 0.5 -60 0.5 0 1 persistent noai', + ], 'difficulty=0 time=18000') + return s From 3df60c21c2ca64b9ce2703c803e4aa555d7f23d0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 05:28:30 +0100 Subject: [PATCH 29/70] tests: compare resolved paths in the prepared-report fallback test macOS temp dirs live under /var, a symlink to /private/var, so the resolved report path never equalled the unresolved fallback. Co-Authored-By: Claude Opus 5.5 --- tests/test_integration_env.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_integration_env.py b/tests/test_integration_env.py index 07ba97a1b..018b02763 100644 --- a/tests/test_integration_env.py +++ b/tests/test_integration_env.py @@ -42,7 +42,7 @@ class PreparedReportTests(unittest.TestCase): fallback.mkdir(parents=True) for name in ('registries.json', 'commands.json'): (fallback / name).write_text('{}') - self.assertEqual(require_server_reports(resources).resolve(), fallback) + self.assertEqual(require_server_reports(resources).resolve(), fallback.resolve()) (resources / 'registries.json').write_text('{}') with self.assertRaisesRegex(ValueError, 'installed together'): require_server_reports(resources) From bf2961834be7c29a8fe46861d55c82e42d2f82ff Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 09:52:00 +0500 Subject: [PATCH 30/70] Item cooldowns: tick them on the server client's path too MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review of #1933 (rdbtCVS): `Game::tick` returns through `tick_remote` whenever `remote` is set — every multiplayer session and the default single player — so the `tick_world` call that advanced the entries never ran there. A thrown pearl's slot stayed at full shade until the server's duration-0 packet arrived instead of fading over the second. `tick_remote_level` advances them now (Player.tick's ItemCooldowns.tick); the groups that end are dropped silently, as the client's plain ItemCooldowns does. Co-Authored-By: [CC] --- crates/horizon-client/src/game/remote.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..8b3799426 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3170,6 +3170,12 @@ impl Game<'_> { fn tick_remote_level(&mut self) -> Result<()> { self.ticks += 1; self.track_experience_display(); + // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s + // for a server's client (multiplayer and the default single player), + // so the entries advance here or the slot stays shaded until the + // server says the entry ended. `onCooldownEnded` is the plain + // ItemCooldowns' no-op on a client. + self.cooldowns.tick(); // Options.broadcastOptions: a changed render distance or Chat option // is sent again. let view = client_view_distance(self.settings.render_distance); From 276f8d49c133df03f05c0670c55b2e59a2aa844a Mon Sep 17 00:00:00 2001 From: levzzz <86072227+levzzz5154@users.noreply.github.com> Date: Mon, 26 Oct 2026 09:45:40 +0500 Subject: [PATCH 31/70] Chat: a LAN guest's line follows the host's Chat option MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review of #1932 (rdbtCVS): with `--in-frame`, opening a world to LAN and setting Commands Only still showed a guest's ordinary chat on the host. The hub's `HostEvent::Chat` went through `system_message`, which asks for `receive_system_messages` — true at Commands Only — so the line passed. `Game::player_message` shows a chat line as `ChatSource::Player`, which is the permission `ChatListener` checks for player chat; `lan_log_event` routes `HostEvent::Chat` there. `/say` and `/me` arrive as chat messages too (say_command, emote_command), so they follow the same permission as they do for the guests' own packets; command feedback such as `/list` is a system message and keeps the system-message permission. Reproduced on the pre-fix build: host at Commands Only, guest sends `baseline-visible` → the host shows ` baseline-visible`. With this change the same line stays hidden at Commands Only and shows at Shown. Co-Authored-By: [CC] --- crates/horizon-client/src/chat_tests.rs | 30 +++++++++++++++++++++++ crates/horizon-client/src/game/chat.rs | 32 +++++++++++++++++++++++++ crates/horizon-client/src/game/lan.rs | 6 ++++- 3 files changed, 67 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index 6b058c0fb..fa065766c 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -436,3 +436,33 @@ fn the_chat_option_filters_the_lines_both_ways() { chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::Full)); assert_eq!(shown(&chat), ["client", "server", "player"]); } + +/// The in-frame LAN host's chat: a guest's line is a player message, so the +/// Chat option's player-message permission hides it at Commands Only and +/// Hidden; command feedback (`/say`, `/me`) is a system message and stays. +#[test] +fn a_guests_line_follows_the_player_message_permission() { + let font = font(); + let shown = |visibility, source| { + let mut chat = Chat::default(); + chat.abilities = ChatAbilities::new(visibility); + chat.add_message(&font, Text::literal("line"), None, source, 0, false); + chat.messages.len() + }; + for (visibility, player, system) in [ + (ChatVisibility::Full, 1, 1), + (ChatVisibility::System, 0, 1), + (ChatVisibility::Hidden, 0, 0), + ] { + assert_eq!( + shown(visibility, ChatSource::Player), + player, + "{visibility:?}" + ); + assert_eq!( + shown(visibility, ChatSource::Server), + system, + "{visibility:?}" + ); + } +} diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 5d3919c8b..be2a318a0 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -481,6 +481,38 @@ impl Game<'_> { self.mods_chat(&line); } } + /// A player's chat line on the window's own chat: a LAN guest's message + /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener` + /// checks `canReceivePlayerMessages` for these, so Commands Only and + /// Hidden drop them; command feedback (`/list`, `/tp`) is a system + /// message and takes the system-message permission instead. + pub(super) fn player_message(&mut self, text: Text) { + if let Some(capture) = self.chat_capture.as_mut() { + capture.push(text); + return; + } + // A server's client receives the line as a packet (PlayerChat or + // DisguisedChat) and filters it there. + if self.remote.is_some() { + return; + } + if !self.ui.chat.shows(ChatSource::Player) { + return; + } + let focused = self.screen == Screen::Chat; + let heard = self.mods.running().then(|| text.plain()); + self.ui.chat.add( + &self.gui.atlas, + text, + None, + ChatSource::Player, + self.ticks, + focused, + ); + if let Some(line) = heard { + self.mods_chat(&line); + } + } /// Keys while the chat screen is open. pub(super) fn chat_key(&mut self, event: &KeyEvent) { if let Some(shortcut) = self.edit_shortcut(event) { diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 50fa222e6..99727b53f 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1403,7 +1403,11 @@ impl Game<'_> { let tag = if secure { "" } else { "[Not Secure] " }; super::dedicated::log("INFO", &format!("{tag}{line}")); } - HostEvent::Chat { line, .. } => self.system_message(Text::literal(line)), + // Player chat (and `/say`'s or `/me`'s, which are chat messages + // too): the host's Chat option decides, as `ChatListener` does + // for the guests' packets. Command feedback is a system message + // and takes the system-message permission instead. + HostEvent::Chat { line, .. } => self.player_message(Text::literal(line)), HostEvent::Warn(line) if dedicated => super::dedicated::log("WARN", &line), HostEvent::Warn(line) => log::warn!("{line}"), HostEvent::Error(line) if dedicated => super::dedicated::log("ERROR", &line), From 77def1f2dd13fe5c7d3f96d6c745c74312409501 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:40:00 +0300 Subject: [PATCH 32/70] Mob models: a skipped part still draws its children The early return skipped the child loop as well, while skipDraw only hides the part's own cubes. A rolled armadillo skips its body and still renders the parts below it. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/mobs/render.rs | 38 ++++++++++++------------ 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 4188c9c85..ef18536d3 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -946,25 +946,25 @@ fn draw_normals( return; } let normals = normals.part(p); - // `skips` is a name lookup: asking once per part, not once per polygon. - if poses.skips(part) { - return; - } - for poly in &part.polygons { - let normal = poly.vertex_normal(normals); - for v in poly.vertices { - let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); - out.push(Vertex { - normal, - pos: pos.to_array(), - uv: [ - uv[0] + (uv[2] - uv[0]) * v[3], - uv[1] + (uv[3] - uv[1]) * v[4], - ], - layer: overlay, - color, - light, - }); + // `skips` is a name lookup: ask once per part, not once per polygon. A part + // hidden this way still draws its children, so only the polygons are gated. + if !poses.skips(part) { + for poly in &part.polygons { + let normal = poly.vertex_normal(normals); + for v in poly.vertices { + let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0); + out.push(Vertex { + normal, + pos: pos.to_array(), + uv: [ + uv[0] + (uv[2] - uv[0]) * v[3], + uv[1] + (uv[3] - uv[1]) * v[4], + ], + layer: overlay, + color, + light, + }); + } } } for c in &part.children { From 1e9644cc1577d2382965fa8733f2190e2cebad58 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:51:52 +0300 Subject: [PATCH 33/70] Signs: cut the first line on byte offsets, not through a char copy first_line collected the whole line into a Vec and then re-collected a prefix of it, eight times per sign per frame, front and back. Every cut point it needs is already a byte offset in the input. Co-Authored-By: Hermes Agent (Nous Research) --- .../horizon-client/src/block_entity_render.rs | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 10c5e2509..28a876d80 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -558,12 +558,11 @@ fn frac(x: f32) -> f32 { /// `StringSplitter.splitLines(...).get(0)` for plain text: the first line, /// wrapped at the last space that fits or mid-word when none does. fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> String { - let chars: Vec = line.chars().collect(); let mut width = 0.0; let mut last_space = None; - for (i, &c) in chars.iter().enumerate() { + for (i, c) in line.char_indices() { if c == '\n' { - return chars[..i].iter().collect(); + return line[..i].to_owned(); } if c == ' ' { last_space = Some(i); @@ -572,9 +571,11 @@ fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> Stri if width > max_width { let end = match last_space { Some(s) if s > 0 => s, - _ => i.max(1), + _ if i > 0 => i, + // The first char alone is too wide: take that one char. + _ => c.len_utf8(), }; - return chars[..end].iter().collect(); + return line[..end].to_owned(); } } line.to_owned() @@ -2098,4 +2099,13 @@ mod tests { assert_eq!(out[1].pos, [2.0, 0.0, 0.0]); assert_eq!(out[2].uv, [0.5, 0.5]); } + + #[test] + fn first_line_wraps_on_bytes_without_splitting_a_char() { + let advance = |c: char| if c == ' ' { 4.0 } else { 6.0 }; + assert_eq!(first_line("ab cd ef", 13.0, &advance), "ab"); + assert_eq!(first_line("abcdef", 13.0, &advance), "ab"); + assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}"); + assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab"); + } } From 9dc72bf3ac6f7eed7c2667953f0ddd84e12c0cad Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 08:58:50 +0300 Subject: [PATCH 34/70] Subtitles: measure each line once per frame The max-width pass built a Text for every audible subtitle and dropped the width it measured, then the draw loop built the same Text again to measure it a second time. The row loop uses the number the first pass already had. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/hud_overlays.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index ecc23a5ee..ebd860e08 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -1111,8 +1111,9 @@ impl SubtitleOverlay { s.purge_old_instances(3000.0 * frame.multiplier, now); } if s.audible_from(position) && !s.played.is_empty() { - width = width.max(width_of(&Text::translate(&s.key, &[]))); - audible.push(i); + let text_width = width_of(&Text::translate(&s.key, &[])); + width = width.max(text_width); + audible.push((i, text_width)); } } if audible.is_empty() { @@ -1121,7 +1122,7 @@ impl SubtitleOverlay { let w = |s: &str| font.width(s) as i32; width += w("<") + w(" ") + w(">") + w(" "); let mut row = 0; - for i in audible { + for (i, text_width) in audible { let s = &self.subtitles[i]; let text_value = Text::translate(&s.key, &[]); let Some(closest) = s.best_candidate(position) else { @@ -1145,7 +1146,6 @@ impl SubtitleOverlay { let half_width = width / 2; let height = 9; let half_height = height / 2; - let text_width = width_of(&text_value); let brightness = s.brightness(closest, frame.multiplier, now); out.push(GuiDraw::Push(vec![ PoseOp::Translate( From dd45bf7740c50f09e6882a4c284d52edbf9a675b Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:08:18 +0300 Subject: [PATCH 35/70] F3: measure each line once per frame The overlay measured every line to place it and measured it again for its background box, about thirty extra glyph walks per frame on a full screen. The width that placed the line is carried to the background pass. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/debug_overlay.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/debug_overlay.rs b/crates/horizon-client/src/debug_overlay.rs index 3448ea411..fa969512c 100644 --- a/crates/horizon-client/src/debug_overlay.rs +++ b/crates/horizon-client/src/debug_overlay.rs @@ -194,18 +194,17 @@ pub fn scale( pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec { let mut out = vec![GuiDraw::Push(vec![PoseOp::Scale(scale, scale)])]; for (lines, align_left) in [(columns[0], true), (columns[1], false)] { - let placed: Vec<(&String, i32, i32)> = lines + let placed: Vec<(&String, i32, i32, i32)> = lines .iter() .enumerate() .filter(|(_, l)| !l.is_empty()) .map(|(i, l)| { let w = font.width(l) as i32; let left = if align_left { 2 } else { width - 2 - w }; - (l, left, 2 + LINE_HEIGHT * i as i32) + (l, left, 2 + LINE_HEIGHT * i as i32, w) }) .collect(); - for (line, left, top) in &placed { - let w = font.width(line) as i32; + for (_, left, top, w) in &placed { out.push(fill( left - 1, top - 1, @@ -214,7 +213,7 @@ pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec BACKGROUND, )); } - for (line, left, top) in placed { + for (line, left, top, _) in placed { out.push(GuiDraw::Text { text: Text::literal(line.clone()), x: left, From b59d9ada27ef08208ce4ca182f5da0d9ff112ff4 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:49:41 +0300 Subject: [PATCH 36/70] Shaders: the frame uniforms keep their buffer between frames update rebuilt the values vector every frame for a fixed-length list: one allocation and one free per frame for nothing. eval_custom already treats the same vector as a buffer to truncate and extend. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/gfx/pack_uniforms.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/gfx/pack_uniforms.rs b/crates/horizon-client/src/gfx/pack_uniforms.rs index c4df4377b..8f5f1a2de 100644 --- a/crates/horizon-client/src/gfx/pack_uniforms.rs +++ b/crates/horizon-client/src/gfx/pack_uniforms.rs @@ -399,7 +399,8 @@ impl FrameUniforms { _ => Value::i(&[0]), } }; - self.values = NAMES.iter().map(|n| value(n)).collect(); + self.values.clear(); + self.values.extend(NAMES.iter().map(|n| value(n))); self.frame = (self.frame + 1) % 720_720; } From 73bbbd3ee8ead8624788812f9818e3ae7a1259f0 Mon Sep 17 00:00:00 2001 From: Alexander Krylov Date: Mon, 26 Oct 2026 09:55:58 +0300 Subject: [PATCH 37/70] Tooltips: compare the hidden component id without a UTF-16 copy TooltipDisplay.shows built a JavaString from the id on every call just to test membership in the NBT list. A hovered tooltip asks this a dozen times per frame, so the hover allocated a dozen short vectors per frame for a read. Co-Authored-By: Hermes Agent (Nous Research) --- crates/horizon-client/src/item_tooltip.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 6e51de391..cb52965a0 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -56,10 +56,9 @@ impl<'a> TooltipDisplay<'a> { else { return true; }; - let component = horizon_world::nbt::JavaString::from(component); - !hidden - .iter() - .any(|tag| matches!(tag, Tag::String(id) if id == &component)) + !hidden.iter().any(|tag| { + matches!(tag, Tag::String(id) if id.0.iter().copied().eq(component.encode_utf16())) + }) } } From b6af2584659fd487757a67084883073058b334b7 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 07:29:40 +0000 Subject: [PATCH 38/70] Fix warden sonic boom particle delivery to connected players Send each sonic ray point through the existing particle packet path with vanilla recipient filtering. Cover nearby and distant clients, damage, and local rendering in the LAN harness. Fixes #1490. Co-Authored-By: Codex (GPT-6.1 Sol) --- crates/horizon-client/src/game/creatures.rs | 3 ++ .../horizon-client/src/game/lan_particles.rs | 28 ++++++++++ tools/lan_e2e.py | 51 +++++++++++++++++++ 3 files changed, 82 insertions(+) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..fb4844bfc 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -1057,6 +1057,9 @@ impl Game<'_> { self.ensure_item_particle_sprites(); } let options = horizon_client::particles::ParticleOptions::simple(ty); + if ty == horizon_client::particles::ParticleType::SonicBoom { + self.lan_sonic_boom(&options, at); + } // Count 0: one particle exactly there, at rest. if count == 0 { self.particles.add(&options, at, [0.0; 3]); diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index 0e35392bf..f92e8cf61 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -25,6 +25,34 @@ fn rgb(c: [f32; 4]) -> [f32; 3] { } impl Game<'_> { + /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point. + /// Keep the local event's rendering; connected players receive one at rest. + pub(super) fn lan_sonic_boom(&self, options: &ParticleOptions, at: [f64; 3]) { + let Some(particle) = self.network_particle(options, None) else { + return; + }; + let packet = C::LevelParticles(play::LevelParticles { + particle, + override_limiter: false, + always_show: false, + pos: at, + dist: [0.0; 3], + max_speed: [0.0; 3], + count: 0, + randomization: 0, + }); + let host = self.lan.as_ref().unwrap(); + for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { + // ServerLevel compares the player's block centre, strictly within 32. + let distance: f64 = (0..3) + .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2)) + .sum(); + if distance < 32.0 * 32.0 { + g.send(&packet); + } + } + } + /// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's /// network id and the data it carries (`state` for the block particles). /// None while not serving, or for a particle whose data isn't sent from diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..4acae0963 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -6591,5 +6591,56 @@ CHECKS += ['replant'] CHECK_FNS['replant'] = check_replant +def check_sonic(host, guest, out): + """A real warden's ray reaches connected clients once, with normal damage. + + Run with and without --server-thread to cover the window's local renderer too. + The creative observer sees the same ray nearby and none outside sendParticles' range. + """ + x, y, z = (int(v // 1) for v in pos_of(host)) + result = {} + guest('command', command='gamemode creative') + host('command', command='difficulty normal') + host('command', command='gamerule natural_health_regeneration false') + try: + host('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 85} {y - 1} {z + 14} minecraft:stone') + host('command', command=f'fill {x - 3} {y} {z - 3} {x + 15} {y + 4} {z + 14} minecraft:air') + host('command', command=f'fill {x - 2} {y} {z + 4} {x + 2} {y + 3} {z + 4} minecraft:stone') + for near in (True, False): + guest('command', command=f'tp @s {x + (3 if near else 80) + 0.5} {y} {z + 0.5}') + host('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0') + host('command', command='gamemode survival') + host('command', command='effect give @s minecraft:instant_health 1 5') + host.wait(4) + host('command', command=f'summon minecraft:warden {x + 0.5} {y} {z + 9.5} {{NoAI:1b,Tags:["sonic_test"]}}') + host('command', command='attribute @e[tag=sonic_test,limit=1] minecraft:knockback_resistance base set 1') + before = {side: made(g, 'sonic_boom') for side, g in (('host', host), ('guest', guest))} + health = host('status')['player']['health'] + host('command', command='data merge entity @e[tag=sonic_test,limit=1] {NoAI:0b}') + host('command', command='attribute @e[tag=sonic_test,limit=1] minecraft:movement_speed base set 0') + host('command', command='damage @e[tag=sonic_test,limit=1] 1 minecraft:player_attack by @s') + for _ in range(400): + host.wait(2) + if host('status')['player']['health'] < health: + break + host.wait(2) # let the observer process the same packet batch + seen = {side: made(g, 'sonic_boom') - before[side] for side, g in (('host', host), ('guest', guest))} + after = host('status')['player']['health'] + result['near' if near else 'far'] = {'particles': seen, 'health': [health, after]} + host.shot(out, f'sonic-{"near" if near else "far"}') + host('command', command='kill @e[tag=sonic_test]') + assert after == health - 10, result + assert seen['host'] == 15, result + assert seen['guest'] == (15 if near else 0), result + finally: + host('command', command='kill @e[tag=sonic_test]') + host('command', command='gamerule natural_health_regeneration true') + return result + + +CHECKS += ['sonic'] +CHECK_FNS['sonic'] = check_sonic + + if __name__ == '__main__': main() From cd7b6e025e49f19ea8085e8d7734079962e919fe Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Mon, 26 Oct 2026 07:49:37 +0000 Subject: [PATCH 39/70] Fix recipe book overlays surviving remote screen changes Co-Authored-By: Codex GPT-6.1 Sol --- crates/horizon-client/src/game/remote.rs | 5 +++ tools/lan_e2e.py | 47 ++++++++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..bdaa8a5f4 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4600,6 +4600,7 @@ impl Game<'_> { } KeyCode::KeyE => { // The inventory opens without telling the server. + self.recipe_ui.reset_screen(); self.screen = if self.creative { Screen::Creative } else { @@ -4838,6 +4839,7 @@ impl Game<'_> { self.remote_close_local(); } fn remote_close_local(&mut self) { + self.recipe_ui.reset_screen(); if let Some(r) = self.remote.as_mut() { r.menu = None; r.menu_title = None; @@ -4908,6 +4910,9 @@ impl Game<'_> { } /// ClientboundOpenScreenPacket for the menus Horizon draws. fn remote_open_screen(&mut self, p: play::OpenScreen) { + // A new RecipeBookComponent owns fresh ghost slots and an overlay, + // even when the server replaces a menu without a close packet. + self.recipe_ui.reset_screen(); let menu = self .remote .as_ref() diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..2eb9d9843 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -2075,6 +2075,53 @@ def check_recipes(host, guest, out): guest.raw('key', 'esc', 'tap') guest.wait(5) assert any('oak_log' in str(item) for item in grid.values()), f'nothing placed in the grid: {grid}' + # #2019: the alternatives popup belongs to one screen. Check both the + # in-frame host (or --server-thread host) and the remote guest, with both + # inventory-close keys and a different recipe-book type on reopening. + for game in (host, guest): + game('command', command='recipe give @s minecraft:oak_planks') + game('command', command='recipe give @s minecraft:birch_planks') + game.wait(10) + for close_key, reopen in (('e', 'inventory'), ('esc', 'furnace')): + game.raw('key', 'e', 'tap') + game.wait(5) + book = game('screen')['recipe_book'] + if len(book['targets']) == 1: + game.raw('click-at', *centre(book['targets'][0])) + game.wait(5) + book = game('screen')['recipe_book'] + for rect in book['targets']: + if rect[2:] != [25.0, 25.0]: + continue + game.raw('click-at', *centre(rect), 'right') + game.wait(2) + targets = game('screen')['recipe_book']['targets'] + if targets and all(r[2:] == [24.0, 24.0] for r in targets): + break + else: + raise AssertionError(f'{game.name}: no alternatives popup opened: {book}') + game.shot(out, f'recipe-overlay-{close_key}-before') + game.raw('key', close_key, 'tap') + game.wait(5) + if reopen == 'inventory': + game.raw('key', 'e', 'tap') + else: + x, y, z = (int(v // 1) for v in pos_of(game)) + game('command', command=f'setblock {x} {y} {z - 2} minecraft:furnace') + game.wait(5) + game.raw('interact', x, y, z - 2) + game.wait(5) + targets = game('screen')['recipe_book']['targets'] + if reopen == 'furnace' and len(targets) == 1 and targets[0][2:] == [20.0, 18.0]: + game.raw('click-at', *centre(targets[0])) + game.wait(5) + targets = game('screen')['recipe_book']['targets'] + game.shot(out, f'recipe-overlay-{close_key}-after') + assert any(r[2:] == [20.0, 18.0] for r in targets), f'{game.name}: stale popup: {targets}' + if reopen == 'inventory': + assert len(targets) > 1, f'{game.name}: the book forgot its open setting' + game.raw('key', 'esc', 'tap') + game.wait(5) return {'known': known, 'grid': grid} 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 40/70] 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 290e2e1ac7cb49bd9ec8a531ace9cbe1a165d092 Mon Sep 17 00:00:00 2001 From: Niraj Khetre Date: Mon, 26 Oct 2026 15:11:21 +0530 Subject: [PATCH 41/70] The ender dragon's hits and breath name it in the death message The dragon's wing and head hits and its breath clouds hurt the player without recording the dragon as the causing entity, and the dragon is not one of the mobs note_attacker looks up. death.attack.mob and death.attack.indirectMagic then got only the victim's name, so the template showed through: "%1$s was killed by %2$s using magic". Record the dragon before its damage lands (EnderDragon.hurt and knockBack use mobAttack(dragon); its breath clouds apply indirectMagic(cloud, dragon)). Fixes #2062 Assisted-by: Claude Opus 5.5 --- crates/horizon-client/src/game/combat.rs | 11 ++++++++--- crates/horizon-client/src/game/dragon.rs | 17 ++++++++++++++--- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index 227aa0332..106e0e1a1 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -52,11 +52,16 @@ impl Game<'_> { /// Remember who deals the next `damage_type` damage to the player. pub(super) fn note_attacker(&mut self, damage_type: &str, mob: u32) { if let Some(name) = self.mob_display_name(mob) { - self.combat - .pending - .push((damage_type.to_owned(), (mob, name))); + self.note_named_attacker(damage_type, mob, name); } } + /// `note_attacker` for an entity that is not one of `self.mobs` (the + /// ender dragon). + pub(super) fn note_named_attacker(&mut self, damage_type: &str, id: u32, name: Text) { + self.combat + .pending + .push((damage_type.to_owned(), (id, name))); + } /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the /// source's `DamageEffects` (`Player.getHurtSound`). pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) { diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 8c316deeb..f28049fd5 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -12,6 +12,7 @@ use horizon_client::{ hud_layout, hud_overlays, mesher::Vertex, particles::{ParticleOptions, ParticleType}, + text::Text, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -1870,7 +1871,7 @@ impl Game<'_> { pl.velocity.z += zd / dd * 4.0; } if !sitting { - g.hurt_player_by("minecraft:mob_attack", 5.0); + g.dragon_hurts_player("minecraft:mob_attack", 5.0); } }); } @@ -1879,7 +1880,7 @@ impl Game<'_> { for h in heads { if h.inflate(Vec3::new(1.0, 1.0, 1.0)).intersects(p.bounds) { self.as_fight_player(p.who, |g| { - g.hurt_player_by("minecraft:mob_attack", 10.0); + g.dragon_hurts_player("minecraft:mob_attack", 10.0); }); } } @@ -2161,10 +2162,20 @@ impl Game<'_> { self.breath_clouds.append(&mut clouds); for (who, amount) in harmed { self.as_fight_player(who, |g| { - g.hurt_player_by("minecraft:indirect_magic", amount); + g.dragon_hurts_player("minecraft:indirect_magic", amount); }); } } + /// Damage from the dragon, which is its causing entity + /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the + /// death message names it. + fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) { + if let Some(id) = self.dragon.as_ref().map(|d| d.id) { + let name = Text::translate("entity.minecraft.ender_dragon", &[]); + self.note_named_attacker(damage_type, id, name); + } + self.hurt_player_by(damage_type, amount); + } /// `BossHealthOverlay.extractRenderState`: whatever `publish_boss_bars` /// (or a server's packets) put on this client's overlay. pub(super) fn draw_boss_bars(&self, batch: &mut HudBatch) { From e3e08911ba77eea2fb561c8879f109f00fab9cd1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 10:48:58 +0100 Subject: [PATCH 42/70] parity: run lan_integration only when named and in the nightly audit The harness runs the whole lan_e2e suite: ~40 minutes on a loaded runner, and single checks flake under load (barter, riding, shulker_bullets in one run; cursor, falling in another, all passing on rerun). Selected by --changed it would run on most gameplay pull requests and on parity-main. tools/parity_hosts.json gains a named_only table that every automatic selection (--changed, --failed, the default, --flake-check) leaves out; naming the harness or --all (the nightly audit) still runs it. Co-Authored-By: Claude Opus 5.5 --- docs/parity-workflow.md | 10 +++++++--- tests/test_parity_runner.py | 5 +++++ tools/parity.py | 15 ++++++++++++++- tools/parity_hosts.json | 5 ++++- 4 files changed, 30 insertions(+), 5 deletions(-) diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index 9153949df..bbb7512df 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -123,9 +123,13 @@ callers. Run Linux games under `xvfb-run -a` when no display is available. Each process gets scratch game, launcher, XDG data and config homes; telemetry, audio and launcher self-update are disabled. -`lan_integration` and `friends_integration` register these suites with the normal -`parity.py` selection used by CI. Their traced imports and Cargo artifacts select -them when the drivers or game implementation change. LAN writes `results.json` +`lan_integration` and `friends_integration` register these suites with `parity.py`. +`friends_integration` (under a minute) is selected like any harness when the +drivers or game implementation change. `lan_integration` is the whole LAN suite +(~40 minutes on a loaded runner, and single checks flake under load), so +`tools/parity_hosts.json` lists it under `named_only`: no automatic selection +(`--changed`, `--failed`, `--flake-check`, CI, parity-main) picks it; it runs +when named and in the nightly audit (`--all`). LAN writes `results.json` with the host mode and each result beside its screenshots and logs. A skipped case is recorded explicitly and does not count as passing coverage. diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index 2d16e7179..a85f1e969 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -145,6 +145,11 @@ class ParityRunnerTests(unittest.TestCase): with mock.patch.object(parity.sys, "platform", "darwin"): self.assertEqual(parity.platform_skips(config), {"options": "libm"}) + def test_named_only_harnesses_are_listed_from_the_host_config(self): + self.assertEqual(parity.named_only({"named_only": {"lan_integration": "slow"}}), {"lan_integration": "slow"}) + self.assertEqual(parity.named_only({}), {}) + self.assertIn("lan_integration", parity.named_only(parity.host_config())) + def test_a_pass_from_another_worktree_counts_only_for_the_same_content(self): with tempfile.TemporaryDirectory() as temp: elsewhere, here, shared = Path(temp, "a"), Path(temp, "b"), Path(temp, "shared") diff --git a/tools/parity.py b/tools/parity.py index 3f18b922d..4c2cd5426 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -11,6 +11,9 @@ python3 tools/parity.py --list # what would run, without running it python3 tools/parity.py --status # last result of every harness +Harnesses in parity_hosts.json's "named_only" run only when named or with --all +(the nightly audit): no automatic selection picks them. + Each harness runs unmodified, in parallel, under a tracer that records what it read: its Python modules, Java oracle sources, other repository files, and the Rust sources of every probe it executed (from Cargo's dep-info). A harness @@ -1285,6 +1288,12 @@ def platform_skips(config): return dict(config.get("linux_only", {})) +def named_only(config): + """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default, + --flake-check): they run only when named or with --all, the nightly audit. {name: reason}""" + return dict(config.get("named_only", {})) + + def finished_run(failed): """Record that this run completed, for tools/gate.py: a crashed runner never writes it.""" STATE_DIR.mkdir(parents=True, exist_ok=True) @@ -1369,9 +1378,13 @@ def main(): for name in [name for name in chosen if base_name(name) in skips and not args.names]: print(f"skipped on {sys.platform}: {name}: {skips[base_name(name)]}", flush=True) chosen.remove(name) + manual = {} if args.names or args.all else named_only(host_config()) + for name in [name for name in chosen if base_name(name) in manual]: + print(f"not selected (runs when named, and nightly): {name}: {manual[base_name(name)]}", flush=True) + chosen.remove(name) rounds = {name: args.repeat for name in chosen} if args.repeat > 1 else {} if args.flake_check: - changed = changed_harnesses(found, records, args.flake_check) + changed = {name for name in changed_harnesses(found, records, args.flake_check) if base_name(name) not in manual} for name in sorted(changed): # A pass counts for a changed harness only if it held over enough runs. if name not in chosen and records.get(name, {}).get("rounds", 1) < args.flake_rounds: diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json index f2ba65c68..164a3ff42 100644 --- a/tools/parity_hosts.json +++ b/tools/parity_hosts.json @@ -36,5 +36,8 @@ "local_only": { "save_roundtrip": "runs the game on a virtual screen (vscreen) with a null ALSA device, or offscreen in the logged-in macOS session" }, - "linux_only": {} + "linux_only": {}, + "named_only": { + "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py" + } } From e7f41e7d13e7d4216908982a3b11c4e7f7194e8f Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 10:51:26 +0100 Subject: [PATCH 43/70] Performance preset: keep animated textures on The preset turned them off, which froze fire, water, lava and portals. Players reported fire with no animation (#2064). The option stays in Advanced Graphics for anyone who wants it off. --- crates/horizon-client/src/graphics.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index b51a586ab..b34b55288 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -444,7 +444,7 @@ pub fn apply_preset(preset: Preset, s: &mut crate::settings::Settings) { let g = &mut s.horizon; g.preset = preset; g.cave_culling = true; - g.animated_textures = preset != Preset::Performance; + g.animated_textures = true; g.chunk_updates = 0; g.upload_budget_kib = 0; g.sky = true; 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 44/70] 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 c80b3b4950363386a52fb3ddaaa9241f535f869a Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 10:58:41 +0100 Subject: [PATCH 45/70] Multiplayer: no break particles or sound when a player puts out fire The predicted break played the block's break sound (wool for fire) and its destroy particles. BaseFireBlock skips both (spawnDestroyByEntityParticles does nothing); players only hear the server's extinguish sound. --- crates/horizon-client/src/game/remote.rs | 32 ++++++++++++++---------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 07ab0c80d..87e06d586 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3813,19 +3813,25 @@ impl Game<'_> { .and_modify(|p| p.0 = sequence) .or_insert((sequence, state.0 as i32)); } - let s = self.res.facts().get(state).sounds.clone(); - let at = [ - f64::from(pos[0]) + 0.5, - f64::from(pos[1]) + 0.5, - f64::from(pos[2]) + 0.5, - ]; - self.audio.play( - &s.break_sound, - Some(at), - (s.volume + 1.0) / 2.0, - s.pitch * 0.8, - ); - self.destroy_particles(pos, state); + // Block.playerWillDestroy's destroy event (particles and the break + // sound), which BaseFireBlock skips: the server's extinguish sound + // is all a player hears. + let facts = self.res.facts().get(state); + if !self.res.items().block_in_tag("minecraft:fire", &facts.name) { + let s = facts.sounds.clone(); + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 0.5, + f64::from(pos[2]) + 0.5, + ]; + self.audio.play( + &s.break_sound, + Some(at), + (s.volume + 1.0) / 2.0, + s.pitch * 0.8, + ); + self.destroy_particles(pos, state); + } // The server's block update follows (waterlogged blocks leave water). let air = self.world.air; if self.world.set(pos[0], pos[1], pos[2], air).is_ok() { From 83f0d5bf582166a3114495eb20cf662f21078040 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:04:49 +0100 Subject: [PATCH 46/70] Worldgen data loads its three biggest parts in parallel GeneratorData::load read everything on the server thread while the chunk workers waited: the block tables, the structure templates and the block behaviours now load on threads of their own, and BlockBehavior::load reads its cached-support table beside the other two. The behaviour exports (gameplay-facts.json is 55 MB) parse from bytes in memory instead of through a reader. ThinkPad (2 cores), 3 alternated runs: 0.63 -> 0.45 s with the behaviour snapshot cached, 2.40 -> 2.07 s on a first start. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/vanillagen.rs | 2 + crates/horizon-world/src/level/data.rs | 6 +- .../horizon-world/src/worldgen/generator.rs | 112 +++++++++++------- .../src/worldgen/generator_blocks.rs | 29 +++-- 4 files changed, 94 insertions(+), 55 deletions(-) diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs index c890213c5..517b14f44 100644 --- a/crates/horizon-client/src/vanillagen.rs +++ b/crates/horizon-client/src/vanillagen.rs @@ -339,7 +339,9 @@ pub fn shared_data( if let Some((_, data)) = cache.iter().find(|(path, _)| path == dir) { return Ok(data.clone()); } + let started = std::time::Instant::now(); let data = GeneratorData::load(dir, registry)?; + log::info!("Horizon: worldgen data loaded in {:?}", started.elapsed()); cache.push((dir.to_owned(), data.clone())); Ok(data) } diff --git a/crates/horizon-world/src/level/data.rs b/crates/horizon-world/src/level/data.rs index e0ef0dca1..4635e8b05 100644 --- a/crates/horizon-world/src/level/data.rs +++ b/crates/horizon-world/src/level/data.rs @@ -16,7 +16,7 @@ use serde_json::Value; use std::{ collections::HashMap, fs::{self, File}, - io::{self, BufReader}, + io, path::Path, sync::Arc, }; @@ -582,8 +582,10 @@ fn fail(message: &str) -> io::Error { invalid(message) } +/// From the file's bytes in memory: several times faster than through a +/// reader on gameplay-facts.json (55 MB), which a first start parses. fn read_json(path: &Path) -> io::Result { - serde_json::from_reader(BufReader::new(File::open(path)?)).map_err(|e| invalid(e.to_string())) + serde_json::from_slice(&fs::read(path)?).map_err(|e| invalid(e.to_string())) } fn interned(cache: &mut HashMap>, text: &str) -> Arc { diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 316bd837c..b554da9e3 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -269,6 +269,20 @@ fn quantize_parameter_report(json: &str) -> Result { } Ok(Value::Array(entries).to_string()) } +/// `load` on a thread of its own ("Worldgen loader"). +fn loading( + load: impl FnOnce() -> T + Send + 'static, +) -> io::Result> { + std::thread::Builder::new() + .name("Worldgen loader".into()) + .spawn(load) +} +/// A loading thread's result; its panic goes on in this thread. +fn joined(thread: std::thread::JoinHandle) -> T { + thread + .join() + .unwrap_or_else(|panic| std::panic::resume_unwind(panic)) +} impl GeneratorData { /// Load a worldgen bundle directory. Required files are JSON objects mapping /// resource identifiers to the resource's JSON text: `noises`, `densities`, @@ -290,6 +304,50 @@ impl GeneratorData { let block_tags = build_tags(&read_bundle(dir, "block_tags")?, |id| { registry.default_state(id).is_some() })?; + let fluid_tags = match read_optional_bundle(dir, "fluid_tags")? { + Some(raw) => build_tags(&raw, |id| { + matches!( + id, + "minecraft:water" + | "minecraft:flowing_water" + | "minecraft:lava" + | "minecraft:flowing_lava" + | "minecraft:empty" + ) + })?, + None => BTreeMap::new(), + }; + // The three biggest reads (the block tables, the structure templates + // and the block behaviours) need only the tags: they run on threads of + // their own while this one reads the rest. A new world's first chunks + // wait for all of it, with the chunk workers idle. + let blocks = loading({ + let (dir, tags, fluids) = (dir.join("blocks"), block_tags.clone(), fluid_tags.clone()); + move || super::generator_blocks::BlockBehavior::load(&dir, registry, &tags, &fluids) + })?; + let structures = loading({ + let (dir, tags) = (dir.to_owned(), block_tags.clone()); + move || -> Result<_, GeneratorError> { + let Ok(json) = fs::read_to_string(dir.join("blocks/structure-blocks.json")) else { + return Ok(None); + }; + Ok(Some(Arc::new(super::structure::StructureResources::new( + registry, + super::structure::StateTransforms::from_json(&json, registry.len())?, + &dir.join("structure"), + read_optional_bundle(&dir, "processor_lists")?.unwrap_or_default(), + &tags, + )))) + } + })?; + let behaviours = loading({ + let root = dir.parent().map(Path::to_owned); + move || { + root.filter(|root| root.join("block-behaviours.json").exists()) + .and_then(|root| crate::level::Behaviours::load(registry, &root).ok()) + .map(Arc::new) + } + })?; let tag_set = |name: &str| -> Result, GeneratorError> { Ok(block_tags .get(name) @@ -382,47 +440,17 @@ impl GeneratorData { read_optional_bundle(dir, "features")?, read_optional_bundle(dir, "placed_features")?, ) { - (Some(features), Some(placed)) => { - let fluid_tags = match read_optional_bundle(dir, "fluid_tags")? { - Some(raw) => build_tags(&raw, |id| { - matches!( - id, - "minecraft:water" - | "minecraft:flowing_water" - | "minecraft:lava" - | "minecraft:flowing_lava" - | "minecraft:empty" - ) - })?, - None => BTreeMap::new(), - }; - Some(FeatureResources { - features, - placed, - feature_tags: read_optional_bundle(dir, "feature_tags")?.unwrap_or_default(), - blocks: super::generator_blocks::BlockBehavior::load( - &dir.join("blocks"), - registry, - &block_tags, - &fluid_tags, - )?, - fluid_tags, - state_providers: read_optional_bundle(dir, "state_providers")? - .unwrap_or_default(), - }) - } + (Some(features), Some(placed)) => Some(FeatureResources { + features, + placed, + feature_tags: read_optional_bundle(dir, "feature_tags")?.unwrap_or_default(), + blocks: joined(blocks)?, + fluid_tags, + state_providers: read_optional_bundle(dir, "state_providers")?.unwrap_or_default(), + }), _ => None, }; - let structures = match fs::read_to_string(dir.join("blocks/structure-blocks.json")) { - Ok(json) => Some(Arc::new(super::structure::StructureResources::new( - registry, - super::structure::StateTransforms::from_json(&json, registry.len())?, - &dir.join("structure"), - read_optional_bundle(dir, "processor_lists")?.unwrap_or_default(), - &block_tags, - ))), - Err(_) => None, - }; + let structures = joined(structures)?; let structure_resources = match ( read_optional_bundle(dir, "structures")?, read_optional_bundle(dir, "structure_sets")?, @@ -435,11 +463,7 @@ impl GeneratorData { }), _ => None, }; - let behaviours = dir - .parent() - .filter(|root| root.join("block-behaviours.json").exists()) - .and_then(|root| crate::level::Behaviours::load(registry, root).ok()) - .map(Arc::new); + let behaviours = joined(behaviours); Ok(Arc::new(Self { behaviours, structure_resources, diff --git a/crates/horizon-world/src/worldgen/generator_blocks.rs b/crates/horizon-world/src/worldgen/generator_blocks.rs index ed1182f36..7498b9e66 100644 --- a/crates/horizon-world/src/worldgen/generator_blocks.rs +++ b/crates/horizon-world/src/worldgen/generator_blocks.rs @@ -108,15 +108,26 @@ impl BlockBehavior { let json = |name: &str| -> Result { Ok(serde_json::from_str(&fs::read_to_string(dir.join(name))?)?) }; - let collisions = - CachedCollisionRegistry::from_table(read("cached-collision.nbt")?.table("collision")?)?; - let properties = BlockPropertiesRegistry::from_table( - read("block-properties.nbt")?.table("block property")?, - &collisions, - )?; - let support = Arc::new(BlockSupportRegistry::from_table( - read("cached-support.nbt")?.table("support")?, - )?); + // The support table reads on its own thread while the collision and + // property tables (which need the collisions) read on this one. + let (collisions, properties, support) = std::thread::scope(|scope| { + let support = scope.spawn(|| -> Result<_, GeneratorError> { + Ok(BlockSupportRegistry::from_table( + read("cached-support.nbt")?.table("support")?, + )?) + }); + let collisions = CachedCollisionRegistry::from_table( + read("cached-collision.nbt")?.table("collision")?, + )?; + let properties = BlockPropertiesRegistry::from_table( + read("block-properties.nbt")?.table("block property")?, + &collisions, + )?; + let support = support + .join() + .unwrap_or_else(|panic| std::panic::resume_unwind(panic))?; + Ok::<_, GeneratorError>((collisions, properties, Arc::new(support))) + })?; let collision = Arc::new(BlockCollisionRegistry::new(Arc::new(collisions))?); let rules = json("survival-rules.json")? .as_object() From 311c0f7392d45ebf72ed637367d14c98978a614d Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Mon, 26 Oct 2026 11:05:49 +0100 Subject: [PATCH 47/70] Stop endermen teleporting nonstop in the End The End has a fixed time and no precipitation, so endermen there must not flee daylight or take rain damage. --- crates/horizon-client/src/mobs/ai.rs | 2 +- crates/horizon-client/src/mobs/enderman.rs | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index c9bc15fda..e2043772a 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -521,7 +521,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if m.kind.flags.water_sensitive - && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez)) + && (m.fluids.in_water || w.raining && !w.end && w.can_see_sky(ex, ey, ez)) { m.damage(1.0, Damage::of(DamageKind::Drown)); } diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index fcfba832e..85967e96e 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -138,9 +138,10 @@ fn teleport_towards( let z = m.position.z + (m.random.next_double() - 0.5) * 8.0 - d[2] * 16.0; teleport_to(m, w, x, y, z, events) } -/// Enderman.customServerAiStep: in daylight, flee by teleporting. +/// Enderman.customServerAiStep: in daylight, flee by teleporting. The End has a +/// fixed time, so `Level.isBrightOutside` is never true there. pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { - if cx.w.daylight && m.age as i32 >= m.extra.counter + 600 { + if cx.w.daylight && !cx.w.end && m.age as i32 >= m.extra.counter + 600 { let br = super::hostile::mob_brightness(m, cx.w); let (x, y, z) = ( m.position.x.floor() as i32, @@ -185,6 +186,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if (m.fluids.in_water || w.raining + && !w.end && w.can_see_sky( m.position.x.floor() as i32, m.eye_y().floor() as i32, From 34d8d94022e0deaa84f27f4c6108804434f601da Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:06:02 +0100 Subject: [PATCH 48/70] parity: server harnesses wait on the server's clock and replies, not on sleeps server_knockback, locator_bar, server_dimension_players and their one-player users now end a step by the server's game clock (a sync round trip, N ticks, a last sync) the way server_player_targets does, so a server that stalls under load still gets all its ticks inside the step. server_knockback's frozen section waits for the stepped tick, the stopped clock and the landed hit; dedicated_server waits for the player's leaving before /list. Co-Authored-By: Claude Sonnet 5.5 --- .../horizonlab/parity/KnockbackClient.java | 41 ++++++- tools/test_dedicated_server_parity.py | 15 ++- tools/test_locator_bar_parity.py | 102 +++++++++++------ tools/test_server_dimension_players_parity.py | 48 ++++---- tools/test_server_knockback_parity.py | 105 ++++++++++++++---- 5 files changed, 225 insertions(+), 86 deletions(-) diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java index d8c0483b6..0c02fa9aa 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java @@ -5,9 +5,12 @@ import io.netty.buffer.Unpooled; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.io.PrintStream; import java.io.PrintWriter; import java.net.InetSocketAddress; import java.net.Socket; @@ -76,7 +79,8 @@ import net.minecraft.world.phys.Vec3; * {@code step LABEL}, {@code join NAME}, {@code cmd NAME COMMAND...} (waits * for its feedback), {@code pos NAME X Y Z YAW PITCH GROUND} (one client tick * at that place, on the ground or not), {@code sprint NAME on|off}, {@code - * attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a + * sync NAME} (a round trip through the server thread; "synced NAME" on stdout when + * it is back), {@code attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a * player's name or an entity type's path, the last one added), {@code use * NAME} (ServerboundUseItemPacket, main hand) and {@code end}. Each player * records the ClientboundSetEntityMotionPacket it receives, its own sprint @@ -88,6 +92,8 @@ public final class KnockbackClient { private static final Map NAMES = new LinkedHashMap<>(); public static void main(String[] args) throws Exception { + // Bootstrap sends System.out to the logger: `synced` lines go to the real stdout. + PrintStream stdout = new PrintStream(new FileOutputStream(FileDescriptor.out), true, StandardCharsets.UTF_8); ParityData.init(); String host = args[0]; int port = Integer.parseInt(args[1]); @@ -116,6 +122,13 @@ public final class KnockbackClient { case "attack" -> players.get(w[1]).attack(w[2]); case "use" -> players.get(w[1]).send(new ServerboundUseItemPacket(InteractionHand.MAIN_HAND, 0, 0, 0)); case "punch" -> players.get(w[1]).send(net.minecraft.network.protocol.game.ServerboundPunchPacket.INSTANCE); + case "sync" -> { + try { + players.get(w[1]).sync(); + } finally { + stdout.println("synced " + w[1]); + } + } case "mark" -> players.get(w[1]).mark(); case "await" -> players.get(w[1]).await(); case "end" -> { @@ -157,6 +170,7 @@ public final class KnockbackClient { private final Map last = new java.util.concurrent.ConcurrentHashMap<>(); private final Object replyLock = new Object(); private int replies; + private int syncs; /** The motion packets about this player it was sent, and how many there were at the last `mark`. */ private int pushes; private int marked; @@ -181,6 +195,24 @@ public final class KnockbackClient { } } + /** A round trip through the server thread, its reply left out of the transcript: every packet this player + * was sent before the reply has been recorded when it returns. */ + void sync() throws Exception { + synchronized (replyLock) { + int before = syncs; + send(new ServerboundChatCommandPacket("time query gametime")); + long until = System.nanoTime() + 30_000_000_000L; + while (syncs == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to sync"); + return; + } + replyLock.wait(left); + } + } + } + void mark() { synchronized (replyLock) { marked = pushes; @@ -327,6 +359,13 @@ public final class KnockbackClient { for (var value : d.packedItems()) { if (value.id() == 0) record("sprinting " + ((((Byte) value.value()) & 8) != 0)); } + } else if (p instanceof ClientboundSystemChatPacket c + && c.content().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t + && t.getKey().equals("commands.time.query.gametime")) { + synchronized (replyLock) { + syncs++; + replyLock.notifyAll(); + } } else if (p instanceof ClientboundSystemChatPacket c) { record("chat " + c.content().getString()); synchronized (replyLock) { diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index 49a934987..1f3870681 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -200,6 +200,17 @@ def game_time(server, timeout=300): raise AssertionError(f'{server.log_path.name}: no game time in {timeout:.0f} s') +def wait_ticks(server, count, timeout=300): + """Waits until the server's game clock has advanced `count` ticks: a server that stalls under load still gets + as many ticks as an idle one, where a sleep gives it fewer. (Not while ticking is frozen.)""" + deadline = time.time() + timeout + until = game_time(server, timeout) + count + while game_time(server, max(1.0, deadline - time.time())) < until: + if time.time() > deadline: + raise AssertionError(f'{server.log_path.name}: the game clock did not advance {count} ticks in {timeout} s') + time.sleep(0.2) + + def legacy_ping(port): """The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler).""" host = 'localhost' @@ -327,7 +338,9 @@ def run_side(label, command, directory, client): joined.join() if failure: raise failure[0] - time.sleep(1) + # The client has gone; `list` must find no one, once the server has handled its leaving (a busy machine + # took longer than a second). + server.wait_for(rf'{PLAYER} left the game', timeout=60) server.console('list') server.console('say console says hi') server.wait_for(r'\[Server\] console says hi', timeout=30) diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py index 985b87a35..6574af76e 100644 --- a/tools/test_locator_bar_parity.py +++ b/tools/test_locator_bar_parity.py @@ -23,15 +23,14 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, wait_ticks except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, wait_ticks NAME = 'locator-bar-parity' PROPERTIES = { @@ -82,7 +81,7 @@ SCRIPT = [ ('creative', [], ['cmd Bob gamemode creative', 'cmd Bob tp @s 6.5 100 0.5']), ('bob-leaves', [], ['quit Bob']), ] -STEP_SECONDS = 2.0 +STEP_TICKS = 40 # Vanilla's server moves a player who just joined on their own first ticks (a tiny step and back), which tracks # them where they spawned; Horizon does not simulate its guests. These steps compare what the bar shows at # their end (Bob has moved by then) rather than every packet. @@ -147,6 +146,47 @@ def server_dir(directory, world=None): return port +class Client: + """A LocatorBarClient process driven by a script on its stdin. A step ends by the server's clock, not the wall's: + every script line has run (`sync`), the server has ticked `ticks` more times, and each client holds what the + server sent until then (a last `sync`). A server that stalls under load still gets all its ticks in the step, + where a fixed sleep filed a stalled server's packets under the next step.""" + + def __init__(self, command, port, out, log): + self.log = log + self.process = subprocess.Popen([*map(str, command), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True) + + def tell(self, line): + self.process.stdin.write(line + '\n') + self.process.stdin.flush() + + def sync(self, names): + """Every line told so far has run for these joined players, and they have received what the server sent + before.""" + for name in names: + self.tell(f'sync {name}') + for name in names: + while (line := self.process.stdout.readline()) != f'synced {name}\n': + if not line: + raise AssertionError(f'the client exited (see {self.log.name})') + self.log.write(line) + + def wait(self, server, names, ticks): + self.sync(names) + wait_ticks(server, ticks) + self.sync(names) + + def end(self): + self.tell('end') + self.log.write(self.process.communicate(timeout=60)[0]) + + def kill(self): + if self.process.poll() is None: + self.process.kill() + + def generate_world(server_command, build): """The flat world both servers load, made once by vanilla: players appear at its spawn itself (respawn_radius 0), on the ground at 0 -60 0, and the chunks around it are saved.""" @@ -176,28 +216,26 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + client = Client(client_command, port, out, log) + joined = [] try: for step, console, actions in SCRIPT: - client.stdin.write(f'step {step}\n') - client.stdin.flush() + client.tell(f'step {step}') for command in console: server.console(command) for action in actions: - client.stdin.write(action + '\n') - client.stdin.flush() - if action.startswith('join'): + client.tell(action) + verb, *rest = action.split() + if verb == 'join': # Joining takes the world's first chunks: wait for the server to place the player. - server.wait_for(rf'{action.split()[1]} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - client.stdin.write('end\n') - client.stdin.flush() - client.wait(timeout=60) + server.wait_for(rf'{rest[0]} joined the game', timeout=120) + joined.append(rest[0]) + elif verb == 'quit': + joined.remove(rest[0]) + client.wait(server, joined, STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): @@ -234,10 +272,11 @@ def sides(name): def one_player(name, script, shown, check, scope, step_seconds=4.0): """A harness of one player, Alice: on each server she joins, then runs `script`, a list of (step, client - actions) `step_seconds` apart. The lines `shown(transcript)` keeps must match vanilla's exactly, and + actions) that each last `step_seconds` of the server's time (20 ticks a second). The lines `shown(transcript)` keeps must match vanilla's exactly, and `check(vanilla's shown lines, vanilla's transcript)` returns why vanilla's run is no proof (the script did not run), or None.""" lock, build, vanilla_server, horizon_server, client = sides(name) + ticks = round(step_seconds * 20) def run(label, server_command, world): directory = build / label @@ -248,27 +287,20 @@ def one_player(name, script, shown, check, scope, step_seconds=4.0): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - process = subprocess.Popen([*map(str, client), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, - stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, text=True) - - def tell(line): - process.stdin.write(line + '\n') - process.stdin.flush() + session = Client(client, port, out, log) try: for line in ['players on', 'state on', 'step joins', 'join Alice']: - tell(line) + session.tell(line) server.wait_for(r'Alice joined the game', timeout=120) - time.sleep(step_seconds) + session.wait(server, ['Alice'], ticks) for step, actions in script: - tell(f'step {step}') + session.tell(f'step {step}') for action in actions: - tell(action) - time.sleep(step_seconds) - tell('end') - process.wait(timeout=60) + session.tell(action) + session.wait(server, ['Alice'], ticks) + session.end() finally: - if process.poll() is None: - process.kill() + session.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py index b1efc4378..82fb2817f 100644 --- a/tools/test_server_dimension_players_parity.py +++ b/tools/test_server_dimension_players_parity.py @@ -16,17 +16,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-dimension-players-parity' NETHER, END, OVERWORLD = 'minecraft:the_nether', 'minecraft:the_end', 'minecraft:overworld' @@ -42,7 +41,8 @@ SCRIPT = [ ('bob-portal', ['cmd Bob setblock 2 101 3 minecraft:end_portal', 'cmd Bob tp @s 2.5 101 3.5']), ('bob-portal-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), ] -STEP_SECONDS = 5.0 +PLAYERS = ('Alice', 'Bob') +STEP_TICKS = 100 def run_side(label, server_command, client_command, build, world): @@ -54,38 +54,30 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: - tell('players on') - tell('step joins') - for name, x in (('Alice', 0.5), ('Bob', 2.5)): - tell(f'join {name}') + client.tell('players on') + client.tell('step joins') + for name, x in zip(PLAYERS, (0.5, 2.5)): + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - tell(f'fly {name} on') - tell(f'cmd {name} tp @s {x} 100 0.5') - time.sleep(STEP_SECONDS) + client.tell(f'fly {name} on') + client.tell(f'cmd {name} tp @s {x} 100 0.5') + client.wait(server, PLAYERS, STEP_TICKS) for step, actions in SCRIPT: - tell(f'step {step}') + client.tell(f'step {step}') for action in actions: - tell(action) + client.tell(action) # Standing still, a client still sends its position every 20 ticks # (LocalPlayer.sendPosition): the server then tracks to it what it has sent the # chunks of since (ChunkMap.move). - time.sleep(STEP_SECONDS / 2) - tell('still Alice') - tell('still Bob') - time.sleep(STEP_SECONDS / 2) - tell('end') - client.wait(timeout=60) + client.wait(server, PLAYERS, STEP_TICKS // 2) + for name in PLAYERS: + client.tell(f'still {name}') + client.wait(server, PLAYERS, STEP_TICKS // 2) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py index d7fbaeba1..66b75946e 100644 --- a/tools/test_server_knockback_parity.py +++ b/tools/test_server_knockback_parity.py @@ -18,6 +18,11 @@ players made of vanilla's protocol code, joins them both and runs one script on travelled a tick (the mob's hit, then ServerPlayer's travel, then ServerEntity.sendChanges). It is night, so that no zombie burns (a burning mob is in its hurt cooldown). +The script waits on the server, not on the wall: `ticks N` is N ticks of its game clock (with a `sync` round trip +before and after, so each client holds what the server sent), `tickstep` is one `/tick step` that has run, `frozen` +a frozen game that has stopped, and `hit` a hit that has landed (a frozen server still ticks its players, so a hit +lands in Alice's next tick). A server that stalls under load gets the same ticks as an idle one. + Each case is compared on its own. KNOWN lists the cases Horizon still gets wrong and why; one that matches again is reported, and should leave the list. """ @@ -32,15 +37,16 @@ import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from .test_locator_bar_parity import generate_world, ops_json except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from test_locator_bar_parity import generate_world, ops_json NAME = 'server-knockback-parity' +PLAYERS = ('Alice', 'Bob') PROPERTIES = { 'online-mode': 'false', 'white-list': 'false', @@ -82,18 +88,17 @@ def mob_case(kind, weapon=SWORD, sprint=False, crit=False, air=False): f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true'] lines = ['cmd Alice kill @e[type=!player]', 'cmd Alice gamemode creative', 'cmd Bob gamemode creative', f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Alice tp Bob 2.5 -60 12.5', - *stand('Alice', A, -90), 'sleep 1.2'] + *stand('Alice', A, -90), 'ticks 24'] # In the air: frozen before its first tick, so it has not landed. - lines += ['cmd Alice tick freeze', *summon] if air else [*summon, 'sleep 1.5', 'cmd Alice tick freeze'] - lines += ['sleep 0.3', f'cmd Alice data get entity {mob} Pos'] + lines += ['cmd Alice tick freeze', 'frozen', *summon] if air else [*summon, 'ticks 30', 'cmd Alice tick freeze', 'frozen'] + lines += [f'cmd Alice data get entity {mob} Pos'] if sprint: lines.append('sprint Alice on') if crit: lines += falling(0.8) - lines += ['sleep 0.2', f'attack Alice {kind}', 'sleep 0.2', f'cmd Alice data get entity {mob} Motion'] + lines += [f'hit {kind}', f'cmd Alice data get entity {mob} Motion'] for _ in range(20): - lines += ['cmd Alice tick step 1', 'sleep 0.25', f'cmd Alice data get entity {mob} Pos', - f'cmd Alice data get entity {mob} Motion'] + lines += ['tickstep', f'cmd Alice data get entity {mob} Pos', f'cmd Alice data get entity {mob} Motion'] lines += ['cmd Alice tick unfreeze', 'cmd Alice kill @e[type=!player]'] if sprint: lines.append('sprint Alice off') @@ -114,7 +119,7 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if shield: # A shield blocks from five ticks after it is raised. lines += ['cmd Bob item replace entity @s weapon.mainhand with minecraft:shield', 'use Bob'] - lines += ['sleep 1.5', *stand('Bob', V, 90, ticks=1)] + lines += ['ticks 30', *stand('Bob', V, 90, ticks=1)] if sprint: lines.append('sprint Alice on') if crit: @@ -124,10 +129,12 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if cooldown: # A swing at the air first: the hit is weak, and the stronger one four ticks later lands inside Bob's hurt # cooldown (LivingEntity.hurtServer: it hurts by the difference, with no knockback and no motion packet). - lines += ['sleep 0.2', 'punch Alice', 'attack Alice Bob'] - lines += ['sleep 0.2', 'attack Alice Bob', 'sleep 0.3'] + lines += ['ticks 4', 'punch Alice', 'attack Alice Bob'] + # The gap between those two hits is an upper bound on the server's ticks, so a stalled server (which gets + # fewer in a wall's 0.2 s) still lands the second inside the cooldown; the rest is to have the server's ticks. + lines += ['sleep 0.2' if cooldown else 'ticks 4', 'attack Alice Bob', 'ticks 6'] if twice: - lines += [*stand('Bob', V, 90, ticks=20), 'sleep 1.5', 'attack Alice Bob', 'sleep 0.3'] + lines += [*stand('Bob', V, 90, ticks=20), 'ticks 30', 'attack Alice Bob', 'ticks 6'] if sprint: lines.append('sprint Alice off') lines += stand('Alice', A, -90) @@ -144,7 +151,7 @@ def mob_hits_case(kind): hit = ['mark Bob', f'cmd Alice summon minecraft:{kind} {V[0] + 1} {V[1]} {V[2]} {{Rotation:[90f,0f]}}', f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true', 'await Bob', f'cmd Alice kill {mob}'] return ['cmd Bob clear @s', 'cmd Bob effect give @s minecraft:resistance 1000 4 true', 'cmd Alice gamemode creative', - *stand('Bob', V, 90), *hit, 'sleep 2', *stand('Bob', V, 90), *hit, 'sleep 1', + *stand('Bob', V, 90), *hit, 'ticks 40', *stand('Bob', V, 90), *hit, 'ticks 20', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamemode survival'] @@ -173,7 +180,20 @@ CASES = { } SETUP = ['cmd Alice gamerule spawn_mobs false', 'cmd Alice gamerule spawn_monsters false', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamerule advance_time false', 'cmd Alice time set midnight', - f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'sleep 2'] + f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'ticks 40'] + + +def server_data(server, selector, path, timeout=120): + """An entity's data, asked from the console (its reply stays in the server's log, out of the clients').""" + deadline = time.time() + timeout + start = len(server.lines) + server.console(f'data get entity {selector} {path}') + while time.time() < deadline: + for line in server.lines[start:]: + if 'has the following entity data' in line: + return line.split('data: ', 1)[-1] + time.sleep(0.02) + raise AssertionError(f'{server.log_path.name}: no entity data in {timeout} s') def server_dir(directory, world): @@ -201,29 +221,72 @@ def run_side(label, server_command, client_command, build, world): server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) + + def sync(): + """Every script line sent so far has run, and each client holds what its server sent before.""" + for name in PLAYERS: + client.stdin.write(f'sync {name}\n') + client.stdin.flush() + for name in PLAYERS: + while (reply := client.stdout.readline()) != f'synced {name}\n': + if not reply: + raise AssertionError(f'{label}: the client exited (see {build}/{label}-client.log)') + log.write(reply) def send(line): - if line.startswith('sleep '): + """A script line for the client, or one of ours: the waits are on the server's game clock, not the + wall's, so a server that stalls under load still gets the ticks each case needs.""" + word = line.split()[0] + if word == 'sleep': time.sleep(float(line.split()[1])) + elif word == 'ticks': + sync() + wait_ticks(server, int(line.split()[1])) + sync() + elif word == 'frozen': + # The tick in flight when ticking was frozen has finished: the clock reads the same twice. + sync() + while game_time(server) != game_time(server): + pass + elif word == 'hit': + # Alice hits the mob. A frozen server still ticks its players, and the hit lands in Alice's + # next tick, not when the packet arrives: the mob's motion says when it has. + sync() + mob = f'@e[type=minecraft:{line.split()[1]},limit=1]' + before = server_data(server, mob, 'Motion') + client.stdin.write(f'attack Alice {line.split()[1]}\n') + client.stdin.flush() + while server_data(server, mob, 'Motion') == before: + time.sleep(0.05) + sync() + elif word == 'tickstep': + # `/tick step 1` answers at once and the tick runs after: the clock says when it has. + sync() + before = game_time(server) + client.stdin.write('cmd Alice tick step 1\n') + client.stdin.flush() + while game_time(server) == before: + time.sleep(0.05) + sync() else: client.stdin.write(line + '\n') client.stdin.flush() try: - for name in ('Alice', 'Bob'): + for name in PLAYERS: send(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(2) + wait_ticks(server, 40) for line in SETUP: send(line) for case, lines in CASES.items(): send(f'step {case}') for line in lines: send(line) - time.sleep(0.5) + send('ticks 10') send('end') - client.wait(timeout=60) + log.write(client.communicate(timeout=60)[0]) finally: if client.poll() is None: client.kill() 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 49/70] 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 6b8fde092ff6bc41b0b5fd84fff03498161fcc8c Mon Sep 17 00:00:00 2001 From: socksprox Date: Mon, 26 Oct 2026 11:20:21 +0100 Subject: [PATCH 50/70] Keep 26.3's name-tag and text-display values Review caught three regressions against the pinned client jar: submitInner lines stay lineHeight+1 (10 px), submitNameTag fades discrete and see-through names with the same 0x7F, and lightCoordsWithEmission floors both light channels at 2. Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- crates/horizon-client/src/game/names.rs | 22 +++++-------------- .../horizon-client/src/game/text_displays.rs | 4 ++-- 2 files changed, 8 insertions(+), 18 deletions(-) diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs index d62e064f7..f49550f77 100644 --- a/crates/horizon-client/src/game/names.rs +++ b/crates/horizon-client/src/game/names.rs @@ -252,27 +252,17 @@ impl Game<'_> { out: &mut Vec, see_through: &mut Vec, ) { - // renderNameTag's text colours: a discrete name's faded 0x20FFFFFF, - // the see-through copy's 0x80FFFFFF. - const DISCRETE: u32 = 0x20; - const FADED: u32 = 0x80; + // The text alpha that goes with getBackgroundOpacity(0.25): + // max((0.25 + 0.75) / 2, 0.5), as ARGB.color (the floor of 255 times it). + const FADED: u32 = 0x7F; for tag in self.name_tags(camera, alpha) { let o = tag.at - camera; if tag.discrete { - self.name_tag_quads( - o, - &tag.lines, - DISCRETE, - true, - 0, - vertex_light(tag.light), - out, - ); + self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out); continue; } - // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2): the block - // channel at least 2, the sky channel unchanged. - let lit = (tag.light & 0xF0) | (tag.light & 15).max(2); + // LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2). + let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2); self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out); // RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap. self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through); diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index 45191e15e..b669c8357 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -198,7 +198,7 @@ impl Game<'_> { Lines { lines, width } }); let width = *width; - let height = lines.len() as f32 * 9.0 - 1.0; + let height = lines.len() as f32 * 10.0 - 1.0; matrix *= glam::Mat4::from_translation(glam::Vec3::new(1.0 - width / 2.0, -height, 0.0)); let mut batch = HudBatch::new([1, 1]); @@ -233,7 +233,7 @@ impl Game<'_> { atlas, line, x, - i as f32 * 9.0, + i as f32 * 10.0, rgba(255, 255, 255, d.opacity as u8), d.flags & 1 != 0, ); 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 51/70] 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 c8132615742b62170412feae5aab463ca46f7168 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:35:15 +0100 Subject: [PATCH 52/70] Horizon shader packs: the material stage runs in the game A pack's `fn material(input: MaterialInput) -> Surface` now gives the lit colour of every terrain surface: sections and distant tiles, solid, cutout and translucent, in both the instanced and the flat draws. Terrain keeps Horizon's meshes, culling and draw lists; only its pipelines change. Their shader is the pack's stage, a prefixed copy of terrain.wgsl's terrain section, and entries that hand the pack the texture, the vertex tint, the light levels and the lightmap's colour apart, then apply the alpha test and fog as `fs_solid` and `fs_translucent` do. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 56 ++- .../horizon-client/src/gfx/native_material.rs | 328 ++++++++++++++++++ crates/horizon-client/src/gfx/native_pack.rs | 24 +- docs/api/shaders.md | 5 +- docs/shaders.md | 15 +- 5 files changed, 397 insertions(+), 31 deletions(-) create mode 100644 crates/horizon-client/src/gfx/native_material.rs diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 5ff14003c..6270135c5 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -67,6 +67,7 @@ mod end_sky; mod flat; pub mod lightning; mod lod; +mod native_material; mod native_pack; mod native_post; mod native_sky; @@ -429,6 +430,8 @@ pub struct Renderer { /// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`. mipmaps: u32, terrain_layout: wgpu::BindGroupLayout, + /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`, for a shader pack's terrain. + terrain_sprites: [f64; 2], sprite_sampler: wgpu::Sampler, lightmap_view: wgpu::TextureView, lightmap_sampler: wgpu::Sampler, @@ -2370,6 +2373,7 @@ impl Renderer { mip_levels, mipmaps: mip_levels - 1, terrain_layout: bindings, + terrain_sprites: sprite_constants.map(|(_, v)| v), sprite_sampler, lightmap_view, lightmap_sampler, @@ -2937,9 +2941,9 @@ impl Renderer { self.native = None; self.pack_atlas = None; } - /// Runs the sky and post stages of one of Horizon's own shader packs from now on (`None`: - /// no pack), with its options' values; replaces a `shaders/` pack. Returns the stages' - /// labels; on an error the pack that ran keeps running. + /// Runs the sky, material and post stages of one of Horizon's own shader packs from now + /// on (`None`: no pack), with its options' values; replaces a `shaders/` pack. Returns the + /// stages' labels; on an error the pack that ran keeps running. pub fn set_native_shader_pack( &mut self, pack: Option<(horizon_shader_api::Report, Vec<(String, f64)>)>, @@ -2948,14 +2952,14 @@ impl Renderer { self.native = None; return Ok(Vec::new()); }; - let format = self.config.format.remove_srgb_suffix(); - let (pack, labels) = native_pack::NativePack::new( - &self.device, - &self.terrain_layout, - report, - &constants, - format, - )?; + let terrain = native_material::TerrainShape { + globals: &self.terrain_layout, + flat: self.flat.as_ref().map(|f| &f.draw_layout), + sprites: self.terrain_sprites, + format: self.config.format.remove_srgb_suffix(), + }; + let (pack, labels) = + native_pack::NativePack::new(&self.device, &terrain, report, &constants)?; self.native = pack.draws().then_some(pack); if self.native.is_some() { self.pack_post = None; @@ -4179,6 +4183,21 @@ impl Renderer { pass.set_bind_group(0, &self.group, &[]); sky.draw(&mut pass, &native.frame); } + // One of Horizon's own packs with a material stage: terrain draws with its pipelines, + // which read the pack's frame at group 3. + let material = self + .native + .as_ref() + .filter(|_| !frame.title) + .and_then(|n| Some((n.material.as_ref()?, &n.frame.group))); + let solid_pipeline = material.map_or(&self.solid, |(m, _)| &m.solid); + let translucent_pipeline = material.map_or(&self.translucent, |(m, _)| &m.translucent); + let pack_flat = material.and_then(|(m, _)| m.flat.as_ref()); + let pack_frame = |pass: &mut wgpu::RenderPass<'_>| { + if let Some((_, group)) = material { + pass.set_bind_group(horizon_shader_api::stages::GROUP, group, &[]); + } + }; { let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, @@ -4212,6 +4231,7 @@ impl Renderer { ..Default::default() }); pass.set_bind_group(0, &self.group, &[]); + pack_frame(&mut pass); if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) { if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass { match self @@ -4260,7 +4280,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } Some(flat) => { - pass.set_pipeline(&flat.solid); + pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0)); let vertices = |p| self.arena.buffer(p); match cull { // As below: phase 1, the test, then phase 2's draws @@ -4278,7 +4298,8 @@ impl Renderer { pack_reads_world, ); pass.set_bind_group(0, &self.group, &[]); - pass.set_pipeline(&flat.solid); + pack_frame(&mut pass); + pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0)); flat.draw_phase2(&mut pass, vertices); } None => flat.draw(&mut pass, &flat.calls[..flat.solid_calls], vertices), @@ -4287,7 +4308,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } None => { - pass.set_pipeline(&self.solid); + pass.set_pipeline(solid_pipeline); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); pass.set_vertex_buffer(1, self.instances.slice(..)); match cull { @@ -4307,7 +4328,8 @@ impl Renderer { pack_reads_world, ); pass.set_bind_group(0, &self.group, &[]); - pass.set_pipeline(&self.solid); + pack_frame(&mut pass); + pass.set_pipeline(solid_pipeline); pass.set_index_buffer( self.indices.slice(..), wgpu::IndexFormat::Uint32, @@ -4399,7 +4421,7 @@ impl Renderer { // The pack draws translucent terrain after its deferred programs. _ if pack_draws_water => {} Some(flat) => { - pass.set_pipeline(&flat.translucent); + pass.set_pipeline(pack_flat.map_or(&flat.translucent, |p| &p.1)); flat.draw(&mut pass, flat.translucent_calls(), |p| { self.arena.buffer(p) }); @@ -4407,7 +4429,7 @@ impl Renderer { pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); } None => { - pass.set_pipeline(&self.translucent); + pass.set_pipeline(translucent_pipeline); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); pass.set_vertex_buffer(1, self.instances.slice(..)); self.draw_sections( diff --git a/crates/horizon-client/src/gfx/native_material.rs b/crates/horizon-client/src/gfx/native_material.rs new file mode 100644 index 000000000..8e54caf12 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_material.rs @@ -0,0 +1,328 @@ +//! The material stage of Horizon's own shader packs (docs/shaders.md): the pack's `material` +//! function gives the lit colour of each point of a block's surface, before the alpha test and +//! fog. Terrain still draws with Horizon's meshes, culling and draw lists; only its pipelines +//! change. Their shader is the pack's stage (`CheckedStage::source`), then a copy of +//! terrain.wgsl's terrain section whose names all take a `horizon_terrain_` prefix +//! (`wgsl_prefix.rs`), then entries that hand the pack what vanilla's `fs_solid` and +//! `fs_translucent` combine: the texture, the vertex tint, the light levels and the lightmap's +//! colour. They read the terrain's group 0, the flat draws' group 1 where those run, and the +//! pack's frame at group 3. + +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_terrain_"; + +/// The entries around the pack's `material`: vanilla's vertex work without the lightmap +/// product, then the material, the alpha test and fog as `fs_solid` and `fs_translucent` do. +const ENTRIES: &str = " +struct HorizonMaterialOut { + @builtin(position) clip: vec4, + @location(0) uv: vec2, + @location(1) @interpolate(flat) layer: u32, + @location(2) tint: vec4, + @location(3) light: vec2, + @location(4) lightmap: vec3, + @location(5) position: vec3, + @location(6) spherical: f32, + @location(7) cylindrical: f32, +} +fn horizon_material_vertex(position: vec3, uv: vec2, layer: u32, color: vec4, + light: vec2, origin: vec3) -> HorizonMaterialOut { + let pos = position + origin; + var out: HorizonMaterialOut; + out.clip = horizon_terrain_globals.view_proj * vec4(pos, 1.0); + out.uv = uv; + out.layer = layer; + out.tint = color; + let block = max(f32(light.y), horizon_terrain_dynamic_block_light(pos)); + let sky = f32(light.x); + // 16 per level, 15 levels. + out.light = min(vec2(block, sky) / 240.0, vec2(1.0)); + out.lightmap = horizon_terrain_sample_lightmap(sky / 16.0, block / 16.0).rgb; + out.position = pos; + out.spherical = length(pos); + out.cylindrical = max(length(pos.xz), abs(pos.y)); + return out; +} +@vertex fn horizon_material_vs( + @location(0) position: vec3, @location(1) uv: vec2, + @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2, + @location(5) origin: vec4) -> HorizonMaterialOut { + return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer, + color, light, origin.xyz); +} +@vertex fn horizon_material_vs_flat( + @builtin(vertex_index) vertex: u32, + @location(0) position: vec3, @location(1) uv: vec2, + @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2 +) -> HorizonMaterialOut { + let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[vertex >> 8u]]; + return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer, + color, light, origin.xyz); +} +fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4 { + let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu); + return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv, + translucent)).color; +} +@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4 { + let color = horizon_material_color(in, false); + // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout. + if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; } + return horizon_terrain_apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical); +} +@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4 { + let color = horizon_material_color(in, true); + if color.a < 0.01 { discard; } + return horizon_terrain_apply_fog(color, in.spherical, in.cylindrical); +} +"; + +/// What terrain pipelines are built against: the renderer's layouts and constants. +pub struct TerrainShape<'a> { + /// The terrain's group 0. + pub globals: &'a wgpu::BindGroupLayout, + /// The flat draws' group 1, where they run (`flat.rs`). + pub flat: Option<&'a wgpu::BindGroupLayout>, + /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`. + pub sprites: [f64; 2], + /// The world target's colour format. + pub format: wgpu::TextureFormat, +} + +/// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the +/// renderer's instanced draws and, where they run, its flat ones. +pub struct NativeMaterial { + pub solid: wgpu::RenderPipeline, + pub translucent: wgpu::RenderPipeline, + pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>, +} + +/// terrain.wgsl's terrain section (its globals, bindings, sampling, lighting and fog), with +/// every name it declares prefixed. +fn vanilla_terrain() -> String { + prefixed( + section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"), + PREFIX, + ) +} + +/// The terrain shader for the pack's material stage `source`. +fn shader_source(source: &str) -> String { + format!( + "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{ENTRIES}", + vanilla_terrain() + ) +} + +/// The material's naga module, its errors in the stage's file. +fn module(stage: &CheckedStage) -> Result { + let text = shader_source(&stage.source); + naga::front::wgsl::parse_str(&text) + .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text))) +} + +impl NativeMaterial { + /// The pipelines of the pack's material `stage` with the option values `constants`. + pub fn new( + device: &wgpu::Device, + shape: &TerrainShape<'_>, + frame: &NativeFrame, + stage: &CheckedStage, + constants: &[(String, f64)], + ) -> Result { + let module = module(stage)?; + let mut constants = present_constants(&module, constants); + let sprite_names = [ + "horizon_terrain_SPRITE_ARRAYS", + "horizon_terrain_SPRITE_SPLIT", + ]; + constants.extend(sprite_names.into_iter().zip(shape.sprites)); + let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(&stage.label), + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + let layout = |flat: Option<&wgpu::BindGroupLayout>| { + let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = + Default::default(); + groups[0] = Some(shape.globals); + groups[1] = flat; + groups[GROUP as usize] = Some(&frame.layout); + device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Native shader pack terrain"), + bind_group_layouts: &groups, + ..Default::default() + }) + }; + let instance_attributes = wgpu::vertex_attr_array![5=>Float32x4]; + let vertices = wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &super::TERRAIN_ATTRIBUTES, + }; + let instances = wgpu::VertexBufferLayout { + array_stride: 16, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &instance_attributes, + }; + // As the renderer's terrain pipelines (gfx.rs): back faces culled, reversed depth. + let pipeline = |layout: &wgpu::PipelineLayout, + vertex: &str, + buffers: &[Option>], + fragment: &str, + blend: Option| { + let options = wgpu::PipelineCompilationOptions { + constants: &constants, + ..Default::default() + }; + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some(&stage.label), + layout: Some(layout), + vertex: wgpu::VertexState { + module: &module, + entry_point: Some(vertex), + compilation_options: options.clone(), + buffers, + }, + primitive: wgpu::PrimitiveState { + cull_mode: Some(wgpu::Face::Back), + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &module, + entry_point: Some(fragment), + compilation_options: options, + targets: &[Some(wgpu::ColorTargetState { + format: shape.format, + blend, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }; + let blend = Some(wgpu::BlendState::ALPHA_BLENDING); + let instanced = layout(None); + let buffers = [Some(vertices.clone()), Some(instances)]; + let solid = pipeline( + &instanced, + "horizon_material_vs", + &buffers, + "horizon_material_fs_solid", + None, + ); + let translucent = pipeline( + &instanced, + "horizon_material_vs", + &buffers, + "horizon_material_fs_translucent", + blend, + ); + let flat = shape.flat.map(|group| { + let layout = layout(Some(group)); + let buffers = [Some(vertices.clone())]; + let vs = "horizon_material_vs_flat"; + ( + pipeline(&layout, vs, &buffers, "horizon_material_fs_solid", None), + pipeline( + &layout, + vs, + &buffers, + "horizon_material_fs_translucent", + blend, + ), + ) + }); + if let Some(e) = pollster::block_on(scope.pop()) { + return Err(format!("{}: {e}", stage.file)); + } + Ok(Self { + solid, + translucent, + flat, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_shader_api::{MANIFEST, Pack, StageKind, check}; + + fn stage(material: &str) -> CheckedStage { + let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\ + [material]\nfile = \"material.wgsl\"\n\ + [[options]]\nid = \"gain\"\nname = \"Gain\"\ntype = \"float\"\n\ + default = 1.0\nmin = 0.0\nmax = 2.0\n"; + let files = [(MANIFEST, manifest), ("material.wgsl", material)] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + let mut report = check(&Pack::from_files(files).unwrap()).unwrap(); + assert_eq!(report.stages[0].kind, StageKind::Material); + report.stages.remove(0) + } + + #[test] + fn the_terrain_takes_a_prefix_and_validates_with_a_pack() { + let terrain = vanilla_terrain(); + for name in [ + "Globals", + "globals", + "sprites_7", + "sprite", + "SPRITE_SPLIT", + "block_slots", + "sample_lightmap", + "apply_fog", + ] { + assert!(terrain.contains(&format!("{PREFIX}{name}")), "{name}"); + } + assert!(!terrain.contains("fs_sky"), "the sky stays out"); + // A pack may use any name Horizon's terrain uses unprefixed. + let own = "override gain: f32;\nconst PI: f32 = 3.0;\n\ + fn sprite(c: vec4) -> vec4 { return c * PI; }\n\ + fn apply_fog(c: vec4) -> vec4 { return c * gain; }\n\ + fn material(input: MaterialInput) -> Surface {\n \ + let lit = input.albedo * input.tint * vec4(input.lightmap, 1.0);\n \ + return Surface(apply_fog(sprite(lit)));\n}\n"; + let stage = stage(own); + let module = module(&stage).unwrap(); + let info = naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::all(), + ) + .validate(&module) + .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source)))); + let entries: Vec<&str> = module + .entry_points + .iter() + .map(|e| e.name.as_str()) + .collect(); + for entry in [ + "horizon_material_vs", + "horizon_material_vs_flat", + "horizon_material_fs_solid", + "horizon_material_fs_translucent", + ] { + assert!(entries.contains(&entry), "{entry}"); + } + drop(info); + assert_eq!( + present_constants(&module, &[("gain".into(), 1.5), ("other".into(), 1.0)]), + [("gain", 1.5)] + ); + } +} diff --git a/crates/horizon-client/src/gfx/native_pack.rs b/crates/horizon-client/src/gfx/native_pack.rs index 3f9206e11..4fb5cdc59 100644 --- a/crates/horizon-client/src/gfx/native_pack.rs +++ b/crates/horizon-client/src/gfx/native_pack.rs @@ -1,8 +1,9 @@ //! One of Horizon's own shader packs while it runs (docs/shaders.md): the frame its stages -//! read, its sky and post stages, and the timer of their passes. +//! read, its sky, material and post stages, and the timer of their passes. use horizon_shader_api::{Report, StageKind}; +use super::native_material::{NativeMaterial, TerrainShape}; use super::native_post::{NativeFrame, NativePost}; use super::native_sky::NativeSky; use super::pack_timing::PassTiming; @@ -10,6 +11,7 @@ use super::pack_timing::PassTiming; pub struct NativePack { pub frame: NativeFrame, pub sky: Option, + pub material: Option, pub post: Option, /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). pub timing: Option, @@ -17,16 +19,16 @@ pub struct NativePack { impl NativePack { /// The pack of the checked stages `report` with the option values `constants`, drawing - /// onto targets of `format`; `globals` is the terrain's group 0, which the sky reads. + /// onto the world's targets as `terrain` describes; the sky reads the terrain's group 0. /// Also returns its stages' labels, in the order they draw. Errors name the stage wgpu /// refused. pub fn new( device: &wgpu::Device, - globals: &wgpu::BindGroupLayout, + terrain: &TerrainShape<'_>, report: Report, constants: &[(String, f64)], - format: wgpu::TextureFormat, ) -> Result<(Self, Vec), String> { + let (globals, format) = (terrain.globals, terrain.format); let frame = NativeFrame::new(device); let (post, others): (Vec<_>, Vec<_>) = report .stages @@ -37,16 +39,28 @@ impl NativePack { .find(|s| s.kind == StageKind::Sky) .map(|stage| NativeSky::new(device, globals, &frame, stage, constants, format)) .transpose()?; + let material = others + .iter() + .find(|s| s.kind == StageKind::Material) + .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants)) + .transpose()?; let post = (!post.is_empty()) .then(|| NativePost::new(device, post, constants, format, &frame)) .transpose()?; let mut labels: Vec = sky.iter().map(|s| s.label.clone()).collect(); + labels.extend( + others + .iter() + .filter(|s| material.is_some() && s.kind == StageKind::Material) + .map(|s| s.label.clone()), + ); if let Some(post) = &post { labels.extend(post.labels().into_iter().map(str::to_owned)); } let pack = Self { frame, sky, + material, post, timing: None, }; @@ -55,6 +69,6 @@ impl NativePack { /// Whether the pack draws anything the game runs today. pub fn draws(&self) -> bool { - self.sky.is_some() || self.post.is_some() + self.sky.is_some() || self.material.is_some() || self.post.is_some() } } diff --git a/docs/api/shaders.md b/docs/api/shaders.md index 7461332e4..faf662b0e 100644 --- a/docs/api/shaders.md +++ b/docs/api/shaders.md @@ -91,11 +91,12 @@ pack exist ([stability.md](stability.md)). ## Not there yet -The material stage in the game (the sky and post stages run, with hot reload), option values other than the defaults, -then the overlay, lighting and shadow stages. +Option values other than the defaults (the three stages run, with hot reload), then the overlay, lighting and shadow +stages. ## Changelog +- 2026-10-26: the material stage in the game: terrain's surfaces through the pack's `material`. - 2026-10-26: the sky stage in the game: the pack's `sky` gets vanilla's colour along each ray. - 2026-10-26: the post stage in the game (`HORIZON_SHADER_PACK`, hot reload with the last good pack kept). - 2026-10-25: `horizon-shader` (`new`, `check`, `pack`), three templates, the example pack and the guide. diff --git a/docs/shaders.md b/docs/shaders.md index fec45b078..127105610 100644 --- a/docs/shaders.md +++ b/docs/shaders.md @@ -13,8 +13,8 @@ Horizon's own format. | Authoring tool | `horizon-shader` (same crate) | `new`, `check`, `pack` | | Templates | `crates/horizon-shader-api/templates/` | post, sky, material | | Example pack | `crates/horizon-shader-api/packs/golden_hour` | a warm sky and two post passes | -| In the game: the sky and post stages | Options > Horizon Settings > Shader Packs | sky, post passes, hot reload | -| In the game: the material stage; the launcher and the registry | | not yet | +| In the game: every stage | Options > Horizon Settings > Shader Packs | sky, material, post passes, hot reload | +| The launcher and the registry | | not yet | ## Quick start @@ -52,8 +52,7 @@ it on Options > Horizon Settings > Shader Packs, which lists Horizon's packs, ma name>` runs a pack whatever the page says, for development. The game checks the pack first, and refuses one that fails, with its problems in the chat. While it runs, the game looks at the pack twice a second: save a file and the pack is checked and rebuilt in place ("Shader pack ... reloaded"); if the new version fails, the chat says -where and the last good version keeps drawing. The sky and post stages run today; the material stage is checked but -not drawn yet. +where and the last good version keeps drawing. All three stages run. ## A pack @@ -89,7 +88,7 @@ by Horizon: a pack changes how things look, not how they are drawn. | Stage | Your function | What it does | | --- | --- | --- | | `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray, opaque (alpha is ignored), drawn where vanilla draws its sky dome (the Overworld's sky; not the Nether's or the End's); the sun, moon, stars and clouds are drawn over it | -| `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog | +| `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog: every terrain section and distant tile, solid, cutout and translucent (not entities, block entities or particles) | | `[[post]]` | `fn post(input: PostInput) -> vec4` | a full-screen pass over the world's picture (up to 8, in order), under the hand and HUD | A pack has at least one stage; a stage it leaves out keeps vanilla's look. Each input says what vanilla would draw @@ -132,8 +131,10 @@ one keeps drawing), the launcher before it installs one, and the registry's CI b `[budget] gpu_ms` is the GPU time your pack aims to add to a frame. To compare, open F3 in the game: while it is open, each pass is timed on the GPU and the overlay shows the pack's total and its costliest passes, by their `name` (the median of the last 15 timed frames). Timing waits for nothing, so it does not slow the game. In a timed frame the sky -stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. +stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. The +material stage runs inside terrain's own draws, so it has no time of its own: compare the frame's GPU time with and +without the pack. ## Next -The material stage in the game, and the registry's `shader` kind with installs from the launcher. +The registry's `shader` kind with installs from the launcher, then the overlay, lighting and shadow stages. From 2918f3181182d92165a73035c0564486992a9b41 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:36:50 +0100 Subject: [PATCH 53/70] Poses::reset clears the scratch pose too A missing part's writes land in `dummy`; a fresh Poses started it at zero, so a reused one must too. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mobs/anim.rs | 1 + crates/horizon-client/src/mobs/render.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index 81faa3a02..3e7ca0339 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -127,6 +127,7 @@ impl Poses { } } self.map.clear(); + self.dummy = [0.0; 9]; self.skipped.clear(); self.hidden.clear(); walk(model, &mut self.map); diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 5c01f3f2f..6c780823d 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -1089,8 +1089,8 @@ fn render_visible( } } } - // One Poses for every layer: a humanoid with armour redraws five to seven - // models, and each used to allocate its own maps. + // One Poses refilled for every layer (armour draws up to seven): it keeps + // its maps' capacity. let mut layer_poses = Poses::default(); for layer in all_layers { let Some(part) = m.kind.layer(&layer.model).cloned() else { From bde76794eed1b4902a4d13039395a848d819634c Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:37:30 +0100 Subject: [PATCH 54/70] Mobs: no rain or thunder outside the overworld Level.canHaveWeather is false in the Nether and the End, so their rain and thunder levels stay at 0. Set that once in the mob world instead of checking the End at two of the rain sites: bees, dolphins, wolves and happy ghasts read the same flag. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/creatures.rs | 7 +++++-- crates/horizon-client/src/mobs/ai.rs | 2 +- crates/horizon-client/src/mobs/enderman.rs | 1 - 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..a4be9e484 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -388,6 +388,9 @@ impl Game<'_> { } pub(super) fn mob_world_base<'s>(&'s self, others: &'s [Seen]) -> MobWorld<'s> { let (rain, thunder) = self.world.weather.levels(1.0); + // Level.canHaveWeather: only the overworld's rain and thunder levels + // ever rise, so nothing rains or thunders in the Nether or the End. + let weather = self.dim == Dim::Overworld; let player = self.player_view(); MobWorld { world: &self.world, @@ -404,8 +407,8 @@ impl Game<'_> { daylight: self.dim != Dim::Nether && self.sky_darken() < 4, game_time: self.world.game_time, day_time: self.world.day_time, - raining: rain > 0.2, - thundering: thunder > 0.9, + raining: weather && rain > 0.2, + thundering: weather && thunder > 0.9, nether: self.dim == Dim::Nether, block_tags: &self.res.items().block_tags, biomes: self.res.biomes(), diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index e2043772a..c9bc15fda 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -521,7 +521,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if m.kind.flags.water_sensitive - && (m.fluids.in_water || w.raining && !w.end && w.can_see_sky(ex, ey, ez)) + && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez)) { m.damage(1.0, Damage::of(DamageKind::Drown)); } diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index 85967e96e..c5ed01680 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -186,7 +186,6 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } if (m.fluids.in_water || w.raining - && !w.end && w.can_see_sky( m.position.x.floor() as i32, m.eye_y().floor() as i32, From fb74b6038f026f5b09ddf1a85b2c64fe636648f9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:38:17 +0100 Subject: [PATCH 55/70] Chat: system and player lines share the window's chat code Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chat_tests.rs | 3 ++- crates/horizon-client/src/game/chat.rs | 31 ++++++++----------------- 2 files changed, 12 insertions(+), 22 deletions(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index fa065766c..071cd8839 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -439,7 +439,8 @@ fn the_chat_option_filters_the_lines_both_ways() { /// The in-frame LAN host's chat: a guest's line is a player message, so the /// Chat option's player-message permission hides it at Commands Only and -/// Hidden; command feedback (`/say`, `/me`) is a system message and stays. +/// Hidden; command feedback (`/list`, `/tp`) is a system message and stays +/// at Commands Only. #[test] fn a_guests_line_follows_the_player_message_permission() { let font = font(); diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index be2a318a0..de5bbf116 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -464,22 +464,7 @@ impl Game<'_> { return; } // The Chat option's Hidden level takes the server's messages too. - if !self.ui.chat.shows(ChatSource::Server) { - return; - } - let focused = self.screen == Screen::Chat; - let heard = self.mods.running().then(|| text.plain()); - self.ui.chat.add( - &self.gui.atlas, - text, - Some(SYSTEM_INDICATOR), - ChatSource::Server, - self.ticks, - focused, - ); - if let Some(line) = heard { - self.mods_chat(&line); - } + self.local_chat_line(text, Some(SYSTEM_INDICATOR), ChatSource::Server); } /// A player's chat line on the window's own chat: a LAN guest's message /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener` @@ -493,10 +478,14 @@ impl Game<'_> { } // A server's client receives the line as a packet (PlayerChat or // DisguisedChat) and filters it there. - if self.remote.is_some() { - return; + if self.remote.is_none() { + self.local_chat_line(text, None, ChatSource::Player); } - if !self.ui.chat.shows(ChatSource::Player) { + } + /// A line on the window's own chat when the Chat option lets `source` + /// through; running mods hear it. + fn local_chat_line(&mut self, text: Text, indicator: Option, source: ChatSource) { + if !self.ui.chat.shows(source) { return; } let focused = self.screen == Screen::Chat; @@ -504,8 +493,8 @@ impl Game<'_> { self.ui.chat.add( &self.gui.atlas, text, - None, - ChatSource::Player, + indicator, + source, self.ticks, focused, ); From f19390bae1a1d5461e117e3b3c0bb6752dcf7d20 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:39:07 +0100 Subject: [PATCH 56/70] Sonic boom: take the LAN host in the same let-else as the particle Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/lan_particles.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index f92e8cf61..719fe79ab 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -28,7 +28,7 @@ impl Game<'_> { /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point. /// Keep the local event's rendering; connected players receive one at rest. pub(super) fn lan_sonic_boom(&self, options: &ParticleOptions, at: [f64; 3]) { - let Some(particle) = self.network_particle(options, None) else { + let (Some(host), Some(particle)) = (&self.lan, self.network_particle(options, None)) else { return; }; let packet = C::LevelParticles(play::LevelParticles { @@ -41,7 +41,6 @@ impl Game<'_> { count: 0, randomization: 0, }); - let host = self.lan.as_ref().unwrap(); for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { // ServerLevel compares the player's block centre, strictly within 32. let distance: f64 = (0..3) From cdbe1edcdab34fbe874538872d6122fe6378b00b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:42:48 +0100 Subject: [PATCH 57/70] Text displays: keep the background at vanilla's -1..width, -1..height TextDisplayRenderer.submitInner calls submitTextBackground(-1, -1, width, height), and Font.prepareBackground's effect glyph spans x0..x1, y0..y1, so the fill is width + 1 by height + 1 from (-1, -1), as before. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/text_displays.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs index b669c8357..45bd64fa7 100644 --- a/crates/horizon-client/src/game/text_displays.rs +++ b/crates/horizon-client/src/game/text_displays.rs @@ -210,10 +210,11 @@ impl Game<'_> { if bg != 0 { batch.fill( atlas, + // submitTextBackground(-1, -1, width, height): corners, not a size. -1.0, -1.0, - width + 2.0, - height + 2.0, + width + 1.0, + height + 1.0, rgba( (bg >> 16) as u8, (bg >> 8) as u8, 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 58/70] 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: From ee83d8f2475063b157b41f87a83237362eb35f06 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:47:27 +0100 Subject: [PATCH 59/70] Chat test: set the abilities through set_abilities (clippy) Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/chat_tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/chat_tests.rs b/crates/horizon-client/src/chat_tests.rs index 071cd8839..beec6cd81 100644 --- a/crates/horizon-client/src/chat_tests.rs +++ b/crates/horizon-client/src/chat_tests.rs @@ -446,7 +446,7 @@ fn a_guests_line_follows_the_player_message_permission() { let font = font(); let shown = |visibility, source| { let mut chat = Chat::default(); - chat.abilities = ChatAbilities::new(visibility); + chat.set_abilities(&font, ChatAbilities::new(visibility)); chat.add_message(&font, Text::literal("line"), None, source, 0, false); chat.messages.len() }; From 189b2c6b3cce355b0b2dc527f2579025cc5e4c16 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 11:52:09 +0100 Subject: [PATCH 60/70] nightly: pick the 03:07 Paris schedule by offset, not by the clock at start; room for lan_integration GitHub started both 10-26 schedules over an hour late, so the hour check skipped both and no audit ran. lan_integration takes ~2,400 s under load, past the 1,800 s per-harness limit. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 60bbbf057..1ea2db6fa 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -8,7 +8,7 @@ name: nightly audit # gh workflow run "nightly audit" -f dry_run=true # the audit, without touching issues on: schedule: - # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:00 in Paris. + # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:07 in Paris today. - cron: '7 1 * * *' - cron: '7 2 * * *' workflow_dispatch: @@ -31,14 +31,19 @@ jobs: audit: # The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform. runs-on: [self-hosted, horizon-game, macOS] - timeout-minutes: 150 + timeout-minutes: 240 # every harness (~80 min) plus lan_integration (~40 min an attempt under load, retried) steps: - - name: 03:00 in Paris + - name: 03:07 in Paris id: when + env: + SCHEDULE: ${{ github.event.schedule }} run: | - hour=$(TZ=Europe/Paris date +%H) - if [[ "${{ github.event_name }}" == schedule && "$hour" != 03 ]]; then - echo "It is ${hour}:00 in Paris: the other schedule runs the audit." + # Which cron is 03:07 in Paris, from Paris's offset today: GitHub can start a schedule hours late, so the + # clock at start time can't tell (on 2026-10-26 both started after 04:00 Paris and both skipped). + offset=$(TZ=Europe/Paris date +%z) + ours=$([ "$offset" = +0200 ] && echo '7 1 * * *' || echo '7 2 * * *') + if [[ "${{ github.event_name }}" == schedule && "$SCHEDULE" != "$ours" ]]; then + echo "Paris is at UTC${offset} today: the '$ours' schedule runs the audit." echo "run=false" >> "$GITHUB_OUTPUT" else echo "run=true" >> "$GITHUB_OUTPUT" @@ -66,7 +71,8 @@ jobs: run: | echo "since=$(date +%Y-%m-%dT%H:%M:%S)" >> "$GITHUB_OUTPUT" set +e - python3 tools/parity.py --all --timeout 1800 2>&1 | tee "$RUNNER_TEMP/audit.log" + # lan_integration (the whole lan_e2e suite) takes ~2,400 s under load, past the usual 1,800. + python3 tools/parity.py --all --timeout 3000 2>&1 | tee "$RUNNER_TEMP/audit.log" echo "exit=${PIPESTATUS[0]}" >> "$GITHUB_OUTPUT" { echo '```'; tail -40 "$RUNNER_TEMP/audit.log"; echo '```'; } >> "$GITHUB_STEP_SUMMARY" - name: Issues for the harnesses that regressed From fe19efb9172be2c00656c1c175b4a2bddf824d4e Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:14:59 +0100 Subject: [PATCH 61/70] Predicted break: test BaseFireBlock by its class, as the server does The world side checks Class::BaseFire; the tag is a data-pack list that can differ from the class. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/remote.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 87e06d586..8992558cd 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3817,7 +3817,7 @@ impl Game<'_> { // sound), which BaseFireBlock skips: the server's extinguish sound // is all a player hears. let facts = self.res.facts().get(state); - if !self.res.items().block_in_tag("minecraft:fire", &facts.name) { + if !facts.has_class("BaseFireBlock") { let s = facts.sounds.clone(); let at = [ f64::from(pos[0]) + 0.5, From c23b4e8e416a59bd7001f77f3e8738b04db9deb3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:27:06 +0100 Subject: [PATCH 62/70] Mod API: game.raycast, the block the player looks at (level 2) `game.raycast(distance)` returns the first block along the player's view (fluids pass), up to 1024 blocks: through the loaded chunks as the crosshair's ray goes, then across the distant terrain's ground heights (`Lod::ground`, from Stink-O's fork). The game casts it only while a running mod imports the function. It is API level 2, so older Horizons refuse a mod that calls it with "update Horizon". Co-authored-by: Stink-O <180130752+Stink-O@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/mods.rs | 57 +++++++++++++++++++ crates/horizon-client/src/lod.rs | 19 +++++++ crates/horizon-mod-sdk/wit/horizon.wit | 21 ++++++- crates/horizon-mods/src/api_level.rs | 5 +- crates/horizon-mods/src/runtime.rs | 29 +++++++++- crates/horizon-mods/tests/sandbox.rs | 47 ++++++++++++++- crates/horizon-mods/tests/ui_guest/src/lib.rs | 16 +++++- docs/api/mods-reference.md | 17 +++++- docs/api/stability.md | 2 +- docs/mods.md | 2 +- 10 files changed, 202 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs index a83277376..1752dec91 100644 --- a/crates/horizon-client/src/game/mods.rs +++ b/crates/horizon-client/src/game/mods.rs @@ -415,8 +415,65 @@ impl Game<'_> { cps, font_widths: self.mods.font_widths.clone(), players: Vec::new(), + view_hit: self.mod_view_hit(), } } + /// The first block along the player's view within + /// [`horizon_mods::RAYCAST_MAX`] and its distance from the eye + /// (`game.raycast`): through the loaded chunks as the crosshair's ray + /// goes (fluids pass), then across the distant terrain's ground heights, + /// a block at a time. + fn mod_view_hit(&self) -> Option<(f32, horizon_mods::Hit)> { + if !self.mods.mods.wants_raycast() { + return None; + } + let eye = self.eye_position()?; + let dir = super::view_vector(self.yaw, self.pitch); + let reach = f64::from(horizon_mods::RAYCAST_MAX); + let (pos, point, state) = match self.clip_ray(eye, dir, reach) { + Some(hit) => ( + hit.pos, + hit.point, + self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]), + ), + None => self.lod_ray(eye, dir, reach)?, + }; + let distance = (0..3).map(|i| (point[i] - eye[i]).powi(2)).sum::(); + let hit = horizon_mods::Hit { + block_x: pos[0], + block_y: pos[1], + block_z: pos[2], + x: point[0], + y: point[1], + z: point[2], + block: self.res.facts().get(state).name.to_string(), + }; + Some((distance.sqrt() as f32, hit)) + } + /// Past the resident chunks: the view walked across the distant + /// terrain's ground heights (`Lod::ground`), a block at a time. Columns in + /// loaded chunks are left to `clip_ray`, which has already missed them. + fn lod_ray( + &self, + eye: [f64; 3], + dir: [f64; 3], + reach: f64, + ) -> Option<([i32; 3], [f64; 3], horizon_world::registry::BlockStateId)> { + let lod = self.lod.as_ref()?; + let mut t = 0.0; + while t <= reach { + let p = [0, 1, 2].map(|i| eye[i] + dir[i] * t); + let (x, z) = (p[0].floor() as i32, p[2].floor() as i32); + if !self.world.loaded(x, z) + && let Some((height, state)) = lod.ground(x, z) + && p[1] <= f64::from(height) + { + return Some(([x, height - 1, z], [p[0], f64::from(height), p[2]], state)); + } + t += 1.0; + } + None + } /// A game tick. pub(super) fn tick_mods(&mut self) { // Here, at the player's level: shown inside a console call (a control diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index a429863a7..1ee61cdf4 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -752,6 +752,25 @@ impl Lod { saved_order: VecDeque::new(), } } + /// The solid ground at block column (x, z): its top face's height and + /// its block, from the finest tile sampled there. For aiming past the + /// resident chunks (`game.raycast`); water is passed, as the view's ray + /// passes it. + pub fn ground(&self, x: i32, z: i32) -> Option<(i32, BlockStateId)> { + (0..=MAX_LEVEL).find_map(|level| { + let size = 16 << level; + let key = TileKey { + x: x.div_euclid(size), + z: z.div_euclid(size), + level, + }; + let columns = self.ready.get(&key).filter(|c| c.len() == CELLS * CELLS)?; + let cell = size / CELLS as i32; + let (cx, cz) = ((x - key.x * size) / cell, (z - key.z * size) / cell); + let surface = columns[cz as usize * CELLS + cx as usize].surface?; + Some((surface.height, surface.state)) + }) + } pub fn stats(&self) -> (usize, usize) { (self.active.len(), self.ready.len()) } diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 84be4d4f0..7f8245c48 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -18,7 +18,8 @@ interface log { write: func(level: level, message: string); } -/// Capability `game-read`: the local player and the world clock. +/// Capability `game-read`: the local player, the world clock and the block +/// the player looks at. interface game { record player { /// Feet position, in blocks. @@ -46,6 +47,24 @@ interface game { get-player: func() -> option; /// None on the title screen. get-clock: func() -> option; + /// A block along the player's view. + record hit { + /// The block hit. + block-x: s32, + block-y: s32, + block-z: s32, + /// The point on its face where the view meets it. + x: f64, + y: f64, + z: f64, + /// `minecraft:stone`, ... + block: string, + } + /// The first block along the player's view (fluids pass), up to + /// `distance` blocks (at most 1024; past the loaded chunks, across the + /// distant terrain when LOD Distance is on), as of this tick. None when + /// nothing is hit, and on the title screen. + raycast: func(distance: f32) -> option; } /// Capability `chat`: messages only the local player sees. diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs index e7b72c20b..0627b71ae 100644 --- a/crates/horizon-mods/src/api_level.rs +++ b/crates/horizon-mods/src/api_level.rs @@ -7,13 +7,13 @@ //! version's level so the launcher can tell before it installs. /// The newest level this Horizon serves. -pub const LEVEL: u32 = 1; +pub const LEVEL: u32 = 2; /// Every function the game offers mods, as `interface.function`, with its /// 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); 32] = [ +pub const FUNCTIONS: [(&str, u32); 33] = [ ("log.write", 0), ("game.get-player", 0), ("game.get-clock", 0), @@ -46,6 +46,7 @@ pub const FUNCTIONS: [(&str, u32); 32] = [ ("players.online", 1), ("players.tell", 1), ("players.broadcast", 1), + ("game.raycast", 2), ]; /// A function's level; None for one this Horizon doesn't have. diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs index f1859337d..ea603ee31 100644 --- a/crates/horizon-mods/src/runtime.rs +++ b/crates/horizon-mods/src/runtime.rs @@ -41,7 +41,7 @@ mod ui_bindings { }); } pub use bindings::horizon::mods::{ - game::{Clock, Player}, + game::{Clock, Hit, Player}, hud::{Corner, Line}, }; use bindings::{ @@ -89,6 +89,8 @@ const FUEL_FRAME: u64 = 10_000_000; const FUEL_EVENT: u64 = 100_000_000; /// Chat lines a mod may show per call, HUD lines and their length. const CHAT_PER_CALL: usize = 8; +/// How far `game.raycast` sees, in blocks. +pub const RAYCAST_MAX: f32 = 1024.0; const HUD_LINES: usize = 16; const LINE_CHARS: usize = 256; /// Total bytes a mod's `storage` may hold on disk, across all its keys. @@ -124,6 +126,10 @@ pub struct Snapshot { pub font_widths: Arc<[f32]>, /// The players on the server, for server mods. pub players: Vec, + /// The first block along the player's view within [`RAYCAST_MAX`] and + /// its distance from the eye, for `game.raycast`; the game works it out + /// only while a mod calls it ([`Mods::wants_raycast`]). + pub view_hit: Option<(f32, Hit)>, } /// Which mods a game starts: the window's game the client mods, the game @@ -227,6 +233,8 @@ struct Running { /// server mod. ui: Option, hooks: Hooks, + /// It imports `game.raycast`. + raycasts: bool, } /// A running mod's exports and the hooks its `init` asked for. @@ -490,7 +498,12 @@ impl Mods { free }); self.out.append(&mut store.data_mut().out); - Ok(Some(Running { store, ui, hooks })) + Ok(Some(Running { + store, + ui, + hooks, + raycasts: functions.iter().any(|f| f == "game.raycast"), + })) } /// True when at least one mod runs: the game skips its mod work otherwise. @@ -743,6 +756,13 @@ impl Mods { .iter() .filter_map(|e| e.run.as_ref()?.store.data().corner.as_ref()) } + /// Some running mod calls `game.raycast`: the snapshot needs a + /// [`Snapshot::view_hit`]. + pub fn wants_raycast(&self) -> bool { + self.entries + .iter() + .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts)) + } /// Some running mod has a `frame` hook: the game refreshes the snapshot /// every frame for it. pub fn wants_frames(&self) -> bool { @@ -1093,6 +1113,11 @@ impl game::Host for State { fn get_clock(&mut self) -> Option { self.snapshot.clock } + fn raycast(&mut self, distance: f32) -> Option { + let (at, hit) = self.snapshot.view_hit.as_ref()?; + // NaN compares false: no hit. + (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone()) + } } impl State { /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`]. diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index aaec89ec7..8eceec815 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -2,8 +2,8 @@ //! examples and a guest //! that misbehaves on command. Needs `rustup target add wasm32-unknown-unknown`. use horizon_mods::{ - BlockPos, Clock, Corner, GameMode, HeldItem, Mods, Output, Package, Player, Runs, ServerPlayer, - Shape, Snapshot, Status, + BlockPos, Clock, Corner, GameMode, HeldItem, Hit, Mods, Output, Package, Player, Runs, + ServerPlayer, Shape, Snapshot, Status, manifest::componentize, testing::{Script, TestGame}, }; @@ -26,7 +26,7 @@ id = "test_ui_guest" name = "Test UI Guest" version = "0.1.0" api = "0.1" -capabilities = ["chat", "ui", "render", "input"] +capabilities = ["game-read", "chat", "ui", "render", "input"] experimental = ["ui", "render", "input"] "#; @@ -722,6 +722,47 @@ fn render_minimap_is_clamped_and_hidden() { assert_eq!(map(&mut mods, "off"), None); } +/// `game.raycast`: the view's hit the game worked out, up to the distance +/// asked for; the game works it out only while a mod imports the call. +#[test] +fn game_raycast_sees_the_view_hit_within_its_distance() { + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + assert!(mods.wants_raycast()); + assert!(!load("coords_hud.hmod").wants_raycast()); + let said = |mods: &mut Mods, args: &str| -> Vec { + assert!(mods.command(&format!("raycast {args}"))); + mods.drain() + .into_iter() + .filter_map(|o| match o { + Output::Chat { text, .. } => Some(text), + _ => None, + }) + .collect() + }; + assert_eq!(said(&mut mods, "100"), ["no hit"]); + mods.set_snapshot(Snapshot { + view_hit: Some(( + 40.5, + Hit { + block_x: 12, + block_y: 63, + block_z: -44, + x: 12.5, + y: 64.0, + z: -43.75, + block: "minecraft:grass_block".into(), + }, + )), + ..player() + }); + let hit = "hit minecraft:grass_block at 12 63 -44 (12.5 64.0 -43.8)"; + assert_eq!(said(&mut mods, "100"), [hit]); + assert_eq!(said(&mut mods, "40"), ["no hit"]); + // NaN asks for nothing; past 1024 is 1024. + assert_eq!(said(&mut mods, "x"), ["no hit"]); + assert_eq!(said(&mut mods, "1e9"), [hit]); +} + #[test] fn corner_panels_text_width_and_readings() { let mut mods = load("horizon_mods_test_ui_guest.hmod"); diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs index 3d4c66076..32e811fc7 100644 --- a/crates/horizon-mods/tests/ui_guest/src/lib.rs +++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs @@ -4,9 +4,10 @@ //! `/render_hud`, `/render_clear` and `/render_shake` test `render`; //! `/input_claim`, `/input_poll`, `/input_held` and `/input_wheel` test //! `input`; `/zoom FACTOR SMOOTH TURN` tests `render.set-zoom`; -//! `/corner` and `/readings` the calls the official extras mods use. +//! `/corner` and `/readings` the calls the official extras mods use; +//! `/raycast DISTANCE` says what `game.raycast` sees. use horizon_mod_sdk::{ - Mod, Registration, chat, + Mod, Registration, chat, game, input::{self, Event}, render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape}, ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget}, @@ -97,6 +98,7 @@ impl Mod for Guest { "input_wheel", "zoom", "minimap", + "raycast", "corner", "readings", ] @@ -217,6 +219,16 @@ impl Mod for Guest { }); render::set_minimap(map); } + "raycast" => { + let distance = args.parse().unwrap_or(f32::NAN); + chat::show(&match game::raycast(distance) { + Some(h) => format!( + "hit {} at {} {} {} ({:.1} {:.1} {:.1})", + h.block, h.block_x, h.block_y, h.block_z, h.x, h.y, h.z + ), + None => "no hit".into(), + }); + } // Clamped to (1, 10); the two after it shake nothing. "render_shake" => { render::shake(2.0, 99.0); diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md index d7bf879b8..a197b2c04 100644 --- a/docs/api/mods-reference.md +++ b/docs/api/mods-reference.md @@ -76,7 +76,7 @@ The mod's log, in the game's log under the mod's id. Always granted. Access: capability `game-read`. -Capability `game-read`: the local player and the world clock. +Capability `game-read`: the local player, the world clock and the block the player looks at. ### record `player` @@ -98,10 +98,25 @@ Capability `game-read`: the local player and the world clock. | `game-time` | `u64` | Ticks since the world was created. | | `day-time` | `u64` | 24000 ticks per day; 0 is 6:00 on the first day. | +### record `hit` + +A block along the player's view. + +| Field | Type | | +| --- | --- | --- | +| `block-x` | `s32` | The block hit. | +| `block-y` | `s32` | | +| `block-z` | `s32` | | +| `x` | `f64` | The point on its face where the view meets it. | +| `y` | `f64` | | +| `z` | `f64` | | +| `block` | `string` | `minecraft:stone`, ... | + | Function | Signature | What it does | | --- | --- | --- | | `get-player` | `func() -> option` | None on the title screen. | | `get-clock` | `func() -> option` | None on the title screen. | +| `raycast` | `func(distance: f32) -> option` | The first block along the player's view (fluids pass), up to `distance` blocks (at most 1024; past the loaded chunks, across the distant terrain when LOD Distance is on), as of this tick. None when nothing is hit, and on the title screen. | ## `chat` diff --git a/docs/api/stability.md b/docs/api/stability.md index 65cfc0c13..f6b40fabe 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 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`. 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`, level 2 `game.raycast`. 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: diff --git a/docs/mods.md b/docs/mods.md index 03ca120b2..7093a22be 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -83,7 +83,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | Interface | Capability | Functions | |---|---|---| | `log` | always | `write(level, message)`, in the game log as `[mod ]` | -| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time | +| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time; `raycast(distance)`: the first block along the view (fluids pass), up to 1024 blocks and across the distant terrain, with the point hit and the block's id | | `chat` | `chat` | `show(text)`: a line only the local player sees, after the mod's name (8 per call) | | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters | | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call | From 5ec21ff5f1468b052d104bd84e5ae07b02a3afe8 Mon Sep 17 00:00:00 2001 From: kohad1ck <163426863+kohad1ck@users.noreply.github.com> Date: Mon, 26 Oct 2026 16:47:07 +0800 Subject: [PATCH 63/70] Font: menus keep their run-time glyphs when the renderer rebuilds its atlas Menu text drawn with characters the bitmap sheets lack (Chinese, Japanese, Korean) is rasterized into a reserve of the shared atlas at run time, and the font caches the atlas rect it got. The loading screen hands over to the game about two seconds after the title shows by building a new renderer, whose atlas texture is made from HudAtlas.pixels alone: those never hold a run-time glyph, while the cache still answers with the old rects, so every such character already drawn went blank. Latin text, straight from the sheets, stayed. build_renderer and loading_renderer now forget the cache before the new texture exists, so the characters that are drawn again are placed into it, as ui_theme clears its own cache when the atlas changes. Fixes #1824, fixes #2040. --- crates/horizon-client/src/font.rs | 25 +++++++++++++++++++++++++ crates/horizon-client/src/game.rs | 14 ++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index 1903cab7e..d0e8c8499 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -1201,6 +1201,31 @@ mod tests { assert!(!font.take_patches().is_empty()); } + /// A renderer rebuilt over the same font (the loading screen's handoff) + /// makes its atlas texture from the textures alone, so the glyphs it had + /// rasterized into the previous texture must be placed into the new one. + #[test] + fn a_rebuilt_atlas_gets_its_glyphs_again() { + let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x)); + let default = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ab"]}]}"#; + let root = root( + "rebuild", + &[ + ("assets/minecraft/font/default.json", default), + ("assets/minecraft/textures/font/a.png", &sheet), + ], + ); + let font = load(&root); + let _ = std::fs::remove_dir_all(&root); + let first = font.glyph('a'); + assert_eq!(font.take_patches().len(), 1); + font.reset_cache(); + // Nothing is left over: drawing the character again places its pixels. + assert!(font.take_patches().is_empty()); + assert_eq!(font.glyph('a').advance, first.advance); + assert_eq!(font.take_patches().len(), 1); + } + #[test] fn provider_filters_follow_the_font_options() { let sheet = png(8, 8, |x, _| x < 4); diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index cdbd72d7b..1bd288bb7 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -12995,6 +12995,14 @@ fn build_renderer( ) -> Result { let assets = &pack.render; let atlas = &gui.atlas; + // The new renderer's atlas texture starts from `HudAtlas.pixels`, which + // holds the textures but never a glyph rasterized at run time. The font's + // cache still answers with the rects it drew into the previous renderer's + // texture, so forget them: the glyphs that are drawn again are placed into + // this texture (as `ui_theme` does when its atlas changes). Without this, + // Chinese and Japanese menu labels go blank when the loading screen hands + // over to the game. + atlas.font.reset_cache(); let mut renderer = pollster::block_on(Renderer::new( window, offscreen, @@ -13041,6 +13049,12 @@ fn loading_renderer( Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height), None => (EMPTY_HUD.as_slice(), 1, 1), }; + // A glyph rasterized into an earlier texture is not in these pixels; the + // new texture gets it again when the character is drawn (see + // `build_renderer`). + if let Some(atlas) = atlas { + atlas.font.reset_cache(); + } let mut renderer = pollster::block_on(Renderer::new( window, offscreen, From b279758c7c75447f74aac2466aa6d0ba1b758d82 Mon Sep 17 00:00:00 2001 From: kohad1ck <163426863+kohad1ck@users.noreply.github.com> Date: Mon, 26 Oct 2026 17:42:05 +0800 Subject: [PATCH 64/70] Localization: server screens and the new world name follow the language The Add/Edit Server, Direct Connection and Friends screens and Create New\nWorld built their titles, field labels, defaults and buttons from English\nliterals, so every non-English language showed English there. Route them\nthrough the current language with vanilla's keys:\n\n- ManageServerScreen: manageServer.add.title/edit.title, enterName, enterIp,\n selectServer.defaultName, gui.done and gui.cancel.\n- DirectJoinServerScreen: manageServer.enterIp (the addServer.enterIp key is\n not in 26.3), selectServer.select and gui.cancel.\n- WorldCreationUiState: selectWorld.newWorld.\n- Select World: selectWorld.title and selectWorld.versionUnknown.\n- DisconnectedScreen: disconnect.lost and gui.toMenu.\n\nA language missing a key keeps the English fallback, so en_us is unchanged.\n\nCo-Authored-By: ZCode Agent --- crates/horizon-client/src/multiplayer.rs | 28 ++++++++++++------------ crates/horizon-client/src/title.rs | 12 +++++++--- 2 files changed, 23 insertions(+), 17 deletions(-) diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index 07d8552ff..f13ffde0a 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -491,7 +491,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 96.0 + 18.0, 200.0, - "Done", + &crate::lang::get_or("gui.done", "Done"), servers::parse_address(address).is_some(), 50, ), @@ -499,7 +499,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 18.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 51, ), @@ -532,7 +532,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 96.0 + 12.0, 200.0, - "Join Server", + &crate::lang::get_or("selectServer.select", "Join Server"), servers::parse_address(address).is_some(), 52, ), @@ -540,7 +540,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 12.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 53, ), @@ -558,7 +558,7 @@ impl Screen { w / 2.0 - 100.0, h / 4.0 + 120.0 + 18.0, 200.0, - "Cancel", + &crate::lang::get_or("gui.cancel", "Cancel"), true, 57, ), @@ -568,7 +568,7 @@ impl Screen { w / 2.0 - 100.0, h / 2.0 + 30.0, 200.0, - "Back to Server List", + &crate::lang::get_or("gui.toMenu", "Back to Server List"), true, 54, )]; @@ -876,10 +876,10 @@ impl Screen { } => { centered( batch, - if index.is_some() { - "Edit Server Info" + &if index.is_some() { + crate::lang::get_or("manageServer.edit.title", "Edit Server Info") } else { - "Add Server" + crate::lang::get_or("manageServer.add.title", "Add Server") }, 17.0, u32::MAX, @@ -888,7 +888,7 @@ impl Screen { Self::field( atlas, batch, - "Server Name", + &crate::lang::get_or("manageServer.enterName", "Server Name"), name, (53.0, 66.0), *focus == 0, @@ -897,7 +897,7 @@ impl Screen { Self::field( atlas, batch, - "Server Address", + &crate::lang::get_or("manageServer.enterIp", "Server Address"), address, (94.0, 106.0), *focus == 1, @@ -916,7 +916,7 @@ impl Screen { Self::field( atlas, batch, - &crate::lang::get_or("addServer.enterIp", "Server Address"), + &crate::lang::get_or("manageServer.enterIp", "Server Address"), address, (100.0, 116.0), true, @@ -973,7 +973,7 @@ impl Screen { Self::Disconnected { reason, retry } => { centered( batch, - "Connection Lost", + &crate::lang::get_or("disconnect.lost", "Connection Lost"), h / 2.0 - 40.0, rgba(170, 170, 170, 255), ); @@ -1019,7 +1019,7 @@ impl Screen { (Self::List { .. }, Some(42)) => { *self = Self::Edit { index: None, - name: "Minecraft Server".into(), + name: crate::lang::get_or("selectServer.defaultName", "Minecraft Server"), address: String::new(), focus: 1, packs: None, diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index a6967816a..6ecaced9c 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -192,7 +192,7 @@ pub fn list_worlds(saves: &Path) -> Vec { commands: matches!(data.get("allowCommands"), Some(horizon_world::nbt::Tag::Byte(v)) if *v != 0), version: data.get("Version").and_then(|v| v.get("Name")) .and_then(|v| match v { horizon_world::nbt::Tag::String(s) => Some(s.to_string_lossy()), _ => None }) - .unwrap_or_else(|| "Unknown".into()), + .unwrap_or_else(|| lang::get_or("selectWorld.versionUnknown", "Unknown")), }) }) .collect(); @@ -272,7 +272,7 @@ impl Title { } pub(crate) fn new_world() -> Mode { Mode::Create { - name: "New World".into(), + name: lang::get_or("selectWorld.newWorld", "New World"), seed: String::new(), creative: false, focus: 0, @@ -867,7 +867,13 @@ impl Title { } Mode::Select { worlds, selected } => { crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); - centered(atlas, batch, "Select World", 8.0, u32::MAX); + centered( + atlas, + batch, + &lang::get_or("selectWorld.title", "Select World"), + 8.0, + u32::MAX, + ); self.caret.borrow_mut().draw( batch, atlas, From f0649da024e683e1a2b3815a99033b06e63deb7b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:46:11 +0100 Subject: [PATCH 65/70] parity: server_ops_feedback ends steps on the server's clock, not a 2 s sleep Built on the Client of the harness-await branch (#2114). Under 2.5 s server stalls the old harness fails (a command's feedback filed under the next step) and the new one passes 3 of 3. Co-Authored-By: Claude Sonnet 5.5 --- tools/test_server_ops_feedback_parity.py | 42 +++++++++++------------- 1 file changed, 19 insertions(+), 23 deletions(-) diff --git a/tools/test_server_ops_feedback_parity.py b/tools/test_server_ops_feedback_parity.py index f7b7a0e73..91854fac6 100644 --- a/tools/test_server_ops_feedback_parity.py +++ b/tools/test_server_ops_feedback_parity.py @@ -19,17 +19,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_dedicated_server_parity import Server, game_time + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_dedicated_server_parity import Server, game_time + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-ops-feedback-parity' # (label, what the console does, what the players do). @@ -53,7 +52,11 @@ QUIET = [ ('alice', [], ['cmd Alice time set 3000']), ] CASES = {'broadcast': ({}, BROADCAST), 'quiet': ({'broadcast-console-to-ops': 'false'}, QUIET)} -STEP_SECONDS = 2.0 +STEP_TICKS = 40 +# A step ends by the server's clock (Client.wait): after a round trip of Alice's (Bob is deopped for a while, so +# his is not used). While send_command_feedback is off a command has no reply for her, so those steps wait for +# the ticks alone. +NO_SYNC = {'feedback-off', 'console-feedback-off'} # Steps whose reply can take longer than a step: the next step waits for this console line first. A loaded machine # took 2 s to save vanilla's world, and the transcript ended before "Saved the game". WAIT_FOR = {'console-save': r'System chat: Saved the game'} @@ -72,33 +75,26 @@ def run_side(label, case, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-{case}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: for name in ('Alice', 'Bob'): - tell(f'join {name}') + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - tell('chat on') + client.wait(server, ['Alice'], STEP_TICKS) + client.tell('chat on') for step, console, actions in script: - tell(f'step {step}') + client.tell(f'step {step}') for command in console: server.console(command) + game_time(server) # the console runs its queue in order: these commands have run for action in actions: - tell(action) + client.tell(action) if step in WAIT_FOR: server.wait_for(WAIT_FOR[step], timeout=120) - time.sleep(STEP_SECONDS) - tell('end') - client.wait(timeout=60) + client.wait(server, [] if step in NO_SYNC else ['Alice'], STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): From 6a7951e150aaf013bf27959591a590c3ac9b5e45 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:09:28 +0100 Subject: [PATCH 66/70] mob_ai oracle: create a Peaceful scenario's hostile mobs past canSpawn EntityType.create returns null for a type that isn't allowedInPeaceful once the difficulty is Peaceful, so the peaceful_* scenarios threw in the oracle. Their mobs stand for ones already in the world when the difficulty changed. Co-Authored-By: Claude Opus 5.5 --- .../test/java/dev/horizonlab/parity/VanillaMobAiOracle.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java index 0345a4bc6..256333d46 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -60,6 +60,7 @@ import net.minecraft.util.debugchart.SampleLogger; import net.minecraft.world.clock.WorldClocks; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.EntitySpawnReason; +import net.minecraft.world.entity.EntitySpawnRequest; import net.minecraft.world.entity.EntityType; import net.minecraft.world.entity.EntityTypes; import net.minecraft.world.entity.monster.creaking.Creaking; @@ -540,7 +541,9 @@ public final class VanillaMobAiOracle { int id = 100000; for (MobSpec spec : s.mobs) { EntityType type = BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse(spec.type)); - Mob mob = (Mob) type.create(level, EntitySpawnReason.COMMAND); + // Ignore canSpawn: a Peaceful scenario's hostile mob is one that was already + // in the world when the difficulty changed (create returns null at Peaceful). + Mob mob = (Mob) type.create(level, new EntitySpawnRequest(EntitySpawnReason.COMMAND, true)); if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, ENTS.size())); mob.setId(id++); mob.snapTo(spec.x, spec.y, spec.z, spec.yaw, 0.0F); From a34cad379faf46b163a3a26ea8b4c1aa85dcb142 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:32:27 +0100 Subject: [PATCH 67/70] mod registry image: copy horizon-shader-api, which horizon-mods now depends on Every Railway build of the registry has failed since horizon-mods gained the optional horizon-shader-api dependency ("no matching package named horizon-shader-api"). Built the same context locally: OK. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-registry/Dockerfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/horizon-mod-registry/Dockerfile b/crates/horizon-mod-registry/Dockerfile index 13522165a..ecd3a9164 100644 --- a/crates/horizon-mod-registry/Dockerfile +++ b/crates/horizon-mod-registry/Dockerfile @@ -4,6 +4,8 @@ WORKDIR /src # The root manifest only for the shared crate's workspace settings (edition, lints). COPY Cargo.toml Cargo.toml COPY crates/horizon-mods crates/horizon-mods +# horizon-mods' optional dependency: cargo needs its manifest even with the feature off. +COPY crates/horizon-shader-api crates/horizon-shader-api COPY crates/horizon-mod-registry crates/horizon-mod-registry RUN cargo build --release --locked --manifest-path crates/horizon-mod-registry/Cargo.toml From 4b3af580d97a1d99a44144d4977ad24ed844b2d8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:34:52 +0100 Subject: [PATCH 68/70] mob_ai: drop the Peaceful type scenarios that diverge for other reasons A slime made without finalizeSpawn keeps 20 health where the probe's has 1, the probe doesn't report a piglin's brain, and a NoAI bee's flower cooldown runs one tick apart; none of that is the Peaceful despawn rule. Co-Authored-By: Claude Opus 5.5 --- tools/test_mob_ai_parity.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index 7aaa597e1..2ce6541e8 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -320,8 +320,9 @@ def scenarios(): 'player 6.5 -60 0.5', f'mob minecraft:zombie 0.5 -60 0.5 0 1 {flags}', ], f'difficulty={difficulty} time=18000') - for species in ('skeleton', 'creeper', 'slime', 'warden', 'wither', - 'piglin', 'shulker', 'bee', 'wolf', 'iron_golem', 'cow'): + # Not slime, piglin or bee: a slime made without finalizeSpawn keeps 20 health, the probe + # doesn't model a piglin's brain, and a NoAI bee's flower cooldown differs (none of it Peaceful). + for species in ('skeleton', 'creeper', 'warden', 'wither', 'shulker', 'wolf', 'iron_golem', 'cow'): add(f'peaceful_type_{species}', 1, [ 'player 6.5 -60 0.5', f'mob minecraft:{species} 0.5 -60 0.5 0 1 persistent noai', From 9e76f8c4f0928500b28a5504d6815c487bb476ba Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:12:04 +0100 Subject: [PATCH 69/70] parity-main: a failure that passes again at HEAD counts as a pass Twice today (runs 40301239508, 40311712302) mob_ai failed in parity-main, passed when bisect ran it again at the same HEAD, and the run still ended red, so no game release could follow main for three hours. The harness step now continues on error and the bisect step gives the verdict: 0 when every failed harness passes again at HEAD, 1 when they fail at the base too or a merge is named. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/parity-main.yml | 9 ++++++--- tests/test_parity_main.py | 5 +++-- tools/parity_main.py | 17 +++++++++-------- 3 files changed, 18 insertions(+), 13 deletions(-) diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml index c47005ab0..70fb33796 100644 --- a/.github/workflows/parity-main.yml +++ b/.github/workflows/parity-main.yml @@ -48,6 +48,9 @@ jobs: GH_TOKEN: ${{ github.token }} run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT" - name: The harnesses the merges since then can affect + id: harnesses + # A failure here is judged by the next step: the run passes when every failed harness passes again at HEAD. + continue-on-error: true env: PARITY_HOSTS: '' BASE_SHA: ${{ steps.base.outputs.sha }} @@ -55,8 +58,8 @@ jobs: echo "Merges since ${BASE_SHA}:" git log --first-parent --format=' %h %s' "$BASE_SHA..HEAD" python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400 - - name: The merge that broke them - if: failure() + - name: A flake, or the merge that broke them + if: steps.harnesses.outcome == 'failure' env: GH_TOKEN: ${{ github.token }} PARITY_HOSTS: '' @@ -65,7 +68,7 @@ jobs: rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true python3 tools/parity_main.py bisect "$BASE_SHA" --comment - name: Logs of the failed harnesses - if: failure() + if: steps.harnesses.outcome == 'failure' uses: actions/upload-artifact@v4 with: name: parity-main-logs diff --git a/tests/test_parity_main.py b/tests/test_parity_main.py index aa58375a6..46e3d0466 100644 --- a/tests/test_parity_main.py +++ b/tests/test_parity_main.py @@ -45,7 +45,7 @@ class ParityMainTests(unittest.TestCase): last_run.parent.mkdir(parents=True) last_run.write_text('{"failed": ["music"]}') real_run = parity_main.subprocess.run - for broken_from, blamed in ((None, None), (0, None), (2, "2")): + for broken_from, blamed, code in ((None, None, 0), (0, None, 1), (2, "2", 1)): comments = [] # git runs for real in the scratch repo; a `gh pr comment` is only recorded, never sent. fake_run = lambda command, **kwargs: (comments.append(command) if command[0] == "gh" @@ -55,7 +55,8 @@ class ParityMainTests(unittest.TestCase): and commits.index(git("rev-parse", "HEAD")) >= broken_from), \ mock.patch.object(parity_main.subprocess, "run", fake_run), \ mock.patch("builtins.print") as printed: - parity_main.bisect(commits[0], 60, comment=True) + self.assertEqual(parity_main.bisect(commits[0], 60, comment=True), code, + "0 only when the failures pass again at HEAD") if blamed: self.assertEqual([command[3] for command in comments], [blamed]) else: diff --git a/tools/parity_main.py b/tools/parity_main.py index 76fa49070..f61c9b028 100644 --- a/tools/parity_main.py +++ b/tools/parity_main.py @@ -78,34 +78,35 @@ def bisect(since, timeout, comment): failed = json.loads(LAST_RUN.read_text(encoding="utf-8")).get("failed") or [] if not failed: print("No failed harness recorded: nothing to bisect.") - return 0 + return 1 head = git("rev-parse", "HEAD").stdout.strip() commits = git("rev-list", "--first-parent", "--reverse", f"{since}..{head}").stdout.split() if not commits: print("No merge since the base.") - return 0 + return 1 def fails(commit): print(f"--- {commit[:9]} {git('log', '-1', '--format=%s', commit).stdout.strip()}", flush=True) git("checkout", "-q", "--detach", commit) return run_harnesses(failed, timeout) - def blame_nobody(why): + def blame_nobody(why, code): line = f"parity-main: {', '.join(failed)} {why}: no merge is named." print(line) if os.environ.get("GITHUB_STEP_SUMMARY"): with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as summary: summary.write(f"### {line}\n") - return 0 + return code # A merge is named only when the harnesses fail again at HEAD and pass at the base: otherwise the search would # end on the newest merge (a flake, or a runner missing files, passes everywhere now) or the oldest one (the - # runner fails at every commit) and blame it for nothing. + # runner fails at every commit) and blame it for nothing. The exit code is the run's verdict: 0 only when every + # failed harness passes when run again at HEAD (the commit is good, so releases may follow it), 1 otherwise. try: if not fails(head): - return blame_nobody(f"pass when run again at {head[:9]}: a flake or the runner") + return blame_nobody(f"pass when run again at {head[:9]}: a flake, counted as a pass", 0) if fails(since): - return blame_nobody(f"fail at the base {since[:9]} too: the runner or a flake") + return blame_nobody(f"fail at the base {since[:9]} too: the runner or a flake", 1) culprit = first_bad(commits, fails) if len(commits) > 1 else commits[0] finally: git("checkout", "-q", "--detach", head) @@ -122,7 +123,7 @@ def bisect(since, timeout, comment): body = (f"🤖 Agent: parity-main found that this merge breaks {', '.join(f'`{name}`' for name in failed)} on main " f"(bisected over {len(commits)} merges: {url}). Releases wait until parity-main passes again.") subprocess.run(["gh", "pr", "comment", number.group(1), "--repo", REPO, "--body", body]) - return 0 + return 1 def main(): From 455817204f21983955e1e83ef57026caa89d55d9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:04:54 +0100 Subject: [PATCH 70/70] Mod registry: 1-5 star ratings, one per GitHub account The registry service keeps players' ratings of published projects in one SQLite file on a volume (REGISTRY_DB, /data on Railway): - GET /api/mods/ratings: every rated project's average and count, cached a minute; never who rated. - GET /api/mods/{id}/rating: the signed-in account's own rating. - POST /api/mods/{id}/rating: sets or changes it, checked like a submission (origin, session, CSRF token), 30 per account and 600 in all per hour, only for projects on the registry's main, never by their owners. - The sign-in takes ?back=/mods/ to come back to a project's page. The image hands the volume to nobody before running as nobody. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-mod-registry/Cargo.lock | 84 +++++- crates/horizon-mod-registry/Cargo.toml | 2 + crates/horizon-mod-registry/Dockerfile | 6 +- crates/horizon-mod-registry/README.md | 24 +- crates/horizon-mod-registry/src/lib.rs | 280 ++++++++++++++++---- crates/horizon-mod-registry/src/main.rs | 5 +- crates/horizon-mod-registry/src/ratings.rs | 129 +++++++++ crates/horizon-mod-registry/tests/submit.rs | 121 ++++++++- 8 files changed, 581 insertions(+), 70 deletions(-) create mode 100644 crates/horizon-mod-registry/src/ratings.rs diff --git a/crates/horizon-mod-registry/Cargo.lock b/crates/horizon-mod-registry/Cargo.lock index f80068fcc..59bd37134 100644 --- a/crates/horizon-mod-registry/Cargo.lock +++ b/crates/horizon-mod-registry/Cargo.lock @@ -294,6 +294,18 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "fallible-iterator" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649" + +[[package]] +name = "fallible-streaming-iterator" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" + [[package]] name = "find-msvc-tools" version = "0.1.15" @@ -310,6 +322,12 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + [[package]] name = "foldhash" version = "0.2.0" @@ -394,17 +412,35 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + [[package]] name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" dependencies = [ - "foldhash", + "foldhash 0.2.0", "serde", "serde_core", ] +[[package]] +name = "hashlink" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" +dependencies = [ + "hashbrown 0.15.5", +] + [[package]] name = "hmac" version = "0.12.1" @@ -424,6 +460,7 @@ dependencies = [ "hmac", "horizon-mods", "http-body-util", + "rusqlite", "serde", "serde_json", "sha2", @@ -651,7 +688,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", - "hashbrown", + "hashbrown 0.17.1", "serde", "serde_core", ] @@ -674,6 +711,17 @@ version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" +[[package]] +name = "libsqlite3-sys" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "133c182a6a2c87864fe97778797e46c7e999672690dc9fa3ee8e241aa4a9c13f" +dependencies = [ + "cc", + "pkg-config", + "vcpkg", +] + [[package]] name = "litemap" version = "0.8.3" @@ -767,7 +815,7 @@ dependencies = [ "cfg_aliases", "codespan-reporting", "half", - "hashbrown", + "hashbrown 0.17.1", "indexmap", "libm", "log", @@ -786,7 +834,7 @@ version = "30.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" dependencies = [ - "hashbrown", + "hashbrown 0.17.1", "indexmap", "rustc-hash", "thiserror", @@ -820,6 +868,12 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + [[package]] name = "potential_utf" version = "0.1.6" @@ -867,6 +921,20 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rusqlite" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f" +dependencies = [ + "bitflags", + "fallible-iterator", + "fallible-streaming-iterator", + "hashlink", + "libsqlite3-sys", + "smallvec", +] + [[package]] name = "rustc-hash" version = "1.1.0" @@ -1316,6 +1384,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + [[package]] name = "version_check" version = "0.9.5" @@ -1344,7 +1418,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" dependencies = [ "bitflags", - "hashbrown", + "hashbrown 0.17.1", "indexmap", "semver", "serde", diff --git a/crates/horizon-mod-registry/Cargo.toml b/crates/horizon-mod-registry/Cargo.toml index affc08f62..959e84f91 100644 --- a/crates/horizon-mod-registry/Cargo.toml +++ b/crates/horizon-mod-registry/Cargo.toml @@ -23,6 +23,8 @@ hmac = "0.12" sha2 = "0.10" base64 = "0.22" getrandom = "0.3" +# Ratings: one SQLite file on a small volume, as the telemetry server keeps its data. +rusqlite = { version = "0.37", features = ["bundled"] } [dev-dependencies] tower = { version = "0.5", features = ["util"] } diff --git a/crates/horizon-mod-registry/Dockerfile b/crates/horizon-mod-registry/Dockerfile index ecd3a9164..ee2065008 100644 --- a/crates/horizon-mod-registry/Dockerfile +++ b/crates/horizon-mod-registry/Dockerfile @@ -12,5 +12,7 @@ RUN cargo build --release --locked --manifest-path crates/horizon-mod-registry/C FROM debian:stable-slim RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/* COPY --from=build /src/crates/horizon-mod-registry/target/release/horizon-mod-registry /usr/local/bin/ -USER nobody -CMD ["horizon-mod-registry"] +ENV REGISTRY_DB=/data/registry.sqlite3 +# Railway mounts the ratings' volume at /data owned by root: hand it to nobody, then run as nobody (setpriv is +# util-linux's, in every Debian image). +CMD ["sh", "-c", "mkdir -p /data && chown nobody:nogroup /data && exec setpriv --reuid=nobody --regid=nogroup --clear-groups horizon-mod-registry"] diff --git a/crates/horizon-mod-registry/README.md b/crates/horizon-mod-registry/README.md index f7cdc68c5..d609e6739 100644 --- a/crates/horizon-mod-registry/README.md +++ b/crates/horizon-mod-registry/README.md @@ -7,20 +7,26 @@ entry's fields), uploads it to the `staging` release of request adding or updating `mods/.toml`. That repository's CI checks it again, with a trial run of a mod in the sandbox; reviewers decide, and merging publishes. Formats and rules: [docs/api/mod-index.md](../../docs/api/mod-index.md). -It keeps no data: a session is a signed cookie holding the GitHub login, and the user's OAuth token is used once, to -read that login, and dropped. The sign-in asks for no scope. +Signed-in players also rate published projects, 1 to 5 stars: one rating per GitHub account and project, which they can +change, never their own project's. That is the only data it keeps, in one SQLite file (`REGISTRY_DB`); it only ever +shows totals, never who rated. A session is a signed cookie holding the GitHub login and id, and the user's OAuth token +is used once, to read them, and dropped. The sign-in asks for no scope. | Route | | | --- | --- | -| `GET /api/mods/auth/login` | Starts the GitHub sign-in | -| `GET /api/mods/auth/callback` | GitHub's redirect: sets the session, back to `/mods/submit` | +| `GET /api/mods/auth/login` | Starts the GitHub sign-in; `?back=/mods/` (or `/mods`) comes back to that page | +| `GET /api/mods/auth/callback` | GitHub's redirect: sets the session, back to `/mods/submit` or the `back` page | | `POST /api/mods/auth/logout` | Ends it | | `GET /api/mods/me` | `{login, csrf}`, or 401 | | `POST /api/mods/submit` | Multipart: `entry` (JSON: `id kind name summary description authors license source icon key signature version game changelog`) and `file`; `{pull_request}` or `{error}` | +| `GET /api/mods/ratings` | `{projects: {: {average, count}}}` for every rated project; cached a minute | +| `GET /api/mods//rating` | The signed-in account's own `{stars}` (null when it hasn't rated), or 401 | +| `POST /api/mods//rating` | JSON `{stars}`, 1 to 5: sets or changes it; `{stars, average, count}` or `{error}` | | `GET /healthz` | `ok` | -A submission must come from `REGISTRY_PUBLIC_URL`'s origin with the session's `X-CSRF-Token`. Six per account and sixty -in all per hour. Only an entry's `owners` publish its updates; a key change, an icon in the repository or anything else +A submission or a rating must come from `REGISTRY_PUBLIC_URL`'s origin with the session's `X-CSRF-Token`. Six +submissions per account and sixty in all per hour; thirty ratings per account and 600 in all. A project's owners can't +rate it, and only projects on the registry's `main` can be rated. Only an entry's `owners` publish its updates; a key change, an icon in the repository or anything else is a pull request by hand. ## Running it @@ -28,7 +34,7 @@ is a pull request by hand. ```sh cargo test # against a mock GitHub (tests/submit.rs) REGISTRY_PUBLIC_URL=http://localhost:4173 REGISTRY_SESSION_KEY=... GITHUB_CLIENT_ID=... GITHUB_CLIENT_SECRET=... \ - GITHUB_BOT_TOKEN=... REGISTRY_REPO=you/horizon-mods-test cargo run + GITHUB_BOT_TOKEN=... REGISTRY_REPO=you/horizon-mods-test REGISTRY_DB=/tmp/registry.sqlite3 cargo run ``` | Variable | | @@ -38,10 +44,12 @@ REGISTRY_PUBLIC_URL=http://localhost:4173 REGISTRY_SESSION_KEY=... GITHUB_CLIENT | `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET` | The OAuth app | | `GITHUB_BOT_TOKEN` | Fine-grained, the registry repository only: Contents and Pull requests read and write | | `REGISTRY_REPO` | Default `ludovic111/horizon-mods` | +| `REGISTRY_DB` | The ratings' SQLite file: default `/data/registry.sqlite3`, the volume | | `PORT` | Default 8080 | On Railway it is the service `horizon-mod-registry` of the project `horizon-site`, next to the website: built from -`main` with this `Dockerfile` from the repository root, health check `/healthz`, no public domain and no volume. The +`main` with this `Dockerfile` from the repository root, health check `/healthz`, no public domain, and the volume +`registry-data` at `/data` for the ratings. The website's Caddy sends `/api/mods/*` to it over Railway's private network (`REGISTRY_UPSTREAM` on the website service: `http://horizon-mod-registry.railway.internal:8080`). `railway.json` lists the same settings; Railway reads them from the service, not from the file. diff --git a/crates/horizon-mod-registry/src/lib.rs b/crates/horizon-mod-registry/src/lib.rs index 72970017a..661337c8c 100644 --- a/crates/horizon-mod-registry/src/lib.rs +++ b/crates/horizon-mod-registry/src/lib.rs @@ -2,13 +2,15 @@ //! `playhorizon.dev/api/mods/*` (docs/api/mod-index.md). A creator signs in //! with GitHub, sends a file and its page; the service runs the file's own //! checks, uploads it to the registry's `staging` release and opens a pull -//! request with the entry. Reviewers decide; merging publishes. It keeps no -//! data: sessions are signed cookies, and GitHub holds everything else. +//! request with the entry. Reviewers decide; merging publishes. Signed-in +//! players also rate published projects (`ratings`, its only data: sessions +//! are signed cookies, and GitHub holds everything else). pub mod github; +pub mod ratings; use axum::{ Json, Router, - extract::{DefaultBodyLimit, Multipart, Query, State}, + extract::{DefaultBodyLimit, Multipart, Path as UrlPath, Query, State}, http::{HeaderMap, StatusCode, header}, response::{IntoResponse, Redirect, Response}, routing::{get, post}, @@ -20,6 +22,7 @@ use horizon_mods::index::{ self, Kind, registry::{self, Entry, EntryVersion, Sources}, }; +use ratings::Ratings; use serde::Deserialize; use serde_json::json; use sha2::Sha256; @@ -37,6 +40,12 @@ const PER_ACCOUNT: usize = 6; const PER_HOUR: usize = 60; /// The page's JSON. const MAX_FORM: usize = 64 << 10; +/// Ratings set per account per hour, and by everyone. +const RATINGS_PER_ACCOUNT: usize = 30; +const RATINGS_PER_HOUR: usize = 600; +/// How long the ratings' totals are served from memory (and cached by +/// browsers and the launcher). +const TOTALS_FOR: Duration = Duration::from_secs(60); pub struct Config { /// `https://playhorizon.dev`: where the form is, and the only origin it @@ -47,11 +56,14 @@ pub struct Config { pub github: GitHub, /// Where files wait during a submission. pub scratch: PathBuf, + /// The ratings' SQLite file (a volume): `:memory:` keeps them in memory. + pub database: PathBuf, } impl Config { /// `REGISTRY_PUBLIC_URL`, `REGISTRY_SESSION_KEY`, `REGISTRY_REPO`, - /// `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`, `GITHUB_BOT_TOKEN`. + /// `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`, `GITHUB_BOT_TOKEN`, + /// `REGISTRY_DB` (default `/data/registry.sqlite3`). pub fn from_env() -> Result { let var = |name: &str| std::env::var(name).map_err(|_| format!("{name} is not set")); let key = var("REGISTRY_SESSION_KEY")?; @@ -69,6 +81,8 @@ impl Config { var("GITHUB_BOT_TOKEN")?, ), scratch: std::env::temp_dir().join("horizon-mod-registry"), + database: std::env::var_os("REGISTRY_DB") + .map_or_else(|| PathBuf::from("/data/registry.sqlite3"), PathBuf::from), }) } @@ -80,17 +94,31 @@ impl Config { #[derive(Clone)] pub struct App(Arc); +type Windows = Mutex>>; + struct Inner { config: Config, - recent: Mutex>>, + /// Submissions in the last hour, by account ("" for everyone's). + recent: Windows, + /// Ratings set in the last hour, the same way. + rated: Windows, + ratings: Mutex, + /// `GET /api/mods/ratings`' body, and when it was made. + totals: Mutex>, } impl App { - pub fn new(config: Config) -> App { - App(Arc::new(Inner { + /// Fails when the ratings' file can't be opened. + pub fn new(config: Config) -> Result { + let ratings = Ratings::open(&config.database) + .map_err(|e| format!("{}: {e}", config.database.display()))?; + Ok(App(Arc::new(Inner { config, - recent: Mutex::new(HashMap::new()), - })) + recent: Mutex::default(), + rated: Mutex::default(), + ratings: Mutex::new(ratings), + totals: Mutex::default(), + }))) } } @@ -101,6 +129,8 @@ pub fn router(app: App) -> Router { .route("/api/mods/auth/callback", get(callback)) .route("/api/mods/auth/logout", post(logout)) .route("/api/mods/me", get(me)) + .route("/api/mods/ratings", get(totals)) + .route("/api/mods/{id}/rating", get(my_rating).post(rate)) .route( "/api/mods/submit", post(submit).layer(DefaultBodyLimit::max( @@ -203,9 +233,29 @@ fn csrf(app: &Inner, headers: &HeaderMap) -> Option { Some(signed.rsplit('.').next()?.chars().take(32).collect()) } -async fn login(State(app): State) -> Response { +#[derive(Deserialize)] +struct Login { + /// The site's page to come back to: `/mods`, `/mods/submit` (the + /// default) or `/mods/`. + back: Option, +} + +/// Whether `path` is a registry page a sign-in may come back to. +fn registry_page(path: &str) -> bool { + match path.strip_prefix("/mods") { + Some("") => true, + Some(rest) => rest.strip_prefix('/').is_some_and(index::valid_id) || rest == "/submit", + None => false, + } +} + +async fn login(State(app): State, Query(q): Query) -> Response { let state = random_hex(); - let signed = sign(&app.0.config.session_key, &state); + let back = q + .back + .filter(|b| registry_page(b)) + .unwrap_or_else(|| "/mods/submit".into()); + let signed = sign(&app.0.config.session_key, &format!("{state}\n{back}")); let url = app .0 .config @@ -229,13 +279,17 @@ async fn callback( headers: HeaderMap, Query(q): Query, ) -> Result { - let expected = cookie(&headers, "hm_state").and_then(|v| unsign(&app.0.config.session_key, &v)); - if expected.as_deref() != Some(q.state.as_str()) { + let started = cookie(&headers, "hm_state").and_then(|v| unsign(&app.0.config.session_key, &v)); + let Some((_, back)) = started + .as_deref() + .and_then(|s| s.split_once('\n')) + .filter(|(state, _)| *state == q.state) + else { return Err(Refusal::new( StatusCode::FORBIDDEN, "the sign-in expired or didn't start here: try again", )); - } + }; let inner = app.0.clone(); let (login, id) = tokio::task::spawn_blocking(move || { inner @@ -250,7 +304,7 @@ async fn callback( &app.0.config.session_key, &format!("{login}\n{id}\n{}", now() + SESSION), ); - let back = format!("{}/mods/submit", app.0.config.public_url); + let back = format!("{}{back}", app.0.config.public_url); let mut response = Redirect::to(&back).into_response(); let headers = response.headers_mut(); headers.append( @@ -283,6 +337,131 @@ async fn me( )) } +fn database(e: rusqlite::Error) -> Refusal { + eprintln!("horizon-mod-registry: ratings: {e}"); + Refusal::new( + StatusCode::INTERNAL_SERVER_ERROR, + "the ratings can't be read right now", + ) +} + +/// A mean as the pages show it: two decimals. +fn rounded(average: f64) -> f64 { + (average * 100.0).round() / 100.0 +} + +/// `GET /api/mods/ratings`: `{"projects": {"": {"average", "count"}}}` for +/// every rated project. Totals only: never who rated. +async fn totals(State(app): State) -> Result { + let mut cached = app.0.totals.lock().unwrap(); + let body = match cached.as_ref().filter(|(at, _)| at.elapsed() < TOTALS_FOR) { + Some((_, body)) => body.clone(), + None => { + let all = app + .0 + .ratings + .lock() + .unwrap() + .summaries() + .map_err(database)?; + let projects: serde_json::Map = all + .into_iter() + .map(|(id, s)| (id, json!({"average": rounded(s.average), "count": s.count}))) + .collect(); + let body = json!({ "projects": projects }).to_string(); + *cached = Some((Instant::now(), body.clone())); + body + } + }; + Ok(( + [ + (header::CONTENT_TYPE, "application/json"), + (header::CACHE_CONTROL, "public, max-age=60"), + ], + body, + ) + .into_response()) +} + +/// `GET /api/mods/{id}/rating`: the signed-in account's own rating, +/// `{"stars": 1..5}` or `{"stars": null}`. +async fn my_rating( + State(app): State, + headers: HeaderMap, + UrlPath(id): UrlPath, +) -> Result, Refusal> { + let (_, account) = session(&app.0, &headers) + .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "not signed in"))?; + let stars = app + .0 + .ratings + .lock() + .unwrap() + .mine(&id, account) + .map_err(database)?; + Ok(Json(json!({ "stars": stars }))) +} + +#[derive(Deserialize)] +struct Rating { + stars: u8, +} + +/// `POST /api/mods/{id}/rating` with `{"stars": 1..5}`: sets or changes the +/// signed-in account's rating of a published project, not its own. Answers +/// the project's new totals and `stars`. +async fn rate( + State(app): State, + headers: HeaderMap, + UrlPath(id): UrlPath, + Json(rating): Json, +) -> Result, Refusal> { + let inner = app.0.clone(); + let (login, account) = signed_in_here(&inner, &headers)?; + if !(1..=5).contains(&rating.stars) { + return Err(bad("a rating is 1 to 5 stars")); + } + if !index::valid_id(&id) { + return Err(Refusal::new(StatusCode::NOT_FOUND, "no such project")); + } + if !allow(&inner.rated, &login, RATINGS_PER_ACCOUNT, RATINGS_PER_HOUR) { + return Err(Refusal::new( + StatusCode::TOO_MANY_REQUESTS, + "too many ratings this hour: try again later", + )); + } + let lookup = inner.clone(); + let wanted = id.clone(); + let entry = tokio::task::spawn_blocking(move || lookup.config.github.entry(&wanted)) + .await + .map_err(|_| Refusal::new(StatusCode::INTERNAL_SERVER_ERROR, "the check crashed"))? + .map_err(github_down)?; + let Some((entry, _)) = entry else { + return Err(Refusal::new( + StatusCode::NOT_FOUND, + format!("{id} isn't published in the registry"), + )); + }; + if entry.owners.iter().any(|o| o.eq_ignore_ascii_case(&login)) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "you publish this project: its players rate it", + )); + } + let summary = { + let ratings = inner.ratings.lock().unwrap(); + ratings + .rate(&id, account, rating.stars, now()) + .map_err(database)?; + ratings.summary(&id).map_err(database)? + }; + *inner.totals.lock().unwrap() = None; + let (average, count) = summary.map_or((0.0, 0), |s| (rounded(s.average), s.count)); + Ok(Json( + json!({"stars": rating.stars, "average": average, "count": count}), + )) +} + /// The page a submission fills in: a project's fields, and the version's. #[derive(Clone, Debug, Deserialize)] #[serde(deny_unknown_fields)] @@ -322,45 +501,56 @@ fn take(window: &mut VecDeque, max: usize) -> bool { window.len() < max } +/// A change sent by the site's own pages: from its origin, signed in, with +/// the session's CSRF token. The account: (login, id). +fn signed_in_here(app: &Inner, headers: &HeaderMap) -> Result<(String, u64), Refusal> { + let origin = headers.get(header::ORIGIN).and_then(|v| v.to_str().ok()); + if origin != Some(app.config.public_url.as_str()) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "send it from the registry's pages", + )); + } + let account = session(app, headers) + .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "sign in with GitHub first"))?; + let sent = headers.get("x-csrf-token").and_then(|v| v.to_str().ok()); + if sent.is_none() || sent.map(str::to_owned) != csrf(app, headers) { + return Err(Refusal::new( + StatusCode::FORBIDDEN, + "reload the page and try again", + )); + } + Ok(account) +} + +/// Counts one more for `login` and for everyone, unless either is at its +/// hourly limit. +fn allow(windows: &Windows, login: &str, per_account: usize, per_hour: usize) -> bool { + let mut windows = windows.lock().unwrap(); + let account = login.to_lowercase(); + let ok = take(windows.entry(String::new()).or_default(), per_hour) + && take(windows.entry(account.clone()).or_default(), per_account); + if ok { + let at = Instant::now(); + windows.entry(String::new()).or_default().push_back(at); + windows.entry(account).or_default().push_back(at); + } + ok +} + async fn submit( State(app): State, headers: HeaderMap, mut multipart: Multipart, ) -> Result, Refusal> { let inner = app.0.clone(); - let origin = headers.get(header::ORIGIN).and_then(|v| v.to_str().ok()); - if origin != Some(inner.config.public_url.as_str()) { + let (login, user_id) = signed_in_here(&inner, &headers)?; + if !allow(&inner.recent, &login, PER_ACCOUNT, PER_HOUR) { return Err(Refusal::new( - StatusCode::FORBIDDEN, - "submit from the registry's form", + StatusCode::TOO_MANY_REQUESTS, + "too many submissions this hour: try again later", )); } - let (login, user_id) = session(&inner, &headers) - .ok_or_else(|| Refusal::new(StatusCode::UNAUTHORIZED, "sign in with GitHub first"))?; - let sent = headers.get("x-csrf-token").and_then(|v| v.to_str().ok()); - if sent.is_none() || sent.map(str::to_owned) != csrf(&inner, &headers) { - return Err(Refusal::new( - StatusCode::FORBIDDEN, - "reload the form and try again", - )); - } - { - let mut recent = inner.recent.lock().unwrap(); - let ok = take(recent.entry(String::new()).or_default(), PER_HOUR) - && take(recent.entry(login.to_lowercase()).or_default(), PER_ACCOUNT); - if !ok { - return Err(Refusal::new( - StatusCode::TOO_MANY_REQUESTS, - "too many submissions this hour: try again later", - )); - } - let at = Instant::now(); - recent.entry(String::new()).or_default().push_back(at); - recent - .entry(login.to_lowercase()) - .or_default() - .push_back(at); - } let dir = inner.config.scratch.join(random_hex()); std::fs::create_dir_all(&dir) .map_err(|e| Refusal::new(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?; diff --git a/crates/horizon-mod-registry/src/main.rs b/crates/horizon-mod-registry/src/main.rs index 81fe1b7b6..a1e40a57a 100644 --- a/crates/horizon-mod-registry/src/main.rs +++ b/crates/horizon-mod-registry/src/main.rs @@ -1,5 +1,5 @@ //! `horizon-mod-registry`: serves on `PORT` (default 8080). Configured by the -//! environment (see `Config::from_env`); keeps no data. +//! environment (see `Config::from_env`); keeps the ratings in `REGISTRY_DB`. use std::net::SocketAddr; use horizon_mod_registry::{App, Config, router}; @@ -16,7 +16,8 @@ async fn main() { .await .unwrap_or_else(|e| panic!("port {port}: {e}")); eprintln!("horizon-mod-registry: listening on {port}, submitting to {repo}"); - axum::serve(listener, router(App::new(config))) + let app = App::new(config).unwrap_or_else(|e| panic!("horizon-mod-registry: {e}")); + axum::serve(listener, router(app)) .with_graceful_shutdown(async { let _ = tokio::signal::ctrl_c().await; }) diff --git a/crates/horizon-mod-registry/src/ratings.rs b/crates/horizon-mod-registry/src/ratings.rs new file mode 100644 index 000000000..0cba85142 --- /dev/null +++ b/crates/horizon-mod-registry/src/ratings.rs @@ -0,0 +1,129 @@ +//! Players' ratings of published projects, 1 to 5 stars: one per GitHub +//! account and project, which its rater can change. Stored in one SQLite +//! file (a Railway volume). Only totals leave it: never who rated what, +//! except a signed-in account's own rating, to that account. +use rusqlite::{Connection, OptionalExtension, params}; +use std::{collections::BTreeMap, path::Path}; + +const SCHEMA: &str = " +PRAGMA journal_mode = WAL; +PRAGMA synchronous = NORMAL; +CREATE TABLE IF NOT EXISTS ratings ( + project TEXT NOT NULL, + account INTEGER NOT NULL, + stars INTEGER NOT NULL CHECK (stars BETWEEN 1 AND 5), + updated INTEGER NOT NULL, + PRIMARY KEY (project, account) +) WITHOUT ROWID; +"; + +/// A project's ratings: their mean, and how many. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Summary { + pub average: f64, + pub count: u64, +} + +pub struct Ratings { + db: Connection, +} + +impl Ratings { + /// Opens (or creates) the file at `path`; `:memory:` for a test. + pub fn open(path: &Path) -> rusqlite::Result { + let db = Connection::open(path)?; + db.execute_batch(SCHEMA)?; + Ok(Ratings { db }) + } + + /// Sets `account`'s rating of `project`, replacing an earlier one. + pub fn rate(&self, project: &str, account: u64, stars: u8, now: u64) -> rusqlite::Result<()> { + self.db.execute( + "INSERT INTO ratings (project, account, stars, updated) VALUES (?1, ?2, ?3, ?4) + ON CONFLICT (project, account) DO UPDATE SET stars = excluded.stars, updated = excluded.updated", + params![project, account as i64, stars, now as i64], + )?; + Ok(()) + } + + /// `account`'s own rating of `project`. + pub fn mine(&self, project: &str, account: u64) -> rusqlite::Result> { + self.db + .query_row( + "SELECT stars FROM ratings WHERE project = ?1 AND account = ?2", + params![project, account as i64], + |r| r.get(0), + ) + .optional() + } + + /// `project`'s summary; None when nobody rated it. + pub fn summary(&self, project: &str) -> rusqlite::Result> { + self.db + .query_row( + "SELECT avg(stars), count(*) FROM ratings WHERE project = ?1 HAVING count(*) > 0", + [project], + |r| { + Ok(Summary { + average: r.get(0)?, + count: r.get::<_, i64>(1)? as u64, + }) + }, + ) + .optional() + } + + /// Every rated project's summary. + pub fn summaries(&self) -> rusqlite::Result> { + let mut statement = self + .db + .prepare("SELECT project, avg(stars), count(*) FROM ratings GROUP BY project")?; + let rows = statement.query_map([], |r| { + Ok(( + r.get::<_, String>(0)?, + Summary { + average: r.get(1)?, + count: r.get::<_, i64>(2)? as u64, + }, + )) + })?; + rows.collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn one_rating_per_account_and_project() { + let r = Ratings::open(Path::new(":memory:")).unwrap(); + r.rate("zoom", 1, 5, 10).unwrap(); + r.rate("zoom", 2, 2, 10).unwrap(); + r.rate("zoom", 1, 4, 11).unwrap(); + r.rate("minimap", 1, 3, 11).unwrap(); + assert_eq!(r.mine("zoom", 1).unwrap(), Some(4)); + assert_eq!(r.mine("zoom", 3).unwrap(), None); + let all = r.summaries().unwrap(); + assert_eq!( + all["zoom"], + Summary { + average: 3.0, + count: 2 + } + ); + assert_eq!( + all["minimap"], + Summary { + average: 3.0, + count: 1 + } + ); + assert_eq!(r.summary("zoom").unwrap(), Some(all["zoom"])); + assert_eq!(r.summary("nothing").unwrap(), None); + assert!( + r.rate("zoom", 1, 6, 12).is_err(), + "the table checks the range too" + ); + } +} diff --git a/crates/horizon-mod-registry/tests/submit.rs b/crates/horizon-mod-registry/tests/submit.rs index f27f18697..d5591d4fc 100644 --- a/crates/horizon-mod-registry/tests/submit.rs +++ b/crates/horizon-mod-registry/tests/submit.rs @@ -1,6 +1,6 @@ //! The whole submission against a mock GitHub: sign in, submit the sample //! signed mod (`crates/horizon-mods/tests/index`), and what lands on GitHub; -//! then what is refused. +//! then what is refused. Then ratings: who may rate what, and what is shown. use axum::{ Json, Router, body::{Body, Bytes}, @@ -55,7 +55,9 @@ async fn mock_github() -> (String, Shared) { .route( "/user", get(|State(s): State| async move { - Json(json!({"login": s.lock().unwrap().login, "id": 7})) + let login = s.lock().unwrap().login.clone(); + let id = if login == "alice" { 7 } else { 8 }; + Json(json!({"login": login, "id": id})) }), ) .route( @@ -174,7 +176,16 @@ impl Client { } async fn sign_in(&mut self) -> String { - let (status, _, location) = self.send(self.get("/api/mods/auth/login")).await; + self.sign_in_from("").await + } + + /// Signs in from the page `back` (`?back=` of the sign-in; "" for none). + async fn sign_in_from(&mut self, back: &str) -> String { + let login = match back { + "" => "/api/mods/auth/login".to_owned(), + back => format!("/api/mods/auth/login?back={back}"), + }; + let (status, _, location) = self.send(self.get(&login)).await; assert_eq!(status, StatusCode::SEE_OTHER); let location = location.unwrap(); assert!(location.contains( @@ -197,10 +208,11 @@ impl Client { .send(self.get(&format!("/api/mods/auth/callback?code=good&state={state}"))) .await; assert_eq!(status, StatusCode::SEE_OTHER); - assert_eq!( - location.as_deref(), - Some("https://playhorizon.test/mods/submit") - ); + let page = match back { + "/mods" | "/mods/zoom" => back, + _ => "/mods/submit", + }; + assert_eq!(location, Some(format!("https://playhorizon.test{page}"))); let (status, me, _) = self.send(self.get("/api/mods/me")).await; assert_eq!(status, StatusCode::OK); me["csrf"].as_str().unwrap().to_owned() @@ -265,9 +277,10 @@ async fn setup() -> (Client, Shared) { "bot".into(), ), scratch, + database: ":memory:".into(), }; let client = Client { - app: router(App::new(config)), + app: router(App::new(config).unwrap()), cookies: HashMap::new(), }; (client, mock) @@ -376,3 +389,95 @@ async fn what_the_form_refuses() { "nothing reached GitHub" ); } + +const ENTRY: &str = "kind = \"mod\"\nname = \"N\"\nsummary = \"s\"\nlicense = \"MIT\"\nsource = \"https://x.test\"\n\n[[versions]]\nversion = \"1.0.0\"\npublished = \"2026-01-01\"\ngame = \"26.3\"\nfile = \"f.hmod\"\nsha256 = \"0000000000000000000000000000000000000000000000000000000000000000\"\n"; + +impl Client { + async fn rate(&mut self, csrf: &str, id: &str, body: &str) -> (StatusCode, Value) { + let request = Request::post(format!("/api/mods/{id}/rating")) + .header(header::COOKIE, self.cookie_header()) + .header(header::ORIGIN, PUBLIC) + .header("x-csrf-token", csrf) + .header(header::CONTENT_TYPE, "application/json") + .body(Body::from(body.to_owned())) + .unwrap(); + let (status, json, _) = self.send(request).await; + (status, json) + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn ratings() { + let (mut client, mock) = setup().await; + { + let mut m = mock.lock().unwrap(); + m.main.insert( + "mods/zoom.toml".into(), + format!("id = \"zoom\"\nowners = [\"bob\"]\n{ENTRY}"), + ); + m.main.insert( + "mods/mine.toml".into(), + format!("id = \"mine\"\nowners = [\"Alice\"]\n{ENTRY}"), + ); + } + // Nothing rated yet; signed out, no own rating and no rating at all. + let (status, json, _) = client.send(client.get("/api/mods/ratings")).await; + assert_eq!((status, json), (StatusCode::OK, json!({"projects": {}}))); + let (status, ..) = client.send(client.get("/api/mods/zoom/rating")).await; + assert_eq!(status, StatusCode::UNAUTHORIZED); + let (status, _) = client.rate("x", "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::UNAUTHORIZED); + + // A sign-in from a project's page comes back to it; anywhere else is the form. + client.sign_in_from("https://evil.test/").await; + let csrf = client.sign_in_from("/mods/zoom").await; + let (status, json) = client.rate("wrong", "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::FORBIDDEN, "{json}"); + for stars in ["0", "6"] { + let (status, json) = client + .rate(&csrf, "zoom", &format!(r#"{{"stars": {stars}}}"#)) + .await; + assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); + } + let (status, json) = client.rate(&csrf, "zoom", r#"{"stars": 4}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json, json!({"stars": 4, "average": 4.0, "count": 1})); + // Changing it replaces it. + let (status, json) = client.rate(&csrf, "zoom", r#"{"stars": 2}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json["count"], 1); + let (_, json, _) = client.send(client.get("/api/mods/zoom/rating")).await; + assert_eq!(json, json!({"stars": 2})); + let (_, json, _) = client.send(client.get("/api/mods/minimap/rating")).await; + assert_eq!(json, json!({"stars": null})); + + // Not one's own project, nor one that isn't published. + let (status, json) = client.rate(&csrf, "mine", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::FORBIDDEN, "{json}"); + let (status, json) = client.rate(&csrf, "nothing", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::NOT_FOUND, "{json}"); + + // Another account's rating counts once more; the totals never say whose. + let mut other = Client { + app: client.app.clone(), + cookies: HashMap::new(), + }; + mock.lock().unwrap().login = "carol".into(); + let carol = other.sign_in().await; + let (status, json) = other.rate(&carol, "zoom", r#"{"stars": 5}"#).await; + assert_eq!(status, StatusCode::OK, "{json}"); + assert_eq!(json, json!({"stars": 5, "average": 3.5, "count": 2})); + let (status, json, _) = client.send(client.get("/api/mods/ratings")).await; + assert_eq!(status, StatusCode::OK); + assert_eq!( + json, + json!({"projects": {"zoom": {"average": 3.5, "count": 2}}}) + ); + + // The limit per account and hour. + let mut last = StatusCode::OK; + for _ in 0..40 { + (last, _) = client.rate(&csrf, "zoom", r#"{"stars": 3}"#).await; + } + assert_eq!(last, StatusCode::TOO_MANY_REQUESTS); +}