From 7bd28cc6f117732376e30853885facc84e65e337 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 07:13:50 +0200 Subject: [PATCH] Port the cauldron item interactions and test them against vanilla Using a bucket, bottle, water potion, dyed armour, patterned banner or dyed shulker box on an empty, water, lava or powder snow cauldron follows CauldronInteractions, including the creative-mode stack rules of ItemUtils.createFilledResult and the underwater refusal for lava and powder snow. A harness runs every item against every cauldron state in vanilla's own useItemOn and compares the result, block writes, sounds, drops and inventory. Co-Authored-By: Claude Sonnet 5.5 --- .../examples/cauldron_fixture.rs | 132 +++++++++ crates/horizon-client/src/cauldron.rs | 271 ++++++++++++++++++ crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/menu.rs | 17 ++ .../parity/VanillaCauldronOracle.java | 168 +++++++++++ tools/test_cauldron_parity.py | 81 ++++++ 6 files changed, 670 insertions(+) create mode 100644 crates/horizon-client/examples/cauldron_fixture.rs create mode 100644 crates/horizon-client/src/cauldron.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCauldronOracle.java create mode 100644 tools/test_cauldron_parity.py diff --git a/crates/horizon-client/examples/cauldron_fixture.rs b/crates/horizon-client/examples/cauldron_fixture.rs new file mode 100644 index 000000000..3b8014410 --- /dev/null +++ b/crates/horizon-client/examples/cauldron_fixture.rs @@ -0,0 +1,132 @@ +//! Cauldron interactions for tools/test_cauldron_parity.py: reads one JSON +//! case per line and prints "result TAB events TAB inventory". +//! +//! usage: cauldron_fixture RESOURCES INPUT OUTPUT +use horizon_client::{ + cauldron::{Outcome, Player, interact}, + crafting::Recipes, + item_data::{canon_stack, parse_stack}, + items::{ItemStack, Items}, + menu::{Env, Kind, Menu}, +}; +use horizon_world::chunk::BlockState; +use serde_json::Value; +use std::{fs, path::Path}; + +struct Stand<'a> { + menu: Menu, + env: &'a Env<'a>, + events: Vec, + hand: Option, +} + +impl Player for Stand<'_> { + fn creative(&self) -> bool { + self.menu.creative + } + fn hand(&mut self) -> &mut Option { + &mut self.hand + } + fn add(&mut self, stack: &mut ItemStack) -> bool { + // The held stack lives in inventory slot 0 for Inventory.add. + self.menu.set_player_item(0, self.hand.take()); + let added = self.menu.give(self.env, stack); + self.hand = self.menu.player_item(0).cloned(); + self.menu.set_player_item(0, None); + added + } + fn contains(&self, stack: &ItemStack) -> bool { + self.menu.player_contains(stack) + || self + .hand + .as_ref() + .is_some_and(|h| h.same_item_same_components(stack)) + } + fn drop_stack(&mut self, stack: ItemStack) { + self.events + .push(format!("drop {}", canon_stack(Some(&stack)))); + } +} + +fn parse(text: &str) -> BlockState { + let (name, props) = text.split_once('|').unwrap_or((text, "")); + BlockState { + name: name.to_owned(), + properties: props + .split(',') + .filter(|p| !p.is_empty()) + .filter_map(|p| p.split_once('=')) + .map(|(k, v)| (k.to_owned(), v.to_owned())) + .collect(), + } +} + +fn describe(state: &BlockState) -> String { + let props: Vec = state + .properties + .iter() + .map(|(k, v)| format!("{k}={v}")) + .collect(); + format!("{}|{}", state.name, props.join(",")) +} + +fn main() -> horizon_client::Result<()> { + let args: Vec = std::env::args().collect(); + let root = Path::new(args.get(1).ok_or("usage: cauldron_fixture RESOURCES INPUT OUTPUT")?); + let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?; + let items = Items::catalog(root)?; + let recipes = Recipes::load(root, &items)?; + let env = Env { + items: &items, + recipes: &recipes, + }; + let mut out = String::new(); + for line in input.lines() { + let case: Value = serde_json::from_str(line)?; + let mut menu = Menu::new(Kind::Inventory); + menu.creative = case["creative"].as_bool().unwrap_or(false); + 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("-"))?, + ); + } + let held = parse_stack(case["held"].as_str().unwrap_or("-"))?; + let mut stand = Stand { + menu, + env: &env, + events: Vec::new(), + hand: held, + }; + let cauldron = parse(case["state"].as_str().unwrap_or_default()); + let result = interact( + &items, + &cauldron, + case["under_water"].as_bool().unwrap_or(false), + &mut stand, + ); + if let Some(block) = &result.block { + stand.events.push(format!("set {}", describe(block))); + } + if let Some(sound) = result.sound { + stand.events.push(format!("sound {sound}")); + } + let kind = match result.outcome { + Outcome::Success => "success", + Outcome::Consume => "consume", + Outcome::Pass => "pass", + }; + stand.menu.set_player_item(0, stand.hand.take()); + let inventory: Vec = (0..41) + .filter_map(|i| { + stand + .menu + .player_item(i) + .map(|s| format!("{i}={}", canon_stack(Some(s)))) + }) + .collect(); + out += &format!("{kind}\t{}\t{}\n", stand.events.join(";"), inventory.join(" ")); + } + fs::write(args.get(3).ok_or("missing OUTPUT")?, out)?; + Ok(()) +} diff --git a/crates/horizon-client/src/cauldron.rs b/crates/horizon-client/src/cauldron.rs new file mode 100644 index 000000000..6ab4fb5c3 --- /dev/null +++ b/crates/horizon-client/src/cauldron.rs @@ -0,0 +1,271 @@ +//! `CauldronInteractions`: what an item does to an empty, water, lava or +//! powder snow cauldron. `tools/test_cauldron_parity.py` compares every item +//! with vanilla's `useItemOn`. +use crate::items::{ItemStack, Items}; +use horizon_world::chunk::BlockState; + +/// The player side of an interaction. +pub trait Player { + fn creative(&self) -> bool; + /// The stack in the interacting hand. + fn hand(&mut self) -> &mut Option; + /// `Inventory.add`; the leftover stays in `stack`. + fn add(&mut self, stack: &mut ItemStack) -> bool; + /// `Inventory.contains`. + fn contains(&self, stack: &ItemStack) -> bool; + fn drop_stack(&mut self, stack: ItemStack); +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Outcome { + /// `InteractionResult.SUCCESS` + Success, + /// `InteractionResult.CONSUME` + Consume, + /// `TRY_WITH_EMPTY_HAND` + Pass, +} + +#[derive(Debug)] +pub struct Interaction { + pub outcome: Outcome, + /// The cauldron's new state. + pub block: Option, + pub sound: Option<&'static str>, +} + +fn state(name: &str, level: Option) -> BlockState { + BlockState { + name: name.to_owned(), + properties: level + .map(|l| ("level".to_owned(), l.to_string())) + .into_iter() + .collect(), + } +} + +fn pass() -> Interaction { + Interaction { + outcome: Outcome::Pass, + block: None, + sound: None, + } +} + +/// `ItemUtils.createFilledResult`. +fn filled(player: &mut dyn Player, new: ItemStack, limit_creative: bool) { + let creative = player.creative(); + if limit_creative && creative { + if !player.contains(&new) { + let mut new = new; + player.add(&mut new); + } + return; + } + let hand = player.hand(); + if !creative && let Some(held) = hand.as_mut() { + held.count -= 1; + if held.count == 0 { + *hand = None; + } + } + if hand.is_none() { + *hand = Some(new); + return; + } + let mut new = new; + if !player.add(&mut new) { + player.drop_stack(new); + } +} + +/// `LayeredCauldronBlock.lowerFillLevel`. +fn lowered(cauldron: &BlockState) -> BlockState { + let level: u8 = cauldron.properties.get("level").and_then(|l| l.parse().ok()).unwrap_or(1); + if level <= 1 { + state("minecraft:cauldron", None) + } else { + let mut next = cauldron.clone(); + next.properties.insert("level".into(), (level - 1).to_string()); + next + } +} + +fn changed(block: BlockState, sound: Option<&'static str>) -> Interaction { + Interaction { + outcome: Outcome::Success, + block: Some(block), + sound, + } +} + +const COLORS: [&str; 16] = [ + "white", "orange", "magenta", "light_blue", "yellow", "lime", "pink", "gray", "light_gray", "cyan", + "purple", "blue", "brown", "green", "red", "black", +]; + +/// The cauldron interaction of the held item (`useItemOn`); the hand stack is +/// changed through `player`. +pub fn interact( + items: &Items, + cauldron: &BlockState, + under_water: bool, + player: &mut dyn Player, +) -> Interaction { + let Some(held) = player.hand().clone() else { + return pass(); + }; + let kind = match cauldron.name.as_str() { + "minecraft:cauldron" => "empty", + "minecraft:water_cauldron" => "water", + "minecraft:lava_cauldron" => "lava", + "minecraft:powder_snow_cauldron" => "powder_snow", + _ => return pass(), + }; + let level: u8 = cauldron.properties.get("level").and_then(|l| l.parse().ok()).unwrap_or(0); + let item = &*held.item; + let water_potion = held.data().and_then(|d| d.potion.as_deref()) == Some("minecraft:water"); + // Dispatcher.get: tags first, then the item map. + if kind == "water" + && items + .item_tags + .get("minecraft:cauldron_can_remove_dye") + .is_some_and(|members| members.contains(item)) + { + if held.data().and_then(|d| d.dyed_color).is_none() { + return pass(); + } + if let Some(stack) = player.hand().as_mut() { + stack.data_mut().dyed_color = None; + stack.tidy(); + } + return changed(lowered(cauldron), None); + } + let fill_bucket = |player: &mut dyn Player, new: &str, can_fill: bool, sound| { + if !can_fill { + return pass(); + } + filled(player, ItemStack::new(new, 1), true); + changed(state("minecraft:cauldron", None), Some(sound)) + }; + let empty_bucket = |player: &mut dyn Player, block: BlockState, sound| { + filled(player, ItemStack::new("minecraft:bucket", 1), true); + changed(block, Some(sound)) + }; + match item { + "minecraft:lava_bucket" => { + return if under_water { + Interaction { + outcome: Outcome::Consume, + block: None, + sound: None, + } + } else { + empty_bucket( + player, + state("minecraft:lava_cauldron", None), + "minecraft:item.bucket.empty_lava", + ) + }; + } + "minecraft:water_bucket" => { + return empty_bucket( + player, + state("minecraft:water_cauldron", Some(3)), + "minecraft:item.bucket.empty", + ); + } + "minecraft:powder_snow_bucket" => { + return if under_water { + Interaction { + outcome: Outcome::Consume, + block: None, + sound: None, + } + } else { + empty_bucket( + player, + state("minecraft:powder_snow_cauldron", Some(3)), + "minecraft:item.bucket.empty_powder_snow", + ) + }; + } + _ => {} + } + match (kind, item) { + ("empty", "minecraft:potion") => { + if !water_potion { + return pass(); + } + filled(player, ItemStack::new("minecraft:glass_bottle", 1), true); + changed( + state("minecraft:water_cauldron", Some(1)), + Some("minecraft:item.bottle.empty"), + ) + } + ("water", "minecraft:bucket") => fill_bucket( + player, + "minecraft:water_bucket", + level == 3, + "minecraft:item.bucket.fill", + ), + ("water", "minecraft:glass_bottle") => { + filled( + player, + ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"), + true, + ); + changed(lowered(cauldron), Some("minecraft:item.bottle.fill")) + } + ("water", "minecraft:potion") => { + if level == 3 || !water_potion { + return pass(); + } + filled(player, ItemStack::new("minecraft:glass_bottle", 1), true); + let mut next = cauldron.clone(); + // BlockState.cycle on a 1..=3 property + next.properties + .insert("level".into(), (level % 3 + 1).to_string()); + changed(next, Some("minecraft:item.bottle.empty")) + } + ("water", name) + if name + .strip_prefix("minecraft:") + .and_then(|n| n.strip_suffix("_banner")) + .is_some_and(|c| COLORS.contains(&c)) => + { + let layers = held.data().map_or(0, |d| d.banner_patterns.len()); + if layers == 0 { + return pass(); + } + let mut cleaned = held.clone(); + cleaned.count = 1; + cleaned.data_mut().banner_patterns.pop(); + cleaned.tidy(); + filled(player, cleaned, false); + changed(lowered(cauldron), None) + } + ("water", name) + if name + .strip_prefix("minecraft:") + .and_then(|n| n.strip_suffix("_shulker_box")) + .is_some_and(|c| COLORS.contains(&c)) => + { + filled(player, held.transmute("minecraft:shulker_box", 1), false); + changed(lowered(cauldron), None) + } + ("lava", "minecraft:bucket") => fill_bucket( + player, + "minecraft:lava_bucket", + true, + "minecraft:item.bucket.fill_lava", + ), + ("powder_snow", "minecraft:bucket") => fill_bucket( + player, + "minecraft:powder_snow_bucket", + level == 3, + "minecraft:item.bucket.fill_powder_snow", + ), + _ => pass(), + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index ca2783d1d..594064c90 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -14,6 +14,7 @@ pub mod block_transform; pub mod blocks; pub mod bossbar; pub mod brewing; +pub mod cauldron; pub mod chat; pub mod chunk; pub mod clock; diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs index 5190cf16f..071d13be4 100644 --- a/crates/horizon-client/src/menu.rs +++ b/crates/horizon-client/src/menu.rs @@ -278,6 +278,23 @@ impl Menu { self.containers[PLAYER][i].as_ref() } + pub fn set_player_item(&mut self, i: usize, stack: Option) { + self.containers[PLAYER][i] = stack; + } + + /// `Inventory.add`: the leftover stays in `stack`. + pub fn give(&mut self, env: &Env, stack: &mut ItemStack) -> bool { + self.inventory_add(env, stack) + } + + /// `Inventory.contains(stack)`. + pub fn player_contains(&self, stack: &ItemStack) -> bool { + self.containers[PLAYER] + .iter() + .flatten() + .any(|have| have.same_item_same_components(stack)) + } + // ---- item helpers ---- fn max_stack(env: &Env, stack: &ItemStack) -> u32 { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCauldronOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCauldronOracle.java new file mode 100644 index 000000000..3c1b5dc04 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaCauldronOracle.java @@ -0,0 +1,168 @@ +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.BlockPos; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.resources.Identifier; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.InteractionHand; +import net.minecraft.world.InteractionResult; +import net.minecraft.world.entity.EntityEquipment; +import net.minecraft.world.entity.EquipmentSlot; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.entity.item.ItemEntity; +import net.minecraft.world.entity.player.Inventory; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.flag.FeatureFlags; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.block.AbstractCauldronBlock; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.block.state.properties.Property; +import net.minecraft.world.level.material.FluidState; +import net.minecraft.world.level.material.Fluids; + +/** + * Original oracle: a cauldron's useItemOn (CauldronInteractions) with a + * recording stand-in level and player. Each case line is JSON: cauldron state + * ("name|prop=value"), the held stack, creative, whether water is above. The + * output line lists the result, block writes, sounds, the final inventory and + * drops. + */ +public final class VanillaCauldronOracle { + static Object unsafe; + static java.lang.reflect.Method allocate; + static final List events = new ArrayList<>(); + static boolean underWater; + + @SuppressWarnings("unchecked") + static T make(Class type) { + try { + return (T) allocate.invoke(unsafe, type); + } catch (Exception e) { + throw new AssertionError(e); + } + } + + static void set(Object target, Class owner, String name, Object value) throws Exception { + Field f = owner.getDeclaredField(name); + f.setAccessible(true); + f.set(target, value); + } + + static String describe(BlockState state) { + StringBuilder out = new StringBuilder(BuiltInRegistries.BLOCK.getKey(state.getBlock()).toString()).append('|'); + List> props = new ArrayList<>(state.getProperties()); + props.sort(Comparator.comparing(Property::getName)); + boolean first = true; + for (Property p : props) { + out.append(first ? "" : ",").append(p.getName()).append('=').append(name(state, p)); + first = false; + } + return out.toString(); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + static String name(BlockState state, Property p) { + return p.getName(state.getValue(p)); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + static BlockState parse(String text) { + String[] parts = text.split("\\|", -1); + Block block = BuiltInRegistries.BLOCK.getValue(Identifier.parse(parts[0])); + BlockState state = block.defaultBlockState(); + if (!parts[1].isEmpty()) { + for (String kv : parts[1].split(",")) { + String[] pair = kv.split("="); + Property p = block.getStateDefinition().getProperty(pair[0]); + state = state.setValue(p, (Comparable) p.getValue(pair[1]).orElseThrow()); + } + } + return state; + } + + static final class World extends ServerLevel { + World() { + super(null, null, null, null, null, null, false, 0L, List.of(), false); + } + @Override public boolean isClientSide() { return false; } + @Override public boolean setBlock(BlockPos pos, BlockState state, int flags, int limit) { events.add("set " + describe(state)); return true; } + @Override public FluidState getFluidState(BlockPos pos) { return underWater ? Fluids.WATER.defaultFluidState() : Fluids.EMPTY.defaultFluidState(); } + @Override public void playSound(net.minecraft.world.entity.Entity p, double x, double y, double z, net.minecraft.sounds.SoundEvent s, net.minecraft.sounds.SoundSource c, float v, float pitch) { + events.add("sound " + BuiltInRegistries.SOUND_EVENT.getKey(s)); + } + @Override public void gameEvent(net.minecraft.core.Holder e, net.minecraft.world.phys.Vec3 p, net.minecraft.world.level.gameevent.GameEvent.Context c) { } + @Override public net.minecraft.core.RegistryAccess registryAccess() { return ParityData.access; } + @Override public net.minecraft.world.flag.FeatureFlagSet enabledFeatures() { return FeatureFlags.DEFAULT_FLAGS; } + } + + static final class FakePlayer extends ServerPlayer { + boolean creative; + Inventory inv; + FakePlayer() { + super(null, null, null, null); + } + @Override public Inventory getInventory() { return inv; } + @Override public boolean hasInfiniteMaterials() { return creative; } + @Override public boolean isCreative() { return creative; } + @Override public void setItemInHand(InteractionHand hand, ItemStack stack) { inv.setItem(0, stack); } + @Override public ItemStack getItemInHand(InteractionHand hand) { return inv.getItem(0); } + @Override public void awardStat(net.minecraft.stats.Stat stat, int count) { } + @Override public ItemEntity drop(ItemStack stack, boolean thrown, net.minecraft.util.Prediction p) { + if (!stack.isEmpty()) events.add("drop " + ParityData.canon(stack)); + return null; + } + } + + public static void main(String[] args) throws Exception { + ParityData.init(); + var field = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe"); + field.setAccessible(true); + unsafe = field.get(null); + allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); + 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) lines::iterator) { + var f = JsonParser.parseString(line).getAsJsonObject(); + try { + events.clear(); + underWater = f.get("under_water").getAsBoolean(); + var world = make(World.class); + var player = make(FakePlayer.class); + player.creative = f.get("creative").getAsBoolean(); + player.inv = new Inventory(player, new EntityEquipment()); + for (var other : f.getAsJsonArray("inventory")) { + var pair = other.getAsJsonArray(); + player.inv.setItem(pair.get(0).getAsInt(), ParityData.stack(pair.get(1).getAsString())); + } + ItemStack held = ParityData.stack(f.get("held").getAsString()); + player.inv.setItem(0, held); + BlockState state = parse(f.get("state").getAsString()); + var cauldron = (AbstractCauldronBlock) state.getBlock(); + var use = net.minecraft.world.level.block.state.BlockBehaviour.class.getDeclaredMethod("useItemOn", ItemStack.class, BlockState.class, + net.minecraft.world.level.Level.class, BlockPos.class, Player.class, InteractionHand.class, net.minecraft.world.phys.BlockHitResult.class); + use.setAccessible(true); + InteractionResult result = (InteractionResult) use.invoke(cauldron, held, state, world, BlockPos.ZERO, player, InteractionHand.MAIN_HAND, null); + String kind = result == InteractionResult.SUCCESS ? "success" : result == InteractionResult.CONSUME ? "consume" + : result == InteractionResult.TRY_WITH_EMPTY_HAND ? "pass" : result.toString(); + StringBuilder inventory = new StringBuilder(); + for (int i = 0; i < 41; i++) { + ItemStack s = player.inv.getItem(i); + if (!s.isEmpty()) inventory.append(i).append('=').append(ParityData.canon(s)).append(' '); + } + out.println(kind + "\t" + String.join(";", events) + "\t" + inventory.toString().trim()); + } catch (Throwable e) { + out.println("error " + e.getClass().getSimpleName() + " " + e.getMessage()); + if (System.getenv("CAULDRON_TRACE") != null) e.printStackTrace(); + } + } + } + } +} diff --git a/tools/test_cauldron_parity.py b/tools/test_cauldron_parity.py new file mode 100644 index 000000000..f815d0cac --- /dev/null +++ b/tools/test_cauldron_parity.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +"""Compare cauldron item interactions with vanilla's CauldronInteractions. + +The Java oracle (VanillaCauldronOracle) calls the cauldron block's useItemOn +with a recording level and player; the Rust example (cauldron_fixture) runs +horizon_client::cauldron. Every item is used on every cauldron state (empty, +water, lava and powder snow at each level), with water potions, dyed armour, +patterned banners and shulker boxes, in survival and creative, under water or +not, and with a crowded inventory. The result, block writes, sounds, drops and +the final inventory are compared. +""" +import argparse +import json +import random +try: + from . import interaction_lab as lib, lab +except ImportError: + import interaction_lab as lib + import lab + +STATES = ['minecraft:cauldron|', 'minecraft:water_cauldron|level=1', 'minecraft:water_cauldron|level=2', + 'minecraft:water_cauldron|level=3', 'minecraft:lava_cauldron|', 'minecraft:powder_snow_cauldron|level=1', + 'minecraft:powder_snow_cauldron|level=3'] +DYES = ['white', 'orange', 'magenta', 'light_blue', 'yellow', 'lime', 'pink', 'gray', 'light_gray', 'cyan', 'purple', + 'blue', 'brown', 'green', 'red', 'black'] + + +def snbt(item, count=1, **components): + body = ','.join('"minecraft:%s":%s' % (k, v) for k, v in sorted(components.items())) + return '{id:"%s",count:%d%s}' % (item, count, ',components:{%s}' % body if body else '') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--seed', type=int, default=7) + parser.add_argument('--limit', type=int, default=4) + args = parser.parse_args() + work = lib.work_dir('cauldron-parity') + vanilla = lib.Vanilla(work) + vanilla.compile('ParityData', 'VanillaCauldronOracle') + items = json.loads((lib.RESOURCES / 'items.json').read_text()) + patterns = sorted('minecraft:' + p.stem for p in (lib.RESOURCES / 'data/minecraft/banner_pattern').glob('*.json')) + rng = random.Random(args.seed) + held = [] + for name, info in items.items(): + if name == 'minecraft:air': + continue + top = info.get('minecraft:max_stack_size', 64) + held.append(snbt(name, 1)) + held.append(snbt(name, rng.randrange(1, top + 1))) + for color in DYES: + for layers in range(0, 4): + body = '[%s]' % ','.join('{pattern:"%s",color:"%s"}' % (rng.choice(patterns), rng.choice(DYES)) for _ in range(layers)) + held.append(snbt('minecraft:%s_banner' % color, rng.choice([1, 3]), banner_patterns=body)) + held.append(snbt('minecraft:%s_shulker_box' % color, rng.choice([1, 2]))) + for item in ['leather_helmet', 'leather_chestplate', 'leather_leggings', 'leather_boots', 'leather_horse_armor', 'wolf_armor']: + held.append(snbt('minecraft:' + item, 1, dyed_color=rng.randrange(1 << 24))) + for potion in ['minecraft:water', 'minecraft:healing', 'minecraft:awkward']: + for item in ['potion', 'splash_potion', 'lingering_potion']: + held.append(snbt('minecraft:' + item, rng.choice([1, 2]), potion_contents='{potion:"%s"}' % potion)) + cases = [] + filler = [snbt(i, 64) for i in ['minecraft:stone', 'minecraft:dirt', 'minecraft:cobblestone']] + for state in STATES: + for stack in held: + crowded = rng.random() < 0.25 + inventory = [[i, rng.choice(filler)] for i in range(1, 36)] if crowded else [] + if not crowded and rng.random() < 0.3: + inventory = [[rng.randrange(1, 36), snbt('minecraft:bucket', rng.randrange(1, 16))]] + cases.append({'state': state, 'held': stack, 'creative': rng.random() < 0.3, 'under_water': rng.random() < 0.3, + 'inventory': inventory}) + (work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases)) + vanilla.run('VanillaCauldronOracle', work / 'cases.jsonl', work / 'native.txt') + lib.cargo_example('horizon-client', 'cauldron_fixture', lib.RESOURCES, work / 'cases.jsonl', work / 'rust.txt') + total = lib.compare(cases, work / 'native.txt', work / 'rust.txt', + lambda case, line: case['state'].split('|')[0] + ' ' + line.split('\t')[0], + lambda case: json.dumps(case)[:700], args.limit) + raise SystemExit(1 if total else 0) + + +if __name__ == '__main__': + main()