Content mods: shared tags merge like a data pack's, replace honoured with a warning
A mod's file for a vanilla, convention or other mod's tag adds its values in load order; one with "replace": true now drops vanilla's entries and the earlier mods' first, as a higher data pack does, and the log says which mod replaced what (kept with the cached root, so a reused root warns too). Carry keeps such tags instead of setting them aside: Towns and Towers' seven minecraft:has_structure biome tags load. Mods still own no other minecraft content. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -874,7 +874,7 @@ struct Known {
|
||||
tag_files: std::collections::BTreeSet<String>,
|
||||
}
|
||||
impl Known {
|
||||
fn new(base: &Path, plan: &Plan, tags: &BTreeMap<String, Vec<J>>) -> Result<Self> {
|
||||
fn new(base: &Path, plan: &Plan, tags: &BTreeMap<String, TagMerge>) -> Result<Self> {
|
||||
let mut blocks: std::collections::BTreeSet<String> =
|
||||
plan.defaults.keys().cloned().collect();
|
||||
blocks.extend(plan.blocks.iter().map(|b| b.decl.id.clone()));
|
||||
@@ -945,8 +945,60 @@ impl Known {
|
||||
}
|
||||
}
|
||||
|
||||
/// Builds the content root for `mods` over `base` in `out`.
|
||||
pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
/// What the mods do to one tag file, in load order (a data pack's
|
||||
/// TagLoader): each adds its values, and one that replaces the tag first
|
||||
/// drops vanilla's entries and the mods' before it.
|
||||
#[derive(Default)]
|
||||
struct TagMerge {
|
||||
/// A mod replaced the tag: vanilla's entries are left out.
|
||||
replaced: bool,
|
||||
/// The mods whose values are in `values`.
|
||||
mods: Vec<String>,
|
||||
values: Vec<J>,
|
||||
}
|
||||
|
||||
impl TagMerge {
|
||||
/// Adds one mod's tag file. A replace that drops entries (vanilla's in a
|
||||
/// `shared` tag, one not in the mod's namespaces, or other mods') warns.
|
||||
fn add(
|
||||
&mut self,
|
||||
id: &str,
|
||||
file: &str,
|
||||
replace: bool,
|
||||
shared: bool,
|
||||
values: &[J],
|
||||
) -> Option<String> {
|
||||
let mut warning = None;
|
||||
if replace {
|
||||
let mut dropped: Vec<String> = Vec::new();
|
||||
if shared && !self.replaced {
|
||||
dropped.push("vanilla's entries".into());
|
||||
}
|
||||
if !self.mods.is_empty() {
|
||||
dropped.push(format!("those of {}", self.mods.join(", ")));
|
||||
}
|
||||
if !dropped.is_empty() {
|
||||
warning = Some(format!(
|
||||
"mod {id} replaces {file}: {} are left out, as a data pack's replace \
|
||||
does; the mods after it in load order still add to it",
|
||||
dropped.join(" and ")
|
||||
));
|
||||
}
|
||||
self.replaced = true;
|
||||
self.mods.clear();
|
||||
self.values.clear();
|
||||
}
|
||||
if !self.mods.iter().any(|m| m == id) {
|
||||
self.mods.push(id.to_owned());
|
||||
}
|
||||
self.values.extend(values.iter().cloned());
|
||||
warning
|
||||
}
|
||||
}
|
||||
|
||||
/// Builds the content root for `mods` over `base` in `out`. Returns the
|
||||
/// warnings for the log: the shared tags a mod replaced.
|
||||
pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<Vec<String>> {
|
||||
// Two mods owning one namespace would mix their files.
|
||||
for (i, a) in mods.iter().enumerate() {
|
||||
for b in &mods[..i] {
|
||||
@@ -986,7 +1038,8 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
overlay.write(name, &bytes)?;
|
||||
}
|
||||
// Mod files, and every tag addition gathered per tag file.
|
||||
let mut tags: BTreeMap<String, Vec<J>> = BTreeMap::new();
|
||||
let mut tags: BTreeMap<String, TagMerge> = BTreeMap::new();
|
||||
let mut warnings = Vec::new();
|
||||
let mut worldgen: BTreeMap<&str, Vec<(String, String)>> = BTreeMap::new();
|
||||
let mut additions: BTreeMap<&str, Vec<Addition>> = BTreeMap::new();
|
||||
for m in mods {
|
||||
@@ -996,19 +1049,14 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
let is_tag = file.starts_with("data/") && file.contains("/tags/");
|
||||
if is_tag && file.ends_with(".json") {
|
||||
let doc: J = serde_json::from_slice(&bytes).map_err(|e| format!("{file}: {e}"))?;
|
||||
if doc.get("replace") == Some(&J::Bool(true)) {
|
||||
let e = format!(
|
||||
"{}: {file}: a mod adds to tags, it cannot replace them",
|
||||
m.id
|
||||
);
|
||||
return Err(e.into());
|
||||
}
|
||||
let Some(J::Arr(values)) = doc.get("values") else {
|
||||
return Err(format!("{}: {file}: no values", m.id).into());
|
||||
};
|
||||
tags.entry(file.clone())
|
||||
.or_default()
|
||||
.extend(values.iter().cloned());
|
||||
let replace = doc.get("replace") == Some(&J::Bool(true));
|
||||
let ns = file.split('/').nth(1).unwrap_or_default();
|
||||
let shared = !m.content.namespaces.iter().any(|n| n == ns);
|
||||
let merge = tags.entry(file.clone()).or_default();
|
||||
warnings.extend(merge.add(&m.id, file, replace, shared, values));
|
||||
} else if !file.starts_with(&declarations) {
|
||||
overlay.write(file, &bytes)?;
|
||||
if let Some((bundle, id)) = worldgen_entry(file) {
|
||||
@@ -1034,8 +1082,8 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
// carried-over mods name blocks left out or other mods' ids: such
|
||||
// entries are dropped instead, so the rest of the tag holds.
|
||||
let known = Known::new(base, &plan, &tags)?;
|
||||
for (file, values) in &mut tags {
|
||||
values.retain(|v| known.keeps(file, v));
|
||||
for (file, merge) in &mut tags {
|
||||
merge.values.retain(|v| known.keeps(file, v));
|
||||
}
|
||||
let mut bundles: Vec<(&str, J)> = Vec::new();
|
||||
for name in TAG_BUNDLES {
|
||||
@@ -1043,11 +1091,13 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
bundles.push((name, read_json(&base.join(name))?));
|
||||
}
|
||||
}
|
||||
for (file, values) in &tags {
|
||||
let vanilla = fs::read_to_string(base.join(file)).ok();
|
||||
for (file, merge) in &tags {
|
||||
let vanilla = fs::read_to_string(base.join(file))
|
||||
.ok()
|
||||
.filter(|_| !merge.replaced);
|
||||
overlay.write(
|
||||
file,
|
||||
merge_tag(vanilla.as_deref(), values, file)?.as_bytes(),
|
||||
merge_tag(vanilla.as_deref(), &merge.values, file)?.as_bytes(),
|
||||
)?;
|
||||
// data/<ns>/tags/block/<path>.json is the block tag <ns>:<path>.
|
||||
let Some((ns, path)) = file
|
||||
@@ -1060,10 +1110,10 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
let id = format!("{ns}:{path}");
|
||||
for (name, doc) in &mut bundles {
|
||||
let text = match doc.get(&id) {
|
||||
Some(J::Str(t)) => Some(t.clone()),
|
||||
Some(J::Str(t)) if !merge.replaced => Some(t.clone()),
|
||||
_ => None,
|
||||
};
|
||||
let merged = merge_tag(text.as_deref(), values, name)?;
|
||||
let merged = merge_tag(text.as_deref(), &merge.values, name)?;
|
||||
doc.set(&id, J::Str(merged));
|
||||
}
|
||||
}
|
||||
@@ -1071,23 +1121,24 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
overlay.write(name, &serde_json::to_vec(doc)?)?;
|
||||
}
|
||||
// Biome tags, merged into the worldgen loader's bundle as block tags are.
|
||||
let biome_tags: Vec<(String, &Vec<J>)> = tags
|
||||
let biome_tags: Vec<(String, &TagMerge)> = tags
|
||||
.iter()
|
||||
.filter_map(|(file, values)| {
|
||||
.filter_map(|(file, merge)| {
|
||||
let (ns, path) = file
|
||||
.strip_prefix("data/")?
|
||||
.split_once("/tags/worldgen/biome/")?;
|
||||
Some((format!("{ns}:{}", path.strip_suffix(".json")?), values))
|
||||
Some((format!("{ns}:{}", path.strip_suffix(".json")?), merge))
|
||||
})
|
||||
.collect();
|
||||
if !biome_tags.is_empty() && base.join(BIOME_TAGS).exists() {
|
||||
let mut doc = read_json(&base.join(BIOME_TAGS))?;
|
||||
for (id, values) in biome_tags {
|
||||
for (id, merge) in biome_tags {
|
||||
let text = match doc.get(&id) {
|
||||
Some(J::Str(t)) => Some(t.clone()),
|
||||
Some(J::Str(t)) if !merge.replaced => Some(t.clone()),
|
||||
_ => None,
|
||||
};
|
||||
doc.set(&id, J::Str(merge_tag(text.as_deref(), values, BIOME_TAGS)?));
|
||||
let merged = merge_tag(text.as_deref(), &merge.values, BIOME_TAGS)?;
|
||||
doc.set(&id, J::Str(merged));
|
||||
}
|
||||
overlay.write(BIOME_TAGS, &serde_json::to_vec(&doc)?)?;
|
||||
}
|
||||
@@ -1128,7 +1179,8 @@ pub fn build(base: &Path, mods: &[ContentMod], out: &Path) -> Result<()> {
|
||||
.collect();
|
||||
namespaces.sort();
|
||||
overlay.write(MARKER, &serde_json::to_vec(&namespaces)?)?;
|
||||
Ok(())
|
||||
overlay.write(WARNINGS, warnings.join("\n").as_bytes())?;
|
||||
Ok(warnings)
|
||||
}
|
||||
|
||||
/// The root to load: `base` itself with no content, else the mods' overlay
|
||||
@@ -1144,13 +1196,21 @@ pub fn resource_root(base: &Path, mods: &[ContentMod], cache: &Path) -> Result<P
|
||||
let out = cache.join("mod-content");
|
||||
let stamp = stamp(base, mods)?;
|
||||
if fs::read(out.join(STAMP)).is_ok_and(|s| s == stamp.as_bytes()) {
|
||||
// A reused root warns as the build did.
|
||||
let warnings = fs::read_to_string(out.join(WARNINGS)).unwrap_or_default();
|
||||
warnings.lines().for_each(|w| log::warn!("Horizon: {w}"));
|
||||
return Ok(out);
|
||||
}
|
||||
build(base, mods, &out)?;
|
||||
for warning in build(base, mods, &out)? {
|
||||
log::warn!("Horizon: {warning}");
|
||||
}
|
||||
fs::write(out.join(STAMP), stamp)?;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// In a root built by [`build`]: its warnings, one per line.
|
||||
const WARNINGS: &str = "horizon-mod-content-warnings.txt";
|
||||
|
||||
/// In a root built by [`resource_root`]: what it was built from.
|
||||
const STAMP: &str = "horizon-mod-content.stamp";
|
||||
|
||||
|
||||
@@ -758,3 +758,92 @@ fn mods_sharing_a_namespace_are_refused() {
|
||||
assert!(e.to_string().starts_with("mods towers and other"), "{e}");
|
||||
let _ = fs::remove_dir_all(&scratch);
|
||||
}
|
||||
|
||||
/// Mods merge into a tag in load order, as data packs do: each adds its
|
||||
/// values, and one that replaces drops what came before it, with a warning
|
||||
/// naming what it dropped.
|
||||
#[test]
|
||||
fn tags_merge_in_load_order_and_replace_warns() {
|
||||
let v = |ids: &[&str]| -> Vec<J> { ids.iter().map(|i| J::Str((*i).into())).collect() };
|
||||
let file = "data/minecraft/tags/worldgen/biome/has_structure/village_plains.json";
|
||||
let mut merge = TagMerge::default();
|
||||
assert_eq!(merge.add("a", file, false, true, &v(&["a:x"])), None);
|
||||
let warning = merge.add("b", file, true, true, &v(&["minecraft:plains"]));
|
||||
assert_eq!(
|
||||
warning.as_deref(),
|
||||
Some(
|
||||
"mod b replaces data/minecraft/tags/worldgen/biome/has_structure/village_plains.json: \
|
||||
vanilla's entries and those of a are left out, as a data pack's replace does; \
|
||||
the mods after it in load order still add to it"
|
||||
)
|
||||
);
|
||||
assert_eq!(merge.add("c", file, false, true, &v(&["c:y"])), None);
|
||||
assert!(merge.replaced);
|
||||
assert_eq!(merge.values, v(&["minecraft:plains", "c:y"]));
|
||||
// A second replace drops only the mods' entries.
|
||||
let warning = merge.add("d", file, true, true, &v(&["d:z"])).unwrap();
|
||||
assert!(
|
||||
warning.contains(": those of b, c are left out"),
|
||||
"{warning}"
|
||||
);
|
||||
assert_eq!(merge.values, v(&["d:z"]));
|
||||
// A mod replacing a tag of its own that nobody added to drops nothing.
|
||||
let own = "data/a/tags/item/gems.json";
|
||||
assert_eq!(
|
||||
TagMerge::default().add("a", own, true, false, &v(&["a:x"])),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
/// A replacing mod's tag leaves vanilla's entries out of the tag file and of
|
||||
/// the worldgen loader's biome tags, and the root keeps the warning for the
|
||||
/// starts that reuse it.
|
||||
#[test]
|
||||
fn a_replacing_mod_tag_reaches_the_root() {
|
||||
let Some(base) = prepared() else {
|
||||
return;
|
||||
};
|
||||
let scratch = std::env::temp_dir().join(format!("horizon-mod-replace-{}", std::process::id()));
|
||||
let _ = fs::remove_dir_all(&scratch);
|
||||
let file = "data/minecraft/tags/worldgen/biome/has_structure/village_plains.json";
|
||||
let adds = folder_mod(
|
||||
&scratch.join("adds"),
|
||||
&[
|
||||
("horizon-mod.toml", &manifest("adds", "")),
|
||||
(file, r#"{"values": ["minecraft:forest"]}"#),
|
||||
],
|
||||
);
|
||||
let towns = folder_mod(
|
||||
&scratch.join("towns"),
|
||||
&[
|
||||
("horizon-mod.toml", &manifest("towns", "")),
|
||||
(file, r#"{"replace": true, "values": ["minecraft:plains"]}"#),
|
||||
],
|
||||
);
|
||||
let late = folder_mod(
|
||||
&scratch.join("late"),
|
||||
&[
|
||||
("horizon-mod.toml", &manifest("late", "")),
|
||||
(file, r#"{"values": ["minecraft:savanna"]}"#),
|
||||
],
|
||||
);
|
||||
let vanilla: serde_json::Value =
|
||||
serde_json::from_slice(&fs::read(base.join(file)).unwrap()).unwrap();
|
||||
assert!(vanilla["values"].as_array().unwrap().len() > 1, "{vanilla}");
|
||||
let root = resource_root(&base, &[adds, towns, late], &scratch.join("cache")).unwrap();
|
||||
let expected = serde_json::json!(["minecraft:plains", "minecraft:savanna"]);
|
||||
let tag: serde_json::Value =
|
||||
serde_json::from_slice(&fs::read(root.join(file)).unwrap()).unwrap();
|
||||
assert_eq!(tag["values"], expected);
|
||||
let tags: BTreeMap<String, String> =
|
||||
serde_json::from_slice(&fs::read(root.join("worldgen/biome_tags.json")).unwrap()).unwrap();
|
||||
let bundled: serde_json::Value =
|
||||
serde_json::from_str(&tags["minecraft:has_structure/village_plains"]).unwrap();
|
||||
assert_eq!(bundled["values"], expected);
|
||||
let warnings = fs::read_to_string(root.join(WARNINGS)).unwrap();
|
||||
assert!(
|
||||
warnings.starts_with("mod towns replaces data/minecraft/tags/worldgen/biome/has_structure/village_plains.json: vanilla's entries and those of adds are left out"),
|
||||
"{warnings}"
|
||||
);
|
||||
let _ = fs::remove_dir_all(&scratch);
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ pub struct Report {
|
||||
pub outside: Vec<String>,
|
||||
/// Files of the mod's own content the game would refuse, kept in
|
||||
/// `outside/` too, with why: a path vanilla does not read (upper case),
|
||||
/// JSON that does not parse, a vanilla tag the mod replaces.
|
||||
/// JSON that does not parse.
|
||||
pub unreadable: BTreeMap<String, String>,
|
||||
pub recipes_upgraded: usize,
|
||||
pub loot_tables_upgraded: usize,
|
||||
@@ -445,13 +445,12 @@ fn unreadable(name: &str, bytes: &mut Vec<u8>) -> Option<String> {
|
||||
Err(_) => return Some(format!("does not parse as JSON: {e}")),
|
||||
},
|
||||
};
|
||||
// A vanilla or convention tag that replaces is kept: the game honours it
|
||||
// as a data pack's, with a warning (docs/mods.md). A tag of the mod's own
|
||||
// that replaces: no pack before it defines the tag, so it is the same tag
|
||||
// added to (Towns and Towers' biome tags).
|
||||
let shared_tag = name.starts_with("data/minecraft/tags/") || name.starts_with("data/c/tags/");
|
||||
if shared_tag && value.get("replace").and_then(Value::as_bool) == Some(true) {
|
||||
return Some("replaces a shared tag; a content mod may only add to it".into());
|
||||
}
|
||||
// A tag of the mod's own that replaces: no pack before it defines the
|
||||
// tag, so it is the same tag added to (Towns and Towers' biome tags).
|
||||
let own_tag = name.starts_with("data/") && name.contains("/tags/");
|
||||
let own_tag = !shared_tag && name.starts_with("data/") && name.contains("/tags/");
|
||||
if own_tag && let Some(o) = value.as_object_mut().filter(|o| o.contains_key("replace")) {
|
||||
o.remove("replace");
|
||||
*bytes = serde_json::to_vec_pretty(&value).expect("a parsed value serializes");
|
||||
@@ -1180,13 +1179,13 @@ mod tests {
|
||||
"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", ""),
|
||||
(
|
||||
"data/minecraft/tags/worldgen/biome/has_structure/village_plains.json",
|
||||
r#"{"replace": true, "values": []}"#,
|
||||
),
|
||||
// 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", ""),
|
||||
(
|
||||
"assets/gem/lang/de_de.json",
|
||||
"\u{feff}{\"item.gem.gem\": \"Juwel\"}",
|
||||
@@ -1219,17 +1218,25 @@ mod tests {
|
||||
&BTreeMap::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(report.copied, 14);
|
||||
assert_eq!(report.copied, 15);
|
||||
let unreadable: Vec<&str> = report.unreadable.keys().map(String::as_str).collect();
|
||||
assert_eq!(
|
||||
unreadable,
|
||||
[
|
||||
"assets/gem/lang/ry_UA.json",
|
||||
"data/gem/tags/item/empty.json",
|
||||
"data/minecraft/tags/worldgen/biome/has_structure/village_plains.json",
|
||||
"data/gem/tags/item/empty.json"
|
||||
]
|
||||
);
|
||||
assert_eq!(report.outside.len(), 3);
|
||||
assert_eq!(report.outside.len(), 2);
|
||||
// A vanilla tag that replaces is kept as it is: the game honours it.
|
||||
let replacing: Value = serde_json::from_slice(
|
||||
&fs::read(out.join(
|
||||
"carry/data/minecraft/tags/worldgen/biome/has_structure/village_plains.json",
|
||||
))
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(replacing, json!({"replace": true, "values": []}));
|
||||
assert!(!out.join("carry/data/gem/tags/item/empty.json").exists());
|
||||
// A byte-order mark is dropped, the file kept.
|
||||
assert_eq!(
|
||||
|
||||
+4
-2
@@ -325,8 +325,10 @@ into `mods/<id>/carry/`, a folder content mod (API 0.2) the game loads with `--d
|
||||
keeps what a content mod may not hold (other namespaces, vanilla data) in `outside/`. Files of
|
||||
the mod's own content that the game's content loader would refuse whole also go to `outside/`,
|
||||
listed with the reason in the report's `unreadable`: paths vanilla does not read (upper case),
|
||||
JSON that does not parse, and shared tags with `"replace": true`. Vanilla skips them one by one.
|
||||
A byte-order mark is dropped. For ATM10's 42 mods that is 19 files in 7 mods, and the 42 load as
|
||||
and JSON that does not parse. Vanilla skips them one by one. A vanilla or convention tag
|
||||
with `"replace": true` is carried as it is: the game honours it as a data pack's, with a warning
|
||||
(docs/mods.md); Towns and Towers' seven `minecraft:has_structure/*` biome tags are such.
|
||||
A byte-order mark is dropped. For ATM10's 42 mods that is 6 files in 4 mods, and the 42 load as
|
||||
carried. No class file is copied. It upgrades from 1.21.1 to 26.3: vanilla-type recipes (ingredients), loot tables
|
||||
(`conditions` lists become one `condition`, `functions` become `modifier`, kinds move to `type`,
|
||||
tool matches on silk touch or shears become `minecraft:tool/can_silk_touch` and
|
||||
|
||||
@@ -307,6 +307,17 @@ 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.
|
||||
|
||||
Tags merge as a data pack's do. Every mod's file for one tag (vanilla's
|
||||
`data/minecraft/tags/`, the convention `data/c/tags/`, or another mod's) adds
|
||||
its values after vanilla's and the mods' before it, in load order. A file with
|
||||
`"replace": true` first drops what came before it, vanilla's entries and the
|
||||
earlier mods', and the mods after it still add theirs, as a higher data pack
|
||||
does. Since the result depends on load order, the game says so in the log:
|
||||
"mod towns replaces data/minecraft/tags/worldgen/biome/has_structure/village_plains.json:
|
||||
vanilla's entries and those of adds are left out, ...". Tags are the only
|
||||
`minecraft` files a mod may hold: its other content stays in its own
|
||||
namespaces.
|
||||
|
||||
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
|
||||
|
||||
Reference in New Issue
Block a user