A `fly` benchmark replied with frame times only. With single player on its
server thread, the world's ticks no longer show in the frames, so a flight
could not tell how long the server took.
The summary now has tick_ms and tick_ms_max: the world's smoothed tick time
(the F3 server line) averaged and at its highest over the flight. On the
server thread it is the server's.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Block triggers counted only the host's own player and the minecarts, so a
guest stepping on a plate did nothing. The guests in the level, not
spectators, now trigger them through Entity.checkInsideBlocks and are
counted by the plates' entity queries. On the server thread no block
ticks run at all yet (#890).
lan_e2e.py plates: a stone plate under the guest, on both sides.
Part of #848
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: Merged. Fixes#861: a ctl tp/fly move is sent even while the destination chunk isn't loaded, the single-player owner is exempt from the move check as in vanilla, and wait-ready waits for the level around the player. lan, dedicated_server, server_entities and server_dimension_players pass.
🤖 Agent: Merged. CI parity and verify passed, and on current main with this branch, horizon-client clippy is clean and all its tests pass (873 lib + integration). Consumables now finish as in vanilla 26.3.
With the world on its server thread, a horizon-ctl `tp` or `fly` moved the
window's player to chunks the server had not sent. The client skips its
tick while its own chunk isn't loaded, so it never sent the move, and the
server kept streaming the old area: "loading terrain..." forever.
- The client sends a move made where nothing is loaded (by horizon-ctl;
a player who walks there has already sent it), so the server streams
the chunks there.
- The integrated server doesn't check its owner's moves, as vanilla's
`shouldCheckPlayerMovement` (`isSingleplayerOwner`); a long `tp` was
"moved too quickly".
- `wait-ready` on a server also waits for the level around the player
(`PlayerLoaded`); the status shows it as `server.loaded`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
BrewingStandBlock opens BrewingStandMenu for a guest: the host clicks it on
the menu engine over the stand's slots (one bottle per slot, ingredient and
fuel slots, quick moves by item) and sends its four data slots
(BrewingStandBlockEntity.dataAccess). The guest opens minecraft:brewing_stand
menus, maps their slots, predicts clicks on Kind::Brewing and shows the
times. Reported by Tydragon00.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Neither side sent LivingEntity.DATA_LIVING_ENTITY_FLAGS for players, so
no one saw another player eat, draw a bow or raise a shield. The host now
sends the item in use and its hand for itself and every guest (always:
the trackers send only the entries that changed, and stopping is a change
back to 0), and draws its guests' bodies using their items. A guest's
client starts and stops the other players' item use from the flags and
drops their eating crumbs at their mouth (Consumable.onConsumeTick); the
eating sounds already come from the server.
lan_e2e.py eating: the host and the guest each see the other eat bread,
and stop.
Part of #803
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The host ignored ServerboundPunchPacket, so a guest mining or hitting
swung only on its own screen; only the first swing a guest's use ever
started went out, the host's own swings never did, the host drew no swing
on guests' bodies and a guest's client ignored
ClientboundSwingAnimationPacket.
The host now swings the guest's hand on a punch (handlePunch), sends each
tick's guest swings to the players around and the host's own to the
guests, and swings and ticks the guests' bodies it draws. A use the server
ran that swung goes back to the guest too: Horizon's client does not run
uses itself, so it never predicted that swing (the hoe). The guest's
client swings itself or the other entity on the packet.
lan_e2e.py swings: mining swings seen from each side, and the guest's own
hoe swing.
Part of #848
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The host told guests of a hurt mob with EntityEvent 2, which 26.3's
clients read as a kinetic hit, not a hurt. It now sends
ClientboundDamageEventPacket (ServerLevel.broadcastDamageEvent) with the
damage type and the attacker, and the guest's client restarts the hurt
flash and jolts the walk animation (LivingEntity.handleDamageEvent).
lan_e2e.py hurt: a pig the guest hits and one the host hits flash on
both sides.
Part of #848
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The guest's client closed every menu it had no screen for, so hoppers
(MenuType.HOPPER) and dispensers and droppers (GENERIC_3x3) did nothing.
They open as their 5 and 9 slot screens now, drawn by the menu's type
and under the server's title.
lan_e2e.py machines: each opens with its slots and keeps a stack the guest
shift-clicks in.
Part of #848
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The host sent the overworld clock's rate even while /time pause held it
(ServerClockInstance.packNetworkState sends 0 when paused), so a guest's
day kept running. A guest also moved its clock by the rounded rate each
client tick and never caught up when the server's game-time sync moved
game_time on, so a guest whose game lagged fell behind for good.
ClientClockManager.tick advances the clock by the game time passed, with
its partial tick; the guest now does the same.
lan_e2e.py time: the paused clock and a guest stalled for 4 seconds.
Part of #848
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A client joined to a server (and the window on the server thread) keeps the
server's chat lines in its own list. The event log only counted the local
chat's lines, so `wait-for chat` never saw a line from the server.
The remote client counts the lines it receives. The event log reads that
count and those lines while connected.
lan_e2e gets a `chat` check: a line the host sends reaches the guest's
event log, and on the server thread the host window's too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With single player on its server thread, the window is a client of the
server. The agent's `command` went out as the owner's chat and returned no
output, so harnesses that read a command's feedback (lan_e2e trials) failed.
Control `give` and `time` changed only the window's copy of the world.
The server now runs them as single player's console does without a server
thread (`as_console`): as the world's owner, in the owner's level. The
feedback goes to the owner's chat and comes back to the agent. `give` runs
`give @s`, and `time` sets the server's clock too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: Merged after #855 and the real verify. block_removal 4000/4000 including 319 mining cases; dispenser, crafter, composter, mace and use_item_on pass.
With HORIZON_SPIKES=MS, a dedicated or integrated server tick longer than
MS ms is logged with the server thread's CPU time over the tick and the
tick's spans (tick_mobs, streaming, ...). A tick with much more wall time
than CPU time waited for a lock or for a core.
The spans recorded on a server thread were never taken before, so they
grew for as long as the server ran with HORIZON_SPIKES set.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every spawn attempt (`NaturalSpawner.getRandomPosWithin`) asks for the
WORLD_SURFACE height of a column. Horizon scanned the column down for it
each time, a chunk-map lookup and a block-name compare per block. Vanilla
reads the chunk's heightmap.
Chunks now keep WORLD_SURFACE: built on the first read, and dropped by a
`set` that can move a column's surface (`Heightmap.update` leaves writes
two or more below it alone). Natural spawning, the spawn rules' bat check
and beacons read it.
The unused `heights` field (never written after `Chunk::empty`) is gone.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ServerLevel.removePlayerImmediately and addRespawnedPlayer: when a player
respawns, every other player tracking it gets RemoveEntities and the next
tick pairs it again as a new entity. The hub only cleared the respawned
player's own tracker, so the others kept the dead body, lying down, wherever
the player went (the host window too, on the server thread).
The in-frame LAN host's death now reaches its guests (LivingEntity.die's
EntityEvent DEATH), and its respawn goes through the same path.
lan_e2e gets a `respawn` check: the host dies and respawns (and on the
server thread the guest too), and the other side's client draws it dead,
then alive. `status` lists the other players a client draws dead.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
test_block_removal_parity gains a "mine" removal: VanillaDispenserOracle
calls the real ServerPlayerGameMode.destroyBlock for a survival player holding
a pickaxe, axe, shovel, sword, shears, a mace or nothing, and Horizon's
dispense fixture calls break_block, the path every player's mining takes (the
single player game, the server thread and LAN guests). It compares the drops,
the spilled contents, experience, sounds, events, statistics and the held
stack. On main it shows every mined container losing its contents (#844, fixed
by #855) and three gaps of Horizon's own, fixed here:
- ItemStack.mineBlock: an item with a tool component counts as used, and wears
its damage_per_block (2 for swords, the mace and the trident), also the mace
and trident, whose tool component has no rules. Shears wear on every block
but fire (ShearsItem.mineBlock).
- DecoratedPotBlock.playerWillDestroy: a pot mined with an item in
breaks_decorated_pots, unless an enchantment prevents it, cracks first and
shatters.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 Agent: Merged after the real verify passed. Waypoints::tick −33% (166 → 111 µs median), with byte-identical packets (530,834, same hash). locator_bar, lan, dedicated_server and server_dimension_players pass.
🤖 Agent: Merged. Entities::tick −37% (112–116 → 71–75 µs median per tick at 40 bots + 570 entities), with the same 14,159,154 packets before and after. 9 covering harnesses pass (server_entities, lan, dedicated_server, server_dimension_players, locator_bar and the entity ones); main has no lan/ changes since.
🤖 Agent: Merged after the real verify passed. Combined check on this branch: fmt, clippy, workspace tests, and the worldgen, structure_density, chunk_generation and world_spawn harnesses pass. modpacks-6's own integration passed 298/298 harnesses with the start oracle at 35/35.
🤖 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.
A moving player updates its connection with every other player, three
times a tick (updateWaypoint, then updatePlayer at the position change and
at ServerChunkCache.move), so with 40 players there are about 4800
updates a tick. Each looked the connection up twice and both players up
four to six times. Now an update finds the connection's place once and
resolves the two players once, then checks, updates or remakes it there.
The same packets go out, in the same order.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Entity tracking still asks every client about every entity each tick
(vanilla re-checks each pair whenever the player sends a move, so for
moving players it does the same), but the check is cheaper:
- each entity's position, id, range and chunk are read once a tick into
a compact list, not from its EntityState once per client;
- each client looks up each of the tick's chunks once in the chunks it
holds, not once per entity in it;
- an entity with no changes and no client starting to track it skips the
loop over the clients.
The decisions and the packets are the same, in the same order.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A value back at its default is left out of an entity's state, so the
tracker never told clients that a player stopped crouching or a mob stopped
burning: Entity's shared flags and pose now go back to 0. On a client of a
server (the host window on the server thread), another player's crouch flag
now reaches their model and name tag.
From #731's server-thread list; lan_e2e's walls check passed in-frame and
failed with --server-thread.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
🤖 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).
ClientboundUpdateAttributesPacket, as vanilla's ServerEntity sends it: every
client-syncable instance when an entity is paired, the changed ones with the
dirty entity data, and a player's dirty set to the player itself.
- Mobs and armor stands report the instances vanilla would have created
(movement speed, finalizeSpawn's bases and modifiers, the baby modifier,
effects', equipment's and /attribute's), players their LiveAttributes.
- Guests get the per-tick movement speed instance and the creative reach
modifiers (ServerPlayer.updatePlayerAttributes).
- cube::set_size sets the attribute bases as AbstractCubeMob.setSize does,
so a summoned slime has its size's health and speed.
- server_entities compares attributes again, the player's own too, with a
slime and a scaled pig in its scene.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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>
🤖 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!