Merge remote-tracking branch 'origin/feat/carry-piece-limited' into integ/mp6
This commit is contained in:
@@ -366,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();
|
||||
@@ -435,6 +436,8 @@ pub fn carry(
|
||||
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);
|
||||
|
||||
@@ -26,6 +26,19 @@ 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",
|
||||
@@ -413,12 +426,22 @@ fn upgrade_types(
|
||||
yung_structure(v, lost);
|
||||
true
|
||||
}
|
||||
Some(t) if JIGSAWS.contains(&t) => {
|
||||
let liquid = match t.split_once(':').map(|(ns, _)| ns) {
|
||||
Some("moogs_structures") => "top",
|
||||
_ => "lowest",
|
||||
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
|
||||
}
|
||||
@@ -599,7 +622,7 @@ fn yung_condition(c: &Value, lost: &mut BTreeMap<String, usize>) -> Value {
|
||||
/// 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;
|
||||
};
|
||||
@@ -620,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;
|
||||
}
|
||||
}
|
||||
@@ -629,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
|
||||
@@ -891,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));
|
||||
@@ -930,10 +1068,7 @@ mod tests {
|
||||
assert_eq!(
|
||||
report.unsupported,
|
||||
BTreeMap::from([
|
||||
(
|
||||
"moogs_structures:moogs_structures_generic_nether_jigsaw_structure".into(),
|
||||
1
|
||||
),
|
||||
("formations:simple".into(), 1),
|
||||
("somelib:element".into(), 1),
|
||||
])
|
||||
);
|
||||
@@ -971,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})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1157,6 +1295,74 @@ mod tests {
|
||||
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();
|
||||
|
||||
Reference in New Issue
Block a user