Right-clicking a furnace as a guest did nothing: the host only handed
chests, barrels, hoppers, dispensers and shulker boxes over. It now opens
the furnace's own menu (minecraft:furnace, blast_furnace or smoker),
runs the guest's clicks through the host's AbstractFurnaceMenu (fuel slot,
take-only result, shift-clicks by recipe and fuel, a new input restarts
cooking) and keeps the client's progress arrows in step with
ContainerSetData. The dedicated server harness now opens a furnace and
smelts an ore in it on both servers.
Fixes#540
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
component_nbt wrapped the numbers of a mixed list under the empty key, and
the NBT writer then wrapped those wrappers again, as ListTag.wrapIfNeeded
does. A vanilla client reading /give's reply ("Gave 1 [Raw Iron] to ...")
unwrapped once, found a {"": 1} argument and dropped the connection. The
list is now left to the writer.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The resource folder is shared: worktrees and parity harnesses link one copy,
and the launcher copies a prepared folder to each new compatible version. A
snapshot there would be read by builds that resolve the tables differently
while the VERSION constant stays the same. Keep it in the game's own
.horizon-cache (set by the client; tools, tests and servers don't cache), add
the running executable to its key, and skip hashing the resources when there
is no snapshot. Postcard without default features drops heapless and the
unmaintained atomic-polyfill from the lockfile.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a server the F key swapped the hands only on the client, and the
inventory menu's off-hand slot (InventoryMenu slot 45) was missing from the
client's slot table, so clicks on it went nowhere and the server's updates
of it were dropped (#543).
- F sends ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND and predicts
nothing, as vanilla's Minecraft.handleKeybinds does (not for spectators).
- Inventory menu slot 45 is the off hand; SetPlayerInventory slot 40 too.
- The server swaps only for non-spectators and stops the item in use
(ServerGamePacketListenerImpl.handlePlayerAction).
Fixes#543
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A guest's STOP_DESTROY_BLOCK cleared the digging before the host's own
count was done, so a block the client broke stayed on the server and the
player fell through or froze on it. The host now follows
ServerPlayerGameMode: it breaks the block when its progress since START is
at least 0.7 and otherwise finishes the dig alone (the delayed destroy).
Block acks go out after the tick's block updates, and the client keeps
predicted blocks until the server acknowledges them
(BlockStatePredictionHandler), so a refused break comes back instead of
being lost.
Fixes#500
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A vanilla 26.3 client that died on a Horizon server stayed on its loading
screen after pressing Respawn (#566): ClientPacketListener.handleRespawn
starts a LevelLoadTracker that waits for the level info's "level chunks
load start" game event and the chunk under the player, and Horizon's
respawn sent neither the level info nor the chunk cache centre.
The hub's respawn now follows PlayerList.respawn: the entities paired with
the dead player are removed (one packet each), its chunks are dropped
without ForgetLevelChunk (as PlayerChunkSender does for a dead player) and
sent again, the abilities, then Respawn (with the last death location),
the teleport to the spawn facing its direction, the default spawn,
difficulty, experience, post effects, the level info, the permission
level, the chunk cache centre and the inventory. A dying guest also gets
the death animation event and no health update while dead, as vanilla's
ServerPlayer.die does.
Guests' commands also ran at the host's permission level: an operator on
a dedicated server could not run operator commands (and LAN guests ran
the host's level). They now run at the guest's own level, as the command
tree they are sent says.
The dedicated server harness covers it: after trading, the vanilla-codec
client is made an operator by the console, runs /kill, respawns, and the
packets from the death screen to the respawned inventory are compared
with vanilla's, then the level must load where it respawned. The client
also stops sending a movement packet beside each teleport acceptance
during the respawn: the 26.3 client sends the acceptance alone, and
vanilla's server kicks a second position in the same tick.
Fixes#566
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Chunk packets took nearly all of the server's tick with players moving
about: every send re-encoded the column for that player (each section
unpacked and re-paletted with linear searches, light layers packed a
nibble at a time, heightmaps primed again) and unpacked all 9 x 24
sections around it to find which light layers exist. At 50 walking
bots that was ~85 % of the tick, 280-470 ms ticks against vanilla's
33 ms on the benchmark machine.
The encoder now keeps what a resident section gives the wire (its
bytes, whether it holds block entity blocks, whether it is all air) by
the section's address. Sections are immutable behind Arc and edits go
through Arc::make_mut, so an edited section moves to a new address,
and the cache's Weak keeps an old address from being reused: the same
address is the same unchanged section. Heightmaps are kept per column
the same way. Block entity tags are still read for every packet. The
bytes sent don't change.
Also: Paletted::from_values uses an index table instead of linear
palette searches (the same palette order and bits), the all-air check
reads the palette first and stops at the first block, uniform sections
skip unpacking, and light layers pack two blocks per byte in one pass.
On a busy Mac mini with 50 walking bots (`tick query`): about 400 ms
ticks with the faster palette and air checks alone, 14 ms with the
caches.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With single player on its server thread, the window is the server's
client, and some of what it answered was its own empty side:
- `horizon-ctl save` and `save-all` returned ok without saving: the
window's save skips worlds it is connected to. They now save on the
server thread (`Integrated::call`).
- `horizon-ctl chat-log` read the window's local chat, which never
showed what the server said (command feedback, joins). It reads the
connection's chat, as the agent's chat query already did.
- The game's own messages (Open to LAN, screenshots...) went to that
local chat, which is not drawn while connected: they now join the
connection's chat.
- `state` names the world (the server thread's `LevelName`).
- The client follows its permission level (EntityEvent 24..28,
LocalPlayer.setPermissionLevel), which the commands the chat offers
and checks depend on.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each dimension change builds the destination's generator again, and with
it a new structure state, so the 128 stronghold ring searches ran again on
every return to the Overworld (about 1.5 s on two workers) and held up the
first new chunks. The ring positions depend only on the shared generator
data, the seed and the dimension's generator definition, so the generator
data now keeps them by those (the last eight), and later generators for
the same world and dimension share them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Single player on its server thread could not be opened to the LAN: the
window is a client of that server, and Open to LAN, /publish and
`horizon-ctl lan` tried to start a second hub on the window's side.
The server thread now publishes itself, as IntegratedServer.publishServer
does:
- The window asks its server with `Integrated::call` (executeBlocking):
a task run between two ticks, while paused too, with its answer.
- Publishing binds the port at once (a busy port fails right away), then
the hub starts listening and announcing the world (LanServerPinger)
with the MOTD "<owner> - <world>". Until then only the owner may log
in; afterwards anyone may, and status pings are answered.
- Unpublishing stops the listener and sends every player but the owner
away (multiplayer.disconnect.server_shutdown).
- /publish and /unpublish run on the server for the player who types
them, and the integrated server's command tree (with publish, without
the dedicated-only commands) is what its players get.
- The owner's level follows Allow Commands; other players get game
master commands only when guests may use commands and the world allows
them (IntegratedServer.getCustomPermissionLevel). Every player's
command runs at their own level.
- The world options screen reads and applies its settings on the
server: difficulty, default and personal game mode, Allow Commands and
the LAN settings; the window shows the outcome.
- A published world does not pause (Minecraft.pause needs
!isPublished), and F3+Escape follows the same rule.
- Memory connections are never compressed, whatever the threshold
(Connection.isMemoryConnection), so network players get the usual 256.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>