From db13bd7df5a0805af298a9083b4506c9f4d46273 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 18 Oct 2026 15:44:32 +0200 Subject: [PATCH] Carry: the structure mods' spawner processors, as data the game runs Carry used to take every processor written in Java out of its list (#822), so spawners kept what the template has: an empty spawner in Moog's templates, a placeholder pig in Better Dungeons'. The new processors module rewrites the ones with a data form before that: - Moog's Structure Lib's and Repurposed Structures' spawner randomizing processors become horizon:spawner_mobs, with Repurposed's rs_spawners list written in (weight-0 entries left out, as its loader does); - YUNG's Better Dungeons and Better Desert Temples spawner processors (a spawner or a placeholder block becomes a spawner of a fixed mob) become vanilla's rule processor with an append_static block entity, the entity in 26.3's shape (equipment, drop_chances); - Moog's vanilla loot swap is a no-op while its "replace vanilla" preset is off, as they ship, and is taken out. Each is counted in carry-report.json's processors_carried. The game's own horizon: types stay in the lists. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-port-pack/src/carry.rs | 16 +- crates/horizon-port-pack/src/lib.rs | 1 + crates/horizon-port-pack/src/processors.rs | 505 +++++++++++++++++++++ crates/horizon-port-pack/src/worldgen.rs | 44 +- docs/modpacks.md | 22 +- 5 files changed, 551 insertions(+), 37 deletions(-) create mode 100644 crates/horizon-port-pack/src/processors.rs diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index bfd0bcad5..b342f45fd 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -367,6 +367,7 @@ pub fn carry( let mut biome_conventions = BTreeSet::new(); let set_tags = crate::worldgen::structure_set_tags(&mut zip); let piece_counts = crate::worldgen::piece_counts(&mut zip); + let processor_data = crate::processors::ProcessorData::read(&mut zip); for i in 0..zip.len() { let mut entry = zip.by_index(i).map_err(|e| e.to_string())?; let name = entry.name().to_owned(); @@ -426,12 +427,15 @@ pub fn carry( if kind == "structure" { crate::worldgen::convention_tags(&v["biomes"], &mut biome_conventions); } - let mut changed = crate::worldgen::upgrade( + let types = &mut report.worldgen_types; + let carried = crate::processors::carry( kind, &mut v, - &mut report.worldgen_types, - &set_tags, + &processor_data, + &mut types.processors_carried, ); + let mut changed = + crate::worldgen::upgrade(kind, &mut v, types, &set_tags) || carried; if kind == "structure" { let path = rel.trim_start_matches("worldgen/structure/"); let structure = format!("{id}:{}", path.trim_end_matches(".json")); @@ -453,6 +457,12 @@ pub fn carry( if let Some((kind, mut added)) = modifier.and_then(|v| crate::worldgen::modifier(&v, loaded, types)) { + crate::processors::carry( + kind, + &mut added, + &processor_data, + &mut types.processors_carried, + ); crate::worldgen::upgrade(kind, &mut added, types, &set_tags); let to = format!( "data/{id}/worldgen/{kind}/{}/{path}", diff --git a/crates/horizon-port-pack/src/lib.rs b/crates/horizon-port-pack/src/lib.rs index 0e678fb9a..08f9b273f 100644 --- a/crates/horizon-port-pack/src/lib.rs +++ b/crates/horizon-port-pack/src/lib.rs @@ -14,5 +14,6 @@ pub mod jar; pub mod modrinth; pub mod oracle; pub mod pipeline; +pub mod processors; pub mod report; pub mod worldgen; diff --git a/crates/horizon-port-pack/src/processors.rs b/crates/horizon-port-pack/src/processors.rs new file mode 100644 index 000000000..7fcc0fd94 --- /dev/null +++ b/crates/horizon-port-pack/src/processors.rs @@ -0,0 +1,505 @@ +//! Structure processors the structure libraries write in Java, carried over +//! as data the game runs: the ones that give spawners their mob. +//! +//! - Moog's Structure Lib's and Repurposed Structures' spawner randomizing +//! processors pick a mob from a weighted list for each spawner. They become +//! `horizon:spawner_mobs` (`horizon_world::worldgen::structure::processor`), +//! with Repurposed's `rs_spawners` list written in. +//! - YUNG's Better Dungeons and Better Desert Temples turn a spawner or a +//! placeholder block into a spawner of a fixed mob. That is vanilla's `rule` +//! processor with an `append_static` block entity. +//! - Moog's vanilla loot swap only acts when its mod's "replace vanilla" +//! preset is on; one that ships off is a no-op and is taken out. +//! +//! 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 serde_json::{Value, json}; +use std::{ + collections::{BTreeMap, BTreeSet}, + io::{Read, Seek}, +}; + +/// What the processors read from the mod's own data files. +#[derive(Debug, Default)] +pub struct ProcessorData { + /// Repurposed Structures' `rs_spawners/.json` by id: each mob and + /// its weight, without the weight-0 entries its loader removes. + pub spawners: BTreeMap>, + /// Moog's "replace vanilla" presets that are on by default: + /// `(mod id, vanilla_key)`. + pub replace_vanilla: BTreeSet<(String, String)>, +} + +impl ProcessorData { + pub fn read(zip: &mut zip::ZipArchive) -> Self { + let mut out = Self::default(); + for i in 0..zip.len() { + let Ok(mut entry) = zip.by_index(i) else { + continue; + }; + let name = entry.name().to_owned(); + let Some((ns, rest)) = name + .strip_prefix("data/") + .and_then(|r| r.strip_suffix(".json")) + .and_then(|r| r.split_once('/')) + else { + continue; + }; + let spawners = rest.strip_prefix("rs_spawners/"); + if spawners.is_none() && rest != "moogs_structures/replace_vanilla" { + continue; + } + let mut text = String::new(); + let Ok(v) = entry + .read_to_string(&mut text) + .map_err(|_| ()) + .and_then(|_| serde_json::from_str::(&text).map_err(|_| ())) + else { + continue; + }; + if let Some(path) = spawners { + let mobs = v["mobs"] + .as_array() + .into_iter() + .flatten() + .filter_map(|m| Some((m["name"].as_str()?.to_owned(), m["weight"].as_f64()?))) + .filter(|(_, w)| *w != 0.) + .collect(); + out.spawners.insert(format!("{ns}:{path}"), mobs); + continue; + } + for preset in v["presets"].as_array().into_iter().flatten() { + if preset["default_enabled"].as_bool() != Some(true) { + continue; + } + for r in preset["replacements"].as_array().into_iter().flatten() { + if let Some(key) = r["vanilla_key"].as_str() { + out.replace_vanilla.insert((ns.to_owned(), key.to_owned())); + } + } + } + } + out + } +} + +/// Calls `f` on each processor list in a worldgen file: a `processor_list` +/// file, and the inline lists of a template pool's elements (list elements +/// included). Whether any call changed something. +pub fn each_list(kind: &str, v: &mut Value, f: &mut dyn FnMut(&mut Value) -> bool) -> bool { + match kind { + "processor_list" => f(v), + "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 |= f(p); + } + } + } else if let Some(p) = element.get_mut("processors") { + changed |= f(p); + } + } + changed + } + _ => false, + } +} + +/// The processors of a list: `{"processors": [...]}` or a bare list (an id +/// names another file and is left alone). +pub fn processors(list: &mut Value) -> Option<&mut Vec> { + match list { + Value::Array(a) => Some(a), + Value::Object(o) => o.get_mut("processors").and_then(Value::as_array_mut), + _ => None, + } +} + +/// Rewrites the processors of a worldgen file that have a data form; each is +/// counted by type in `carried`. Whether anything changed. +pub fn carry( + kind: &str, + v: &mut Value, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> bool { + each_list(kind, v, &mut |list| { + let Some(list) = processors(list) else { + return false; + }; + let mut changed = false; + let mut out = Vec::with_capacity(list.len()); + for p in list.drain(..) { + let kind = p["processor_type"].as_str().unwrap_or_default().to_owned(); + match as_data(&kind, &p, data) { + Some(replacement) => { + *carried.entry(kind).or_default() += 1; + out.extend(replacement); + changed = true; + } + None => out.push(p), + } + } + *list = out; + changed + }) +} + +/// The data form of a Java processor: the processors to put in its place +/// (none for a no-op), or `None` when it has none. +fn as_data(kind: &str, p: &Value, data: &ProcessorData) -> Option> { + let (ns, _) = kind.split_once(':')?; + Some(match kind { + "moogs_structures:spawner_randomizing_processor" => { + let mobs = p["weighted_entities"] + .as_array()? + .iter() + .map(|e| { + // The entry's NBT, then its id over it. + let mut entity = match &e["nbt"] { + Value::Object(o) => o.clone(), + _ => serde_json::Map::new(), + }; + entity.insert("id".into(), e["entity"].as_str()?.into()); + Some(json!({"entity": entity, "weight": e["weight"].as_f64()?})) + }) + .collect::>>()?; + vec![spawner_mobs(p, mobs, None)] + } + "repurposed_structures:spawner_randomizing_processor" => { + // A list the mod does not ship falls back to a vanilla dungeon + // mob in the mod; left out here. + let list = data + .spawners + .get(p["rs_spawner_resourcelocation"].as_str()?)?; + let mobs = list + .iter() + .map(|(id, weight)| json!({"entity": {"id": id}, "weight": weight})) + .collect(); + vec![spawner_mobs(p, mobs, repurposed_light(p)?)] + } + "moogs_structures:vanilla_loot_swap_processor" => { + let key = ( + p["modid"].as_str()?.to_owned(), + p["vanilla_key"].as_str()?.to_owned(), + ); + if data.replace_vanilla.contains(&key) { + return None; + } + Vec::new() + } + _ if ns == "betterdungeons" || ns == "betterdeserttemples" => vec![yung_spawner(kind, p)?], + _ => return None, + }) +} + +/// [`as_data`]'s `horizon:spawner_mobs` for the mods' spawner randomizing +/// processors, whose fields have the same names and defaults. +fn spawner_mobs(p: &Value, mobs: Vec, rules: Option) -> Value { + let mut out = json!({"processor_type": "horizon:spawner_mobs", "mobs": mobs}); + for key in [ + "delay", + "min_spawn_delay", + "max_spawn_delay", + "spawn_count", + "max_nearby_entities", + "required_player_range", + "spawn_range", + ] { + if let Some(n) = p.get(key).filter(|n| n.is_i64()) { + out[key] = n.clone(); + } + } + if let Some(r) = rules { + out["custom_spawn_rules"] = r; + } + if let Some(b) = p.get("spawner_replacement_block") { + out["replacement"] = b.clone(); + } + out +} + +/// Repurposed Structures' `custom_spawn_rules` from its light level ranges: +/// `Some(None)` without either, `None` when one does not read. The sky +/// light's upper bound is written as `max_exclusive`, as the mod does. +fn repurposed_light(p: &Value) -> Option> { + let range = |key: &str| -> Option> { + match p.get(key) { + None => Some(None), + Some(Value::Number(n)) => n.as_i64().map(|n| Some((n, n))), + Some(v) => Some(Some(( + v["min_inclusive"].as_i64()?, + v["max_inclusive"].as_i64()?, + ))), + } + }; + let (block, sky) = ( + range("valid_block_light_level")?, + range("valid_sky_light_level")?, + ); + if block.is_none() && sky.is_none() { + return Some(None); + } + let mut rules = json!({}); + if let Some((min, max)) = block { + rules["block_light_limit"] = json!({"min_inclusive": min, "max_inclusive": max}); + } + if let Some((min, max)) = sky { + rules["sky_light_limit"] = json!({"min_inclusive": min, "max_exclusive": max}); + } + Some(Some(rules)) +} + +/// An item as 26.3 saves it. +fn item(id: &str) -> Value { + json!({"id": format!("minecraft:{id}"), "count": 1}) +} + +/// YUNG's processors that make a spawner of a fixed mob (YUNG's API's +/// `MobSpawnerData`), as vanilla's `rule`: every `input` block becomes a +/// spawner with that NBT. +fn yung_spawner(kind: &str, p: &Value) -> Option { + const SPAWNER: &str = "minecraft:spawner"; + // (input block, mob, fields other than the defaults, whether the mob is + // also the only potential, its equipment) + let (input, mob, fields, potential, equipment): (_, _, &[(&str, i64)], _, _) = match kind { + "betterdungeons:mob_spawner_processor" => { + (SPAWNER, p["spawner_mob"].as_str()?, &[], true, None) + } + "betterdungeons:zombie_mob_spawner_processor" => ( + SPAWNER, + "minecraft:zombie", + &[("MaxNearbyEntities", 8)], + true, + None, + ), + "betterdungeons:skeleton_mob_spawner_processor" => ( + SPAWNER, + "minecraft:skeleton", + &[ + ("RequiredPlayerRange", 18), + ("MaxNearbyEntities", 8), + ("MaxSpawnDelay", 650), + ], + true, + None, + ), + "betterdungeons:small_nether_dungeon_mob_spawner_processor" => { + let mob = p["spawner_mob"].as_str()?; + // Wither skeletons get netherite armor that never drops and a + // stone sword (with the mod's default config, they and blazes + // keep their loot). + let armor = (mob == "minecraft:wither_skeleton").then(|| { + json!({ + "equipment": { + "feet": item("netherite_boots"), + "legs": item("netherite_leggings"), + "chest": item("netherite_chestplate"), + "head": item("netherite_helmet"), + "mainhand": item("stone_sword"), + }, + "drop_chances": {"feet": 0.0, "legs": 0.0, "chest": 0.0, "head": 0.0}, + }) + }); + (SPAWNER, mob, &[], true, armor) + } + "betterdungeons:zombie_tombstone_spawner_processor" => ( + "minecraft:black_stained_glass", + "minecraft:skeleton", + &[], + false, + Some(json!({"equipment": {"mainhand": item("iron_sword")}})), + ), + "betterdeserttemples:gravel_processor" => ( + "minecraft:gravel", + "minecraft:husk", + &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], + false, + None, + ), + // An empty hand list in 1.21.1: the skeletons spawn without a bow, + // since a spawn entry with more than its id is not finalized. + "betterdeserttemples:bone_block_processor" => ( + "minecraft:bone_block", + "minecraft:skeleton", + &[("RequiredPlayerRange", 32)], + false, + Some(json!({"equipment": {}})), + ), + "betterdeserttemples:infested_cracked_stone_bricks_processor" => ( + "minecraft:infested_cracked_stone_bricks", + "minecraft:silverfish", + &[("RequiredPlayerRange", 24)], + false, + None, + ), + // 1.21.1 ignores the items' old `Count` and `tag` (the shield's + // pattern, the boots' dye): plain items. + "betterdeserttemples:yellow_wool_processor" => ( + "minecraft:yellow_wool", + "minecraft:husk", + &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], + false, + Some(json!({"equipment": { + "mainhand": item("golden_sword"), + "offhand": item("shield"), + "feet": item("leather_boots"), + "legs": item("leather_leggings"), + "chest": item("golden_chestplate"), + "head": item("chainmail_helmet"), + }})), + ), + _ => return None, + }; + let mut entity = json!({"id": mob}); + if let Some(Value::Object(extra)) = equipment { + entity.as_object_mut()?.extend(extra); + } + let potentials = match potential { + true => json!([{"data": {"entity": entity.clone()}, "weight": 1}]), + false => json!([]), + }; + let mut nbt = json!({ + "Delay": 20, "MinSpawnDelay": 200, "MaxSpawnDelay": 800, "SpawnCount": 4, + "MaxNearbyEntities": 6, "RequiredPlayerRange": 16, "SpawnRange": 4, + "SpawnData": {"entity": entity}, + "SpawnPotentials": potentials, + }); + for (key, value) in fields { + nbt[*key] = (*value).into(); + } + Some(json!({ + "processor_type": "minecraft:rule", + "rules": [{ + "input_predicate": {"predicate_type": "minecraft:block_match", "block": input}, + "location_predicate": {"predicate_type": "minecraft:always_true"}, + "output_state": {"Name": SPAWNER}, + "block_entity_modifier": {"type": "minecraft:append_static", "data": nbt}, + }], + })) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn data() -> ProcessorData { + let mut d = ProcessorData::default(); + d.spawners.insert( + "repurposed_structures:dungeons/badlands".into(), + vec![ + ("minecraft:husk".into(), 10.), + ("minecraft:cave_spider".into(), 3.), + ], + ); + d.replace_vanilla.insert(("mvs".into(), "village".into())); + d + } + + #[test] + fn spawner_processors_become_data() { + let mut list = json!({"processors": [ + {"processor_type": "moogs_structures:spawner_randomizing_processor", + "weighted_entities": [{"entity": "minecraft:blaze", "weight": 2, "nbt": {"Health": 5}}], + "spawn_count": 2, "spawner_replacement_block": {"Name": "minecraft:stone"}}, + {"processor_type": "repurposed_structures:spawner_randomizing_processor", + "rs_spawner_resourcelocation": "repurposed_structures:dungeons/badlands", + "valid_block_light_level": {"min_inclusive": 0, "max_inclusive": 7}}, + {"processor_type": "repurposed_structures:spawner_randomizing_processor", + "rs_spawner_resourcelocation": "repurposed_structures:missing"}, + {"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": 0}, + {"processor_type": "moogs_structures:vanilla_loot_swap_processor", + "modid": "mns", "vanilla_key": "fortress", "loot_table_mapping": {}}, + {"processor_type": "moogs_structures:vanilla_loot_swap_processor", + "modid": "mvs", "vanilla_key": "village", "loot_table_mapping": {}}]}); + let mut carried = BTreeMap::new(); + assert!(carry("processor_list", &mut list, &data(), &mut carried)); + let p = list["processors"].as_array().unwrap(); + assert_eq!(p.len(), 5, "{p:#?}"); + assert_eq!( + p[0], + json!({"processor_type": "horizon:spawner_mobs", + "mobs": [{"entity": {"Health": 5, "id": "minecraft:blaze"}, "weight": 2.0}], + "spawn_count": 2, "replacement": {"Name": "minecraft:stone"}}) + ); + assert_eq!( + p[1], + json!({"processor_type": "horizon:spawner_mobs", + "mobs": [{"entity": {"id": "minecraft:husk"}, "weight": 10.0}, + {"entity": {"id": "minecraft:cave_spider"}, "weight": 3.0}], + "custom_spawn_rules": {"block_light_limit": {"min_inclusive": 0, "max_inclusive": 7}}}) + ); + // Unknown list, vanilla processor, and a swap whose preset is on: kept + // (the Java ones are dropped later); the swap that is off is gone. + assert_eq!( + p[2]["rs_spawner_resourcelocation"], + "repurposed_structures:missing" + ); + assert_eq!(p[3]["processor_type"], "minecraft:gravity"); + assert_eq!(p[4]["modid"], "mvs"); + assert_eq!( + carried, + BTreeMap::from([ + ("moogs_structures:spawner_randomizing_processor".into(), 1), + ("moogs_structures:vanilla_loot_swap_processor".into(), 1), + ( + "repurposed_structures:spawner_randomizing_processor".into(), + 1 + ), + ]) + ); + } + + #[test] + fn yungs_spawners_become_rules() { + let mut pool = json!({"elements": [{"element": {"processors": {"processors": [ + {"processor_type": "betterdungeons:skeleton_mob_spawner_processor"}, + {"processor_type": "betterdeserttemples:bone_block_processor"}, + {"processor_type": "betterdungeons:small_nether_dungeon_mob_spawner_processor", + "spawner_mob": "minecraft:wither_skeleton"}, + {"processor_type": "betterdungeons:candle_processor"}]}}}]}); + let mut carried = BTreeMap::new(); + assert!(carry("template_pool", &mut pool, &data(), &mut carried)); + let p = &pool["elements"][0]["element"]["processors"]["processors"]; + let rule = |i: usize| &p[i]["rules"][0]; + assert_eq!(rule(0)["input_predicate"]["block"], "minecraft:spawner"); + assert_eq!( + rule(0)["output_state"], + json!({"Name": "minecraft:spawner"}) + ); + let nbt = &rule(0)["block_entity_modifier"]["data"]; + assert_eq!( + ( + nbt["RequiredPlayerRange"].clone(), + nbt["MaxNearbyEntities"].clone() + ), + (json!(18), json!(8)) + ); + assert_eq!(nbt["MaxSpawnDelay"], 650); + assert_eq!( + nbt["SpawnPotentials"], + json!([{"data": {"entity": {"id": "minecraft:skeleton"}}, "weight": 1}]) + ); + // Bone blocks become bowless skeleton spawners with no potentials. + let bone = &rule(1)["block_entity_modifier"]["data"]; + assert_eq!(rule(1)["input_predicate"]["block"], "minecraft:bone_block"); + assert_eq!( + bone["SpawnData"], + json!({"entity": {"id": "minecraft:skeleton", "equipment": {}}}) + ); + assert_eq!(bone["SpawnPotentials"], json!([])); + let wither = &rule(2)["block_entity_modifier"]["data"]["SpawnData"]["entity"]; + assert_eq!( + wither["equipment"]["head"]["id"], + "minecraft:netherite_helmet" + ); + assert_eq!(wither["drop_chances"]["feet"], 0.0); + assert_eq!(p[3]["processor_type"], "betterdungeons:candle_processor"); + assert_eq!(carried.values().sum::(), 3); + } +} diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index dbd4fb8c6..51d1a0ce5 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -118,6 +118,9 @@ pub struct Upgrade { pub rules_lost: BTreeMap, /// Processors written in Java, taken out of their lists, by type. pub processors_dropped: BTreeMap, + /// Processors written in Java carried as data the game runs + /// ([`crate::processors`]), by type. + pub processors_carried: BTreeMap, /// Entries added to other structure sets and template pools /// (`horizon:add_to`), by the set or pool they join. pub added_to: BTreeMap, @@ -332,49 +335,28 @@ pub fn upgrade( ) -> bool { let states = block_states(v); report.block_states += usize::from(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, - }; + let dropped = crate::processors::each_list(kind, v, &mut |list| { + drop_java_processors(list, &mut report.processors_dropped) + }); 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 +/// Takes the processors written in Java (any type outside `minecraft:` and +/// the game's own `horizon:`) out of a processor list: `{"processors": +/// [...]}`, a bare list, or an id (left as it is). The ones with a data form +/// were rewritten before ([`crate::processors::carry`]). 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 Some(processors) = crate::processors::processors(list) else { + 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:"); + let java = !t.starts_with("minecraft:") && !t.starts_with("horizon:"); if java { *dropped.entry(t.to_owned()).or_default() += 1; } diff --git a/docs/modpacks.md b/docs/modpacks.md index 3dced2eee..cbb63a30f 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -438,7 +438,23 @@ Two cases the oracle fills in: list. The structures now generate undecorated (no pillars under them, spawners as the template has them); 1,427 processors of 146 types in ATM10's mods, the most common `lithostitched:block_swap`, Formations' `biome_replacements` and Repurposed Structures' - pillar, fluid and void processors. Porting the common ones is next. + pillar, fluid and void processors. + - **Spawner processors** carried as data (`horizon-port-pack/src/processors.rs`). Most + chests in the mods' templates already name their loot table; what the Java processors add + is the spawners' mobs. Moog's and Repurposed Structures' spawner randomizing processors + become `horizon:spawner_mobs` (a weighted mob per spawner, picked with the placement's + random as theirs do, and the spawner NBT they write; Repurposed's `rs_spawners` lists are + written in). YUNG's Better Dungeons and Better Desert Temples turn a spawner or a + placeholder block (gravel, bone block, yellow wool...) into a spawner of a fixed mob: that + is vanilla's `rule` processor with an `append_static` block entity. Moog's vanilla loot + swap acts only when a "replace vanilla" preset is on, and they ship off. 119 of the 1,427 + processors are carried; 1,308 are still taken out (blocks swapped, aged or propped up, + Moog's trial spawner and vault configs, YUNG's chest caps). + In the 128×128-chunk square (seed 1234), every spawner of a mod structure now has its mob: + in the Overworld 83 Better Dungeons spawners held the template's placeholder pig and 17 of + Moog's were empty (763 spawners with a mob, up from 628); in the Nether the 52 empty ones + in Moog's Nether Structures are filled (162, up from 110). Chests are unchanged: 2,777 + and 1,405 with a loot table. - **Big templates** (#838). Vanilla reads structure templates with no limit on their tag count; Horizon now does too (`nbt::Limits::templates`). Seven of ATM10's 8,962 carried templates are past the old 1,000,000-tag cap: YUNG's monument start, four When Dungeons @@ -487,8 +503,8 @@ Two cases the oracle fills in: - Repurposed's mineshafts, mansions, monuments, Nether cities and shipwrecks, Better Mineshafts and two Better Dungeons types: Java structure types; - YUNG's and Moog's enhanced terrain adaptation, YUNG's piece modifiers and dead-end pools, - and the processors written in Java (YUNG's spawners, chests, banners; 29 in Better Dungeons - alone), so these structures place their template blocks only; + and the block processors written in Java (YUNG's banners, legs and decorations, Repurposed's + pillars and fluid fixes, Lithostitched's block swaps); - MO Structures (38; its library is only on CurseForge). With every structure PR above, the same square (seed 1234, chunks -64..63) holds 362