Merge pull request #870 from ludovic111/integ/mp6
🤖 Agent: Merged after the real verify passed. Combined check on this branch: fmt, clippy, workspace tests, and the worldgen, structure_density, chunk_generation and world_spawn harnesses pass. modpacks-6's own integration passed 298/298 harnesses with the start oracle at 35/35.
This commit is contained in:
@@ -53,13 +53,7 @@ impl Game<'_> {
|
||||
let Ok(raw) = Compression::Gzip.decode(&bytes, 1 << 28) else {
|
||||
continue;
|
||||
};
|
||||
let Ok((named, _)) = nbt::read_named(
|
||||
&raw,
|
||||
Limits {
|
||||
max_bytes: 1 << 28,
|
||||
..Limits::default()
|
||||
},
|
||||
) else {
|
||||
let Ok((named, _)) = nbt::read_named(&raw, Limits::templates()) else {
|
||||
continue;
|
||||
};
|
||||
return Some(Arc::new(StructureTemplate::from_nbt(
|
||||
|
||||
@@ -697,6 +697,78 @@ fn worldgen_entry(file: &str) -> Option<(&'static str, String)> {
|
||||
Some((bundle, format!("{ns}:{}", path.strip_suffix(".json")?)))
|
||||
}
|
||||
|
||||
/// The key of a mod's structure set or template pool file that adds its
|
||||
/// entries to other sets or pools (vanilla's, another mod's) instead of
|
||||
/// being one of its own. Vanilla data never has it.
|
||||
const ADD_TO: &str = "horizon:add_to";
|
||||
/// The bundles a mod may add to, and the list each entry goes into.
|
||||
const ADDABLE: [(&str, &str); 2] = [
|
||||
("worldgen/structure_sets.json", "structures"),
|
||||
("worldgen/template_pools.json", "elements"),
|
||||
];
|
||||
|
||||
/// A mod file's additions (`horizon:add_to`): its entries appended to the
|
||||
/// list of each set or pool it names, as lithostitched's
|
||||
/// `add_structure_set_entries` and `add_template_pool_elements` do for
|
||||
/// NeoForge and Fabric packs.
|
||||
struct Addition {
|
||||
targets: Vec<String>,
|
||||
list: &'static str,
|
||||
entries: Vec<J>,
|
||||
}
|
||||
impl Addition {
|
||||
/// What a mod file of `bundle` adds, if it is an addition file.
|
||||
fn read(bundle: &str, text: &str) -> Result<Option<Self>> {
|
||||
let Some((_, list)) = ADDABLE.iter().find(|(b, _)| *b == bundle) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if !text.contains(ADD_TO) {
|
||||
return Ok(None);
|
||||
}
|
||||
let doc: J = serde_json::from_str(text)?;
|
||||
let Some(targets) = doc.get(ADD_TO) else {
|
||||
return Ok(None);
|
||||
};
|
||||
let targets = match targets {
|
||||
J::Str(s) => vec![s.clone()],
|
||||
J::Arr(a) => a
|
||||
.iter()
|
||||
.map(|v| match v {
|
||||
J::Str(s) => Some(s.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Option<_>>()
|
||||
.ok_or(format!("{ADD_TO}: not a list of ids"))?,
|
||||
_ => return Err(format!("{ADD_TO}: not an id or a list of ids").into()),
|
||||
};
|
||||
let Some(J::Arr(entries)) = doc.get(list) else {
|
||||
return Err(format!("{ADD_TO} without a {list} list").into());
|
||||
};
|
||||
Ok(Some(Self {
|
||||
targets,
|
||||
list,
|
||||
entries: entries.clone(),
|
||||
}))
|
||||
}
|
||||
/// Appends the entries to each target in the bundle `doc` (id → the
|
||||
/// file's text). A target nobody defines is skipped, as a tag entry
|
||||
/// naming an unknown id is.
|
||||
fn apply(&self, doc: &mut J) -> Result<()> {
|
||||
for target in &self.targets {
|
||||
let Some(J::Str(text)) = doc.get(target) else {
|
||||
continue;
|
||||
};
|
||||
let mut v: J = serde_json::from_str(text).map_err(|e| format!("{target}: {e}"))?;
|
||||
let Some(J::Arr(list)) = v.get_mut(self.list) else {
|
||||
continue;
|
||||
};
|
||||
list.extend(self.entries.iter().cloned());
|
||||
doc.set(target, J::Str(serde_json::to_string(&v)?));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// The overlay being written: `out` mirrors `base` through links, and a
|
||||
/// directory becomes real only when something inside it is written.
|
||||
struct Overlay<'a> {
|
||||
@@ -904,6 +976,7 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
// Mod files, and every tag addition gathered per tag file.
|
||||
let mut tags: BTreeMap<String, Vec<J>> = BTreeMap::new();
|
||||
let mut worldgen: BTreeMap<&str, Vec<(String, String)>> = BTreeMap::new();
|
||||
let mut additions: BTreeMap<&str, Vec<Addition>> = BTreeMap::new();
|
||||
for m in mods {
|
||||
let declarations = format!("data/{}/horizon/", m.id);
|
||||
for file in &m.content.files {
|
||||
@@ -928,7 +1001,11 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
overlay.write(file, &bytes)?;
|
||||
if let Some((bundle, id)) = worldgen_entry(file) {
|
||||
let text = String::from_utf8(bytes).map_err(|e| format!("{file}: {e}"))?;
|
||||
worldgen.entry(bundle).or_default().push((id, text));
|
||||
let entries = worldgen.entry(bundle).or_default();
|
||||
match Addition::read(bundle, &text).map_err(|e| format!("{file}: {e}"))? {
|
||||
Some(addition) => additions.entry(bundle).or_default().push(addition),
|
||||
None => entries.push((id, text)),
|
||||
}
|
||||
} else if let Some(template) = file
|
||||
.strip_prefix("data/")
|
||||
.and_then(|r| r.split_once("/structure/"))
|
||||
@@ -1002,7 +1079,8 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
}
|
||||
overlay.write(BIOME_TAGS, &serde_json::to_vec(&doc)?)?;
|
||||
}
|
||||
// Structures and the pools, sets, processors and features they use.
|
||||
// Structures and the pools, sets, processors and features they use, then
|
||||
// what mods add to sets and pools, in mod and file order.
|
||||
for (bundle, entries) in &worldgen {
|
||||
if !base.join(bundle).exists() {
|
||||
continue;
|
||||
@@ -1011,6 +1089,11 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
for (id, text) in entries {
|
||||
doc.set(id, J::Str(text.clone()));
|
||||
}
|
||||
for addition in additions.get(bundle).into_iter().flatten() {
|
||||
addition
|
||||
.apply(&mut doc)
|
||||
.map_err(|e| format!("{bundle}: {e}"))?;
|
||||
}
|
||||
overlay.write(bundle, &serde_json::to_vec(&doc)?)?;
|
||||
}
|
||||
// A block without its own blockstate looks like its template, so every
|
||||
|
||||
@@ -576,6 +576,18 @@ fn content_root_carries_a_structure_mod() {
|
||||
"data/huts/tags/worldgen/biome/has_hut.json",
|
||||
r##"{"values": ["#minecraft:is_overworld", "#c:is_plains", "othermod:glade", "minecraft:plains"]}"##,
|
||||
),
|
||||
// Additions to vanilla's set and pool; a target nobody defines is skipped.
|
||||
(
|
||||
"data/huts/worldgen/structure_set/added/villages.json",
|
||||
r#"{"horizon:add_to": "minecraft:villages",
|
||||
"structures": [{"structure": "huts:hut", "weight": 3}]}"#,
|
||||
),
|
||||
(
|
||||
"data/huts/worldgen/template_pool/added/houses.json",
|
||||
r#"{"horizon:add_to": ["othermod:houses", "minecraft:village/plains/houses"],
|
||||
"elements": [{"weight": 2, "element": {"element_type": "minecraft:single_pool_element",
|
||||
"location": "huts:hut", "projection": "rigid", "processors": "minecraft:empty"}}]}"#,
|
||||
),
|
||||
];
|
||||
for (name, text) in files {
|
||||
let path = dir.join(name);
|
||||
@@ -601,6 +613,37 @@ fn content_root_carries_a_structure_mod() {
|
||||
hut["values"],
|
||||
serde_json::json!(["#minecraft:is_overworld", "minecraft:plains"])
|
||||
);
|
||||
// The additions join vanilla's entries at the end and are no set or pool
|
||||
// of their own.
|
||||
let bundle = |name: &str, base: &Path| -> BTreeMap<String, String> {
|
||||
serde_json::from_slice(&fs::read(base.join("worldgen").join(name)).unwrap()).unwrap()
|
||||
};
|
||||
for (name, id, list, added) in [
|
||||
(
|
||||
"structure_sets.json",
|
||||
"minecraft:villages",
|
||||
"structures",
|
||||
serde_json::json!({"structure": "huts:hut", "weight": 3}),
|
||||
),
|
||||
(
|
||||
"template_pools.json",
|
||||
"minecraft:village/plains/houses",
|
||||
"elements",
|
||||
serde_json::json!({"weight": 2, "element": {"element_type": "minecraft:single_pool_element",
|
||||
"location": "huts:hut", "projection": "rigid", "processors": "minecraft:empty"}}),
|
||||
),
|
||||
] {
|
||||
let (ours, vanilla) = (bundle(name, &root), bundle(name, &base));
|
||||
let entries = |text: &str| -> Vec<serde_json::Value> {
|
||||
let v: serde_json::Value = serde_json::from_str(text).unwrap();
|
||||
v[list].as_array().unwrap().clone()
|
||||
};
|
||||
let mut expected = entries(&vanilla[id]);
|
||||
expected.push(added);
|
||||
assert_eq!(entries(&ours[id]), expected, "{id}");
|
||||
assert!(!ours.keys().any(|k| k.starts_with("huts:added/")), "{name}");
|
||||
assert!(!ours.contains_key("othermod:houses"));
|
||||
}
|
||||
|
||||
let assets = Assets::load(&root).unwrap();
|
||||
let biomes = crate::biome::Biomes::load(&root).unwrap();
|
||||
|
||||
@@ -331,13 +331,16 @@ fn unreadable(name: &str, bytes: &mut Vec<u8>) -> Option<String> {
|
||||
|
||||
/// Carries `jar` over into `out/carry/`. With the oracle's `facts`, blocks
|
||||
/// and items are the ones the mod registers, with the templates and numbers
|
||||
/// the facts give; `allowed` says which vanilla blocks the game has.
|
||||
/// the facts give; `allowed` says which vanilla blocks the game has;
|
||||
/// `loaded` which mods are ported along, for the conditions of the mod's
|
||||
/// worldgen modifiers.
|
||||
pub fn carry(
|
||||
jar: &Path,
|
||||
info: &JarInfo,
|
||||
out: &Path,
|
||||
facts: Option<&Facts>,
|
||||
allowed: &dyn Fn(&str) -> bool,
|
||||
loaded: &dyn Fn(&str) -> bool,
|
||||
conventions: &BTreeMap<String, Value>,
|
||||
) -> Result<Report, String> {
|
||||
let id = &info.mod_id;
|
||||
@@ -363,6 +366,7 @@ pub fn carry(
|
||||
let mut block_loot = BTreeSet::new();
|
||||
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);
|
||||
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();
|
||||
@@ -422,11 +426,43 @@ pub fn carry(
|
||||
if kind == "structure" {
|
||||
crate::worldgen::convention_tags(&v["biomes"], &mut biome_conventions);
|
||||
}
|
||||
if crate::worldgen::upgrade(kind, &mut v, &mut report.worldgen_types, &set_tags)
|
||||
{
|
||||
let mut changed = crate::worldgen::upgrade(
|
||||
kind,
|
||||
&mut v,
|
||||
&mut report.worldgen_types,
|
||||
&set_tags,
|
||||
);
|
||||
if kind == "structure" {
|
||||
let path = rel.trim_start_matches("worldgen/structure/");
|
||||
let structure = format!("{id}:{}", path.trim_end_matches(".json"));
|
||||
changed |= crate::worldgen::disables(&structure, &mut v);
|
||||
changed |=
|
||||
crate::worldgen::add_piece_counts(&structure, &mut v, &piece_counts);
|
||||
}
|
||||
if changed {
|
||||
bytes = serde_json::to_vec_pretty(&v).unwrap_or(bytes);
|
||||
}
|
||||
}
|
||||
} else if let Some(path) = rel
|
||||
.strip_prefix("lithostitched/worldgen_modifier/")
|
||||
.filter(|_| name.starts_with("data/") && name.ends_with(".json"))
|
||||
{
|
||||
// Additions to other sets and pools, as files the game merges.
|
||||
let modifier = serde_json::from_slice::<Value>(&bytes).ok();
|
||||
let types = &mut report.worldgen_types;
|
||||
if let Some((kind, mut added)) =
|
||||
modifier.and_then(|v| crate::worldgen::modifier(&v, loaded, types))
|
||||
{
|
||||
crate::worldgen::upgrade(kind, &mut added, types, &set_tags);
|
||||
let to = format!(
|
||||
"data/{id}/worldgen/{kind}/{}/{path}",
|
||||
crate::worldgen::ADDED
|
||||
);
|
||||
write(
|
||||
&inside.join(to),
|
||||
&serde_json::to_vec_pretty(&added).unwrap_or_default(),
|
||||
)?;
|
||||
}
|
||||
} else if rel.starts_with("tags/worldgen/biome/") && name.starts_with("data/") {
|
||||
if let Ok(v) = serde_json::from_slice::<Value>(&bytes) {
|
||||
crate::worldgen::convention_tags(&v, &mut biome_conventions);
|
||||
@@ -462,6 +498,35 @@ pub fn carry(
|
||||
}
|
||||
write(&dest, &bytes)?;
|
||||
}
|
||||
// Entries the mod adds to other structure sets in Java code, for the
|
||||
// structures it has.
|
||||
for (file, set, entries) in crate::worldgen::code_set_entries(id) {
|
||||
let entries: Vec<Value> = entries
|
||||
.into_iter()
|
||||
.filter(|(s, _)| {
|
||||
s.split_once(':').is_some_and(|(ns, path)| {
|
||||
inside
|
||||
.join(format!("data/{ns}/worldgen/structure/{path}.json"))
|
||||
.exists()
|
||||
})
|
||||
})
|
||||
.map(|(structure, weight)| json!({"structure": structure, "weight": weight}))
|
||||
.collect();
|
||||
if entries.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let added = &mut report.worldgen_types.added_to;
|
||||
*added.entry(set.to_owned()).or_default() += entries.len();
|
||||
let to = format!(
|
||||
"data/{id}/worldgen/structure_set/{}/{file}.json",
|
||||
crate::worldgen::ADDED
|
||||
);
|
||||
let v = json!({"horizon:add_to": set, "structures": entries});
|
||||
write(
|
||||
&inside.join(to),
|
||||
&serde_json::to_vec_pretty(&v).unwrap_or_default(),
|
||||
)?;
|
||||
}
|
||||
// 1.21.4 moved item models behind `items/<name>.json` definitions.
|
||||
for m in &item_models {
|
||||
let def = inside.join(format!("assets/{id}/items/{m}.json"));
|
||||
@@ -832,6 +897,14 @@ mod tests {
|
||||
r#"{"values": ["gem:gem_block"]}"#,
|
||||
),
|
||||
("data/c/tags/item/gems.json", r#"{"values": ["gem:gem"]}"#),
|
||||
(
|
||||
"data/gem/lithostitched/worldgen_modifier/houses.json",
|
||||
r#"{"type": "lithostitched:add_template_pool_elements",
|
||||
"template_pools": "minecraft:village/plains/houses",
|
||||
"elements": [{"weight": 2, "element": {"element_type": "minecraft:single_pool_element",
|
||||
"location": "gem:hut", "projection": "rigid",
|
||||
"processors": {"processors": [{"processor_type": "lithostitched:block_swap"}]}}}]}"#,
|
||||
),
|
||||
// What the game would refuse: vanilla skips these files alone.
|
||||
("assets/gem/lang/ry_UA.json", r#"{"item.gem.gem": "Gem"}"#),
|
||||
("data/gem/tags/item/empty.json", ""),
|
||||
@@ -858,8 +931,17 @@ mod tests {
|
||||
);
|
||||
assert_eq!(info.census.classes, 1);
|
||||
let out = dir.join("work/mods/gem");
|
||||
let report = carry(&jar, &info, &out, None, &|_| true, &BTreeMap::new()).unwrap();
|
||||
assert_eq!(report.copied, 13);
|
||||
let report = carry(
|
||||
&jar,
|
||||
&info,
|
||||
&out,
|
||||
None,
|
||||
&|_| true,
|
||||
&|_| true,
|
||||
&BTreeMap::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(report.copied, 14);
|
||||
let unreadable: Vec<&str> = report.unreadable.keys().map(String::as_str).collect();
|
||||
assert_eq!(
|
||||
unreadable,
|
||||
@@ -892,6 +974,25 @@ mod tests {
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(recipe["key"]["#"], "gem:gem");
|
||||
// A lithostitched pool addition, as a file the game merges, upgraded
|
||||
// as the mod's own pools are.
|
||||
let added: Value = serde_json::from_slice(
|
||||
&fs::read(carried.join("data/gem/worldgen/template_pool/horizon_added/houses.json"))
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
added["horizon:add_to"],
|
||||
json!(["minecraft:village/plains/houses"])
|
||||
);
|
||||
assert_eq!(
|
||||
added["elements"][0]["element"]["processors"],
|
||||
json!({"processors": []})
|
||||
);
|
||||
assert_eq!(
|
||||
report.worldgen_types.added_to["minecraft:village/plains/houses"],
|
||||
1
|
||||
);
|
||||
|
||||
// Horizon's own reader accepts it: blocks and items declared, files fenced.
|
||||
let package = horizon_mods::Package::read(&carried).unwrap();
|
||||
|
||||
@@ -120,13 +120,27 @@ pub fn carry(
|
||||
});
|
||||
let allowed = |b: &str| vanilla.as_ref().is_none_or(|v| v.contains(b));
|
||||
let conventions = crate::worldgen::loader_biome_tags(work);
|
||||
let mut done = 0;
|
||||
for r in &records {
|
||||
let chosen = if only.is_empty() {
|
||||
let chosen = |r: &inventory::Record| {
|
||||
if only.is_empty() {
|
||||
r.class == "content"
|
||||
} else {
|
||||
only.contains(&r.key)
|
||||
};
|
||||
}
|
||||
};
|
||||
// The mods ported along (carried now or before), for the conditions of
|
||||
// the mods' worldgen modifiers.
|
||||
let ported: BTreeSet<&str> = records
|
||||
.iter()
|
||||
.filter(|r| {
|
||||
r.jar.is_some() && (chosen(r) || work.join("mods").join(&r.key).join("carry").is_dir())
|
||||
})
|
||||
.filter_map(|r| Some(r.info.as_ref()?.mod_id.as_str()))
|
||||
.chain(["minecraft"])
|
||||
.collect();
|
||||
let loaded = |m: &str| ported.contains(m);
|
||||
let mut done = 0;
|
||||
for r in &records {
|
||||
let chosen = chosen(r);
|
||||
let (Some(jar), Some(info)) = (&r.jar, &r.info) else {
|
||||
if chosen && !only.is_empty() {
|
||||
log(format!(
|
||||
@@ -155,6 +169,7 @@ pub fn carry(
|
||||
&work.join("mods").join(&r.key),
|
||||
facts.as_ref().filter(seen),
|
||||
&allowed,
|
||||
&loaded,
|
||||
&conventions,
|
||||
) {
|
||||
Ok(report) => {
|
||||
|
||||
@@ -26,11 +26,53 @@ const JIGSAWS: [&str; 3] = [
|
||||
"moogs_structures:moogs_structures_generic_jigsaw_structure",
|
||||
"repurposed_structures:generic_jigsaw_structure",
|
||||
];
|
||||
/// The Nether variants of the piece-limited jigsaws: laid out the same,
|
||||
/// then moved onto land.
|
||||
const NETHER_JIGSAWS: [&str; 2] = [
|
||||
"moogs_structures:moogs_structures_generic_nether_jigsaw_structure",
|
||||
"repurposed_structures:generic_nether_jigsaw_structure",
|
||||
];
|
||||
/// Layout rules the piece-limited assembler keeps (`horizon:piece_limited`).
|
||||
const PIECE_LIMITED_RULES: [&str; 4] = [
|
||||
"y_allowance",
|
||||
"burying_type",
|
||||
"use_bounding_box_hack",
|
||||
"pools_that_ignore_boundaries",
|
||||
];
|
||||
/// Placements that are vanilla's random spread with extra rules.
|
||||
const SPREADS: [&str; 2] = [
|
||||
"moogs_structures:advanced_random_spread",
|
||||
"repurposed_structures:advanced_random_spread",
|
||||
];
|
||||
/// YUNG's placements: vanilla's random spread with an enhanced exclusion
|
||||
/// zone (several sets), plus, for the temples, no start near an ocean or a
|
||||
/// river, and for strongholds, starts only in odd rings around the origin.
|
||||
const YUNG_SPREADS: [&str; 4] = [
|
||||
"yungsapi:enhanced_random_spread",
|
||||
"betterdeserttemples:desert_temple",
|
||||
"betterjungletemples:jungle_temple",
|
||||
"betterstrongholds:stronghold",
|
||||
];
|
||||
/// YUNG's structures and the vanilla structure type each one's mod turns
|
||||
/// off (its DisableVanilla*Mixin, on by default in each mod's config).
|
||||
const YUNG_REPLACES: [(&str, &str); 7] = [
|
||||
(
|
||||
"betterdeserttemples:desert_temple",
|
||||
"minecraft:desert_pyramid",
|
||||
),
|
||||
(
|
||||
"betterjungletemples:jungle_temple",
|
||||
"minecraft:jungle_temple",
|
||||
),
|
||||
("betterwitchhuts:witch_hut", "minecraft:swamp_hut"),
|
||||
(
|
||||
"betteroceanmonuments:ocean_monument",
|
||||
"minecraft:ocean_monument",
|
||||
),
|
||||
("betterstrongholds:stronghold", "minecraft:stronghold"),
|
||||
("betterfortresses:fortress", "minecraft:fortress"),
|
||||
("bettermineshafts:mineshaft_", "minecraft:mineshaft"),
|
||||
];
|
||||
/// Moog's Structure Lib spreads its structures 1.65 times as far apart as
|
||||
/// its files say (AdvancedRandomSpread's constructor).
|
||||
const MOOGS_SPACING: f64 = 1.65;
|
||||
@@ -76,6 +118,206 @@ pub struct Upgrade {
|
||||
pub rules_lost: BTreeMap<String, usize>,
|
||||
/// Processors written in Java, taken out of their lists, by type.
|
||||
pub processors_dropped: BTreeMap<String, usize>,
|
||||
/// Entries added to other structure sets and template pools
|
||||
/// (`horizon:add_to`), by the set or pool they join.
|
||||
pub added_to: BTreeMap<String, usize>,
|
||||
/// Lithostitched worldgen modifiers not carried: by type, `conditions`
|
||||
/// when they need a mod that is not ported along, `target` when they
|
||||
/// name their sets or pools by a tag.
|
||||
pub modifiers_left: BTreeMap<String, usize>,
|
||||
}
|
||||
|
||||
/// Where a mod's additions to other sets and pools go in its carry:
|
||||
/// `data/<id>/worldgen/<kind>/horizon_added/<name>.json`.
|
||||
pub const ADDED: &str = "horizon_added";
|
||||
|
||||
/// A lithostitched worldgen modifier
|
||||
/// (`data/<ns>/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 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<Vec<&str>> = 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
|
||||
}
|
||||
|
||||
/// ChoiceTheorem's Overhauled Village's villages and outposts, which it adds
|
||||
/// to vanilla's `villages` and `pillager_outposts` sets in Java code
|
||||
/// (`CTOV.registerstructure`, through lithostitched), with its default
|
||||
/// config: every village type in three sizes, weighted 10, 4 and 1, and
|
||||
/// every outpost weighted 1. Vanilla's own entries stay (weight 1 each).
|
||||
const CTOV_VILLAGES: [&str; 21] = [
|
||||
"beach",
|
||||
"christmas",
|
||||
"desert",
|
||||
"desert_oasis",
|
||||
"dark_forest",
|
||||
"jungle",
|
||||
"jungle_tree",
|
||||
"mesa",
|
||||
"mesa_fortified",
|
||||
"mountain",
|
||||
"mountain_alpine",
|
||||
"mushroom",
|
||||
"plains",
|
||||
"plains_fortified",
|
||||
"savanna",
|
||||
"savanna_na",
|
||||
"snowy_igloo",
|
||||
"swamp",
|
||||
"swamp_fortified",
|
||||
"taiga",
|
||||
"taiga_fortified",
|
||||
];
|
||||
const CTOV_OUTPOSTS: [&str; 11] = [
|
||||
"beach",
|
||||
"dark_forest",
|
||||
"desert",
|
||||
"jungle",
|
||||
"badlands",
|
||||
"mountain",
|
||||
"plains",
|
||||
"savanna",
|
||||
"snowy",
|
||||
"swamp",
|
||||
"taiga",
|
||||
];
|
||||
|
||||
/// The entries a mod adds to other structure sets in Java code, as its
|
||||
/// default config has them: (file name, set, `[(structure, weight)]`).
|
||||
/// Lithostitched appends them in the order of a hash map of every modifier
|
||||
/// in the pack, which carry cannot know; they are written in the order the
|
||||
/// mod registers them. Each set picks by weight, so how often each starts
|
||||
/// is the same.
|
||||
pub fn code_set_entries(mod_id: &str) -> Vec<(&'static str, &'static str, Vec<(String, u32)>)> {
|
||||
match mod_id {
|
||||
"ctov" => {
|
||||
let outposts = CTOV_OUTPOSTS
|
||||
.iter()
|
||||
.map(|v| (format!("ctov:pillager_outpost_{v}"), 1))
|
||||
.collect();
|
||||
let villages = [("small", 10), ("medium", 4), ("large", 1)]
|
||||
.into_iter()
|
||||
.flat_map(|(size, weight)| {
|
||||
CTOV_VILLAGES
|
||||
.iter()
|
||||
.map(move |v| (format!("ctov:{size}/village_{v}"), weight))
|
||||
})
|
||||
.collect();
|
||||
vec![
|
||||
("pillager_outposts", "minecraft:pillager_outposts", outposts),
|
||||
("villages", "minecraft:villages", villages),
|
||||
]
|
||||
}
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Rewrites one `data/<ns>/worldgen/<kind>/...` file in place; whether it
|
||||
@@ -180,12 +422,26 @@ fn upgrade_types(
|
||||
let mut unsupported = |t: &str| *report.unsupported.entry(t.to_owned()).or_default() += 1;
|
||||
let changed = match kind {
|
||||
"structure" => match v["type"].as_str() {
|
||||
Some(t) if JIGSAWS.contains(&t) => {
|
||||
let liquid = match t.split_once(':').map(|(ns, _)| ns) {
|
||||
Some("moogs_structures") => "top",
|
||||
_ => "lowest",
|
||||
Some("yungsapi:yung_jigsaw") => {
|
||||
yung_structure(v, lost);
|
||||
true
|
||||
}
|
||||
Some(t) if JIGSAWS.contains(&t) || NETHER_JIGSAWS.contains(&t) => {
|
||||
let library = match t.split_once(':').map(|(ns, _)| ns) {
|
||||
Some("moogs_structures") => Some("moogs"),
|
||||
Some("repurposed_structures") => Some("repurposed"),
|
||||
_ => None,
|
||||
};
|
||||
start_checks(v, liquid, lost);
|
||||
let liquid = if library == Some("moogs") {
|
||||
"top"
|
||||
} else {
|
||||
"lowest"
|
||||
};
|
||||
let limited = library.map(|l| piece_limited(v, l));
|
||||
start_checks(v, liquid, lost, limited.is_some());
|
||||
if let Some(limited) = limited {
|
||||
v["horizon:piece_limited"] = limited;
|
||||
}
|
||||
v["type"] = "minecraft:jigsaw".into();
|
||||
true
|
||||
}
|
||||
@@ -206,6 +462,11 @@ fn upgrade_types(
|
||||
p["type"] = "minecraft:random_spread".into();
|
||||
true
|
||||
}
|
||||
Some(t) if YUNG_SPREADS.contains(&t) => {
|
||||
let t = t.to_owned();
|
||||
yung_placement(&t, &mut v["placement"], set_tags, lost);
|
||||
true
|
||||
}
|
||||
Some(t) if !t.starts_with("minecraft:") => {
|
||||
unsupported(t);
|
||||
false
|
||||
@@ -231,6 +492,9 @@ fn upgrade_types(
|
||||
if let Some((_, to)) = ELEMENTS.iter().find(|(from, _)| *from == t) {
|
||||
element["element_type"] = (*to).into();
|
||||
changed = true;
|
||||
} else if t == "yungsapi:yung_single_element" {
|
||||
yung_element(element, lost);
|
||||
changed = true;
|
||||
} else if !t.starts_with("minecraft:") {
|
||||
unsupported(t);
|
||||
}
|
||||
@@ -243,10 +507,122 @@ fn upgrade_types(
|
||||
changed
|
||||
}
|
||||
|
||||
/// YUNG's API's jigsaw as vanilla's, laid out by its own assembler in the
|
||||
/// game (`horizon:yungsapi`, `horizon_world::worldgen::structure::yung`):
|
||||
/// the heights pieces stay within move under the key. Its terrain
|
||||
/// adaptation and a start offset in the chunk are lost.
|
||||
fn yung_structure(v: &mut Value, lost: &mut BTreeMap<String, usize>) {
|
||||
let Some(o) = v.as_object_mut() else {
|
||||
return;
|
||||
};
|
||||
o.insert("type".into(), "minecraft:jigsaw".into());
|
||||
let mut rules = serde_json::Map::new();
|
||||
for key in ["min_y", "max_y"] {
|
||||
if let Some(y) = o.remove(key) {
|
||||
rules.insert(key.into(), y);
|
||||
}
|
||||
}
|
||||
let none = |a: &Value| a["type"] == "yungsapi:none";
|
||||
if o.remove("enhanced_terrain_adaptation")
|
||||
.is_some_and(|a| !none(&a))
|
||||
{
|
||||
*lost
|
||||
.entry("enhanced_terrain_adaptation".into())
|
||||
.or_default() += 1;
|
||||
}
|
||||
for key in ["x_offset_in_chunk", "z_offset_in_chunk"] {
|
||||
if o.remove(key).is_some_and(|n| n != 0) {
|
||||
*lost.entry(key.into()).or_default() += 1;
|
||||
}
|
||||
}
|
||||
o.insert("horizon:yungsapi".into(), rules.into());
|
||||
}
|
||||
|
||||
/// YUNG's single pool element as vanilla's, its rules under
|
||||
/// `horizon:yungsapi`: name and `max_count`, depth range, priority,
|
||||
/// `ignore_bounds` and its condition. Its terrain adaptation, dead-end pool
|
||||
/// and modifiers are lost.
|
||||
fn yung_element(element: &mut Value, lost: &mut BTreeMap<String, usize>) {
|
||||
let Some(o) = element.as_object_mut() else {
|
||||
return;
|
||||
};
|
||||
o.insert(
|
||||
"element_type".into(),
|
||||
"minecraft:single_pool_element".into(),
|
||||
);
|
||||
let mut rules = serde_json::Map::new();
|
||||
for (from, to) in [
|
||||
("name", "name"),
|
||||
("max_count", "max_count"),
|
||||
("min_required_depth", "min_depth"),
|
||||
("max_possible_depth", "max_depth"),
|
||||
("is_priority", "priority"),
|
||||
("ignore_bounds", "ignore_bounds"),
|
||||
] {
|
||||
if let Some(x) = o.remove(from) {
|
||||
rules.insert(to.into(), x);
|
||||
}
|
||||
}
|
||||
if let Some(c) = o.remove("condition") {
|
||||
rules.insert("condition".into(), yung_condition(&c, lost));
|
||||
}
|
||||
for key in ["enhanced_terrain_adaptation", "deadend_pool", "modifiers"] {
|
||||
let empty =
|
||||
|x: &Value| x.as_array().is_some_and(Vec::is_empty) || x["type"] == "yungsapi:none";
|
||||
if o.remove(key).is_some_and(|x| !empty(&x)) {
|
||||
*lost.entry(format!("yungsapi {key}")).or_default() += 1;
|
||||
}
|
||||
}
|
||||
o.insert("horizon:yungsapi".into(), rules.into());
|
||||
}
|
||||
|
||||
/// One of YUNG's structure conditions in the game's terms. `mod_loaded`
|
||||
/// holds for Minecraft alone: a mod that needs code is not ported, and the
|
||||
/// pieces it guards would place its blocks. A condition the game does not
|
||||
/// have does not hold, and is counted.
|
||||
fn yung_condition(c: &Value, lost: &mut BTreeMap<String, usize>) -> Value {
|
||||
let t = c["type"].as_str().unwrap_or_default();
|
||||
let list = |lost: &mut BTreeMap<String, usize>| -> Value {
|
||||
let all = c["conditions"].as_array().into_iter().flatten();
|
||||
all.map(|x| yung_condition(x, lost))
|
||||
.collect::<Vec<_>>()
|
||||
.into()
|
||||
};
|
||||
let opt = |k: &str| c.get(k).cloned().unwrap_or(Value::Null);
|
||||
match t.trim_start_matches("yungsapi:") {
|
||||
"always_true" => serde_json::json!({"type": "true"}),
|
||||
"not" => {
|
||||
serde_json::json!({"type": "not", "condition": yung_condition(&c["condition"], lost)})
|
||||
}
|
||||
"all_of" => serde_json::json!({"type": "all_of", "conditions": list(lost)}),
|
||||
"any_of" => serde_json::json!({"type": "any_of", "conditions": list(lost)}),
|
||||
"depth" => serde_json::json!({"type": "depth",
|
||||
"min_depth": opt("min_required_depth"), "max_depth": opt("max_possible_depth")}),
|
||||
"altitude" => serde_json::json!({"type": "altitude",
|
||||
"bottom": opt("bottom_cutoff_y"), "top": opt("top_cutoff_y")}),
|
||||
"random_chance" => serde_json::json!({"type": "random_chance", "chance": opt("chance")}),
|
||||
"rotation" => serde_json::json!({"type": "rotation", "rotations": opt("rotations")}),
|
||||
"piece_in_horizontal_direction" => {
|
||||
// "yungsapi:all" (or no list) matches any piece.
|
||||
let pieces: Vec<Value> = c["pieces"].as_array().cloned().unwrap_or_default();
|
||||
let any = pieces.is_empty() || pieces.iter().any(|p| p == "yungsapi:all");
|
||||
serde_json::json!({"type": "piece_in_horizontal_direction",
|
||||
"pieces": if any { Vec::new() } else { pieces },
|
||||
"range": opt("range"), "rotation": opt("rotation")})
|
||||
}
|
||||
"mod_loaded" if c["modid"] == "minecraft" => serde_json::json!({"type": "true"}),
|
||||
"mod_loaded" => serde_json::json!({"type": "false"}),
|
||||
_ => {
|
||||
*lost.entry(format!("yungsapi condition {t}")).or_default() += 1;
|
||||
serde_json::json!({"type": "false"})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Moves a Repurposed Structures or Moog's jigsaw's start rules under
|
||||
/// `horizon:start_checks`, and counts the layout rules it loses. `liquid` is
|
||||
/// the block its no-start-in-liquid rule reads.
|
||||
fn start_checks(v: &mut Value, liquid: &str, lost: &mut BTreeMap<String, usize>) {
|
||||
fn start_checks(v: &mut Value, liquid: &str, lost: &mut BTreeMap<String, usize>, limited: bool) {
|
||||
let Some(o) = v.as_object_mut() else {
|
||||
return;
|
||||
};
|
||||
@@ -267,7 +643,8 @@ fn start_checks(v: &mut Value, liquid: &str, lost: &mut BTreeMap<String, usize>)
|
||||
}
|
||||
}
|
||||
for rule in LAYOUT_RULES {
|
||||
if o.remove(rule).is_some_and(|r| r != Value::Bool(false)) {
|
||||
let kept = limited && PIECE_LIMITED_RULES.contains(&rule);
|
||||
if o.remove(rule).is_some_and(|r| r != Value::Bool(false)) && !kept {
|
||||
*lost.entry(rule.into()).or_default() += 1;
|
||||
}
|
||||
}
|
||||
@@ -276,6 +653,121 @@ fn start_checks(v: &mut Value, liquid: &str, lost: &mut BTreeMap<String, usize>)
|
||||
}
|
||||
}
|
||||
|
||||
/// A Repurposed Structures or Moog's jigsaw's layout rules for the game's
|
||||
/// piece-limited assembler: y_allowance, burying, the pools whose fallbacks
|
||||
/// ignore the bounds, liquid, and the Nether variants' land search. The
|
||||
/// bounding box hack is vanilla's expansion hack. The pieces' counts are
|
||||
/// added from the mod's count files ([`piece_counts`]).
|
||||
fn piece_limited(v: &mut Value, library: &str) -> Value {
|
||||
let mut out = serde_json::Map::new();
|
||||
out.insert("library".into(), library.into());
|
||||
let lower = |x: &Value| x.as_str().map(str::to_ascii_lowercase);
|
||||
for (from, to) in [("min_y_allowed", "min_y"), ("max_y_allowed", "max_y")] {
|
||||
if let Some(n) = v.get("y_allowance").and_then(|y| y.get(from)) {
|
||||
out.insert(to.into(), n.clone());
|
||||
}
|
||||
}
|
||||
if let Some(b) = v.get("burying_type").and_then(lower) {
|
||||
out.insert("burying".into(), b.into());
|
||||
}
|
||||
if v["cannot_spawn_in_liquid"].as_bool() == Some(true) {
|
||||
out.insert("no_liquid".into(), true.into());
|
||||
}
|
||||
if let Some(pools) = v
|
||||
.get("pools_that_ignore_boundaries")
|
||||
.filter(|p| p.is_array())
|
||||
{
|
||||
out.insert("ignore_bounds_pools".into(), pools.clone());
|
||||
}
|
||||
if v["use_bounding_box_hack"].as_bool() == Some(true) {
|
||||
v["use_expansion_hack"] = true.into();
|
||||
}
|
||||
if let Some(o) = v.as_object_mut() {
|
||||
if let Some(search) = o.remove("land_search_direction") {
|
||||
out.insert("land_search".into(), lower(&search).into());
|
||||
}
|
||||
if let Some(ledge) = o.remove("ledge_offset_y") {
|
||||
out.insert("ledge_offset_y".into(), ledge);
|
||||
}
|
||||
}
|
||||
out.into()
|
||||
}
|
||||
|
||||
/// The pieces' spawn counts of the structures a mod ships, by structure id:
|
||||
/// Repurposed Structures' `rs_pieces_spawn_counts` (each file names its
|
||||
/// `target_structure`) and Moog's `msl_pieces_spawn_counts` (the file's id),
|
||||
/// in the game's `horizon:piece_limited` shape.
|
||||
pub fn piece_counts<R: Read + std::io::Seek>(
|
||||
zip: &mut zip::ZipArchive<R>,
|
||||
) -> BTreeMap<String, Value> {
|
||||
let mut out = BTreeMap::new();
|
||||
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 (rs, path) = if let Some(p) = rest.strip_prefix("rs_pieces_spawn_counts/") {
|
||||
(true, p)
|
||||
} else if let Some(p) = rest.strip_prefix("msl_pieces_spawn_counts/") {
|
||||
(false, p)
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
let mut text = String::new();
|
||||
let Ok(v) = entry
|
||||
.read_to_string(&mut text)
|
||||
.map_err(|_| ())
|
||||
.and_then(|_| serde_json::from_str::<Value>(&text).map_err(|_| ()))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let id = match v["target_structure"].as_str() {
|
||||
Some(target) if rs => target.to_owned(),
|
||||
_ if rs => continue,
|
||||
_ => format!("{ns}:{path}"),
|
||||
};
|
||||
let pieces: Vec<Value> = v["pieces_spawn_counts"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|p| {
|
||||
let mut e = serde_json::Map::new();
|
||||
e.insert("name".into(), p["nbt_piece_name"].as_str()?.into());
|
||||
for (from, to) in [
|
||||
("always_spawn_this_many", "required"),
|
||||
("never_spawn_more_than_this_many", "max"),
|
||||
("minimum_distance_from_center_piece", "min_depth"),
|
||||
] {
|
||||
if let Some(n) = p.get(from).filter(|n| n.is_number()) {
|
||||
e.insert(to.into(), n.clone());
|
||||
}
|
||||
}
|
||||
Some(Value::Object(e))
|
||||
})
|
||||
.collect();
|
||||
out.insert(id, pieces.into());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Adds a structure's piece counts to its `horizon:piece_limited` key.
|
||||
pub fn add_piece_counts(id: &str, v: &mut Value, counts: &BTreeMap<String, Value>) -> bool {
|
||||
match (counts.get(id), v.get_mut("horizon:piece_limited")) {
|
||||
(Some(pieces), Some(limited)) => {
|
||||
limited["pieces"] = pieces.clone();
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// AdvancedRandomSpread's spacing and separation, as Moog's computes them
|
||||
/// with its default config: 1.65 times the file's, rounded, the separation
|
||||
/// below the spacing. `when_replacing` (other numbers while a preset
|
||||
@@ -306,7 +798,10 @@ fn placement_rules(
|
||||
if let Some(d) = o.remove("min_distance_from_world_origin") {
|
||||
o.insert("horizon:min_distance_from_world_origin".into(), d);
|
||||
}
|
||||
if let Some(zone) = o.remove("super_exclusion_zone") {
|
||||
let zone = ["super_exclusion_zone", "enhanced_exclusion_zone"]
|
||||
.into_iter()
|
||||
.find_map(|k| Some((k, o.remove(k)?)));
|
||||
if let Some((key, zone)) = zone {
|
||||
let sets: Vec<String> = match &zone["other_set"] {
|
||||
Value::String(s) => match s.strip_prefix('#') {
|
||||
Some(tag) => set_tags.get(tag).cloned().unwrap_or_default(),
|
||||
@@ -319,7 +814,7 @@ fn placement_rules(
|
||||
_ => Vec::new(),
|
||||
};
|
||||
if sets.is_empty() {
|
||||
*lost.entry("super_exclusion_zone".into()).or_default() += 1;
|
||||
*lost.entry(key.into()).or_default() += 1;
|
||||
} else {
|
||||
o.insert(
|
||||
"horizon:exclusion_zone".into(),
|
||||
@@ -329,6 +824,65 @@ fn placement_rules(
|
||||
}
|
||||
}
|
||||
|
||||
/// One of YUNG's placements as vanilla's random spread with `horizon:` keys:
|
||||
/// the enhanced exclusion zone as `horizon:exclusion_zone`; the temples'
|
||||
/// ocean and river search (findBiomeHorizontal around the chunk's middle
|
||||
/// block at y 120, 48 blocks, every 2 quarts) as `horizon:avoid_biomes`; the
|
||||
/// strongholds' rings as `horizon:ring_sections`.
|
||||
fn yung_placement(
|
||||
t: &str,
|
||||
p: &mut Value,
|
||||
set_tags: &BTreeMap<String, Vec<String>>,
|
||||
lost: &mut BTreeMap<String, usize>,
|
||||
) {
|
||||
placement_rules(p, set_tags, lost);
|
||||
p["type"] = "minecraft:random_spread".into();
|
||||
let Some(o) = p.as_object_mut() else {
|
||||
return;
|
||||
};
|
||||
match t {
|
||||
"betterdeserttemples:desert_temple" | "betterjungletemples:jungle_temple" => {
|
||||
o.insert(
|
||||
"horizon:avoid_biomes".into(),
|
||||
serde_json::json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"],
|
||||
"radius": 48, "step": 2, "y": 120}),
|
||||
);
|
||||
}
|
||||
"betterstrongholds:stronghold" => {
|
||||
let mut rings = serde_json::Map::new();
|
||||
for (from, to) in [
|
||||
("chunk_distance_to_first_ring", "distance_to_first_ring"),
|
||||
("ring_chunk_thickness", "thickness"),
|
||||
("max_ring_section", "max_section"),
|
||||
] {
|
||||
if let Some(n) = o.remove(from) {
|
||||
rings.insert(to.into(), n);
|
||||
}
|
||||
}
|
||||
o.insert("horizon:ring_sections".into(), rings.into());
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// Marks a YUNG's structure that the game can start (its type is vanilla's
|
||||
/// after the upgrade) with the vanilla type its mod turns off, under
|
||||
/// `horizon:disables`. One the game cannot start leaves the vanilla
|
||||
/// structure in place, so the world keeps one of the two.
|
||||
pub fn disables(id: &str, v: &mut Value) -> bool {
|
||||
let Some((_, vanilla)) = YUNG_REPLACES.iter().find(|(s, _)| id.starts_with(s)) else {
|
||||
return false;
|
||||
};
|
||||
if !v["type"]
|
||||
.as_str()
|
||||
.is_some_and(|t| t.starts_with("minecraft:"))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
v["horizon:disables"] = serde_json::json!([vanilla]);
|
||||
true
|
||||
}
|
||||
|
||||
/// The mod's structure set tags (`data/<ns>/tags/worldgen/structure_set/`),
|
||||
/// by tag id, with the tags they include expanded. Optional entries
|
||||
/// (`{"id": ..., "required": false}`) count as their id.
|
||||
@@ -476,9 +1030,8 @@ mod tests {
|
||||
let mut s = json!({"type": "lithostitched:jigsaw", "start_pool": "a:b"});
|
||||
assert!(upgrade("structure", &mut s, &mut report, &NO_TAGS));
|
||||
assert_eq!(s["type"], "minecraft:jigsaw");
|
||||
let mut nether =
|
||||
json!({"type": "moogs_structures:moogs_structures_generic_nether_jigsaw_structure"});
|
||||
assert!(!upgrade("structure", &mut nether, &mut report, &NO_TAGS));
|
||||
let mut formation = json!({"type": "formations:simple"});
|
||||
assert!(!upgrade("structure", &mut formation, &mut report, &NO_TAGS));
|
||||
let mut set = json!({"placement": {"type": "moogs_structures:advanced_random_spread",
|
||||
"spacing": 10, "separation": 5, "min_distance_from_world_origin": 250}});
|
||||
assert!(upgrade("structure_set", &mut set, &mut report, &NO_TAGS));
|
||||
@@ -499,7 +1052,7 @@ mod tests {
|
||||
{"weight": 1, "element": {"element_type": "moogs_structures:versioned_single_pool_element", "location": "m:x"}},
|
||||
{"weight": 1, "element": {"element_type": "minecraft:list_pool_element", "elements": [
|
||||
{"element_type": "empty_pool_element"}]}},
|
||||
{"weight": 1, "element": {"element_type": "yungsapi:yung_single_element"}}
|
||||
{"weight": 1, "element": {"element_type": "somelib:element"}}
|
||||
]});
|
||||
assert!(upgrade("template_pool", &mut pool, &mut report, &NO_TAGS));
|
||||
assert_eq!(
|
||||
@@ -515,11 +1068,8 @@ mod tests {
|
||||
assert_eq!(
|
||||
report.unsupported,
|
||||
BTreeMap::from([
|
||||
(
|
||||
"moogs_structures:moogs_structures_generic_nether_jigsaw_structure".into(),
|
||||
1
|
||||
),
|
||||
("yungsapi:yung_single_element".into(), 1),
|
||||
("formations:simple".into(), 1),
|
||||
("somelib:element".into(), 1),
|
||||
])
|
||||
);
|
||||
}
|
||||
@@ -556,9 +1106,12 @@ mod tests {
|
||||
let mut plain = json!({"type": "lithostitched:jigsaw", "cannot_spawn_in_liquid": false});
|
||||
assert!(upgrade("structure", &mut plain, &mut report, &NO_TAGS));
|
||||
assert!(plain.get("horizon:start_checks").is_none());
|
||||
// The layout rules go to the piece-limited assembler.
|
||||
assert!(report.rules_lost.is_empty());
|
||||
assert_eq!(
|
||||
report.rules_lost,
|
||||
BTreeMap::from([("burying_type".into(), 1), ("y_allowance".into(), 1)])
|
||||
moogs["horizon:piece_limited"],
|
||||
json!({"library": "moogs", "min_y": 60, "burying": "lowest_corner",
|
||||
"no_liquid": true})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -599,6 +1152,52 @@ mod tests {
|
||||
assert_eq!(report.rules_lost["super_exclusion_zone"], 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn yungs_jigsaws_keep_their_rules() {
|
||||
let mut report = Upgrade::default();
|
||||
let mut s = json!({"type": "yungsapi:yung_jigsaw", "start_pool": "y:start", "size": 20,
|
||||
"max_y": 60, "x_offset_in_chunk": 0, "max_distance_from_center": 80,
|
||||
"enhanced_terrain_adaptation": {"type": "yungsapi:custom", "kernel_size": 24}});
|
||||
assert!(upgrade("structure", &mut s, &mut report, &NO_TAGS));
|
||||
assert_eq!(s["type"], "minecraft:jigsaw");
|
||||
assert_eq!(s["horizon:yungsapi"], json!({"max_y": 60}));
|
||||
for gone in ["max_y", "x_offset_in_chunk", "enhanced_terrain_adaptation"] {
|
||||
assert!(s.get(gone).is_none(), "{gone}");
|
||||
}
|
||||
let mut pool = json!({"elements": [{"weight": 3, "element": {
|
||||
"element_type": "yungsapi:yung_single_element", "location": "y:room",
|
||||
"processors": "minecraft:empty", "projection": "rigid",
|
||||
"name": "room", "max_count": 2, "min_required_depth": 1, "is_priority": true,
|
||||
"ignore_bounds": false, "deadend_pool": "y:end",
|
||||
"condition": {"type": "yungsapi:all_of", "conditions": [
|
||||
{"type": "yungsapi:piece_in_horizontal_direction", "pieces": ["yungsapi:all"],
|
||||
"range": 5, "rotation": "none"},
|
||||
{"type": "yungsapi:not", "condition": {"type": "yungsapi:mod_loaded", "modid": "create"}},
|
||||
{"type": "yungsapi:biome", "biomes": []}]}}}]});
|
||||
assert!(upgrade("template_pool", &mut pool, &mut report, &NO_TAGS));
|
||||
let e = &pool["elements"][0]["element"];
|
||||
assert_eq!(e["element_type"], "minecraft:single_pool_element");
|
||||
assert_eq!(e["location"], "y:room");
|
||||
assert_eq!(
|
||||
e["horizon:yungsapi"],
|
||||
json!({"name": "room", "max_count": 2, "min_depth": 1, "priority": true,
|
||||
"ignore_bounds": false, "condition": {"type": "all_of", "conditions": [
|
||||
{"type": "piece_in_horizontal_direction", "pieces": [], "range": 5, "rotation": "none"},
|
||||
{"type": "not", "condition": {"type": "false"}},
|
||||
{"type": "false"}]}})
|
||||
);
|
||||
assert!(e.get("deadend_pool").is_none());
|
||||
assert_eq!(
|
||||
report.rules_lost,
|
||||
BTreeMap::from([
|
||||
("enhanced_terrain_adaptation".into(), 1),
|
||||
("yungsapi condition yungsapi:biome".into(), 1),
|
||||
("yungsapi deadend_pool".into(), 1),
|
||||
])
|
||||
);
|
||||
assert!(report.unsupported.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn drops_processors_written_in_java() {
|
||||
let mut report = Upgrade::default();
|
||||
@@ -643,6 +1242,127 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn yungs_placements_keep_their_rules() {
|
||||
let tags = BTreeMap::from([(
|
||||
"bf:avoid".to_owned(),
|
||||
vec!["minecraft:nether_complexes".to_owned()],
|
||||
)]);
|
||||
let mut report = Upgrade::default();
|
||||
let mut fortress = json!({"placement": {"type": "yungsapi:enhanced_random_spread",
|
||||
"salt": 1, "spacing": 30, "separation": 20,
|
||||
"enhanced_exclusion_zone": {"other_set": "#bf:avoid", "chunk_count": 10}}});
|
||||
assert!(upgrade("structure_set", &mut fortress, &mut report, &tags));
|
||||
assert_eq!(
|
||||
fortress["placement"],
|
||||
json!({"type": "minecraft:random_spread", "salt": 1, "spacing": 30, "separation": 20,
|
||||
"horizon:exclusion_zone": {"other_sets": ["minecraft:nether_complexes"], "chunk_count": 10}})
|
||||
);
|
||||
let mut temple = json!({"placement": {"type": "betterdeserttemples:desert_temple",
|
||||
"salt": 2, "spacing": 30, "separation": 20,
|
||||
"exclusion_zone": {"other_set": "minecraft:villages", "chunk_count": 6}}});
|
||||
assert!(upgrade("structure_set", &mut temple, &mut report, &tags));
|
||||
assert_eq!(temple["placement"]["type"], "minecraft:random_spread");
|
||||
assert_eq!(temple["placement"]["exclusion_zone"]["chunk_count"], 6);
|
||||
assert_eq!(
|
||||
temple["placement"]["horizon:avoid_biomes"],
|
||||
json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"],
|
||||
"radius": 48, "step": 2, "y": 120})
|
||||
);
|
||||
let mut stronghold = json!({"placement": {"type": "betterstrongholds:stronghold",
|
||||
"salt": 3, "spacing": 85, "separation": 50,
|
||||
"chunk_distance_to_first_ring": 80, "ring_chunk_thickness": 96}});
|
||||
assert!(upgrade(
|
||||
"structure_set",
|
||||
&mut stronghold,
|
||||
&mut report,
|
||||
&tags
|
||||
));
|
||||
assert_eq!(
|
||||
stronghold["placement"],
|
||||
json!({"type": "minecraft:random_spread", "salt": 3, "spacing": 85, "separation": 50,
|
||||
"horizon:ring_sections": {"distance_to_first_ring": 80, "thickness": 96}})
|
||||
);
|
||||
assert_eq!(report.mapped, 3);
|
||||
assert!(report.unsupported.is_empty());
|
||||
// The vanilla counterpart is turned off only for a structure the game starts.
|
||||
let mut ported = json!({"type": "minecraft:jigsaw"});
|
||||
assert!(disables("betterstrongholds:stronghold", &mut ported));
|
||||
assert_eq!(ported["horizon:disables"], json!(["minecraft:stronghold"]));
|
||||
let mut java = json!({"type": "bettermineshafts:mineshaft"});
|
||||
assert!(!disables("bettermineshafts:mineshaft_oak", &mut java));
|
||||
let mut circle = json!({"type": "minecraft:jigsaw"});
|
||||
assert!(!disables("betterwitchhuts:witch_circle", &mut circle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn piece_limited_jigsaws_keep_their_layout() {
|
||||
let mut report = Upgrade::default();
|
||||
let mut nether = json!({"type": "repurposed_structures:generic_nether_jigsaw_structure",
|
||||
"start_pool": "rs:x", "size": 8, "y_allowance": {"min_y_allowed": 40, "max_y_allowed": 90},
|
||||
"cannot_spawn_in_liquid": true, "pools_that_ignore_boundaries": ["rs:roof"],
|
||||
"use_bounding_box_hack": true, "land_search_direction": "HIGHEST_LAND",
|
||||
"ledge_offset_y": 2});
|
||||
assert!(upgrade("structure", &mut nether, &mut report, &NO_TAGS));
|
||||
assert_eq!(nether["type"], "minecraft:jigsaw");
|
||||
assert_eq!(
|
||||
nether["horizon:piece_limited"],
|
||||
json!({"library": "repurposed", "min_y": 40, "max_y": 90, "no_liquid": true,
|
||||
"ignore_bounds_pools": ["rs:roof"], "land_search": "highest_land",
|
||||
"ledge_offset_y": 2})
|
||||
);
|
||||
assert_eq!(nether["use_expansion_hack"], true);
|
||||
for gone in [
|
||||
"y_allowance",
|
||||
"use_bounding_box_hack",
|
||||
"land_search_direction",
|
||||
"ledge_offset_y",
|
||||
] {
|
||||
assert!(nether.get(gone).is_none(), "{gone}");
|
||||
}
|
||||
let mut moogs = json!({"type": "moogs_structures:moogs_structures_generic_jigsaw_structure",
|
||||
"burying_type": "AVERAGE_LAND"});
|
||||
assert!(upgrade("structure", &mut moogs, &mut report, &NO_TAGS));
|
||||
assert_eq!(
|
||||
moogs["horizon:piece_limited"],
|
||||
json!({"library": "moogs", "burying": "average_land"})
|
||||
);
|
||||
// Lithostitched's jigsaw is vanilla's: no key.
|
||||
let mut litho = json!({"type": "lithostitched:jigsaw"});
|
||||
assert!(upgrade("structure", &mut litho, &mut report, &NO_TAGS));
|
||||
assert!(litho.get("horizon:piece_limited").is_none());
|
||||
assert!(report.rules_lost.is_empty(), "{:?}", report.rules_lost);
|
||||
assert!(report.unsupported.is_empty());
|
||||
|
||||
let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
let opts = zip::write::SimpleFileOptions::default();
|
||||
for (name, text) in [
|
||||
(
|
||||
"data/rs/rs_pieces_spawn_counts/city.json",
|
||||
r#"{"target_structure": "rs:city_nether", "pieces_spawn_counts": [
|
||||
{"nbt_piece_name": "rs:city/center", "always_spawn_this_many": 1,
|
||||
"never_spawn_more_than_this_many": 1, "minimum_distance_from_center_piece": 3}]}"#,
|
||||
),
|
||||
(
|
||||
"data/mvs/msl_pieces_spawn_counts/tower.json",
|
||||
r#"{"pieces_spawn_counts": [{"nbt_piece_name": "mvs:top", "never_spawn_more_than_this_many": 2}]}"#,
|
||||
),
|
||||
] {
|
||||
zip.start_file(name, opts).unwrap();
|
||||
std::io::Write::write_all(&mut zip, text.as_bytes()).unwrap();
|
||||
}
|
||||
let mut zip = zip::ZipArchive::new(zip.finish().unwrap()).unwrap();
|
||||
let counts = piece_counts(&mut zip);
|
||||
assert_eq!(
|
||||
counts["rs:city_nether"],
|
||||
json!([{"name": "rs:city/center", "required": 1, "max": 1, "min_depth": 3}])
|
||||
);
|
||||
assert_eq!(counts["mvs:tower"], json!([{"name": "mvs:top", "max": 2}]));
|
||||
assert!(add_piece_counts("rs:city_nether", &mut nether, &counts));
|
||||
assert_eq!(nether["horizon:piece_limited"]["pieces"][0]["required"], 1);
|
||||
assert!(!add_piece_counts("rs:other", &mut nether, &counts));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_block_states_in_26_3_shape() {
|
||||
let mut report = Upgrade::default();
|
||||
@@ -675,6 +1395,88 @@ mod tests {
|
||||
assert_eq!(report.mapped, 0);
|
||||
}
|
||||
|
||||
#[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 ctov_joins_vanillas_villages_and_outposts() {
|
||||
let sets = code_set_entries("ctov");
|
||||
let (file, set, outposts) = &sets[0];
|
||||
assert_eq!(
|
||||
(*file, *set),
|
||||
("pillager_outposts", "minecraft:pillager_outposts")
|
||||
);
|
||||
assert_eq!(outposts.len(), 11);
|
||||
assert!(outposts.iter().all(|(_, w)| *w == 1));
|
||||
let (_, set, villages) = &sets[1];
|
||||
assert_eq!(*set, "minecraft:villages");
|
||||
assert_eq!(villages.len(), 63);
|
||||
assert_eq!(villages[0], ("ctov:small/village_beach".into(), 10));
|
||||
assert_eq!(villages[21], ("ctov:medium/village_beach".into(), 4));
|
||||
assert_eq!(
|
||||
villages[62],
|
||||
("ctov:large/village_taiga_fortified".into(), 1)
|
||||
);
|
||||
assert!(code_set_entries("mvs").is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn convention_tags_include_theirs() {
|
||||
let conventions = BTreeMap::from([
|
||||
|
||||
@@ -110,6 +110,19 @@ impl Limits {
|
||||
max_depth: 512,
|
||||
}
|
||||
}
|
||||
|
||||
/// Structure templates (`structure/*.nbt`): vanilla reads them with
|
||||
/// `NbtAccounter.unlimitedHeap()` (TemplateSource.readStructure), and
|
||||
/// mods ship templates past the default node cap (YUNG's Better Ocean
|
||||
/// Monuments' start piece, 115x64x126 blocks, holds millions of tags).
|
||||
/// The byte cap stays as the only guard on the decompressed file.
|
||||
pub fn templates() -> Self {
|
||||
Self {
|
||||
max_bytes: 1 << 28,
|
||||
max_nodes: usize::MAX,
|
||||
max_depth: 512,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
@@ -836,6 +849,18 @@ mod tests {
|
||||
assert!(read_network(&bytes, limits).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn templates_read_past_the_default_node_cap() {
|
||||
// A big mod template (YUNG's monument start) holds more tags than the
|
||||
// default cap; vanilla reads templates with an unlimited accounter.
|
||||
let root = NamedTag {
|
||||
name: JavaString::default(),
|
||||
tag: Tag::compound([("blocks", Tag::List(vec![Tag::Byte(1); 1_000_001]))]),
|
||||
};
|
||||
let bytes = write_named(&root, Limits::templates()).unwrap();
|
||||
assert!(read_named(&bytes, Limits::default()).is_err());
|
||||
assert_eq!(read_named(&bytes, Limits::templates()).unwrap().0, root);
|
||||
}
|
||||
#[test]
|
||||
fn depth_boundary_and_every_truncated_prefix() {
|
||||
let mut tag = Tag::Int(1);
|
||||
for _ in 0..512 {
|
||||
|
||||
@@ -10,6 +10,7 @@ pub mod mineshaft;
|
||||
pub mod monument;
|
||||
pub mod nether_fossil;
|
||||
pub mod ocean_ruin;
|
||||
pub mod piece_limited;
|
||||
pub mod processor;
|
||||
pub mod ruined_portal;
|
||||
pub mod simple;
|
||||
@@ -18,6 +19,7 @@ pub mod start_checks;
|
||||
pub mod stronghold;
|
||||
pub mod template;
|
||||
pub mod temple;
|
||||
pub mod yung;
|
||||
|
||||
use crate::{
|
||||
nbt::{self, Limits},
|
||||
@@ -342,11 +344,7 @@ impl StructureResources {
|
||||
flate2::read::GzDecoder::new(bytes.as_slice())
|
||||
.read_to_end(&mut raw)
|
||||
.ok()?;
|
||||
let limits = Limits {
|
||||
max_bytes: 1 << 28,
|
||||
..Limits::default()
|
||||
};
|
||||
let tag = nbt::read_named(&raw, limits).ok()?.0.tag;
|
||||
let tag = nbt::read_named(&raw, Limits::templates()).ok()?.0.tag;
|
||||
Some(Arc::new(StructureTemplate::from_nbt(
|
||||
&tag,
|
||||
self.registry,
|
||||
|
||||
@@ -39,6 +39,9 @@ pub enum PoolElement {
|
||||
legacy: bool,
|
||||
projection: Projection,
|
||||
waterlogging: Option<bool>,
|
||||
/// YUNG's API's rules on the piece (`"horizon:yungsapi"`), read only
|
||||
/// by its assembler ([`super::yung`]).
|
||||
yung: Option<Box<super::yung::Rules>>,
|
||||
},
|
||||
Feature {
|
||||
feature: String,
|
||||
@@ -81,11 +84,12 @@ fn opposite(d: Direction) -> Direction {
|
||||
Direction::East => Direction::West,
|
||||
}
|
||||
}
|
||||
fn step(d: Direction) -> [i32; 3] {
|
||||
pub(super) fn step(d: Direction) -> [i32; 3] {
|
||||
let n = d.normal();
|
||||
[n[0], n[1], n[2]]
|
||||
}
|
||||
fn shuffle<T>(list: &mut [T], random: &mut impl RandomSource) {
|
||||
/// Util.shuffle.
|
||||
pub(super) fn shuffle<T>(list: &mut [T], random: &mut impl RandomSource) {
|
||||
for i in (2..=list.len()).rev() {
|
||||
let swap = random.next_int_bound(i as i32).unwrap_or(0) as usize;
|
||||
list.swap(i - 1, swap);
|
||||
@@ -135,6 +139,10 @@ impl PoolElement {
|
||||
Some("ignore_waterlogging") => Some(false),
|
||||
_ => None,
|
||||
},
|
||||
yung: value
|
||||
.get("horizon:yungsapi")
|
||||
.map(|rules| super::yung::Rules::decode(rules, resources).map(Box::new))
|
||||
.transpose()?,
|
||||
}
|
||||
}
|
||||
"minecraft:feature_pool_element" => Self::Feature {
|
||||
@@ -219,10 +227,13 @@ impl PoolElement {
|
||||
.first()
|
||||
.map(|e| e.shuffled_jigsaws(resources, position, rotation, random))
|
||||
.unwrap_or_default(),
|
||||
Self::Single { template, .. } => {
|
||||
Self::Single { template, yung, .. } => {
|
||||
let mut jigsaws = template_jigsaws(resources, template, position, rotation);
|
||||
shuffle(&mut jigsaws, random);
|
||||
jigsaws.sort_by_key(|j| std::cmp::Reverse(j.selection_priority));
|
||||
// YUNG's elements keep the shuffled order.
|
||||
if yung.is_none() {
|
||||
jigsaws.sort_by_key(|j| std::cmp::Reverse(j.selection_priority));
|
||||
}
|
||||
jigsaws
|
||||
}
|
||||
}
|
||||
@@ -230,6 +241,13 @@ impl PoolElement {
|
||||
pub fn ground_level_delta(&self) -> i32 {
|
||||
1
|
||||
}
|
||||
/// YUNG's API's rules, on a piece of one of its structures.
|
||||
pub fn yung(&self) -> Option<&super::yung::Rules> {
|
||||
match self {
|
||||
Self::Single { yung, .. } => yung.as_deref(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
/// StructureTemplate.getJigsaws: palette chosen by a position-seeded random.
|
||||
fn template_jigsaws(
|
||||
@@ -274,7 +292,7 @@ fn template_jigsaws(
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn can_attach(source: &Jigsaw, target: &Jigsaw) -> bool {
|
||||
pub(super) fn can_attach(source: &Jigsaw, target: &Jigsaw) -> bool {
|
||||
source.front == opposite(target.front)
|
||||
&& (source.rollable || source.top == target.top)
|
||||
&& target
|
||||
@@ -285,12 +303,15 @@ fn can_attach(source: &Jigsaw, target: &Jigsaw) -> bool {
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Pool {
|
||||
templates: Vec<Arc<PoolElement>>,
|
||||
fallback: String,
|
||||
/// Each element repeated by its weight.
|
||||
pub(super) templates: Vec<Arc<PoolElement>>,
|
||||
/// The elements with their weights, in file order (`rawTemplates`).
|
||||
pub(super) raw: Vec<(Arc<PoolElement>, i32)>,
|
||||
pub(super) fallback: String,
|
||||
max_size: OnceLock<i32>,
|
||||
}
|
||||
impl Pool {
|
||||
fn random_template(&self, random: &mut impl RandomSource) -> Arc<PoolElement> {
|
||||
pub(super) fn random_template(&self, random: &mut impl RandomSource) -> Arc<PoolElement> {
|
||||
if self.templates.is_empty() {
|
||||
return Arc::new(PoolElement::Empty);
|
||||
}
|
||||
@@ -304,7 +325,7 @@ impl Pool {
|
||||
shuffle(&mut copy, random);
|
||||
copy
|
||||
}
|
||||
fn max_size(&self) -> i32 {
|
||||
pub(super) fn max_size(&self) -> i32 {
|
||||
*self.max_size.get_or_init(|| {
|
||||
self.templates
|
||||
.iter()
|
||||
@@ -343,7 +364,7 @@ impl Pools {
|
||||
}
|
||||
let pool = self.raw.get(name).and_then(|json| {
|
||||
let value: Value = serde_json::from_str(json).ok()?;
|
||||
let mut templates = Vec::new();
|
||||
let (mut templates, mut raw) = (Vec::new(), Vec::new());
|
||||
for entry in value["elements"].as_array()? {
|
||||
let element =
|
||||
match PoolElement::decode(&entry["element"], resources, bindings, None) {
|
||||
@@ -355,12 +376,15 @@ impl Pools {
|
||||
return None;
|
||||
}
|
||||
};
|
||||
for _ in 0..entry["weight"].as_i64().unwrap_or(1) {
|
||||
let weight = entry["weight"].as_i64().unwrap_or(1);
|
||||
for _ in 0..weight {
|
||||
templates.push(element.clone());
|
||||
}
|
||||
raw.push((element, weight as i32));
|
||||
}
|
||||
Some(Arc::new(Pool {
|
||||
templates,
|
||||
raw,
|
||||
fallback: value["fallback"]
|
||||
.as_str()
|
||||
.unwrap_or("minecraft:empty")
|
||||
@@ -393,7 +417,7 @@ pub struct PoolPiece {
|
||||
pub waterlogging: bool,
|
||||
}
|
||||
impl PoolPiece {
|
||||
fn moved(&mut self, dy: i32) {
|
||||
pub(super) fn moved(&mut self, dy: i32) {
|
||||
self.position[1] += dy;
|
||||
self.bounding_box = self.bounding_box.moved([0, dy, 0]);
|
||||
}
|
||||
@@ -466,6 +490,7 @@ fn place_element<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
legacy,
|
||||
projection,
|
||||
waterlogging: override_liquid,
|
||||
..
|
||||
} => {
|
||||
let ignore = if *legacy {
|
||||
IGNORE_STRUCTURE_AND_AIR.get_or_init(|| {
|
||||
@@ -547,13 +572,13 @@ pub struct JigsawConfig<'a> {
|
||||
|
||||
/// Free space for children: an inclusive container box minus placed boxes.
|
||||
#[derive(Debug)]
|
||||
struct Free {
|
||||
container: BoundingBox,
|
||||
removed: Vec<BoundingBox>,
|
||||
pub(super) struct Free {
|
||||
pub(super) container: BoundingBox,
|
||||
pub(super) removed: Vec<BoundingBox>,
|
||||
}
|
||||
impl Free {
|
||||
/// Whether every point of the (0.25-deflated) box lies in free space.
|
||||
fn fits(&self, b: &BoundingBox) -> bool {
|
||||
pub(super) fn fits(&self, b: &BoundingBox) -> bool {
|
||||
(0..3).all(|i| b.min[i] >= self.container.min[i] && b.max[i] <= self.container.max[i])
|
||||
&& !self.removed.iter().any(|r| r.intersects(b))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,980 @@
|
||||
//! The piece-limited jigsaw assembler of Repurposed Structures and Moog's
|
||||
//! Structure Lib (PieceLimitedJigsawManager, the same code in both), for
|
||||
//! their structures carried over from a modpack (docs/modpacks.md). Carry
|
||||
//! maps their jigsaw types to `minecraft:jigsaw` with a
|
||||
//! `"horizon:piece_limited"` key; vanilla data never has it.
|
||||
//!
|
||||
//! ```json
|
||||
//! "horizon:piece_limited": {
|
||||
//! "library": "moogs", // or "repurposed": their few differences
|
||||
//! "min_y": 40, "max_y": 120, // y_allowance: pieces stay inside, unless buried
|
||||
//! "burying": "lowest_corner", // or "average_land", "lowest_side"
|
||||
//! "no_liquid": true, // cannot_spawn_in_liquid, as burying reads it
|
||||
//! "ignore_bounds_pools": ["x:pool"],
|
||||
//! "land_search": "highest_land", // the Nether variants: or "lowest_land", "fixed_height"
|
||||
//! "ledge_offset_y": 2,
|
||||
//! "pieces": [{"name": "x:piece", "required": 1, "min_depth": 3, "max": 2}]
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! It differs from vanilla's JigsawPlacement: a fresh random seeded by the
|
||||
//! chunk, the start piece drawn uniformly and moved to the surface at its
|
||||
//! center, a bounding volume 120 blocks down and 180 up, children drawn by
|
||||
//! weight from the pools' weighted entries in order (`nextInt(total) + 1`,
|
||||
//! counted down), pieces capped by template (`max`) and some required
|
||||
//! (`required`, from `min_depth`), the whole layout retried up to 40 times
|
||||
//! until every required piece is in, and after it the pieces centred on the
|
||||
//! chunk corner, then buried in the terrain or moved onto Nether land.
|
||||
use super::{
|
||||
BoundingBox, Rotation, StructureResources, StructureTemplate,
|
||||
jigsaw::{
|
||||
Free, JigsawConfig, Junction, PoolElement, PoolPiece, Pools, Projection, can_attach,
|
||||
shuffle, step,
|
||||
},
|
||||
start::StartContext,
|
||||
};
|
||||
use crate::{
|
||||
heightmap::HeightmapType, identifier::Identifier, java_hash_map::JavaHashMap,
|
||||
worldgen::block_feature::FeatureBlockBindings,
|
||||
};
|
||||
use horizon_core::{
|
||||
position::ChunkPos,
|
||||
random::{LegacyRandom, RandomSource, WorldgenRandom},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
collections::{HashSet, VecDeque},
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
/// Which mod's copy of the code: they differ in a few post-layout steps.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Library {
|
||||
Moogs,
|
||||
Repurposed,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Burying {
|
||||
LowestCorner,
|
||||
AverageLand,
|
||||
LowestSide,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum LandSearch {
|
||||
Highest,
|
||||
Lowest,
|
||||
Fixed,
|
||||
}
|
||||
|
||||
/// One template's counts (`*_pieces_spawn_counts`).
|
||||
#[derive(Clone, Debug)]
|
||||
struct Counted {
|
||||
required: Option<i32>,
|
||||
min_depth: i32,
|
||||
max: Option<i32>,
|
||||
}
|
||||
|
||||
/// `"horizon:piece_limited"` of a jigsaw structure.
|
||||
#[derive(Debug)]
|
||||
pub struct Config {
|
||||
library: Library,
|
||||
min_y: Option<i32>,
|
||||
max_y: Option<i32>,
|
||||
burying: Option<Burying>,
|
||||
no_liquid: bool,
|
||||
ignore_bounds: HashSet<String>,
|
||||
land_search: Option<LandSearch>,
|
||||
ledge: i32,
|
||||
/// Counted templates by id, in the order of Java's HashMap of the
|
||||
/// required pieces (the first one still short is forced in first).
|
||||
pieces: Vec<(Identifier, Counted)>,
|
||||
}
|
||||
|
||||
impl Config {
|
||||
pub fn decode(v: &Value) -> Self {
|
||||
let int = |k: &str| v[k].as_i64().map(|n| n as i32);
|
||||
let mut pieces: Vec<(Identifier, Counted)> = Vec::new();
|
||||
for p in v["pieces"].as_array().into_iter().flatten() {
|
||||
let Some(id) = p["name"].as_str().and_then(|n| Identifier::parse(n).ok()) else {
|
||||
continue;
|
||||
};
|
||||
let counted = Counted {
|
||||
required: p["required"].as_i64().map(|n| n as i32),
|
||||
min_depth: p["min_depth"].as_i64().unwrap_or(0) as i32,
|
||||
max: p["max"].as_i64().map(|n| n as i32),
|
||||
};
|
||||
// A later entry for the same piece replaces it, as HashMap.put.
|
||||
match pieces.iter_mut().find(|(k, _)| *k == id) {
|
||||
Some(slot) => slot.1 = counted,
|
||||
None => pieces.push((id, counted)),
|
||||
}
|
||||
}
|
||||
// getRequirePieces builds a HashMap of the required ones and the
|
||||
// assembler copies it (new HashMap(map)): iterate as that copy does.
|
||||
let mut map = JavaHashMap::default();
|
||||
for (i, (id, c)) in pieces.iter().enumerate() {
|
||||
if c.required.is_some() {
|
||||
map.put(id.clone(), i);
|
||||
}
|
||||
}
|
||||
let order: Vec<usize> = map.copied().entries().map(|(_, &i)| i).collect();
|
||||
let mut sorted: Vec<(Identifier, Counted)> =
|
||||
order.iter().map(|&i| pieces[i].clone()).collect();
|
||||
sorted.extend(pieces.iter().filter(|(_, c)| c.required.is_none()).cloned());
|
||||
Self {
|
||||
library: match v["library"].as_str() {
|
||||
Some("repurposed") => Library::Repurposed,
|
||||
_ => Library::Moogs,
|
||||
},
|
||||
min_y: int("min_y"),
|
||||
max_y: int("max_y"),
|
||||
burying: match v["burying"].as_str() {
|
||||
Some("lowest_corner") => Some(Burying::LowestCorner),
|
||||
Some("average_land") => Some(Burying::AverageLand),
|
||||
Some("lowest_side") => Some(Burying::LowestSide),
|
||||
_ => None,
|
||||
},
|
||||
no_liquid: v["no_liquid"].as_bool().unwrap_or(false),
|
||||
ignore_bounds: v["ignore_bounds_pools"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|p| Some(p.as_str()?.to_owned()))
|
||||
.collect(),
|
||||
land_search: match v["land_search"].as_str() {
|
||||
Some("highest_land") => Some(LandSearch::Highest),
|
||||
Some("lowest_land") => Some(LandSearch::Lowest),
|
||||
Some("fixed_height") => Some(LandSearch::Fixed),
|
||||
_ => None,
|
||||
},
|
||||
ledge: int("ledge_offset_y").unwrap_or(0),
|
||||
pieces: sorted,
|
||||
}
|
||||
}
|
||||
fn required(&self) -> impl Iterator<Item = &Counted> {
|
||||
self.pieces
|
||||
.iter()
|
||||
.map(|(_, c)| c)
|
||||
.filter(|c| c.required.is_some())
|
||||
}
|
||||
}
|
||||
|
||||
/// The counted templates, loaded, in [`Config::pieces`] order.
|
||||
struct Counts(Vec<Arc<StructureTemplate>>);
|
||||
impl Counts {
|
||||
fn new(limits: &Config, resources: &StructureResources) -> Self {
|
||||
Self(
|
||||
limits
|
||||
.pieces
|
||||
.iter()
|
||||
.map(|(id, _)| {
|
||||
resources
|
||||
.template(&id.to_string())
|
||||
.unwrap_or_else(|| Arc::new(StructureTemplate::empty()))
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
/// The index of a single element's template among the counted ones.
|
||||
fn of(&self, element: &PoolElement) -> Option<usize> {
|
||||
let PoolElement::Single { template, .. } = element else {
|
||||
return None;
|
||||
};
|
||||
self.0.iter().position(|t| Arc::ptr_eq(t, template))
|
||||
}
|
||||
}
|
||||
|
||||
/// PieceLimitedJigsawManager.assembleJigsawStructure and the structure's
|
||||
/// postLayoutAdjustments: the start's center and the pieces, or None when
|
||||
/// nothing starts. `start` is the chunk's corner at the sampled start height.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn assemble(
|
||||
config: &JigsawConfig<'_>,
|
||||
limits: &Config,
|
||||
context: &mut impl StartContext,
|
||||
pools: &Pools,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
chunk: ChunkPos,
|
||||
start: [i32; 3],
|
||||
) -> Option<([i32; 3], Vec<PoolPiece>)> {
|
||||
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
|
||||
random.set_large_feature_seed(context.seed(), chunk.x, chunk.z);
|
||||
let rotation = Rotation::random(&mut random);
|
||||
let pool = pools.get(config.start_pool, resources, bindings)?;
|
||||
// An empty start pool crashes the mod's generation; nothing starts.
|
||||
if pool.templates.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let element = pool.random_template(&mut random);
|
||||
if matches!(element.as_ref(), PoolElement::Empty) {
|
||||
return None;
|
||||
}
|
||||
let mut first = PoolPiece {
|
||||
bounding_box: element.bounding_box(start, rotation),
|
||||
ground_level_delta: element.ground_level_delta(),
|
||||
element,
|
||||
position: start,
|
||||
rotation,
|
||||
junctions: Vec::new(),
|
||||
waterlogging: config.waterlogging,
|
||||
};
|
||||
let b = first.bounding_box;
|
||||
let (cx, cz) = ((b.max[0] + b.min[0]) / 2, (b.max[2] + b.min[2]) / 2);
|
||||
let top = limits.max_y.unwrap_or(i32::MAX);
|
||||
let bottom = limits.min_y.unwrap_or(i32::MIN);
|
||||
let cy = match config.project_to {
|
||||
Some(kind) => {
|
||||
let y = start[1] + context.base_height(cx, cz, kind);
|
||||
if y > top || y < bottom {
|
||||
return None;
|
||||
}
|
||||
y
|
||||
}
|
||||
None => start[1],
|
||||
};
|
||||
first.moved(cy - (b.min[1] + first.ground_level_delta));
|
||||
let start_box = first.bounding_box;
|
||||
let (start_position, start_rotation) = (first.position, first.rotation);
|
||||
let counts = Counts::new(limits, resources);
|
||||
let run_once = limits.required().next().is_none();
|
||||
let mut pieces = vec![first];
|
||||
let mut attempts = 0;
|
||||
// `for (attempts = 0; runOnce || doesNotHaveAllRequiredPieces(...); attempts++)`:
|
||||
// the first test sees the start piece alone.
|
||||
while run_once || lacks_required(limits, &counts, &pieces) {
|
||||
if attempts == 40 {
|
||||
break;
|
||||
}
|
||||
if attempts > 0 {
|
||||
let element = pool.random_template(&mut random);
|
||||
pieces = vec![PoolPiece {
|
||||
bounding_box: element.bounding_box(start_position, start_rotation),
|
||||
ground_level_delta: element.ground_level_delta(),
|
||||
element,
|
||||
position: start_position,
|
||||
rotation: start_rotation,
|
||||
junctions: Vec::new(),
|
||||
waterlogging: config.waterlogging,
|
||||
}];
|
||||
} else {
|
||||
pieces.truncate(1);
|
||||
}
|
||||
if config.max_depth > 0 {
|
||||
let r = config.max_distance[0];
|
||||
let free = Rc::new(RefCell::new(Free {
|
||||
container: BoundingBox::new([cx - r, cy - 120, cz - r], [cx + r, cy + 180, cz + r]),
|
||||
removed: vec![start_box],
|
||||
}));
|
||||
let buried = limits.burying.is_some();
|
||||
let mut assembler = Assembler {
|
||||
config,
|
||||
limits,
|
||||
counted: &counts,
|
||||
pools,
|
||||
resources,
|
||||
bindings,
|
||||
pieces: std::mem::take(&mut pieces),
|
||||
states: vec![(free, 0)],
|
||||
counts: vec![0; limits.pieces.len()],
|
||||
max_y: if buried { i32::MAX } else { top },
|
||||
min_y: if buried { i32::MIN } else { bottom },
|
||||
};
|
||||
let mut queue = VecDeque::from([0]);
|
||||
while let Some(piece) = queue.pop_front() {
|
||||
assembler.children(piece, &mut queue, context, &mut random);
|
||||
}
|
||||
pieces = assembler.pieces;
|
||||
}
|
||||
if run_once {
|
||||
break;
|
||||
}
|
||||
attempts += 1;
|
||||
}
|
||||
adjust(config, limits, context, start, &mut pieces);
|
||||
if pieces.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let mut whole = pieces[0].bounding_box;
|
||||
for p in &pieces[1..] {
|
||||
whole.encapsulate(&p.bounding_box);
|
||||
}
|
||||
// The builder is cleared when the layout reaches past the build height.
|
||||
if whole.max[1] > context.max_y() + 1 {
|
||||
return None;
|
||||
}
|
||||
Some(([cx, cy, cz], pieces))
|
||||
}
|
||||
|
||||
/// doesNotHaveAllRequiredPieces.
|
||||
fn lacks_required(limits: &Config, counts: &Counts, pieces: &[PoolPiece]) -> bool {
|
||||
let mut left: Vec<i32> = limits
|
||||
.pieces
|
||||
.iter()
|
||||
.map(|(_, c)| c.required.unwrap_or(0))
|
||||
.collect();
|
||||
for p in pieces {
|
||||
if let Some(i) = counts.of(&p.element) {
|
||||
left[i] -= 1;
|
||||
}
|
||||
}
|
||||
left.iter().any(|&n| n > 0)
|
||||
}
|
||||
|
||||
/// Moves a piece; Repurposed Structures' movePieceProperly also writes its
|
||||
/// junctions, all three setters into the source X, so only the last sticks.
|
||||
fn shift(limits: &Config, piece: &mut PoolPiece, d: [i32; 3]) {
|
||||
piece.position = std::array::from_fn(|i| piece.position[i] + d[i]);
|
||||
piece.bounding_box = piece.bounding_box.moved(d);
|
||||
if limits.library == Library::Repurposed {
|
||||
for j in &mut piece.junctions {
|
||||
j.source_x = j.source_z + d[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
fn shift_all(limits: &Config, pieces: &mut [PoolPiece], d: [i32; 3]) {
|
||||
for p in pieces {
|
||||
shift(limits, p, d);
|
||||
}
|
||||
}
|
||||
|
||||
/// The structure's postLayoutAdjustments.
|
||||
fn adjust(
|
||||
config: &JigsawConfig<'_>,
|
||||
limits: &Config,
|
||||
context: &mut impl StartContext,
|
||||
start: [i32; 3],
|
||||
pieces: &mut Vec<PoolPiece>,
|
||||
) {
|
||||
if pieces.is_empty() {
|
||||
return;
|
||||
}
|
||||
// GeneralUtils.centerAllPieces on the chunk's corner.
|
||||
let center = pieces[0].bounding_box.center();
|
||||
let d = [start[0] - center[0], 0, start[2] - center[2]];
|
||||
for p in pieces.iter_mut() {
|
||||
// Centring uses StructurePiece.move in both mods.
|
||||
p.position = std::array::from_fn(|i| p.position[i] + d[i]);
|
||||
p.bounding_box = p.bounding_box.moved(d);
|
||||
}
|
||||
let offset_y = start[1];
|
||||
let sea = context.sea_level();
|
||||
if let Some(search) = limits.land_search {
|
||||
nether(limits, context, search, offset_y, pieces);
|
||||
return;
|
||||
}
|
||||
let Some(burying) = limits.burying else {
|
||||
return;
|
||||
};
|
||||
let kind = config.project_to.unwrap_or(HeightmapType::WorldSurfaceWg);
|
||||
let ocean_floor = matches!(
|
||||
kind,
|
||||
HeightmapType::OceanFloorWg | HeightmapType::OceanFloor
|
||||
);
|
||||
let box0 = pieces[0].bounding_box;
|
||||
let mut land = match burying {
|
||||
Burying::LowestCorner => [
|
||||
(box0.min[0], box0.min[2]),
|
||||
(box0.min[0], box0.max[2]),
|
||||
(box0.max[0], box0.min[2]),
|
||||
(box0.max[0], box0.max[2]),
|
||||
]
|
||||
.into_iter()
|
||||
.map(|(x, z)| context.base_height(x, z, kind) - 1)
|
||||
.min()
|
||||
.unwrap_or(0),
|
||||
Burying::LowestSide => {
|
||||
let c = box0.center();
|
||||
let mut highest = i32::MAX;
|
||||
for (x, z) in [
|
||||
(box0.min[0], c[2]),
|
||||
(c[0], box0.max[2]),
|
||||
(c[0], box0.min[2]),
|
||||
(box0.max[0], c[2]),
|
||||
] {
|
||||
// getFirstOccupiedHeight (Repurposed's cached free height - 1).
|
||||
let land = context.base_height(x, z, kind) - 1;
|
||||
match limits.min_y {
|
||||
Some(min) if land >= min => highest = land,
|
||||
Some(_) => {}
|
||||
None => highest = highest.min(land),
|
||||
}
|
||||
}
|
||||
if let Some(min) = limits.min_y.filter(|_| highest == i32::MAX) {
|
||||
highest = min;
|
||||
}
|
||||
highest
|
||||
}
|
||||
Burying::AverageLand => {
|
||||
average_land(limits, context, kind, ocean_floor, offset_y, pieces);
|
||||
return;
|
||||
}
|
||||
};
|
||||
if limits.no_liquid || !ocean_floor {
|
||||
land = land.max(sea);
|
||||
} else {
|
||||
land = land.min(sea - box0.span()[1]);
|
||||
}
|
||||
// offsetToNewHeight.
|
||||
if limits.max_y.is_some()
|
||||
&& let Some(min) = limits.min_y
|
||||
&& box0.max[1] + offset_y < min
|
||||
{
|
||||
land = land.max(limits.max_y.unwrap_or(land));
|
||||
}
|
||||
if let Some(min) = limits.min_y
|
||||
&& box0.min[1] + offset_y < min
|
||||
{
|
||||
land = land.min(min);
|
||||
}
|
||||
let dy = land - box0.min[1] + offset_y;
|
||||
shift_all(limits, pieces, [0, dy, 0]);
|
||||
}
|
||||
|
||||
/// AVERAGE_LAND: the mean land height over a grid on the first piece's
|
||||
/// footprint; no structure when none of the heights is allowed.
|
||||
fn average_land(
|
||||
limits: &Config,
|
||||
context: &mut impl StartContext,
|
||||
kind: HeightmapType,
|
||||
ocean_floor: bool,
|
||||
offset_y: i32,
|
||||
pieces: &mut Vec<PoolPiece>,
|
||||
) {
|
||||
let b = pieces[0].bounding_box;
|
||||
let c = b.center();
|
||||
let (lx, lz) = (b.max[0] - b.min[0], b.max[2] - b.min[2]);
|
||||
let radius = (f64::from(lx * lx + lz * lz).sqrt() as i32) / 2;
|
||||
// The mod's loop never ends with a step of 0; one block apart instead.
|
||||
let step = (radius / 2).max(1);
|
||||
let (min, max) = (
|
||||
limits.min_y.unwrap_or(i32::MIN),
|
||||
limits.max_y.unwrap_or(i32::MAX),
|
||||
);
|
||||
let (mut sum, mut n) = (0i64, 0i64);
|
||||
let mut x = -radius;
|
||||
while x <= radius {
|
||||
let mut z = -radius;
|
||||
while z <= radius {
|
||||
let h = context.base_height(c[0] + x, c[2] + z, kind) - 1;
|
||||
if h > min && h < max {
|
||||
sum += i64::from(h);
|
||||
n += 1;
|
||||
}
|
||||
z += step;
|
||||
}
|
||||
x += step;
|
||||
}
|
||||
let mut average = (n > 0).then(|| sum as f64 / n as f64);
|
||||
if average.is_none() {
|
||||
average = limits.max_y.or(limits.min_y).map(f64::from);
|
||||
}
|
||||
let Some(mut average) = average else {
|
||||
pieces.clear();
|
||||
return;
|
||||
};
|
||||
if limits.no_liquid && !ocean_floor {
|
||||
average = average.max(f64::from(context.sea_level()));
|
||||
if let Some(max) = limits.max_y {
|
||||
// Math.max, as the mod has it.
|
||||
average = average.max(f64::from(max));
|
||||
}
|
||||
}
|
||||
let dy = average as i32 - b.min[1] + offset_y;
|
||||
shift_all(limits, pieces, [0, dy, 0]);
|
||||
}
|
||||
|
||||
/// The Nether variants: onto the highest or lowest land at the layout's
|
||||
/// center (or a fixed height), a ledge above it, within y_allowance.
|
||||
fn nether(
|
||||
limits: &Config,
|
||||
context: &mut impl StartContext,
|
||||
search: LandSearch,
|
||||
offset_y: i32,
|
||||
pieces: &mut [PoolPiece],
|
||||
) {
|
||||
let mut whole = pieces[0].bounding_box;
|
||||
for p in &pieces[1..] {
|
||||
whole.encapsulate(&p.bounding_box);
|
||||
}
|
||||
let sea = context.sea_level();
|
||||
let generation = context.generation();
|
||||
let terrain_limit = generation.min_y + generation.height;
|
||||
let base = pieces[0].bounding_box.min[1];
|
||||
let found = |context: &mut dyn ColumnQuery, highest: bool| {
|
||||
let c = whole.center();
|
||||
context.land(c[0], c[2], highest, !limits.no_liquid, sea, terrain_limit)
|
||||
};
|
||||
let mut target = match (limits.library, search) {
|
||||
(Library::Moogs, LandSearch::Fixed) => offset_y + limits.ledge,
|
||||
(library, search) => {
|
||||
let y = found(context, search == LandSearch::Highest);
|
||||
let at = if y < terrain_limit && y > sea + 1 {
|
||||
y
|
||||
} else {
|
||||
sea
|
||||
};
|
||||
if library == Library::Repurposed {
|
||||
shift_all(limits, pieces, [0, at + limits.ledge - base, 0]);
|
||||
return;
|
||||
}
|
||||
at + limits.ledge + offset_y
|
||||
}
|
||||
};
|
||||
let height = whole.max[1] - whole.min[1];
|
||||
let below = whole.min[1] - base;
|
||||
if let Some(top) = limits.max_y {
|
||||
target = target.min(top - height - below);
|
||||
}
|
||||
if let Some(bottom) = limits.min_y {
|
||||
target = target.max(bottom - below);
|
||||
}
|
||||
shift_all(limits, pieces, [0, target - base, 0]);
|
||||
}
|
||||
|
||||
/// GeneralUtils.getHighestLand and getLowestLand on the noise column.
|
||||
trait ColumnQuery {
|
||||
fn land(
|
||||
&mut self,
|
||||
x: i32,
|
||||
z: i32,
|
||||
highest: bool,
|
||||
on_liquid: bool,
|
||||
sea: i32,
|
||||
terrain_limit: i32,
|
||||
) -> i32;
|
||||
}
|
||||
impl<C: StartContext> ColumnQuery for C {
|
||||
fn land(
|
||||
&mut self,
|
||||
x: i32,
|
||||
z: i32,
|
||||
highest: bool,
|
||||
on_liquid: bool,
|
||||
sea: i32,
|
||||
terrain_limit: i32,
|
||||
) -> i32 {
|
||||
let min = self.generation().min_y;
|
||||
let mut columns = self.base_columns(
|
||||
x,
|
||||
z,
|
||||
&[HeightmapType::WorldSurfaceWg, HeightmapType::OceanFloorWg],
|
||||
);
|
||||
let solid = columns.pop().unwrap_or_default();
|
||||
let filled = columns.pop().unwrap_or_default();
|
||||
land_in(&filled, &solid, min, highest, on_liquid, sea, terrain_limit)
|
||||
}
|
||||
}
|
||||
|
||||
/// The land search over one noise column: `filled` (not air) and `solid`
|
||||
/// (canOcclude, for the noise's own blocks) from `min` up; past the
|
||||
/// column's ends a NoiseColumn reads air.
|
||||
fn land_in(
|
||||
filled: &[bool],
|
||||
solid: &[bool],
|
||||
min: i32,
|
||||
highest: bool,
|
||||
on_liquid: bool,
|
||||
sea: i32,
|
||||
terrain_limit: i32,
|
||||
) -> i32 {
|
||||
let at = |c: &[bool], y: i32| {
|
||||
usize::try_from(y - min)
|
||||
.ok()
|
||||
.and_then(|i| c.get(i).copied())
|
||||
.unwrap_or(false)
|
||||
};
|
||||
let air = |y: i32| !at(filled, y);
|
||||
let stands = |y: i32| if on_liquid { !air(y) } else { at(solid, y) };
|
||||
if highest {
|
||||
let mut y = terrain_limit - 40;
|
||||
while y > sea {
|
||||
if at(solid, y) && air(y + 3) && stands(y) {
|
||||
return y;
|
||||
}
|
||||
y -= 1;
|
||||
}
|
||||
y
|
||||
} else {
|
||||
let mut y = sea + 1;
|
||||
while y <= terrain_limit - 40 {
|
||||
if stands(y) && air(y + 1) && air(y + 5) {
|
||||
return y + 1;
|
||||
}
|
||||
y += 1;
|
||||
}
|
||||
sea
|
||||
}
|
||||
}
|
||||
|
||||
/// PieceLimitedJigsawManager.Assembler.
|
||||
struct Assembler<'a> {
|
||||
config: &'a JigsawConfig<'a>,
|
||||
limits: &'a Config,
|
||||
counted: &'a Counts,
|
||||
pools: &'a Pools,
|
||||
resources: &'a StructureResources,
|
||||
bindings: &'a FeatureBlockBindings<'a>,
|
||||
pieces: Vec<PoolPiece>,
|
||||
/// Per piece: the free space it was placed in, and its depth.
|
||||
states: Vec<(Rc<RefCell<Free>>, i32)>,
|
||||
/// Pieces placed per counted template.
|
||||
counts: Vec<i32>,
|
||||
max_y: i32,
|
||||
min_y: i32,
|
||||
}
|
||||
|
||||
/// Where a child goes: the parent's jigsaw and what it needs.
|
||||
struct Slot<'s> {
|
||||
source: usize,
|
||||
jigsaw: &'s super::jigsaw::Jigsaw,
|
||||
target_pos: [i32; 3],
|
||||
free: Rc<RefCell<Free>>,
|
||||
depth: i32,
|
||||
}
|
||||
|
||||
impl Assembler<'_> {
|
||||
fn pool(&self, name: &str) -> Option<Arc<super::jigsaw::Pool>> {
|
||||
let name = self.config.aliases.get(name).map_or(name, String::as_str);
|
||||
self.pools.get(name, self.resources, self.bindings)
|
||||
}
|
||||
/// generatePiece: one child per jigsaw where one fits, from the target
|
||||
/// pool unless the piece is at the last depth, else from its fallback.
|
||||
fn children(
|
||||
&mut self,
|
||||
source: usize,
|
||||
queue: &mut VecDeque<usize>,
|
||||
context: &mut impl StartContext,
|
||||
random: &mut impl RandomSource,
|
||||
) {
|
||||
let (element, position, rotation, source_box) = {
|
||||
let s = &self.pieces[source];
|
||||
(s.element.clone(), s.position, s.rotation, s.bounding_box)
|
||||
};
|
||||
let (context_free, depth) = self.states[source].clone();
|
||||
let mut source_free: Option<Rc<RefCell<Free>>> = None;
|
||||
for jigsaw in element.shuffled_jigsaws(self.resources, position, rotation, random) {
|
||||
let Some(target) = self.pool(&jigsaw.pool) else {
|
||||
continue;
|
||||
};
|
||||
if target.templates.is_empty() && jigsaw.pool != "minecraft:empty" {
|
||||
continue;
|
||||
}
|
||||
let s = step(jigsaw.front);
|
||||
let target_pos: [i32; 3] = std::array::from_fn(|i| jigsaw.pos[i] + s[i]);
|
||||
let free = if source_box.is_inside(target_pos) {
|
||||
source_free
|
||||
.get_or_insert_with(|| {
|
||||
Rc::new(RefCell::new(Free {
|
||||
container: source_box,
|
||||
removed: Vec::new(),
|
||||
}))
|
||||
})
|
||||
.clone()
|
||||
} else {
|
||||
context_free.clone()
|
||||
};
|
||||
let slot = Slot {
|
||||
source,
|
||||
jigsaw: &jigsaw,
|
||||
target_pos,
|
||||
free,
|
||||
depth,
|
||||
};
|
||||
if depth != self.config.max_depth
|
||||
&& self.process(&slot, target.raw.clone(), false, queue, context, random)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let Some(fallback) = self.pool(&target.fallback) else {
|
||||
continue;
|
||||
};
|
||||
let ignore = self.limits.ignore_bounds.contains(&target.fallback);
|
||||
self.process(&slot, fallback.raw.clone(), ignore, queue, context, random);
|
||||
}
|
||||
}
|
||||
/// processList: whether a piece was placed.
|
||||
fn process(
|
||||
&mut self,
|
||||
slot: &Slot<'_>,
|
||||
mut candidates: Vec<(Arc<PoolElement>, i32)>,
|
||||
ignore_bounds: bool,
|
||||
queue: &mut VecDeque<usize>,
|
||||
context: &mut impl StartContext,
|
||||
random: &mut impl RandomSource,
|
||||
) -> bool {
|
||||
let jigsaw = slot.jigsaw;
|
||||
let (source_rigid, source_y, source_ground) = {
|
||||
let s = &self.pieces[slot.source];
|
||||
(
|
||||
s.element.projection() == Projection::Rigid,
|
||||
s.bounding_box.min[1],
|
||||
s.ground_level_delta,
|
||||
)
|
||||
};
|
||||
let local_y = jigsaw.pos[1] - source_y;
|
||||
let mut surface = None;
|
||||
let (x, z) = (jigsaw.pos[0], jigsaw.pos[2]);
|
||||
let mut base =
|
||||
|context: &mut dyn SurfaceQuery| *surface.get_or_insert_with(|| context.surface(x, z));
|
||||
let mut total: i32 = candidates.iter().map(|c| c.1).sum();
|
||||
while !candidates.is_empty() {
|
||||
let mut chosen = None;
|
||||
// The first required piece still short is forced in once deep enough.
|
||||
let needed = self
|
||||
.limits
|
||||
.pieces
|
||||
.iter()
|
||||
.enumerate()
|
||||
.find(|(i, (_, c))| c.required.is_some_and(|r| self.counts[*i] < r));
|
||||
if let Some((need_index, (_, need))) = needed {
|
||||
let need_template = &self.counted.0[need_index];
|
||||
let found = candidates.iter().position(|(e, _)| {
|
||||
matches!(e.as_ref(), PoolElement::Single { template, .. }
|
||||
if Arc::ptr_eq(template, need_template))
|
||||
});
|
||||
if let Some(i) = found {
|
||||
if slot.depth >= (self.config.max_depth - 1).min(need.min_depth) {
|
||||
chosen = Some(i);
|
||||
} else {
|
||||
total -= candidates[i].1;
|
||||
candidates.remove(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
let index = match chosen {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
if total <= 0 || candidates.is_empty() {
|
||||
return false;
|
||||
}
|
||||
let mut weight = random.next_int_bound(total).unwrap_or(0) + 1;
|
||||
let mut found = candidates.len() - 1;
|
||||
for (i, (_, w)) in candidates.iter().enumerate() {
|
||||
weight -= w;
|
||||
if weight <= 0 {
|
||||
found = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
found
|
||||
}
|
||||
};
|
||||
let (target, weight) = candidates[index].clone();
|
||||
if matches!(target.as_ref(), PoolElement::Empty) {
|
||||
return false;
|
||||
}
|
||||
let counted = self.counted.of(&target);
|
||||
let full = counted.is_some_and(|i| {
|
||||
self.limits.pieces[i]
|
||||
.1
|
||||
.max
|
||||
.is_some_and(|m| self.counts[i] >= m)
|
||||
});
|
||||
if full {
|
||||
total -= weight;
|
||||
candidates.remove(index);
|
||||
continue;
|
||||
}
|
||||
let mut rotations = Rotation::ALL;
|
||||
shuffle(&mut rotations, random);
|
||||
for rotation in rotations {
|
||||
let target_jigsaws =
|
||||
target.shuffled_jigsaws(self.resources, [0; 3], rotation, random);
|
||||
let hack_box = target.bounding_box([0; 3], rotation);
|
||||
let expand_to = if self.config.use_expansion_hack && hack_box.span()[1] <= 16 {
|
||||
target_jigsaws
|
||||
.iter()
|
||||
.map(|tj| {
|
||||
let st = step(tj.front);
|
||||
if !hack_box.is_inside(std::array::from_fn(|i| tj.pos[i] + st[i])) {
|
||||
return 0;
|
||||
}
|
||||
let child = self.pool(&tj.pool);
|
||||
let child_size = child.as_ref().map_or(0, |p| p.max_size());
|
||||
let fallback_size = child
|
||||
.and_then(|p| self.pool(&p.fallback))
|
||||
.map_or(0, |p| p.max_size());
|
||||
child_size.max(fallback_size)
|
||||
})
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
for target_jigsaw in &target_jigsaws {
|
||||
if !can_attach(jigsaw, target_jigsaw) {
|
||||
continue;
|
||||
}
|
||||
let target_local = target_jigsaw.pos;
|
||||
let raw_position: [i32; 3] =
|
||||
std::array::from_fn(|i| slot.target_pos[i] - target_local[i]);
|
||||
let raw_box = target.bounding_box(raw_position, rotation);
|
||||
let target_rigid = target.projection() == Projection::Rigid;
|
||||
let delta_y = local_y - target_local[1] + step(jigsaw.front)[1];
|
||||
let target_y = if source_rigid && target_rigid {
|
||||
source_y + delta_y
|
||||
} else {
|
||||
base(context) - target_local[1]
|
||||
};
|
||||
let offset = target_y - raw_box.min[1];
|
||||
let mut target_box = raw_box.moved([0, offset, 0]);
|
||||
let target_position =
|
||||
[raw_position[0], raw_position[1] + offset, raw_position[2]];
|
||||
if expand_to > 0 {
|
||||
let size = (expand_to + 1).max(target_box.max[1] - target_box.min[1]);
|
||||
target_box.max[1] = target_box.min[1] + size;
|
||||
}
|
||||
if target_box.max[1] > self.max_y || target_box.min[1] < self.min_y {
|
||||
continue;
|
||||
}
|
||||
if !ignore_bounds && !slot.free.borrow().fits(&target_box) {
|
||||
continue;
|
||||
}
|
||||
let target_ground = if target_rigid {
|
||||
source_ground - delta_y
|
||||
} else {
|
||||
target.ground_level_delta()
|
||||
};
|
||||
let junction_y = if source_rigid {
|
||||
source_y + local_y
|
||||
} else if target_rigid {
|
||||
target_y + target_local[1]
|
||||
} else {
|
||||
base(context) + delta_y / 2
|
||||
};
|
||||
self.pieces[slot.source].junctions.push(Junction {
|
||||
source_x: slot.target_pos[0],
|
||||
source_ground_y: junction_y - local_y + source_ground,
|
||||
source_z: slot.target_pos[2],
|
||||
});
|
||||
slot.free.borrow_mut().removed.push(target_box);
|
||||
self.pieces.push(PoolPiece {
|
||||
element: target.clone(),
|
||||
position: target_position,
|
||||
ground_level_delta: target_ground,
|
||||
rotation,
|
||||
bounding_box: target_box,
|
||||
junctions: vec![Junction {
|
||||
source_x: jigsaw.pos[0],
|
||||
source_ground_y: junction_y - target_local[1] + target_ground,
|
||||
source_z: jigsaw.pos[2],
|
||||
}],
|
||||
waterlogging: self.config.waterlogging,
|
||||
});
|
||||
self.states.push((slot.free.clone(), slot.depth + 1));
|
||||
if slot.depth < self.config.max_depth {
|
||||
queue.push_back(self.pieces.len() - 1);
|
||||
}
|
||||
if let Some(i) = counted {
|
||||
self.counts[i] += 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
total -= weight;
|
||||
candidates.remove(index);
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// The surface height query, object-safe for the per-call cache.
|
||||
trait SurfaceQuery {
|
||||
fn surface(&mut self, x: i32, z: i32) -> i32;
|
||||
}
|
||||
impl<C: StartContext> SurfaceQuery for C {
|
||||
fn surface(&mut self, x: i32, z: i32) -> i32 {
|
||||
self.base_height(x, z, HeightmapType::WorldSurfaceWg)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn required_pieces_follow_javas_hash_map() {
|
||||
let limits = Config::decode(&json!({"library": "repurposed", "pieces": [
|
||||
{"name": "rs:city/a", "required": 1},
|
||||
{"name": "rs:city/x", "max": 2},
|
||||
{"name": "rs:city/b", "required": 1, "min_depth": 3},
|
||||
{"name": "rs:city/c", "required": 2},
|
||||
{"name": "rs:city/a", "required": 4}]}));
|
||||
let names: Vec<String> = limits.pieces.iter().map(|(id, _)| id.to_string()).collect();
|
||||
// Buckets 3, 2, 1 of the copied map's 4: c, b, a; then the capped one.
|
||||
assert_eq!(names, ["rs:city/c", "rs:city/b", "rs:city/a", "rs:city/x"]);
|
||||
assert_eq!(
|
||||
limits.pieces[2].1.required,
|
||||
Some(4),
|
||||
"a later entry replaces"
|
||||
);
|
||||
assert_eq!(limits.pieces[1].1.min_depth, 3);
|
||||
assert_eq!(limits.library, Library::Repurposed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nether_land_is_found_in_the_column() {
|
||||
// A column from y 0: netherrack to 40, lava 41..=45, air, a ledge 70..=72.
|
||||
let (mut filled, mut solid) = (vec![false; 128], vec![false; 128]);
|
||||
for y in 0..=45 {
|
||||
filled[y] = true;
|
||||
solid[y] = y <= 40;
|
||||
}
|
||||
for y in 70..=72 {
|
||||
filled[y] = true;
|
||||
solid[y] = true;
|
||||
}
|
||||
// Highest: from 88 down, a solid block with air 3 above.
|
||||
assert_eq!(land_in(&filled, &solid, 0, true, true, 32, 128), 72);
|
||||
// Lowest: from 33 up, a block to stand on with air 1 and 5 above; one up.
|
||||
assert_eq!(land_in(&filled, &solid, 0, false, true, 32, 128), 46);
|
||||
assert_eq!(land_in(&filled, &solid, 0, false, false, 32, 128), 73);
|
||||
// Nothing found: the highest search stops at the sea level.
|
||||
let empty = vec![false; 128];
|
||||
assert_eq!(land_in(&empty, &empty, 0, true, true, 32, 128), 32);
|
||||
assert_eq!(land_in(&empty, &empty, 0, false, true, 32, 128), 32);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn repurposed_moves_junctions_as_its_code_does() {
|
||||
let template = Arc::new(StructureTemplate::empty());
|
||||
let element = Arc::new(PoolElement::Single {
|
||||
template,
|
||||
processors: Default::default(),
|
||||
legacy: false,
|
||||
projection: Projection::Rigid,
|
||||
waterlogging: None,
|
||||
yung: None,
|
||||
});
|
||||
let piece = || PoolPiece {
|
||||
bounding_box: BoundingBox::new([0; 3], [4; 3]),
|
||||
ground_level_delta: 1,
|
||||
element: element.clone(),
|
||||
position: [0; 3],
|
||||
rotation: Rotation::None,
|
||||
junctions: vec![Junction {
|
||||
source_x: 1,
|
||||
source_ground_y: 2,
|
||||
source_z: 3,
|
||||
}],
|
||||
waterlogging: true,
|
||||
};
|
||||
let moogs = Config::decode(&json!({}));
|
||||
let rs = Config::decode(&json!({"library": "repurposed"}));
|
||||
let (mut a, mut b) = (piece(), piece());
|
||||
shift(&moogs, &mut a, [10, 20, 30]);
|
||||
shift(&rs, &mut b, [10, 20, 30]);
|
||||
assert_eq!(a.bounding_box, BoundingBox::new([10, 20, 30], [14, 24, 34]));
|
||||
assert_eq!(a.position, [10, 20, 30]);
|
||||
assert_eq!(a.junctions[0].source_x, 1);
|
||||
// movePieceProperly sets the source X three times; Z + dz is left.
|
||||
assert_eq!(b.junctions[0].source_x, 33);
|
||||
assert_eq!(b.junctions[0].source_ground_y, 2);
|
||||
}
|
||||
}
|
||||
@@ -57,6 +57,11 @@ pub struct JigsawDef {
|
||||
waterlogging: bool,
|
||||
/// A carried mod's start rules (`"horizon:start_checks"`).
|
||||
checks: super::start_checks::StartChecks,
|
||||
/// Laid out by YUNG's API's assembler (`"horizon:yungsapi"`).
|
||||
yung: Option<super::yung::Config>,
|
||||
/// Laid out by Repurposed Structures' and Moog's piece-limited
|
||||
/// assembler (`"horizon:piece_limited"`).
|
||||
piece_limited: Option<super::piece_limited::Config>,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub enum StructureKind {
|
||||
@@ -97,6 +102,9 @@ pub struct StructureDef {
|
||||
pub biomes: BTreeSet<BiomeId>,
|
||||
pub step: usize,
|
||||
pub terrain: TerrainAdjustment,
|
||||
/// Another loaded structure turns this one's type off
|
||||
/// (`"horizon:disables"`): it never starts.
|
||||
pub disabled: bool,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
enum Reduction {
|
||||
@@ -137,6 +145,107 @@ pub struct StructureSet {
|
||||
/// (`"horizon:exclusion_zone"`: `other_sets`, `chunk_count`).
|
||||
min_distance: Option<i64>,
|
||||
avoid: Option<(Vec<String>, i32)>,
|
||||
/// `"horizon:ring_sections"`: starts only in odd rings around the origin.
|
||||
rings: Option<RingSections>,
|
||||
/// `"horizon:avoid_biomes"`: no start with one of these biomes near.
|
||||
avoid_biomes: Option<AvoidBiomes>,
|
||||
}
|
||||
|
||||
/// YUNG's Better Strongholds' placement (BetterStrongholdsPlacement
|
||||
/// .isPlacementChunk): the world is cut into rings `thickness` chunks wide,
|
||||
/// the first one starting `distance_to_first_ring` chunks out; a start is
|
||||
/// placed only in the odd ones, and in none past `max_section`.
|
||||
///
|
||||
/// ```json
|
||||
/// "horizon:ring_sections": {"distance_to_first_ring": 80, "thickness": 96, "max_section": 5}
|
||||
/// ```
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
struct RingSections {
|
||||
first: i32,
|
||||
thickness: i32,
|
||||
max: Option<i32>,
|
||||
}
|
||||
impl RingSections {
|
||||
fn decode(v: &Value) -> Self {
|
||||
let int = |k: &str| v[k].as_i64().map(|n| n as i32);
|
||||
Self {
|
||||
first: int("distance_to_first_ring").unwrap_or(0),
|
||||
thickness: int("thickness").unwrap_or(1).max(1),
|
||||
max: int("max_section"),
|
||||
}
|
||||
}
|
||||
fn allows(&self, x: i32, z: i32) -> bool {
|
||||
// Java int arithmetic: the squares wrap past 46,340 chunks, and the
|
||||
// square root of a negative int is NaN, which casts to 0.
|
||||
let squared = x.wrapping_mul(x).wrapping_add(z.wrapping_mul(z));
|
||||
let distance = f64::from(squared).sqrt() as i32;
|
||||
let section = distance.wrapping_add(self.thickness - self.first) / self.thickness;
|
||||
!self.max.is_some_and(|max| section > max) && section % 2 == 1
|
||||
}
|
||||
}
|
||||
|
||||
/// YUNG's Better Desert and Jungle Temples' placement: no start when a
|
||||
/// biome of the set is found around the chunk's middle block at height `y`
|
||||
/// (BiomeSource.findBiomeHorizontal with `radius` blocks and `step` quarts
|
||||
/// between samples, closest first).
|
||||
///
|
||||
/// ```json
|
||||
/// "horizon:avoid_biomes": {"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"],
|
||||
/// "radius": 48, "step": 2, "y": 120}
|
||||
/// ```
|
||||
#[derive(Debug)]
|
||||
struct AvoidBiomes {
|
||||
biomes: BTreeSet<BiomeId>,
|
||||
radius: i32,
|
||||
step: i32,
|
||||
y: i32,
|
||||
}
|
||||
impl AvoidBiomes {
|
||||
fn decode(
|
||||
v: &Value,
|
||||
biome_set: &dyn Fn(&Value) -> Result<BTreeSet<BiomeId>, DecodeError>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let mut biomes = BTreeSet::new();
|
||||
match &v["biomes"] {
|
||||
Value::Array(list) => {
|
||||
for entry in list {
|
||||
biomes.extend(biome_set(entry)?);
|
||||
}
|
||||
}
|
||||
other => biomes = biome_set(other)?,
|
||||
}
|
||||
let int = |k: &str, default: i32| v[k].as_i64().map_or(default, |n| n as i32);
|
||||
Ok(Self {
|
||||
biomes,
|
||||
radius: int("radius", 0),
|
||||
step: int("step", 1).max(1),
|
||||
y: int("y", 0),
|
||||
})
|
||||
}
|
||||
fn near(&self, chunk: ChunkPos, mut biome: impl FnMut([i32; 3]) -> BiomeId) -> bool {
|
||||
// ChunkPos.getMiddleBlockPosition, then QuartPos.fromBlock.
|
||||
let (cx, cz) = ((chunk.x * 16 + 8) >> 2, (chunk.z * 16 + 8) >> 2);
|
||||
let (radius, y) = (self.radius >> 2, self.y >> 2);
|
||||
let mut r = 0;
|
||||
while r <= radius {
|
||||
let mut dz = -r;
|
||||
while dz <= r {
|
||||
let z_edge = dz.abs() == r;
|
||||
let mut dx = -r;
|
||||
while dx <= r {
|
||||
if (z_edge || dx.abs() == r)
|
||||
&& self.biomes.contains(&biome([cx + dx, y, cz + dz]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
dx += self.step;
|
||||
}
|
||||
dz += self.step;
|
||||
}
|
||||
r += self.step;
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn heightmap(name: &str) -> Option<HeightmapType> {
|
||||
@@ -182,8 +291,19 @@ impl StructureRegistry {
|
||||
biome_set: &dyn Fn(&Value) -> Result<BTreeSet<BiomeId>, DecodeError>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let mut defs = Vec::new();
|
||||
let (mut types, mut disables) = (Vec::new(), BTreeSet::new());
|
||||
for (name, json) in structures {
|
||||
let v: Value = serde_json::from_str(json)?;
|
||||
types.push(v["type"].as_str().unwrap_or_default().to_owned());
|
||||
// YUNG's mods turn their vanilla counterparts off (the
|
||||
// DisableVanilla*Mixin on ChunkGenerator.tryGenerateStructure).
|
||||
disables.extend(
|
||||
v["horizon:disables"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|t| Some(t.as_str()?.to_owned())),
|
||||
);
|
||||
let kind = match v["type"].as_str().unwrap_or_default() {
|
||||
"minecraft:jigsaw" => StructureKind::Jigsaw(JigsawDef {
|
||||
start_pool: v["start_pool"].as_str().unwrap_or_default().to_owned(),
|
||||
@@ -202,6 +322,10 @@ impl StructureRegistry {
|
||||
padding: pair(v.get("dimension_padding"), "bottom", "top", 0),
|
||||
waterlogging: v["liquid_settings"].as_str() != Some("ignore_waterlogging"),
|
||||
checks: super::start_checks::StartChecks::decode(v.get("horizon:start_checks")),
|
||||
yung: v.get("horizon:yungsapi").map(super::yung::Config::decode),
|
||||
piece_limited: v
|
||||
.get("horizon:piece_limited")
|
||||
.map(super::piece_limited::Config::decode),
|
||||
}),
|
||||
"minecraft:buried_treasure" => StructureKind::BuriedTreasure,
|
||||
"minecraft:igloo" => StructureKind::Igloo,
|
||||
@@ -251,8 +375,12 @@ impl StructureRegistry {
|
||||
.position(|s| Some(*s) == v["step"].as_str())
|
||||
.unwrap_or(4),
|
||||
terrain: terrain(v["terrain_adaptation"].as_str()),
|
||||
disabled: false,
|
||||
});
|
||||
}
|
||||
for (def, kind) in defs.iter_mut().zip(&types) {
|
||||
def.disabled = disables.contains(kind);
|
||||
}
|
||||
let index = |name: &str| defs.iter().position(|d| d.name == name);
|
||||
let mut out = Vec::new();
|
||||
for (name, json) in sets {
|
||||
@@ -314,6 +442,11 @@ impl StructureRegistry {
|
||||
z["chunk_count"].as_i64().unwrap_or(0) as i32,
|
||||
)
|
||||
}),
|
||||
rings: p.get("horizon:ring_sections").map(RingSections::decode),
|
||||
avoid_biomes: p
|
||||
.get("horizon:avoid_biomes")
|
||||
.map(|a| AvoidBiomes::decode(a, biome_set))
|
||||
.transpose()?,
|
||||
});
|
||||
}
|
||||
Ok(Self {
|
||||
@@ -420,6 +553,9 @@ impl StructureRegistry {
|
||||
if !placed {
|
||||
return false;
|
||||
}
|
||||
if set.rings.as_ref().is_some_and(|r| !r.allows(x, z)) {
|
||||
return false;
|
||||
}
|
||||
// AdvancedRandomSpread.isPlacementChunk, in blocks from the chunk's corner.
|
||||
if let Some(d) = set.min_distance {
|
||||
let (bx, bz) = (i64::from(x) * 16, i64::from(z) * 16);
|
||||
@@ -591,6 +727,16 @@ pub fn create_starts(
|
||||
if !registry.is_structure_chunk(set, seed, chunk.x, chunk.z, rings) {
|
||||
continue;
|
||||
}
|
||||
// Part of the set's placement in YUNG's mods; checked here, where the
|
||||
// biome source is at hand, so another set's exclusion zone naming
|
||||
// this one does not see it.
|
||||
if set
|
||||
.avoid_biomes
|
||||
.as_ref()
|
||||
.is_some_and(|a| a.near(chunk, |q| context.noise_biome(q)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if set.structures.len() == 1 {
|
||||
if let Some(start) = try_generate(
|
||||
registry,
|
||||
@@ -640,6 +786,9 @@ fn try_generate(
|
||||
chunk: ChunkPos,
|
||||
) -> Option<StructureStart> {
|
||||
let def = ®istry.structures[structure];
|
||||
if def.disabled {
|
||||
return None;
|
||||
}
|
||||
context.set_valid_biomes(&def.biomes);
|
||||
let seed = context.seed();
|
||||
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
|
||||
@@ -669,16 +818,40 @@ fn try_generate(
|
||||
padding: jigsaw.padding,
|
||||
waterlogging: jigsaw.waterlogging,
|
||||
};
|
||||
let (position, mut pieces) = assemble(
|
||||
&config,
|
||||
context,
|
||||
®istry.pools,
|
||||
resources,
|
||||
bindings,
|
||||
&mut random,
|
||||
start,
|
||||
)?;
|
||||
if jigsaw.max_depth <= 0 {
|
||||
let (position, mut pieces) = match (&jigsaw.yung, &jigsaw.piece_limited) {
|
||||
(_, Some(limits)) => super::piece_limited::assemble(
|
||||
&config,
|
||||
limits,
|
||||
context,
|
||||
®istry.pools,
|
||||
resources,
|
||||
bindings,
|
||||
chunk,
|
||||
start,
|
||||
)?,
|
||||
(Some(yung), None) => super::yung::assemble(
|
||||
&config,
|
||||
yung,
|
||||
context,
|
||||
®istry.pools,
|
||||
resources,
|
||||
bindings,
|
||||
&mut random,
|
||||
start,
|
||||
)?,
|
||||
(None, None) => assemble(
|
||||
&config,
|
||||
context,
|
||||
®istry.pools,
|
||||
resources,
|
||||
bindings,
|
||||
&mut random,
|
||||
start,
|
||||
)?,
|
||||
};
|
||||
// Vanilla's JigsawPlacement keeps no piece at size 0; the
|
||||
// piece-limited assembler keeps the start piece.
|
||||
if jigsaw.max_depth <= 0 && jigsaw.piece_limited.is_none() {
|
||||
pieces.clear();
|
||||
}
|
||||
(
|
||||
@@ -1114,3 +1287,106 @@ pub fn place_in_chunk<W: FeatureWorld + PlacementContext, R: RandomSource + 'sta
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
fn registry(structures: &[(&str, Value)], sets: &[(&str, Value)]) -> StructureRegistry {
|
||||
let text = |l: &[(&str, Value)]| {
|
||||
l.iter()
|
||||
.map(|(k, v)| ((*k).to_owned(), v.to_string()))
|
||||
.collect::<BTreeMap<_, _>>()
|
||||
};
|
||||
// Biome tags: `#t:one` is biome 1, `#t:two` biome 2.
|
||||
StructureRegistry::new(&text(structures), &text(sets), BTreeMap::new(), &|v| {
|
||||
Ok(match v.as_str() {
|
||||
Some("#t:one") => BTreeSet::from([BiomeId(1)]),
|
||||
Some("#t:two") => BTreeSet::from([BiomeId(2)]),
|
||||
_ => BTreeSet::new(),
|
||||
})
|
||||
})
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_structure_turns_its_vanilla_counterpart_off() {
|
||||
let r = registry(
|
||||
&[
|
||||
(
|
||||
"minecraft:pyramid",
|
||||
json!({"type": "minecraft:desert_pyramid"}),
|
||||
),
|
||||
("minecraft:igloo", json!({"type": "minecraft:igloo"})),
|
||||
(
|
||||
"yung:temple",
|
||||
json!({"type": "minecraft:swamp_hut", "horizon:disables": ["minecraft:desert_pyramid"]}),
|
||||
),
|
||||
],
|
||||
&[],
|
||||
);
|
||||
let disabled: Vec<_> = r
|
||||
.structures
|
||||
.iter()
|
||||
.map(|d| (d.name.as_str(), d.disabled))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
disabled,
|
||||
[
|
||||
("minecraft:igloo", false),
|
||||
("minecraft:pyramid", true),
|
||||
("yung:temple", false)
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ring_sections_keep_the_odd_rings() {
|
||||
let rings = RingSections::decode(
|
||||
&json!({"distance_to_first_ring": 80, "thickness": 96, "max_section": 3}),
|
||||
);
|
||||
// (d + 16) / 96: 0 inside 80 chunks, 1 to 175, 2 to 271, 3 to 367.
|
||||
assert!(!rings.allows(79, 0));
|
||||
assert!(rings.allows(80, 0));
|
||||
assert!(rings.allows(0, -175));
|
||||
assert!(!rings.allows(176, 0));
|
||||
assert!(rings.allows(272, 0));
|
||||
assert!(!rings.allows(464, 0), "section 5 is past max_section 3");
|
||||
// Java's int square wraps: 50,000² + 0 is negative, its root NaN, 0.
|
||||
assert!(!rings.allows(50_000, 0));
|
||||
let open = RingSections::decode(&json!({"distance_to_first_ring": 80, "thickness": 96}));
|
||||
assert!(open.allows(464, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn avoid_biomes_samples_around_the_middle_block() {
|
||||
let r = registry(
|
||||
&[],
|
||||
&[(
|
||||
"yung:temples",
|
||||
json!({"structures": [], "placement": {"type": "minecraft:random_spread",
|
||||
"spacing": 24, "separation": 8, "salt": 1,
|
||||
"horizon:avoid_biomes": {"biomes": ["#t:one", "#t:two"],
|
||||
"radius": 48, "step": 2, "y": 120}}}),
|
||||
)],
|
||||
);
|
||||
let avoid = r.sets[0].avoid_biomes.as_ref().unwrap();
|
||||
assert_eq!(avoid.biomes, BTreeSet::from([BiomeId(1), BiomeId(2)]));
|
||||
// Chunk (1, -1): middle block (24, 120, -8), quart (6, 30, -2).
|
||||
let mut asked = Vec::new();
|
||||
assert!(!avoid.near(ChunkPos::new(1, -1), |q| {
|
||||
asked.push(q);
|
||||
BiomeId(0)
|
||||
}));
|
||||
assert_eq!(asked[0], [6, 30, -2]);
|
||||
// Every even offset within 12 quarts, once: 13 x 13.
|
||||
assert_eq!(asked.len(), 169);
|
||||
assert!(asked.contains(&[6 - 12, 30, -2 + 12]));
|
||||
assert!(!asked.contains(&[7, 30, -2]));
|
||||
// An ocean on the edge of the square is found.
|
||||
assert!(avoid.near(ChunkPos::new(1, -1), |q| {
|
||||
BiomeId(if q == [18, 30, 10] { 2 } else { 0 })
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,727 @@
|
||||
//! YUNG's API's jigsaw assembler, for the structures of the "YUNG's Better"
|
||||
//! mods carried over from a modpack (docs/modpacks.md). Carry maps
|
||||
//! `yungsapi:yung_jigsaw` to `minecraft:jigsaw` with a `"horizon:yungsapi"`
|
||||
//! key, and its pool elements to vanilla's single element with the piece's
|
||||
//! rules under the same key; vanilla data never has it.
|
||||
//!
|
||||
//! The assembler differs from vanilla's JigsawPlacement: it picks the start
|
||||
//! piece and every child by weight from the pool's weighted entries (a
|
||||
//! priority piece first), lays pieces out breadth first, caps pieces by name
|
||||
//! (`max_count`), limits them by depth, lets some ignore the bounds, checks
|
||||
//! each piece's condition, and keeps every piece between `min_y` and
|
||||
//! `max_y`. Pieces fit the same free space as vanilla's.
|
||||
use super::{
|
||||
BoundingBox, Rotation, StructureResources, StructureTemplate,
|
||||
jigsaw::{
|
||||
Free, JigsawConfig, JigsawContext, Junction, PoolElement, PoolPiece, Pools, Projection,
|
||||
can_attach, shuffle, step,
|
||||
},
|
||||
};
|
||||
use crate::{
|
||||
heightmap::HeightmapType,
|
||||
worldgen::{DecodeError, block_feature::FeatureBlockBindings},
|
||||
};
|
||||
use horizon_core::random::RandomSource;
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
collections::{HashMap, VecDeque},
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
/// A YUNG structure's own settings (`"horizon:yungsapi"` on the structure):
|
||||
/// the heights every piece must stay within.
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Config {
|
||||
pub min_y: Option<i32>,
|
||||
pub max_y: Option<i32>,
|
||||
}
|
||||
impl Config {
|
||||
pub fn decode(v: &Value) -> Self {
|
||||
let y = |k: &str| v[k].as_i64().map(|n| n as i32);
|
||||
Self {
|
||||
min_y: y("min_y"),
|
||||
max_y: y("max_y"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A piece's rules (`"horizon:yungsapi"` on a pool element).
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Rules {
|
||||
/// Pieces sharing a name share the cap `max_count`.
|
||||
name: Option<String>,
|
||||
max_count: Option<i32>,
|
||||
min_depth: Option<i32>,
|
||||
max_depth: Option<i32>,
|
||||
/// Chosen before any other piece of its pool.
|
||||
priority: bool,
|
||||
/// Placed even where it overlaps other pieces or leaves the bounds.
|
||||
ignore_bounds: bool,
|
||||
condition: Condition,
|
||||
}
|
||||
impl Rules {
|
||||
pub fn decode(v: &Value, resources: &StructureResources) -> Result<Self, DecodeError> {
|
||||
let int = |k: &str| v[k].as_i64().map(|n| n as i32);
|
||||
Ok(Self {
|
||||
name: v["name"].as_str().map(str::to_owned),
|
||||
max_count: int("max_count"),
|
||||
min_depth: int("min_depth"),
|
||||
max_depth: int("max_depth"),
|
||||
priority: v["priority"].as_bool().unwrap_or(false),
|
||||
ignore_bounds: v["ignore_bounds"].as_bool().unwrap_or(false),
|
||||
condition: match v.get("condition") {
|
||||
Some(c) => Condition::decode(c, resources)?,
|
||||
None => Condition::True,
|
||||
},
|
||||
})
|
||||
}
|
||||
/// YungJigsawPoolElement.isAtValidDepth.
|
||||
fn at_valid_depth(&self, depth: i32) -> bool {
|
||||
self.min_depth.is_none_or(|d| d <= depth) && self.max_depth.is_none_or(|d| d >= depth)
|
||||
}
|
||||
/// The name a capped piece counts under: `max_count` without a name is
|
||||
/// ignored, as YUNG's does.
|
||||
fn capped(&self) -> Option<(&str, i32)> {
|
||||
Some((self.name.as_deref()?, self.max_count?))
|
||||
}
|
||||
}
|
||||
|
||||
/// YUNG's structure conditions, as carry writes them.
|
||||
#[derive(Debug, Default)]
|
||||
enum Condition {
|
||||
#[default]
|
||||
True,
|
||||
False,
|
||||
Not(Box<Condition>),
|
||||
AllOf(Vec<Condition>),
|
||||
AnyOf(Vec<Condition>),
|
||||
Depth {
|
||||
min: Option<i32>,
|
||||
max: Option<i32>,
|
||||
},
|
||||
Altitude {
|
||||
bottom: Option<f64>,
|
||||
top: Option<f64>,
|
||||
},
|
||||
RandomChance(f32),
|
||||
Rotation(Vec<Rotation>),
|
||||
/// Another piece (of these templates, or any) within `range` blocks in
|
||||
/// the direction `rotation` turns the piece's own north.
|
||||
PieceInDirection {
|
||||
templates: Vec<Arc<StructureTemplate>>,
|
||||
range: i32,
|
||||
rotation: Rotation,
|
||||
},
|
||||
}
|
||||
impl Condition {
|
||||
fn decode(v: &Value, resources: &StructureResources) -> Result<Self, DecodeError> {
|
||||
let list = |k: &'static str| -> Result<Vec<Condition>, DecodeError> {
|
||||
v[k].as_array()
|
||||
.ok_or(DecodeError::Field(k))?
|
||||
.iter()
|
||||
.map(|c| Self::decode(c, resources))
|
||||
.collect()
|
||||
};
|
||||
let int = |k: &str| v[k].as_i64().map(|n| n as i32);
|
||||
let rotation = |r: &Value| {
|
||||
r.as_str()
|
||||
.and_then(Rotation::from_name)
|
||||
.ok_or(DecodeError::Field("condition rotation"))
|
||||
};
|
||||
Ok(match v["type"].as_str().unwrap_or_default() {
|
||||
"true" => Self::True,
|
||||
"false" => Self::False,
|
||||
"not" => Self::Not(Box::new(Self::decode(&v["condition"], resources)?)),
|
||||
"all_of" => Self::AllOf(list("conditions")?),
|
||||
"any_of" => Self::AnyOf(list("conditions")?),
|
||||
"depth" => Self::Depth {
|
||||
min: int("min_depth"),
|
||||
max: int("max_depth"),
|
||||
},
|
||||
"altitude" => Self::Altitude {
|
||||
bottom: v["bottom"].as_f64(),
|
||||
top: v["top"].as_f64(),
|
||||
},
|
||||
"random_chance" => Self::RandomChance(v["chance"].as_f64().unwrap_or(0.) as f32),
|
||||
"rotation" => Self::Rotation(
|
||||
v["rotations"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(rotation)
|
||||
.collect::<Result<_, _>>()?,
|
||||
),
|
||||
"piece_in_horizontal_direction" => Self::PieceInDirection {
|
||||
templates: v["pieces"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|p| resources.template(p.as_str()?))
|
||||
.collect(),
|
||||
range: int("range").unwrap_or(0),
|
||||
rotation: rotation(&v["rotation"])?,
|
||||
},
|
||||
_ => return Err(DecodeError::Field("YUNG condition type")),
|
||||
})
|
||||
}
|
||||
/// StructureCondition.passes. `at` is the piece being placed: its box,
|
||||
/// rotation and depth; the start piece has no box yet.
|
||||
fn passes(&self, at: &At<'_>, random: &mut impl RandomSource) -> bool {
|
||||
match self {
|
||||
Self::True => true,
|
||||
Self::False => false,
|
||||
Self::Not(c) => !c.passes(at, random),
|
||||
Self::AllOf(all) => all.iter().all(|c| c.passes(at, random)),
|
||||
Self::AnyOf(any) => any.iter().any(|c| c.passes(at, random)),
|
||||
Self::Depth { min, max } => {
|
||||
min.is_none_or(|d| d <= at.depth) && max.is_none_or(|d| d >= at.depth)
|
||||
}
|
||||
Self::Altitude { bottom, top } => {
|
||||
let [low, high] = at.piece.map_or([0, 0], |b| [b.min[1], b.max[1]]);
|
||||
bottom.is_none_or(|y| f64::from(low) >= y)
|
||||
&& top.is_none_or(|y| f64::from(high) <= y)
|
||||
}
|
||||
Self::RandomChance(chance) => random.next_float() < *chance,
|
||||
Self::Rotation(valid) => valid.contains(&at.rotation),
|
||||
Self::PieceInDirection {
|
||||
templates,
|
||||
range,
|
||||
rotation,
|
||||
} => {
|
||||
let Some(piece) = at.piece else {
|
||||
return false;
|
||||
};
|
||||
let mut search = piece;
|
||||
match at.rotation.get_rotated(*rotation) {
|
||||
Rotation::None => search.min[2] -= range,
|
||||
Rotation::Clockwise90 => search.max[0] += range,
|
||||
Rotation::Clockwise180 => search.max[2] += range,
|
||||
Rotation::Counterclockwise90 => search.min[0] -= range,
|
||||
}
|
||||
at.pieces.iter().any(|other| {
|
||||
let PoolElement::Single { template, .. } = other.element.as_ref() else {
|
||||
return false;
|
||||
};
|
||||
let b = other.bounding_box;
|
||||
b != piece
|
||||
&& (templates.is_empty()
|
||||
|| templates.iter().any(|t| Arc::ptr_eq(t, template)))
|
||||
&& b.intersects(&search)
|
||||
&& !b.intersects(&piece)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The surface height query, object-safe for the per-call cache.
|
||||
trait JigsawContextDyn {
|
||||
fn surface(&mut self, x: i32, z: i32) -> i32;
|
||||
}
|
||||
impl<C: JigsawContext> JigsawContextDyn for C {
|
||||
fn surface(&mut self, x: i32, z: i32) -> i32 {
|
||||
self.base_height(x, z, HeightmapType::WorldSurfaceWg)
|
||||
}
|
||||
}
|
||||
|
||||
/// What a condition sees of the piece being placed.
|
||||
struct At<'a> {
|
||||
depth: i32,
|
||||
rotation: Rotation,
|
||||
piece: Option<BoundingBox>,
|
||||
pieces: &'a [PoolPiece],
|
||||
}
|
||||
|
||||
/// The index of the entry to try: the first priority piece, else one drawn
|
||||
/// by weight (`nextInt(total) + 1`, counted down).
|
||||
fn pick(
|
||||
candidates: &[(Arc<PoolElement>, i32)],
|
||||
total: i32,
|
||||
random: &mut impl RandomSource,
|
||||
) -> usize {
|
||||
if let Some(i) = candidates
|
||||
.iter()
|
||||
.position(|(e, _)| e.yung().is_some_and(|r| r.priority))
|
||||
{
|
||||
return i;
|
||||
}
|
||||
let mut chosen = random.next_int_bound(total).unwrap_or(0) + 1;
|
||||
for (i, (_, weight)) in candidates.iter().enumerate() {
|
||||
chosen -= weight;
|
||||
if chosen <= 0 {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
candidates.len() - 1
|
||||
}
|
||||
|
||||
/// JigsawManager.assembleJigsawStructure: the start position and the
|
||||
/// pieces, or None when no start piece fits.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn assemble(
|
||||
config: &JigsawConfig<'_>,
|
||||
yung: &Config,
|
||||
context: &mut impl JigsawContext,
|
||||
pools: &Pools,
|
||||
resources: &StructureResources,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
random: &mut impl RandomSource,
|
||||
position: [i32; 3],
|
||||
) -> Option<([i32; 3], Vec<PoolPiece>)> {
|
||||
let pool = pools.get(config.start_pool, resources, bindings)?;
|
||||
let mut candidates = pool.raw.clone();
|
||||
shuffle(&mut candidates, random);
|
||||
let rotation = Rotation::random(random);
|
||||
let mut total: i32 = candidates.iter().map(|c| c.1).sum();
|
||||
let (element, adjusted, local) = loop {
|
||||
if candidates.is_empty() || total <= 0 {
|
||||
return None;
|
||||
}
|
||||
let index = pick(&candidates, total, random);
|
||||
let (element, weight) = candidates[index].clone();
|
||||
if matches!(element.as_ref(), PoolElement::Empty) {
|
||||
return None;
|
||||
}
|
||||
let anchored = match config.start_jigsaw {
|
||||
Some(name) => {
|
||||
element
|
||||
.shuffled_jigsaws(resources, position, rotation, random)
|
||||
.into_iter()
|
||||
.find(|j| j.name.as_deref() == Some(name))?
|
||||
.pos
|
||||
}
|
||||
None => position,
|
||||
};
|
||||
let local: [i32; 3] = std::array::from_fn(|i| anchored[i] - position[i]);
|
||||
let adjusted: [i32; 3] = std::array::from_fn(|i| position[i] - local[i]);
|
||||
let at = At {
|
||||
depth: 0,
|
||||
rotation,
|
||||
piece: None,
|
||||
pieces: &[],
|
||||
};
|
||||
if element
|
||||
.yung()
|
||||
.is_some_and(|r| !r.condition.passes(&at, random))
|
||||
{
|
||||
total -= weight;
|
||||
candidates.remove(index);
|
||||
continue;
|
||||
}
|
||||
break (element, adjusted, local);
|
||||
};
|
||||
let mut start = PoolPiece {
|
||||
bounding_box: element.bounding_box(adjusted, rotation),
|
||||
ground_level_delta: element.ground_level_delta(),
|
||||
element,
|
||||
position: adjusted,
|
||||
rotation,
|
||||
junctions: Vec::new(),
|
||||
waterlogging: config.waterlogging,
|
||||
};
|
||||
let b = start.bounding_box;
|
||||
let (cx, cz) = ((b.max[0] + b.min[0]) / 2, (b.max[2] + b.min[2]) / 2);
|
||||
let bottom = match config.project_to {
|
||||
Some(kind) => position[1] + context.base_height(cx, cz, kind),
|
||||
None => adjusted[1],
|
||||
};
|
||||
start.moved(bottom - (b.min[1] + start.ground_level_delta));
|
||||
let cy = bottom + local[1];
|
||||
let d = config.max_distance[0];
|
||||
let free = Rc::new(RefCell::new(Free {
|
||||
container: BoundingBox::new([cx - d, cy - d, cz - d], [cx + d, cy + d, cz + d]),
|
||||
removed: vec![start.bounding_box],
|
||||
}));
|
||||
let mut assembler = Assembler {
|
||||
config,
|
||||
yung,
|
||||
pools,
|
||||
resources,
|
||||
bindings,
|
||||
pieces: vec![start],
|
||||
states: vec![(free, 0)],
|
||||
counts: HashMap::new(),
|
||||
};
|
||||
if config.max_depth > 0 {
|
||||
let mut queue = VecDeque::from([0]);
|
||||
while let Some(piece) = queue.pop_front() {
|
||||
assembler.children(piece, &mut queue, context, random);
|
||||
}
|
||||
}
|
||||
Some(([cx, cy, cz], assembler.pieces))
|
||||
}
|
||||
|
||||
/// JigsawStructureAssembler.
|
||||
struct Assembler<'a> {
|
||||
config: &'a JigsawConfig<'a>,
|
||||
yung: &'a Config,
|
||||
pools: &'a Pools,
|
||||
resources: &'a StructureResources,
|
||||
bindings: &'a FeatureBlockBindings<'a>,
|
||||
pieces: Vec<PoolPiece>,
|
||||
/// Per piece: the free space it was placed in, and its depth.
|
||||
states: Vec<(Rc<RefCell<Free>>, i32)>,
|
||||
/// Pieces placed per capped name.
|
||||
counts: HashMap<String, i32>,
|
||||
}
|
||||
|
||||
/// Where a child goes: the parent's jigsaw and what it needs.
|
||||
struct Slot<'s> {
|
||||
source: usize,
|
||||
jigsaw: &'s super::jigsaw::Jigsaw,
|
||||
target_pos: [i32; 3],
|
||||
free: Rc<RefCell<Free>>,
|
||||
depth: i32,
|
||||
}
|
||||
|
||||
impl Assembler<'_> {
|
||||
fn pool(&self, name: &str) -> Option<Arc<super::jigsaw::Pool>> {
|
||||
let name = self.config.aliases.get(name).map_or(name, String::as_str);
|
||||
self.pools.get(name, self.resources, self.bindings)
|
||||
}
|
||||
/// JigsawStructureAssembler.Settings.isInBounds.
|
||||
fn in_bounds(&self, y: i32, context: &impl JigsawContext) -> bool {
|
||||
self.yung.max_y.is_none_or(|m| y <= m)
|
||||
&& self.yung.min_y.is_none_or(|m| y >= m)
|
||||
&& y >= context.min_y() + self.config.padding[0]
|
||||
&& y <= context.max_y() + 1 - self.config.padding[1]
|
||||
}
|
||||
/// addChildrenForPiece: one child per jigsaw where one fits, from the
|
||||
/// target pool unless the piece is at the last depth, else its fallback.
|
||||
fn children(
|
||||
&mut self,
|
||||
source: usize,
|
||||
queue: &mut VecDeque<usize>,
|
||||
context: &mut impl JigsawContext,
|
||||
random: &mut impl RandomSource,
|
||||
) {
|
||||
let (element, position, rotation, source_box) = {
|
||||
let s = &self.pieces[source];
|
||||
(s.element.clone(), s.position, s.rotation, s.bounding_box)
|
||||
};
|
||||
let (context_free, depth) = self.states[source].clone();
|
||||
let mut source_free: Option<Rc<RefCell<Free>>> = None;
|
||||
for jigsaw in element.shuffled_jigsaws(self.resources, position, rotation, random) {
|
||||
let Some(target) = self.pool(&jigsaw.pool) else {
|
||||
continue;
|
||||
};
|
||||
if target.templates.is_empty() && jigsaw.pool != "minecraft:empty" {
|
||||
continue;
|
||||
}
|
||||
let Some(fallback) = self.pool(&target.fallback) else {
|
||||
continue;
|
||||
};
|
||||
if fallback.templates.is_empty() && target.fallback != "minecraft:empty" {
|
||||
continue;
|
||||
}
|
||||
let s = step(jigsaw.front);
|
||||
let target_pos: [i32; 3] = std::array::from_fn(|i| jigsaw.pos[i] + s[i]);
|
||||
let free = if source_box.is_inside(target_pos) {
|
||||
source_free
|
||||
.get_or_insert_with(|| {
|
||||
Rc::new(RefCell::new(Free {
|
||||
container: source_box,
|
||||
removed: Vec::new(),
|
||||
}))
|
||||
})
|
||||
.clone()
|
||||
} else {
|
||||
context_free.clone()
|
||||
};
|
||||
let slot = Slot {
|
||||
source,
|
||||
jigsaw: &jigsaw,
|
||||
target_pos,
|
||||
free,
|
||||
depth,
|
||||
};
|
||||
let placed = depth != self.config.max_depth
|
||||
&& self.choose(&slot, target.raw.clone(), queue, context, random);
|
||||
if !placed {
|
||||
self.choose(&slot, fallback.raw.clone(), queue, context, random);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// chooseCandidateFromPool: whether a piece was placed.
|
||||
fn choose(
|
||||
&mut self,
|
||||
slot: &Slot<'_>,
|
||||
mut candidates: Vec<(Arc<PoolElement>, i32)>,
|
||||
queue: &mut VecDeque<usize>,
|
||||
context: &mut impl JigsawContext,
|
||||
random: &mut impl RandomSource,
|
||||
) -> bool {
|
||||
let jigsaw = slot.jigsaw;
|
||||
let (source_rigid, source_y, source_ground) = {
|
||||
let s = &self.pieces[slot.source];
|
||||
(
|
||||
s.element.projection() == Projection::Rigid,
|
||||
s.bounding_box.min[1],
|
||||
s.ground_level_delta,
|
||||
)
|
||||
};
|
||||
let local_y = jigsaw.pos[1] - source_y;
|
||||
// The surface at the jigsaw, read once per call.
|
||||
let mut surface = None;
|
||||
let (x, z) = (jigsaw.pos[0], jigsaw.pos[2]);
|
||||
let mut base = |context: &mut dyn JigsawContextDyn| {
|
||||
*surface.get_or_insert_with(|| context.surface(x, z))
|
||||
};
|
||||
shuffle(&mut candidates, random);
|
||||
let mut total: i32 = candidates.iter().map(|c| c.1).sum();
|
||||
while !candidates.is_empty() && total > 0 {
|
||||
let index = pick(&candidates, total, random);
|
||||
let (target, weight) = candidates[index].clone();
|
||||
if matches!(target.as_ref(), PoolElement::Empty) {
|
||||
return false;
|
||||
}
|
||||
let rules = target.yung();
|
||||
let capped = rules.and_then(Rules::capped);
|
||||
let full = capped
|
||||
.is_some_and(|(name, max)| self.counts.get(name).copied().unwrap_or(0) >= max);
|
||||
if full || rules.is_some_and(|r| !r.at_valid_depth(slot.depth)) {
|
||||
total -= weight;
|
||||
candidates.remove(index);
|
||||
continue;
|
||||
}
|
||||
let mut rotations = Rotation::ALL;
|
||||
shuffle(&mut rotations, random);
|
||||
for rotation in rotations {
|
||||
let target_jigsaws =
|
||||
target.shuffled_jigsaws(self.resources, [0; 3], rotation, random);
|
||||
let hack_box = target.bounding_box([0; 3], rotation);
|
||||
let expand_to = if self.config.use_expansion_hack && hack_box.span()[1] <= 16 {
|
||||
target_jigsaws
|
||||
.iter()
|
||||
.map(|tj| {
|
||||
let st = step(tj.front);
|
||||
if !hack_box.is_inside(std::array::from_fn(|i| tj.pos[i] + st[i])) {
|
||||
return 0;
|
||||
}
|
||||
let child = self.pool(&tj.pool);
|
||||
let child_size = child.as_ref().map_or(0, |p| p.max_size());
|
||||
let fallback_size = child
|
||||
.and_then(|p| self.pool(&p.fallback))
|
||||
.map_or(0, |p| p.max_size());
|
||||
child_size.max(fallback_size)
|
||||
})
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
for target_jigsaw in &target_jigsaws {
|
||||
if !can_attach(jigsaw, target_jigsaw) {
|
||||
continue;
|
||||
}
|
||||
let target_local = target_jigsaw.pos;
|
||||
let raw_position: [i32; 3] =
|
||||
std::array::from_fn(|i| slot.target_pos[i] - target_local[i]);
|
||||
let raw_box = target.bounding_box(raw_position, rotation);
|
||||
let target_rigid = target.projection() == Projection::Rigid;
|
||||
let delta_y = local_y - target_local[1] + step(jigsaw.front)[1];
|
||||
let target_y = if source_rigid && target_rigid {
|
||||
source_y + delta_y
|
||||
} else {
|
||||
base(context) - target_local[1]
|
||||
};
|
||||
let offset = target_y - raw_box.min[1];
|
||||
let mut target_box = raw_box.moved([0, offset, 0]);
|
||||
let target_position =
|
||||
[raw_position[0], raw_position[1] + offset, raw_position[2]];
|
||||
if expand_to > 0 {
|
||||
let size = (expand_to + 1).max(target_box.max[1] - target_box.min[1]);
|
||||
target_box.max[1] = target_box.min[1] + size;
|
||||
}
|
||||
if !self.in_bounds(target_box.max[1], context)
|
||||
|| !self.in_bounds(target_box.min[1], context)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if !rules.is_some_and(|r| r.ignore_bounds)
|
||||
&& !slot.free.borrow().fits(&target_box)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let target_ground = if target_rigid {
|
||||
source_ground - delta_y
|
||||
} else {
|
||||
target.ground_level_delta()
|
||||
};
|
||||
let junction_y = if source_rigid {
|
||||
source_y + local_y
|
||||
} else if target_rigid {
|
||||
target_y + target_local[1]
|
||||
} else {
|
||||
base(context) + delta_y / 2
|
||||
};
|
||||
let at = At {
|
||||
depth: slot.depth + 1,
|
||||
rotation,
|
||||
piece: Some(target_box),
|
||||
pieces: &self.pieces,
|
||||
};
|
||||
if rules.is_some_and(|r| !r.condition.passes(&at, random)) {
|
||||
continue;
|
||||
}
|
||||
self.pieces[slot.source].junctions.push(Junction {
|
||||
source_x: slot.target_pos[0],
|
||||
source_ground_y: junction_y - local_y + source_ground,
|
||||
source_z: slot.target_pos[2],
|
||||
});
|
||||
slot.free.borrow_mut().removed.push(target_box);
|
||||
self.pieces.push(PoolPiece {
|
||||
element: target.clone(),
|
||||
position: target_position,
|
||||
ground_level_delta: target_ground,
|
||||
rotation,
|
||||
bounding_box: target_box,
|
||||
junctions: vec![Junction {
|
||||
source_x: jigsaw.pos[0],
|
||||
source_ground_y: junction_y - target_local[1] + target_ground,
|
||||
source_z: jigsaw.pos[2],
|
||||
}],
|
||||
waterlogging: self.config.waterlogging,
|
||||
});
|
||||
self.states.push((slot.free.clone(), slot.depth + 1));
|
||||
if slot.depth < self.config.max_depth {
|
||||
queue.push_back(self.pieces.len() - 1);
|
||||
}
|
||||
if let Some((name, _)) = capped {
|
||||
*self.counts.entry(name.to_owned()).or_default() += 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
total -= weight;
|
||||
candidates.remove(index);
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use horizon_core::random::LegacyRandom;
|
||||
|
||||
fn single(template: &Arc<StructureTemplate>, rules: Option<Rules>) -> Arc<PoolElement> {
|
||||
Arc::new(PoolElement::Single {
|
||||
template: template.clone(),
|
||||
processors: Default::default(),
|
||||
legacy: false,
|
||||
projection: Projection::Rigid,
|
||||
waterlogging: None,
|
||||
yung: rules.map(Box::new),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picks_priority_pieces_then_by_weight() {
|
||||
let t = Arc::new(StructureTemplate::empty());
|
||||
let plain = single(&t, None);
|
||||
let first = single(
|
||||
&t,
|
||||
Some(Rules {
|
||||
priority: true,
|
||||
..Rules::default()
|
||||
}),
|
||||
);
|
||||
let mut random = LegacyRandom::new(7);
|
||||
let list = vec![(plain.clone(), 3), (first, 1)];
|
||||
assert_eq!(pick(&list, 4, &mut random), 1);
|
||||
// By weight: nextInt(total) + 1, counted down; the first entry
|
||||
// takes draws 1..=3 of 4.
|
||||
let list = vec![(plain.clone(), 3), (plain, 1)];
|
||||
let mut ours = LegacyRandom::new(42);
|
||||
let mut theirs = LegacyRandom::new(42);
|
||||
for _ in 0..32 {
|
||||
let draw = theirs.next_int_bound(4).unwrap() + 1;
|
||||
assert_eq!(pick(&list, 4, &mut ours), usize::from(draw > 3));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rules_cap_by_name_and_depth() {
|
||||
let rules = Rules {
|
||||
name: Some("room".into()),
|
||||
max_count: Some(2),
|
||||
min_depth: Some(1),
|
||||
max_depth: Some(3),
|
||||
..Rules::default()
|
||||
};
|
||||
assert_eq!(rules.capped(), Some(("room", 2)));
|
||||
assert!(!rules.at_valid_depth(0) && rules.at_valid_depth(1) && !rules.at_valid_depth(4));
|
||||
// max_count without a name is ignored, as YUNG's does.
|
||||
let unnamed = Rules {
|
||||
max_count: Some(1),
|
||||
..Rules::default()
|
||||
};
|
||||
assert_eq!(unnamed.capped(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn conditions() {
|
||||
let t = Arc::new(StructureTemplate::empty());
|
||||
let other = Arc::new(StructureTemplate::empty());
|
||||
let neighbour = PoolPiece {
|
||||
element: single(&t, None),
|
||||
position: [0; 3],
|
||||
ground_level_delta: 1,
|
||||
rotation: Rotation::None,
|
||||
bounding_box: BoundingBox::new([0, 0, -6], [4, 4, -1]),
|
||||
junctions: Vec::new(),
|
||||
waterlogging: true,
|
||||
};
|
||||
let pieces = [neighbour];
|
||||
let at = |rotation, depth| At {
|
||||
depth,
|
||||
rotation,
|
||||
piece: Some(BoundingBox::new([0, 10, 0], [4, 14, 4])),
|
||||
pieces: &pieces,
|
||||
};
|
||||
let mut random = LegacyRandom::new(1);
|
||||
let depth = Condition::Depth {
|
||||
min: Some(2),
|
||||
max: None,
|
||||
};
|
||||
assert!(!depth.passes(&at(Rotation::None, 1), &mut random));
|
||||
assert!(depth.passes(&at(Rotation::None, 2), &mut random));
|
||||
let altitude = |bottom, top| Condition::Altitude { bottom, top };
|
||||
assert!(altitude(Some(10.), Some(14.)).passes(&at(Rotation::None, 0), &mut random));
|
||||
assert!(!altitude(Some(10.5), None).passes(&at(Rotation::None, 0), &mut random));
|
||||
assert!(!altitude(None, Some(13.9)).passes(&at(Rotation::None, 0), &mut random));
|
||||
// North (-Z) of an unrotated piece, within 5 blocks; the neighbour
|
||||
// stays below it in Y, but only X and Z are searched, and it must
|
||||
// not overlap the piece itself.
|
||||
let north = |templates, rotation| Condition::PieceInDirection {
|
||||
templates,
|
||||
range: 5,
|
||||
rotation,
|
||||
};
|
||||
assert!(!north(Vec::new(), Rotation::None).passes(&at(Rotation::None, 1), &mut random));
|
||||
let low = At {
|
||||
piece: Some(BoundingBox::new([0, 0, 0], [4, 4, 4])),
|
||||
..at(Rotation::None, 1)
|
||||
};
|
||||
assert!(north(Vec::new(), Rotation::None).passes(&low, &mut random));
|
||||
assert!(north(vec![t.clone()], Rotation::None).passes(&low, &mut random));
|
||||
assert!(!north(vec![other], Rotation::None).passes(&low, &mut random));
|
||||
// The piece turned 180°: its north is south.
|
||||
let turned = At {
|
||||
rotation: Rotation::Clockwise180,
|
||||
..low
|
||||
};
|
||||
assert!(!north(Vec::new(), Rotation::None).passes(&turned, &mut random));
|
||||
assert!(north(Vec::new(), Rotation::Clockwise180).passes(&turned, &mut random));
|
||||
let all = Condition::AllOf(vec![
|
||||
Condition::True,
|
||||
Condition::Not(Box::new(Condition::False)),
|
||||
Condition::Rotation(vec![Rotation::Clockwise180]),
|
||||
]);
|
||||
assert!(all.passes(&turned, &mut random));
|
||||
assert!(!Condition::AnyOf(vec![Condition::False]).passes(&turned, &mut random));
|
||||
}
|
||||
}
|
||||
+45
-13
@@ -439,6 +439,35 @@ Two cases the oracle fills in:
|
||||
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.
|
||||
- **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
|
||||
Arise main pieces and two Nullscape pieces. They used to load as empty templates, so their
|
||||
structures never started.
|
||||
- **Additions to other sets and pools** (#832 in the game, #833 in carry). A set or pool file
|
||||
holding `horizon:add_to` appends its entries to the sets or pools it names (docs/mods.md).
|
||||
Carry writes these from lithostitched's `add_structure_set_entries` and
|
||||
`add_template_pool_elements` modifiers whose load conditions hold for the mods ported
|
||||
along, and from CTOV's Java registration: its 21 village types and 11 outposts join
|
||||
vanilla's `villages` and `pillager_outposts` with the mod's default weights.
|
||||
- **YUNG's API** (#839, #846 in the game; #840, #847 in carry). `yungsapi:yung_jigsaw` and its
|
||||
elements become vanilla's jigsaw and single element, with their rules under
|
||||
`horizon:yungsapi`. The game assembles them as YUNG's `JigsawManager` does: priority
|
||||
pieces, caps by name, depth ranges, `ignore_bounds` and the conditions tree. YUNG's
|
||||
placements become `horizon:` keys on a random spread: `horizon:exclusion_zone` for the
|
||||
enhanced exclusion zone, `horizon:avoid_biomes` for the temples' ocean and river search,
|
||||
`horizon:ring_sections` for Better Strongholds' rings. `horizon:disables` on a YUNG
|
||||
structure turns off the vanilla type its mod's mixin turns off. It is written only when
|
||||
the game can start the replacement, so vanilla mineshafts stay while Better Mineshafts (a
|
||||
Java type) can't.
|
||||
- **Repurposed Structures' and Moog's own assembler** (#850 in the game, #851 in carry). Both
|
||||
lay out their jigsaws with `PieceLimitedJigsawManager`, not vanilla's. Their structures, the
|
||||
Nether variants too, get `horizon:piece_limited`: `y_allowance`, burying, the pools whose
|
||||
fallbacks ignore the bounds, liquid, the Nether land search and ledge, and each
|
||||
structure's piece caps and required pieces from the mod's `*_pieces_spawn_counts` files.
|
||||
The game assembles them the mods' way and runs their post-layout steps (centring,
|
||||
burying, the Nether land search).
|
||||
|
||||
|
||||
Each mod's `carry-report.json` lists what was mapped, the rules and processors lost by name,
|
||||
and the types left as they are. NeoForge's convention biome tags (`#c:is_forest`, ...) come
|
||||
@@ -453,19 +482,22 @@ Two cases the oracle fills in:
|
||||
ChoiceTheorem's Overhauled Village 66), and 103 convention biome tags written.
|
||||
- When Dungeons Arise, Structory and Towns and Towers use vanilla's types already.
|
||||
- Still lost, written in Java:
|
||||
- YUNG's API: its own jigsaw assembler (priority pieces, per-piece caps, conditions,
|
||||
enhanced terrain adaptation) and 491 elements and jigsaws, behind every "YUNG's Better"
|
||||
mod;
|
||||
- Formations' structure and element types (179);
|
||||
- the nether jigsaw variants of Moog's and Repurposed (69), which search the column for
|
||||
land after the layout;
|
||||
- Moog's and Repurposed's layout rules: they centre the pieces on the start, bury or lift
|
||||
the structure to the terrain and cap pieces per pool;
|
||||
- Repurposed's mineshafts, mansions, monuments and cities, and MO Structures (38; its
|
||||
library is only on CurseForge).
|
||||
- CTOV's villages and outposts are added to vanilla's `villages` and `pillager_outposts`
|
||||
sets by Java code, as lithostitched's `add_structure_set_entries` worldgen modifiers do for
|
||||
many packs; a content mod has no way to add to a vanilla set yet, so none start.
|
||||
- Formations' structure and element types (179): their placements read block states in the
|
||||
noise column (solid, water, lava), which the structure context doesn't give yet;
|
||||
- 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;
|
||||
- MO Structures (38; its library is only on CurseForge).
|
||||
|
||||
With every structure PR above, the same square (seed 1234, chunks -64..63) holds 362
|
||||
overworld starts with 22,026 pieces. CTOV has 7, Better Dungeons 72 and Better Ocean
|
||||
Monuments 3, and vanilla's monuments are gone as YUNG's mod has them. In the Nether there
|
||||
are 512 starts, up from 322: Moog's Nether Structures 147, Repurposed's Nether structures
|
||||
40, Better Fortresses 7, with no vanilla fortress. Over chunks -256..255: Better Strongholds 10
|
||||
(vanilla 0), Better Jungle Temples 5, Better Witch Huts 11. Vanilla's own worlds are
|
||||
unchanged: the structure-start oracle still matches 35 of 35.
|
||||
|
||||
In a world with the 40 mods, seed 1234, `/locate structure mvs:azelea_house` finds one 27
|
||||
blocks from spawn and it stands there as the template builds it; When Dungeons Arise's
|
||||
|
||||
@@ -287,6 +287,22 @@ its row. The game reads this content into its block and item tables
|
||||
nobody registers (a block a port left out, another mod's item) is dropped,
|
||||
so the rest of the tag still loads; vanilla would drop the whole tag.
|
||||
|
||||
A mod adds to structure sets and template pools that are not its own
|
||||
(vanilla's villages, another mod's houses) with a set or pool file in its own
|
||||
namespace holding `horizon:add_to`, a key vanilla data never has. Its entries
|
||||
are appended to each set or pool named, after every mod's own files, in mod
|
||||
and file order; the file is no set or pool itself. A name nobody defines is
|
||||
skipped.
|
||||
|
||||
```json
|
||||
{ "horizon:add_to": "minecraft:villages",
|
||||
"structures": [ { "structure": "mymod:village_beach", "weight": 10 } ] }
|
||||
```
|
||||
|
||||
A pool addition holds `"elements"` as a pool does. This is what lithostitched's
|
||||
`add_structure_set_entries` and `add_template_pool_elements` modifiers do on
|
||||
NeoForge and Fabric, and `horizon-port-pack carry` writes them from those.
|
||||
|
||||
## Versions and compatibility
|
||||
|
||||
- The API is the WIT package `horizon:mods@0.1.0`. New functions and
|
||||
|
||||
Reference in New Issue
Block a user