From 65732406fc428926985929b1367d42b6d57abde5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 18 Oct 2026 06:48:02 +0200 Subject: [PATCH] Carry: take processors written in Java out of their lists The game, like vanilla, refuses a processor list holding a type it does not know, and with it every pool naming the list, so those structures did not generate at all. Carry now takes the library types out of processor lists (files and inline ones in pool elements) and counts them by type in the carry report: the structures generate, undecorated. On ATM10's carried mods: 1,427 processors of 146 types; pool decode failures 31 -> 0. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-port-pack/src/worldgen.rs | 96 +++++++++++++++++++++++- 1 file changed, 95 insertions(+), 1 deletion(-) diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index 91ff1bfef..25e0dbbea 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -74,6 +74,8 @@ pub struct Upgrade { pub unsupported: BTreeMap, /// Rules of mapped types the game does not run, by field. pub rules_lost: BTreeMap, + /// Processors written in Java, taken out of their lists, by type. + pub processors_dropped: BTreeMap, } /// Rewrites one `data//worldgen//...` file in place; whether it @@ -88,7 +90,55 @@ pub fn upgrade( ) -> bool { let states = block_states(v); report.block_states += usize::from(states); - upgrade_types(kind, v, report, set_tags) || states + let dropped = match kind { + "processor_list" => drop_java_processors(v, &mut report.processors_dropped), + "template_pool" => { + let mut changed = false; + for e in v["elements"].as_array_mut().into_iter().flatten() { + let element = &mut e["element"]; + if let Some(list) = element.get_mut("elements").and_then(Value::as_array_mut) { + for inner in list { + if let Some(p) = inner.get_mut("processors") { + changed |= drop_java_processors(p, &mut report.processors_dropped); + } + } + } else if let Some(p) = element.get_mut("processors") { + changed |= drop_java_processors(p, &mut report.processors_dropped); + } + } + changed + } + _ => false, + }; + upgrade_types(kind, v, report, set_tags) || states || dropped +} + +/// Takes the processors written in Java (any type outside `minecraft:`) +/// out of a processor list: `{"processors": [...]}`, a bare list, or an id +/// (left as it is). The game, like vanilla, refuses a list holding a type it +/// does not know, and with it every pool that names the list, so without +/// this the structure does not generate at all. Without them it generates +/// undecorated: no pillars under it, spawners left as the template has +/// them, blocks not swapped. Whether anything was taken out. +fn drop_java_processors(list: &mut Value, dropped: &mut BTreeMap) -> bool { + let processors = match list { + Value::Array(a) => a, + Value::Object(o) => match o.get_mut("processors") { + Some(Value::Array(a)) => a, + _ => return false, + }, + _ => return false, + }; + let before = processors.len(); + processors.retain(|p| { + let t = p["processor_type"].as_str().unwrap_or_default(); + let java = !t.starts_with("minecraft:"); + if java { + *dropped.entry(t.to_owned()).or_default() += 1; + } + !java + }); + processors.len() != before } /// 1.21.1 writes a block or fluid state as `{"Name": ..., "Properties": @@ -549,6 +599,50 @@ mod tests { assert_eq!(report.rules_lost["super_exclusion_zone"], 1); } + #[test] + fn drops_processors_written_in_java() { + let mut report = Upgrade::default(); + let mut list = json!({"processors": [ + {"processor_type": "repurposed_structures:bottom_pillar_processor"}, + {"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": -1}, + {"processor_type": "moogs_structures:spawner_randomizing_processor"}]}); + assert!(upgrade("processor_list", &mut list, &mut report, &NO_TAGS)); + assert_eq!( + list["processors"], + json!([{"processor_type": "minecraft:gravity", + "heightmap": "WORLD_SURFACE_WG", "offset": -1}]) + ); + let mut pool = json!({"elements": [ + {"weight": 1, "element": {"element_type": "minecraft:single_pool_element", + "processors": {"processors": [{"processor_type": "lithostitched:block_swap"}]}}}, + {"weight": 1, "element": {"element_type": "minecraft:list_pool_element", "elements": [ + {"element_type": "minecraft:single_pool_element", "processors": "x:named"}]}}]}); + assert!(upgrade("template_pool", &mut pool, &mut report, &NO_TAGS)); + assert_eq!( + pool["elements"][0]["element"]["processors"], + json!({"processors": []}) + ); + assert_eq!( + pool["elements"][1]["element"]["elements"][0]["processors"], + "x:named" + ); + let mut vanilla = json!({"processors": [{"processor_type": "minecraft:nop"}]}); + assert!(!upgrade( + "processor_list", + &mut vanilla, + &mut report, + &NO_TAGS + )); + assert_eq!( + report.processors_dropped, + BTreeMap::from([ + ("lithostitched:block_swap".into(), 1), + ("moogs_structures:spawner_randomizing_processor".into(), 1), + ("repurposed_structures:bottom_pillar_processor".into(), 1), + ]) + ); + } + #[test] fn writes_block_states_in_26_3_shape() { let mut report = Upgrade::default();