🤖 Agent: Merged. Mesh scheduling while flying at RD32: 0.62/0.72 → 0.36/0.22 ms per frame; at rest with ~12,000 waiting sections: 0.30–0.91 → 0.06–0.22 ms. Same checks as #865.
🤖 Agent: Merged. Terrain vertices go 28→24 B: vertex memory −14%, Metal GPU 0.62→0.54 ms. HD 620 FPS is unchanged (vertex size isn't its bottleneck). Screenshots: the only differing pixels are on water, at main-vs-main noise level, with identical drawn sections. 95/95 covering harnesses on an integration with #866 and #867.
🤖 Agent: Merged after the real verify passed. Output is byte-identical (palettes / region files), and 17 covering harnesses passed with both PRs on main 256f7c20 (since then main has only #751, a settings UI change).
🤖 Agent: Merged after the real verify passed. Output is byte-identical (palettes / region files), and 17 covering harnesses passed with both PRs on main 256f7c20 (since then main has only #751, a settings UI change).
Reads every chunk of a saved dimension, then times SaveDir's save_later and
flush against the same encoding and compression done on one thread, and
checks the written chunks byte for byte.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Sections waiting to be remeshed were one hash set that the render thread
walked section by section every frame, though every check (column loaded,
in view, its 3x3 lit, its region) holds for a whole column. At RD 32 about
12,000 sections wait at the edge of the lit area at any time. They are now
kept per column (a bit per section index), so each frame looks at each
column once and meshes all of its ready sections together.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Relighting block edits and relit chunks collected every changed cell,
sorted and de-duplicated them, then marked the sections around each cell
for remeshing. Vanilla's light engine reports changed sections to
LevelRenderer instead. LightChanges now keeps, per changed section, which
of 27 border classes (low face, inside, high face per axis) its changed
cells fall in; that gives exactly the same dirty sections and light log
without keeping or sorting the cells.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
TerrainVertex goes from 28 to 24 bytes: the UV becomes two u16 in 32768
steps per unit, which hold model UVs (multiples of 1/16 and their halves)
exactly and decode exactly in terrain.wgsl. The position stays a float:
fixed point moves the edges of offset plants and rotated elements by a
fraction of a pixel.
Section vertex memory drops 14% (RD 16: 380 -> 325 MB, arena 503 -> 369 MB);
pixels are unchanged on Metal and Vulkan outside animated water.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: Merged. CI parity passed 94 of 95. The one miss, tooltip_display, passes locally on main with this branch, and so does options. Thanks LookImEcho-Rick!
The writer thread encoded (NBT) and zlib-compressed every chunk of a batch
one after another before writing them. A batch of at least 8 chunks is now
shared out to scoped helper threads (at most half the hardware threads),
which take the next chunk as they finish one. The results are put back in
submission order and written exactly as before, so the region files are
byte-identical: each chunk's bytes depend only on the chunk, and sector
allocation follows the same write order.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
palette_ids (behind PalettedContainer::pack, every saved and sent section,
and from_values, every generated one) scanned the palette for each of the
4096 values while it had up to 16 entries, then hashed every value with
SipHash. A run of one value is now matched once, and past 16 entries a
thread-local table indexed by value (block states and biomes are below
65536) replaces the hash map; only the palette's entries are set, and they
are cleared before returning. The output is unchanged: palette in
first-occurrence order and the same ids.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: Merged. tick_lan is 40–55% cheaper and MSPT about 20% lower (40 bots, ~600 entities). The agent ran 95/95 harnesses (--changed) with #842 on main 4b43242a. The orchestrator then ran clippy and the lan tests on current main with both: clean.
🤖 Agent: Merged. light_chunk is 28% faster, light parity shows 0 differing values against vanilla 26.3, and CI parity passed on a merge with main after #824's light changes. Thanks rdbt!
🤖 Agent: Merged. Reviewed against vanilla: landing comes from Entity.move's vertical collision, the landing position is blockPosition(), velocity is zeroed per axis, and placement goes through Level.isUnobstructed with the collision shape. Locally on this head, fmt and clippy are clean, and contextual_collision, level_place, placement, powder_snow_collision and world_movement all PASS. Thanks LookImEcho-Rick!
🤖 Agent: Merged. CI parity passed 88 of 89 harnesses. The one miss, dedicated_server (a known intermittent failure), passes locally on this head. Thanks rdbt!
ServerWaypointManager's per-tick work for every moving player copied each
connection out of its row (its icon's style string too), scanned the row
again to put it back, copied the lists of players and waypoints it walked,
and looked players up through SipHash. Connections are now updated where
they are (the same row order and the same packets), the lists are walked
by index and the maps use FxHash.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every guest had its own copy of what it was last told about every entity,
so each tick compared each entity's data and built and encoded its update
packets once per guest. A level now keeps one ServerEntity state per
entity (ChunkMap.entityMap), whose changes are worked out once a tick,
encoded once and sent to every guest tracking it; a guest's Tracker is the
set of entities it is paired with. The update cadence is the entity's own
tickCount, as vanilla's, and late clients are paired with the data the
others hold. The per-tick copy of every entity state, the id lists and the
packet lists are gone too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: merged: decoration_order::vanilla_order on flat arrays (RD32 8.14→1.06 ms per call; ticket order unchanged, checked against the old version). Combined on current main with #834/#835: clippy, client + world tests PASS.
🤖 Agent: merged: section uploads through one reused staging buffer and one encoder, as vanilla's SectionRenderDispatcher (RD32 exploring: FPS 43.5→56.0, CPU 23.7→18.6 ms/frame, p99 122→106 ms; sections drawn identical in 12 views). Combined on current main with #834/#835: clippy, client + world tests PASS.
Rust's bool parser takes only true/false, so the fixture failed on Python's
True/False; Java's Boolean.parseBoolean ignores case.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: merged: LAN guests and the server-thread game keep each chunk's light and get vanilla light updates (travel CPU −17%, light_chunk −35%; lan_e2e light PASS with and without --server-thread).
🤖 Agent: merged: brewing stands tick in the level's single ticker list, in vanilla's order. perf-ticks-7's four PRs together on main d85a3603: clippy, 861 client + world tests, 19 harnesses (light, lan, dedicated_server, save_roundtrip, world_reopen, disk, datafix ×6, world, server_world_gen, block_entity ×4, chunk_stage) PASS.
🤖 Agent: merged: chunks saved in place in their region file, as vanilla (save into a full region 80.3→7.1 ms). perf-ticks-7's four PRs together on main d85a3603: clippy, 861 client + world tests, 19 harnesses (light, lan, dedicated_server, save_roundtrip, world_reopen, disk, datafix ×6, world, server_world_gen, block_entity ×4, chunk_stage) PASS.
Queue::write_buffer creates a staging buffer for every call: on Metal a
kernel call to make the buffer, then page faults while the mesh is copied
into fresh memory. While exploring at render distance 32 the render thread
made two such writes per uploaded section, plus one for its flat-draw ids.
Section meshes and flat ids now go through their own StagingBelt (4 MiB
mapped buffers, reused once the GPU has read them) into one encoder that
the frame's submission runs ahead of its own commands. A page of the
section arena that grows records its copy into that encoder too, so copies
recorded before the grow reach the grown buffer. A frame that is not drawn
still submits the copies, and more than 64 MiB of them are submitted early.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A remote client (a LAN guest, or the game on its server thread) threw away
the light in each LevelChunkWithLight and relit the column and its
neighbours itself. It now applies the sky and block layers as
ClientPacketListener.applyLightData does, and relights only block changes,
as vanilla's client does.
The hub now sends ClientboundLightUpdatePacket for the light sections that
changed in a column to the players for whom it is on the tracked border
(ChunkHolder.broadcastChanges), so light from blocks a guest doesn't track
reaches it.
horizon-ctl gains 'light X1 Y1 Z1 X2 Y2 Z2', and lan_e2e a 'light' check
comparing the guest's light with the host's.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: merged: worldgen block states rewritten to 26.3's format (1,005 files in 17 mods). Combined check of main + modpacks-5's six: clippy, tests, worldgen structure_density block_properties registry_fluid chunk_stage PASS.
🤖 Agent: merged secure chat as vanilla 26.3's server (chat sessions, signed chat and commands, enforce-secure-profile; secure_chat harness identical to vanilla offline and online; 7 server harnesses pass).
🤖 Agent: merged: the integrated server follows the window's render distance past 32 (fixes#804), and the lan_e2e hazards check now finds the guest by name (the server-thread hunger gap was a test bug).
IntegratedServer.tickServer: the server takes the window's render and
simulation distances when they change ("Changing view distance to N, from
M"), tells every player (SetChunkCacheRadius, SetSimulationDistance), and
each player's chunks follow, up to what they asked for. The integrated
server no longer clamps the view distance to 32, and a remote client sends
its render distance again when it changes (Options.broadcastOptions),
past 32 too. Fixes#804.
lan_e2e: a distance check (--server-thread), and the guest is found by
name in lan status, where the server thread lists the owner too: the
hazards check read the owner's food (the "no hunger from moving" gap).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
tick_block_entity_anims rebuilt a map of every drawn block entity, sorted
it and swept the animation states against it every tick. The renderer now
keeps a revision that changes when its block entities do, and the sorted
ticker list is rebuilt only then. The animation states use FxHashMap.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Chat session updates with their profile key checked against the services'
keys, signed chat and the message chain, last-seen acknowledgements, the
signature cache, signed say/me/msg, enforce-secure-profile, and vanilla's
log lines. Offline servers and players without a chat session chat
unsigned, as on vanilla. tools/test_secure_chat_parity.py compares both
servers with test keys and a mock services server.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Repurposed Structures' and Moog's jigsaws check biomes and terrain height in
a radius and refuse to start in liquid; their spreads keep a minimum
distance from the world origin and away from several other sets. Carry maps
them to vanilla's jigsaw and random spread and writes those rules under
horizon: keys; the game now runs them (start_checks.rs, the spread's
min distance and exclusion sets). Vanilla data has none of the keys.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The game, like vanilla, refuses a processor list holding a type it does not
know, and with it every pool naming the list, so those structures did not
generate at all. Carry now takes the library types out of processor lists
(files and inline ones in pool elements) and counts them by type in the
carry report: the structures generate, undecorated. On ATM10's carried
mods: 1,427 processors of 146 types; pool decode failures 31 -> 0.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Repurposed Structures' and Moog's jigsaws and spreads add rules on top of
vanilla's; mapped to vanilla they were lost, and Moog's spreads structures
1.65 times as far apart as its files say, so MVS alone started 9x as often
as on NeoForge. Carry now writes the start rules under
horizon:start_checks, the minimum distance and the super exclusion zone's
sets (from the mod's structure set tags) under horizon: placement keys,
and scales Moog's spacing. Layout rules (piece clipping, burying) are still
lost and counted in the carry report's rules_lost.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>