Commit Graph

68 Commits

Author SHA1 Message Date
Ludovic Marie def901b06f Merge remote-tracking branch 'origin/main' into integ/bl4 2026-10-18 20:09:06 +02:00
Ludovic Marie a714a9b6f8 Merge pull request #900 from ludovic111/fix/server-light-border
🤖 Agent: reviewed; verify passes.
2026-10-18 19:52:34 +02:00
Ludovic Marie d4d46b1bb7 Merge remote-tracking branch 'origin/fix/lan-paused-clock' into integ/bl4
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 19:22:08 +02:00
Ludovic Marie faba097ff2 Merge remote-tracking branch 'origin/fix/lan-swings' into integ/bl4
# Conflicts:
#	crates/horizon-client/src/game/lan_actions.rs
#	tools/lan_e2e.py
2026-10-18 19:22:07 +02:00
Ludovic Marie c234641ead Merge remote-tracking branch 'origin/fix/lan-damage-events' into integ/bl4
# Conflicts:
#	crates/horizon-protocol/src/packets/play.rs
#	tools/lan_e2e.py
2026-10-18 19:17:43 +02:00
Ludovic Marie bff5121f6e Merge remote-tracking branch 'origin/fix/lan-guest-pressure-plates' into integ/bl4
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 19:16:57 +02:00
Ludovic Marie 40fbae13b6 Merge remote-tracking branch 'origin/fix/lan-guest-brewing' into integ/bl4
# Conflicts:
#	crates/horizon-client/src/game/lan_crafting.rs
#	tools/lan_e2e.py
2026-10-18 19:16:56 +02:00
Ludovic Marie feb85f6d15 Merge remote-tracking branch 'origin/fix/lan-guest-machine-screens' into integ/bl4
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 19:16:35 +02:00
Ludovic Marie ac2547c24a lan_e2e light: wait for the border chunk's light before comparing
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>
2026-10-18 19:03:29 +02:00
Ludovic Marie dd1fd6d3c5 Merge remote-tracking branch 'origin/fix/remote-chat-events' into integ/sh7
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 17:23:49 +02:00
Ludovic Marie 159a5dfa5f LAN: pressure plates, tripwires and detector rails see the guests
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>
2026-10-18 16:59:56 +02:00
Ludovic Marie 5b47d53dbf LAN: guests use brewing stands
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>
2026-10-18 16:41:07 +02:00
Ludovic Marie 89cbe03ebe LAN: everyone sees players' arm swings
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>
2026-10-18 16:41:06 +02:00
Ludovic Marie 0bc19687aa LAN: guests see mobs flash when hit
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>
2026-10-18 16:41:06 +02:00
Ludovic Marie a49f93f9ef LAN: guests open hoppers, dispensers and droppers
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>
2026-10-18 16:41:06 +02:00
Ludovic Marie 567cc33576 LAN: the guest's clock stops with /time pause and keeps up with the server's game time
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>
2026-10-18 16:41:05 +02:00
Ludovic Marie 164f1dfd52 Feed a remote client's chat lines to the agent's event log
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>
2026-10-18 16:39:37 +02:00
Ludovic Marie 20d9c4c984 Pair a respawned player again for the other players
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>
2026-10-18 16:11:08 +02:00
Ludovic Marie 817a71ffa5 Clients keep the light the server sends; the server sends light updates
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>
2026-10-18 09:39:50 +02:00
Ludovic Marie a2363a3bf6 fix(server-thread): the integrated server follows the render distance, past 32 too
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>
2026-10-18 08:09:49 +02:00
Ludovic Marie c2f3d01ee4 Merge remote-tracking branch 'pr/779' into integ/mp-sh
# Conflicts:
#	mods/horizon/src/test/java/dev/horizonlab/parity/LocatorBarClient.java
2026-10-18 06:35:13 +02:00
Ludovic Marie 6829da90f2 Merge remote-tracking branch 'pr/769' into integ/mp-sh
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 06:34:56 +02:00
Ludovic Marie daa8b2f528 Merge remote-tracking branch 'pr/760' into integ/mp-sh
# Conflicts:
#	tools/lan_e2e.py
2026-10-18 06:34:26 +02:00
Ludovic Marie 2e2f4a6581 Merge pull request #809 from ludovic111/fix/ask-server-suggestions
🤖 Agent: merged: ask_server suggestions. Combined check of main + perf-ticks-6's six: clippy, tests, 8 harnesses PASS.
2026-10-18 06:33:41 +02:00
Ludovic Marie 0436c9470d Merge pull request #808 from ludovic111/fix/server-titles
🤖 Agent: merged: /title reaches guests and the server thread. Combined check of main + perf-ticks-6's six: clippy, tests, 8 harnesses PASS.
2026-10-18 06:33:36 +02:00
Ludovic Marie ff6e01de03 Command suggestions: ask the server for nodes the tree marks ask_server
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>
2026-10-18 04:57:29 +02:00
Ludovic Marie c12f5cf41a Server titles: /title reaches the guest, and its HUD shows and clears them
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>
2026-10-18 04:00:48 +02:00
Ludovic Marie 65d5a35cd2 Server: a dead guest is sent its health of 0, as ServerPlayer.doTick does
The hub held SetHealth back once a guest died, so the guest's health
stayed at its last positive value under the death screen. ServerPlayer
sends it every tick it changes, dead or not, and only when the health or
the food level changes or the saturation reaches or leaves zero: the hub
sent it on every change of saturation too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 04:00:24 +02:00
Ludovic Marie 209b898c02 The console's and players' command feedback reaches the operators
CommandSourceStack.broadcastToAdmins beyond a guest on a dedicated server:

- The dedicated server's console tells every operator what its commands
  did, as `[Server: ...]`, when `broadcast-console-to-ops` is on
  (DedicatedServer.shouldInformAdmins). This covers the game's commands
  and the dedicated-only ones vanilla broadcasts (op, deop, ban, pardon,
  kick, whitelist, save-all, save-on/off, stop).
- In a world open to LAN, the host, an operator when commands are
  allowed, hears of its guests' commands, and op guests hear of the
  host's.
- A player's name in the line is their display name, with the `/tell`
  suggestion, the entity hover and the insertion (Player.getDisplayName).

New harness test_server_ops_feedback_parity: two vanilla-codec
operators' system chat while the console and one of them run commands,
deop and op, toggle send_command_feedback and save, with
broadcast-console-to-ops on and off. LocatorBarClient can record system
chat (`chat on`). lan_e2e's feedback check also asserts the host is told.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 03:02:11 +02:00
Ludovic Marie 5e1abf2b4e Clients of a server show its primed TNT, falling blocks, projectiles and crystals
A Horizon client of a server places what PR #766 sends: primed TNT with
its fuse, falling blocks with their block state and start position,
arrows (critical, in the ground), snowballs, eggs, pearls, fireballs,
wither skulls, wind charges and llama spit, tridents, firework rockets
and end crystals with their beam and base. They interpolate like mobs,
turn with the move packets, and are cleared with the connection, a
respawn or a dimension change.

`status` lists them (`projectiles`), and lan_e2e has a `projectiles`
check: the guest sees the host's primed TNT, end crystal and landed
arrow where the host has them, and a falling block lands on both sides.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 03:00:42 +02:00
Ludovic Marie 583502f0f4 Clients of a server show its boats, minecarts, armor stands, frames and paintings
ClientPacketListener.handleAddEntity for the objects a server tracks: a
Horizon client of a server (a LAN host, a dedicated server, single
player's server thread) now places the boats, minecarts, armor stands,
item frames and paintings it is sent, where the server says.

- Spawn: carts by kind, boats and rafts by wood (with a chest), armor
  stands, frames and paintings at their block with the direction from the
  spawn data.
- Entity data: frame items and rotation, painting variants (a registry
  holder), armor stand flags and health, boat paddles, vehicle hurt.
- Equipment: what an armor stand wears and holds.
- Moves interpolate like mobs'; rotation and ground state follow.
- They are cleared with the connection, a respawn or a dimension change.

`status` lists them (`objects`), and lan_e2e has an `objects` check: the
host summons them, the guest sees each as the host has it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 02:54:25 +02:00
Ludovic Marie cf63dcd39f Merge remote-tracking branch 'pr/724' into bm2/combined
# Conflicts:
#	crates/horizon-client/src/game/lan_actions.rs
#	tools/lan_e2e.py
2026-10-17 23:57:19 +02:00
Ludovic Marie 40e9e9660b Merge remote-tracking branch 'pr/727' into bm2/combined
# Conflicts:
#	crates/horizon-client/src/game/agent.rs
#	tools/lan_e2e.py
2026-10-17 23:55:19 +02:00
Ludovic Marie e74d5207dc Merge remote-tracking branch 'pr/726' into bm2/combined
# Conflicts:
#	crates/horizon-client/src/game/remote.rs
#	tools/lan_e2e.py
2026-10-17 23:54:59 +02:00
Ludovic Marie 9bb22caa22 Merge remote-tracking branch 'pr/725' into bm2/combined
# Conflicts:
#	tools/lan_e2e.py
2026-10-17 23:54:22 +02:00
Ludovic Marie 6f5a3319ee Merge commit '123e8286ac55894a0e9f61c78b3844fd46241e2a' into bm2/combined
# Conflicts:
#	crates/horizon-client/src/game/remote.rs
#	tools/lan_e2e.py
2026-10-17 23:54:21 +02:00
Ludovic Marie 8bfe19245b Merge commit 'bf1cd958686ffc95a6ff30cdbedc9a8de59315ad' into HEAD
# Conflicts:
#	tools/lan_e2e.py
2026-10-17 22:33:41 +02:00
Ludovic Marie bf1cd95868 Merge main into feat/server-command-tree
tools/lan_e2e.py: the check lists keep #700's effects and portals and this PR's commands.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 22:33:18 +02:00
Ludovic Marie d1d36f4121 Guests: experience orbs fly to them and give them their points
On a LAN world or a server, guests never got experience: orbs followed and
were taken only by the host's own player (none on a dedicated server), and
guests weren't sent orbs at all.

- Each orb follows the nearest living, non-spectator player within 8
  blocks, the host or a guest (ExperienceOrb.followNearbyPlayer).
- A guest takes an orb as Player.aiStep does: one of those in its box grown
  by 1, 0.5, 1, at random, at most every 2 ticks (takeXpDelay), repairing
  with Mending first; the rest goes to the guest's experience (sent with
  SetExperience as before), the level-up sound every fifth level.
  TakeItemEntity goes to the players around, the pickup sound plays at the
  orb.
- Orbs have entity ids and are tracked to guests (AddEntity, DATA_VALUE).
  The client shows a server's orbs, moves them with the server's packets and
  flies them to their collector.

tools/lan_e2e.py xp: three 7-point orbs near the guest: it sees three and
ends at level 2 (21 points); the host gets none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 18:13:55 +02:00
Ludovic Marie 22dc3e5954 Guests: touching mobs push them on their own client, as in vanilla
A mob's push of a guest went to the guest as SetEntityMotion carrying the
server copy's velocity, which nothing damps: every tick of contact added
to it and replaced what the guest's client was doing. Vanilla pushes
players on their own client only (EntitySelector.pushableBy): the server
no longer sends those pushes, and a server client now pushes its player
away from every living entity it touches (Entity.push, team rules, no
spectators, bats or passengers of the same vehicle).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 18:13:55 +02:00
Ludovic Marie 123e8286ac Guests: container clicks reach the server (chests, furnaces, crafting drags)
On a LAN world or a server, a guest's clicks that went through the menu
engine (placing a carried stack, quick craft drags, double clicks, number
keys, Q) ran only on the guest's own copy and were never sent: the item
showed in the chest or furnace, the server still had it in the inventory,
and the next menu brought it back.

menu_ops now sends every click of the server's open menu as vanilla's
MultiPlayerGameMode.handleContainerInput does: the engine predicts it on
the client's copy, then a ContainerClick goes out with the slots it changed
and the carried stack after it (a drag is its three kinds of clicks). The
plain inventory and crafting table are predicted too, the Shift double click
sends each QUICK_MOVE, and a prediction no longer drops, crafts or makes maps
on the client (the server does).

tools/lan_e2e.py clicks: real mouse presses put a stack into a chest and a
furnace, drag planks over the crafting grid and craft; the server has each.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 17:51:33 +02:00
Ludovic Marie ce62f9c57f Server clients: eating plays on the player's own screen
A server client sent UseItem and never started the use itself, so food
showed no eating animation or crumbs, and holding right click sent a new
UseItem every 4 ticks. Like MultiPlayerGameMode.useItem, the client now
starts eating (Consumable.startConsuming), counts the use down for the
animation and its particles, and starts no other use until it ends; the
server still eats the item. Looking at another player no longer stops
the item from being used (Player.interactOn passes).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 17:42:19 +02:00
Ludovic Marie 28d218b3a2 Guests: a bed puts the guest to sleep, not the host
The bed's sleeping state, timer and respawn point were the host's fields,
so a guest clicking a bed put the host to sleep and moved the host's
spawn. as_guest now swaps them with the guest's own; the guest gets its
sleeping pose and bed (entity data 14), wakes on STOP_SLEEPING with the
WAKE_UP animation, and the night skips only once enough players sleep
(players_sleeping_percentage). Guests respawn at their own bed, else the
world spawn. Server clients lie in the bed from the synced position.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 17:40:40 +02:00
Ludovic Marie a4feb65161 Show the server's recipe book on a server and place its recipes
On a server, single player's server thread included, the inventory
had no recipe book: the window ignored the recipe book packets, and
the server ignored a guest's ServerboundPlaceRecipePacket.

- horizon-protocol decodes the recipe book's packets and the recipe
  displays they carry: RecipeBookAdd / Remove / Settings,
  PlaceGhostRecipe and the serverbound PlaceRecipe. Every 26.3
  `recipe_display` and `slot_display` type is decoded (shaped,
  shapeless, furnace, stonecutter and smithing displays; empty,
  any_fuel, with_any_potion, only_with_component, item, item_stack,
  tag, dyed, smithing_trim, with_remainder and composite slots).
- The remote client keeps the book the server sends (ClientRecipeBook:
  added, highlighted, removed, replaced), shows the unlock toast,
  applies the open and filter settings, and counts the menu the
  server last sent for the craftable filter. Clicking a recipe sends
  PlaceRecipe; a ghost recipe from the server fades in.
- The server handles a guest's PlaceRecipe in the inventory grid and
  the crafting table (ServerPlaceRecipe on the menu engine, for known
  recipes only) and answers with the slots, or a ghost recipe when the
  items are missing.
- The screen state reports the recipe book's buttons.

lan_e2e.py gains a `recipes` check: the guest gets oak logs, opens the
book, clicks the planks recipe, and a log lands in the grid.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 16:09:58 +02:00
Ludovic Marie e4741b7793 Decode the server's command tree and complete commands with it
The window dropped ClientboundCommandsPacket ("argument nodes are not
decoded"), so on a server, single player's server thread included,
the chat was a bare input line without completion, colouring or usage.

- horizon-protocol decodes argument nodes: the 26.3
  `command_argument_type` ids and every parser's properties
  (ArgumentTypeInfo.deserializeFromNetwork), plus the custom
  suggestion provider.
- command::network turns the tree into a Dispatcher. A node at a path
  the client's vanilla tree also has takes that node's argument type
  and suggestion provider; any other node takes the type its parser
  and properties describe.
- On a server the chat is ChatScreen over that tree, so Tab completes,
  arguments are coloured, usage and errors show, and Enter sends the
  command to the server. Player-name suggestions come from the
  server's player list. The old bare input line is gone.
- The screen state reports the chat input (`chat_input`).

lan_e2e.py gains a `commands` check: the guest completes `/gamem` to
`/gamemode` and `/gamemode cr` to `/gamemode creative` with Tab, and
the command runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 15:34:24 +02:00
Ludovic Marie 805d5532e5 Give mob, beacon, sculk and splash effects to every player
On a server (the integrated server thread and the dedicated server)
the host has no player of its own, so effects that only touched the
host's player reached nobody; on a LAN world they reached only the
host. Beacons, the warden's and shriekers' darkness, the elder
guardian's mining fatigue, splash and lingering potions' splash and
the raid victory's Hero of the Village now run for each player in
the level, guests through `as_guest`.

The elder guardian's curse sends the guest the GUARDIAN_ELDER_EFFECT
game event, which the remote client now shows (the apparition and
the curse sound).

lan_e2e.py gains an `effects` check: a speed beacon next to both
players must give both of them speed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 15:04:04 +02:00
Ludovic Marie a67a323959 Server: one level per dimension, so players can be in different dimensions
A server (the dedicated server and single player's server thread) now
holds a level per dimension, like vanilla's `MinecraftServer.levels`. Each
server tick runs every level with players in it, one at a time, by swapping
its fields into place (game/levels.rs), so the world tick code runs
unchanged. Before this, a portal did nothing while two or more players were
online.

- Levels: the parked levels keep the world, streaming, save, block ticks,
  entities, block entity state, raids, sculk and creaking scans. The
  Overworld stays loaded; another level is saved and closed after 300 ticks
  with nobody in it. Saving saves every level.
- Hub: `tick` is split into `poll` (the network, once per tick),
  `tick_level` (the packets, chunks, block changes, containers and entities
  of the players in the level in place) and `end_tick` (latency). Each guest
  has a dimension; time, weather, sounds and events reach only the players
  in their level, and the clock and weather last sent are kept per level.
- Travel: every player has their own portal state; a portal moves only that
  player into the destination's level (`ServerPlayer.teleport` packets as
  before). Respawning brings a player back to the Overworld's level.
- Player data saves and loads each player's dimension, and a returning
  player is placed in their own level.
- tools/lan_e2e.py --server-thread --check portals: the guest goes to the
  Nether while the host stays, then the host goes to the End while the guest
  is in the Nether, and both come back.

The in-frame game keeps its one level that follows its player.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 14:46:03 +02:00
Ludovic Marie 45cbb4f7d6 LAN: a guest's chest, crafting table or sign no longer takes the host's mouse (#687)
A guest's action runs on the host's game with the guest's state swapped in
(`as_guest`). The swap restored the open screen but not what opening one
does to the window: `capture(false)` released the host's pointer, so the
cursor showed and the camera stopped whenever a guest opened a chest, a
crafting table or any other menu. `keys.clear()` dropped the keys the host
was holding, and a sign, book, command block or mount menu the guest opened
was drawn on the host's screen.

- `capture` leaves the window alone while a guest acts.
- `as_guest` keeps the host's held keys, sign editor, book, command block
  screen and mount menu, as it already kept the open screen.
- `state` reports `pointer_grabbed` (mouse movement turns the camera).
- tools/lan_e2e.py: `chest` and `crafting` check that the host keeps its
  screen and its mouse look; a new `sign` check places a sign as the guest.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 14:13:46 +02:00
Ludovic Marie 91360e2f29 tools/lan_e2e.py: walls runs next to nametags, before the world fills up
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:08:31 +02:00
Ludovic Marie ee088c0022 tools/lan_e2e.py: walls sees a dead guest by its death screen too
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:05:39 +02:00