32f5f01e22
The harness the modpack design calls for, for data-tier mods: - tools/neoforge_oracle.py installs a NeoForge 21.1.259 server (ATM10's) under .local/neoforge-oracle, builds the exporter in mods/horizon/src/neoforge-oracle (our code, never shipped), runs it headless with the user's jars and writes every block (class chain, states, per-state hardness, light, tool need, map colour, sounds, outline and collision; drops for hand, diamond tools, shears and silk touch; placement; BlockSetType and WoodType), item, recipe and tag of the mods' namespaces, plus the vanilla blocks for templates. About 30 s. - examples/mod_port_probe.rs builds the content root from the carried mods and dumps what Horizon's loaders make of the same things. - tools/mod_port_harness.py compares them per mod and writes <work>/mods/<id>/harness/result.json. 1.21.1 sound events map to 26.3's through vanilla blocks both have, and vanilla items newer than 1.21.1 are not counted against a recipe. On ATM10's own jars (MIT): Macaw's Trapdoors passes everything; Doors, Fences, Paths, Glassential, Factory Blocks and Cloud Glass pass every drop, recipe, tag and placement and fail only on what API 0.2 cannot say (shapes and sound events of their own, blocks of classes no vanilla block shares). Jars, facts and results stay in the work folder. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
272 lines
10 KiB
Rust
272 lines
10 KiB
Rust
//! The Horizon side of a mod port's harness (tools/mod_port_harness.py,
|
|
//! docs/modpacks.md): builds the content root for carried-over mods and
|
|
//! writes what Horizon makes of every block state, drop, recipe and tag the
|
|
//! NeoForge oracle exported.
|
|
//!
|
|
//! cargo run -p horizon-client --example mod_port_probe -- PREPARED WORK OUT.json [MOD...]
|
|
//!
|
|
//! WORK is a `horizon-port-pack` work folder: `oracle/facts.json` and
|
|
//! `mods/<id>/carry/`. The root is built in `WORK/horizon-root`.
|
|
use horizon_client::{
|
|
Result,
|
|
assets::Assets,
|
|
blocks::BlockFacts,
|
|
crafting::{Recipe, Recipes},
|
|
items::{ItemStack, Items},
|
|
mod_content::{self, ContentMod},
|
|
stations::StationRecipes,
|
|
};
|
|
use horizon_core::{geometry::Axis, random::LegacyRandom};
|
|
use horizon_world::chunk::BlockState;
|
|
use serde_json::{Map, Value, json};
|
|
use std::{collections::BTreeMap, fs, path::Path};
|
|
|
|
fn boxes(list: impl IntoIterator<Item = [f64; 6]>) -> Value {
|
|
let mut v: Vec<[f64; 6]> = list.into_iter().collect();
|
|
v.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
|
|
json!(v)
|
|
}
|
|
|
|
fn sound(s: &horizon_client::blocks::Sounds) -> Value {
|
|
json!({"volume": s.volume, "pitch": s.pitch, "break": &*s.break_sound, "step": &*s.step,
|
|
"place": &*s.place, "hit": &*s.hit, "fall": &*s.fall})
|
|
}
|
|
|
|
fn tool(name: &str) -> Option<ItemStack> {
|
|
match name {
|
|
"hand" => None,
|
|
"silk_touch_pickaxe" => {
|
|
let mut pick = ItemStack::new("minecraft:diamond_pickaxe", 1);
|
|
pick.enchant("minecraft:silk_touch", 1);
|
|
Some(pick)
|
|
}
|
|
other => Some(ItemStack::new(&format!("minecraft:{other}"), 1)),
|
|
}
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let args: Vec<String> = std::env::args().skip(1).collect();
|
|
let [base, work, out, wanted @ ..] = args.as_slice() else {
|
|
return Err("usage: mod_port_probe PREPARED WORK OUT.json [MOD...]".into());
|
|
};
|
|
let (base, work) = (Path::new(base), Path::new(work));
|
|
let oracle: Value = serde_json::from_slice(&fs::read(work.join("oracle/facts.json"))?)?;
|
|
let mut mods = Vec::new();
|
|
for entry in fs::read_dir(work.join("mods"))?.flatten() {
|
|
let id = entry.file_name().to_string_lossy().into_owned();
|
|
let dir = entry.path().join("carry");
|
|
if !(wanted.is_empty() || wanted.contains(&id)) || !dir.is_dir() {
|
|
continue;
|
|
}
|
|
let package = horizon_mods::Package::read(&dir)?;
|
|
let content = horizon_mods::Content::read(&dir, &package.manifest)?;
|
|
mods.push(ContentMod {
|
|
id: package.manifest.id.clone(),
|
|
content,
|
|
});
|
|
}
|
|
mods.sort_by(|a, b| a.id.cmp(&b.id));
|
|
let root = work.join("horizon-root");
|
|
let began = std::time::Instant::now();
|
|
let step = |what: &str| {
|
|
let what = what.to_owned();
|
|
move |e: Box<dyn std::error::Error>| format!("{what}: {e}")
|
|
};
|
|
mod_content::build(base, &mods, &root).map_err(step("content root"))?;
|
|
let built = began.elapsed().as_secs_f64();
|
|
let assets = Assets::load(&root).map_err(step("assets"))?;
|
|
let registry = assets.registry;
|
|
let facts = BlockFacts::load(&root, registry).map_err(step("block facts"))?;
|
|
let items = Items::load(&root, registry, &facts).map_err(step("items"))?;
|
|
let recipes = Recipes::load(&root, &items).map_err(step("recipes"))?;
|
|
let stations = StationRecipes::load(&root, &items);
|
|
let collisions =
|
|
horizon_client::collisions::load(&root, registry).map_err(step("collisions"))?;
|
|
let loaded = began.elapsed().as_secs_f64() - built;
|
|
let ours = |id: &str| {
|
|
id.split_once(':')
|
|
.is_some_and(|(ns, _)| mods.iter().any(|m| m.id == ns))
|
|
};
|
|
let tools: Vec<String> = serde_json::from_value(oracle["tools"].clone())?;
|
|
|
|
let mut blocks = Map::new();
|
|
for (name, block) in oracle["blocks"].as_object().ok_or("oracle: no blocks")? {
|
|
if !ours(name) {
|
|
continue;
|
|
}
|
|
let Some(default) = registry.default_state(name) else {
|
|
blocks.insert(name.clone(), Value::Null);
|
|
continue;
|
|
};
|
|
let mut states = Map::new();
|
|
for (key, o) in block["states"].as_object().into_iter().flatten() {
|
|
let properties: BTreeMap<String, String> = key
|
|
.split(',')
|
|
.filter(|p| !p.is_empty())
|
|
.filter_map(|p| p.split_once('='))
|
|
.map(|(k, v)| (k.to_owned(), v.to_owned()))
|
|
.collect();
|
|
let descriptor = BlockState {
|
|
name: name.clone(),
|
|
properties,
|
|
};
|
|
let Some(id) = registry.id(&descriptor) else {
|
|
states.insert(key.clone(), Value::Null);
|
|
continue;
|
|
};
|
|
let f = facts.get(id);
|
|
let collision = collisions
|
|
.cached_shapes()
|
|
.cached_shape(id)
|
|
.ok()
|
|
.flatten()
|
|
.map(|s| {
|
|
boxes(s.boxes().iter().map(|b| {
|
|
[
|
|
b.min(Axis::X),
|
|
b.min(Axis::Y),
|
|
b.min(Axis::Z),
|
|
b.max(Axis::X),
|
|
b.max(Axis::Y),
|
|
b.max(Axis::Z),
|
|
]
|
|
}))
|
|
});
|
|
let mut row = json!({
|
|
"hardness": f.hardness,
|
|
"explosion_resistance": f.explosion_resistance,
|
|
"emission": f.emission,
|
|
"requires_tool": f.requires_tool,
|
|
"friction": f.friction,
|
|
"map_color_id": f.map_color,
|
|
"can_occlude": f.can_occlude,
|
|
"sound": sound(&f.sounds),
|
|
"outline": boxes(f.outline.iter().copied()),
|
|
"collision": collision,
|
|
"classes": f.classes.iter().map(|c| &**c).collect::<Vec<_>>(),
|
|
});
|
|
if o.get("drops").is_some() {
|
|
let mut drops = Map::new();
|
|
for t in &tools {
|
|
let mut random = LegacyRandom::new(0);
|
|
let held = tool(t);
|
|
let mut counts: BTreeMap<String, u32> = BTreeMap::new();
|
|
for s in items.block_drops(registry, id, held.as_ref(), &mut random) {
|
|
*counts.entry(s.item.to_string()).or_default() += s.count;
|
|
}
|
|
drops.insert(t.clone(), json!(counts));
|
|
}
|
|
row["drops"] = Value::Object(drops);
|
|
}
|
|
states.insert(key.clone(), row);
|
|
}
|
|
let item = facts.get(default).item.to_string();
|
|
blocks.insert(
|
|
name.clone(),
|
|
json!({"states": states, "item": item, "item_known": items.items.contains_key(&*item)}),
|
|
);
|
|
}
|
|
|
|
// Vanilla's sounds, by block: the harness maps the oracle's version's
|
|
// sound events to this one's through them.
|
|
let mut vanilla_sounds = Map::new();
|
|
for name in oracle["blocks"]
|
|
.as_object()
|
|
.into_iter()
|
|
.flatten()
|
|
.map(|(k, _)| k)
|
|
{
|
|
if let Some(id) = name
|
|
.starts_with("minecraft:")
|
|
.then(|| registry.default_state(name))
|
|
.flatten()
|
|
{
|
|
vanilla_sounds.insert(name.clone(), sound(&facts.get(id).sounds));
|
|
}
|
|
}
|
|
|
|
let mut item_rows = Map::new();
|
|
for name in oracle["items"]
|
|
.as_object()
|
|
.into_iter()
|
|
.flatten()
|
|
.map(|(k, _)| k)
|
|
{
|
|
item_rows.insert(
|
|
name.clone(),
|
|
match items.items.get(name.as_str()) {
|
|
Some(i) => json!({"max_stack_size": i.max_stack, "block": i.block.map(|b| b.0)}),
|
|
None => Value::Null,
|
|
},
|
|
);
|
|
}
|
|
|
|
let sorted = |list: &[String]| {
|
|
let mut v = list.to_vec();
|
|
v.sort();
|
|
v.dedup();
|
|
v
|
|
};
|
|
let mut recipe_rows = Map::new();
|
|
for (name, recipe) in &recipes.crafting {
|
|
if !ours(name) {
|
|
continue;
|
|
}
|
|
let row = match recipe {
|
|
Recipe::Shaped { cells, result, .. } => json!({
|
|
"result": result.item.as_deref(), "count": result.count,
|
|
"ingredients": cells.iter().flatten().map(|i| sorted(&i.1)).collect::<Vec<_>>()}),
|
|
Recipe::Shapeless {
|
|
ingredients,
|
|
result,
|
|
} => json!({
|
|
"result": result.item.as_deref(), "count": result.count,
|
|
"ingredients": ingredients.iter().map(|i| sorted(&i.1)).collect::<Vec<_>>()}),
|
|
Recipe::Special(_) => json!({"special": true}),
|
|
};
|
|
recipe_rows.insert(name.clone(), row);
|
|
}
|
|
for c in recipes.cooking.iter().filter(|c| ours(&c.id)) {
|
|
recipe_rows.insert(
|
|
c.id.clone(),
|
|
json!({"result": &*c.result.item, "count": c.result.count,
|
|
"ingredients": [sorted(&c.ingredient.1)]}),
|
|
);
|
|
}
|
|
for s in stations.stonecutting.iter().filter(|s| ours(&s.id)) {
|
|
recipe_rows.insert(
|
|
s.id.clone(),
|
|
json!({"result": &*s.result.item, "count": s.result.count,
|
|
"ingredients": [sorted(&s.input.1)]}),
|
|
);
|
|
}
|
|
|
|
let mut block_tags = Map::new();
|
|
for (tag, members) in &items.block_tags {
|
|
let mut ids: Vec<&String> = members.iter().filter(|m| ours(m)).collect();
|
|
if !ids.is_empty() {
|
|
ids.sort();
|
|
block_tags.insert(tag.clone(), json!(ids));
|
|
}
|
|
}
|
|
|
|
let report = json!({
|
|
"states": registry.len(),
|
|
"build_seconds": built,
|
|
"load_seconds": loaded,
|
|
"blocks": blocks,
|
|
"items": item_rows,
|
|
"recipes": recipe_rows,
|
|
"block_tags": block_tags,
|
|
"vanilla_sounds": vanilla_sounds,
|
|
});
|
|
fs::write(out, serde_json::to_vec(&report)?)?;
|
|
println!(
|
|
"{out}: {} blocks, {} items, {} recipes; root built in {built:.2} s, loaded in {loaded:.2} s",
|
|
blocks.len(),
|
|
item_rows.len(),
|
|
recipe_rows.len()
|
|
);
|
|
Ok(())
|
|
}
|