Place recipe book recipes as vanilla's ServerPlaceRecipe does

ServerPlaceRecipe and StackedContents' RecipePicker run on the menu
engine (horizon_client::menu::place) for the inventory, crafting table
and furnaces: testClearGrid, clearGrid with placeItemBackInInventory,
the biggest craftable stack, clamping to stack sizes and moveItemToGrid.
A new harness compares 6,000 placements with vanilla; vanilla's item
order follows identity hash codes, so the oracle hands its order to the
Rust side. The game's recipe book now places through the engine, and
its craftable filter uses the same counts and placement ingredients.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-12 16:51:38 +02:00
parent eb9bee05bd
commit acf4df3a90
9 changed files with 1308 additions and 434 deletions
@@ -0,0 +1,89 @@
//! Recipe book placements for tools/test_place_recipe_parity.py: reads one
//! JSON case per line (menu, inventory, grid, recipe, max, creative,
//! selected) and the oracle's order of the counted items, runs
//! `Menu::place_recipe` and prints the oracle's line.
//!
//! usage: place_recipe_fixture RESOURCES CASES ORDERS OUTPUT
use horizon_client::{
crafting::Recipes,
item_data::{canon_stack, parse_stack},
items::Items,
menu::{Env, Kind, Menu, place::PostPlace},
};
use serde_json::Value;
use std::{fs, path::Path};
fn state(menu: &Menu) -> String {
let slots: Vec<String> = (0..menu.slot_count())
.map(|i| canon_stack(menu.slot(i)))
.collect();
let data: String = menu.data.iter().map(|d| format!(" {d}")).collect();
let inv: Vec<String> = (0..41).map(|i| canon_stack(menu.player_item(i))).collect();
format!(
"{} | {} |{data} | {} | inv {}",
slots.join(" "),
canon_stack(menu.carried.as_ref()),
menu.drops.join(";"),
inv.join(" ")
)
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let usage = "usage: place_recipe_fixture RESOURCES CASES ORDERS OUTPUT";
let root = Path::new(args.get(1).ok_or(usage)?);
let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
let orders = fs::read_to_string(args.get(3).ok_or(usage)?)?;
let items = Items::catalog(root)?;
let recipes = Recipes::load(root, &items)?;
let brewing = horizon_client::brewing::Brewing::load(root, &items);
let banners = horizon_client::banner::Banners::default();
let env = Env {
items: &items,
recipes: &recipes,
brewing: &brewing,
banners: &banners,
};
let mut out = String::new();
for (line, order) in cases.lines().zip(orders.lines()) {
let case: Value = serde_json::from_str(line)?;
let kind = Kind::parse(case["menu"].as_str().unwrap_or_default()).ok_or("menu kind")?;
let mut menu = Menu::new(kind);
menu.creative = case["creative"].as_bool().unwrap_or(false);
menu.selected = case["selected"].as_u64().unwrap_or(0) as usize;
for pair in case["inventory"].as_array().ok_or("inventory")? {
menu.set_player_item(
pair[0].as_u64().unwrap_or(0) as usize,
parse_stack(pair[1].as_str().unwrap_or("-"))?,
);
}
for pair in case["grid"].as_array().ok_or("grid")? {
menu.set_slot(
&env,
pair[0].as_u64().unwrap_or(0) as usize,
parse_stack(pair[1].as_str().unwrap_or("-"))?,
);
}
menu.drops.clear();
let order: Vec<String> = order.split_whitespace().map(str::to_owned).collect();
let recipe = case["recipe"].as_str().unwrap_or_default();
let impossible = recipes.placement(recipe).is_none_or(|p| p.impossible());
let post = if impossible {
"-"
} else {
match menu.place_recipe(
&env,
recipe,
case["max"].as_bool().unwrap_or(false),
menu.creative,
Some(&order),
) {
PostPlace::Nothing => "NOTHING",
PostPlace::Ghost => "PLACE_GHOST_RECIPE",
}
};
out += &format!("post {post} | {}\n", state(&menu));
}
fs::write(args.get(4).ok_or(usage)?, out)?;
Ok(())
}
+138 -47
View File
@@ -56,6 +56,39 @@ impl Ingredient {
self.0.contains(&*stack.item)
}
}
/// `PlacementInfo`: the ingredients to find and, per recipe slot, the index
/// of its ingredient (`slotsToIngredientIndex`, -1 for an empty slot). Empty
/// when the recipe is impossible to place.
#[derive(Clone, Debug, Default)]
pub struct Placement {
pub ingredients: Vec<Ingredient>,
pub slots: Vec<i32>,
/// A `ShapedRecipe`'s width and height (the others fill the grid).
pub shaped: Option<(usize, usize)>,
}
impl Placement {
/// `PlacementInfo.createFromOptionals` (and `create` with no empty slots).
pub fn of(cells: Vec<Option<Ingredient>>, shaped: Option<(usize, usize)>) -> Self {
let mut out = Self {
shaped,
..Self::default()
};
for cell in cells {
match cell {
Some(i) if i.0.is_empty() => return Self::default(),
Some(i) => {
out.slots.push(out.ingredients.len() as i32);
out.ingredients.push(i);
}
None => out.slots.push(-1),
}
}
out
}
pub fn impossible(&self) -> bool {
self.slots.is_empty()
}
}
/// A recipe result: `ItemStackTemplate` (`id`, `count`, `components`), with the
/// id optional for the transmuting recipes that keep the input's item.
#[derive(Clone, Debug)]
@@ -1319,56 +1352,114 @@ impl Recipes {
map_scale,
};
for (name, recipe) in &self.crafting {
let result = match recipe {
Recipe::Special(special) => {
if !special.matches(&ctx, &input) {
continue;
}
special.assemble(&ctx, &input)
}
Recipe::Shaped {
width,
height,
cells,
result,
} => {
if *width != input.width
|| *height != input.height
|| cells.iter().flatten().count() != input.count()
{
continue;
}
let matches = |mirror: bool| {
(0..*height).all(|y| {
(0..*width).all(|x| {
let rx = if mirror { width - 1 - x } else { x };
match (&cells[y * width + rx], input.get(x, y)) {
(None, None) => true,
(Some(i), Some(s)) => i.test(s),
_ => false,
}
})
})
};
if !(matches(false) || matches(true)) {
continue;
}
Some(result.create())
}
Recipe::Shapeless {
ingredients,
result,
} => {
if !matches_all(ingredients, &input.stacks()) {
continue;
}
Some(result.create())
}
};
return result.map(|r| (name.as_str(), r));
if let Some(result) = Self::assemble_if_matches(&ctx, &input, recipe) {
return result.map(|r| (name.as_str(), r));
}
}
None
}
/// `Recipe.matches` then `assemble` for one recipe: None when it does
/// not match, Some(None) when it matches with nothing to make.
fn assemble_if_matches(
ctx: &Context,
input: &Input,
recipe: &Recipe,
) -> Option<Option<ItemStack>> {
match recipe {
Recipe::Special(special) => special
.matches(ctx, input)
.then(|| special.assemble(ctx, input)),
Recipe::Shaped {
width,
height,
cells,
result,
} => {
if *width != input.width
|| *height != input.height
|| cells.iter().flatten().count() != input.count()
{
return None;
}
let matches = |mirror: bool| {
(0..*height).all(|y| {
(0..*width).all(|x| {
let rx = if mirror { width - 1 - x } else { x };
match (&cells[y * width + rx], input.get(x, y)) {
(None, None) => true,
(Some(i), Some(s)) => i.test(s),
_ => false,
}
})
})
};
(matches(false) || matches(true)).then(|| Some(result.create()))
}
Recipe::Shapeless {
ingredients,
result,
} => matches_all(ingredients, &input.stacks()).then(|| Some(result.create())),
}
}
/// `recipe.matches(craftSlots.asCraftInput())` for one recipe by id
/// (`minecraft:name`).
pub fn recipe_matches(&self, id: &str, grid: &[Option<ItemStack>], size: usize) -> bool {
let name = id.trim_start_matches("minecraft:");
let Some((_, recipe)) = self.crafting.iter().find(|(n, _)| n == name) else {
return false;
};
let Some(input) = Input::of(grid, size) else {
return false;
};
let ctx = Context {
recipes: self,
map_scale: &|_| None,
};
Self::assemble_if_matches(&ctx, &input, recipe).is_some()
}
/// `Recipe.placementInfo` of a crafting or cooking recipe by id; None for
/// an unknown id, an empty placement when it is impossible to place.
pub fn placement(&self, id: &str) -> Option<Placement> {
let name = id.trim_start_matches("minecraft:");
if let Some(c) = self.cooking.iter().find(|c| c.id == name) {
return Some(Placement::of(vec![Some(c.ingredient.clone())], None));
}
let (_, recipe) = self.crafting.iter().find(|(n, _)| n == name)?;
Some(match recipe {
Recipe::Shaped {
width,
height,
cells,
..
} => Placement::of(cells.clone(), Some((*width, *height))),
Recipe::Shapeless { ingredients, .. } => {
Placement::of(ingredients.iter().cloned().map(Some).collect(), None)
}
Recipe::Special(Special::Transmute {
input,
material,
max,
..
}) => {
let mut list = vec![Some(input.clone())];
list.extend(std::iter::repeat_n(Some(material.clone()), *max));
Placement::of(list, None)
}
Recipe::Special(Special::Dye { target, dye, .. }) => {
Placement::of(vec![Some(target.clone()), Some(dye.clone())], None)
}
Recipe::Special(Special::Imbue {
source, material, ..
}) => Placement::of(
(0..9)
.map(|i| Some(if i == 4 { source } else { material }.clone()))
.collect(),
None,
),
// CustomRecipe.placementInfo: NOT_PLACEABLE.
Recipe::Special(_) => Placement::default(),
})
}
/// `Recipe.getRemainingItems` placed on the `size`x`size` grid: an item's
/// crafting remainder (buckets, bottles), the patterned banner a duplicate
/// keeps and the written book a clone keeps.
+9
View File
@@ -3738,9 +3738,15 @@ impl Game<'_> {
banners: &self.res.stations.banners,
};
menu.creative = creative;
menu.selected = self.selected;
for (i, stack) in before.iter().enumerate() {
menu.set_slot(&env, i, stack.clone());
}
// The off hand is part of the inventory even when the menu has no slot for it.
let offhand_mapped = game_of.contains(&Some(504));
if !offhand_mapped {
menu.set_player_item(40, self.offhand.clone());
}
menu.settle(&env);
if kind == Kind::Loom
&& let Some((selected, patterns)) = station_menu
@@ -3773,6 +3779,9 @@ impl Game<'_> {
}
}
self.carried = carried;
if !offhand_mapped {
self.offhand = menu.player_item(40).cloned();
}
for stack in dropped {
self.player_drop(stack);
}
+33 -215
View File
@@ -9,7 +9,8 @@ use horizon_client::{
containers::{BlockEntity, FurnaceKind},
hud::{HudBatch, Rect, rgba},
items::ItemStack,
recipe_book::{Available, Book, BookType, Collection, Display, Entry, Tab},
menu::place::{PostPlace, Stacked},
recipe_book::{Book, BookType, Collection, Display, Entry, Tab},
ui::EditBox,
};
use std::{
@@ -212,30 +213,16 @@ impl Game<'_> {
fn book_grid(&self) -> (usize, usize) {
(self.craft_size, self.craft_size)
}
/// The slot ids holding the menu's recipe inputs (and, for furnaces, the
/// fuel and result slots that the book also reads).
fn book_input_slots(&self, book: BookType) -> Vec<usize> {
match book {
BookType::Crafting => {
let (w, h) = self.book_grid();
(0..w * h).map(|i| 100 + i).collect()
}
_ => vec![300],
}
}
/// The items the book counts: the inventory and the menu's crafting slots.
fn book_available(&mut self, book: BookType) -> Available {
let mut stacks: Vec<ItemStack> = self.inventory.iter().flatten().cloned().collect();
let slots = match book {
BookType::Crafting => self.book_input_slots(book),
_ => vec![300, 301, 302],
};
for slot in slots {
if let Some(s) = self.slot_mut(slot).clone() {
stacks.push(s);
}
}
Available::from_stacks(stacks.iter())
/// The items the book counts (`RecipeBookComponent.updateStackedContents`):
/// the inventory and the menu's crafting slots, as the menu engine counts them.
fn book_available(&mut self, _book: BookType) -> Stacked {
let mut out = Stacked::default();
let stock = &mut out;
self.menu_session(|menu, env, _| {
*stock = menu.stacked_contents(env);
Some(false)
});
out
}
fn unlocked_recipes(&self) -> BTreeSet<String> {
self.adv
@@ -317,7 +304,7 @@ impl Game<'_> {
let available = self.book_available(book_type);
let shown = |e: &Entry| {
(book_type != BookType::Crafting || e.fits(gw, gh))
&& (!filtering || available.can_craft(&e.requirements()))
&& (!filtering || book.can_craft(e, &available))
};
let new = |level: &Self, e: &Entry| level.level.recipe_book.to_be_displayed.contains(&e.id);
let mut tabs = Vec::new();
@@ -376,7 +363,7 @@ impl Game<'_> {
BookType::Crafting => e.fits(gw, gh),
_ => true,
};
let craftable = |e: &Entry| selected(e) && available.can_craft(&e.requirements());
let craftable = |e: &Entry| selected(e) && book.can_craft(e, &available);
let filtering = self.book_filtering(book_type);
let mut tabs = Vec::new();
for tab in book_type.tabs() {
@@ -660,8 +647,9 @@ impl Game<'_> {
self.recipe_ui.ghost.clear();
self.place_recipe(book_type, entry_index, use_max);
}
/// `ServerPlaceRecipe.placeRecipe`: fills the grid from the inventory,
/// or shows the ghost recipe when the items are missing.
/// `ServerboundPlaceRecipePacket`: the server places the recipe
/// (`ServerPlaceRecipe` on the menu engine) and answers with a ghost
/// recipe when the items are missing.
fn place_recipe(&mut self, book_type: BookType, entry_index: usize, use_max: bool) {
let Some(entry) = self
.recipe_ui
@@ -672,88 +660,23 @@ impl Game<'_> {
else {
return;
};
let (gw, gh) = match book_type {
BookType::Crafting => self.book_grid(),
_ => (1, 1),
};
let inputs = self.book_input_slots(book_type);
let clear: Vec<usize> = match book_type {
BookType::Crafting => inputs.clone(),
_ => vec![300, 302],
};
if !self.creative && !self.can_clear_grid(&clear) {
return;
}
let available = self.book_available(book_type);
let requirements = entry.requirements();
if !available.can_craft(&requirements) {
self.clear_book_grid(&clear);
let creative = self.creative;
let mut post = None;
let answer = &mut post;
self.menu_session(|menu, env, _| {
// handlePlaceRecipe: an impossible recipe is refused outright.
if env
.recipes
.placement(&entry.id)
.is_none_or(|p| p.impossible())
{
return Some(false);
}
*answer = Some(menu.place_recipe(env, &entry.id, use_max, creative, None));
Some(true)
});
if post == Some(PostPlace::Ghost) {
self.fill_ghost(book_type, &entry);
self.recipe_book_changed();
return;
}
let matches_placed = self.recipe_matches(book_type, &entry);
let biggest = available.biggest_stack(&requirements);
if matches_placed {
for slot in &inputs {
let stack = self.slot_mut(*slot).clone();
if let Some(s) = stack {
let max = self.res.items.get(&s.item).map_or(64, |i| i.max_stack);
if biggest.min(max) < s.count + 1 {
return;
}
}
}
}
let amount = if use_max {
biggest
} else if matches_placed {
let smallest = inputs
.iter()
.filter_map(|slot| self.slot_mut(*slot).as_ref().map(|s| s.count))
.min();
smallest.map_or(1, |n| n + 1)
} else {
1
};
let order = self
.recipe_ui
.book
.as_ref()
.map(|b| b.order.clone())
.unwrap_or_default();
let Some(mut used) = available.pick(&requirements, amount, &order) else {
return;
};
let item_max = |item: &str| self.res.items.get(item).map_or(64, |i| i.max_stack);
let mut amount = amount;
let clamped = used.iter().map(|i| item_max(i)).fold(amount, u32::min);
if clamped != amount {
amount = clamped;
match available.pick(&requirements, amount, &order) {
Some(u) => used = u,
None => return,
}
}
self.clear_book_grid(&clear);
for (ingredient, grid_index) in entry.grid_cells(gw, gh) {
let Some(ingredient) = ingredient else {
continue;
};
let slot = inputs[grid_index.min(inputs.len() - 1)];
let mut remaining = amount as i64;
while remaining > 0 {
remaining = self.move_item_to_grid(slot, &used[ingredient], remaining);
if remaining < 0 {
break;
}
}
}
if let Some(BlockEntity::Furnace(f)) = self
.container
.and_then(|k| self.world.block_entities.get_mut(&k))
{
f.cooking_timer = 0;
}
self.recipe_book_changed();
}
@@ -764,111 +687,6 @@ impl Game<'_> {
self.container_changed(key);
}
}
/// `menu.recipeMatches(recipe)`: the grid already holds this recipe.
fn recipe_matches(&mut self, book_type: BookType, entry: &Entry) -> bool {
match (&entry.display, book_type) {
(Display::Furnace(ingredient), _) => self
.slot_mut(300)
.as_ref()
.is_some_and(|s| ingredient.test(s)),
(_, BookType::Crafting) => {
let n = self.craft_size;
let grid: Vec<Option<ItemStack>> =
(0..n * n).map(|i| self.craft_grid[i].clone()).collect();
self.res
.recipes
.find(&grid, n)
.is_some_and(|(name, _)| format!("minecraft:{name}") == entry.id)
}
_ => false,
}
}
/// `Inventory.getSlotWithRemainingSpace`.
fn has_room_for(&self, stack: &ItemStack) -> bool {
let max = self.res.items.get(&stack.item).map_or(64, |i| i.max_stack);
self.inventory
.iter()
.flatten()
.any(|s| s.same_item_same_components(stack) && max > 1 && s.count < max)
}
/// `ServerPlaceRecipe.testClearGrid`.
fn can_clear_grid(&mut self, slots: &[usize]) -> bool {
let mut free: Vec<ItemStack> = Vec::new();
let free_in_inventory = self.inventory.iter().filter(|s| s.is_none()).count();
for &slot in slots {
let Some(mut stack) = self.slot_mut(slot).clone() else {
continue;
};
if !self.has_room_for(&stack) && free.len() <= free_in_inventory {
for other in free.iter_mut() {
let max = self.res.items.get(&other.item).map_or(64, |i| i.max_stack);
if other.item == stack.item
&& other.count != max
&& other.count + stack.count <= max
{
other.count += stack.count;
stack.count = 0;
break;
}
}
if stack.count > 0 {
if free.len() >= free_in_inventory {
return false;
}
free.push(stack);
}
} else if !self.has_room_for(&stack) {
return false;
}
}
true
}
/// `ServerPlaceRecipe.clearGrid`: the grid's items go back to the inventory.
fn clear_book_grid(&mut self, slots: &[usize]) {
for &slot in slots {
if let Some(stack) = self.slot_mut(slot).take() {
self.give_or_drop_quiet(stack);
}
}
}
/// Back into the inventory; what does not fit is lost only in creative
/// (survival checks room first with `can_clear_grid`).
fn give_or_drop_quiet(&mut self, stack: ItemStack) {
let _ = self.give(stack);
}
/// `ServerPlaceRecipe.moveItemToGrid`; the count still to move or -1.
fn move_item_to_grid(&mut self, slot: usize, item: &str, count: i64) -> i64 {
let target = self.slot_mut(slot).clone();
let found = self.inventory.iter().position(|s| {
s.as_ref().is_some_and(|s| {
&*s.item == item
&& s.damage == 0
&& s.enchantments().is_empty()
&& s.custom_name().is_none()
&& target
.as_ref()
.is_none_or(|t| t.same_item_same_components(s))
})
});
let Some(index) = found else { return -1 };
let Some(source) = self.inventory[index].as_mut() else {
return -1;
};
let taken = (count as u32).min(source.count);
let moved = ItemStack {
count: taken,
..source.clone()
};
source.count -= taken;
if source.count == 0 {
self.inventory[index] = None;
}
match self.slot_mut(slot) {
Some(existing) => existing.count += taken,
empty => *empty = Some(moved),
}
count - i64::from(taken)
}
// ---- ghost recipe ----
+14 -6
View File
@@ -14,6 +14,8 @@ use crate::{
};
use std::sync::Arc;
pub mod place;
/// What a menu needs to know about items and recipes.
pub struct Env<'a> {
pub items: &'a Items,
@@ -144,6 +146,8 @@ pub struct Menu {
pub carried: Option<ItemStack>,
pub data: Vec<i32>,
pub creative: bool,
/// The selected hotbar slot (`Inventory.selected`).
pub selected: usize,
/// Dropped stacks (canonical text), `xp+N` and the like, in order.
pub drops: Vec<String>,
/// The dropped stacks themselves, for the caller to throw.
@@ -345,6 +349,7 @@ impl Menu {
carried: None,
data: vec![0; data],
creative: false,
selected: 0,
drops: Vec::new(),
dropped: Vec::new(),
quick_status: 0,
@@ -818,13 +823,16 @@ impl Menu {
/// `Inventory.getSlotWithRemainingSpace` (selected slot 0, offhand, rest).
fn slot_with_space(&self, env: &Env, stack: &ItemStack) -> Option<usize> {
let inv = &self.containers[PLAYER];
[0, OFFHAND].into_iter().chain(0..36).find(|&i| {
inv[i].as_ref().is_some_and(|have| {
have.same_item_same_components(stack)
&& Self::stackable(env, have)
&& have.count < CONTAINER_MAX.min(Self::max_stack(env, have))
[self.selected, OFFHAND]
.into_iter()
.chain(0..36)
.find(|&i| {
inv[i].as_ref().is_some_and(|have| {
have.same_item_same_components(stack)
&& Self::stackable(env, have)
&& have.count < CONTAINER_MAX.min(Self::max_stack(env, have))
})
})
})
}
/// `Inventory.addResource`: returns what did not fit.
+706
View File
@@ -0,0 +1,706 @@
//! `ServerPlaceRecipe`: what the server does with a recipe book click
//! (`ServerboundPlaceRecipePacket`) in the inventory, crafting table and
//! furnace menus, with `StackedContents`' exact matching of items to
//! ingredients (`RecipePicker`). `tools/test_place_recipe_parity.py`
//! compares every placement with vanilla's.
//!
//! Vanilla keeps the available items in a `Reference2IntOpenHashMap` keyed by
//! item holders, whose iteration order follows their identity hash codes: it
//! differs between runs of the game, and decides which of several fitting
//! items fills an ingredient. `Stacked` keeps an explicit order: the order
//! items were first counted, or one given (the harness passes the oracle's).
use super::{Env, GRID, Kind, MAIN, Menu, PLAYER, RESULT, split, tidy};
use crate::{
crafting::{Ingredient, Placement},
items::ItemStack,
};
use std::{collections::HashMap, sync::Arc};
/// `StackedContents<Holder<Item>>`: item counts in an iteration order.
#[derive(Clone, Debug, Default)]
pub struct Stacked {
keys: Vec<Arc<str>>,
amounts: Vec<i32>,
index: HashMap<Arc<str>, usize>,
}
/// `Inventory.isUsableForCrafting`: not damaged, enchanted or renamed.
pub fn usable_for_crafting(stack: &ItemStack) -> bool {
stack.damage == 0 && stack.enchantments().is_empty() && stack.custom_name().is_none()
}
impl Stacked {
/// `StackedContents.account`.
pub fn account(&mut self, item: &Arc<str>, count: i32) {
match self.index.get(item) {
Some(&i) => self.amounts[i] += count,
None => {
self.index.insert(item.clone(), self.keys.len());
self.keys.push(item.clone());
self.amounts.push(count);
}
}
}
/// `StackedItemContents.accountStack(stack, maxCount)`.
pub fn account_stack(&mut self, stack: &ItemStack, max: u32) {
if stack.count > 0 {
self.account(&stack.item, stack.count.min(max) as i32);
}
}
/// `accountSimpleStack`.
pub fn account_simple(&mut self, stack: &ItemStack, max: u32) {
if usable_for_crafting(stack) {
self.account_stack(stack, max);
}
}
/// Reorders the keys: the given items first, in that order (vanilla's hash
/// map order for the same items), then the rest as they were.
pub fn set_order(&mut self, order: &[String]) {
let mut keys: Vec<Arc<str>> = order
.iter()
.filter_map(|o| self.index.get_key_value(o.as_str()).map(|(k, _)| k.clone()))
.collect();
for k in &self.keys {
if !keys.contains(k) {
keys.push(k.clone());
}
}
let amounts = keys.iter().map(|k| self.amounts[self.index[k]]).collect();
self.index = keys
.iter()
.cloned()
.enumerate()
.map(|(i, k)| (k, i))
.collect();
self.keys = keys;
self.amounts = amounts;
}
pub fn keys(&self) -> &[Arc<str>] {
&self.keys
}
/// `canCraft(ingredients, null)` without touching the counts (the recipe
/// book's craftable test; the answer does not depend on the order).
pub fn can_craft(&self, ingredients: &[&Ingredient]) -> bool {
!ingredients.is_empty() && self.clone().try_pick(ingredients, 1, None)
}
/// `getResultUpperBound`.
fn upper_bound(&self, ingredients: &[&Ingredient]) -> i32 {
let mut min = i32::MAX;
'ingredients: for ing in ingredients {
let mut max = 0;
for (key, &count) in self.keys.iter().zip(&self.amounts) {
if count > max {
if ing.0.contains(&**key) {
max = count;
}
if max >= min {
continue 'ingredients;
}
}
}
min = max;
if min == 0 {
break;
}
}
min
}
/// `tryPick` (`canCraft(recipe, amount, output)`).
pub fn try_pick(
&mut self,
ingredients: &[&Ingredient],
amount: i32,
output: Option<&mut Vec<Arc<str>>>,
) -> bool {
Picker::new(self, ingredients).try_pick(amount, output)
}
/// `tryPickAll` (`getBiggestCraftableStack`).
pub fn try_pick_all(
&mut self,
ingredients: &[&Ingredient],
max_size: i32,
output: Option<&mut Vec<Arc<str>>>,
) -> i32 {
Picker::new(self, ingredients).try_pick_all(max_size, output)
}
}
/// `StackedContents.RecipePicker`: augmenting paths over item-ingredient pairs.
struct Picker<'a> {
stacked: &'a mut Stacked,
ingredients: Vec<&'a Ingredient>,
/// Indices into the stacked keys of the items any ingredient accepts.
items: Vec<usize>,
connection: Vec<bool>,
assigned: Vec<bool>,
satisfied: Vec<bool>,
visited_ingredient: Vec<bool>,
visited_item: Vec<bool>,
path: Vec<usize>,
}
impl<'a> Picker<'a> {
fn new(stacked: &'a mut Stacked, ingredients: &[&'a Ingredient]) -> Self {
// getUniqueAvailableIngredientItems
let items: Vec<usize> = (0..stacked.keys.len())
.filter(|&i| {
stacked.amounts[i] > 0
&& ingredients.iter().any(|g| g.0.contains(&*stacked.keys[i]))
})
.collect();
let (ni, nt) = (ingredients.len(), items.len());
let mut connection = vec![false; ni * nt];
for (g, ing) in ingredients.iter().enumerate() {
for (t, &key) in items.iter().enumerate() {
if ing.0.contains(&*stacked.keys[key]) {
connection[t * ni + g] = true;
}
}
}
Self {
stacked,
ingredients: ingredients.to_vec(),
items,
connection,
assigned: vec![false; ni * nt],
satisfied: vec![false; ni],
visited_ingredient: vec![false; ni],
visited_item: vec![false; nt],
path: Vec::new(),
}
}
fn at(&self, item: usize, ingredient: usize) -> usize {
item * self.ingredients.len() + ingredient
}
fn clear_visited(&mut self) {
self.visited_ingredient.fill(false);
self.visited_item.fill(false);
}
fn try_pick(&mut self, capacity: i32, mut output: Option<&mut Vec<Arc<str>>>) -> bool {
if capacity <= 0 {
return true;
}
let mut satisfied_count = 0;
loop {
let Some(path) = self.try_assigning_new_item(capacity) else {
let valid = satisfied_count == self.ingredients.len();
let has_output = valid && output.is_some();
self.clear_visited();
self.satisfied.fill(false);
for g in 0..self.ingredients.len() {
for t in 0..self.items.len() {
let at = self.at(t, g);
if self.assigned[at] {
self.assigned[at] = false;
let key = self.items[t];
self.stacked.amounts[key] += capacity;
if has_output && let Some(out) = output.as_deref_mut() {
out.push(self.stacked.keys[key].clone());
}
break;
}
}
}
return valid;
};
let key = self.items[path[0]];
self.stacked.amounts[key] -= capacity;
self.satisfied[path[path.len() - 1]] = true;
satisfied_count += 1;
for i in 0..path.len() - 1 {
if i & 1 == 0 {
let at = self.at(path[i], path[i + 1]);
self.assigned[at] = true;
} else {
let at = self.at(path[i + 1], path[i]);
self.assigned[at] = false;
}
}
}
}
fn try_assigning_new_item(&mut self, capacity: i32) -> Option<Vec<usize>> {
self.clear_visited();
for t in 0..self.items.len() {
if self.stacked.amounts[self.items[t]] >= capacity
&& let Some(path) = self.find_path(t)
{
return Some(path);
}
}
None
}
fn find_path(&mut self, start: usize) -> Option<Vec<usize>> {
self.path.clear();
self.visited_item[start] = true;
self.path.push(start);
while !self.path.is_empty() {
let len = self.path.len();
if (len - 1) & 1 == 0 {
let item = self.path[len - 1];
for g in 0..self.ingredients.len() {
let at = self.at(item, g);
if !self.visited_ingredient[g] && self.connection[at] && !self.assigned[at] {
self.visited_ingredient[g] = true;
self.path.push(g);
break;
}
}
} else {
let ingredient = self.path[len - 1];
if !self.satisfied[ingredient] {
return Some(self.path.clone());
}
for t in 0..self.items.len() {
if !self.visited_item[t] && self.assigned[self.at(t, ingredient)] {
self.visited_item[t] = true;
self.path.push(t);
break;
}
}
}
if self.path.len() == len {
self.path.pop();
}
}
None
}
fn try_pick_all(&mut self, max_size: i32, output: Option<&mut Vec<Arc<str>>>) -> i32 {
let mut min = 0i32;
// Java int arithmetic: an empty ingredient list overflows as vanilla does.
let mut max = max_size
.min(self.stacked.upper_bound(&self.ingredients))
.wrapping_add(1);
loop {
let mid = min.wrapping_add(max) / 2;
if self.try_pick(mid, None) {
if max.wrapping_sub(min) <= 1 {
if mid > 0 {
self.try_pick(mid, output);
}
return mid;
}
min = mid;
} else {
max = mid;
}
}
}
}
/// `RecipeBookMenu.PostPlaceAction`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PostPlace {
Nothing,
/// The client shows the recipe as a ghost (`ClientboundPlaceGhostRecipePacket`).
Ghost,
}
/// The menu slots a placement works on.
struct Grid {
width: usize,
height: usize,
/// `inputGridSlots` and `slotsToClear` as menu slot indices.
inputs: Vec<usize>,
clear: Vec<usize>,
}
impl Menu {
fn place_grid(&self) -> Option<Grid> {
match self.kind {
Kind::Inventory => Some(Grid {
width: 2,
height: 2,
inputs: (1..5).collect(),
clear: (1..5).collect(),
}),
Kind::Crafting => Some(Grid {
width: 3,
height: 3,
inputs: (1..10).collect(),
clear: (1..10).collect(),
}),
Kind::Furnace(_) => Some(Grid {
width: 1,
height: 1,
inputs: vec![0],
clear: vec![0, 2],
}),
_ => None,
}
}
/// `Inventory.fillStackedContents` then the menu's
/// `fillCraftSlotsStackedContents`.
pub fn stacked_contents(&self, env: &Env) -> Stacked {
let mut stacked = Stacked::default();
for stack in self.containers[PLAYER][..36].iter().flatten() {
stacked.account_simple(stack, Self::max_stack(env, stack));
}
match self.kind {
// A furnace's SimpleContainer counts all three slots, unfiltered.
Kind::Furnace(_) => {
for stack in self.containers[MAIN].iter().flatten() {
stacked.account_stack(stack, Self::max_stack(env, stack));
}
}
_ => {
for stack in self.containers[GRID].iter().flatten() {
stacked.account_simple(stack, Self::max_stack(env, stack));
}
}
}
stacked
}
/// `RecipeBookMenu.handlePlacement` for the recipe `id`
/// (`ServerPlaceRecipe.placeRecipe`). `allow_drop` is the player being in
/// creative; `order` the iteration order of the counted items, if known.
pub fn place_recipe(
&mut self,
env: &Env,
id: &str,
use_max: bool,
allow_drop: bool,
order: Option<&[String]>,
) -> PostPlace {
let Some(grid) = self.place_grid() else {
return PostPlace::Nothing;
};
let Some(placement) = env.recipes.placement(id) else {
return PostPlace::Nothing;
};
if placement.impossible() {
return PostPlace::Nothing;
}
if !allow_drop && !self.test_clear_grid(env, &grid) {
return PostPlace::Nothing;
}
let mut stacked = self.stacked_contents(env);
if let Some(order) = order {
stacked.set_order(order);
}
let ingredients: Vec<&Ingredient> = placement.ingredients.iter().collect();
let post = if stacked.try_pick(&ingredients, 1, None) {
self.place(env, id, &grid, &placement, &mut stacked, use_max);
PostPlace::Nothing
} else {
self.clear_grid(env, &grid);
PostPlace::Ghost
};
// AbstractCraftingMenu.finishPlacingRecipe: the result follows the grid.
self.recompute(env);
post
}
/// `recipeMatches`: the recipe already fills the grid.
fn recipe_in_grid(&self, env: &Env, id: &str) -> bool {
match self.kind {
Kind::Furnace(_) => {
let name = id.trim_start_matches("minecraft:");
match (
env.recipes.cooking.iter().find(|c| c.id == name),
self.containers[MAIN][0].as_ref(),
) {
(Some(c), Some(input)) => c.ingredient.test(input),
_ => false,
}
}
_ => env
.recipes
.recipe_matches(id, &self.containers[GRID], self.grid_size),
}
}
fn place(
&mut self,
env: &Env,
id: &str,
grid: &Grid,
placement: &Placement,
stacked: &mut Stacked,
use_max: bool,
) {
let ingredients: Vec<&Ingredient> = placement.ingredients.iter().collect();
let matches = self.recipe_in_grid(env, id);
let biggest = stacked.try_pick_all(&ingredients, i32::MAX, None);
if matches {
for &s in &grid.inputs {
if let Some(stack) = self.slot(s)
&& (biggest.min(Self::max_stack(env, stack) as i32) as i64)
< i64::from(stack.count) + 1
{
return;
}
}
}
// calculateAmountToCraft
let amount = if use_max {
biggest
} else if matches {
let smallest = grid
.inputs
.iter()
.filter_map(|&s| self.slot(s))
.map(|s| s.count as i32)
.min();
smallest.map_or(i32::MAX, |n| n + 1)
} else {
1
};
let mut used = Vec::new();
if !stacked.try_pick(&ingredients, amount, Some(&mut used)) {
return;
}
// clampToMaxStackSize
let adjusted = used.iter().fold(amount, |n, item| {
n.min(env.items.get(item).map_or(1, |i| i.max_stack) as i32)
});
if adjusted != amount {
used.clear();
if !stacked.try_pick(&ingredients, adjusted, Some(&mut used)) {
return;
}
}
self.clear_grid(env, grid);
let (w, h) = placement.shaped.unwrap_or((grid.width, grid.height));
let slots: Vec<i32> = placement.slots.clone();
for (ingredient, index) in
crate::recipe_book::place_cells(grid.width, grid.height, w, h, &slots)
{
if ingredient == -1 {
continue;
}
let target = grid.inputs[index];
let item = used[ingredient as usize].clone();
let mut remaining = adjusted;
while remaining > 0 {
remaining = self.move_item_to_grid(target, &item, remaining);
if remaining == -1 {
break;
}
}
}
}
/// `moveItemToGrid`: the rest still to move, or -1 when nothing matches.
fn move_item_to_grid(&mut self, target: usize, item: &str, count: i32) -> i32 {
let existing = self.slot(target).cloned();
let found = (0..36).find(|&i| {
self.containers[PLAYER][i].as_ref().is_some_and(|s| {
&*s.item == item
&& usable_for_crafting(s)
&& existing
.as_ref()
.is_none_or(|e| e.same_item_same_components(s))
})
});
let Some(i) = found else {
return -1;
};
let cell = &mut self.containers[PLAYER][i];
let taken = match cell.as_mut() {
Some(have) if (count as u32) < have.count => split(have, count as u32),
_ => cell.take().expect("found"),
};
tidy(cell);
let taken_count = taken.count as i32;
let slot = self.slots[target];
match self.containers[slot.container][slot.index].as_mut() {
None => self.containers[slot.container][slot.index] = Some(taken),
Some(have) => have.count += taken.count,
}
count - taken_count
}
/// `clearGrid`: the slots to clear go back to the inventory (or drop),
/// then the grid empties (`clearCraftingContent`).
fn clear_grid(&mut self, env: &Env, grid: &Grid) {
for &s in &grid.clear {
let slot = self.slots[s];
if let Some(stack) = self.containers[slot.container][slot.index].clone() {
let mut copy = stack;
self.place_back(env, &mut copy);
}
}
match self.kind {
Kind::Furnace(_) => {
for &s in &grid.clear {
let slot = self.slots[s];
self.containers[slot.container][slot.index] = None;
}
}
_ => {
self.containers[GRID].fill(None);
self.containers[RESULT][0] = None;
}
}
}
/// `Inventory.placeItemBackInInventory`.
fn place_back(&mut self, env: &Env, stack: &mut ItemStack) {
while stack.count > 0 {
let slot = self
.slot_with_space(env, stack)
.or_else(|| (0..36).find(|&i| self.containers[PLAYER][i].is_none()));
let Some(slot) = slot else {
let dropped = std::mem::replace(
stack,
ItemStack {
count: 0,
..stack.clone()
},
);
self.drop_stack(&dropped);
break;
};
let have = self.containers[PLAYER][slot]
.as_ref()
.map_or(0, |s| s.count);
let space = Self::max_stack(env, stack).saturating_sub(have);
let mut part = split(stack, space);
self.inventory_add_at(env, slot, &mut part);
}
}
/// `Inventory.add(slot, stack)`.
fn inventory_add_at(&mut self, env: &Env, slot: usize, stack: &mut ItemStack) {
if stack.count == 0 {
return;
}
if Self::damageable(env, stack) && stack.damage > 0 {
self.containers[PLAYER][slot] = Some(stack.clone());
stack.count = 0;
return;
}
loop {
let last = stack.count;
// addResource(slot, stack)
let cell = self.containers[PLAYER][slot].get_or_insert_with(|| ItemStack {
count: 0,
..stack.clone()
});
let room = super::CONTAINER_MAX
.min(Self::max_stack(env, cell))
.saturating_sub(cell.count);
let add = stack.count.min(room);
cell.count += add;
stack.count -= add;
tidy(&mut self.containers[PLAYER][slot]);
if stack.count == 0 || stack.count >= last {
if stack.count == last && self.creative {
stack.count = 0;
}
return;
}
}
}
/// `testClearGrid`: whether the inventory can take the grid back.
fn test_clear_grid(&self, env: &Env, grid: &Grid) -> bool {
let mut free_slots: Vec<ItemStack> = Vec::new();
let free_in_inventory = self.containers[PLAYER][..36]
.iter()
.filter(|s| s.is_none())
.count();
for &s in &grid.inputs {
let Some(mut stack) = self.slot(s).cloned() else {
continue;
};
let with_space = self.slot_with_space(env, &stack);
if with_space.is_none() && free_slots.len() <= free_in_inventory {
for listed in &mut free_slots {
let max = Self::max_stack(env, listed);
if listed.item == stack.item
&& listed.count != max
&& listed.count + stack.count <= max
{
listed.count += stack.count;
stack.count = 0;
break;
}
}
if stack.count > 0 {
if free_slots.len() >= free_in_inventory {
return false;
}
free_slots.push(stack);
}
} else if with_space.is_none() {
return false;
}
}
true
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ing(items: &[&str]) -> Ingredient {
Ingredient(items.iter().map(|s| (*s).to_owned()).collect())
}
fn have(items: &[(&str, i32)]) -> Stacked {
let mut s = Stacked::default();
for (item, n) in items {
s.account(&Arc::from(*item), *n);
}
s
}
#[test]
fn a_single_item_can_fill_several_ingredients() {
let planks = ing(&["minecraft:oak_planks", "minecraft:birch_planks"]);
let reqs = [&planks, &planks, &planks, &planks];
let mut a = have(&[("minecraft:oak_planks", 2), ("minecraft:birch_planks", 2)]);
assert!(a.can_craft(&reqs));
// Two sets need 8 planks, but only 4 are there.
assert!(!a.try_pick(&reqs, 2, None));
assert_eq!(a.try_pick_all(&reqs, i32::MAX, None), 1);
assert_eq!(
have(&[("minecraft:oak_planks", 64)]).try_pick_all(&reqs, i32::MAX, None),
16
);
// Picking leaves the counts as they were.
assert!(a.try_pick(&reqs, 1, None));
assert!(a.can_craft(&reqs));
}
#[test]
fn the_matching_reassigns_flexible_ingredients() {
// The first ingredient takes either item, the second only the stick:
// the first item tried (the stick) moves over to free it.
let any = ing(&["minecraft:stick", "minecraft:bone"]);
let stick = ing(&["minecraft:stick"]);
let mut a = have(&[("minecraft:stick", 1), ("minecraft:bone", 1)]);
let mut used = Vec::new();
assert!(a.try_pick(&[&any, &stick], 1, Some(&mut used)));
assert_eq!(&*used[0], "minecraft:bone");
assert_eq!(&*used[1], "minecraft:stick");
assert!(!have(&[("minecraft:stick", 1)]).can_craft(&[&any, &stick]));
}
#[test]
fn the_order_decides_between_fitting_items() {
let planks = ing(&["minecraft:oak_planks", "minecraft:birch_planks"]);
let mut a = have(&[("minecraft:oak_planks", 4), ("minecraft:birch_planks", 4)]);
let mut used = Vec::new();
a.try_pick(&[&planks], 1, Some(&mut used));
assert_eq!(&*used[0], "minecraft:oak_planks");
a.set_order(&["minecraft:birch_planks".to_owned()]);
used.clear();
a.try_pick(&[&planks], 1, Some(&mut used));
assert_eq!(&*used[0], "minecraft:birch_planks");
}
#[test]
fn damaged_or_named_stacks_are_not_counted() {
let mut named = ItemStack::new("minecraft:stick", 4);
named.data_mut().custom_name = Some("x".into());
let mut damaged = ItemStack::new("minecraft:iron_sword", 1);
damaged.damage = 3;
let mut s = Stacked::default();
for stack in [&named, &damaged, &ItemStack::new("minecraft:stick", 2)] {
s.account_simple(stack, 64);
}
assert_eq!(s.keys().len(), 1);
assert!(s.can_craft(&[&ing(&["minecraft:stick"]), &ing(&["minecraft:stick"])]));
assert!(!s.can_craft(&[&ing(&["minecraft:stick"]); 3]));
}
}
+22 -166
View File
@@ -4,7 +4,7 @@
//! craftable stack), where a recipe goes in a grid (`PlaceRecipeHelper`) and
//! the book's saved settings.
use crate::{
crafting::{Ingredient, Recipe, Recipes},
crafting::{Ingredient, Placement, Recipe, Recipes},
items::{ItemStack, Items},
};
use horizon_world::nbt::Tag;
@@ -245,6 +245,9 @@ pub struct Collection {
#[derive(Default)]
pub struct Book {
pub entries: Vec<Entry>,
/// `Recipe.placementInfo` by recipe id: what the book's craftable test
/// and the server's placement look for.
pub placements: HashMap<String, Placement>,
/// Item id -> registry position, to order ingredient choices.
pub order: HashMap<String, usize>,
}
@@ -327,7 +330,15 @@ impl Book {
.enumerate()
.map(|(i, id)| (id.to_string(), i))
.collect();
Self { entries, order }
let placements = entries
.iter()
.filter_map(|e| Some((e.id.clone(), recipes.placement(&e.id)?)))
.collect();
Self {
entries,
placements,
order,
}
}
/// The unlocked recipes of one tab as collections (`ClientRecipeBook.rebuildCollections`).
pub fn collections(
@@ -380,6 +391,13 @@ impl Book {
Category::SmokerFood => BookType::Smoker,
})
}
/// `RecipeDisplayEntry.canCraft`: the recipe's placement ingredients can
/// all be found in `stock`.
pub fn can_craft(&self, entry: &Entry, stock: &crate::menu::place::Stacked) -> bool {
self.placements.get(&entry.id).is_some_and(|p| {
!p.impossible() && stock.can_craft(&p.ingredients.iter().collect::<Vec<_>>())
})
}
pub fn entry(&self, id: &str) -> Option<&Entry> {
self.entries.iter().find(|e| e.id == id)
}
@@ -419,125 +437,6 @@ impl Book {
}
}
/// `StackedItemContents`: simple stacks (undamaged, unenchanted, unnamed) by item.
#[derive(Clone, Debug, Default)]
pub struct Available {
pub counts: HashMap<String, u32>,
}
impl Available {
/// `accountSimpleStack`.
pub fn add(&mut self, stack: &ItemStack) {
if stack.count > 0
&& stack.damage == 0
&& stack.enchantments().is_empty()
&& stack.custom_name().is_none()
{
*self.counts.entry(stack.item.to_string()).or_default() += stack.count;
}
}
pub fn from_stacks<'a>(stacks: impl IntoIterator<Item = &'a ItemStack>) -> Self {
let mut a = Self::default();
for s in stacks {
a.add(s);
}
a
}
/// `StackedItemContents.canCraft(ingredients, null)`.
pub fn can_craft(&self, requirements: &[&Ingredient]) -> bool {
!requirements.is_empty() && pick(requirements, &self.counts, 1, &HashMap::new()).is_some()
}
/// `canCraft(recipe, amount, output)`: the item each ingredient uses when
/// `amount` sets can be made, preferring earlier registry items.
pub fn pick(
&self,
requirements: &[&Ingredient],
amount: u32,
order: &HashMap<String, usize>,
) -> Option<Vec<String>> {
pick(requirements, &self.counts, amount, order)
}
/// `getBiggestCraftableStack`: how many sets can be made, up to 99.
pub fn biggest_stack(&self, requirements: &[&Ingredient]) -> u32 {
if !self.can_craft(requirements) {
return 0;
}
let none = HashMap::new();
let (mut lo, mut hi) = (1u32, 99u32);
while lo < hi {
let mid = (lo + hi).div_ceil(2);
if pick(requirements, &self.counts, mid, &none).is_some() {
lo = mid;
} else {
hi = mid - 1;
}
}
lo
}
}
/// Bipartite assignment of one item to each ingredient where an item can
/// serve `count / amount` ingredients.
fn pick(
requirements: &[&Ingredient],
counts: &HashMap<String, u32>,
amount: u32,
order: &HashMap<String, usize>,
) -> Option<Vec<String>> {
let amount = amount.max(1);
let capacity = |item: &str| counts.get(item).copied().unwrap_or(0) / amount;
let candidates: Vec<Vec<String>> = requirements
.iter()
.map(|ing| {
let mut v: Vec<String> = ing.0.iter().filter(|i| capacity(i) > 0).cloned().collect();
v.sort_by_key(|i| (order.get(i).copied().unwrap_or(usize::MAX), i.clone()));
v
})
.collect();
let mut used: HashMap<String, Vec<usize>> = HashMap::new();
fn assign(
i: usize,
candidates: &[Vec<String>],
used: &mut HashMap<String, Vec<usize>>,
visited: &mut Vec<String>,
capacity: &dyn Fn(&str) -> u32,
) -> bool {
for item in &candidates[i] {
if visited.contains(item) {
continue;
}
visited.push(item.clone());
let holders = used.get(item).cloned().unwrap_or_default();
if (holders.len() as u32) < capacity(item) {
used.entry(item.clone()).or_default().push(i);
return true;
}
for j in holders {
if assign(j, candidates, used, visited, capacity) {
// j moved elsewhere: drop it from this item and take its place.
if let Some(list) = used.get_mut(item) {
list.retain(|x| *x != j);
list.push(i);
}
return true;
}
}
}
false
}
for i in 0..requirements.len() {
let mut visited = Vec::new();
if !assign(i, &candidates, &mut used, &mut visited, &capacity) {
return None;
}
}
let mut result = vec![String::new(); requirements.len()];
for (item, holders) in used {
for i in holders {
result[i] = item.clone();
}
}
Some(result)
}
/// The recipe book's saved state: the `recipeBook` compound of the player.
#[derive(Clone, Debug, Default)]
pub struct Settings {
@@ -602,11 +501,6 @@ mod tests {
fn ing(items: &[&str]) -> Ingredient {
Ingredient(items.iter().map(|s| (*s).to_owned()).collect())
}
fn have(items: &[(&str, u32)]) -> Available {
Available {
counts: items.iter().map(|(i, n)| ((*i).to_owned(), *n)).collect(),
}
}
#[test]
fn small_recipes_are_centred_in_the_grid() {
// One ingredient in a 3x3 grid goes to the middle cell.
@@ -631,46 +525,6 @@ mod tests {
assert_eq!(small, vec![0]);
}
#[test]
fn a_single_item_can_fill_several_ingredients() {
let planks = ing(&["minecraft:oak_planks", "minecraft:birch_planks"]);
let reqs = [&planks, &planks, &planks, &planks];
let a = have(&[("minecraft:oak_planks", 2), ("minecraft:birch_planks", 2)]);
assert!(a.can_craft(&reqs));
let none = HashMap::new();
// Two sets need 8 planks, but only 4 are there.
assert!(a.pick(&reqs, 2, &none).is_none());
assert!(a.pick(&reqs, 1, &none).is_some());
assert_eq!(a.biggest_stack(&reqs), 1);
assert_eq!(
have(&[("minecraft:oak_planks", 64)]).biggest_stack(&reqs),
16
);
}
#[test]
fn the_matching_reassigns_flexible_ingredients() {
// The first ingredient takes either item, the second only the stick:
// one stick must not be wasted on the first.
let any = ing(&["minecraft:stick", "minecraft:bone"]);
let stick = ing(&["minecraft:stick"]);
let a = have(&[("minecraft:stick", 1), ("minecraft:bone", 1)]);
let mut order = HashMap::new();
order.insert("minecraft:stick".to_owned(), 0);
order.insert("minecraft:bone".to_owned(), 1);
let picked = a.pick(&[&any, &stick], 1, &order).expect("matching");
assert_eq!(picked, vec!["minecraft:bone", "minecraft:stick"]);
assert!(!have(&[("minecraft:stick", 1)]).can_craft(&[&any, &stick]));
}
#[test]
fn damaged_or_named_stacks_are_not_counted() {
let mut named = ItemStack::new("minecraft:stick", 4);
named.data_mut().custom_name = Some("x".into());
let mut damaged = ItemStack::new("minecraft:iron_sword", 1);
damaged.damage = 3;
let a = Available::from_stacks([&named, &damaged, &ItemStack::new("minecraft:stick", 2)]);
assert_eq!(a.counts.get("minecraft:stick"), Some(&2));
assert!(!a.counts.contains_key("minecraft:iron_sword"));
}
#[test]
fn collections_group_recipes_of_a_category() {
let entry = |id: &str, group: Option<&str>, category| Entry {
id: id.into(),
@@ -686,6 +540,7 @@ mod tests {
entry("minecraft:c", None, Category::CraftingBuilding),
entry("minecraft:d", Some("planks"), Category::CraftingMisc),
],
placements: HashMap::new(),
order: HashMap::new(),
};
let unlocked: BTreeSet<String> = ["a", "b", "c", "d"]
@@ -713,6 +568,7 @@ mod tests {
display: Display::Shapeless(Vec::new()),
result: ItemStack::new("minecraft:stick", 4),
}],
placements: HashMap::new(),
order: HashMap::new(),
};
let lines = |s: &ItemStack| vec![format!("Item {}", s.item), "Stick".to_owned()];
@@ -0,0 +1,113 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.core.Holder;
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.world.entity.EntityEquipment;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.entity.player.StackedContents;
import net.minecraft.world.entity.player.StackedItemContents;
import net.minecraft.world.flag.FeatureFlags;
import net.minecraft.world.inventory.*;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.crafting.RecipeHolder;
import net.minecraft.world.item.crafting.RecipeManager;
/**
* Original oracle: the server side of a recipe book click. For each case a
* stand-in player (the menu oracle's) holds an inventory and opens the
* inventory, crafting table or a furnace menu with some grid contents; then
* RecipeBookMenu.handlePlacement (ServerPlaceRecipe) runs as
* ServerGamePacketListenerImpl.handlePlaceRecipe calls it, and every menu
* slot, the whole inventory, the drops and the post-place action are printed.
*
* The items available to the placement are kept in a hash map whose order
* follows identity hash codes; the order this run used (a replica built the
* same way iterates identically) goes to a second output for the Rust side.
*/
public final class VanillaPlaceRecipeOracle {
@SuppressWarnings("unchecked")
static List<String> order(Inventory inv, RecipeBookMenu menu) throws Exception {
StackedItemContents contents = new StackedItemContents();
inv.fillStackedContents(contents);
menu.fillCraftSlotsStackedContents(contents);
Field raw = StackedItemContents.class.getDeclaredField("raw");
raw.setAccessible(true);
StackedContents<Holder<Item>> stacked = (StackedContents<Holder<Item>>) raw.get(contents);
List<String> out = new ArrayList<>();
for (var entry : it.unimi.dsi.fastutil.objects.Reference2IntMaps.fastIterable(stacked.amounts)) {
out.add(entry.getKey().unwrapKey().orElseThrow().identifier().toString());
}
return out;
}
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;
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8));
var orders = new PrintWriter(Files.newBufferedWriter(Path.of(args[2]), StandardCharsets.UTF_8));
var lines = Files.lines(Path.of(args[0]))) {
for (String line : (Iterable<String>) lines::iterator) {
var f = JsonParser.parseString(line).getAsJsonObject();
List<String> order = List.of();
try {
VanillaMenuOracle.drops.clear();
var world = VanillaMenuOracle.make(VanillaMenuOracle.World.class);
world.server = VanillaMenuOracle.make(VanillaMenuOracle.Server.class);
var player = VanillaMenuOracle.make(VanillaMenuOracle.FakePlayer.class);
player.world = world;
player.creative = f.get("creative").getAsBoolean();
player.advancements = VanillaMenuOracle.make(net.minecraft.server.PlayerAdvancements.class);
VanillaMenuOracle.set(player.advancements, net.minecraft.server.PlayerAdvancements.class, "activeTriggers", new IdentityHashMap<>());
VanillaMenuOracle.set(player, ServerPlayer.class, "connection", VanillaMenuOracle.make(VanillaMenuOracle.Connection.class));
var inv = new Inventory(player, new EntityEquipment());
player.inv = inv;
for (var pair : f.getAsJsonArray("inventory")) {
var p = pair.getAsJsonArray();
inv.setItem(p.get(0).getAsInt(), ParityData.stack(p.get(1).getAsString()));
}
inv.setSelectedSlot(f.get("selected").getAsInt());
AbstractContainerMenu menu = VanillaMenuOracle.menu(f.get("menu").getAsString(), player, inv);
VanillaMenuOracle.set(player, Player.class, "containerMenu", menu);
if (menu instanceof InventoryMenu im) VanillaMenuOracle.set(player, Player.class, "inventoryMenu", im);
for (var pair : f.getAsJsonArray("grid")) {
var p = pair.getAsJsonArray();
menu.getSlot(p.get(0).getAsInt()).set(ParityData.stack(p.get(1).getAsString()));
}
VanillaMenuOracle.drops.clear();
RecipeBookMenu book = (RecipeBookMenu) menu;
order = order(inv, book);
RecipeHolder<?> recipe = recipes.byKey(ResourceKey.create(Registries.RECIPE, Identifier.parse(f.get("recipe").getAsString()))).orElseThrow();
String post = "-";
// ServerGamePacketListenerImpl.handlePlaceRecipe
if (!recipe.value().placementInfo().isImpossibleToPlace()) {
post = book.handlePlacement(f.get("max").getAsBoolean(), player.isCreative(), recipe, world, inv).name();
}
StringBuilder line2 = new StringBuilder("post " + post + " | ");
line2.append(VanillaMenuOracle.state(menu, inv)).append(" | inv");
for (int i = 0; i < 41; i++) line2.append(' ').append(ParityData.canon(inv.getItem(i)));
out.println(line2);
} catch (Throwable e) {
out.println("error-case " + e.getClass().getSimpleName());
if (System.getenv("MENU_TRACE") != null) e.printStackTrace();
}
orders.println(String.join(" ", order));
}
}
}
}
+184
View File
@@ -0,0 +1,184 @@
#!/usr/bin/env python3
"""Compare the server side of recipe book clicks with vanilla's ServerPlaceRecipe.
Each case opens the inventory, a crafting table or a furnace (smelting,
blasting, smoking) on a player whose inventory holds the items of a random
recipe of the book (shaped, shapeless, transmuting, dyeing, imbuing and
cooking recipes), with more or fewer than needed, damaged, enchanted and
renamed copies the book must not use, junk, and sometimes a nearly full
inventory; the grid is empty, holds the same recipe already (placing again
adds one set, or a full stack with shift) or something else. The Java oracle
(VanillaPlaceRecipeOracle) runs RecipeBookMenu.handlePlacement as the server's
packet handler does; examples/place_recipe_fixture runs
horizon_client::menu's place_recipe. Every menu slot, the whole inventory,
the drops and whether the client gets a ghost recipe are compared.
Vanilla counts the available items in a hash map ordered by identity hash
codes, an order that changes between runs and decides which of several
fitting items fills an ingredient; the oracle writes the order its run used
and the Rust side follows it.
"""
import argparse
import json
import random
try:
from . import interaction_lab as lib, test_crafter_parity as crafter
except ImportError:
import interaction_lab as lib
import test_crafter_parity as crafter
GRIDS = {'inventory': 2, 'crafting': 3}
COOKING = {'furnace': 'minecraft:smelting', 'blast_furnace': 'minecraft:blasting', 'smoker': 'minecraft:smoking'}
CRAFTING_TYPES = ('minecraft:crafting_shaped', 'minecraft:crafting_shapeless', 'minecraft:crafting_transmute',
'minecraft:crafting_dye', 'minecraft:crafting_imbue')
JUNK = ['minecraft:dirt', 'minecraft:stone', 'minecraft:diamond', 'minecraft:stick', 'minecraft:oak_planks',
'minecraft:apple', 'minecraft:feather', 'minecraft:coal', 'minecraft:iron_ingot', 'minecraft:cobblestone']
def stack(item, count, kind=None, rng=None):
comps = []
if kind == 'damaged':
comps.append('"minecraft:damage":%d' % rng.randrange(1, 30))
elif kind == 'enchanted':
comps.append('"minecraft:enchantments":{"minecraft:unbreaking":1}')
elif kind == 'named':
comps.append('"minecraft:custom_name":"x"')
body = ',components:{%s}' % ','.join(comps) if comps else ''
return '{id:"%s",count:%d%s}' % (item, count, body)
class Gen:
def __init__(self, rng, items, recipes):
self.rng = rng
self.items = items
self.recipes = recipes
self.by_type = {}
for name, r in recipes.recipes.items():
self.by_type.setdefault(r['type'], []).append(name)
def top(self, item):
return self.items.get(item, {}).get('minecraft:max_stack_size', 64)
def ingredients(self, r):
"""Each ingredient's item choices, as PlacementInfo lists them."""
t = r['type']
if t == 'minecraft:crafting_shaped':
return [self.recipes.choices(r['key'][ch]) for row in r['pattern'] for ch in row if ch != ' ']
if t == 'minecraft:crafting_shapeless':
return [self.recipes.choices(i) for i in r['ingredients']]
if t == 'minecraft:crafting_transmute':
n = r.get('material_count', {})
top = n.get('max', 1) if isinstance(n, dict) else n
return [self.recipes.choices(r['input'])] + [self.recipes.choices(r['material'])] * top
if t == 'minecraft:crafting_dye':
return [self.recipes.choices(r['target']), self.recipes.choices(r['dye'])]
if t == 'minecraft:crafting_imbue':
return [self.recipes.choices(r['material'])] * 8 + [self.recipes.choices(r['source'])]
return [self.recipes.choices(r['ingredient'])]
def fits(self, r, size):
t = r['type']
if t == 'minecraft:crafting_shaped':
return len(r['pattern']) <= size and max(len(row) for row in r['pattern']) <= size
return len(self.ingredients(r)) <= size * size
def case(self, menu):
rng = self.rng
if menu in COOKING:
name = rng.choice(self.by_type.get(COOKING[menu], []))
else:
size = GRIDS[menu]
pool = [n for t in CRAFTING_TYPES for n in self.by_type.get(t, [])]
for _ in range(50):
name = rng.choice(pool)
if self.fits(self.recipes.recipes[name], size):
break
r = self.recipes.recipes[name]
ingredients = self.ingredients(r)
inventory = {}
free = list(range(36))
rng.shuffle(free)
def put(item_stack):
if free:
inventory[free.pop()] = item_stack
for choices in ingredients:
if not choices or rng.random() < 0.08:
continue
for item in rng.sample(choices, min(len(choices), rng.choice([1, 1, 1, 2, 3]))):
top = self.top(item)
for _ in range(rng.choice([1, 1, 1, 2, 3])):
count = 1 if top == 1 else rng.choice([1, 1, 2, 3, 7, top, top - 1, rng.randrange(1, top + 1)])
kind = rng.choice([None] * 12 + ['damaged', 'enchanted', 'named'])
if kind == 'damaged' and not self.items.get(item, {}).get('minecraft:max_damage'):
kind = None
put(stack(item, max(1, count), kind, rng))
fill = rng.choice([0, 0, 3, 8, 30, 36])
for _ in range(fill):
item = rng.choice(JUNK)
put(stack(item, rng.choice([1, 16, 64, self.top(item)])))
if rng.random() < 0.15:
inventory[40] = stack(rng.choice(JUNK + [c[0] for c in ingredients if c]), rng.choice([1, 5, 64]))
grid = []
roll = rng.random()
if menu in COOKING:
if roll < 0.3:
grid.append([0, stack(rng.choice(ingredients[0]), rng.choice([1, 3, 64]))])
elif roll < 0.5:
grid.append([0, stack(rng.choice(JUNK), rng.choice([1, 64]))])
if rng.random() < 0.4:
grid.append([1, stack('minecraft:coal', rng.choice([1, 64]))])
if rng.random() < 0.4:
result = r['result']['id'] if isinstance(r['result'], dict) else r['result']
grid.append([2, stack(rng.choice([result, 'minecraft:stone']), rng.choice([1, 5, 64]))])
else:
size = GRIDS[menu]
if roll < 0.35:
# The same recipe already in the grid (a placed or crafted set).
cells = self.recipes.grid(rng, name) if size == 3 else None
if cells is None:
cells = [None] * 9
for i, choices in enumerate(ingredients[:size * size]):
if choices:
cells[(i // size) * 3 + i % size] = rng.choice(choices).split(':')[1]
for i, cell in enumerate(cells):
x, y = i % 3, i // 3
if cell and x < size and y < size:
item = 'minecraft:' + cell
grid.append([1 + x + y * size, stack(item, rng.choice([1, 1, 2, 5, self.top(item)]))])
elif roll < 0.6:
for i in range(size * size):
if rng.random() < 0.4:
grid.append([1 + i, stack(rng.choice(JUNK), rng.choice([1, 3, 64]))])
return {'menu': menu, 'recipe': 'minecraft:' + name, 'max': rng.random() < 0.5, 'creative': rng.random() < 0.2,
'selected': rng.randrange(9), 'inventory': sorted([k, v] for k, v in inventory.items()), 'grid': grid}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--seed', type=int, default=11)
parser.add_argument('--cases', type=int, default=6000)
parser.add_argument('--limit', type=int, default=3)
args = parser.parse_args()
work = lib.work_dir('place-recipe-parity')
vanilla = lib.Vanilla(work)
vanilla.compile('ParityData', 'VanillaMenuOracle', 'VanillaPlaceRecipeOracle')
items = json.loads((lib.RESOURCES / 'items.json').read_text())
gen = Gen(random.Random(args.seed), items, crafter.Recipes(lib.RESOURCES))
menus = ['inventory', 'crafting', 'crafting', 'furnace', 'blast_furnace', 'smoker']
cases = [gen.case(menus[n % len(menus)]) for n in range(args.cases)]
(work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases))
vanilla.run('VanillaPlaceRecipeOracle', work / 'cases.jsonl', work / 'native.txt', work / 'orders.txt')
lib.cargo_example('horizon-client', 'place_recipe_fixture', lib.RESOURCES, work / 'cases.jsonl', work / 'orders.txt',
work / 'rust.txt')
bad = lib.compare(cases, work / 'native.txt', work / 'rust.txt',
lambda case, line: f'{case["menu"]} {line.split(" ")[1] if line.startswith("post") else "error"}',
limit=args.limit)
errors = sum(1 for line in (work / 'native.txt').read_text().splitlines() if line.startswith('error-case'))
if errors:
print(f'{errors} oracle errors')
raise SystemExit(1 if bad or errors else 0)
if __name__ == '__main__':
main()