ca5404e52d
BeaconMenu now runs on horizon_client::menu (Kind::Beacon): the payment slot (beacon_payment_items, one item), quickMoveStack and updateEffects with BeaconBlockEntity.validateEffects, verified against the vanilla class by test_menu_click_parity with a new SET_BEACON op (valid and invalid powers for each pyramid level). ServerboundSetBeaconPacket is now in the protocol. The LAN host opens minecraft:beacon for guests with the block entity's levels and powers as data slots (kept current while the menu is open), applies a guest's powers to the block entity (power_select while the beam is up) and drops the payment when the menu closes, as BeaconMenu.removed does. Guests show the server's levels and powers and their Done button sends the packet. Single player's beacon clicks go through the engine too. Part of #868. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
426 lines
24 KiB
Python
426 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
"""Compare AbstractContainerMenu.clicked with vanilla's menu classes.
|
|
|
|
The Java oracle (VanillaMenuOracle) runs each case's clicks on the real menu
|
|
class with a stand-in player and level; the Rust example (menu_fixture) runs
|
|
horizon_client::menu. Cases are randomized slot contents with random click
|
|
sequences covering every ContainerInput (pickup, quick move, swap, clone,
|
|
throw, the three quick craft drags, pickup all, and the screens' Shift double
|
|
click: QUICK_MOVE on every slot of the clicked slot's container holding the
|
|
item the first click moved) over the player inventory,
|
|
crafting table, chests, hopper, dispenser, shulker box, the furnaces, the
|
|
brewing stand, the crafter (the client's menu, and the server's over the block
|
|
entity with slot state packets), the loom (with its pattern buttons), the
|
|
stonecutter (with its recipe buttons), the grindstone (enchanted, damaged and
|
|
cursed tools and books), the anvil (repairs, enchantment merges and renames,
|
|
with the player's levels), the smithing table (upgrades and trims), the
|
|
enchanting table (its button checks against the costs, lapis and levels), the
|
|
beacon (its payment slot and ServerboundSetBeaconPacket against the pyramid's
|
|
levels) and the
|
|
server's furnace menus over their block entities (`*_be`: a new input restarts
|
|
cooking, other clicks keep its progress). After
|
|
every click the slots, carried stack, data slots and drops 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
|
|
|
|
MENUS = {'inventory': 46, 'crafting': 46, 'chest1': 45, 'chest2': 54, 'chest3': 63, 'chest4': 72, 'chest5': 81,
|
|
'chest6': 90, 'hopper': 41, 'dispenser': 45, 'shulker': 63, 'furnace': 39, 'blast_furnace': 39, 'smoker': 39, 'brewing': 41, 'crafter': 46,
|
|
'crafter_be': 46, 'loom': 40, 'stonecutter': 38, 'grindstone': 39, 'anvil': 39, 'smithing': 40, 'enchanting': 38, 'beacon': 37, 'furnace_be': 39, 'blast_furnace_be': 39, 'smoker_be': 39}
|
|
DATA = {'furnace': 4, 'blast_furnace': 4, 'smoker': 4, 'brewing': 4, 'crafter': 10, 'crafter_be': 10, 'loom': 1,
|
|
'stonecutter': 1, 'enchanting': 10, 'beacon': 3,
|
|
'furnace_be': 4, 'blast_furnace_be': 4, 'smoker_be': 4}
|
|
DYES = ['white', 'orange', 'magenta', 'light_blue', 'yellow', 'lime', 'pink', 'gray', 'light_gray', 'cyan', 'purple',
|
|
'blue', 'brown', 'green', 'red', 'black']
|
|
PATTERNS = ['minecraft:' + p for p in ('base', 'square_bottom_left', 'stripe_bottom', 'cross', 'border', 'gradient',
|
|
'creeper', 'flower', 'globe', 'rhombus', 'small_stripes', 'half_horizontal')]
|
|
COMMON = ['stone', 'dirt', 'cobblestone', 'oak_planks', 'stick', 'coal', 'iron_ingot', 'diamond', 'apple', 'bread',
|
|
'oak_log', 'sand', 'bucket', 'water_bucket', 'lava_bucket', 'ender_pearl', 'snowball', 'egg', 'white_wool',
|
|
'iron_helmet', 'diamond_chestplate', 'leather_leggings', 'iron_boots', 'shield', 'carved_pumpkin',
|
|
'elytra', 'turtle_helmet', 'iron_sword', 'diamond_pickaxe', 'bow', 'shulker_box', 'red_shulker_box',
|
|
'raw_iron', 'potato', 'beef', 'chicken', 'sticky_piston', 'blaze_rod', 'lava_bucket', 'oak_sapling',
|
|
'white_dye', 'red_dye', 'torch', 'crafting_table', 'furnace', 'chest', 'glass_bottle', 'nether_wart', 'blaze_powder',
|
|
'redstone', 'gunpowder', 'sugar', 'potion', 'splash_potion', 'lingering_potion', 'fermented_spider_eye', 'dragon_breath']
|
|
# Stonecutter inputs (several recipes each), and a block it doesn't cut.
|
|
CUTTABLE = ['stone', 'cobblestone', 'andesite', 'granite', 'copper_block', 'sandstone', 'quartz_block', 'deepslate',
|
|
'stone_bricks', 'oak_planks']
|
|
# Grindstone inputs: tools and armor, books, and their enchantments (curses too).
|
|
GRINDABLE = ['iron_sword', 'diamond_pickaxe', 'bow', 'iron_helmet', 'elytra', 'shield', 'fishing_rod', 'trident']
|
|
# Beacon powers (BEACON_EFFECTS by level, and one no level gives) and payments.
|
|
POWERS = ['speed', 'haste', 'resistance', 'jump_boost', 'strength', 'regeneration', 'night_vision']
|
|
PAYMENTS = ['iron_ingot', 'gold_ingot', 'emerald', 'diamond', 'netherite_ingot']
|
|
ENCHANTS = ['sharpness', 'unbreaking', 'mending', 'efficiency', 'protection', 'power', 'looting', 'fortune',
|
|
'binding_curse', 'vanishing_curse']
|
|
|
|
|
|
# Anvil renames (ServerboundRenameItemPacket): blank, too long, a section sign, an item's own name.
|
|
NAMES = ['', ' ', 'Blade', 'Iron Sword', 'Diamond Pickaxe', 'Enchanted Book', '\u00a7cRed', 'x' * 50, 'x' * 51]
|
|
# Smithing inputs: templates, bases and additions (trim materials and netherite).
|
|
TEMPLATES = ['netherite_upgrade_smithing_template', 'coast_armor_trim_smithing_template',
|
|
'sentry_armor_trim_smithing_template', 'bolt_armor_trim_smithing_template']
|
|
BASES = ['diamond_sword', 'diamond_chestplate', 'diamond_pickaxe', 'iron_helmet', 'iron_chestplate', 'netherite_boots',
|
|
'leather_leggings', 'golden_helmet', 'turtle_helmet', 'diamond_hoe']
|
|
ADDITIONS = ['netherite_ingot', 'iron_ingot', 'gold_ingot', 'emerald', 'redstone', 'quartz', 'amethyst_shard',
|
|
'lapis_lazuli', 'copper_ingot', 'diamond']
|
|
|
|
|
|
def quote(text):
|
|
return '"' + text + '"'
|
|
|
|
|
|
def snbt(item, count, damage=0, curse=False, potion=None):
|
|
comps = []
|
|
if potion:
|
|
comps.append('"minecraft:potion_contents":{potion:"%s"}' % potion)
|
|
if damage:
|
|
comps.append('"minecraft:damage":%d' % damage)
|
|
if curse:
|
|
comps.append('"minecraft:enchantments":{"minecraft:binding_curse":1}')
|
|
body = ',components:{%s}' % ','.join(comps) if comps else ''
|
|
return '{id:%s,count:%d%s}' % (quote(item), count, body)
|
|
|
|
|
|
class Gen:
|
|
def __init__(self, rng, items):
|
|
self.rng = rng
|
|
self.items = items
|
|
self.pool = ['minecraft:' + c for c in COMMON if 'minecraft:' + c in items]
|
|
self.all = [k for k, v in items.items() if k != 'minecraft:air' and 'bundle' not in k
|
|
and not k.endswith('_spawn_egg')]
|
|
|
|
def stack(self):
|
|
rng = self.rng
|
|
item = rng.choice(self.pool if rng.random() < 0.85 else self.all)
|
|
info = self.items[item]
|
|
top = info.get('minecraft:max_stack_size', 64)
|
|
damage = 0
|
|
if info.get('minecraft:max_damage') and rng.random() < 0.3:
|
|
damage = rng.randrange(1, info['minecraft:max_damage'])
|
|
count = 1 if top == 1 else rng.choice([1, 1, 2, top, top, top - 1, rng.randrange(1, top + 1)])
|
|
potion = rng.choice(['minecraft:water', 'minecraft:awkward', 'minecraft:healing', 'minecraft:thick']) if item.endswith('potion') and rng.random() < 0.8 else None
|
|
return snbt(item, max(1, count), damage, curse=rng.random() < 0.15 and 'equippable' in json.dumps(info), potion=potion)
|
|
|
|
def slots(self, size, density):
|
|
return [self.stack() if self.rng.random() < density else '-' for _ in range(size)]
|
|
|
|
def loom_stack(self, roll=None):
|
|
"""A banner (with up to seven layers), a dye, a pattern item or anything."""
|
|
rng = self.rng
|
|
roll = rng.random() if roll is None else roll
|
|
if roll < 0.3:
|
|
layers = ','.join('{pattern:"%s",color:"%s"}' % (rng.choice(PATTERNS), rng.choice(DYES))
|
|
for _ in range(rng.choice([0, 0, 1, 2, 5, 6, 6, 7])))
|
|
extra = ',components:{"minecraft:banner_patterns":[%s]}' % layers if layers else ''
|
|
return '{id:"minecraft:%s_banner",count:%d%s}' % (rng.choice(DYES), rng.choice([1, 1, 2, 16]), extra)
|
|
if roll < 0.55:
|
|
return snbt('minecraft:%s_dye' % rng.choice(DYES), rng.choice([1, 1, 2, 3, 64]))
|
|
if roll < 0.75:
|
|
pool = [k for k in self.items if k.endswith('_banner_pattern')]
|
|
return snbt(rng.choice(pool), 1)
|
|
return self.stack()
|
|
|
|
def cut_stack(self):
|
|
"""Mostly something the stonecutter cuts, sometimes anything."""
|
|
rng = self.rng
|
|
if rng.random() < 0.75:
|
|
return snbt('minecraft:' + rng.choice(CUTTABLE), rng.choice([1, 1, 2, 3, 10, 63, 64]))
|
|
return self.stack()
|
|
|
|
def grind_stack(self):
|
|
"""Mostly an enchanted or damaged tool or an enchanted book, sometimes anything."""
|
|
rng = self.rng
|
|
roll = rng.random()
|
|
if roll > 0.8:
|
|
return self.stack()
|
|
levels = ','.join('"minecraft:%s":%d' % (e, rng.randrange(1, 4))
|
|
for e in rng.sample(ENCHANTS, rng.choice([0, 1, 1, 2, 3])))
|
|
comps = []
|
|
if roll < 0.25:
|
|
item = 'minecraft:' + rng.choice(['enchanted_book', 'enchanted_book', 'book'])
|
|
if levels:
|
|
comps.append('"minecraft:stored_enchantments":{%s}' % levels)
|
|
count = 1 if rng.random() < 0.85 else 2
|
|
else:
|
|
item = 'minecraft:' + rng.choice(GRINDABLE)
|
|
info = self.items.get(item, {})
|
|
if levels:
|
|
comps.append('"minecraft:enchantments":{%s}' % levels)
|
|
if info.get('minecraft:max_damage') and rng.random() < 0.6:
|
|
comps.append('"minecraft:damage":%d' % rng.randrange(0, info['minecraft:max_damage']))
|
|
count = 1
|
|
if rng.random() < 0.2:
|
|
comps.append('"minecraft:repair_cost":%d' % rng.choice([1, 3, 7]))
|
|
body = ',components:{%s}' % ','.join(comps) if comps else ''
|
|
return '{id:%s,count:%d%s}' % (quote(item), count, body)
|
|
|
|
def anvil_stack(self):
|
|
"""A tool to repair or enchant, an enchanted book, a repair material, a named item or anything."""
|
|
rng = self.rng
|
|
roll = rng.random()
|
|
if roll < 0.45:
|
|
stack = self.grind_stack()
|
|
elif roll < 0.65:
|
|
item = rng.choice(['iron_ingot', 'diamond', 'leather', 'oak_planks', 'phantom_membrane', 'string'])
|
|
stack = snbt('minecraft:' + item, rng.choice([1, 1, 2, 3, 5, 64]))
|
|
else:
|
|
stack = self.stack()
|
|
if rng.random() < 0.15:
|
|
name = '"minecraft:custom_name":"%s"' % rng.choice(['Blade', 'Iron Sword', 'Old'])
|
|
stack = stack.replace(',components:{', ',components:{%s,' % name) if ',components:{' in stack \
|
|
else stack[:-1] + ',components:{%s}}' % name
|
|
return stack
|
|
|
|
def smith_stack(self, slot=None):
|
|
"""A template, a base or an addition (for `slot`, else any), sometimes anything."""
|
|
rng = self.rng
|
|
if rng.random() < 0.15:
|
|
return self.stack()
|
|
slot = rng.randrange(3) if slot is None else slot
|
|
pool = [TEMPLATES, BASES, ADDITIONS][slot]
|
|
item = 'minecraft:' + rng.choice(pool)
|
|
count = 1 if slot == 1 else rng.choice([1, 1, 2, 5, 64])
|
|
if slot == 1 and rng.random() < 0.3:
|
|
return '{id:%s,count:1,components:{"minecraft:enchantments":{"minecraft:unbreaking":2}}}' % quote(item)
|
|
return snbt(item, count)
|
|
|
|
def recipe(self, slots, width, start=1):
|
|
"""Fills the crafting grid (slots `start`..) with a small known recipe."""
|
|
rng = self.rng
|
|
amount = lambda: rng.choice([1, 1, 2, 5, 64])
|
|
choices = [[('oak_log',)], [('oak_planks',), ('oak_planks',)], [('oak_planks', 'oak_planks'), ('oak_planks', 'oak_planks')],
|
|
[('iron_ingot',) * 3] * 3, [('milk_bucket',) * 3, ('sugar', 'egg', 'sugar'), ('wheat',) * 3],
|
|
[('wheat',) * 3], [('white_wool',) * 2, ('white_wool',) * 2], [('coal',), ('stick',)]]
|
|
pattern = rng.choice(choices)
|
|
if len(pattern) > width or any(len(row) > width for row in pattern):
|
|
pattern = [('oak_planks',), ('oak_planks',)]
|
|
for y, row in enumerate(pattern):
|
|
for x, name in enumerate(row):
|
|
slots[start + x + y * width] = snbt('minecraft:' + name, amount() if name != 'milk_bucket' else 1)
|
|
|
|
def ops(self, size, menu, slots):
|
|
rng = self.rng
|
|
out = []
|
|
for _ in range(rng.randrange(1, 9)):
|
|
if menu == 'loom' and rng.random() < 0.25:
|
|
# A pattern button (clickMenuButton), sometimes out of range.
|
|
out.append([rng.choice([0, 0, 1, 2, 3, 5, 10, 20, 39, 40, -1]), 0, 'BUTTON'])
|
|
continue
|
|
if menu == 'loom' and rng.random() < 0.15:
|
|
# The result: take it, shift it out, throw it.
|
|
out.append([3, rng.randrange(0, 2), rng.choice(['PICKUP', 'QUICK_MOVE', 'THROW', 'SWAP'])])
|
|
continue
|
|
if menu == 'stonecutter' and rng.random() < 0.25:
|
|
# A recipe button (clickMenuButton), sometimes out of range or the selected one.
|
|
out.append([rng.choice([0, 0, 1, 2, 3, 5, 10, 30, -1]), 0, 'BUTTON'])
|
|
continue
|
|
if menu == 'stonecutter' and rng.random() < 0.2:
|
|
out.append([1, rng.randrange(0, 2), rng.choice(['PICKUP', 'QUICK_MOVE', 'QUICK_MOVE', 'THROW', 'SWAP'])])
|
|
continue
|
|
if menu == 'anvil' and rng.random() < 0.15:
|
|
out.append([0, 0, 'RENAME', rng.choice(NAMES)])
|
|
continue
|
|
if menu in ('anvil', 'smithing') and rng.random() < 0.2:
|
|
result = 2 if menu == 'anvil' else 3
|
|
out.append([result, rng.randrange(0, 2), rng.choice(['PICKUP', 'QUICK_MOVE', 'QUICK_MOVE', 'THROW', 'SWAP'])])
|
|
continue
|
|
if menu == 'enchanting' and rng.random() < 0.25:
|
|
# An offer button (clickMenuButton), sometimes out of range.
|
|
out.append([rng.choice([0, 1, 2, 2, 3, -1]), 0, 'BUTTON'])
|
|
continue
|
|
if menu == 'beacon' and rng.random() < 0.3:
|
|
# ServerboundSetBeaconPacket: powers, valid or not, or none.
|
|
pick = lambda: 'minecraft:' + rng.choice(POWERS) if rng.random() < 0.8 else None
|
|
primary, secondary = pick(), pick()
|
|
if primary is None and secondary not in (None, 'minecraft:regeneration', 'minecraft:night_vision'):
|
|
# validateEffects compares a null primary (Holder.equals: a NullPointerException).
|
|
primary = secondary
|
|
out.append([0, 0, 'SET_BEACON', primary, secondary])
|
|
continue
|
|
if menu == 'grindstone' and rng.random() < 0.2:
|
|
out.append([2, rng.randrange(0, 2), rng.choice(['PICKUP', 'QUICK_MOVE', 'QUICK_MOVE', 'THROW', 'SWAP'])])
|
|
continue
|
|
if menu == 'crafter_be' and rng.random() < 0.2:
|
|
out.append([rng.choice([0, 1, 4, 8, 8, 9, -1]), rng.randrange(0, 2), 'SLOT_STATE'])
|
|
continue
|
|
kind = rng.choices(['PICKUP', 'QUICK_MOVE', 'SWAP', 'CLONE', 'THROW', 'DRAG', 'PICKUP_ALL', 'JUNK',
|
|
'QUICK_MOVE_ALL'], [30, 20, 8, 3, 6, 14, 6, 2, 0 if menu.endswith('_be') else 6])[0]
|
|
slot = 0 if rng.random() < 0.2 and size in (46,) else rng.randrange(size)
|
|
if kind == 'QUICK_MOVE_ALL':
|
|
# A Shift double click: lastQuickMoved is mostly what a slot of the menu holds.
|
|
held = [s for s in slots if s != '-']
|
|
moved = rng.choice(held) if held and rng.random() < 0.85 else self.stack()
|
|
out.append([slot, 0, kind, moved])
|
|
continue
|
|
if kind == 'PICKUP':
|
|
out.append([rng.choice([slot, slot, slot, -999, -1]), rng.randrange(0, 3), kind])
|
|
elif kind == 'QUICK_MOVE':
|
|
out.append([rng.choice([slot, slot, slot, -999, -1]), rng.randrange(0, 3), kind])
|
|
elif kind == 'SWAP':
|
|
out.append([slot, rng.choice([0, 1, 2, 3, 4, 5, 6, 7, 8, 40, 9, -1]), kind])
|
|
elif kind in ('CLONE', 'THROW', 'PICKUP_ALL'):
|
|
out.append([slot, rng.randrange(0, 2), kind])
|
|
elif kind == 'DRAG':
|
|
ty = rng.randrange(0, 4)
|
|
out.append([-999, 0 | ty << 2, 'QUICK_CRAFT'])
|
|
for _ in range(rng.randrange(0, 6)):
|
|
out.append([rng.randrange(size), 1 | ty << 2, 'QUICK_CRAFT'])
|
|
out.append([-999, 2 | ty << 2, 'QUICK_CRAFT'])
|
|
else:
|
|
out.append([rng.choice([slot, 999, -5]), rng.randrange(-1, 5), rng.choice(
|
|
['PICKUP', 'QUICK_MOVE', 'QUICK_CRAFT', 'SWAP', 'THROW', 'PICKUP_ALL'])])
|
|
return out
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--seed', type=int, default=7)
|
|
parser.add_argument('--cases', type=int, default=8000)
|
|
parser.add_argument('--limit', type=int, default=3)
|
|
parser.add_argument('--menus', help='comma-separated menus to run (default: all)')
|
|
args = parser.parse_args()
|
|
work = lib.work_dir('menu-click-parity')
|
|
vanilla = lib.Vanilla(work)
|
|
vanilla.compile('ParityData', 'VanillaMenuOracle')
|
|
items = json.loads((lib.RESOURCES / 'items.json').read_text())
|
|
rng = random.Random(args.seed)
|
|
g = Gen(rng, items)
|
|
cases = []
|
|
chosen = args.menus.split(',') if args.menus else list(MENUS)
|
|
for n in range(args.cases):
|
|
menu = chosen[n % len(chosen)]
|
|
size = MENUS[menu]
|
|
slots = g.slots(size, rng.choice([0.1, 0.4, 0.8]))
|
|
if menu == 'loom':
|
|
for i in rng.sample(range(4, size), 8):
|
|
slots[i] = g.loom_stack()
|
|
# Mostly a banner, a dye and sometimes a pattern item in their slots.
|
|
slots[0] = g.loom_stack(0.0) if rng.random() < 0.75 else rng.choice(['-', g.loom_stack()])
|
|
slots[1] = g.loom_stack(0.4) if rng.random() < 0.75 else rng.choice(['-', g.loom_stack()])
|
|
slots[2] = g.loom_stack(0.6) if rng.random() < 0.4 else rng.choice(['-', '-', g.loom_stack()])
|
|
# The result slot follows the inputs; a fixture stack there is rare.
|
|
slots[3] = '-' if rng.random() < 0.9 else g.loom_stack()
|
|
if menu == 'stonecutter':
|
|
for i in rng.sample(range(2, size), 8):
|
|
slots[i] = g.cut_stack()
|
|
slots[0] = g.cut_stack() if rng.random() < 0.8 else '-'
|
|
# The result follows the input and the selected recipe; a fixture stack there is rare.
|
|
slots[1] = '-' if rng.random() < 0.9 else g.cut_stack()
|
|
if menu == 'grindstone':
|
|
for i in rng.sample(range(3, size), 10):
|
|
slots[i] = g.grind_stack()
|
|
slots[0] = g.grind_stack() if rng.random() < 0.7 else '-'
|
|
slots[1] = g.grind_stack() if rng.random() < 0.6 else '-'
|
|
# Two of the same tool, so mergeItems runs.
|
|
if slots[0] != '-' and rng.random() < 0.3:
|
|
slots[1] = slots[0] if rng.random() < 0.4 else g.grind_stack()
|
|
# The result follows the inputs; a fixture stack there is rare.
|
|
slots[2] = '-' if rng.random() < 0.9 else g.grind_stack()
|
|
if menu == 'anvil':
|
|
for i in rng.sample(range(3, size), 10):
|
|
slots[i] = g.anvil_stack()
|
|
slots[0] = g.anvil_stack() if rng.random() < 0.8 else '-'
|
|
slots[1] = g.anvil_stack() if rng.random() < 0.6 else '-'
|
|
if slots[0] != '-' and rng.random() < 0.25:
|
|
slots[1] = slots[0]
|
|
slots[2] = '-' if rng.random() < 0.9 else g.anvil_stack()
|
|
if menu == 'smithing':
|
|
for i in rng.sample(range(4, size), 12):
|
|
slots[i] = g.smith_stack()
|
|
for i in range(3):
|
|
slots[i] = g.smith_stack(i) if rng.random() < 0.75 else '-'
|
|
slots[3] = '-' if rng.random() < 0.9 else g.smith_stack()
|
|
if menu == 'enchanting':
|
|
lapis = lambda: snbt('minecraft:lapis_lazuli', rng.choice([1, 2, 3, 5, 64]))
|
|
enchantable = lambda: snbt('minecraft:' + rng.choice(['iron_sword', 'book', 'diamond_pickaxe', 'bow',
|
|
'golden_helmet', 'fishing_rod']), 1)
|
|
for i in rng.sample(range(2, size), 10):
|
|
slots[i] = rng.choice([lapis, enchantable, g.grind_stack])()
|
|
slots[0] = rng.choice([enchantable, enchantable, g.grind_stack, g.stack])() if rng.random() < 0.8 else '-'
|
|
slots[1] = lapis() if rng.random() < 0.7 else rng.choice(['-', g.stack()])
|
|
if menu == 'beacon':
|
|
pay = lambda: snbt('minecraft:' + rng.choice(PAYMENTS), rng.choice([1, 1, 1, 2, 64]))
|
|
for i in rng.sample(range(1, size), 8):
|
|
slots[i] = pay()
|
|
slots[0] = pay() if rng.random() < 0.7 else rng.choice(['-', g.stack()])
|
|
if menu == 'crafter_be':
|
|
slots[45] = '-'
|
|
if rng.random() < 0.6:
|
|
g.recipe(slots, 3, start=0)
|
|
if menu in ('inventory', 'crafting'):
|
|
slots[0] = '-'
|
|
if menu in ('inventory', 'crafting') and rng.random() < 0.6:
|
|
g.recipe(slots, 2 if menu == 'inventory' else 3)
|
|
if menu.endswith('_be') and menu != 'crafter_be' and rng.random() < 0.7:
|
|
# Mostly something cooking: a smeltable input, the same in the
|
|
# inventory and in hand, so merges and partial takes happen.
|
|
food = snbt('minecraft:' + rng.choice(['raw_iron', 'beef', 'potato', 'sand', 'cobblestone', 'oak_log']),
|
|
rng.choice([1, 2, 5, 32, 64]))
|
|
slots[0] = food
|
|
for i in rng.sample(range(3, size), 4):
|
|
slots[i] = food if rng.random() < 0.6 else g.stack()
|
|
carried_food = food if rng.random() < 0.5 else None
|
|
else:
|
|
carried_food = None
|
|
def datum(i):
|
|
if menu.endswith('_be') and menu != 'crafter_be':
|
|
# litTimeRemaining, litTotalTime, cookingTimer, cookingTotalTime
|
|
return [rng.choice([0, 37, 1600]), 1600, rng.choice([0, 1, 57, 199]), rng.choice([200, 100])][i]
|
|
if menu in ('crafter', 'crafter_be'):
|
|
return rng.choice([0, 0, 1])
|
|
if menu in ('loom', 'stonecutter'):
|
|
return rng.choice([-1, -1, 0, 0, 1, 2, 3, 30])
|
|
if menu == 'beacon':
|
|
# the levels, then the powers (encodeEffect: id + 1)
|
|
return rng.choice([0, 1, 2, 3, 4, 4]) if i == 0 else rng.choice([0, 0, 2, 4, 11])
|
|
if menu == 'enchanting':
|
|
# costs, the seed, then the clues
|
|
return [rng.choice([0, 1, 2, 5, 15, 30]) for _ in range(3)][0] if i < 3 else \
|
|
rng.randrange(-2**15, 2**15) if i == 3 else rng.choice([-1, -1, 0, 3, 12])
|
|
return 0
|
|
carried = {'loom': g.loom_stack, 'stonecutter': g.cut_stack, 'grindstone': g.grind_stack,
|
|
'anvil': g.anvil_stack, 'smithing': g.smith_stack}.get(menu, g.stack)() if rng.random() < 0.5 else '-'
|
|
if carried_food is not None:
|
|
carried = carried_food
|
|
cases.append({'menu': menu, 'creative': rng.random() < 0.25, 'slots': slots,
|
|
'levels': rng.choice([0, 1, 3, 8, 30, 39, 40]),
|
|
'carried': carried, 'data': [datum(i) for i in range(DATA.get(menu, 0))],
|
|
'ops': g.ops(size, menu, slots)})
|
|
(work / 'cases.jsonl').write_text(''.join(json.dumps(c) + '\n' for c in cases))
|
|
vanilla.run('VanillaMenuOracle', work / 'cases.jsonl', work / 'native.txt')
|
|
lib.cargo_example('horizon-client', 'menu_fixture', lib.RESOURCES, work / 'cases.jsonl', work / 'rust.txt')
|
|
native = (work / 'native.txt').read_text().split('\n')
|
|
rust = (work / 'rust.txt').read_text().split('\n')
|
|
|
|
def by_case(lines):
|
|
out, cur = [], []
|
|
for line in lines:
|
|
cur.append(line)
|
|
if line == 'end' or line.startswith('error-case'):
|
|
out.append(cur)
|
|
cur = []
|
|
return out
|
|
native, rust = by_case(native), by_case(rust)
|
|
bad = {}
|
|
for case, a, b in zip(cases, native, rust):
|
|
if a != b:
|
|
step = next(i for i, (x, y) in enumerate(zip(a, b)) if x != y) if len(a) == len(b) else 0
|
|
op = case['ops'][step - 1] if 0 < step <= len(case['ops']) else None
|
|
bad.setdefault((case['menu'], op[2] if op else 'init'), []).append((case, step, a, b))
|
|
total = sum(len(v) for v in bad.values())
|
|
for key, entries in sorted(bad.items(), key=lambda e: -len(e[1])):
|
|
print(f'{key}: {len(entries)} differing')
|
|
for case, step, a, b in entries[:args.limit]:
|
|
print(f' ops {case["ops"][:step]}\n start {a[0]}\n native {a[step]}\n rust {b[step]}')
|
|
print(f'{len(cases) - total}/{len(cases)} cases match')
|
|
raise SystemExit(1 if total else 0)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|