Merge pull request #631 from ludovic111/feat/port-pack-oracle-carry
horizon-port-pack carry: templates and numbers from the NeoForge oracle, 1.21.1 loot upgraded
This commit is contained in:
@@ -3,7 +3,7 @@
|
||||
//! upgraded from 1.21.1 to 26.3, item models get their `items/` client
|
||||
//! definitions, and each blockstate gets a vanilla template guessed from its
|
||||
//! properties until the oracle's facts replace the guess.
|
||||
use crate::jar::JarInfo;
|
||||
use crate::{jar::JarInfo, oracle::Facts};
|
||||
use serde::Serialize;
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
@@ -20,14 +20,26 @@ pub struct Report {
|
||||
/// data other than tags), kept in `outside/` for review.
|
||||
pub outside: Vec<String>,
|
||||
pub recipes_upgraded: usize,
|
||||
pub loot_tables_upgraded: usize,
|
||||
/// Worldgen and structure files (`data/<id>/worldgen/`, `structure/`).
|
||||
pub worldgen: usize,
|
||||
/// Recipes left as they were: custom types, NeoForge conditions.
|
||||
pub recipes_kept: Vec<String>,
|
||||
pub item_definitions_added: usize,
|
||||
/// Declared blocks and their guessed templates.
|
||||
/// Templates and properties came from the NeoForge oracle's facts, not
|
||||
/// from guesses.
|
||||
pub oracle: bool,
|
||||
/// Declared blocks and their templates.
|
||||
pub blocks: BTreeMap<String, String>,
|
||||
/// Blockstates whose properties match no template.
|
||||
pub blocks_unknown: Vec<String>,
|
||||
/// What a declared block's template does not reproduce (oracle only).
|
||||
pub differences: BTreeMap<String, Vec<String>>,
|
||||
/// Blocks left out, and why.
|
||||
pub blocks_unknown: BTreeMap<String, String>,
|
||||
pub items: usize,
|
||||
/// Items left out, and why (oracle only).
|
||||
pub items_unknown: BTreeMap<String, String>,
|
||||
/// Convention (`c:`) tags the recipes use, filled in from the oracle.
|
||||
pub convention_tags: usize,
|
||||
}
|
||||
|
||||
/// Vanilla blocks by their sorted property names.
|
||||
@@ -42,6 +54,7 @@ const TEMPLATES: &[(&str, &str)] = &[
|
||||
"minecraft:oak_trapdoor",
|
||||
),
|
||||
("east,north,south,waterlogged,west", "minecraft:oak_fence"),
|
||||
("east,north,south,waterlogged,west", "minecraft:glass_pane"),
|
||||
(
|
||||
"east,north,south,up,waterlogged,west",
|
||||
"minecraft:cobblestone_wall",
|
||||
@@ -58,9 +71,24 @@ const TEMPLATES: &[(&str, &str)] = &[
|
||||
("stage", "minecraft:oak_sapling"),
|
||||
];
|
||||
|
||||
pub fn template(properties: &BTreeSet<String>) -> Option<&'static str> {
|
||||
let key = properties.iter().cloned().collect::<Vec<_>>().join(",");
|
||||
TEMPLATES.iter().find(|(k, _)| *k == key).map(|(_, t)| *t)
|
||||
/// A guess without the oracle: the template whose properties include the
|
||||
/// blockstate's with the fewest left over (a blockstate may leave out what
|
||||
/// its models ignore, such as `powered` or `waterlogged`), the block's name
|
||||
/// breaking ties (`_pane`, `_gate`, `_trapdoor`).
|
||||
pub fn template(name: &str, properties: &BTreeSet<String>) -> Option<&'static str> {
|
||||
let fits = TEMPLATES.iter().filter_map(|(k, t)| {
|
||||
let have: BTreeSet<&str> = k.split(',').filter(|p| !p.is_empty()).collect();
|
||||
properties
|
||||
.iter()
|
||||
.all(|p| have.contains(p.as_str()))
|
||||
.then(|| (have.len() - properties.len(), *t))
|
||||
});
|
||||
let hint = |t: &str| {
|
||||
let kind = t.rsplit('_').next().unwrap_or(t);
|
||||
!name.ends_with(&format!("_{kind}"))
|
||||
};
|
||||
fits.min_by_key(|&(extra, t)| (extra, hint(t)))
|
||||
.map(|(_, t)| t)
|
||||
}
|
||||
|
||||
/// The property names a blockstate file uses.
|
||||
@@ -165,7 +193,92 @@ pub fn upgrade_recipe(recipe: &mut Value) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Where a jar entry goes: `Some(true)` inside the content mod, `Some(false)`
|
||||
/// A 1.21.1 loot table in 26.3's shape, in place: `conditions` lists become
|
||||
/// one `condition` (`all_of` for several), `functions` become `modifier`,
|
||||
/// and conditions and functions name their kind in `type`. A tool match on
|
||||
/// silk touch alone, or on shears alone, becomes 26.3's
|
||||
/// `minecraft:tool/can_silk_touch` or `minecraft:tool/can_shear`.
|
||||
pub fn upgrade_loot(v: &mut Value) {
|
||||
match v {
|
||||
Value::Array(a) => a.iter_mut().for_each(upgrade_loot),
|
||||
Value::Object(o) => {
|
||||
if let Some(Value::Array(mut list)) = o.remove("conditions") {
|
||||
list.iter_mut().for_each(upgrade_condition);
|
||||
let one = match <[Value; 1]>::try_from(list) {
|
||||
Ok([c]) => c,
|
||||
Err(list) => json!({"type": "minecraft:all_of", "terms": list}),
|
||||
};
|
||||
o.insert("condition".to_owned(), one);
|
||||
}
|
||||
if let Some(Value::Array(mut list)) = o.remove("functions") {
|
||||
for f in &mut list {
|
||||
rename_kind(f, "function");
|
||||
upgrade_loot(f);
|
||||
}
|
||||
o.insert("modifier".to_owned(), Value::Array(list));
|
||||
}
|
||||
for (k, x) in o.iter_mut() {
|
||||
if k != "condition" && k != "modifier" {
|
||||
upgrade_loot(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// `{"<key>": kind, ...}` as `{"type": kind, ...}`.
|
||||
fn rename_kind(v: &mut Value, key: &str) {
|
||||
if let Some(o) = v.as_object_mut()
|
||||
&& !o.contains_key("type")
|
||||
&& let Some(kind) = o.remove(key)
|
||||
{
|
||||
o.insert("type".to_owned(), kind);
|
||||
}
|
||||
}
|
||||
|
||||
/// One 1.21.1 loot condition in 26.3's shape.
|
||||
fn upgrade_condition(c: &mut Value) {
|
||||
rename_kind(c, "condition");
|
||||
if let Some(term) = c.get_mut("term") {
|
||||
upgrade_condition(term);
|
||||
}
|
||||
if let Some(Value::Array(terms)) = c.get_mut("terms") {
|
||||
terms.iter_mut().for_each(upgrade_condition);
|
||||
}
|
||||
if c["type"] == "minecraft:match_tool"
|
||||
&& let Some(named) = named_tool_condition(&c["predicate"])
|
||||
{
|
||||
*c = json!(named);
|
||||
}
|
||||
}
|
||||
|
||||
/// 26.3's named tool conditions for the 1.21.1 predicates they replace.
|
||||
fn named_tool_condition(predicate: &Value) -> Option<&'static str> {
|
||||
let keys: Vec<&str> = predicate.as_object()?.keys().map(String::as_str).collect();
|
||||
match keys.as_slice() {
|
||||
["predicates"] => {
|
||||
let list = predicate["predicates"]["minecraft:enchantments"].as_array()?;
|
||||
let [e] = list.as_slice() else {
|
||||
return None;
|
||||
};
|
||||
let silk = e["enchantments"] == "minecraft:silk_touch"
|
||||
&& e["levels"]["min"].as_u64().unwrap_or(1) <= 1
|
||||
&& e["levels"].get("max").is_none()
|
||||
&& predicate["predicates"].as_object()?.len() == 1;
|
||||
silk.then_some("minecraft:tool/can_silk_touch")
|
||||
}
|
||||
["items"] => {
|
||||
let items = &predicate["items"];
|
||||
let shears = items == "minecraft:shears" || *items == json!(["minecraft:shears"]);
|
||||
shears.then_some("minecraft:tool/can_shear")
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Where a jar entry goes: `Some(true)` inside the content mod (its own
|
||||
/// namespace, additions to vanilla and convention tags), `Some(false)`
|
||||
/// to `outside/`, `None` not carried (code, metadata).
|
||||
fn place(name: &str, id: &str) -> Option<bool> {
|
||||
let mut parts = name.splitn(3, '/');
|
||||
@@ -173,10 +286,21 @@ fn place(name: &str, id: &str) -> Option<bool> {
|
||||
if !(root == "assets" || root == "data") || rest.is_empty() || name.ends_with('/') {
|
||||
return None;
|
||||
}
|
||||
Some(ns == id || (root == "data" && ns == "minecraft" && rest.starts_with("tags/")))
|
||||
let shared_tags =
|
||||
root == "data" && (ns == "minecraft" || ns == "c") && rest.starts_with("tags/");
|
||||
Some(ns == id || shared_tags)
|
||||
}
|
||||
|
||||
pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, 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.
|
||||
pub fn carry(
|
||||
jar: &Path,
|
||||
info: &JarInfo,
|
||||
out: &Path,
|
||||
facts: Option<&Facts>,
|
||||
allowed: &dyn Fn(&str) -> bool,
|
||||
) -> Result<Report, String> {
|
||||
let id = &info.mod_id;
|
||||
if id.is_empty()
|
||||
|| id.len() > 64
|
||||
@@ -196,6 +320,7 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
|
||||
let mut report = Report::default();
|
||||
let mut blockstates: BTreeMap<String, Value> = BTreeMap::new();
|
||||
let mut item_models = BTreeSet::new();
|
||||
let mut convention = BTreeSet::new();
|
||||
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();
|
||||
@@ -218,11 +343,17 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
|
||||
};
|
||||
if keep {
|
||||
let rel = name.split_once(&format!("/{id}/")).map_or("", |(_, r)| r);
|
||||
if name.starts_with("data/")
|
||||
&& (rel.starts_with("worldgen/") || rel.starts_with("structure/"))
|
||||
{
|
||||
report.worldgen += 1;
|
||||
}
|
||||
if let Some(file) = rel
|
||||
.strip_prefix("recipe/")
|
||||
.filter(|_| name.starts_with("data/"))
|
||||
{
|
||||
if let Ok(mut recipe) = serde_json::from_slice::<Value>(&bytes) {
|
||||
tags_used(&recipe, &mut convention);
|
||||
if upgrade_recipe(&mut recipe) {
|
||||
report.recipes_upgraded += 1;
|
||||
bytes = serde_json::to_vec_pretty(&recipe).unwrap_or(bytes);
|
||||
@@ -230,6 +361,15 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
|
||||
report.recipes_kept.push(file.to_owned());
|
||||
}
|
||||
}
|
||||
} else if rel.starts_with("loot_table/") && name.starts_with("data/") {
|
||||
if let Ok(mut table) = serde_json::from_slice::<Value>(&bytes) {
|
||||
let before = table.clone();
|
||||
upgrade_loot(&mut table);
|
||||
if table != before {
|
||||
report.loot_tables_upgraded += 1;
|
||||
bytes = serde_json::to_vec_pretty(&table).unwrap_or(bytes);
|
||||
}
|
||||
}
|
||||
} else if let Some(b) = rel
|
||||
.strip_prefix("blockstates/")
|
||||
.and_then(|b| b.strip_suffix(".json"))
|
||||
@@ -257,25 +397,116 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
|
||||
}
|
||||
}
|
||||
let decl = inside.join(format!("data/{id}/horizon"));
|
||||
for (b, state) in &blockstates {
|
||||
match template(&properties(state)) {
|
||||
Some(t) => {
|
||||
write(
|
||||
&decl.join(format!("block/{b}.json")),
|
||||
json!({"template": t}).to_string().as_bytes(),
|
||||
)?;
|
||||
report.blocks.insert(b.clone(), t.to_owned());
|
||||
let write_decl = |kind: &str, name: &str, v: &Value| {
|
||||
let text = serde_json::to_vec_pretty(v).unwrap_or_default();
|
||||
write(&decl.join(format!("{kind}/{name}.json")), &text)
|
||||
};
|
||||
if let Some(facts) = facts {
|
||||
report.oracle = true;
|
||||
let prefix = format!("{id}:");
|
||||
let mut declared = BTreeSet::new();
|
||||
for (full, block) in facts.blocks.range(prefix.clone()..) {
|
||||
let Some(b) = full.strip_prefix(&prefix) else {
|
||||
break;
|
||||
};
|
||||
let Some(choice) = facts.template(full, allowed) else {
|
||||
let props: Vec<&str> = block.properties.keys().map(String::as_str).collect();
|
||||
let why = format!(
|
||||
"no vanilla {} with properties [{}]",
|
||||
block.vanilla_class().rsplit('.').next().unwrap_or(""),
|
||||
props.join(", ")
|
||||
);
|
||||
report.blocks_unknown.insert(b.to_owned(), why);
|
||||
continue;
|
||||
};
|
||||
let mut v = json!({"template": choice.template, "properties": choice.properties});
|
||||
if block.item == "minecraft:air" {
|
||||
v["item"] = json!(false);
|
||||
} else if block.item != *full {
|
||||
v["item"] = json!(false);
|
||||
report
|
||||
.differences
|
||||
.entry(b.to_owned())
|
||||
.or_default()
|
||||
.push(format!("its item is {}", block.item));
|
||||
} else {
|
||||
declared.insert(full.clone());
|
||||
}
|
||||
write_decl("block", b, &v)?;
|
||||
report.blocks.insert(b.to_owned(), choice.template);
|
||||
if !choice.differences.is_empty() {
|
||||
report
|
||||
.differences
|
||||
.entry(b.to_owned())
|
||||
.or_default()
|
||||
.extend(choice.differences);
|
||||
}
|
||||
None => report.blocks_unknown.push(b.clone()),
|
||||
}
|
||||
}
|
||||
for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) {
|
||||
let item = json!({"template": "minecraft:stick"});
|
||||
write(
|
||||
&decl.join(format!("item/{m}.json")),
|
||||
item.to_string().as_bytes(),
|
||||
)?;
|
||||
report.items += 1;
|
||||
for (full, item) in facts.items.range(prefix.clone()..) {
|
||||
let Some(name) = full.strip_prefix(&prefix) else {
|
||||
break;
|
||||
};
|
||||
if declared.contains(full) {
|
||||
continue;
|
||||
}
|
||||
if item
|
||||
.block
|
||||
.as_ref()
|
||||
.is_some_and(|b| facts.blocks.contains_key(b))
|
||||
&& report.blocks_unknown.contains_key(name)
|
||||
{
|
||||
report
|
||||
.items_unknown
|
||||
.insert(name.to_owned(), "its block is left out".into());
|
||||
continue;
|
||||
}
|
||||
match facts.item(full) {
|
||||
Ok((v, differences)) => {
|
||||
write_decl("item", name, &v)?;
|
||||
report.items += 1;
|
||||
if !differences.is_empty() {
|
||||
report.differences.insert(name.to_owned(), differences);
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
report.items_unknown.insert(name.to_owned(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Convention tags are NeoForge's and the pack's: the recipes get the
|
||||
// members the oracle saw, those of vanilla and of this mod.
|
||||
for tag in &convention {
|
||||
let Some(path) = tag.strip_prefix("c:") else {
|
||||
continue;
|
||||
};
|
||||
let file = inside.join(format!("data/c/tags/item/{path}.json"));
|
||||
if file.exists() {
|
||||
continue;
|
||||
}
|
||||
if let Some(members) = facts.tag_members("item", tag, id) {
|
||||
let v = json!({"values": members});
|
||||
write(&file, &serde_json::to_vec_pretty(&v).unwrap_or_default())?;
|
||||
report.convention_tags += 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (b, state) in &blockstates {
|
||||
match template(b, &properties(state)) {
|
||||
Some(t) => {
|
||||
write_decl("block", b, &json!({"template": t}))?;
|
||||
report.blocks.insert(b.clone(), t.to_owned());
|
||||
}
|
||||
None => {
|
||||
let props: Vec<String> = properties(state).into_iter().collect();
|
||||
let why = format!("no template for properties [{}]", props.join(", "));
|
||||
report.blocks_unknown.insert(b.clone(), why);
|
||||
}
|
||||
}
|
||||
}
|
||||
for m in item_models.iter().filter(|m| !blockstates.contains_key(*m)) {
|
||||
write_decl("item", m, &json!({"template": "minecraft:stick"}))?;
|
||||
report.items += 1;
|
||||
}
|
||||
}
|
||||
let q = |s: &str| toml::Value::String(s.to_owned()).to_string();
|
||||
let name = if info.name.is_empty() { id } else { &info.name };
|
||||
@@ -299,6 +530,30 @@ pub fn carry(jar: &Path, info: &JarInfo, out: &Path) -> Result<Report, String> {
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
/// The tags a recipe's ingredients name (`#ns:path` or `{"tag": ...}`).
|
||||
fn tags_used(v: &Value, out: &mut BTreeSet<String>) {
|
||||
match v {
|
||||
Value::String(s) => {
|
||||
if let Some(t) = s.strip_prefix('#') {
|
||||
out.insert(t.to_owned());
|
||||
}
|
||||
}
|
||||
Value::Array(a) => a.iter().for_each(|x| tags_used(x, out)),
|
||||
Value::Object(o) => {
|
||||
for (k, x) in o {
|
||||
match (k.as_str(), x) {
|
||||
("tag", Value::String(t)) => {
|
||||
out.insert(t.clone());
|
||||
}
|
||||
("result", _) => {}
|
||||
_ => tags_used(x, out),
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn write(path: &Path, bytes: &[u8]) -> Result<(), String> {
|
||||
if let Some(dir) = path.parent() {
|
||||
fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
|
||||
@@ -325,21 +580,86 @@ mod tests {
|
||||
assert!(!upgrade_recipe(&mut tag_list));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn upgrades_loot_tables() {
|
||||
let mut slab = json!({"type": "minecraft:block", "pools": [{"rolls": 1.0, "entries": [{
|
||||
"type": "minecraft:item", "name": "m:slab",
|
||||
"functions": [{"function": "minecraft:set_count", "count": 2.0, "add": false,
|
||||
"conditions": [{"condition": "minecraft:block_state_property", "block": "m:slab",
|
||||
"properties": {"type": "double"}}]},
|
||||
{"function": "minecraft:explosion_decay"}]}]}]});
|
||||
upgrade_loot(&mut slab);
|
||||
assert_eq!(
|
||||
slab["pools"][0]["entries"][0]["modifier"][0],
|
||||
json!({"type": "minecraft:set_count", "count": 2.0, "add": false,
|
||||
"condition": {"type": "minecraft:block_state_property", "block": "m:slab",
|
||||
"properties": {"type": "double"}}})
|
||||
);
|
||||
let silk = json!({"condition": "minecraft:match_tool", "predicate": {"predicates": {
|
||||
"minecraft:enchantments": [{"enchantments": "minecraft:silk_touch", "levels": {"min": 1}}]}}});
|
||||
let shears = json!({"condition": "minecraft:match_tool", "predicate": {"items": "minecraft:shears"}});
|
||||
let mut glass = json!({"pools": [{"conditions": [silk.clone()], "entries": []},
|
||||
{"conditions": [{"condition": "minecraft:any_of", "terms": [silk, shears]},
|
||||
{"condition": "minecraft:survives_explosion"}], "entries": []}]});
|
||||
upgrade_loot(&mut glass);
|
||||
assert_eq!(
|
||||
glass["pools"][0]["condition"],
|
||||
"minecraft:tool/can_silk_touch"
|
||||
);
|
||||
assert_eq!(
|
||||
glass["pools"][1]["condition"],
|
||||
json!({"type": "minecraft:all_of", "terms": [
|
||||
{"type": "minecraft:any_of", "terms": ["minecraft:tool/can_silk_touch", "minecraft:tool/can_shear"]},
|
||||
{"type": "minecraft:survives_explosion"}]})
|
||||
);
|
||||
// A loot table already in 26.3's shape stays as it is.
|
||||
let mut new = glass.clone();
|
||||
upgrade_loot(&mut new);
|
||||
assert_eq!(new, glass);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn templates_from_blockstate_properties() {
|
||||
let door =
|
||||
json!({"variants": {"facing=east,half=lower,hinge=left,open=false,powered=false": {}}});
|
||||
assert_eq!(template(&properties(&door)), Some("minecraft:oak_door"));
|
||||
assert_eq!(
|
||||
template("gem_door", &properties(&door)),
|
||||
Some("minecraft:oak_door")
|
||||
);
|
||||
// Models that ignore `powered`: still a door.
|
||||
let door = json!({"variants": {"facing=east,half=lower,hinge=left,open=false": {}}});
|
||||
assert_eq!(
|
||||
template("gem_door", &properties(&door)),
|
||||
Some("minecraft:oak_door")
|
||||
);
|
||||
let trapdoor = json!({"variants": {"facing=east,half=top,open=false": {}}});
|
||||
assert_eq!(
|
||||
template("gem_trapdoor", &properties(&trapdoor)),
|
||||
Some("minecraft:oak_trapdoor")
|
||||
);
|
||||
let sides = json!({"multipart": [{"when": {"north": "true"}}, {"when": {"east": "true"}},
|
||||
{"when": {"south": "true"}}, {"when": {"west": "true"}}]});
|
||||
assert_eq!(
|
||||
template("gem_pane", &properties(&sides)),
|
||||
Some("minecraft:glass_pane")
|
||||
);
|
||||
assert_eq!(
|
||||
template("gem_fence", &properties(&sides)),
|
||||
Some("minecraft:oak_fence")
|
||||
);
|
||||
let fence = json!({"multipart": [{"apply": {}}, {"when": {"north": "true"}, "apply": {}},
|
||||
{"when": {"east": "true"}}, {"when": {"south": "true"}}, {"when": {"west": "true"}},
|
||||
{"when": {"OR": [{"waterlogged": "true"}]}}]});
|
||||
assert_eq!(template(&properties(&fence)), Some("minecraft:oak_fence"));
|
||||
assert_eq!(
|
||||
template(&properties(&json!({"variants": {"": {}}}))),
|
||||
template("gem_fence", &properties(&fence)),
|
||||
Some("minecraft:oak_fence")
|
||||
);
|
||||
assert_eq!(
|
||||
template("gem_block", &properties(&json!({"variants": {"": {}}}))),
|
||||
Some("minecraft:stone")
|
||||
);
|
||||
let odd = json!({"variants": {"charge=1,mode=fast": {}}});
|
||||
assert_eq!(template(&properties(&odd)), None);
|
||||
assert_eq!(template("gem_core", &properties(&odd)), None);
|
||||
}
|
||||
|
||||
/// A small NeoForge jar carried over is a content mod Horizon loads.
|
||||
@@ -411,14 +731,17 @@ mod tests {
|
||||
);
|
||||
assert_eq!(info.census.classes, 1);
|
||||
let out = dir.join("work/mods/gem");
|
||||
let report = carry(&jar, &info, &out).unwrap();
|
||||
assert_eq!(report.copied, 11);
|
||||
assert_eq!(report.outside, ["data/c/tags/item/gems.json"]);
|
||||
let report = carry(&jar, &info, &out, None, &|_| true).unwrap();
|
||||
assert_eq!(report.copied, 12);
|
||||
assert!(report.outside.is_empty());
|
||||
assert_eq!((report.recipes_upgraded, report.recipes_kept.len()), (1, 1));
|
||||
assert_eq!(report.item_definitions_added, 2);
|
||||
assert_eq!(report.blocks["gem_door"], "minecraft:oak_door");
|
||||
assert_eq!(report.blocks["gem_block"], "minecraft:stone");
|
||||
assert_eq!(report.blocks_unknown, ["gem_core"]);
|
||||
assert_eq!(
|
||||
report.blocks_unknown.keys().collect::<Vec<_>>(),
|
||||
["gem_core"]
|
||||
);
|
||||
assert_eq!(report.items, 1);
|
||||
let carried = out.join("carry");
|
||||
assert!(!carried.join("com").exists());
|
||||
|
||||
@@ -50,6 +50,12 @@ pub fn read(path: &Path) -> Result<JarInfo, String> {
|
||||
} else {
|
||||
JarInfo::default()
|
||||
};
|
||||
// `version = "${file.jarVersion}"` is filled in from the manifest at load.
|
||||
if info.version.starts_with("${") {
|
||||
info.version = text(&mut zip, "META-INF/MANIFEST.MF")
|
||||
.and_then(|m| manifest_value(&m, "Implementation-Version"))
|
||||
.unwrap_or_default();
|
||||
}
|
||||
let names: Vec<String> = zip.file_names().map(str::to_owned).collect();
|
||||
info.census = census(&names);
|
||||
if info.mod_id.is_empty() {
|
||||
@@ -61,6 +67,16 @@ pub fn read(path: &Path) -> Result<JarInfo, String> {
|
||||
Ok(info)
|
||||
}
|
||||
|
||||
/// A main-section attribute of `META-INF/MANIFEST.MF`.
|
||||
fn manifest_value(manifest: &str, key: &str) -> Option<String> {
|
||||
manifest
|
||||
.lines()
|
||||
.take_while(|l| !l.trim().is_empty())
|
||||
.find_map(|l| l.strip_prefix(key)?.strip_prefix(':'))
|
||||
.map(|v| v.trim().to_owned())
|
||||
.filter(|v| !v.is_empty())
|
||||
}
|
||||
|
||||
/// `[[mods]]` (the first one is the jar's mod), the top-level `license`, and
|
||||
/// `[[dependencies.<id>]]` with `type = "required"` (or the older
|
||||
/// `mandatory = true`).
|
||||
|
||||
@@ -6,8 +6,11 @@
|
||||
//! `<work>/modrinth.json`), the jars in the instance or `<work>/jars/`,
|
||||
//! classes, tiers and dependency layers in `<work>/inventory.json` and
|
||||
//! `inventory.csv`.
|
||||
//! - `carry <work> [<mod id>...]`: the content mods' data and assets into
|
||||
//! `<work>/mods/<id>/carry/`, a folder mod for local use.
|
||||
//! - `carry <work> [--resources <prepared>] [<mod id>...]`: the content
|
||||
//! mods' data and assets into `<work>/mods/<id>/carry/`, a folder mod for
|
||||
//! local use. With the NeoForge oracle's `<work>/oracle/facts.json`
|
||||
//! (`tools/neoforge_oracle.py`), blocks and items come from its facts;
|
||||
//! `--resources` limits templates to the blocks Horizon's tables have.
|
||||
//!
|
||||
//! The work folder belongs to the user: jars and carried-over files stay
|
||||
//! there and are never uploaded or committed.
|
||||
@@ -17,10 +20,11 @@ mod import;
|
||||
mod inventory;
|
||||
mod jar;
|
||||
mod modrinth;
|
||||
mod oracle;
|
||||
|
||||
use std::{fs, path::Path, process::ExitCode};
|
||||
|
||||
const USAGE: &str = "usage: horizon-port-pack import <pack> <work> | inventory <work> [--offline] | carry <work> [<mod id>...]";
|
||||
const USAGE: &str = "usage: horizon-port-pack import <pack> <work> | inventory <work> [--offline] | carry <work> [--resources <prepared>] [<mod id>...]";
|
||||
|
||||
fn main() -> ExitCode {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
@@ -32,7 +36,19 @@ fn main() -> ExitCode {
|
||||
Some("inventory") => {
|
||||
path(1).and_then(|w| inventory(w, args.iter().any(|a| a == "--offline")))
|
||||
}
|
||||
Some("carry") => path(1).and_then(|w| carry(w, &args[2..])),
|
||||
Some("carry") => path(1).and_then(|w| {
|
||||
let mut rest = args[2..].to_vec();
|
||||
let resources = match rest.iter().position(|a| a == "--resources") {
|
||||
Some(i) if i + 1 < rest.len() => {
|
||||
let r = rest.remove(i + 1);
|
||||
rest.remove(i);
|
||||
Some(std::path::PathBuf::from(r))
|
||||
}
|
||||
Some(_) => return Err(USAGE.to_owned()),
|
||||
None => None,
|
||||
};
|
||||
carry(w, resources.as_deref(), &rest)
|
||||
}),
|
||||
_ => Err(USAGE.to_owned()),
|
||||
};
|
||||
match result {
|
||||
@@ -107,8 +123,31 @@ fn inventory(work: &Path, offline: bool) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn carry(work: &Path, only: &[String]) -> Result<(), String> {
|
||||
/// The vanilla blocks a prepared resource root has (`facts.json`'s defaults).
|
||||
fn vanilla_blocks(resources: &Path) -> Result<std::collections::BTreeSet<String>, String> {
|
||||
let facts: serde_json::Value = read_json(&resources.join("facts.json"))?;
|
||||
let defaults = facts["defaults"]
|
||||
.as_object()
|
||||
.ok_or("facts.json: no defaults")?;
|
||||
Ok(defaults.keys().cloned().collect())
|
||||
}
|
||||
|
||||
fn carry(work: &Path, resources: Option<&Path>, only: &[String]) -> Result<(), String> {
|
||||
let records: Vec<inventory::Record> = read_json(&work.join("inventory.json"))?;
|
||||
let facts_path = work.join("oracle/facts.json");
|
||||
let facts = if facts_path.exists() {
|
||||
let f = oracle::Facts::read(&facts_path)?;
|
||||
println!(
|
||||
"oracle facts: {} blocks, {} items",
|
||||
f.blocks.len(),
|
||||
f.items.len()
|
||||
);
|
||||
Some(f)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let vanilla = resources.map(vanilla_blocks).transpose()?;
|
||||
let allowed = |b: &str| vanilla.as_ref().is_none_or(|v| v.contains(b));
|
||||
let mut done = 0;
|
||||
for r in &records {
|
||||
let chosen = if only.is_empty() {
|
||||
@@ -125,19 +164,29 @@ fn carry(work: &Path, only: &[String]) -> Result<(), String> {
|
||||
if !chosen {
|
||||
continue;
|
||||
}
|
||||
match carry::carry(jar, info, &work.join("mods").join(&r.key)) {
|
||||
match carry::carry(
|
||||
jar,
|
||||
info,
|
||||
&work.join("mods").join(&r.key),
|
||||
facts.as_ref(),
|
||||
&allowed,
|
||||
) {
|
||||
Ok(report) => {
|
||||
done += 1;
|
||||
println!(
|
||||
"{}: {} files, {} recipes upgraded ({} kept), {} item definitions added, {} blocks ({} without a template), {} items, {} outside",
|
||||
"{}: {} files, {} recipes upgraded ({} kept), {} loot tables upgraded, {} item definitions added, {} blocks ({} left out, {} with differences), {} items ({} left out), {} convention tags, {} outside",
|
||||
r.key,
|
||||
report.copied,
|
||||
report.recipes_upgraded,
|
||||
report.recipes_kept.len(),
|
||||
report.loot_tables_upgraded,
|
||||
report.item_definitions_added,
|
||||
report.blocks.len(),
|
||||
report.blocks_unknown.len(),
|
||||
report.differences.len(),
|
||||
report.items,
|
||||
report.items_unknown.len(),
|
||||
report.convention_tags,
|
||||
report.outside.len()
|
||||
);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,384 @@
|
||||
//! The NeoForge oracle's facts (`tools/neoforge_oracle.py export`, in
|
||||
//! `<work>/oracle/facts.json`): every block, item, recipe and tag the pack's
|
||||
//! mods register, read from the running game, and the vanilla blocks beside
|
||||
//! them. Carry-over uses them in place of guesses: a block's template is the
|
||||
//! vanilla block of the same class and states whose shapes and sounds match
|
||||
//! best, and the declared properties are the mod's own numbers.
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Map, Value, json};
|
||||
use std::{
|
||||
collections::{BTreeMap, BTreeSet},
|
||||
path::Path,
|
||||
};
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct Facts {
|
||||
pub blocks: BTreeMap<String, Block>,
|
||||
pub items: BTreeMap<String, Item>,
|
||||
#[serde(default)]
|
||||
pub tags: Tags,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Deserialize)]
|
||||
pub struct Tags {
|
||||
#[serde(default)]
|
||||
pub block: BTreeMap<String, Vec<String>>,
|
||||
#[serde(default)]
|
||||
pub item: BTreeMap<String, Vec<String>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct Block {
|
||||
/// The class and its superclasses, most derived first.
|
||||
pub class: Vec<String>,
|
||||
pub properties: BTreeMap<String, Vec<String>>,
|
||||
pub default: String,
|
||||
pub item: String,
|
||||
pub explosion_resistance: f32,
|
||||
pub friction: f32,
|
||||
pub speed_factor: f32,
|
||||
pub jump_factor: f32,
|
||||
#[serde(default)]
|
||||
pub block_set_type: Option<SetType>,
|
||||
#[serde(default)]
|
||||
pub wood_type: Option<String>,
|
||||
pub states: BTreeMap<String, State>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct SetType {
|
||||
pub name: String,
|
||||
pub can_open_by_hand: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct State {
|
||||
pub hardness: f32,
|
||||
pub emission: u8,
|
||||
pub requires_tool: bool,
|
||||
pub map_color_id: u8,
|
||||
pub sound: Value,
|
||||
pub outline: Value,
|
||||
pub collision: Value,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct Item {
|
||||
pub class: String,
|
||||
pub max_stack_size: u8,
|
||||
pub rarity: String,
|
||||
#[serde(default)]
|
||||
pub block: Option<String>,
|
||||
#[serde(default)]
|
||||
pub food: Option<Value>,
|
||||
}
|
||||
|
||||
const VANILLA_PACKAGE: &str = "net.minecraft.";
|
||||
|
||||
/// A state key with its properties sorted, so keys compare across blocks.
|
||||
pub fn state_key(key: &str) -> String {
|
||||
let mut parts: Vec<&str> = key.split(',').filter(|p| !p.is_empty()).collect();
|
||||
parts.sort_unstable();
|
||||
parts.join(",")
|
||||
}
|
||||
|
||||
impl Block {
|
||||
/// The first vanilla class in the chain.
|
||||
pub fn vanilla_class(&self) -> &str {
|
||||
self.class
|
||||
.iter()
|
||||
.find(|c| c.starts_with(VANILLA_PACKAGE))
|
||||
.map_or("", String::as_str)
|
||||
}
|
||||
/// Its own class is a mod class: behaviour code the template may not have.
|
||||
pub fn custom_class(&self) -> bool {
|
||||
self.class
|
||||
.first()
|
||||
.is_some_and(|c| !c.starts_with(VANILLA_PACKAGE))
|
||||
}
|
||||
fn default_state(&self) -> Option<&State> {
|
||||
self.states
|
||||
.get(&self.default)
|
||||
.or_else(|| self.states.values().next())
|
||||
}
|
||||
fn same_states(&self, other: &Block) -> bool {
|
||||
self.properties.len() == other.properties.len()
|
||||
&& self.properties.iter().all(|(k, v)| {
|
||||
other.properties.get(k).is_some_and(|w| {
|
||||
v.iter().collect::<BTreeSet<_>>() == w.iter().collect::<BTreeSet<_>>()
|
||||
})
|
||||
})
|
||||
}
|
||||
fn by_key(&self) -> BTreeMap<String, &State> {
|
||||
self.states.iter().map(|(k, s)| (state_key(k), s)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// The template carry-over gives a mod block.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Choice {
|
||||
pub template: String,
|
||||
/// `data/<mod>/horizon/block/<name>.json`'s `properties`.
|
||||
pub properties: Map<String, Value>,
|
||||
/// What the template does not reproduce, for the report.
|
||||
pub differences: Vec<String>,
|
||||
}
|
||||
|
||||
impl Facts {
|
||||
pub fn read(path: &Path) -> Result<Facts, String> {
|
||||
let bytes = std::fs::read(path).map_err(|e| format!("{}: {e}", path.display()))?;
|
||||
serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display()))
|
||||
}
|
||||
|
||||
/// The vanilla block that best stands in for `id`: the same vanilla
|
||||
/// class and states, then the most states with the same outline and
|
||||
/// collision, then the same sounds, set type, wood type and hardness.
|
||||
/// `None` when no vanilla block has its class and states.
|
||||
pub fn template(&self, id: &str, allowed: &dyn Fn(&str) -> bool) -> Option<Choice> {
|
||||
let block = self.blocks.get(id)?;
|
||||
let class = block.vanilla_class();
|
||||
let own = block.by_key();
|
||||
let ours = block.default_state()?;
|
||||
let mut best: Option<(i64, &str, &Block)> = None;
|
||||
for (name, v) in &self.blocks {
|
||||
if !name.starts_with("minecraft:")
|
||||
|| v.vanilla_class() != class
|
||||
|| v.custom_class()
|
||||
|| !block.same_states(v)
|
||||
|| !allowed(name)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let theirs = v.by_key();
|
||||
let shapes = own
|
||||
.iter()
|
||||
.filter(|(k, s)| {
|
||||
theirs
|
||||
.get(*k)
|
||||
.is_some_and(|t| t.outline == s.outline && t.collision == s.collision)
|
||||
})
|
||||
.count() as i64;
|
||||
let Some(td) = v.default_state() else {
|
||||
continue;
|
||||
};
|
||||
let same_set = match (&block.block_set_type, &v.block_set_type) {
|
||||
(Some(a), Some(b)) => {
|
||||
(a.name == b.name) as i64 * 2
|
||||
+ (a.can_open_by_hand == b.can_open_by_hand) as i64 * 8
|
||||
}
|
||||
_ => 0,
|
||||
};
|
||||
let score = shapes * 1000
|
||||
+ (td.sound == ours.sound) as i64 * 100
|
||||
+ same_set * 10
|
||||
+ (block.wood_type.is_some() && block.wood_type == v.wood_type) as i64 * 20
|
||||
+ (td.hardness == ours.hardness) as i64 * 5
|
||||
+ (td.map_color_id == ours.map_color_id) as i64;
|
||||
if best.is_none_or(|(s, n, _)| score > s || (score == s && name.as_str() < n)) {
|
||||
best = Some((score, name, v));
|
||||
}
|
||||
}
|
||||
let (_, template, t) = best?;
|
||||
Some(self.choice(block, template, t, allowed))
|
||||
}
|
||||
|
||||
fn choice(
|
||||
&self,
|
||||
block: &Block,
|
||||
template: &str,
|
||||
t: &Block,
|
||||
allowed: &dyn Fn(&str) -> bool,
|
||||
) -> Choice {
|
||||
let (ours, theirs) = (block.default_state(), t.default_state());
|
||||
let mut properties = Map::new();
|
||||
let mut differences = Vec::new();
|
||||
if let Some(s) = ours {
|
||||
properties.insert("hardness".into(), json!(s.hardness));
|
||||
properties.insert(
|
||||
"explosion_resistance".into(),
|
||||
json!(block.explosion_resistance),
|
||||
);
|
||||
properties.insert("light".into(), json!(s.emission));
|
||||
properties.insert("requires_tool".into(), json!(s.requires_tool));
|
||||
properties.insert("friction".into(), json!(block.friction));
|
||||
properties.insert("map_color".into(), json!(s.map_color_id));
|
||||
if theirs.is_none_or(|t| t.sound != s.sound) {
|
||||
match self.sound_block(&s.sound, allowed) {
|
||||
Some(b) => {
|
||||
properties.insert("sounds".into(), json!(b));
|
||||
}
|
||||
None => differences.push("sounds: no vanilla block has them".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
if (block.speed_factor, block.jump_factor) != (t.speed_factor, t.jump_factor) {
|
||||
differences.push(format!(
|
||||
"speed and jump factors {} {} (template {} {})",
|
||||
block.speed_factor, block.jump_factor, t.speed_factor, t.jump_factor
|
||||
));
|
||||
}
|
||||
let theirs = t.by_key();
|
||||
let mut shapes = 0;
|
||||
let mut varying = BTreeSet::new();
|
||||
let first = ours.map(|s| (s.hardness, s.emission, s.requires_tool, s.map_color_id));
|
||||
for (k, s) in block.by_key() {
|
||||
let Some(v) = theirs.get(&k) else {
|
||||
continue;
|
||||
};
|
||||
if v.outline != s.outline || v.collision != s.collision {
|
||||
shapes += 1;
|
||||
}
|
||||
if Some((s.hardness, s.emission, s.requires_tool, s.map_color_id)) != first {
|
||||
varying.insert("per-state hardness, light or map colour");
|
||||
}
|
||||
}
|
||||
if shapes > 0 {
|
||||
differences.push(format!(
|
||||
"shapes differ from {template} in {shapes} of {} states",
|
||||
block.states.len()
|
||||
));
|
||||
}
|
||||
differences.extend(varying.into_iter().map(str::to_owned));
|
||||
if block.custom_class() {
|
||||
differences.push(format!(
|
||||
"class {} (behaviour beyond {})",
|
||||
block.class[0],
|
||||
block.vanilla_class()
|
||||
));
|
||||
}
|
||||
Choice {
|
||||
template: template.to_owned(),
|
||||
properties,
|
||||
differences,
|
||||
}
|
||||
}
|
||||
|
||||
/// A vanilla block whose default state has these sounds.
|
||||
fn sound_block(&self, sound: &Value, allowed: &dyn Fn(&str) -> bool) -> Option<&str> {
|
||||
self.blocks
|
||||
.iter()
|
||||
.filter(|(n, _)| n.starts_with("minecraft:") && allowed(n))
|
||||
.find(|(_, b)| b.default_state().is_some_and(|s| &s.sound == sound))
|
||||
.map(|(n, _)| n.as_str())
|
||||
}
|
||||
|
||||
/// An item declaration for a mod item that is not a declared block's:
|
||||
/// a vanilla template item with its stack size and rarity, and what it
|
||||
/// does not reproduce.
|
||||
pub fn item(&self, id: &str) -> Result<(Value, Vec<String>), String> {
|
||||
let item = self.items.get(id).ok_or("not in the oracle")?;
|
||||
if item.block.is_some() {
|
||||
return Err("a block item without a block".into());
|
||||
}
|
||||
let mut differences = Vec::new();
|
||||
if !item.class.starts_with(VANILLA_PACKAGE) {
|
||||
differences.push(format!("class {} (behaviour beyond Item)", item.class));
|
||||
}
|
||||
if item.food.is_some() {
|
||||
return Err("food (no food template yet)".into());
|
||||
}
|
||||
let mut decl = json!({"template": "minecraft:stick"});
|
||||
if item.max_stack_size != 64 {
|
||||
decl["max_stack_size"] = json!(item.max_stack_size);
|
||||
}
|
||||
if item.rarity != "common" {
|
||||
decl["rarity"] = json!(item.rarity);
|
||||
}
|
||||
Ok((decl, differences))
|
||||
}
|
||||
|
||||
/// A tag's members the content mod may name: vanilla's and its own.
|
||||
pub fn tag_members(&self, kind: &str, tag: &str, own: &str) -> Option<Vec<String>> {
|
||||
let map = if kind == "block" {
|
||||
&self.tags.block
|
||||
} else {
|
||||
&self.tags.item
|
||||
};
|
||||
let members = map.get(tag)?;
|
||||
Some(
|
||||
members
|
||||
.iter()
|
||||
.filter(|m| {
|
||||
m.split_once(':')
|
||||
.is_some_and(|(ns, _)| ns == "minecraft" || ns == own)
|
||||
})
|
||||
.cloned()
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn state(hardness: f32, sound: &str, outline: Value) -> Value {
|
||||
json!({"hardness": hardness, "emission": 0, "requires_tool": false, "map_color_id": 13,
|
||||
"sound": {"break": sound}, "outline": outline, "collision": outline})
|
||||
}
|
||||
fn block(class: &[&str], props: Value, states: Value) -> Value {
|
||||
let default = states
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.keys()
|
||||
.next()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
json!({"class": class, "properties": props, "default": default, "item": "x",
|
||||
"explosion_resistance": 3.0, "friction": 0.6, "speed_factor": 1.0,
|
||||
"jump_factor": 1.0, "states": states})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn templates_follow_class_shapes_and_sounds() {
|
||||
let cube = json!([[0, 0, 0, 1, 1, 1]]);
|
||||
let low = json!([[0, 0, 0, 1, 0.9375, 1]]);
|
||||
let block_class = ["net.minecraft.world.level.block.Block"];
|
||||
let path = ["net.minecraft.world.level.block.DirtPathBlock"];
|
||||
let facts: Facts = serde_json::from_value(json!({
|
||||
"blocks": {
|
||||
"minecraft:stone": block(&block_class, json!({}), json!({"": state(1.5, "stone", cube.clone())})),
|
||||
"minecraft:oak_planks": block(&block_class, json!({}), json!({"": state(2.0, "wood", cube.clone())})),
|
||||
"minecraft:dirt_path": block(&path, json!({}), json!({"": state(0.65, "grass", low.clone())})),
|
||||
"m:wood_tile": block(&["m.Tile", block_class[0]], json!({}), json!({"": state(2.5, "wood", cube.clone())})),
|
||||
"m:path": block(&["m.Path", block_class[0]], json!({}), json!({"": state(1.0, "stone", low.clone())})),
|
||||
"m:gadget": block(&["m.Gadget", block_class[0]], json!({"mode": ["a", "b"]}),
|
||||
json!({"mode=a": state(1.0, "stone", cube.clone()), "mode=b": state(1.0, "stone", cube)})),
|
||||
},
|
||||
"items": {}
|
||||
}))
|
||||
.unwrap();
|
||||
let any = |_: &str| true;
|
||||
let tile = facts.template("m:wood_tile", &any).unwrap();
|
||||
assert_eq!(tile.template, "minecraft:oak_planks");
|
||||
assert_eq!(tile.properties["hardness"], json!(2.5));
|
||||
assert!(!tile.properties.contains_key("sounds"));
|
||||
assert_eq!(
|
||||
tile.differences,
|
||||
["class m.Tile (behaviour beyond net.minecraft.world.level.block.Block)"]
|
||||
);
|
||||
// A plain Block is never templated on a DirtPathBlock: shapes differ, and say so.
|
||||
let path = facts.template("m:path", &any).unwrap();
|
||||
assert_eq!(path.template, "minecraft:stone");
|
||||
assert!(
|
||||
path.differences[0].starts_with("shapes differ"),
|
||||
"{:?}",
|
||||
path.differences
|
||||
);
|
||||
assert_eq!(facts.template("m:gadget", &any), None);
|
||||
let tile = facts
|
||||
.template("m:wood_tile", &|n: &str| n != "minecraft:oak_planks")
|
||||
.unwrap();
|
||||
assert_eq!(tile.template, "minecraft:stone");
|
||||
assert_eq!(tile.differences[0], "sounds: no vanilla block has them");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_keys_sort() {
|
||||
assert_eq!(
|
||||
state_key("half=lower,facing=north"),
|
||||
"facing=north,half=lower"
|
||||
);
|
||||
assert_eq!(state_key(""), "");
|
||||
}
|
||||
}
|
||||
+21
-8
@@ -268,6 +268,7 @@ inspected:
|
||||
cargo run -p horizon-port-pack -- import ~/Downloads/pack.mrpack ~/.horizon/ports/pack
|
||||
cargo run -p horizon-port-pack -- inventory ~/.horizon/ports/pack # --offline reuses modrinth.json
|
||||
cargo run -p horizon-port-pack -- carry ~/.horizon/ports/pack # content mods with a jar, or name them
|
||||
# --resources <prepared root>: only templates Horizon's tables have
|
||||
```
|
||||
|
||||
`inventory` reads metadata only: Modrinth answers by file hash, and the jars only if the user's
|
||||
@@ -277,14 +278,26 @@ classes come from the reviewed table, Modrinth categories and sides; with jars,
|
||||
only): content 54, library 33, client-ui 26, performance 25, other 14, unknown 2, server-only 1;
|
||||
40 rows matched the reviewed ATM10 table; three dependency layers (93 / 57 / 5).
|
||||
|
||||
`carry` copies a jar's `assets/<id>/`, `data/<id>/` and `data/minecraft/tags/` into
|
||||
`mods/<id>/carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and keeps
|
||||
what a content mod may not hold (other namespaces such as `c` tags, vanilla data) in `outside/`.
|
||||
No class file is copied. It upgrades vanilla-type recipes from 1.21.1 ingredients to 26.3's,
|
||||
adds the `items/` definitions 1.21.4 introduced, and declares each block from a vanilla template
|
||||
guessed from its blockstate properties (stone for none, a door for `facing, half, hinge, open,
|
||||
powered`, ...); blocks with an unknown property set, custom recipe types and NeoForge
|
||||
conditions are listed in `carry-report.json` for the oracle step.
|
||||
`carry` copies a jar's `assets/<id>/`, `data/<id>/`, `data/minecraft/tags/` and `data/c/tags/`
|
||||
into `mods/<id>/carry/`, a folder content mod (API 0.2) the game loads with `--dev-mod`, and
|
||||
keeps what a content mod may not hold (other namespaces, vanilla data) in `outside/`. 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
|
||||
`minecraft:tool/can_shear`), and the `items/` definitions 1.21.4 introduced.
|
||||
|
||||
Blocks and items come from the NeoForge oracle when `<work>/oracle/facts.json` exists (step 6):
|
||||
every block the mod registers gets the vanilla template of the same vanilla class and states
|
||||
whose shapes, sounds, set type and wood type match best, with the mod's own hardness, blast
|
||||
resistance, light, tool need, friction, map colour and sounds as overrides. `--resources
|
||||
<prepared>` limits templates to blocks Horizon's tables have. `carry-report.json` lists, per
|
||||
block, what the template does not reproduce (other shapes, sounds no vanilla block has, a class
|
||||
of its own), and the blocks left out: those whose vanilla class has no vanilla block with the
|
||||
same states (Macaw's garage doors, multi-part gates). Recipes get the convention tags they use
|
||||
(`c:dyes/red`), filled from the oracle with vanilla's and the mod's own members. Without the
|
||||
oracle, templates are guessed from the blockstate's properties: the template whose properties
|
||||
include them with the fewest left over (models often ignore `powered` or `waterlogged`), the
|
||||
block's name breaking ties (`_pane`, `_gate`, `_trapdoor`).
|
||||
|
||||
### 1. Import
|
||||
|
||||
|
||||
Reference in New Issue
Block a user