Files
horizon-airdef/tools/test_tab_list_parity.py
T
Ludovic Marie 8a32850f95 Lay out the player list exactly as vanilla PlayerTabOverlay does
tab_list ports PlayerTabOverlay: the comparator (list order, spectators,
team, name ignoring case), the 80-player limit and 20-row columns, heads
with the default skin by UUID and upside-down names, team and spectator
name styling, ping bars, the list objective as integer scores in their
number format or hearts with their change blink and the hp text fallback,
and the wrapped header and footer. Font::split_lines now follows
StringSplitter.splitLines and Text::resolve_legacy applies legacy codes
inside components. test_tab_list_parity runs vanilla's overlay against
examples/tab_list_fixture: 1,000 cases, 3,476 frames, 844,758 calls match.

The protocol gains the scoreboard, team and world border packets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 15:47:55 +02:00

185 lines
9.4 KiB
Python

#!/usr/bin/env python3
"""Compare the player list (tab list) with the vanilla 26.3 client.
The Java oracle (VanillaTabListOracle) runs vanilla's own
PlayerTabOverlay.extractRenderState, frame after frame, on a stand-in client
whose connection lists the case's players (game mode, latency, display name,
list order, hat layer, online mode for heads), whose level holds some of
them (upside-down Dinnerbone and Grumm) and whose real Scoreboard has the
case's teams (colour, prefix, suffix), `list` objective (integer or hearts,
number formats) and scores, with the header, footer, row background option
and Hud ticks. It records every fill, text (as styled runs), sprite and
face blit. `examples/tab_list_fixture` lays out the same frames with
`horizon_client::tab_list`; the ordered call lists must agree.
test_tab_list_parity.py [--count N] [--detail N]
"""
import argparse
import json
import os
import random
import subprocess
import sys
import uuid
try:
from . import lab, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, test_rust_parity as base, test_model_baking_parity as baking
PARITY = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity'
COLORS = ['black', 'dark_blue', 'dark_green', 'dark_aqua', 'dark_red', 'dark_purple', 'gold', 'gray', 'dark_gray',
'blue', 'green', 'aqua', 'red', 'light_purple', 'yellow', 'white']
WORDS = ['Welcome', 'to', 'the', 'server', 'Horizon', 'players', 'online', 'mc.example.net', 'Have', 'fun!',
'Supercalifragilisticexpialidocious', 'a', 'é', 'Ünïcödé', '§aGreen', '§lBold', '[VIP]', '1234567890']
NAMES = ['Steve', 'Alex', 'Notch', 'jeb_', 'Dinnerbone', 'Grumm', 'xX_Pro_Xx', 'a', 'Zed', 'zebra', 'Émile', 'ÆON',
'bob', 'Carl', '_under', '123', 'MMMMMMMMMMMMMMMM', 'iiiiiiii', 'Wide_W', 'ßtraße', 'Ⅻ', 'Mix3d_Case']
def component(rng, words=3, depth=0):
text = ' '.join(rng.choice(WORDS) for _ in range(words))
kind = rng.random()
if kind < 0.3:
return text
c = {'text': text}
if rng.random() < 0.5:
c['color'] = rng.choice(COLORS + ['#12ABEF'])
for flag in ('bold', 'italic', 'underlined', 'strikethrough', 'obfuscated'):
if rng.random() < 0.15:
c[flag] = rng.random() < 0.8
if depth < 2 and rng.random() < 0.4:
c['extra'] = [component(rng, rng.randint(1, 3), depth + 1) for _ in range(rng.randint(1, 2))]
if rng.random() < 0.08:
c = {'translate': 'multiplayer.player.list.hp', 'with': [text], 'color': rng.choice(COLORS)}
return c
def number_format(rng):
kind = rng.random()
if kind < 0.4:
return None
if kind < 0.55:
return {'type': 'blank'}
if kind < 0.85:
style = {'color': rng.choice(COLORS)}
if rng.random() < 0.4:
style['bold'] = True
return {'type': 'styled', 'style': style}
return {'type': 'fixed', 'value': component(rng, 1)}
def cases(count):
rng = random.Random(0x544142)
out = []
for n in range(count):
size = rng.choice([1, 1, 2, 3, 5, 8, 12, 19, 20, 21, 25, 40, 41, 60, 79, 80, 85, 100])
names = []
while len(names) < size:
name = rng.choice(NAMES) if rng.random() < 0.5 else ''.join(
rng.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_') for _ in range(rng.randint(1, 16)))
if name.lower() not in {x.lower() for x in names}:
names.append(name)
players = []
for name in names:
players.append({
'uuid': str(uuid.UUID(int=rng.getrandbits(128))), 'name': name,
'gameMode': rng.choice([0, 0, 0, 1, 2, 3]),
'latency': rng.choice([-1, 0, 1, 149, 150, 299, 300, 599, 600, 999, 1000, 5000, rng.randint(0, 2000)]),
'displayName': component(rng, rng.randint(1, 2)) if rng.random() < 0.2 else None,
'listOrder': rng.choice([0, 0, 0, 1, -1, 5, 2147483647, -2147483648]),
'showHat': rng.random() < 0.8, 'inLevel': rng.random() < 0.5,
})
teams = []
for t in range(rng.choice([0, 0, 1, 2, 4])):
members = [p['name'] for p in players if rng.random() < 0.3]
teams.append({'name': rng.choice(['red', 'Blue', 'team' + str(t), 'ä', 'z', 'A']) + str(t),
'color': rng.choice([None] + COLORS),
'prefix': rng.choice(['', '[R] ', {'text': '★ ', 'color': 'gold', 'bold': True}, component(rng, 1)]),
'suffix': rng.choice(['', ' ✔', {'text': ' (afk)', 'italic': True}]), 'members': members})
objective = None
if rng.random() < 0.7:
objective = {'name': 'obj', 'renderType': rng.choice(['integer', 'hearts', 'hearts']), 'numberFormat': number_format(rng)}
frames = []
tick = rng.randint(0, 100000)
values = {}
for f in range(rng.randint(1, 6)):
scores = {}
for p in players:
if objective and (f == 0 and rng.random() < 0.85 or rng.random() < 0.3):
v = rng.choice([0, 1, 2, 7, 19, 20, 21, 40, 99, 100, -3, 1234567, rng.randint(-50, 300)])
if p['name'] in values and rng.random() < 0.5:
v = values[p['name']] + rng.choice([-3, -1, 1, 2, 10])
values[p['name']] = v
scores[p['name']] = {'value': v, 'format': number_format(rng) if rng.random() < 0.2 else None}
reset = [p['name'] for p in players if objective and rng.random() < 0.03]
for r in reset:
values.pop(r, None)
tick += rng.choice([1, 1, 2, 3, 5, 10, 21, 40])
frames.append({'tick': tick, 'visible': rng.random() < 0.85, 'scores': scores, 'reset': reset})
header = footer = None
if rng.random() < 0.6:
header = rng.choice([component(rng, rng.randint(1, 30)), 'Line one\nLine two', '\n', 'trailing\n', ' two spaces ',
{'text': 'Header', 'extra': ['\n', component(rng, 12)]}])
if rng.random() < 0.5:
footer = rng.choice([component(rng, rng.randint(1, 30)), 'Footer', 'x\n\ny'])
out.append({'width': rng.choice([427, 320, 480, 640, 961, 160, 90, 300]), 'onlineMode': rng.random() < 0.7,
'backgroundForChatOnly': rng.random() < 0.8, 'opacity': rng.choice([0.5, 0.0, 1.0, 0.37]),
'header': header, 'footer': footer, 'teams': teams, 'objective': objective, 'players': players,
'frames': frames})
return out
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--count', type=int, default=700)
parser.add_argument('--detail', type=int, default=3)
args = parser.parse_args()
lock, jars, _ = base.verify_artifacts()
libraries = baking.client_libraries()
build = lab.LOCAL / 'rust-tab-list-parity'; build.mkdir(parents=True, exist_ok=True)
resources = lab.LOCAL / 'horizon-client' / '26.3'
chosen = cases(args.count)
inputs = build / 'inputs.jsonl'; inputs.write_text(''.join(json.dumps(c) + '\n' for c in chosen))
classes = build / 'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *libraries]))
def run(command, name):
with (build / (name + '.log')).open('w') as log:
result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
if result.returncode:
print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes,
*(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaTabListOracle'))], 'compile-java')
run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTabListOracle',
inputs, build / 'vanilla.jsonl'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'tab_list_fixture', '--',
resources, inputs, build / 'rust.jsonl'], 'rust')
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust)
errors, bad, frames, calls = [], [], 0, 0
for v, r in zip(vanilla, rust):
if 'error' in v:
errors.append(v['error']); continue
for i, (a, b) in enumerate(zip(v['frames'], r['frames'])):
frames += 1
calls += len(a)
if a != b:
first = next((k for k, (x, y) in enumerate(zip(a, b)) if x != y), min(len(a), len(b)))
bad.append((v['case'], i, first, a[first:first + 2], b[first:first + 2], len(a), len(b)))
break
for e in sorted(set(errors))[:5]:
print('ORACLE ERROR', e)
for case, i, k, a, b, la, lb in bad[:args.detail]:
print('MISMATCH', json.dumps(case)[:3000])
print(f' frame {i}, call {k} ({la} vanilla, {lb} Horizon calls)\n vanilla {a}\n horizon {b}')
print(f'{len(vanilla) - len(bad) - len(errors)}/{len(vanilla)} player lists match ({frames} frames, {calls} calls); '
f'{len(errors)} oracle errors')
if bad or errors:
sys.exit(1)
print('tab list parity ok')
if __name__ == '__main__':
main()