Merge branch 'parity/leftovers' into parity-base

This commit is contained in:
Ludovic Marie
2026-10-13 07:07:54 +02:00
20 changed files with 1373 additions and 92 deletions
@@ -0,0 +1,73 @@
//! The ghost recipe a recipe book click fades into the menu, for
//! tools/test_ghost_recipe_parity.py: reads one JSON case per line (menu, recipe
//! id, the stack in the furnace's fuel slot) and prints, for every display of
//! the recipe, the slots `Book::ghost` fills and the stacks each cycles through.
//!
//! usage: ghost_recipe_fixture RESOURCES CASES OUTPUT
use horizon_client::{
crafting::Recipes,
item_data::{canon_stack, parse_stack},
items::Items,
recipe_book::{Book, BookType, GhostTarget, RecipeIndex},
};
use serde_json::Value;
use std::{fmt::Write as _, fs, path::Path};
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let usage = "usage: ghost_recipe_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 index = RecipeIndex::load(root);
let mut book = Book::build(&recipes, &items);
book.set_display_ids(&index);
let mut out = String::new();
for line in cases.lines() {
let case: Value = serde_json::from_str(line)?;
let menu = case["menu"].as_str().unwrap_or_default();
let id = case["recipe"].as_str().unwrap_or_default();
let (book_type, grid) = match menu {
"inventory" => (BookType::Crafting, 2),
"crafting" => (BookType::Crafting, 3),
"furnace" => (BookType::Furnace, 0),
"blast_furnace" => (BookType::BlastFurnace, 0),
_ => (BookType::Smoker, 0),
};
let fuel = match case["fuel"].as_str() {
Some(s) => parse_stack(s)?,
None => None,
};
for entry in book.entries.iter().filter(|e| e.id == id) {
let crafting = book_type == BookType::Crafting;
let is_furnace = matches!(
entry.display,
horizon_client::recipe_book::Display::Furnace(_)
);
if is_furnace == crafting || (crafting && !entry.fits(grid, grid)) {
out.push_str("skip | ");
continue;
}
for slot in book.ghost(entry, book_type, grid, fuel.is_none(), &items) {
let (index, result) = match slot.target {
GhostTarget::Result => (if crafting { 0 } else { 2 }, true),
GhostTarget::Grid(i) => (1 + i, false),
GhostTarget::Input => (0, false),
GhostTarget::Fuel => (1, false),
};
let stacks: Vec<String> = slot.items.iter().map(|s| canon_stack(Some(s))).collect();
let _ = write!(
out,
"{index}{}={} ",
if result { "R" } else { "I" },
stacks.join(",")
);
}
out.push_str("| ");
}
out.push('\n');
}
fs::write(args.get(3).ok_or(usage)?, out)?;
Ok(())
}
@@ -0,0 +1,42 @@
//! Creative toolbars read through the data fixers, for
//! tools/test_hotbar_parity.py: reads one JSON case per line (the SNBT of a
//! `hotbar.nbt`, or null for a missing file) and prints the stacks of the nine
//! rows after `horizon_client::hotbar::from_tag`.
//!
//! usage: hotbar_fixture RESOURCES CASES OUTPUT
use horizon_client::{hotbar, item_data::canon_stack, items::Items};
use horizon_world::nbt::{Tag, parse_snbt};
use serde_json::Value;
use std::path::Path;
use std::{fmt::Write as _, fs};
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let usage = "usage: hotbar_fixture RESOURCES CASES OUTPUT";
let items = Items::catalog(Path::new(args.first().and(args.get(1)).ok_or(usage)?))?;
let known = |id: &str| items.get(id).is_some();
let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
let mut out = String::new();
for line in cases.lines() {
let case: Value = serde_json::from_str(line)?;
let rows = match case["snbt"].as_str() {
Some(text) => match parse_snbt(text) {
Ok((tag @ Tag::Compound(_), _)) => hotbar::from_tag(tag, &known),
_ => return Err("case snbt".into()),
},
None => (0..hotbar::GROUPS)
.map(|_| vec![None; hotbar::SIZE])
.collect(),
};
for (i, row) in rows.iter().enumerate() {
let _ = write!(out, "{i}:");
for stack in row {
let _ = write!(out, " {}", canon_stack(stack.as_ref()));
}
out.push_str(" | ");
}
out.push('\n');
}
fs::write(args.get(3).ok_or(usage)?, out)?;
Ok(())
}
@@ -26,6 +26,11 @@ fn main() -> horizon_client::Result<()> {
let mut book = Book::build(&recipes, &items);
book.set_display_ids(&index);
let max = |s: &horizon_client::items::ItemStack| items.get(&s.item).map_or(64, |i| i.max_stack);
let names = horizon_client::creative::Names::load(root);
let translate = |k: &str| names.get(k).map(str::to_owned);
let tooltip = |s: &horizon_client::items::ItemStack| {
horizon_client::item_tooltip::lines(s, items.get(&s.item), &translate)
};
let mut out = String::new();
for line in cases.lines() {
let case: Value = serde_json::from_str(line)?;
@@ -69,6 +74,7 @@ fn main() -> horizon_client::Result<()> {
_ => BookType::Smoker,
};
let filtering = case["filtering"].as_bool().unwrap_or(false);
let query = case["search"].as_str().unwrap_or_default();
for tab in book_type.tabs() {
let collections = client.collections(&book, book_type, tab);
let selected = |i: usize| match (&book.entries[i].display, book_type) {
@@ -85,6 +91,9 @@ fn main() -> horizon_client::Result<()> {
let shown: Vec<_> = collections
.iter()
.filter(|c| c.entries.iter().any(|&i| selected(i)))
.filter(|c| {
query.is_empty() || book.collection_matches(&c.entries, query, &tooltip)
})
.filter(|c| !filtering || c.entries.iter().any(|&i| craftable(i)))
.collect();
let name = match tab {
+88 -21
View File
@@ -297,9 +297,19 @@ pub enum Special {
}
impl Special {
/// The recipe-book displays of a learnable (non-custom) crafting recipe:
/// its layout and result.
pub fn book_displays(&self) -> Vec<(crate::recipe_book::Display, ItemStack)> {
/// its layout, its result as the button shows it, and every stack the
/// result display cycles through when it is more than that one
/// (`SlotDisplay.resolveForStacks`).
pub fn book_displays(&self) -> Vec<BookDisplay> {
use crate::recipe_book::Display;
let first_of =
|all: &Vec<ItemStack>, single: ItemStack| all.first().cloned().unwrap_or(single);
let shown = |display, result, variants| BookDisplay {
display,
result,
variants,
stacks: Vec::new(),
};
match self {
Self::Transmute {
input,
@@ -313,26 +323,54 @@ impl Special {
let mut ingredients = vec![input.clone()];
ingredients.extend(std::iter::repeat_n(material.clone(), n));
let mut made = result.create();
if result.item.is_none() {
// The result keeps the input's item: show the first one.
if let Some(first) = input.0.iter().min() {
made.item = Arc::from(first.as_str());
}
}
if *add_count {
made.count += n as u32;
}
(Display::Shapeless(ingredients), made)
// The result keeps the input's item: any item of the ingredient.
let all: Vec<ItemStack> = if result.item.is_none() {
input
.1
.iter()
.map(|item| {
let mut stack = made.clone();
stack.item = Arc::from(item.as_str());
stack
})
.collect()
} else {
Vec::new()
};
shown(Display::Shapeless(ingredients), first_of(&all, made), all)
})
.collect(),
Self::Dye {
target,
dye,
result,
} => vec![(
Display::Shapeless(vec![target.clone(), dye.clone()]),
result.create(),
)],
} => {
// DyedSlotDemo: the targets cycle fastest, 16 stacks at most.
let (targets, dyes) = (&target.1, &dye.1);
let all: Vec<ItemStack> = (0..targets.len() * dyes.len())
.map(|i| {
let mut made = result.create();
made.item = Arc::from(targets[i % targets.len()].as_str());
let name = dyes[i / targets.len()].trim_start_matches("minecraft:");
let color = crate::block_entity_render::DYES
.iter()
.find(|(c, _)| name.strip_suffix("_dye") == Some(c))
.map_or(crate::block_entity_render::DYES[0].1, |d| d.1);
made.data_mut().dyed_color = Some(color as i32);
made
})
.take(16)
.collect();
let first = result.create();
vec![shown(
Display::Shapeless(vec![target.clone(), dye.clone()]),
first_of(&all, first),
all,
)]
}
Self::Imbue {
source,
material,
@@ -341,19 +379,48 @@ impl Special {
let cells = (0..9)
.map(|i| Some(if i == 4 { source } else { material }.clone()))
.collect();
vec![(
Display::Shaped {
width: 3,
height: 3,
cells,
},
result.create(),
)]
// Any potion's tipped arrow.
let potions = |item: ItemStack| -> Vec<ItemStack> {
crate::brewing::POTIONS
.iter()
.map(|p| item.clone().with_potion(&format!("minecraft:{}", p.id)))
.collect()
};
let all = potions(result.create());
// The source ingredient is shown as a lingering potion of each kind.
let lingering = source
.1
.iter()
.flat_map(|item| potions(ItemStack::new(item, 1)))
.collect();
vec![BookDisplay {
stacks: vec![(4, lingering)],
..shown(
Display::Shaped {
width: 3,
height: 3,
cells,
},
first_of(&all, result.create()),
all,
)
}]
}
_ => Vec::new(),
}
}
}
/// One recipe-book display of a special recipe.
pub struct BookDisplay {
pub display: crate::recipe_book::Display,
/// The result as the button shows it (the first of `variants`).
pub result: ItemStack,
/// Every stack the result display cycles through; empty for one stack.
pub variants: Vec<ItemStack>,
/// Ingredients shown as other stacks than their items, by index in
/// `Entry::requirements`.
pub stacks: Vec<(usize, Vec<ItemStack>)>,
}
/// `CraftingInput`: the occupied bounding box of the grid.
pub struct Input<'a> {
pub width: usize,
+23 -61
View File
@@ -10,7 +10,7 @@ use horizon_client::{
hud::{HudBatch, Rect, rgba},
items::ItemStack,
menu::place::{PostPlace, Stacked},
recipe_book::{Book, BookType, ClientBook, Collection, Display, Entry, Tab},
recipe_book::{Book, BookType, ClientBook, Collection, Entry, GhostTarget, Tab},
recipe_book_screen::{
self as screen, ButtonView, Call, Drawn, GhostView, ItemCall, OverlayRecipe, OverlayView,
Screen as Layout, Search, TabView,
@@ -423,7 +423,11 @@ impl Game<'_> {
}
if !query.is_empty()
&& !book.collection_matches(&c.entries, &query, &|stack| {
self.stack_tooltip(stack).into_iter().map(|l| l.0).collect()
horizon_client::item_tooltip::lines(
stack,
self.res.items.get(&stack.item),
&|k| self.res.names.get(k).map(str::to_owned),
)
})
{
continue;
@@ -712,68 +716,26 @@ impl Game<'_> {
/// `fillGhostRecipe`: the recipe's ingredients faded into the slots.
fn fill_ghost(&mut self, book_type: BookType, entry: &Entry) {
let grid = self.craft_size;
let fuel_empty = self.slot_mut(301).is_none();
let Some(book) = self.recipe_ui.book.as_ref() else {
return;
};
let stacks = |ingredient: &horizon_client::crafting::Ingredient| -> Vec<ItemStack> {
book.items_of(ingredient)
.iter()
.map(|i| ItemStack::new(i, 1))
.collect()
};
let mut ghost = Vec::new();
match book_type {
BookType::Crafting => {
let (gw, gh) = (self.craft_size, self.craft_size);
ghost.push(Ghost {
slot: 200,
items: vec![entry.result.clone()],
result: true,
});
let requirements = entry.requirements();
for (ingredient, grid_index) in entry.grid_cells(gw, gh) {
if let Some(i) = ingredient {
let items = stacks(requirements[i]);
if !items.is_empty() {
ghost.push(Ghost {
slot: 100 + grid_index,
items,
result: false,
});
}
}
}
}
_ => {
ghost.push(Ghost {
slot: 302,
items: vec![entry.result.clone()],
result: true,
});
if let Display::Furnace(ingredient) = &entry.display {
ghost.push(Ghost {
slot: 300,
items: stacks(ingredient),
result: false,
});
if self.slot_mut(301).is_none() {
let mut fuels: Vec<&std::sync::Arc<str>> = self
.res
.items
.order
.iter()
.filter(|i| self.res.items.get(i).is_some_and(|i| i.fuel.is_some()))
.collect();
fuels.dedup();
ghost.push(Ghost {
slot: 301,
items: fuels.iter().map(|i| ItemStack::new(i, 1)).collect(),
result: false,
});
}
}
}
}
let ghost = book
.ghost(entry, book_type, grid, fuel_empty, &self.res.items)
.into_iter()
.map(|g| Ghost {
slot: match (g.target, book_type) {
(GhostTarget::Result, BookType::Crafting) => 200,
(GhostTarget::Result, _) => 302,
(GhostTarget::Grid(i), _) => 100 + i,
(GhostTarget::Input, _) => 300,
(GhostTarget::Fuel, _) => 301,
},
result: g.target == GhostTarget::Result,
items: g.items,
})
.collect();
self.recipe_ui.ghost = ghost;
}
+121
View File
@@ -0,0 +1,121 @@
//! The creative mode toolbars of `hotbar.nbt` (`HotbarManager`,
//! `Hotbar`): nine saved rows of nine stacks, read through the `HOTBAR`
//! data fixers when the file is from an older version.
use crate::{items::ItemStack, save};
use horizon_world::nbt::{JavaString, Tag};
use std::path::Path;
/// `HotbarManager.NUM_HOTBAR_GROUPS`.
pub const GROUPS: usize = 9;
/// `Inventory.getSelectionSize`: the stacks of one saved row.
pub const SIZE: usize = 9;
/// One saved toolbar row.
pub type Hotbar = Vec<Option<ItemStack>>;
fn empty() -> Hotbar {
vec![None; SIZE]
}
/// `Hotbar.CODEC` and `Hotbar.load` on the row's tag: a row of fewer than nine
/// entries is lost, a longer one is cut (`Util.fixedSize` returns the first
/// nine as a partial result), an entry that is not a stack is empty.
fn row(tag: Option<&Tag>, known: &dyn Fn(&str) -> bool) -> Hotbar {
let Some(Tag::List(items)) = tag else {
return empty();
};
if items.len() < SIZE {
return empty();
}
items.iter().take(SIZE).map(|t| stack(t, known)).collect()
}
/// `ItemStack.OPTIONAL_CODEC` of a saved stack: the count is lenient (1
/// unless it is a number from 1 to 99), an item that is not registered is an
/// error.
fn stack(tag: &Tag, known: &dyn Fn(&str) -> bool) -> Option<ItemStack> {
let stack = save::item_from_nbt(tag)?;
if !known(&stack.item) {
return None;
}
let count = match tag.get("count") {
Some(Tag::Byte(n)) => i32::from(*n),
Some(Tag::Short(n)) => i32::from(*n),
Some(Tag::Int(n)) => *n,
_ => 1,
};
Some(ItemStack {
count: if (1..=99).contains(&count) {
count as u32
} else {
1
},
..stack
})
}
/// `HotbarManager.load` on the file's tag.
pub fn from_tag(mut tag: Tag, known: &dyn Fn(&str) -> bool) -> Vec<Hotbar> {
let version = match tag.get("DataVersion") {
Some(Tag::Int(v)) => *v,
_ => 1343,
};
// Until the last fixer that rewrites item stacks (`UnfilledBuriedTreasureMapFix`,
// 5016) the fixers read each row as a list of stacks: an entry that is
// none is dropped from its row (a bare item id is a stack from 3818.5 on)
// and a row that is no list ends the reading. After that fixer nothing
// reads the rows and bare ids are no stacks.
const LAST_STACK_FIXER: i32 = 5016;
if version < horizon_world::DATA_VERSION
&& let Tag::Compound(rows) = &mut tag
{
if version < LAST_STACK_FIXER {
// A row that is no list stops the traversal there: it and the
// rows after it (in key order) are lost.
let broken = (0..GROUPS).find(|i| {
rows.get(&JavaString::from(i.to_string().as_str()))
.is_some_and(|r| {
!matches!(
r,
Tag::List(_) | Tag::ByteArray(_) | Tag::IntArray(_) | Tag::LongArray(_)
)
})
});
if let Some(broken) = broken {
for i in broken..GROUPS {
rows.remove(&JavaString::from(i.to_string().as_str()));
}
}
// Entries that are no stacks are dropped from their row.
for row in rows.values_mut() {
if let Tag::List(items) = row {
items.retain(|i| {
matches!(i, Tag::Compound(_))
|| (version > 3818 && matches!(i, Tag::String(_)))
});
}
}
} else {
for row in rows.values_mut() {
if let Tag::List(items) = row {
for item in items.iter_mut().filter(|i| matches!(i, Tag::String(_))) {
*item = Tag::Compound(Default::default());
}
}
}
}
}
horizon_world::datafix::update_hotbar(&mut tag);
(0..GROUPS)
.map(|i| row(tag.get(&i.to_string()), known))
.collect()
}
/// `HotbarManager.load` of the `hotbar.nbt` at `path`: every row empty when
/// the file is missing or unreadable.
pub fn load(path: &Path, known: &dyn Fn(&str) -> bool) -> Vec<Hotbar> {
match save::read_dat(path) {
Some(tag @ Tag::Compound(_)) => from_tag(tag, known),
_ => (0..GROUPS).map(|_| empty()).collect(),
}
}
+297
View File
@@ -0,0 +1,297 @@
//! The lines of an item's tooltip as `ItemStack.getTooltipLines` writes them
//! without a player and without advanced tooltips, for stacks as recipes
//! produce them. The recipe book's search tree matches them, so recipes of
//! tools and armour answer to "attack speed" or "when on head".
use crate::items::{ItemInfo, ItemStack};
/// `EquipmentSlotGroup` in declaration order, the order tooltips list them in.
const SLOT_GROUPS: [&str; 11] = [
"any", "mainhand", "offhand", "hand", "feet", "legs", "chest", "head", "armor", "body",
"saddle",
];
/// `ItemAttributeModifiers.ATTRIBUTE_MODIFIER_FORMAT`, `DecimalFormat("#.##")`
/// of a positive amount (half-even on the exact value).
fn format_amount(value: f64) -> String {
let text = format!("{:.2}", value);
text.trim_end_matches('0').trim_end_matches('.').to_owned()
}
/// `ItemAttributeModifiers.Display.Default.apply`: a modifier's line, none
/// for a zero amount. `percent` is the modifier's operation id (0: added
/// value, 1 and 2: multiplied).
fn modifier_line(
translate: &dyn Fn(&str) -> Option<String>,
attribute: &str,
amount: f64,
operation: usize,
) -> Option<String> {
let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
let scale = match operation {
0 if attribute == "knockback_resistance" => 10.0,
0 => 1.0,
_ => 100.0,
};
let (kind, shown) = if amount > 0.0 {
("plus", amount * scale)
} else if amount < 0.0 {
("take", -amount * scale)
} else {
return None;
};
Some(
text(&format!("attribute.modifier.{kind}.{operation}"))
.replacen("%s", &format_amount(shown), 1)
.replacen("%s", &text(&format!("attribute.name.{attribute}")), 1)
.replace("%%", "%"),
)
}
/// `ItemStack.addAttributeTooltips` for the item's own modifiers: per slot
/// group an empty line, the group's heading and a line per modifier.
fn attribute_lines(info: &ItemInfo, translate: &dyn Fn(&str) -> Option<String>) -> Vec<String> {
let mut lines = Vec::new();
for group in SLOT_GROUPS {
let mut first = true;
for (attribute, _, amount, operation, slot) in &info.modifiers {
if slot != group {
continue;
}
if std::mem::take(&mut first) {
lines.push(String::new());
lines.push(
translate(&format!("item.modifiers.{group}"))
.unwrap_or_else(|| format!("item.modifiers.{group}")),
);
}
let id = match operation.as_str() {
"add_multiplied_base" => 1,
"add_multiplied_total" => 2,
_ => 0,
};
let path = attribute.strip_prefix("minecraft:").unwrap_or(attribute);
lines.extend(modifier_line(translate, path, *amount, id));
}
}
lines
}
/// The attribute modifiers a mob effect adds per amplifier level
/// (`MobEffects`): attribute, amount, operation id.
fn effect_modifier(effect: &str) -> Option<(&'static str, f64, usize)> {
Some(match effect {
"speed" => ("movement_speed", 0.2, 2),
"slowness" => ("movement_speed", -0.15, 2),
"strength" => ("attack_damage", 3.0, 0),
"weakness" => ("attack_damage", -4.0, 0),
"jump_boost" => ("safe_fall_distance", 1.0, 0),
"luck" => ("luck", 1.0, 0),
"invisibility" => ("waypoint_transmit_range", -1.0, 2),
_ => return None,
})
}
fn is_potion_item(item: &str) -> bool {
item.ends_with("potion") || item == "minecraft:tipped_arrow"
}
/// The name line of `stack`, as the item's translation or, for potions and
/// smithing templates, its name component gives it.
pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option<String>) -> String {
let path = stack.item.trim_start_matches("minecraft:");
if let Some(name) = stack.custom_name() {
return name.to_owned();
}
let key = if is_potion_item(&stack.item) {
Some(crate::brewing::potion_name_key(&stack.item, stack.potion()))
} else if let Some(pattern) = path.strip_suffix("_armor_trim_smithing_template") {
Some(format!("trim_pattern.minecraft.{pattern}"))
} else if path == "netherite_upgrade_smithing_template" {
Some("upgrade.minecraft.netherite_upgrade".to_owned())
} else if path.ends_with("_banner_pattern") {
// The item name component of the pattern items that have one.
Some(format!("item.minecraft.{path}.new"))
} else {
None
};
key.and_then(|k| translate(&k))
.or_else(|| translate(&format!("item.minecraft.{path}")))
.or_else(|| translate(&format!("block.minecraft.{path}")))
.unwrap_or_else(|| path.replace('_', " "))
}
/// The lines of `stack` below its name that its components give, in
/// `ItemStack.addDetailsToTooltip` order.
pub fn detail_lines(
stack: &ItemStack,
info: Option<&ItemInfo>,
translate: &dyn Fn(&str) -> Option<String>,
) -> Vec<String> {
let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
let path = stack.item.trim_start_matches("minecraft:");
let mut lines = Vec::new();
// SmithingTemplateItem.appendHoverText.
if path.ends_with("_smithing_template") {
let kind = if path == "netherite_upgrade_smithing_template" {
"netherite_upgrade"
} else {
"armor_trim"
};
lines.push(text("item.minecraft.smithing_template"));
lines.push(String::new());
lines.push(text("item.minecraft.smithing_template.applies_to"));
lines.push(format!(
" {}",
text(&format!(
"item.minecraft.smithing_template.{kind}.applies_to"
))
));
lines.push(text("item.minecraft.smithing_template.ingredients"));
lines.push(format!(
" {}",
text(&format!(
"item.minecraft.smithing_template.{kind}.ingredients"
))
));
}
// BeehiveBlock: the block state components of the item.
if path == "beehive" {
lines.push(
text("container.beehive.bees")
.replacen("%s", "0", 1)
.replacen("%s", "3", 1),
);
lines.push(
text("container.beehive.honey")
.replacen("%s", "0", 1)
.replacen("%s", "5", 1),
);
}
let data = stack.data();
// FireworkRocketItem: the flight duration (an unset component is 1).
if path == "firework_rocket" {
let flight = data.and_then(|d| d.fireworks.as_ref()).map_or(1, |f| f.0);
lines.push(format!(
"{} {flight}",
text("item.minecraft.firework_rocket.flight")
));
}
// PotDecorations.addToTooltip.
if let Some(sherds) = data
.and_then(|d| d.pot_decorations.as_ref())
.filter(|s| s.iter().any(Option::is_some))
{
lines.push(String::new());
for sherd in sherds.iter() {
let item = sherd.as_ref().map_or("minecraft:brick", |s| &*s.item);
lines.push(name_line(&ItemStack::new(item, 1), translate));
}
}
// PotionContents.addToTooltip: the effects, then their attribute modifiers.
if is_potion_item(&stack.item) {
let scale = match path {
"lingering_potion" => 0.25,
"tipped_arrow" => 0.125,
_ => 1.0,
};
lines.extend(
crate::brewing::tooltip(stack.potion(), scale, translate)
.into_iter()
.map(|l| l.0),
);
let applied: Vec<String> = stack
.potion()
.and_then(crate::brewing::potion)
.into_iter()
.flat_map(|p| p.effects.iter())
.filter_map(|(effect, _, amplifier)| {
let (attribute, amount, operation) = effect_modifier(effect)?;
modifier_line(
translate,
attribute,
amount * (*amplifier + 1) as f64,
operation,
)
})
.collect();
if !applied.is_empty() {
lines.push(String::new());
lines.push(text("potion.whenDrank"));
lines.extend(applied);
}
}
// JukeboxPlayable.addToTooltip: the song's description.
if path.starts_with("music_disc_") {
lines.push(text(&format!("item.minecraft.{path}.desc")));
}
// Trim.addToTooltip.
if let Some((material, pattern)) = data.and_then(|d| d.trim.as_ref()) {
let short = |s: &str| s.trim_start_matches("minecraft:").to_owned();
lines.push(text("item.minecraft.smithing_template.upgrade"));
lines.push(format!(
" {}",
text(&format!("trim_pattern.minecraft.{}", short(pattern)))
));
lines.push(format!(
" {}",
text(&format!("trim_material.minecraft.{}", short(material)))
));
}
// DyedItemColor.addToTooltip (without advanced tooltips).
if data.is_some_and(|d| d.dyed_color.is_some()) {
lines.push(text("item.dyed"));
}
if let Some(info) = info {
lines.extend(attribute_lines(info, translate));
}
lines
}
/// Every line of `stack`'s tooltip, name first.
pub fn lines(
stack: &ItemStack,
info: Option<&ItemInfo>,
translate: &dyn Fn(&str) -> Option<String>,
) -> Vec<String> {
let mut lines = vec![name_line(stack, translate)];
lines.extend(detail_lines(stack, info, translate));
lines
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn amounts_use_two_decimals_at_most() {
assert_eq!(format_amount(8.0), "8");
assert_eq!(format_amount(3.2000000953674316), "3.2");
assert_eq!(format_amount(2.8200000524520874), "2.82");
assert_eq!(format_amount(0.125), "0.12");
assert_eq!(format_amount(0.375), "0.38");
}
#[test]
fn modifier_lines_follow_the_sign_and_operation() {
let lang = |k: &str| {
Some(
match k {
"attribute.modifier.plus.2" => "+%s%% %s",
"attribute.modifier.take.2" => "-%s%% %s",
"attribute.name.movement_speed" => "Speed",
_ => return None,
}
.to_owned(),
)
};
assert_eq!(
modifier_line(&lang, "movement_speed", 0.2, 2).as_deref(),
Some("+20% Speed")
);
assert_eq!(
modifier_line(&lang, "movement_speed", -0.6, 2).as_deref(),
Some("-60% Speed")
);
assert_eq!(modifier_line(&lang, "movement_speed", 0.0, 2), None);
}
}
+25
View File
@@ -158,11 +158,32 @@ pub struct ItemStack {
/// Components beyond count and damage (see `item_data`); None when default.
pub extra: Option<Box<crate::item_data::StackData>>,
}
/// `order`'s items in the registry's order (`command-registries.json`'s
/// `items`, exported from the game); `order` itself when that is missing.
fn registry_order(root: &Path, order: &[Arc<str>]) -> Vec<Arc<str>> {
let listed: Vec<String> = fs::read(root.join("command-registries.json"))
.ok()
.and_then(|b| serde_json::from_slice::<Value>(&b).ok())
.and_then(|v| serde_json::from_value(v["items"].clone()).ok())
.unwrap_or_default();
if listed.is_empty() {
return order.to_vec();
}
let known: HashSet<&str> = order.iter().map(|i| &**i).collect();
listed
.iter()
.filter(|i| known.contains(i.as_str()))
.map(|i| Arc::from(i.as_str()))
.collect()
}
/// Item ids standing for a loot table's `minecraft:dynamic` entries.
const DYNAMIC: &str = "#dynamic:";
pub struct Items {
pub items: HashMap<Arc<str>, ItemInfo>,
pub order: Vec<Arc<str>>,
/// The same items in item registry (network id) order, as vanilla lists
/// them; sorted by name when the registry export is missing.
pub registry_order: Vec<Arc<str>>,
/// Block tag name (without '#') -> member block names.
pub block_tags: HashMap<String, HashSet<String>>,
pub item_tags: HashMap<String, HashSet<String>>,
@@ -456,9 +477,11 @@ impl Items {
}
let loot_root = root.join("data/minecraft/loot_table");
walk_loot(&loot_root, &loot_root, &mut loot)?;
let registry_order = registry_order(root, &order);
Ok(Self {
items,
order,
registry_order,
block_tags: load_tags(root, "block")?,
item_tags: load_tags(root, "item")?,
item_tag_order: load_tag_lists(root, "item")?,
@@ -474,6 +497,7 @@ impl Items {
Ok(Self {
items: HashMap::new(),
order: Vec::new(),
registry_order: Vec::new(),
block_tags: load_tags(root, "block")?,
item_tags: load_tags(root, "item")?,
item_tag_order: load_tag_lists(root, "item")?,
@@ -487,6 +511,7 @@ impl Items {
Self {
items: HashMap::new(),
order: Vec::new(),
registry_order: Vec::new(),
block_tags: HashMap::new(),
item_tag_order: item_tags
.iter()
+2
View File
@@ -48,6 +48,7 @@ pub mod gamerules;
pub mod gfx;
pub mod gossip;
pub mod health;
pub mod hotbar;
pub mod hud;
pub mod hud_layout;
pub mod hud_overlays;
@@ -55,6 +56,7 @@ pub mod hunger;
pub mod input;
pub mod item_data;
pub mod item_render;
pub mod item_tooltip;
pub mod items;
pub mod java_text;
pub mod key_names;
+128 -4
View File
@@ -157,8 +157,23 @@ pub struct Entry {
pub group: Option<String>,
pub display: Display,
pub result: ItemStack,
/// Every stack its display can show as the result when that is more than
/// `result` (a map copy of any map, an arrow of any potion): the search
/// tree reads them all, the button shows the first.
pub variants: Vec<ItemStack>,
/// Ingredients shown as other stacks than their items (by index in
/// `requirements`): the potions an imbued arrow's lingering potion is.
pub stacks: Vec<(usize, Vec<ItemStack>)>,
}
impl Entry {
/// Every stack the result display cycles through.
pub fn results(&self) -> &[ItemStack] {
if self.variants.is_empty() {
std::slice::from_ref(&self.result)
} else {
&self.variants
}
}
/// The ingredients that must be matched to craft it, in order.
pub fn requirements(&self) -> Vec<&Ingredient> {
match &self.display {
@@ -306,14 +321,16 @@ impl Book {
// Custom recipes are never learnable; the others show one
// display per material count (TransmuteRecipe.display).
Recipe::Special(special) => {
for (display, result) in special.book_displays() {
for shown in special.book_displays() {
entries.push(Entry {
id: format!("minecraft:{name}"),
display_id: -1,
category: crafting_category(&category),
group: group(&grp),
display,
result,
display: shown.display,
result: shown.result,
variants: shown.variants,
stacks: shown.stacks,
});
}
continue;
@@ -326,6 +343,8 @@ impl Book {
group: group(&grp),
display,
result: result.create(),
variants: Vec::new(),
stacks: Vec::new(),
});
}
for c in &recipes.cooking {
@@ -345,6 +364,8 @@ impl Book {
group: group(&c.group),
display: Display::Furnace(c.ingredient.clone()),
result: c.result.clone(),
variants: Vec::new(),
stacks: Vec::new(),
});
}
let order = items
@@ -410,6 +431,85 @@ impl Book {
pub fn items_of(&self, ingredient: &Ingredient) -> Vec<String> {
ingredient.1.clone()
}
/// `RecipeBookComponent.fillGhostRecipe` of a book type: the result and the
/// ingredients faded into the menu's slots, in the order the component
/// sets them. `grid` is the side of the crafting grid, `fuel_empty`
/// whether the furnace's fuel slot is empty.
pub fn ghost(
&self,
entry: &Entry,
book_type: BookType,
grid: usize,
fuel_empty: bool,
items: &crate::items::Items,
) -> Vec<GhostSlot> {
let stacks = |ingredient: &Ingredient| -> Vec<ItemStack> {
self.items_of(ingredient)
.iter()
.map(|i| ItemStack::new(i, 1))
.collect()
};
let mut out = Vec::new();
match book_type {
BookType::Crafting => {
out.push(GhostSlot {
target: GhostTarget::Result,
items: entry.results().to_vec(),
});
let requirements = entry.requirements();
for (ingredient, index) in entry.grid_cells(grid, grid) {
let Some(i) = ingredient else { continue };
let list = match entry.stacks.iter().find(|s| s.0 == i) {
Some(shown) => shown.1.clone(),
None => stacks(requirements[i]),
};
if !list.is_empty() {
out.push(GhostSlot {
target: GhostTarget::Grid(index),
items: list,
});
}
}
}
_ => {
out.push(GhostSlot {
target: GhostTarget::Result,
items: entry.results().to_vec(),
});
if let Display::Furnace(ingredient) = &entry.display {
out.push(GhostSlot {
target: GhostTarget::Input,
items: stacks(ingredient),
});
if fuel_empty {
// `SlotDisplay.AnyFuel`: every item with a cooking fuel
// component, the registry's component lookup listing the
// items of one component value together, the values in
// the order of their first item.
let mut groups: Vec<(String, Vec<ItemStack>)> = Vec::new();
for item in &items.registry_order {
let Some(fuel) = items.get(item).and_then(|i| i.fuel.as_ref()) else {
continue;
};
let key = format!("{fuel:?}");
match groups.iter_mut().find(|g| g.0 == key) {
Some(group) => group.1.push(ItemStack::new(item, 1)),
None => groups.push((key, vec![ItemStack::new(item, 1)])),
}
}
let fuels = groups.into_iter().flat_map(|g| g.1).collect();
out.push(GhostSlot {
target: GhostTarget::Fuel,
items: fuels,
});
}
}
}
}
// `GhostSlots.setSlot` keeps only slots with something to show.
out.retain(|g| !g.items.is_empty());
out
}
/// The recipe-book search tree (`SessionSearchTrees.updateRecipes`, a
/// `FullTextSearchTree`): without a colon the text must occur in a
/// tooltip line of a result item of the collection; `namespace:path`
@@ -421,7 +521,10 @@ impl Book {
tooltip: &dyn Fn(&ItemStack) -> Vec<String>,
) -> bool {
let query = query.to_lowercase();
let results: Vec<&ItemStack> = entries.iter().map(|&i| &self.entries[i].result).collect();
let results: Vec<&ItemStack> = entries
.iter()
.flat_map(|&i| self.entries[i].results())
.collect();
let in_lines = |text: &str| {
results
.iter()
@@ -440,6 +543,23 @@ impl Book {
}
}
/// Where a ghost recipe's stacks are drawn.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GhostTarget {
Result,
/// A crafting grid slot, row by row.
Grid(usize),
/// A furnace's input and fuel slots.
Input,
Fuel,
}
/// One slot of a ghost recipe and the stacks it cycles through.
#[derive(Clone, Debug)]
pub struct GhostSlot {
pub target: GhostTarget,
pub items: Vec<ItemStack>,
}
/// A `RecipeDisplayId` as a `HashMap` key: a record of one int hashes as it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct DisplayKey(i32);
@@ -747,6 +867,8 @@ mod tests {
group: group.map(str::to_owned),
display: Display::Shapeless(vec![ing(&["minecraft:stick"])]),
result: ItemStack::new("minecraft:stick", 1),
variants: Vec::new(),
stacks: Vec::new(),
};
let book = Book {
entries: vec![
@@ -793,6 +915,8 @@ mod tests {
group: None,
display: Display::Shapeless(Vec::new()),
result: ItemStack::new("minecraft:stick", 4),
variants: Vec::new(),
stacks: Vec::new(),
}],
placements: HashMap::new(),
order: HashMap::new(),
@@ -56,6 +56,7 @@ pub(super) fn register(out: &mut Vec<(Key, FixFn)>) {
})
}));
out.push((key(3818, 0), beehive_fields));
out.push((key(3818, 0), empty_item_in_hotbar));
out.push((key(3818, 1), banner_patterns));
out.push((key(3818, 2), tipped_arrow_potion));
out.push((key(3818, 4), particle_unflattening));
@@ -714,6 +715,21 @@ fn beehive_fields(cx: &mut Cx) {
});
}
/// `EmptyItemInHotbarFix`: a saved toolbar's air or zero-count stacks become
/// the empty compound.
fn empty_item_in_hotbar(cx: &mut Cx) {
if !matches!(cx.root, Ty::Hotbar) {
return;
}
cx.each(Ty::ItemStack, |stack| {
let air = as_str(stack.get("id")).is_none_or(|id| id == "minecraft:air");
let empty = as_int(stack.get("Count"), 0) <= 0;
if air || empty {
*stack = empty_map();
}
});
}
const PATTERN_IDS: [(&str, &str); 41] = [
("b", "minecraft:base"),
("bl", "minecraft:square_bottom_left"),
+7
View File
@@ -334,6 +334,13 @@ pub fn update_player_to(tag: &mut Tag, to: i32) {
dynamic::set(tag, "DataVersion", Tag::Int(to));
}
/// `HotbarManager.load`: a creative toolbar file (`hotbar.nbt`, its DataVersion
/// 1343 when missing) brought to the current version.
pub fn update_hotbar(tag: &mut Tag) {
let version = dynamic::as_int(tag.get("DataVersion"), 1343);
update(Ty::Hotbar, tag, version, CURRENT);
}
/// The saved data type of a file below a `data` folder (`namespace/path.dat`).
pub fn saved_data_type(relative: &str) -> Option<Ty> {
let name = relative.strip_suffix(".dat").unwrap_or(relative);
+23 -3
View File
@@ -1426,14 +1426,34 @@ vanilla's own classes, and the game uses that code:
paints them. `tools/test_recipe_book_render_parity.py` builds vanilla's
widgets for 600 states (`VanillaRecipeBookScreenOracle`) and compares every
call. Ingredients cycle in their `HolderSet` order (tags in `TagLoader` order).
- **The book's text search.** `recipe_book_view` also searches: the oracle
builds `SessionSearchTrees`' `FullTextSearchTree` over the tooltip lines and
ids of every result a display can show, and `item_tooltip` writes those
lines (attribute modifiers, smithing template, potion, dyed, pot, rocket and
disc lines; the names of potions, templates and banner patterns). Displays
with several results (map copies, tipped arrows, dyed armour) keep them in
`Entry::variants`.
- **The ghost recipe.** `Book::ghost` is the one place that fills a recipe's
ingredients into the grid or furnace slots (`PlaceRecipeHelper`'s centring,
the first slots for shapeless recipes, every fuel for an empty fuel slot, in
the registry's component-lookup order); `tools/test_ghost_recipe_parity.py`
runs `fillGhostRecipe` against the real menus for all 2,698 recipe and menu
pairs.
- **The loom's banner preview.** `item_render::gui::draw_banner_result` draws
`GuiBannerResultRenderer`'s flag model and layers in the 20x40 picture in
picture, lit with `ITEMS_FLAT`; the block entity render harness compares its
quads under the picture-in-picture pose.
Not compared yet: the recipe book's text search, furnaces awarding their
recipes and experience when their output is taken, and the limited crafting
game rule.
Not compared yet: furnaces awarding their recipes and experience when their
output is taken, and the limited crafting game rule. Tooltips in general lack
the lines `item_tooltip` writes for recipe results (the game's hover tooltips
do not show attribute modifiers yet).
`horizon_client::hotbar` reads the creative toolbars of an older `hotbar.nbt`
through the `HOTBAR` data fixers (`EmptyItemInHotbarFix`, every item stack
fixer): `tools/test_hotbar_parity.py` loads generated files of 34 versions with
the real `HotbarManager`. The toolbar screen (save and load keys) is not wired
to it yet.
## Player list and world border rendering
@@ -0,0 +1,130 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.client.gui.screens.recipebook.CraftingRecipeBookComponent;
import net.minecraft.client.gui.screens.recipebook.FurnaceRecipeBookComponent;
import net.minecraft.client.gui.screens.recipebook.GhostSlots;
import net.minecraft.client.gui.screens.recipebook.RecipeBookComponent;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.Identifier;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.util.context.ContextMap;
import net.minecraft.world.entity.EntityEquipment;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.flag.FeatureFlags;
import net.minecraft.world.inventory.*;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.crafting.RecipeManager;
import net.minecraft.world.item.crafting.display.FurnaceRecipeDisplay;
import net.minecraft.world.item.crafting.display.RecipeDisplay;
import net.minecraft.world.item.crafting.display.RecipeDisplayEntry;
import net.minecraft.world.item.crafting.display.ShapedCraftingRecipeDisplay;
import net.minecraft.world.item.crafting.display.ShapelessCraftingRecipeDisplay;
import net.minecraft.world.item.crafting.display.SlotDisplayContext;
/**
* Original oracle for the ghost recipe the recipe book fades into the menu
* when a recipe is clicked: for every display of a recipe, the client's
* CraftingRecipeBookComponent / FurnaceRecipeBookComponent.fillGhostRecipe
* runs against the real inventory, crafting table or furnace menu (the
* component is allocated without its constructor and given the menu) and
* fills a GhostSlots. Printed per display, in the order the component set
* them: the menu slot, whether it is the result, and the stacks the slot
* cycles through (PlaceRecipeHelper's grid placement for shaped recipes, the
* first slots for shapeless ones, the ingredient, the result and every fuel
* for a furnace whose fuel slot is empty).
*/
public final class VanillaGhostRecipeOracle {
@SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
ParityData.init();
var field = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");
field.setAccessible(true);
VanillaMenuOracle.unsafe = field.get(null);
VanillaMenuOracle.allocate = VanillaMenuOracle.unsafe.getClass().getMethod("allocateInstance", Class.class);
RecipeManager recipes = new RecipeManager(ParityData.lookup);
recipes.finalizeRecipeLoading(FeatureFlags.VANILLA_SET);
VanillaMenuOracle.recipes = recipes;
ContextMap context = ContextMap.builder().set(SlotDisplayContext.REGISTRIES, ParityData.access).buildAndValidate(SlotDisplayContext.CONTEXT);
Field ghostField = GhostSlots.class.getDeclaredField("ingredients");
ghostField.setAccessible(true);
Field menuField = RecipeBookComponent.class.getDeclaredField("menu");
menuField.setAccessible(true);
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8));
var lines = Files.lines(Path.of(args[0]))) {
for (String line : (Iterable<String>) lines::iterator) {
var f = JsonParser.parseString(line).getAsJsonObject();
try {
var world = VanillaMenuOracle.make(VanillaMenuOracle.World.class);
world.server = VanillaMenuOracle.make(VanillaMenuOracle.Server.class);
var player = VanillaMenuOracle.make(VanillaMenuOracle.FakePlayer.class);
player.world = world;
var inv = new Inventory(player, new EntityEquipment());
player.inv = inv;
String kind = f.get("menu").getAsString();
AbstractContainerMenu menu = VanillaMenuOracle.menu(kind, player, inv);
VanillaMenuOracle.set(player, Player.class, "containerMenu", menu);
if (f.has("fuel") && !f.get("fuel").isJsonNull()) {
menu.getSlot(1).set(ParityData.stack(f.get("fuel").getAsString()));
}
RecipeBookComponent<?> component = kind.equals("inventory") || kind.equals("crafting")
? VanillaMenuOracle.make(CraftingRecipeBookComponent.class)
: VanillaMenuOracle.make(FurnaceRecipeBookComponent.class);
menuField.set(component, menu);
Method fill = (component instanceof CraftingRecipeBookComponent ? CraftingRecipeBookComponent.class : FurnaceRecipeBookComponent.class)
.getDeclaredMethod("fillGhostRecipe", GhostSlots.class, RecipeDisplay.class, ContextMap.class);
fill.setAccessible(true);
int grid = kind.equals("inventory") ? 2 : 3;
List<RecipeDisplayEntry> displays = new ArrayList<>();
recipes.listDisplaysForRecipe(ResourceKey.create(Registries.RECIPE, Identifier.parse(f.get("recipe").getAsString())), displays::add);
StringBuilder result = new StringBuilder();
for (RecipeDisplayEntry entry : displays) {
RecipeDisplay display = entry.display();
// CraftingRecipeBookComponent.canDisplay: only what fits the grid is listed.
boolean fits = switch (display) {
case ShapedCraftingRecipeDisplay shaped -> grid >= shaped.width() && grid >= shaped.height();
case ShapelessCraftingRecipeDisplay shapeless -> grid * grid >= shapeless.ingredients().size();
case FurnaceRecipeDisplay furnace -> !kind.equals("inventory") && !kind.equals("crafting");
default -> false;
};
if (kind.equals("inventory") || kind.equals("crafting") ? display instanceof FurnaceRecipeDisplay : !(display instanceof FurnaceRecipeDisplay)) fits = false;
if (!fits) {
result.append("skip | ");
continue;
}
GhostSlots ghost = new GhostSlots(() -> 0);
fill.invoke(component, ghost, display, context);
var map = (Map<Slot, Object>) ghostField.get(ghost);
for (var e : map.entrySet()) {
Object slot = e.getValue();
Method items = slot.getClass().getDeclaredMethod("items");
Method isResult = slot.getClass().getDeclaredMethod("isResultSlot");
items.setAccessible(true);
isResult.setAccessible(true);
result.append(menu.slots.indexOf(e.getKey())).append((boolean) isResult.invoke(slot) ? "R" : "I").append('=');
boolean first = true;
for (ItemStack stack : (List<ItemStack>) items.invoke(slot)) {
result.append(first ? "" : ",").append(ParityData.canon(stack));
first = false;
}
result.append(' ');
}
result.append("| ");
}
out.println(result);
} catch (Throwable e) {
out.println("error-case " + e.getClass().getSimpleName() + " " + e.getMessage());
if (System.getenv("MENU_TRACE") != null) e.printStackTrace();
}
}
}
}
}
@@ -0,0 +1,50 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.client.HotbarManager;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.NbtIo;
import net.minecraft.nbt.TagParser;
import net.minecraft.util.datafix.DataFixers;
import net.minecraft.world.item.ItemStack;
/**
* Original oracle for creative toolbars read from a hotbar.nbt of any version:
* each case's SNBT is written as the file and the real HotbarManager (with the
* game's DataFixer, so DataFixTypes.HOTBAR and its item stack fixers) loads it;
* each of the nine rows is then loaded with Hotbar.load and printed.
*/
public final class VanillaHotbarOracle {
public static void main(String[] args) throws Exception {
ParityData.init();
Path dir = Files.createTempDirectory("hotbar");
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8));
var lines = Files.lines(Path.of(args[0]))) {
for (String line : (Iterable<String>) lines::iterator) {
var f = JsonParser.parseString(line).getAsJsonObject();
try {
Files.deleteIfExists(dir.resolve("hotbar.nbt"));
if (!f.get("snbt").isJsonNull()) {
CompoundTag tag = TagParser.parseCompoundFully(f.get("snbt").getAsString());
NbtIo.write(tag, dir.resolve("hotbar.nbt"));
}
HotbarManager manager = new HotbarManager(dir, DataFixers.getDataFixer());
StringBuilder result = new StringBuilder();
for (int i = 0; i < HotbarManager.NUM_HOTBAR_GROUPS; i++) {
result.append(i).append(':');
for (ItemStack stack : manager.get(i).load(ParityData.lookup)) result.append(' ').append(ParityData.canon(stack));
result.append(" | ");
}
out.println(result);
} catch (Throwable e) {
out.println("error-case " + e.getClass().getSimpleName() + " " + e.getMessage());
if (System.getenv("MENU_TRACE") != null) e.printStackTrace();
}
}
}
}
}
@@ -6,7 +6,16 @@ import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Stream;
import net.minecraft.ChatFormatting;
import net.minecraft.client.ClientRecipeBook;
import net.minecraft.client.searchtree.FullTextSearchTree;
import net.minecraft.client.searchtree.SearchTree;
import net.minecraft.core.Registry;
import net.minecraft.util.context.ContextMap;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.TooltipFlag;
import net.minecraft.world.item.crafting.display.SlotDisplayContext;
import net.minecraft.client.gui.screens.recipebook.RecipeCollection;
import net.minecraft.client.gui.screens.recipebook.SearchRecipeBookCategory;
import net.minecraft.core.registries.Registries;
@@ -34,7 +43,10 @@ import net.minecraft.world.item.crafting.display.ShapelessCraftingRecipeDisplay;
* every tab of the book RecipeBookTabButton.updateVisibility and
* RecipeBookComponent.updateCollections (without a search) decide the
* buttons. Printed per tab: visibility, the page count, and each button's
* displays with their selected and craftable flags.
* displays with their selected and craftable flags. A case may carry a search
* text: the collections are searched as SessionSearchTrees.updateRecipes builds
* the tree (a FullTextSearchTree over the tooltip lines and ids of the results)
* and RecipeBookComponent.updateCollections applies it.
*/
public final class VanillaRecipeBookViewOracle {
record Tab(ExtendedRecipeBookCategory category, String name) {}
@@ -109,12 +121,38 @@ public final class VanillaRecipeBookViewOracle {
for (RecipeCollection c : book.getCollection(tab.category())) c.selectRecipes(contents, canDisplay);
}
boolean filtering = f.get("filtering").getAsBoolean();
String query = f.has("search") ? f.get("search").getAsString() : "";
Set<RecipeCollection> found = null;
if (!query.isEmpty()) {
// SessionSearchTrees.updateRecipes.
List<RecipeCollection> all = book.getCollections();
Registry<Item> itemRegistry = ParityData.access.lookupOrThrow(net.minecraft.core.registries.Registries.ITEM);
Item.TooltipContext tooltipContext = Item.TooltipContext.of(ParityData.access);
ContextMap recipeContext = SlotDisplayContext.fromLevel(ParityData.level);
SearchTree<RecipeCollection> tree = new FullTextSearchTree<>(
collection -> collection.getRecipes().stream().flatMap(e -> e.resultItems(recipeContext).stream())
.flatMap(item -> item.getTooltipLines(tooltipContext, null, TooltipFlag.Default.NORMAL).stream())
.map(l -> ChatFormatting.stripFormatting(l.getString()).trim()).filter(x -> !x.isEmpty()),
collection -> collection.getRecipes().stream().flatMap(e -> e.resultItems(recipeContext).stream())
.map(stack -> itemRegistry.getKey(stack.getItem())),
all);
if (System.getenv("DUMP_TOOLTIPS") != null) {
for (RecipeCollection c : all) for (var e : c.getRecipes()) for (var stack : e.resultItems(recipeContext)) {
System.err.println("TT " + e.id().index() + " " + itemRegistry.getKey(stack.getItem()) + " " + stack.getTooltipLines(tooltipContext, null, TooltipFlag.Default.NORMAL).stream().map(l -> l.getString()).toList());
}
}
found = new java.util.LinkedHashSet<>(tree.search(query.toLowerCase(Locale.ROOT)));
}
StringBuilder result = new StringBuilder();
for (Tab tab : tabs) {
List<RecipeCollection> collections = new ArrayList<>(book.getCollection(tab.category()));
boolean visible = tab.category() instanceof SearchRecipeBookCategory || collections.stream().anyMatch(RecipeCollection::hasAnySelected);
result.append(tab.name()).append(visible ? " shown" : " hidden");
collections.removeIf(c -> !c.hasAnySelected());
if (found != null) {
Set<RecipeCollection> set = found;
collections.removeIf(c -> !set.contains(c));
}
if (filtering) collections.removeIf(c -> !c.hasCraftable());
result.append(" pages=").append((int) Math.ceil(collections.size() / 20.0));
for (RecipeCollection c : collections) {
+77
View File
@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""Compare the ghost recipe of a recipe book click with the vanilla client's.
Each case opens the inventory (2x2), a crafting table (3x3), a furnace, a
blast furnace or a smoker and clicks a recipe of its book (every crafting and
cooking recipe, the furnaces with their fuel slot empty or holding coal). The
Java oracle (VanillaGhostRecipeOracle) runs vanilla's
CraftingRecipeBookComponent / FurnaceRecipeBookComponent.fillGhostRecipe
against the real menu for every display of the recipe and prints the GhostSlots
it fills: the menu slot, whether it is the result and the stacks the slot
cycles through (PlaceRecipeHelper's centred placement of shaped recipes, the
first slots for shapeless ones, every fuel for an empty fuel slot);
examples/ghost_recipe_fixture prints the same from
horizon_client::recipe_book::Book::ghost, which the game fills its ghost
slots from. The lines must agree.
"""
import argparse
import json
import os
import random
import subprocess
import sys
try:
from . import interaction_lab as lib, test_model_baking_parity as baking, test_rust_parity as base
except ImportError:
import interaction_lab as lib
import test_model_baking_parity as baking
import test_rust_parity as base
CRAFTING = ('minecraft:crafting_shaped', 'minecraft:crafting_shapeless', 'minecraft:crafting_transmute',
'minecraft:crafting_dye', 'minecraft:crafting_imbue')
COOKING = {'minecraft:smelting': 'furnace', 'minecraft:blasting': 'blast_furnace', 'minecraft:smoking': 'smoker'}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--seed', type=int, default=11)
parser.add_argument('--limit', type=int, default=3)
args = parser.parse_args()
rng = random.Random(args.seed)
lock, jars, _ = base.verify_artifacts()
work = lib.work_dir('ghost-recipe-parity')
classes = work / 'classes'
classes.mkdir(exist_ok=True)
deps = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()]))
sources = ('ParityData', 'VanillaMenuOracle', 'VanillaGhostRecipeOracle')
done = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-cp', deps,
'-d', str(classes), *(str(lib.PARITY / f'{n}.java') for n in sources)], capture_output=True, text=True)
if done.returncode:
print(done.stderr[-4000:])
sys.exit('javac failed')
cases = []
for path in sorted((lib.RESOURCES / 'data/minecraft/recipe').glob('*.json')):
kind = json.loads(path.read_text()).get('type')
recipe = 'minecraft:' + path.stem
if kind in CRAFTING:
for menu in ('inventory', 'crafting'):
cases.append({'menu': menu, 'recipe': recipe})
elif kind in COOKING:
for fuel in (None, '{id:"minecraft:coal",count:3}'):
cases.append({'menu': COOKING[kind], 'recipe': recipe, 'fuel': fuel})
rng.shuffle(cases)
(work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases))
run = subprocess.run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + deps, 'dev.horizonlab.parity.VanillaGhostRecipeOracle',
str(work / 'cases.jsonl'), str(work / 'native.txt')], capture_output=True, text=True)
if run.returncode:
print(run.stderr[-4000:])
sys.exit('oracle failed')
lib.cargo_example('horizon-client', 'ghost_recipe_fixture', lib.RESOURCES, work / 'cases.jsonl', work / 'rust.txt')
bad = lib.compare(cases, work / 'native.txt', work / 'rust.txt',
lambda case, line: case['menu'] if not line.startswith('error') else 'oracle error',
describe=json.dumps, limit=args.limit)
raise SystemExit(1 if bad else 0)
if __name__ == '__main__':
main()
+163
View File
@@ -0,0 +1,163 @@
#!/usr/bin/env python3
"""Compare creative toolbars read from an older hotbar.nbt with the vanilla client's.
Each case is the SNBT of a hotbar.nbt of some DataVersion (the version tag
missing means 1343): nine rows of nine stacks in the item format of that era
(damage values of 1.12, `tag` compounds of 1.13 to 1.20.4, components of
1.20.5 on), with empty stacks (air, count zero or negative, no
id), rows of the wrong size or type and garbage. The Java oracle
(VanillaHotbarOracle) writes the file and loads it with the client's real
HotbarManager and DataFixers (DataFixTypes.HOTBAR, so EmptyItemInHotbarFix
and every item stack fixer), then Hotbar.load on each row;
examples/hotbar_fixture runs horizon_client::hotbar on the same tag. The nine
rows' stacks are compared.
"""
import argparse
import json
import os
import random
import subprocess
import sys
try:
from . import interaction_lab as lib, test_model_baking_parity as baking, test_rust_parity as base
except ImportError:
import interaction_lab as lib
import test_model_baking_parity as baking
import test_rust_parity as base
VERSIONS = [None, 1343, 1344, 1451, 1519, 1631, 1976, 2200, 2504, 2586, 2730, 2975, 3105, 3218, 3337, 3465, 3578, 3698,
3700, 3817, 3818, 3820, 3824, 3825, 3900, 4059, 4082, 4189, 4325, 4540, 4650, 4780, 4900, 5023]
LEGACY = [
'{id:"minecraft:planks",Damage:2s,Count:3b}', '{id:"minecraft:wool",Damage:14s,Count:64b}',
'{id:"minecraft:stone",Damage:3s,Count:1b}', '{id:"minecraft:log",Damage:1s,Count:1b}',
'{id:"minecraft:log2",Damage:1s,Count:7b}', '{id:"minecraft:potion",Damage:8193s,Count:1b}',
'{id:"minecraft:diamond_pickaxe",Damage:12s,Count:1b,tag:{ench:[{id:32s,lvl:3s}],display:{Name:"Pick"}}}',
'{id:"minecraft:golden_apple",Damage:1s,Count:2b}', '{id:"minecraft:dye",Damage:4s,Count:5b}',
'{id:"minecraft:stained_glass_pane",Damage:5s,Count:9b}', '{id:"minecraft:skull",Damage:3s,Count:1b,tag:{SkullOwner:"Notch"}}',
'{id:"minecraft:banner",Damage:1s,Count:1b,tag:{BlockEntityTag:{Base:1,Patterns:[{Pattern:"cre",Color:15}]}}}',
'{id:"minecraft:tallgrass",Damage:1s,Count:1b}', '{id:"minecraft:stick",Count:1b}', '{id:"minecraft:iron_sword",Count:1b,Damage:40s}',
'{id:"minecraft:bed",Damage:14s,Count:1b}', '{id:"minecraft:monster_egg",Damage:2s,Count:3b}',
'{id:"minecraft:written_book",Count:1b,tag:{title:"t",author:"a",pages:["{\\"text\\":\\"p\\"}"]}}',
]
CLASSIC = [
'{id:"minecraft:diamond_sword",Count:1b,tag:{Damage:5,Enchantments:[{id:"minecraft:sharpness",lvl:3s}],display:{Name:\'{"text":"Cool"}\'}}}',
'{id:"minecraft:potion",Count:1b,tag:{Potion:"minecraft:strong_healing"}}', '{id:"minecraft:stone",Count:64b}',
'{id:"minecraft:firework_rocket",Count:3b,tag:{Fireworks:{Flight:2b}}}', '{id:"minecraft:cobblestone",Count:12b}',
'{id:"minecraft:player_head",Count:1b,tag:{SkullOwner:"Notch"}}', '{id:"minecraft:dirt",Count:2b}',
'{id:"minecraft:white_banner",Count:1b,tag:{BlockEntityTag:{Patterns:[{Pattern:"cre",Color:15}]}}}',
'{id:"minecraft:enchanted_book",Count:1b,tag:{StoredEnchantments:[{id:"minecraft:mending",lvl:1s}]}}',
'{id:"minecraft:tipped_arrow",Count:8b,tag:{Potion:"minecraft:weakness"}}', '{id:"minecraft:string",Count:3b}',
'{id:"minecraft:iron_axe",Count:1b,tag:{Damage:3,RepairCost:7,Unbreakable:1b}}',
'{id:"minecraft:filled_map",Count:1b,tag:{map:12}}', '{id:"minecraft:leather_chestplate",Count:1b,tag:{display:{color:255}}}',
'{id:"minecraft:shield",Count:1b,tag:{BlockEntityTag:{Base:3}}}', '{id:"minecraft:bundle",Count:1b,tag:{Items:[{id:"minecraft:stone",Count:2b}]}}',
'{id:"minecraft:diamond_sword",Count:1b,tag:{AttributeModifiers:[{AttributeName:"generic.attack_damage",Name:"x",Amount:2.5d,Operation:0,UUID:[I;1,2,3,4],Slot:"mainhand"}]}}',
]
COMPONENTS = [
'{id:"minecraft:diamond_sword",count:1,components:{"minecraft:damage":5}}', '{id:"minecraft:stone",count:64}',
'{id:"minecraft:potion",count:1,components:{"minecraft:potion_contents":{potion:"minecraft:strong_healing"}}}',
'{id:"minecraft:firework_rocket",count:3,components:{"minecraft:fireworks":{flight_duration:2b}}}',
'{id:"minecraft:white_banner",count:1}', '{id:"minecraft:iron_axe",count:1,components:{"minecraft:repair_cost":7}}',
'{id:"minecraft:grass_block",count:2}', '{id:"minecraft:cobblestone",count:12}', '{id:"minecraft:stone"}',
]
JUNK = ['{}', '{id:"minecraft:air",Count:1b}', '{id:"minecraft:stone",Count:0b}', '{id:"minecraft:stone",Count:-3b}',
'{Count:5b}', '{id:"minecraft:stone"}', '{id:"minecraft:air",count:3}', '{id:"minecraft:stone",count:0}',
'{id:"minecraft:stone",count:200}', '{id:"minecraft:stone",Count:100b}', '{id:"minecraft:nonexistent",Count:1b}',
'{id:5s,Count:1b}', '{id:"minecraft:stone",Count:"x"}']
# Entries that are no stacks, and rows that are no lists: the fixers drop the entry from its row (so a row of ten
# with one is a full row, and a row of nine a short one) and a row that is no list ends the reading. Several of
# them in one file interact in ways this does not follow, so each gets its own file.
ODD = ['"stone"', '5', '[]', '1b', '{}', '[I;1,2]']
def pool(version):
v = version or 1343
if v < 1451:
return LEGACY
if v < 3819:
return CLASSIC
return COMPONENTS
def stack(rng, version):
r = rng.random()
if r < 0.75:
return rng.choice(pool(version))
if r < 0.92:
return rng.choice(JUNK)
return rng.choice(pool(rng.choice(VERSIONS)))
def case(rng):
version = rng.choice(VERSIONS)
rows = []
elements = {}
for i in range(9):
r = rng.random()
if r < 0.04:
continue
if r < 0.07:
rows.append(f'"{i}":5')
continue
size = 9 if r < 0.93 else rng.choice([0, 8, 10])
stacks = [stack(rng, version) for _ in range(size)]
elements[i] = stacks
rows.append(f'"{i}":[' + ','.join(stacks) + ']')
head = '' if version is None else f'DataVersion:{version},'
return {'snbt': '{' + head + ','.join(rows) + '}', 'version': version, 'elements': elements}
def odd_cases():
cases = []
for version in [None, 1343, 1631, 3337, 3700, 3818, 3819, 3824, 4325, 4540, 5015, 5016, 5022, 5023]:
v = version or 1343
ok = '{id:"minecraft:stone",Count:2b}' if v < 3819 else '{id:"minecraft:stone",count:2}'
head = '' if version is None else f'DataVersion:{version},'
good = '[' + ','.join([ok] * 9) + ']'
for odd in ODD:
for position in (0, 4, 8):
row = [ok] * 9
row[position] = odd
cases.append({'snbt': '{' + head + f'"0":[{",".join(row)}],"1":{good}' + '}'})
for row_size in (8, 10):
row = [ok] * row_size
row[3] = odd
cases.append({'snbt': '{' + head + f'"0":[{",".join(row)}],"1":{good}' + '}'})
# A row that is none: the rows after it.
cases.append({'snbt': '{' + head + ','.join(f'"{i}":{odd if i == 2 else good}' for i in range(9)) + '}'})
return cases
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--seed', type=int, default=23)
parser.add_argument('--cases', type=int, default=400)
parser.add_argument('--limit', type=int, default=3)
args = parser.parse_args()
rng = random.Random(args.seed)
lock, jars, _ = base.verify_artifacts()
work = lib.work_dir('hotbar-parity')
classes = work / 'classes'
classes.mkdir(exist_ok=True)
deps = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()]))
done = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-cp', deps,
'-d', str(classes), *(str(lib.PARITY / f'{n}.java') for n in ('ParityData', 'VanillaHotbarOracle'))],
capture_output=True, text=True)
if done.returncode:
print(done.stderr[-4000:])
sys.exit('javac failed')
cases = [{'snbt': None}] + odd_cases() + [case(rng) for _ in range(args.cases)]
(work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases))
run = subprocess.run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + deps, 'dev.horizonlab.parity.VanillaHotbarOracle',
str(work / 'cases.jsonl'), str(work / 'native.txt')], capture_output=True, text=True)
if run.returncode:
print(run.stderr[-4000:])
sys.exit('oracle failed')
lib.cargo_example('horizon-client', 'hotbar_fixture', lib.RESOURCES, work / 'cases.jsonl', work / 'rust.txt')
bad = lib.compare(cases, work / 'native.txt', work / 'rust.txt', lambda c, line: 'hotbar' if not line.startswith('error') else 'oracle error',
describe=lambda c: c['snbt'][:300] if c['snbt'] else 'missing file', limit=args.limit)
raise SystemExit(1 if bad else 0)
if __name__ == '__main__':
main()
+9
View File
@@ -145,6 +145,15 @@ def make_cases(build):
'graphicsMode:1\nlang:Fr_Ca\nresourcePacks:["a","programer_art"]\nincompatibleResourcePacks:["programer_art"]\n',
'key_key.forward:abc\n', 'key_key.forward:\n', 'key_key.attack:k\n', 'chatOpacity:Infinity\n',
'chatOpacity: 0.5d\n', 'menuBackgroundBlurriness:0.25\n', 'menuBackgroundBlurriness:1.04999\n',
# OptionsForceVBOFix writes a key nothing reads; the lower-casing, key and graphics fixers on odd values.
'useVbo:false\nao:true\nao:3\n', 'ao:\n', 'graphicsMode:3\nao:2\n', 'graphicsMode:abc\n', 'fancyGraphics:abc\n',
'fancyGraphics:TRUE\n', 'lang:\u039f\u0394\u03a5\u03a3\u03a3\u0395\u03a5\u03a3\n', 'lang:\u0130_TR\n', 'lang:\u00df_\u00dc\n',
'key_key.attack:-101\nkey_key.use:-92\nkey_key.forward:2147483647\nkey_key.back:99999\nkey_key.left:-2147483648\n',
'key_key.hotbar.1:2\nkey_key.hotbar.9:10\nkey_key.swapHands:33\nkey_key.drop:16\nkey_key.debug.modifier:292\n',
'showNowPlayingToast:maybe\n', 'showNowPlayingToast:true\nmusicToast:never\n',
'resourcePacks:["programer_art","x"]\nincompatibleResourcePacks:[]\n', 'resourcePacks:[\'programer_art\']\n',
'menuBackgroundBlurriness:-3\n', 'menuBackgroundBlurriness:1e3\n', 'menuBackgroundBlurriness:\n', 'chatOpacity:0\n',
'chatOpacity:1\ntextBackgroundOpacity:0.2\n', 'preferredGraphicsBackend:vulkan\n', 'onboardAccessibility:true\n',
]
versions = [-1, 0, 100, 504, 505, 815, 816, 1343, 1344, 1445, 1446, 1935, 1936, 2555, 2556, 2557, 2558, 3200, 3201,
3213, 3214, 3318, 3319, 3942, 3943, 4650, 4651, 4660, 4661, 4891, 4892, 5022, 5023, 5024, 9999]
+51 -2
View File
@@ -11,7 +11,10 @@ RecipeCollection.selectRecipes and the tab and page logic of
RecipeBookComponent; examples/recipe_book_view_fixture runs
horizon_client::recipe_book::ClientBook. Per tab: visibility, pages and
every button's displays with their selected and craftable flags, in order
(the client's HashMap of display ids decides it).
(the client's HashMap of display ids decides it). Most cases also carry a
search text (names, parts of them, ids with a colon, odd ones); the oracle
searches the collections with the FullTextSearchTree of SessionSearchTrees
over the tooltip lines and ids of every result a display can show.
"""
import argparse
import json
@@ -31,6 +34,51 @@ except ImportError:
import test_rust_parity as base
def queries(rng, items):
"""Search texts: a name or part of one, with case and spacing changes, ids with a colon, and odd ones."""
lang = json.loads((lib.RESOURCES / 'assets/minecraft/lang/en_us.json').read_text())
names = []
for i in items:
path = i.split(':')[-1]
names.append((path, lang.get('item.minecraft.' + path) or lang.get('block.minecraft.' + path) or path))
def make():
path, name = rng.choice(names)
a = rng.randrange(len(name))
part = name[a:a + rng.randint(1, 8)]
kind = rng.randrange(14)
if kind == 0:
return name
if kind == 1:
return name.upper()
if kind == 2:
return part
if kind == 3:
return part.lower()
if kind == 4:
return 'minecraft:' + path[a % max(1, len(path)):][:rng.randint(0, 6)]
if kind == 5:
return 'minecraft:' + part
if kind == 6:
return ' ' + rng.choice(['minecraft', 'mine', 'craft', 'x', '']) + ' : ' + path.split('_')[0] + ' '
if kind == 7:
return ':' + part
if kind == 8:
return rng.choice(['minecraft:', ':', 'a:b:c', 'minecraft:oak', 'minecraft:stone', 'oak', 'plank', 'ingot', 'Block of', ' ',
'İ', 'ΣΑΣ', 'ß', 'tool', 'enchant', 'dye'])
if kind == 9:
return path
if kind == 10:
return path.replace('_', ' ')
if kind == 11:
return 'minecraft:' + path
if kind == 12:
return rng.choice(['Wooden', 'Iron', 'Golden', 'Diamond', 'Stone', 'Netherite', 'Copper', 'Smooth', 'Cut', 'Chiseled']) \
+ rng.choice(['', ' ', ' Pickaxe', ' Slab', ' Stairs'])
return ''
return make
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--seed', type=int, default=17)
@@ -54,6 +102,7 @@ def main():
rng = gen.rng
ids = sorted('minecraft:' + n for n in recipes.recipes)
cases = []
query = queries(rng, items)
for n in range(args.cases):
kind = ['crafting', 'crafting', 'furnace', 'blast_furnace', 'smoker'][n % 5]
# Few to most recipes known: the table grows and display ids collide.
@@ -72,7 +121,7 @@ def main():
inventory = [s for _, s in case['inventory']]
slots = [s for _, s in case['grid']]
cases.append({'type': kind, 'grid': 2 if menu == 'inventory' else 3, 'history': history, 'inventory': inventory,
'slots': slots, 'filtering': rng.random() < 0.5})
'slots': slots, 'filtering': rng.random() < 0.5, 'search': query() if rng.random() < 0.7 else ''})
(work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases))
run = subprocess.run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + deps, 'dev.horizonlab.parity.VanillaRecipeBookViewOracle',
str(work / 'cases.jsonl'), str(work / 'native.txt')], capture_output=True, text=True)