Files
horizon-airdef/crates/horizon-client/examples/recipe_book_render_fixture.rs
T
Ludovic Marie eec52f9055 The recipe book draws as vanilla's widgets do; test_recipe_book_render_parity
horizon_client::recipe_book_screen lays out RecipeBookComponent's drawing
(background, search EditBox, tab buttons, the filter CycleButton, the page
of RecipeButtons with its number and arrows, the alternatives overlay,
tooltips) and GhostSlots as vanilla's GUI calls with their poses, and the
game paints them. The new harness builds vanilla's widgets for 600 random
states (VanillaRecipeBookScreenOracle) and compares every call: 600/600.

Ingredients keep their HolderSet order (tags in TagLoader order), which is
how the overlay and ghost slots cycle; the book centres over the menu on
narrow screens as widthTooNarrow does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-13 02:22:55 +02:00

264 lines
10 KiB
Rust

//! The recipe book's drawing, for tools/test_recipe_book_render_parity.py:
//! reads one JSON case per line (book type, GUI size, tabs, search box,
//! filter, recipe collections and page, overlay, ghost slots, cycling index,
//! mouse) and writes the calls `horizon_client::recipe_book_screen` makes,
//! in the oracle's JSON form.
//!
//! usage: recipe_book_render_fixture RESOURCES CASES OUTPUT
use horizon_client::{
crafting::Recipes,
hud::{HudAtlas, HudBatch},
items::{ItemStack, Items},
lang,
recipe_book::{Book, BookType, Entry},
recipe_book_screen::{
ButtonView, Call, GhostView, ItemCall, OverlayRecipe, OverlayView, Run, Screen, Search,
TabView, draw, overlay_cells, overlay_origin,
},
};
use serde_json::{Value, json};
use std::{fmt::Write as _, fs, path::Path};
fn runs(r: &[Run]) -> Value {
Value::Array(
r.iter()
.map(|r| json!([r.text, r.color, r.italic]))
.collect(),
)
}
fn round(v: f32) -> f32 {
(v * 1e4).round() / 1e4
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let usage = "usage: recipe_book_render_fixture RESOURCES CASES OUTPUT";
let root = Path::new(args.get(1).ok_or(usage)?);
let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
let items = Items::catalog(root)?;
let recipes = Recipes::load(root, &items)?;
let book = Book::build(&recipes, &items);
let atlas = HudAtlas::build(root)?;
let root_buf = root.to_path_buf();
lang::set(lang::Language::load(&[&root_buf], lang::DEFAULT));
let translate = |key: &str| lang::get(key);
let text_width = |s: &str| HudBatch::text_width(&atlas, s) as i32;
let mut out = String::new();
for line in cases.lines() {
let case: Value = serde_json::from_str(line)?;
let int = |v: &Value| v.as_i64().unwrap_or(0) as i32;
let kind = match case["type"].as_str().unwrap_or_default() {
"crafting" => BookType::Crafting,
"furnace" => BookType::Furnace,
"blast_furnace" => BookType::BlastFurnace,
_ => BookType::Smoker,
};
let filtering = case["filtering"].as_bool().unwrap_or(false);
let tab_list = kind.tabs();
let tabs: Vec<TabView> = case["tabs"]
.as_array()
.into_iter()
.flatten()
.map(|t| {
let (a, b) = tab_list[t["tab"].as_u64().unwrap_or(0) as usize].icons();
TabView {
icons: (a.to_owned(), b.map(str::to_owned)),
selected: t["selected"].as_bool().unwrap_or(false),
anim: t["anim"].as_f64().unwrap_or(0.0) as f32,
}
})
.collect();
let s = &case["search"];
let search = Search {
value: s["value"].as_str().unwrap_or_default().to_owned(),
cursor: s["cursor"].as_u64().unwrap_or(0) as usize,
highlight: s["highlight"].as_u64().unwrap_or(0) as usize,
display: s["display"].as_u64().unwrap_or(0) as usize,
focused: s["focused"].as_bool().unwrap_or(false),
blink_ms: s["blink"].as_u64().unwrap_or(0),
};
// Each collection's recipes and craftable flags.
let collections: Vec<Vec<(&Entry, bool)>> = case["collections"]
.as_array()
.into_iter()
.flatten()
.map(|c| {
c["recipes"]
.as_array()
.into_iter()
.flatten()
.filter_map(|r| Some((book.entry(r[0].as_str()?)?, r[1].as_bool()?)))
.collect()
})
.collect();
let page = case["page"].as_u64().unwrap_or(0) as usize;
let pages = collections.len().div_ceil(20);
let anims = case["buttonAnims"].as_array().cloned().unwrap_or_default();
let shown = &collections[(20 * page).min(collections.len())..];
let buttons: Vec<ButtonView> = shown
.iter()
.take(20)
.enumerate()
.map(|(i, c)| ButtonView {
has_craftable: c.iter().any(|e| e.1),
entries: c
.iter()
.filter(|e| e.1 || !filtering)
.map(|e| vec![e.0.result.clone()])
.collect(),
anim: anims.get(i).and_then(Value::as_f64).unwrap_or(0.0) as f32,
})
.collect();
let (xo, yo) = Screen {
book: kind,
width: int(&case["width"]),
height: int(&case["height"]),
narrow: case["narrow"].as_bool().unwrap_or(false),
mouse: (0, 0),
index: 0,
filtering,
search: &search,
tabs: &[],
buttons: &[],
page,
pages,
overlay: None,
ghost: None,
translate: &translate,
text_width: &text_width,
}
.origin();
let overlay = case["overlay"].as_u64().map(|i| {
let i = i as usize;
let c = &shown[i];
let mut recipes: Vec<OverlayRecipe> = c
.iter()
.filter(|e| e.1)
.map(|e| OverlayRecipe {
craftable: true,
cells: overlay_cells(&book, e.0),
})
.collect();
if !filtering {
recipes.extend(c.iter().filter(|e| !e.1).map(|e| OverlayRecipe {
craftable: false,
cells: overlay_cells(&book, e.0),
}));
}
let (x, y) = overlay_origin(
xo + 11 + 25 * (i as i32 % 5),
yo + 31 + 25 * (i as i32 / 5),
recipes.len(),
xo,
yo,
);
OverlayView { x, y, recipes }
});
let ghosts: Vec<GhostView> = case["ghost"]
.as_array()
.into_iter()
.flatten()
.map(|g| GhostView {
x: int(&g["x"]),
y: int(&g["y"]),
result: g["result"].as_bool().unwrap_or(false),
items: g["items"]
.as_array()
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(|i| ItemStack::new(i, 1))
.collect(),
})
.collect();
let screen = Screen {
book: kind,
width: int(&case["width"]),
height: int(&case["height"]),
narrow: case["narrow"].as_bool().unwrap_or(false),
mouse: (int(&case["mouse"][0]), int(&case["mouse"][1])),
index: case["index"].as_u64().unwrap_or(0) as usize,
filtering,
search: &search,
tabs: &tabs,
buttons: &buttons,
page,
pages,
overlay: overlay.as_ref(),
ghost: case.get("ghost").map(|_| {
(
int(&case["left"]),
int(&case["top"]),
case["big"].as_bool().unwrap_or(false),
ghosts.as_slice(),
)
}),
translate: &translate,
text_width: &text_width,
};
let draws: Vec<Value> = draw(&screen)
.into_iter()
.filter_map(|d| {
let m: Vec<f32> = d.pose.iter().map(|v| round(*v)).collect();
let mut o = match d.call {
Call::Blit {
texture,
x,
y,
w,
h,
u,
v,
tw,
th,
} => json!({"t": "blit", "texture": texture, "x": x, "y": y, "w": w, "h": h,
"u": u, "v": v, "tw": tw, "th": th}),
Call::Sprite { id, x, y, w, h } => {
json!({"t": "sprite", "id": id, "x": x, "y": y, "w": w, "h": h})
}
Call::Fill {
x0,
y0,
x1,
y1,
color,
} => json!({"t": "fill", "x0": x0, "y0": y0, "x1": x1, "y1": y1, "color": color}),
Call::Highlight { x0, y0, x1, y1 } => {
json!({"t": "highlight", "x0": x0, "y0": y0, "x1": x1, "y1": y1})
}
Call::Text {
runs: r,
x,
y,
color,
shadow,
} => json!({"t": "text", "runs": runs(&r), "x": x, "y": y, "color": color, "shadow": shadow}),
Call::Item { call, stack, x, y } => {
if stack.count == 0 || &*stack.item == "minecraft:air" {
return None;
}
let t = match call {
ItemCall::Item => "item",
ItemCall::Fake => "fake",
ItemCall::Decorations => "decorations",
};
json!({"t": t, "id": &*stack.item, "count": stack.count, "x": x, "y": y})
}
Call::Tooltip(lines) => {
json!({"t": "tooltip", "lines": lines.iter().map(|l| runs(l)).collect::<Vec<_>>()})
}
Call::ItemTooltip { stack, more } => {
json!({"t": "item_tooltip", "id": &*stack.item, "more": more})
}
Call::Stratum => json!({"t": "stratum"}),
};
o["m"] = json!(m);
Some(o)
})
.collect();
let _ = writeln!(out, "{}", json!({ "draws": draws }));
}
fs::write(args.get(3).ok_or(usage)?, out)?;
Ok(())
}