Merge pull request #115 from ludovic111/fix/sweet-berries-93

Sweet berries can be planted; picking and bone meal work
This commit is contained in:
Ludovic Marie
2026-10-14 18:04:47 +02:00
committed by GitHub
8 changed files with 423 additions and 27 deletions
+48 -27
View File
@@ -519,6 +519,13 @@ impl LevelAccess for GameLevel<'_> {
effect: PlayerEffect::DropItem(item),
..
} => self.pop_above(pos, item),
// Picking a sweet berry bush or cave vines: the harvest loot,
// popped before the pick sound draws its pitch.
LevelEvent::Player {
pos,
state,
effect: PlayerEffect::InteractLoot(table),
} => self.drop_interact_loot(pos, state, table),
event => self.events.push(event),
}
}
@@ -2109,14 +2116,16 @@ impl Game<'_> {
game_master: false,
};
let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
let item = held.as_ref().map(|s| s.item.to_string());
let result = self.with_level(|b, level, ticks| {
b.use_without_item(
b.use_item_on(
level,
ticks,
BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
face,
at,
player,
item.as_deref(),
)
});
self.process_level_events()?;
@@ -2158,14 +2167,10 @@ impl Game<'_> {
}
return Ok(());
}
if info.food.is_some()
&& let Some(p) = self.player.as_ref()
&& (p.health.food.food < 20 || self.creative)
{
// Consumable.startConsuming: held right click for consume_seconds.
if self.using.is_none() {
self.using = Some((self.selected, 0));
}
// Food that is also a block item (berries, carrots, potatoes) aimed at
// a block tries to place first: BlockItem.useOn eats only when the
// placement fails.
if !(info.block.is_some() && self.pick().is_some()) && self.start_eating(&info) {
return Ok(());
}
if self.use_bone_meal(&stack)? || self.ignite_tnt(&stack)? {
@@ -2198,6 +2203,8 @@ impl Game<'_> {
return Ok(());
}
if !self.may_build() {
// ItemStack.useOn passes in adventure mode; useItem eats.
self.start_eating(&info);
return Ok(());
}
let face = match hit.face {
@@ -2223,6 +2230,11 @@ impl Game<'_> {
let outcome = self.with_level(|b, level, ticks| b.place_block(level, ticks, &ctx));
let PlaceOutcome::Placed { pos, state } = outcome else {
self.process_level_events()?;
// BlockItem.useOn: a consumable that could not be placed is used,
// which ItemStack.useOn counts as a use of the item.
if self.start_eating(&info) {
self.stats.add("used", &stack.item, 1);
}
return Ok(());
};
let target = [pos.x, pos.y, pos.z];
@@ -2239,25 +2251,18 @@ impl Game<'_> {
}
}
self.swing_arm();
let sounds = self.res.facts.get(state).sounds.clone();
let center = [
f64::from(target[0]) + 0.5,
f64::from(target[1]) + 0.5,
f64::from(target[2]) + 0.5,
];
// SolidBucketItem.getPlaceSound: the bucket's own empty sound.
// BlockItem.place's sound is among the level events;
// SolidBucketItem.getPlaceSound replaces it with the bucket's own.
let solid_bucket = &*stack.item == "minecraft:powder_snow_bucket";
let place_sound = if solid_bucket {
"minecraft:item.bucket.empty_powder_snow"
} else {
&sounds.place
};
self.audio.play(
place_sound,
Some(center),
(sounds.volume + 1.0) / 2.0,
sounds.pitch * 0.8,
);
if solid_bucket {
for event in &mut self.level_events {
if let LevelEvent::Sound { pos: at, sound, .. } = event
&& *at == pos
{
*sound = "minecraft:item.bucket.empty_powder_snow".into();
}
}
}
self.process_level_events()?;
// BlockItem.place: the used statistic and the placed_block trigger.
self.stats.add("used", &stack.item, 1);
@@ -2271,6 +2276,22 @@ impl Game<'_> {
}
Ok(())
}
/// `Consumable.startConsuming` for held food the player can eat
/// (`Player.canEat`): the right click is held for `consume_seconds`.
fn start_eating(&mut self, info: &horizon_client::items::ItemInfo) -> bool {
if info.food.is_none()
|| !self
.player
.as_ref()
.is_some_and(|p| p.health.food.food < 20 || self.creative)
{
return false;
}
if self.using.is_none() {
self.using = Some((self.selected, 0));
}
true
}
fn consume_held(&mut self) {
if self.creative {
return;
@@ -10,11 +10,13 @@ use super::{
use horizon_client::{
Result,
chunk::Chunk,
command::args::GameMode,
containers::BlockEntity,
gamerules::Value as RuleValue,
item_data::{canon_stack, parse_stack},
items::ItemStack,
mobs::{Mob, Species},
motion::PlayerMotion,
projectiles::ProjectileKind,
world::World,
};
@@ -25,6 +27,7 @@ use horizon_core::{
use horizon_world::{level::Ticks, registry::BlockStateId};
use serde_json::Value;
use std::{cell::RefCell, collections::HashMap, fmt::Write as _, io::Write as _, sync::Arc};
use winit::keyboard::KeyCode;
thread_local! {
/// Level and game events recorded while a fixture case runs.
@@ -267,6 +270,8 @@ impl Game<'_> {
self.fixture_remove(origin, op)?;
} else if let Some(op) = case.get("use") {
used = self.fixture_use(origin, op)?;
} else if let Some(op) = case.get("use_item") {
used = self.fixture_use_item(origin, op)?;
} else if case.get("hopper").is_some() {
// HopperBlockEntity.pushItemsTick, once.
self.hopper_try_move_items((origin.x, origin.y, origin.z));
@@ -402,6 +407,72 @@ impl Game<'_> {
Ok(out)
}
/// A player three blocks south of `pos` right-clicks its top face holding
/// the case's item (`use_item_as_player` on that hit): the statistics,
/// the held stack and the item it started using, as
/// `VanillaDispenserOracle.useItem` prints them.
fn fixture_use_item(&mut self, pos: BlockPos, op: &Value) -> Result<Vec<String>> {
let stack = parse_stack(op["item"].as_str().unwrap_or("-"))?;
self.mode = if op["creative"].as_bool().unwrap_or(false) {
GameMode::Creative
} else {
GameMode::Survival
};
self.creative = self.mode == GameMode::Creative;
let mut player = PlayerMotion::new(
self.motion,
horizon_core::geometry::Vec3::new(
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 1.0,
f64::from(pos.z) + 3.5,
),
)?;
player.health.food.food = op["food"].as_i64().unwrap_or(20) as i32;
self.player = Some(player);
self.yaw = 0.0;
self.pitch = 90.0;
self.keys.clear();
if op["sneaking"].as_bool().unwrap_or(false) {
self.keys.insert(KeyCode::ShiftLeft);
}
self.using = None;
self.inventory[self.selected] = stack.clone();
let used_before = stack
.as_ref()
.map_or(0, |s| self.stats.get("used", &s.item));
self.forced_hit = Some(super::Hit {
pos: [pos.x, pos.y, pos.z],
face: [0, 1, 0],
point: [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 1.0,
f64::from(pos.z) + 0.5,
],
});
let used = self.use_item_as_player();
self.forced_hit = None;
used?;
self.process_level_events()?;
let mut out = Vec::new();
if let Some(s) = &stack {
let used = self.stats.get("used", &s.item) - used_before;
if used != 0 {
out.push(format!("stat {} minecraft:used {used}", s.item));
}
}
let using = self
.using
.and_then(|(slot, _)| self.stack_in(slot))
.map_or("-".to_owned(), |s| s.item.to_string());
out.push(format!(
"held {} using {using}",
canon_stack(self.inventory[self.selected].as_ref())
));
self.player = None;
self.using = None;
Ok(out)
}
/// A stack in a block entity's slot: a container's, a jukebox's record, a
/// lectern's book, or the items of a block entity Horizon keeps as saved.
fn fixture_fill(&mut self, p: (i32, i32, i32), slot: usize, stack: Option<ItemStack>) {
+11
View File
@@ -47,9 +47,20 @@ impl Game<'_> {
};
let pos = BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]);
let used = self.with_level(|b, level, ticks| b.use_bone_meal(level, ticks, pos, face));
// ItemStack.causeUseVibration at the player, after the meal is used
// up (shrunk even in creative): an emptied stack has no use effects.
if used
&& stack.count > 1
&& let Some(p) = self.player.as_ref().map(|p| p.position)
{
let ctx = self.player_context(None);
self.post_game_event("minecraft:item_interact_finish", [p.x, p.y, p.z], ctx);
}
self.process_level_events()?;
if used {
self.swing_arm();
// ItemStack.useOn: an item interaction counts as a use.
self.stats.add("used", &stack.item, 1);
self.consume_held();
}
Ok(used)
+17
View File
@@ -221,6 +221,23 @@ impl GameLevel<'_> {
delay: 10,
});
}
/// `Block.dropFromBlockInteractLootTable` with `Block.popResource` of
/// every stack.
pub(super) fn drop_interact_loot(&mut self, pos: BlockPos, state: BlockStateId, table: &str) {
let drops = self.items.interact_loot(
table,
self.registry,
state,
&mut self.world.random,
self.rand_sequences,
self.seed,
);
for stack in drops {
if &*stack.item != "minecraft:air" && stack.count > 0 {
self.pop_resource([pos.x, pos.y, pos.z], stack);
}
}
}
/// `Block.dropResources(state, level, pos, blockEntity)`: the block's loot
/// (from its random sequence, else the level random), with what its block
/// entity copies into it, popped at once.
+27
View File
@@ -754,6 +754,33 @@ impl Items {
.as_str()
.map(str::to_owned)
}
/// `Block.dropFromBlockInteractLootTable`: the `block_interact` table `id`
/// for a right click on `state` (its `match_block` conditions see the
/// state), from the table's random sequence when it has one.
pub fn interact_loot(
&self,
id: &str,
registry: &BlockRegistry,
state: BlockStateId,
random: &mut impl RandomSource,
sequences: &mut crate::random_sequences::RandomSequences,
seed: i64,
) -> Vec<ItemStack> {
let (Some(table), Some(block)) = (self.loot.get(id), registry.state(state)) else {
return vec![];
};
let ctx = LootContext {
items: self,
block: &block.name,
properties: &block.properties,
held: None,
killed_by_player: false,
};
match table.get("random_sequence").and_then(Value::as_str) {
Some(sequence) => ctx.evaluate(table, sequences.get(sequence, seed)),
None => ctx.evaluate(table, random),
}
}
/// `loot_table` drawing from any random (a random sequence).
pub fn loot_table_from(
&self,
@@ -527,4 +527,28 @@ impl Behaviours {
self.sim(level, ticks)
.use_without_item(pos, face, hit, player)
}
/// `BlockState.useItemOn` with `item` in the main hand, then, when the
/// block asks to try with an empty hand (the default), `useWithoutItem`.
/// `SweetBerryBushBlock.useItemOn` passes bone meal on a bush that can
/// still grow on to the item.
#[allow(clippy::too_many_arguments)]
pub fn use_item_on<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
face: Direction,
hit: Vec3,
player: PlayerContext,
item: Option<&str>,
) -> InteractionResult {
let state = level.block_state(pos);
if item == Some("minecraft:bone_meal")
&& self.data(state).chain.contains(&Class::SweetBerryBush)
&& self.table.int(state, self.props.age) < 3
{
return InteractionResult::Pass;
}
self.use_without_item(level, ticks, pos, face, hit, player)
}
}
@@ -295,6 +295,8 @@ public final class VanillaDispenserOracle {
remove(w, origin, f.getAsJsonObject("remove"));
} else if (f.has("use")) {
used = use(w, origin, f.getAsJsonObject("use"));
} else if (f.has("use_item")) {
used = useItem(w, origin, f.getAsJsonObject("use_item"));
} else if (f.has("hopper")) {
// HopperBlockEntity.pushItemsTick, once.
var hopper = (net.minecraft.world.level.block.entity.HopperBlockEntity) w.getBlockEntity(origin);
@@ -410,6 +412,93 @@ public final class VanillaDispenserOracle {
return out;
}
/**
* The player of a "use_item" case: a `User` that also has abilities, food,
* item cooldowns and a place (away from the clicked block), and records
* starting to use its item instead of syncing it.
*/
static final class Clicker extends net.minecraft.server.level.ServerPlayer {
VanillaBlockUpdateOracle.World world;
boolean creative, sneaking;
ItemStack hand;
List<String> stats;
String using;
Clicker() {
super(null, null, null, null);
}
@Override public ServerLevel level() { return world; }
@Override public boolean hasInfiniteMaterials() { return creative; }
@Override public boolean isCreative() { return creative; }
@Override public boolean isSpectator() { return false; }
@Override public boolean isSecondaryUseActive() { return sneaking; }
@Override public boolean isShiftKeyDown() { return sneaking; }
@Override public boolean isDescending() { return sneaking; }
@Override public EntityType<?> getType() { return EntityTypes.PLAYER; }
@Override public net.minecraft.core.Holder<EntityType<?>> typeHolder() { return EntityTypes.PLAYER.builtInRegistryHolder(); }
@Override public ItemStack getItemBySlot(EquipmentSlot slot) { return slot == EquipmentSlot.MAINHAND ? hand : ItemStack.EMPTY; }
@Override public ItemStack getItemInHand(net.minecraft.world.InteractionHand h) {
return h == net.minecraft.world.InteractionHand.MAIN_HAND ? hand : ItemStack.EMPTY;
}
@Override public void setItemInHand(net.minecraft.world.InteractionHand h, ItemStack stack) {
if (h == net.minecraft.world.InteractionHand.MAIN_HAND) hand = stack;
}
@Override public void startUsingItem(net.minecraft.world.InteractionHand h) {
using = BuiltInRegistries.ITEM.getKey(getItemInHand(h).getItem()).toString();
}
@Override public boolean isUsingItem() { return using != null; }
@Override public void awardStat(net.minecraft.stats.Stat<?> stat, int count) {
stats.add("stat " + User.key(stat) + " " + BuiltInRegistries.STAT_TYPE.getKey(stat.getType()) + " " + count);
}
}
/**
* A right click on the top of the block at `pos` (`ServerPlayerGameMode.useItemOn`
* of the real game mode, survival or creative): the block's `useItemOn` and
* `useWithoutItem`, then the item's `useOn` (`BlockItem.place`, falling back
* to eating a consumable), and `useItem` when that passes, as
* `Minecraft.startUseItem` goes on to. The statistics, the held stack and
* the item the player started using follow.
*/
static List<String> useItem(VanillaBlockUpdateOracle.World w, BlockPos pos, JsonObject use) throws Exception {
Clicker player = (Clicker) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, Clicker.class);
player.world = w;
player.creative = use.get("creative").getAsBoolean();
player.sneaking = use.get("sneaking").getAsBoolean();
player.hand = stack(use.get("item").getAsString());
player.stats = new ArrayList<>();
var abilities = new net.minecraft.world.entity.player.Abilities();
abilities.invulnerable = abilities.instabuild = abilities.mayfly = player.creative;
VanillaBlockUpdateOracle.set(net.minecraft.world.entity.player.Player.class, player, "abilities", abilities);
var food = new net.minecraft.world.food.FoodData();
food.setFoodLevel(use.get("food").getAsInt());
VanillaBlockUpdateOracle.set(net.minecraft.world.entity.player.Player.class, player, "foodData", food);
VanillaBlockUpdateOracle.set(net.minecraft.world.entity.player.Player.class, player, "cooldowns", new net.minecraft.world.item.ItemCooldowns());
var advancements = (net.minecraft.server.PlayerAdvancements) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, net.minecraft.server.PlayerAdvancements.class);
VanillaBlockUpdateOracle.set(net.minecraft.server.PlayerAdvancements.class, advancements, "activeTriggers", new HashMap<>());
VanillaBlockUpdateOracle.set(net.minecraft.server.level.ServerPlayer.class, player, "advancements", advancements);
// Standing three blocks south of the clicked block, looking down at it.
var at = net.minecraft.world.phys.Vec3.atBottomCenterOf(pos).add(0, 1, 3);
VanillaBlockUpdateOracle.set(Entity.class, player, "position", at);
VanillaBlockUpdateOracle.set(Entity.class, player, "blockPosition", BlockPos.containing(at));
VanillaBlockUpdateOracle.set(Entity.class, player, "xRot", 90f);
var gameMode = new net.minecraft.server.level.ServerPlayerGameMode(player);
VanillaBlockUpdateOracle.set(net.minecraft.server.level.ServerPlayerGameMode.class, gameMode, "gameModeForPlayer",
player.creative ? net.minecraft.world.level.GameType.CREATIVE : net.minecraft.world.level.GameType.SURVIVAL);
var hit = new net.minecraft.world.phys.BlockHitResult(net.minecraft.world.phys.Vec3.atCenterOf(pos).add(0, 0.5, 0),
net.minecraft.core.Direction.UP, pos, false);
var hand = net.minecraft.world.InteractionHand.MAIN_HAND;
var result = gameMode.useItemOn(player, w, player.getItemInHand(hand), hand, hit);
// Minecraft.startUseItem: a click on a block that neither succeeded nor
// failed goes on to use the item in the same hand.
if (!(result instanceof net.minecraft.world.InteractionResult.Success)
&& !(result instanceof net.minecraft.world.InteractionResult.Fail) && !player.hand.isEmpty()) {
gameMode.useItem(player, w, player.getItemInHand(hand), hand);
}
List<String> out = new ArrayList<>(player.stats);
out.add("held " + ParityData.canon(player.hand) + " using " + (player.using == null ? "-" : player.using));
return out;
}
/** The level's block entity positions by x, y, z. */
static List<BlockPos> sortedEntities(VanillaBlockUpdateOracle.World w) {
List<BlockPos> out = new ArrayList<>(w.blockEntities == null ? List.of() : w.blockEntities.keySet());
+136
View File
@@ -0,0 +1,136 @@
#!/usr/bin/env python3
"""Compare a player's right click on a block with vanilla's, for items that are
both food and blocks (sweet and glow berries, carrots, potatoes) and for sweet
berry bushes.
Every case has a block at the origin, something above it, and a player three
blocks south, survival or creative, hungry or full, sneaking or not, who
right-clicks the top face of the origin holding an item. Vanilla runs the real
`ServerPlayerGameMode.useItemOn` over the headless level of the dispenser
harness (`VanillaDispenserOracle.useItem`): the block's `useItemOn` and
`useWithoutItem` (picking a bush's berries, `SweetBerryBushBlock.useItemOn`
passing bone meal on), then `ItemStack.useOn` (`BlockItem.place` with its
`mayPlaceOn` rules, `BoneMealItem.useOn`, and eating a consumable that could
not be placed). Horizon runs `use_item_as_player` on that hit in a headless
game (`HORIZON_DISPENSE_FIXTURE`). Both print block changes, dropped items,
level events, sounds, game events, the used statistic, the held stack, the
item the player started using, and the level random afterwards.
"""
import json
import os
import random
try:
from . import block_update_harness as h, lab, test_dispenser_parity as d, test_rust_parity as base
except ImportError:
import block_update_harness as h
import lab
import test_dispenser_parity as d
import test_rust_parity as base
# Blocks the item is used on: the supports of the planted blocks and others.
GROUNDS = ['grass_block', 'dirt', 'coarse_dirt', 'podzol', 'rooted_dirt', 'moss_block', 'pale_moss_block', 'mud',
'muddy_mangrove_roots', 'farmland', 'stone', 'sand', 'gravel', 'clay', 'snow_block', 'oak_planks']
ITEMS = ['sweet_berries', 'sweet_berries', 'sweet_berries', 'glow_berries', 'carrot', 'potato', 'bone_meal',
'wheat_seeds', 'beetroot_seeds', 'apple']
# What is in the way above the clicked block.
ABOVE = ['air'] * 8 + ['short_grass', 'snow', 'stone', 'water', 'dead_bush', 'fern']
def cases(facts, count, seed):
rng = random.Random(seed)
states = d.States(facts)
for n in range(count):
case = {**h.environment(rng), 'pos': [0, 0, 0]}
case.pop('raining', None)
case.pop('thundering', None)
cells = []
item = rng.choice(ITEMS)
if rng.random() < 0.3:
# A sweet berry bush on grass: pick it, bone meal it, or plant against it.
age = rng.randrange(4)
cells.append([0, 0, 0, states.get('sweet_berry_bush', age=str(age))])
cells.append([0, -1, 0, states.get(rng.choice(['grass_block', 'dirt', 'podzol', 'farmland']))])
item = rng.choice(['bone_meal', 'bone_meal', 'sweet_berries', 'apple', '-', 'stick'])
else:
ground = rng.choice(GROUNDS)
cells.append([0, 0, 0, states.any(rng, ground) if ground == 'farmland' else states.get(ground)])
above = rng.choice(ABOVE)
if above != 'air':
cells.append([0, 1, 0, states.get(above)])
if item == 'glow_berries' and rng.random() < 0.5:
# A ceiling two blocks up for the cave vines to hang from.
cells.append([0, 2, 0, states.get(rng.choice(['stone', 'dirt', 'oak_leaves']))])
if item == 'bone_meal' and ground in ('grass_block', 'moss_block', 'pale_moss_block'):
# Bone meal on spreading blocks is the bone meal harness's.
item = 'sweet_berries'
held = '-' if item == '-' else d.plain(item, rng.choice([1, 1, 2, 16, 64]))
case['use_item'] = {'item': held, 'creative': rng.random() < 0.2, 'sneaking': rng.random() < 0.2,
'food': rng.choice([20, 20, 19, 10, 0])}
case['cells'] = cells
case['items'] = []
case['mode'] = 'dispense'
yield case
def kind(case, facts):
first = facts.states[case['cells'][0][3]][0].split(':')[1]
item = case['use_item']['item']
item = item.split('"')[1].split(':')[1] if item != '-' else 'empty hand'
return f'{item} on {first}'
def main():
parser = h.argument_parser(__doc__)
args = parser.parse_args()
if args.count == 40000:
args.count = 4000
lock, jars, libraries = base.verify_artifacts()
facts = h.load_facts()
resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version']
work = lab.LOCAL / 'use-item-on-parity'
work.mkdir(parents=True, exist_ok=True)
all_cases = list(cases(facts, args.count, args.seed))
(work / 'cases.jsonl').write_text(''.join(json.dumps(case) + '\n' for case in all_cases))
classes = work / 'classes'
classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
java_root = lab.ROOT / 'mods/horizon/src/test/java'
d.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-sourcepath', str(java_root), '-nowarn',
'-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'})
ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
native = h.split_cases((work / 'native.txt').read_text(), ignore)
rust = h.split_cases((work / 'rust.txt').read_text(), ignore)
assert len(native) == len(rust) == len(all_cases), (len(native), len(rust), len(all_cases))
groups, errors = {}, {}
planted = eaten = 0
for case, a, b in zip(all_cases, native, rust):
if a and a[0].startswith('error'):
errors.setdefault(a[0], []).append(case)
continue
planted += any(line.startswith('set 0,1,0') for line in a)
eaten += any(line.startswith('held') and not line.endswith('using -') for line in a)
if not d.same(a, b):
groups.setdefault(kind(case, facts), []).append((case, a, b))
for name, entries in sorted(errors.items(), key=lambda e: -len(e[1])):
print(f'oracle error x{len(entries)}: {name}')
for name, entries in sorted(groups.items(), key=lambda e: -len(e[1])):
print(f'{name}: {len(entries)} differing')
for case, a, b in entries[:args.show]:
print(' case ' + d.describe(case, facts) + ' use=' + json.dumps(case['use_item']))
print(' native ' + ' | '.join(sorted(a)))
print(' rust ' + ' | '.join(sorted(b)))
total = sum(len(v) for v in groups.values())
skipped = sum(len(v) for v in errors.values())
print(f'{len(all_cases) - total - skipped}/{len(all_cases) - skipped} cases match ({skipped} oracle errors); '
f'vanilla planted in {planted} and started eating in {eaten}')
h.finish(total + skipped)
if __name__ == '__main__':
main()