On the server thread, lan_e2e --check light failed its border step (#891):
the guest's border chunk still had block light 0 next to glowstone placed
in the chunk past it. The server was right; the check was not.
same_light() waits until the host's light equals the guest's, but on the
server thread the host's game is a client too, and both are dark until
the light update arrives. They agreed at once, same_light returned, and
the next line read the guest's light before the update came.
The check now waits up to 100 ticks for the guest's border light, then
compares the host's with it.
With temporary logging on the server thread: the glowstone lands in a
finished chunk that isn't lit (the ring past what the guest tracks), so
the edit queues a full light job for its neighbours. The border chunk's
job then relights sections 15 to 17, and Hub::broadcast_light_changes
sends them to both clients as a tracked border chunk, as
ChunkMap.isChunkOnTrackedBorder does. Nothing in the engine changes.
Fixes#891
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. 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.
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>
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>
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>
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>
🤖 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!
🤖 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!
EntitySelector.findPlayers and EntityArgument's player targets on a
hosted world or dedicated server: every guest other than the one in place
is Target::Guest, found by name, UUID or selector, and what a command does
to them (give, gamemode, tp, kill, effect give/clear, data) runs with
their state swapped in, their own messages going to their chat. The
console, operators and command blocks can all target them; execute
as/at reads their position, rotation and eye height; a teleport into
another level (execute in, the console's Overworld, a destination in
another level) moves them there.
as_guest splits into enter_guest/leave_guest so that guest turns nest,
and a guest's commands run with the hub back in self.lan (queued per
packet), so they reach the other players (and /kick works for ops).
Item and advancement names and player names in feedback take vanilla's
component shape; /kill on a guest sends vanilla's death message.
Harness: tools/test_server_player_targets_parity.py.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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.
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 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).
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>
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>
Brewing stands were the last server ticker with a pass of its own over the
whole block entity map every tick. They now tick in their place in
Level.blockEntityTickers, as BrewingStandBlock.getTicker makes them: in
list order, only in block-ticking range and inside the world border, with
their bottle states written as each one ticks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A remote client's chat now sends ServerboundCommandSuggestionPacket for an
argument node whose provider is minecraft:ask_server (bossbar ids, data
storage, datapacks, team names, functions...), as ClientSuggestionProvider.customSuggestion
does. The suggestions are done when ClientboundCommandSuggestionsPacket
answers that id; its completions join the local ones (Suggestions.merge).
Replies to older requests are dropped.
The remote tree takes each node's provider from the packet only: a local
provider the server didn't send stood in for the server's before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
TitleCommand sends the targeted player ClientboundSetTitleText,
SetSubtitleText, SetActionBarText, SetTitlesAnimation and ClearTitles. A
guest's /title (the window's own player on the server thread too) only
changed the server's HUD; it is now sent to the guest. The remote client
showed titles and action bars as a bare line and ignored subtitles, times
and clearing; it now feeds the HUD's titles as ClientPacketListener does
(the action bar of a SystemChat overlay too) and ticks them (Gui.tick).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>