Merge main into feat/lua-mods (Cargo.toml members one per line; stability.md server-mods row from main)

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.github/workflows/ci.yml

@@ -72,6 +72,9 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
+          # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
+          # prepared vanilla data, so without it they pass at once.
+          cargo +stable test --workspace --lib --features horizon-client/mods,horizon-mods/pack mod_content::tests:: -- --ignored
           cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
   # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
@@ -144,6 +147,7 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
   # Horizon never downloads the game. These jobs need a self-hosted Linux runner
   # (label horizon-game) holding the maintainer's own copy: the official launcher's
   # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in

.github/workflows/parity-main.yml

@@ -25,8 +25,8 @@ jobs:
   parity-main:
     # A Mac mini runner of its own (ludovics-mac-mini-2 holds only this label since 2026-10-26): behind PR parity jobs
     # this run waited 2 h while every merge replaced the pending one, and on the release runner a release then waited
-    # behind the next run. PR parity jobs have ludovics-mac-mini and the desktop. Not the desktop: a job slowed down
-    # because the maintainer came back could time out, and a failure here bisects and comments on merges.
+    # behind the next run. PR parity jobs have ludovics-mac-mini and playhorizon. Not playhorizon: its 4 CPUs
+    # make a core-crate run several times longer, and a failure here bisects and comments on merges.
     runs-on: [self-hosted, macOS, horizon-parity-main]
     timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
     steps:

.github/workflows/parity.yml

@@ -1,6 +1,6 @@
 name: parity
-# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the maintainer's
-# own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
+# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner or playhorizon's, which hold the
+# maintainer's own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
 # and by run-parity.yml when a maintainer labels a fork's pull request run-parity. See docs/release-flow.md.
 on:
   workflow_call:
@@ -13,6 +13,13 @@ on:
         description: The commit to check out and test
         type: string
         required: true
+      full:
+        description: >-
+          The pull request carries the full-parity label (a change every harness reaches, such as a crate split): it
+          runs on playhorizon's runner only, so the Mac mini's runners stay free for the others. While that runner is
+          busy the job waits for it.
+        type: boolean
+        default: false
 permissions:
   contents: read
 env:
@@ -21,40 +28,53 @@ env:
 
 jobs:
   parity:
-    runs-on: [self-hosted, horizon-game]
-    timeout-minutes: 120  # a change to core crates reruns ~300 harnesses: ~60-90 min on the Mac mini
+    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "playhorizon"]') || fromJSON('["self-hosted", "horizon-game"]') }}
+    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini; on playhorizon (4 of its 8 vCPUs, 4
+    # harnesses at a time) up to a few hours, and any pull request's job may land there.
+    timeout-minutes: ${{ inputs.full && 360 || 180 }}
     steps:
       - uses: actions/checkout@v4
         with:
-          # The commit the event names: a fork's later pushes need another run-parity label.
+          # The commit the event names: a fork's later pushes need another run-parity label. The next step merges
+          # main into it.
           ref: ${{ inputs.head }}
           fetch-depth: 0
           persist-credentials: false
           # Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
           clean: false
+      - name: The head merged into main (what merging it would land)
+        id: merge
+        env:
+          BASE_SHA: ${{ inputs.base }}
+          HEAD_SHA: ${{ inputs.head }}
+        run: |
+          # Harness fixes and game fixes that reached main since the branch was made then apply here too: a head
+          # tested alone failed harnesses already fixed on main (server_knockback before #2114, mob_ai's heap before
+          # #2270, save_roundtrip before #2212). Selection then compares with this main, so it sees only the pull
+          # request's own changes. A head that conflicts with main is tested alone.
+          set -euo pipefail
+          git merge --abort 2>/dev/null || true
+          git fetch -q --no-tags origin +refs/heads/main:refs/remotes/origin/main
+          main=$(git rev-parse origin/main)
+          if git -c user.name=parity -c user.email=parity@localhost merge -q --no-edit --no-ff "$main" >/dev/null 2>&1; then
+            echo "base=$main" >> "$GITHUB_OUTPUT"
+            echo "Tested: head ${HEAD_SHA:0:9} merged into main ${main:0:9}" | tee -a "$GITHUB_STEP_SUMMARY"
+          else
+            git merge --abort
+            echo "base=$BASE_SHA" >> "$GITHUB_OUTPUT"
+            echo "::warning::head ${HEAD_SHA:0:9} conflicts with main ${main:0:9}: tested alone, without main's fixes"
+            echo "Tested: head ${HEAD_SHA:0:9} alone (it conflicts with main ${main:0:9})" | tee -a "$GITHUB_STEP_SUMMARY"
+          fi
       - uses: dtolnay/rust-toolchain@stable
       - name: Tools from the runner
         run: bash tools/ci/runner-env.sh
       - name: Vanilla data, and resources prepared by this preparer
-        env:
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's script: one written before a fix to it left a real .local/horizon-client without sounds.json on
-          # the runner, and every later job there failed `subtitle`. A branch that changes the script runs its own.
-          set -euo pipefail
-          if git rev-parse --verify -q origin/main >/dev/null \
-            && git diff --quiet "$(git merge-base "$BASE_SHA" HEAD)" HEAD -- tools/ci/vanilla-data.sh; then
-            git show origin/main:tools/ci/vanilla-data.sh > "$RUNNER_TEMP/vanilla-data.sh"
-            bash "$RUNNER_TEMP/vanilla-data.sh"
-          else
-            bash tools/ci/vanilla-data.sh
-          fi
+        run: bash tools/ci/vanilla-data.sh
       - name: The prepared output is the one the preparer's OUTPUT_VERSION says
         env:
-          BASE_SHA: ${{ inputs.base }}
+          BASE_SHA: ${{ steps.merge.outputs.base }}
         run: |
-          # The job runs main's workflow on the head's files: a head made before OUTPUT_VERSION (#1947) has neither
-          # the tool nor the number, so there is nothing to check.
+          # A head made before OUTPUT_VERSION (#1947) that conflicts with main has neither the tool nor the number.
           if [ ! -f tools/prepare_output.py ] || ! grep -q OUTPUT_VERSION crates/horizon-prepare/src/lib.rs; then
             echo "This head's preparer has no OUTPUT_VERSION: nothing to check"
             exit 0
@@ -65,47 +85,8 @@ jobs:
       - name: The harnesses this change can affect
         env:
           PARITY_HOSTS: ''
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's selection (tools/parity.py --changed --list with main's parity.py and parity_reach.py), so a
-          # branch made before a better selection landed gets it too; the head's own runner then runs those
-          # harnesses. A branch that changes the selection itself selects with its own code.
-          set -euo pipefail
-          own() { python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400; }  # world_spawn takes ~1480 s on a busy runner
-          fork_point=$(git merge-base "$BASE_SHA" HEAD)
-          if ! git rev-parse --verify -q origin/main >/dev/null || ! git diff --quiet "$fork_point" HEAD -- tools/parity.py tools/parity_reach.py; then
-            own
-            exit
-          fi
-          had_reach=$(git ls-files tools/parity_reach.py)
-          git show origin/main:tools/parity.py > tools/parity.py
-          git show origin/main:tools/parity_reach.py > tools/parity_reach.py
-          status=0
-          python3 tools/parity.py --changed "$BASE_SHA" --list > .local/parity-selection.txt || status=$?
-          git checkout -- tools/parity.py
-          if [ -n "$had_reach" ]; then git checkout -- tools/parity_reach.py; else rm -f tools/parity_reach.py; fi
-          cat .local/parity-selection.txt
-          if [ "$status" != 0 ]; then
-            echo "main's selection failed: the head's own selection runs"
-            own
-            exit
-          fi
-          names=$(sed '$d' .local/parity-selection.txt | grep -E '^[A-Za-z0-9_#]+$' || true)
-          # The summary line says how many would run: a count that doesn't match the names read (a format change)
-          # must not let the job pass untested.
-          expected=$(tail -1 .local/parity-selection.txt | sed -nE 's/^([0-9]+) of [0-9]+ harnesses would run$/\1/p')
-          count=$(printf '%s' "$names" | grep -c . || true)
-          if [ -z "$expected" ] || [ "$expected" != "$count" ]; then
-            echo "main's selection listed $count names, its summary says '${expected:-?}': the head's own selection runs"
-            own
-            exit
-          fi
-          if [ "$count" = 0 ]; then
-            echo "Nothing to run."
-            exit 0
-          fi
-          # shellcheck disable=SC2086
-          python3 tools/parity.py $names --timeout 2400
+          BASE_SHA: ${{ steps.merge.outputs.base }}
+        run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
       - name: Logs of the failed harnesses
         if: failure()
         uses: actions/upload-artifact@v4

.github/workflows/run-parity.yml

@@ -22,3 +22,4 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}

AGENTS.md

@@ -10,7 +10,8 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
   folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
@@ -34,7 +35,9 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~190 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~180 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
+| `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -63,6 +66,7 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
 cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
+cargo test -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
@@ -118,16 +122,16 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 | Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` |
 | Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` |
 | Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` |
-| Commands | parse: L: `command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`, `nbt_path.rs`; G: `functions.rs`, `command_blocks.rs` |
+| Commands | parse: crate `horizon-command` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`; `horizon-client-core`: `nbt_path.rs`, `scoreboard.rs`; G: `functions.rs`, `command_blocks.rs` |
 | UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` |
 | Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) |
 | LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) |
 | Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
 | Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
-| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `block_entity_nbt.rs`, `options_file.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
+| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `options_file.rs`; `horizon-client-core/src/block_entity_nbt.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
 | Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
-| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` |
+| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`; `horizon-client-core/src/lang.rs`; crate `horizon-assets`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
 | Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |

Cargo.lock

@@ -216,6 +216,13 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "beacons"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -470,6 +477,13 @@ dependencies = [
  "horizon-mod-sdk",
 ]
 
+[[package]]
+name = "coords-hud-lua"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-lua",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -923,6 +937,13 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
 
+[[package]]
+name = "far-view"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1086,6 +1107,30 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "gc-arena"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cd70cf88a32937834aae9614ff2569b5d9467fa0c42c5d7762fd94a8de88266"
+dependencies = [
+ "allocator-api2",
+ "gc-arena-derive",
+ "hashbrown 0.14.5",
+ "sptr",
+]
+
+[[package]]
+name = "gc-arena-derive"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c612a69f5557a11046b77a7408d2836fe77077f842171cd211c5ef504bd3cddd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure 0.13.2",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -1250,6 +1295,16 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -1365,6 +1420,8 @@ dependencies = [
  "glam",
  "horizon-assets",
  "horizon-bench",
+ "horizon-client-core",
+ "horizon-command",
  "horizon-core",
  "horizon-dualsense",
  "horizon-friends",
@@ -1396,6 +1453,23 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "horizon-client-core"
+version = "0.1.0"
+dependencies = [
+ "horizon-world",
+ "serde_json",
+]
+
+[[package]]
+name = "horizon-command"
+version = "0.1.0"
+dependencies = [
+ "horizon-client-core",
+ "horizon-protocol",
+ "horizon-world",
+]
+
 [[package]]
 name = "horizon-core"
 version = "0.1.0"
@@ -1435,6 +1509,16 @@ dependencies = [
  "wgpu",
 ]
 
+[[package]]
+name = "horizon-mod-lua"
+version = "0.1.0"
+dependencies = [
+ "getrandom 0.2.17",
+ "getrandom 0.3.4",
+ "horizon-mod-sdk",
+ "piccolo",
+]
+
 [[package]]
 name = "horizon-mod-sdk"
 version = "0.1.0"
@@ -2711,6 +2795,21 @@ dependencies = [
  "indexmap",
 ]
 
+[[package]]
+name = "piccolo"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "003bf52de285e1ff1adcbc6572588db3849988ea660a2d55af3a2ffbc81f597f"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+ "anyhow",
+ "gc-arena",
+ "hashbrown 0.14.5",
+ "rand",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.1.13"
@@ -2838,6 +2937,15 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
 [[package]]
 name = "predator-missile"
 version = "0.1.0"
@@ -2938,6 +3046,27 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
+[[package]]
+name = "rand"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -2971,6 +3100,13 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
+[[package]]
+name = "recipes"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -3410,6 +3546,12 @@ dependencies = [
  "bitflags 2.13.2",
 ]
 
+[[package]]
+name = "sptr"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a"
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3527,6 +3669,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "synstructure"
 version = "0.14.0"
@@ -5188,7 +5341,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 3.0.6",
- "synstructure",
+ "synstructure 0.14.0",
 ]
 
 [[package]]
@@ -5229,7 +5382,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 3.0.6",
- "synstructure",
+ "synstructure 0.14.0",
 ]
 
 [[package]]

Cargo.toml

@@ -1,6 +1,48 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = [
+    "crates/horizon-core",
+    "crates/horizon-dualsense",
+    "crates/horizon-threads",
+    "crates/horizon-hdr",
+    "crates/horizon-world",
+    "crates/horizon-client",
+    "crates/horizon-client-core",
+    "crates/horizon-command",
+    "crates/horizon-server-files",
+    "crates/horizon-server",
+    "crates/horizon-bots",
+    "crates/horizon-assets",
+    "crates/horizon-protocol",
+    "crates/horizon-theme",
+    "crates/horizon-prepare",
+    "crates/horizon-telemetry",
+    "crates/horizon-bench",
+    "crates/horizon-friends",
+    "crates/horizon-relay",
+    "crates/horizon-mod-sdk",
+    "crates/horizon-mods",
+    "crates/horizon-mods/tests/guest",
+    "crates/horizon-mods/tests/ui_guest",
+    "crates/cargo-horizon-mod",
+    "crates/horizon-port-pack",
+    "crates/horizon-shaders",
+    "crates/horizon-shader-api",
+    "crates/horizon-release-sign",
+    "crates/horizon-mod-sdk/examples/coords-hud",
+    "crates/horizon-mod-sdk/examples/coords-hud-lua",
+    "crates/horizon-mod-sdk/examples/predator-missile",
+    "crates/horizon-mod-sdk/examples/welcome",
+    "crates/horizon-mod-sdk/examples/beacons",
+    "mods/official/fps-overlay",
+    "mods/official/keystrokes",
+    "mods/official/far-view",
+    "mods/official/minimap",
+    "mods/official/zoom",
+    "xtask",
+    "mods/official/recipes",
+    "crates/horizon-mod-lua",
+]
 resolver = "2"
 
 [workspace.package]

crates/cargo-horizon-mod/src/check.rs

@@ -200,7 +200,7 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
         return Err(format!("it didn't start: {reason}"));
     }
     let client: Vec<String> = mods.commands().map(str::to_owned).collect();
-    let server: Vec<String> = mods.server_commands().map(str::to_owned).collect();
+    let server: Vec<String> = mods.server_commands().map(|c| c.name.clone()).collect();
     report.commands = [client.clone(), server.clone()].concat();
     // A server mod plays with one player on, who joins, chats and leaves.
     let steve = ServerPlayer {
@@ -266,8 +266,17 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
                 format!("{} quiet command(s)", lines.len())
             }
             Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
+            Output::SetBlocks {
+                dimension, blocks, ..
+            } => {
+                format!("set {} block(s) in {dimension}", blocks.len())
+            }
             Output::OpenScreen { .. } => "opened a screen".to_string(),
             Output::CloseScreen { .. } => "closed its screen".to_string(),
+            Output::PlaceRecipe { book_id, all } => {
+                format!("placed recipe {book_id}{}", if all { " (all)" } else { "" })
+            }
+            Output::Give { item, count, .. } => format!("gave {count} {item}"),
             Output::Shake { strength, seconds } => {
                 format!("shook the camera: {strength:.2} for {seconds:.1} s")
             }

crates/cargo-horizon-mod/src/main.rs

@@ -1,7 +1,7 @@
 //! `cargo horizon-mod`: make Horizon mods in Rust (`docs/mods.md`).
 //!
-//! - `new <path> [--template code|content] [--name "Name"] [--sdk-path <dir>]`:
-//!   a mod from a template: a Rust crate, or a content mod (no code).
+//! - `new <path> [--template code|content|lua] [--name "Name"] [--sdk-path <dir>]`:
+//!   a mod from a template: a Rust crate, a content mod (no code), or a Lua mod.
 //! - `build [--debug]`: the `.hmod` in `target/horizon-mod/`, with the mod's
 //!   `assets/` and `data/`; a folder without `Cargo.toml` is content only.
 //! - `run [--game <horizon-client>] [-- <game args>]`: build, then play with
@@ -26,6 +26,8 @@ use std::{
 
 const TARGET: &str = "wasm32-unknown-unknown";
 const SDK_GIT: &str = "{ git = \"https://github.com/ludovic111/horizon\" }";
+/// The Lua runtime from the same repository, with the template's capability.
+const LUA_GIT: &str = "{ git = \"https://github.com/ludovic111/horizon\", features = [\"chat\"] }";
 
 fn main() -> ExitCode {
     // Cargo runs `cargo-horizon-mod horizon-mod <args>`.
@@ -42,7 +44,7 @@ fn main() -> ExitCode {
         Some("test") => test(&args[1..]),
         Some("check") => check(&args[1..]),
         Some("registry") => registry::main(&args[1..]),
-        _ => Err("usage: cargo horizon-mod new <path> [--template code|content] | build [--debug] | run [--game <horizon-client>] [-- <game args>] | test [--debug] [--hmod <file>] [<name>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
+        _ => Err("usage: cargo horizon-mod new <path> [--template code|content|lua] | build [--debug] | run [--game <horizon-client>] [-- <game args>] | test [--debug] [--hmod <file>] [<name>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
     };
     match result {
         Ok(()) => ExitCode::SUCCESS,
@@ -83,18 +85,26 @@ fn new(args: &[String]) -> Result<(), String> {
         })
         .collect();
     let name = flag(args, "--name").map_or_else(|| base.replace(['-', '_'], " "), str::to_string);
-    let sdk = match flag(args, "--sdk-path") {
+    let (sdk, lua) = match flag(args, "--sdk-path") {
         Some(p) => {
             let p = std::fs::canonicalize(p).map_err(|e| format!("--sdk-path {p}: {e}"))?;
-            format!("{{ path = {:?} }}", p.display().to_string())
+            let lua = p.parent().unwrap_or(&p).join("horizon-mod-lua");
+            (
+                format!("{{ path = {:?} }}", p.display().to_string()),
+                format!(
+                    "{{ path = {:?}, features = [\"chat\"] }}",
+                    lua.display().to_string()
+                ),
+            )
         }
-        None => SDK_GIT.to_string(),
+        None => (SDK_GIT.to_string(), LUA_GIT.to_string()),
     };
     let fill = |t: &str| {
         t.replace("{crate}", &id.replace('_', "-"))
             .replace("{id}", &id)
             .replace("{name}", &name)
             .replace("{sdk}", &sdk)
+            .replace("{lua}", &lua)
     };
     let code = [
         ("Cargo.toml", include_str!("../template/Cargo.toml.in")),
@@ -146,10 +156,19 @@ fn new(args: &[String]) -> Result<(), String> {
         ),
         (".gitignore", include_str!("../template/gitignore")),
     ];
+    // The code template's mod, written in Lua.
+    let lua_files = [
+        ("Cargo.toml", include_str!("../template/lua/Cargo.toml.in")),
+        (MANIFEST, include_str!("../template/lua/horizon-mod.toml")),
+        ("src/lib.rs", include_str!("../template/lua/src/lib.rs")),
+        ("main.lua", include_str!("../template/lua/main.lua")),
+        (".gitignore", include_str!("../template/gitignore")),
+    ];
     let files: &[(&str, &str)] = match flag(args, "--template").unwrap_or("code") {
         "code" => &code,
         "content" => &content,
-        other => return Err(format!("no template {other}: code or content")),
+        "lua" => &lua_files,
+        other => return Err(format!("no template {other}: code, content or lua")),
     };
     for &(file, text) in files {
         let file = fill(file);
@@ -215,6 +234,13 @@ fn build_in(root: &Path, release: bool) -> Result<PathBuf, String> {
 fn compile(root: &Path, release: bool) -> Result<(Vec<u8>, PathBuf), String> {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
+    // The Lua runtime's seeds (crates/horizon-mod-lua): getrandom 0.3
+    // takes a custom source only with this cfg.
+    let flags = std::env::var("CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS").unwrap_or_default();
+    cmd.env(
+        "CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS",
+        format!("{flags} --cfg getrandom_backend=\"custom\"").trim(),
+    );
     cmd.current_dir(root).args([
         "build",
         "--lib",
@@ -386,6 +412,26 @@ mod tests {
         std::fs::remove_dir_all(&dir).unwrap();
     }
 
+    #[test]
+    fn the_lua_template_is_a_valid_mod() {
+        let dir = std::env::temp_dir().join(format!("horizon-mod-lua-{}", std::process::id()));
+        let path = dir.join("hello-lua");
+        new(&[
+            path.display().to_string(),
+            "--template".into(),
+            "lua".into(),
+        ])
+        .unwrap();
+        let manifest =
+            Manifest::parse(&std::fs::read_to_string(path.join(MANIFEST)).unwrap()).unwrap();
+        assert_eq!(manifest.capabilities, [horizon_mods::Capability::Chat]);
+        let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap();
+        assert!(cargo.contains("horizon-mod-lua = ") && cargo.contains(LUA_GIT));
+        let script = std::fs::read_to_string(path.join("main.lua")).unwrap();
+        assert!(script.contains("horizon.command(\"hello\")"));
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
     #[test]
     fn the_content_template_builds_and_checks_with_no_code() {
         let dir = std::env::temp_dir().join(format!("horizon-mod-content-{}", std::process::id()));
@@ -424,7 +470,7 @@ mod tests {
             new(&[
                 dir.join("x").display().to_string(),
                 "--template".into(),
-                "lua".into()
+                "python".into()
             ])
             .is_err()
         );

crates/cargo-horizon-mod/template/lua/Cargo.toml.in

@@ -0,0 +1,17 @@
+[package]
+name = "{crate}"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+# The Lua interpreter, built into the mod with main.lua. Its features are the
+# capabilities horizon-mod.toml lists (game-read, chat, hud, storage): keep
+# the two lists the same.
+[dependencies]
+horizon-mod-lua = {lua}
+
+[profile.release]
+opt-level = "s"
+lto = true

crates/cargo-horizon-mod/template/lua/horizon-mod.toml

@@ -0,0 +1,12 @@
+id = "{id}"
+name = "{name}"
+version = "0.1.0"
+description = ""
+authors = []
+# The Horizon mod API the Lua runtime targets.
+api = "0.1"
+# client: runs in the player's game.
+side = "client"
+# What the mod may do, shown to players before they turn it on:
+# game-read (position, health, time), chat (show messages), hud (draw text).
+capabilities = ["chat"]

crates/cargo-horizon-mod/template/lua/main.lua

@@ -0,0 +1,12 @@
+-- {name}: a Horizon mod in Lua (https://playhorizon.dev/docs/mod-code).
+-- Commands come from horizon.command; hooks are global functions:
+-- on_tick(tick), on_frame(seconds), on_command(name, args), on_chat(text).
+
+local greeted = 0
+
+horizon.command("hello")
+
+function on_command(name, args)
+  greeted = greeted + 1
+  horizon.chat.show(string.format("Hello %s! (%d so far)", args, greeted))
+end

crates/cargo-horizon-mod/template/lua/src/lib.rs

@@ -0,0 +1,2 @@
+// The mod is main.lua: this builds it into the mod with its interpreter.
+horizon_mod_lua::lua_mod!("main.lua");

crates/horizon-client-core/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "horizon-client-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's lowest layer: chat text and translations, SNBT and NBT paths, the scoreboard, boss bars, game rules and the registry and particle tables commands name"
+
+[dependencies]
+horizon-world = { path = "../horizon-world" }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+
+[lints]
+workspace = true

crates/horizon-client-core/src/block_entity_nbt.rs

@@ -259,7 +259,7 @@ fn is_pos(tag: &Tag) -> bool {
     matches!(tag, Tag::IntArray(v) if v.len() == 3)
 }
 /// The loaded `SignText` of one side, or the empty text.
-pub(crate) fn sign_side(tag: Option<&Tag>) -> Tag {
+pub fn sign_side(tag: Option<&Tag>) -> Tag {
     let empty = || string("");
     let mut messages: Vec<Tag> = match tag.and_then(|t| t.get("messages")) {
         Some(Tag::List(list)) => list.iter().filter_map(component).collect(),

crates/horizon-client-core/src/component.rs

@@ -252,7 +252,7 @@ pub fn to_text_with(
             } else if let Some(sel) = o.get("selector").and_then(Value::as_str) {
                 resolve(sel)
             } else if let Some(key) = o.get("keybind").and_then(Value::as_str) {
-                crate::keybinds::display_name(key)
+                crate::key_display::display_name(key)
             } else {
                 Text::empty()
             };

crates/horizon-client-core/src/gamerules.rs

@@ -292,27 +292,4 @@ mod tests {
         assert_eq!(GameRules::load(&dir), rules);
         let _ = fs::remove_dir_all(dir);
     }
-    /// The world's save (Level.write) writes the rules as they are now, and a
-    /// world opened again reads them back (#74).
-    #[test]
-    fn level_save_keeps_changed_rules() {
-        let dir =
-            std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
-        let _ = fs::remove_dir_all(&dir);
-        let mut level = crate::save::Level::default();
-        level.write(&dir).unwrap();
-        // Rules changed while playing, then saved and loaded again.
-        let mut rules = GameRules::load(&dir);
-        assert_eq!(rules, GameRules::default());
-        assert!(rules.set("advance_time", Value::Bool(false)));
-        assert!(rules.set("advance_weather", Value::Bool(false)));
-        assert!(rules.set("random_tick_speed", Value::Int(0)));
-        level.game_rules = rules.by_name();
-        level.write(&dir).unwrap();
-        assert_eq!(GameRules::load(&dir), rules);
-        let read = crate::save::Level::read(&dir).unwrap();
-        assert_eq!(read.game_rules, rules.by_name());
-        assert_eq!(read.game_rule("advance_time"), 0);
-        let _ = fs::remove_dir_all(dir);
-    }
 }

crates/horizon-client-core/src/identifier.rs

@@ -0,0 +1,18 @@
+//! Resource identifiers (`Identifier`).
+
+/// Identifier.parse: `ns:path` or `path`, validated.
+pub fn parse_identifier(raw: &str) -> Option<String> {
+    let (ns, path) = match raw.split_once(':') {
+        Some(("", path)) => ("minecraft", path),
+        Some((ns, path)) => (ns, path),
+        None => ("minecraft", raw),
+    };
+    let ns_ok = ns != ".."
+        && ns
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
+    let path_ok = path.chars().all(|c| {
+        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
+    });
+    (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
+}

crates/horizon-client-core/src/key_display.rs

@@ -0,0 +1,38 @@
+//! Key display names (`InputConstants.Key.getDisplayName`), shared by key
+//! mappings and `keybind` text components.
+use crate::text::Text;
+
+/// InputConstants.Key.getDisplayName: one-character keys as the upper-case
+/// character, others by translation.
+pub fn display_name(key: &str) -> Text {
+    if let Some(rest) = key.strip_prefix("key.keyboard.")
+        && rest.chars().count() == 1
+    {
+        let c = rest.to_uppercase();
+        return Text::literal(c);
+    }
+    let symbol = match key {
+        "key.keyboard.minus" => Some("-"),
+        "key.keyboard.equal" => Some("="),
+        "key.keyboard.left.bracket" => Some("["),
+        "key.keyboard.right.bracket" => Some("]"),
+        "key.keyboard.backslash" => Some("\\"),
+        "key.keyboard.semicolon" => Some(";"),
+        "key.keyboard.apostrophe" => Some("'"),
+        "key.keyboard.grave.accent" => Some("`"),
+        "key.keyboard.comma" => Some(","),
+        "key.keyboard.period" => Some("."),
+        "key.keyboard.slash" => Some("/"),
+        _ => None,
+    };
+    if let Some(s) = symbol {
+        return Text::literal(s);
+    }
+    if let Some(n) = key.strip_prefix("key.mouse.")
+        && n.parse::<u32>().is_ok()
+        && !crate::lang::has(key)
+    {
+        return Text::translate("key.mouse", &[Text::literal(n)]);
+    }
+    Text::translate(key, &[])
+}

crates/horizon-client-core/src/lang.rs

@@ -42,8 +42,12 @@ struct Bundled;
 impl ResourceSource for Bundled {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
         let body = match path {
-            "assets/horizon/lang/en_us.json" => include_str!("../assets/horizon/lang/en_us.json"),
-            "assets/horizon/lang/ru_ru.json" => include_str!("../assets/horizon/lang/ru_ru.json"),
+            "assets/horizon/lang/en_us.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
+            }
+            "assets/horizon/lang/ru_ru.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
+            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())

crates/horizon-client-core/src/lib.rs

@@ -0,0 +1,23 @@
+//! The client's lowest layer, below commands and gameplay: chat text and
+//! translations, SNBT and NBT paths, text components, the scoreboard, boss
+//! bars, game rules, block entity NBT tables, and the registry, particle and
+//! sound source tables commands name. horizon-client re-exports each module
+//! under its old path (`horizon_client::text`, ...).
+#![forbid(unsafe_code)]
+pub mod block_entity_nbt;
+pub mod bossbar;
+pub mod component;
+pub mod fastutil_order;
+pub mod gamerules;
+pub mod identifier;
+pub mod key_display;
+pub mod lang;
+pub mod nbt_path;
+pub mod particle_type;
+pub mod registries;
+pub mod scoreboard;
+pub mod snbt;
+pub mod sound_source;
+pub mod text;
+pub mod uuid;
+pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

crates/horizon-client-core/src/particle_type.rs

@@ -0,0 +1,209 @@
+//! Particle types (`ParticleTypes`): the vanilla particle types with a client
+//! implementation, by registry name, and their per-type flags.
+
+macro_rules! particle_types {
+    ($($variant:ident = $name:literal),* $(,)?) => {
+        /// Vanilla particle types with a client implementation here.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum ParticleType { $($variant),* }
+        impl ParticleType {
+            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
+            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
+            pub fn name(self) -> &'static str {
+                match self { $(ParticleType::$variant => $name),* }
+            }
+            pub fn from_name(name: &str) -> Option<Self> {
+                let name = name.strip_prefix("minecraft:").unwrap_or(name);
+                match name { $($name => Some(ParticleType::$variant),)* _ => None }
+            }
+        }
+    };
+}
+particle_types! {
+    Block = "block",
+    BlockCrumble = "block_crumble",
+    Trail = "trail",
+    DustPillar = "dust_pillar",
+    FallingDust = "falling_dust",
+    Smoke = "smoke",
+    LargeSmoke = "large_smoke",
+    WhiteSmoke = "white_smoke",
+    Flame = "flame",
+    SoulFireFlame = "soul_fire_flame",
+    CopperFireFlame = "copper_fire_flame",
+    SmallFlame = "small_flame",
+    Lava = "lava",
+    DrippingWater = "dripping_water",
+    FallingWater = "falling_water",
+    DrippingLava = "dripping_lava",
+    FallingLava = "falling_lava",
+    LandingLava = "landing_lava",
+    DrippingHoney = "dripping_honey",
+    FallingHoney = "falling_honey",
+    LandingHoney = "landing_honey",
+    FallingNectar = "falling_nectar",
+    FallingSporeBlossom = "falling_spore_blossom",
+    SporeBlossomAir = "spore_blossom_air",
+    DrippingObsidianTear = "dripping_obsidian_tear",
+    FallingObsidianTear = "falling_obsidian_tear",
+    LandingObsidianTear = "landing_obsidian_tear",
+    DrippingDripstoneWater = "dripping_dripstone_water",
+    FallingDripstoneWater = "falling_dripstone_water",
+    DrippingDripstoneLava = "dripping_dripstone_lava",
+    FallingDripstoneLava = "falling_dripstone_lava",
+    Splash = "splash",
+    Rain = "rain",
+    Bubble = "bubble",
+    SulfurBubbles = "sulfur_bubbles",
+    BubblePop = "bubble_pop",
+    BubbleColumnUp = "bubble_column_up",
+    CurrentDown = "current_down",
+    Underwater = "underwater",
+    Portal = "portal",
+    ReversePortal = "reverse_portal",
+    Enchant = "enchant",
+    Nautilus = "nautilus",
+    VaultConnection = "vault_connection",
+    Crit = "crit",
+    EnchantedHit = "enchanted_hit",
+    DamageIndicator = "damage_indicator",
+    Heart = "heart",
+    AngryVillager = "angry_villager",
+    HappyVillager = "happy_villager",
+    Composter = "composter",
+    Mycelium = "mycelium",
+    Dolphin = "dolphin",
+    EggCrack = "egg_crack",
+    Poof = "poof",
+    Explosion = "explosion",
+    ExplosionEmitter = "explosion_emitter",
+    CampfireCosySmoke = "campfire_cosy_smoke",
+    CampfireSignalSmoke = "campfire_signal_smoke",
+    Note = "note",
+    Dust = "dust",
+    TotemOfUndying = "totem_of_undying",
+    Firework = "firework",
+    EndRod = "end_rod",
+    Ash = "ash",
+    WhiteAsh = "white_ash",
+    CrimsonSpore = "crimson_spore",
+    WarpedSpore = "warped_spore",
+    CherryLeaves = "cherry_leaves",
+    PaleOakLeaves = "pale_oak_leaves",
+    TintedLeaves = "tinted_leaves",
+    Effect = "effect",
+    InstantEffect = "instant_effect",
+    EntityEffect = "entity_effect",
+    Witch = "witch",
+    Infested = "infested",
+    Cloud = "cloud",
+    Sneeze = "sneeze",
+    Snowflake = "snowflake",
+    Soul = "soul",
+    SculkSoul = "sculk_soul",
+    DragonBreath = "dragon_breath",
+    Gust = "gust",
+    SmallGust = "small_gust",
+    GustEmitterLarge = "gust_emitter_large",
+    GustEmitterSmall = "gust_emitter_small",
+    DustColorTransition = "dust_color_transition",
+    SculkCharge = "sculk_charge",
+    SculkChargePop = "sculk_charge_pop",
+    Shriek = "shriek",
+    SonicBoom = "sonic_boom",
+    Vibration = "vibration",
+    SweepAttack = "sweep_attack",
+    Glow = "glow",
+    WaxOn = "wax_on",
+    WaxOff = "wax_off",
+    ElectricSpark = "electric_spark",
+    Scrape = "scrape",
+    SquidInk = "squid_ink",
+    GlowSquidInk = "glow_squid_ink",
+    Item = "item",
+    ItemSlime = "item_slime",
+    ItemSnowball = "item_snowball",
+    ItemCobweb = "item_cobweb",
+    SulfurCubeGoo = "sulfur_cube_goo",
+    Flash = "flash",
+    Firefly = "firefly",
+    TrialSpawnerDetection = "trial_spawner_detection",
+    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
+    TrialOmen = "trial_omen",
+    RaidOmen = "raid_omen",
+    OminousSpawning = "ominous_spawning",
+    Spit = "spit",
+    Fishing = "fishing",
+    DustPlume = "dust_plume",
+    RedPoplarLeaves = "red_poplar_leaves",
+    OrangePoplarLeaves = "orange_poplar_leaves",
+    YellowPoplarLeaves = "yellow_poplar_leaves",
+    PauseMobGrowth = "pause_mob_growth",
+    ResetMobGrowth = "reset_mob_growth",
+    BlockMarker = "block_marker",
+}
+impl ParticleType {
+    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
+    /// spawned regardless of distance.
+    pub fn override_limiter(self) -> bool {
+        matches!(
+            self,
+            Self::BlockMarker
+                | Self::DamageIndicator
+                | Self::ExplosionEmitter
+                | Self::Explosion
+                | Self::Gust
+                | Self::GustEmitterLarge
+                | Self::GustEmitterSmall
+                | Self::SonicBoom
+                | Self::SculkCharge
+                | Self::SculkChargePop
+                | Self::Vibration
+                | Self::Poof
+                | Self::Spit
+                | Self::SquidInk
+                | Self::SweepAttack
+                | Self::CampfireCosySmoke
+                | Self::CampfireSignalSmoke
+                | Self::GlowSquidInk
+                | Self::Glow
+                | Self::WaxOn
+                | Self::WaxOff
+                | Self::ElectricSpark
+                | Self::Scrape
+                | Self::TrialSpawnerDetection
+                | Self::TrialSpawnerDetectionOminous
+                | Self::VaultConnection
+                | Self::OminousSpawning
+        )
+    }
+    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
+    /// hardcodes the translucent layer, drawn after translucent terrain.
+    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
+    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
+    /// sprite set on the engine.
+    pub fn translucent_layer(self) -> bool {
+        match self {
+            // CampfireSmokeParticle.
+            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
+            // PlayerCloudParticle.
+            | Self::Cloud | Self::Sneeze
+            // SpellParticle.
+            | Self::Effect | Self::InstantEffect | Self::EntityEffect
+            | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
+            // EmissiveRisingParticle.
+            | Self::Soul | Self::SculkSoul
+            // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,
+            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
+            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
+            | Self::Vibration | Self::Firefly | Self::Flash
+            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
+            // SparkParticle (firework), SquidInkParticle, TotemParticle.
+            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
+            | Self::TotemOfUndying
+            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
+            | Self::VaultConnection => true,
+            _ => false,
+        }
+    }
+}

crates/horizon-client-core/src/registries.rs

@@ -0,0 +1,188 @@
+//! Registry contents and source state that commands validate and complete
+//! arguments against (what the server's registry access holds).
+use std::collections::BTreeMap;
+
+/// Registry contents and source state used to validate and complete arguments.
+#[derive(Clone, Debug, Default)]
+pub struct Registries {
+    /// Permission level of the command source.
+    pub permission: u8,
+    pub items: Vec<String>,
+    pub item_tags: Vec<String>,
+    /// Block id -> (property, allowed values).
+    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
+    pub block_tags: Vec<String>,
+    /// Entity types that `summon` can create.
+    pub summonable: Vec<String>,
+    /// Every entity type (selector `type=`).
+    pub entity_types: Vec<String>,
+    pub effects: Vec<String>,
+    pub enchantments: Vec<String>,
+    pub structures: Vec<String>,
+    pub biomes: Vec<String>,
+    pub dimensions: Vec<String>,
+    pub clocks: Vec<String>,
+    pub timelines: Vec<String>,
+    pub time_markers: Vec<String>,
+    pub advancements: Vec<String>,
+    /// Game rule name -> integer-valued.
+    pub game_rules: Vec<(String, bool)>,
+    pub players: Vec<String>,
+    /// Scoreboard objective names, team names and tracked score holders.
+    pub objectives: Vec<String>,
+    pub teams: Vec<String>,
+    pub tracked: Vec<String>,
+    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
+    pub functions: Vec<String>,
+    /// `/data ... storage` ids.
+    pub storages: Vec<String>,
+    /// Boss bar ids and datapack predicate ids.
+    pub bossbars: Vec<String>,
+    pub predicates: Vec<String>,
+    pub item_modifiers: Vec<String>,
+    pub schedules: Vec<String>,
+    pub stopwatches: Vec<String>,
+    pub recipes: Vec<String>,
+    pub sounds: Vec<String>,
+    pub damage_types: Vec<String>,
+    pub attributes: Vec<String>,
+    pub loot_tables: Vec<String>,
+    pub templates: Vec<String>,
+    pub random_sequences: Vec<String>,
+    pub datapacks_enabled: Vec<String>,
+    pub datapacks_disabled: Vec<String>,
+    pub function_tags: Vec<String>,
+    /// The block the source is looking at (relevant coordinates).
+    pub target_block: Option<[i32; 3]>,
+    /// Every registry's element and tag ids (`minecraft:item` -> ...), as
+    /// the server's registry access and reloadable registries hold them.
+    pub by_registry: BTreeMap<String, RegistryIds>,
+    /// Blocks whose default state has a block entity.
+    pub block_entities: std::collections::BTreeSet<String>,
+    /// Block tag -> member blocks.
+    pub block_tag_members: BTreeMap<String, Vec<String>>,
+    /// Data component types with a codec (not transient).
+    pub persistent_components: Vec<String>,
+    /// Recipes `/recipe` can give (not special).
+    pub learnable_recipes: Vec<String>,
+    /// Advancement id -> criterion names.
+    pub advancement_criteria: BTreeMap<String, Vec<String>>,
+    /// World clock -> time markers shown in commands.
+    pub clock_time_markers: BTreeMap<String, Vec<String>>,
+    /// Trigger objectives the source may use (`/trigger` suggestions).
+    pub trigger_objectives: Vec<String>,
+    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
+    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
+}
+/// The ids and tag ids of one registry.
+#[derive(Clone, Debug, Default)]
+pub struct RegistryIds {
+    pub ids: Vec<String>,
+    pub tags: Vec<String>,
+}
+const EMPTY: &[String] = &[];
+impl Registries {
+    /// Fill what the game did not build itself from vanilla's exported
+    /// registries (`command-registries.json`, written by
+    /// `VanillaCommandParseOracle registries`): built-in registries such as
+    /// mob effects, data component types and dialogs, block entities and tag
+    /// members. Registries that data packs reload stay with the game.
+    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
+        fn strings(v: &serde_json::Value) -> Vec<String> {
+            v.as_array()
+                .map(|a| {
+                    a.iter()
+                        .filter_map(|x| x.as_str().map(str::to_owned))
+                        .collect()
+                })
+                .unwrap_or_default()
+        }
+        let fill = |field: &mut Vec<String>, key: &str| {
+            if field.is_empty() {
+                *field = strings(&r[key]);
+            }
+        };
+        fill(&mut self.effects, "effects");
+        fill(&mut self.enchantments, "enchantments");
+        fill(&mut self.attributes, "attributes");
+        fill(&mut self.damage_types, "damage_types");
+        fill(&mut self.templates, "templates");
+        fill(&mut self.persistent_components, "persistent_components");
+        fill(&mut self.learnable_recipes, "learnable_recipes");
+        const RELOADED: [&str; 5] = [
+            "minecraft:advancement",
+            "minecraft:recipe",
+            "minecraft:loot_table",
+            "minecraft:predicate",
+            "minecraft:item_modifier",
+        ];
+        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
+            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
+                continue;
+            }
+            self.by_registry.insert(
+                name.clone(),
+                RegistryIds {
+                    ids: strings(&entry["ids"]),
+                    tags: strings(&entry["tags"]),
+                },
+            );
+        }
+        if self.block_entities.is_empty() {
+            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
+        }
+        if self.block_tag_members.is_empty() {
+            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
+                self.block_tag_members.insert(tag.clone(), strings(members));
+            }
+        }
+        if self.clock_time_markers.is_empty() {
+            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
+                self.clock_time_markers
+                    .insert(clock.clone(), strings(markers));
+            }
+        }
+        if self.advancement_criteria.is_empty() {
+            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
+                self.advancement_criteria
+                    .insert(id.clone(), strings(criteria));
+            }
+        }
+    }
+    /// The element ids of a registry (sorted).
+    pub fn ids(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.ids;
+        }
+        match registry {
+            "minecraft:item" => &self.items,
+            "minecraft:entity_type" => &self.entity_types,
+            "minecraft:mob_effect" => &self.effects,
+            "minecraft:enchantment" => &self.enchantments,
+            "minecraft:worldgen/structure" => &self.structures,
+            "minecraft:worldgen/biome" => &self.biomes,
+            "minecraft:world_clock" => &self.clocks,
+            "minecraft:timeline" => &self.timelines,
+            "minecraft:attribute" => &self.attributes,
+            "minecraft:damage_type" => &self.damage_types,
+            "minecraft:sound_event" => &self.sounds,
+            "minecraft:predicate" => &self.predicates,
+            "minecraft:item_modifier" => &self.item_modifiers,
+            "minecraft:loot_table" => &self.loot_tables,
+            "minecraft:recipe" => &self.recipes,
+            "minecraft:advancement" => &self.advancements,
+            _ => EMPTY,
+        }
+    }
+    /// The tag ids of a registry (sorted).
+    pub fn tags(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.tags;
+        }
+        match registry {
+            "minecraft:item" => &self.item_tags,
+            "minecraft:block" => &self.block_tags,
+            _ => EMPTY,
+        }
+    }
+}

crates/horizon-client-core/src/scoreboard.rs

@@ -2,9 +2,9 @@
 //! `ObjectiveCriteria`, `NumberFormat`) and its saved data
 //! (`data/minecraft/scoreboard.dat`, `ScoreboardSaveData.Packed`).
 use crate::{
-    command::Registries,
     component,
     fastutil_order::{HashSetOrder, OpenOrder},
+    registries::Registries,
     text::{self, Style, Text},
 };
 use horizon_world::nbt::Tag;
@@ -1266,7 +1266,7 @@ fn entity_uuids(tag: &mut Tag) {
                             })
                             .collect::<Option<Vec<i32>>>(),
                         Tag::String(s) => {
-                            crate::save::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
+                            crate::uuid::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
                         }
                         _ => None,
                     };

crates/horizon-client-core/src/sound_source.rs

@@ -0,0 +1,7 @@
+//! Sound sources (`SoundSource`), by name.
+
+/// SoundSource names in vanilla order.
+pub const SOUND_SOURCES: [&str; 11] = [
+    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
+    "voice", "ui",
+];

crates/horizon-client-core/src/text.rs

@@ -67,7 +67,7 @@ pub struct Style {
 }
 /// A style's `font` field: an identifier (`alt` is `minecraft:alt`).
 pub fn font_id(v: &Value) -> Option<String> {
-    crate::command::args::parse_identifier(v.as_str()?)
+    crate::identifier::parse_identifier(v.as_str()?)
 }
 impl Style {
     pub fn color(c: u32) -> Self {

crates/horizon-client-core/src/uuid.rs

@@ -0,0 +1,24 @@
+//! UUIDs as vanilla's four-int form, to and from their text form.
+
+pub fn uuid_text(u: [i32; 4]) -> String {
+    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
+    format!(
+        "{}-{}-{}-{}-{}",
+        &hex[0..8],
+        &hex[8..12],
+        &hex[12..16],
+        &hex[16..20],
+        &hex[20..32]
+    )
+}
+pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
+    let hex: String = s.chars().filter(|c| *c != '-').collect();
+    if hex.len() != 32 {
+        return None;
+    }
+    let mut out = [0i32; 4];
+    for (i, v) in out.iter_mut().enumerate() {
+        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
+    }
+    Some(out)
+}

crates/horizon-client/Cargo.toml

@@ -9,6 +9,8 @@ description = "Horizon native development client"
 
 [dependencies]
 horizon-assets = { path = "../horizon-assets" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-command = { path = "../horizon-command" }
 horizon-core = { path = "../horizon-core" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }

crates/horizon-client/examples/probe/arrow_probe.rs

@@ -163,6 +163,8 @@ pub fn main() -> Result<()> {
                                     ArrowSound::HitGround => "hit",
                                     ArrowSound::Splash => "splash",
                                     ArrowSound::Extinguish => "extinguish",
+                                    ArrowSound::TridentHitGround => "trident_hit_ground",
+                                    ArrowSound::TridentHit => "trident_hit",
                                 },
                                 volume.to_bits(),
                                 pitch.to_bits()

crates/horizon-client/examples/probe/entity_anim_fixture.rs

@@ -592,6 +592,7 @@ pub fn main() -> horizon_client::Result<()> {
                     pose,
                     num("maxCrossbowChageDuration"),
                     num("ticksUsingItem"),
+                    false,
                 );
             }
             Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator => {

crates/horizon-client/examples/probe/finalize_spawn_fixture.rs

@@ -154,11 +154,11 @@ const MEMORIES: [&str; 7] = [
 fn variant(m: &Mob, regs: &SpawnRegistries, v: &mut Vec<String>) {
     use Species as S;
     let s = m.species();
-    let named = |reg: &finalize::VariantRegistry, i: u8| {
-        format!(
-            "minecraft:{}",
+    let named = |reg: &finalize::VariantRegistry, i: Option<u8>| {
+        let name = i.map_or("classic", |i| {
             reg.names.get(i as usize).map_or("?", |n| n.as_str())
-        )
+        });
+        format!("minecraft:{name}")
     };
     let var = format!("minecraft:{}", finalize::variant_name(s, m.extra.variant));
     match s {

crates/horizon-client/examples/probe/recipe_book_fixture.rs

@@ -5,6 +5,10 @@
 //!
 //! usage: recipe_book_fixture RESOURCES CASES OUTPUT
 use horizon_client::recipe_book::{BookType, RecipeIndex, Settings};
+use horizon_protocol::{
+    buf::{Codec, Reader, Writer},
+    packets::recipes::RecipeBookChangeSettings,
+};
 use horizon_world::nbt::Tag;
 use serde_json::Value;
 use std::{collections::BTreeSet, fs, path::Path};
@@ -93,8 +97,23 @@ pub fn main() -> horizon_client::Result<()> {
                         _ => BookType::Smoker,
                     }
                     .index();
-                    book.open[i] = op["open"].as_bool().unwrap_or(false);
-                    book.filtering[i] = op["filtering"].as_bool().unwrap_or(false);
+                    let packet = RecipeBookChangeSettings {
+                        book_type: i as i32,
+                        open: op["open"].as_bool().unwrap_or(false),
+                        filtering: op["filtering"].as_bool().unwrap_or(false),
+                    };
+                    let mut wire = Writer::new();
+                    RecipeBookChangeSettings::write(&packet, &mut wire);
+                    extra = format!(
+                        " packet={}",
+                        wire.data
+                            .iter()
+                            .map(|b| format!("{b:02x}"))
+                            .collect::<String>()
+                    );
+                    let decoded = RecipeBookChangeSettings::read(&mut Reader::new(&wire.data))?;
+                    book.open[decoded.book_type as usize] = decoded.open;
+                    book.filtering[decoded.book_type as usize] = decoded.filtering;
                 }
                 "save" => {
                     let tag = book.write();

crates/horizon-client/src/animate_tick.rs

@@ -35,8 +35,9 @@ enum Animate {
     Campfire {
         spawn_particles: bool,
     },
-    /// Leaves: optional falling-leaf particle and chance, tinted by foliage.
-    Leaves(Option<(T, f32)>),
+    /// Leaves: optional falling-leaf particle and chance; a tinted leaf takes
+    /// the biome foliage colour unless a fixed colour is given (azalea).
+    Leaves(Option<(T, f32)>, Option<u32>),
     NetherPortal,
     EnchantingTable,
     EndRod([i32; 3]),
@@ -49,6 +50,8 @@ enum Animate {
     EnderChest,
     /// FallingBlock with its dust colour.
     Falling(u32),
+    /// A beehive or bee nest full of honey (`BeehiveBlock.animateTick`).
+    Beehive,
     RedstoneOre,
     RedstoneWire {
         power: u8,
@@ -104,10 +107,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             spawn_particles: false,
         },
         "oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
-        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01))),
-        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1))),
-        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02))),
-        "spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => Animate::Leaves(None),
+        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None),
+        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None),
+        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None),
+        "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None),
+        "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None),
+        "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None),
+        // The azalea blocks drop tinted leaves of the fixed colour -9399763.
+        "azalea_leaves" | "flowering_azalea_leaves" => {
+            Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D))
+        }
+        "spruce_leaves" => Animate::Leaves(None, None),
         "nether_portal" => Animate::NetherPortal,
         "enchanting_table" => Animate::EnchantingTable,
         "end_rod" => Animate::EndRod(facing()),
@@ -119,6 +129,14 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "sand" => Animate::Falling(0xDBD3A0),
         "red_sand" => Animate::Falling(0xA95821),
         "gravel" => Animate::Falling(0x807C7B),
+        // AnvilBlock/ConcretePowderBlock.getDustColor is the map colour;
+        // DragonEggBlock's is black.
+        "anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7),
+        "dragon_egg" => Animate::Falling(0x000000),
+        _ if name.ends_with("_concrete_powder") => Animate::Falling(concrete_powder_color(
+            name.trim_end_matches("_concrete_powder"),
+        )),
+        "beehive" | "bee_nest" if prop("honey_level").as_deref() == Some("5") => Animate::Beehive,
         "redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
         "redstone_wire" => {
             let power = prop("power").and_then(|p| p.parse().ok()).unwrap_or(0);
@@ -161,6 +179,27 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         _ => Animate::None,
     }
 }
+/// `DyeColor.getMapColor` of a concrete powder colour.
+fn concrete_powder_color(dye: &str) -> u32 {
+    match dye {
+        "white" => 0xFFFFFF,
+        "orange" => 0xD87F33,
+        "magenta" => 0xB24CD8,
+        "light_blue" => 0x6699D8,
+        "yellow" => 0xE5E533,
+        "lime" => 0x7FCC19,
+        "pink" => 0xF27FA5,
+        "gray" => 0x4C4C4C,
+        "light_gray" => 0x999999,
+        "cyan" => 0x4C7F99,
+        "purple" => 0x7F3FB2,
+        "blue" => 0x334CB2,
+        "brown" => 0x664C33,
+        "green" => 0x667F33,
+        "red" => 0x993333,
+        _ => 0x191919,
+    }
+}
 /// `RedstoneWireBlock.COLORS`.
 fn redstone_color(power: u8) -> [f32; 3] {
     let f = f32::from(power) / 15.0;
@@ -504,6 +543,53 @@ fn try_spawn_drip(
         }
     }
 }
+/// `BeehiveBlock.trySpawnDripParticles`.
+fn beehive_drip(
+    tables: &AnimateTables,
+    engine: &mut ParticleEngine,
+    ctx: &AnimateContext,
+    state: BlockStateId,
+    pos: [i32; 3],
+) {
+    if ctx.facts.get(state).fluid != Fluid::None || engine.random().next_float() < 0.3 {
+        return;
+    }
+    let Some((bottom, top, bounds)) = ctx.shape_y(pos) else {
+        return;
+    };
+    if top < 1.0
+        || tables
+            .impermeable
+            .get(state.0 as usize)
+            .copied()
+            .unwrap_or(false)
+    {
+        return;
+    }
+    let y = if bottom > 0.0 {
+        f64::from(pos[1]) + bottom - 0.05
+    } else {
+        let below = [pos[0], pos[1] - 1, pos[2]];
+        let below_top = ctx.shape_y(below).map_or(1.0, |s| s.1);
+        // `belowTop < 1 || !isCollisionShapeFullBlock` and no fluid below.
+        if (below_top < 1.0 || !ctx.sturdy(below))
+            && ctx.facts.get(ctx.state(below)).fluid == Fluid::None
+        {
+            f64::from(pos[1]) - 0.05
+        } else {
+            return;
+        }
+    };
+    let r = engine.random();
+    let (a, b) = (r.next_double(), r.next_double());
+    let (fx, fz) = (f64::from(pos[0]), f64::from(pos[2]));
+    let p = [
+        fx + bounds[0] + (bounds[1] - bounds[0]) * a,
+        y,
+        fz + bounds[2] + (bounds[3] - bounds[2]) * b,
+    ];
+    add(engine, T::DrippingHoney, p, [0.0; 3]);
+}
 /// `WaterFluid.animateTick` / `LavaFluid.animateTick`.
 fn fluid_animate_tick(
     engine: &mut ParticleEngine,
@@ -685,7 +771,7 @@ fn block_animate_tick(
                 }
             }
         }
-        Animate::Leaves(falling) => {
+        Animate::Leaves(falling, fixed_tint) => {
             let below = [pos[0], pos[1] - 1, pos[2]];
             // LeavesBlock.makeDrippingWaterParticles.
             if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
@@ -705,7 +791,7 @@ fn block_animate_tick(
                 let r = engine.random();
                 let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
                 let options = if ty == T::TintedLeaves {
-                    let c = ctx.foliage(pos);
+                    let c = fixed_tint.unwrap_or_else(|| ctx.foliage(pos));
                     let f = |s: u32| ((c >> s) & 255) as f32 / 255.0;
                     ParticleOptions::colored(ty, [f(16), f(8), f(0), 1.0])
                 } else {
@@ -977,6 +1063,13 @@ fn block_animate_tick(
                 }
             }
         }
+        Animate::Beehive => {
+            // BeehiveBlock.animateTick: nextInt(1) + 1 attempts.
+            let attempts = next_int(engine.random(), 1) + 1;
+            for _ in 0..attempts {
+                beehive_drip(tables, engine, ctx, state, pos);
+            }
+        }
         Animate::RedstoneOre => {
             for d in [
                 [0, -1, 0],
@@ -1209,21 +1302,32 @@ fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     }
     add(engine, T::SmallFlame, p, [0.0; 3]);
 }
-/// `CampfireBlockEntity.particleTick` for every lit campfire (no cooking items).
+/// `CampfireBlockEntity.particleTick` for every lit campfire; `cooking` says
+/// which of a campfire's four slots hold an item.
 pub fn campfire_particles<'a>(
     tables: &AnimateTables,
     engine: &mut ParticleEngine,
     ctx: &AnimateContext,
     blocks: impl Iterator<Item = &'a ([i32; 3], u32)>,
+    cooking: &dyn Fn([i32; 3]) -> [bool; 4],
 ) {
     for &(pos, state) in blocks {
         if !tables.is_lit_campfire(state) {
             continue;
         }
-        let signal = ctx
+        let properties = ctx
             .registry
             .state(BlockStateId(state))
-            .is_some_and(|s| s.properties.get("signal_fire").map(String::as_str) == Some("true"));
+            .map(|s| &s.properties);
+        let prop = |k: &str| properties.and_then(|p| p.get(k)).map(String::as_str);
+        let signal = prop("signal_fire") == Some("true");
+        // Direction.get2DDataValue: south, west, north, east.
+        let rotation = match prop("facing") {
+            Some("west") => 1,
+            Some("north") => 2,
+            Some("east") => 3,
+            _ => 0,
+        };
         let r = engine.random();
         if r.next_float() < 0.11 {
             let count = next_int(r, 2) + 2;
@@ -1231,6 +1335,28 @@ pub fn campfire_particles<'a>(
                 make_campfire_smoke(engine, pos, signal, false);
             }
         }
+        // The smoke over each cooking item, at the slot's corner of the fire.
+        let occupied = cooking(pos);
+        for (slot, _) in occupied.iter().enumerate().filter(|(_, held)| **held) {
+            if engine.random().next_float() >= 0.2 {
+                continue;
+            }
+            // Direction.from2DDataValue((slot + rotation) % 4) and its clockwise side.
+            let (step, clockwise) = match (slot + rotation) % 4 {
+                0 => ([0.0, 1.0], [-1.0, 0.0]),
+                1 => ([-1.0, 0.0], [0.0, -1.0]),
+                2 => ([0.0, -1.0], [1.0, 0.0]),
+                _ => ([1.0, 0.0], [0.0, 1.0]),
+            };
+            let at = [
+                f64::from(pos[0]) + 0.5 - step[0] * 0.3125 + clockwise[0] * 0.3125,
+                f64::from(pos[1]) + 0.5,
+                f64::from(pos[2]) + 0.5 - step[1] * 0.3125 + clockwise[1] * 0.3125,
+            ];
+            for _ in 0..4 {
+                add(engine, T::Smoke, at, [0.0, 5.0e-4, 0.0]);
+            }
+        }
     }
 }
 /// `CampfireBlock.makeParticles` (always visible, overriding the limiter);

crates/horizon-client/src/arrows.rs

@@ -9,7 +9,7 @@ use crate::{
     collisions::SceneCollisions,
     mobs::Who,
     motion::{FluidResources, LAVA, WATER},
-    projectiles::{Hit, Projectile},
+    projectiles::{Hit, Projectile, ProjectileKind},
     world::World,
 };
 use horizon_core::{
@@ -132,6 +132,10 @@ pub enum ArrowSound {
     HitGround,
     /// `entity.generic.extinguish_fire`.
     Extinguish,
+    /// A thrown trident's `getDefaultHitGroundSoundEvent` (`item.trident.hit_ground`).
+    TridentHitGround,
+    /// `ThrownTrident.onHitEntity`'s `item.trident.hit`.
+    TridentHit,
 }
 /// What a burning arrow does to the block it hits (`onProjectileHit`).
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -169,6 +173,9 @@ pub struct ArrowState {
     pub was_eye_in_water: bool,
     pub first_tick: bool,
     pub has_been_shot: bool,
+    /// `ThrownTrident.dealtDamage`: it has hit an entity (or sat in a block
+    /// for over 4 ticks) and hits no more.
+    pub dealt_damage: bool,
     pub removed: bool,
     /// The arrow's own random (`Entity.random`).
     pub random: LegacyRandom,
@@ -211,6 +218,7 @@ impl ArrowState {
             was_eye_in_water: false,
             first_tick: true,
             has_been_shot: false,
+            dealt_damage: false,
             removed: false,
             random,
             events: Vec::new(),
@@ -451,12 +459,14 @@ pub fn finish_entity_hit(p: &mut Projectile, scene: &ArrowScene, outcome: Entity
     let Some(mut st) = p.arrow.take() else {
         return false;
     };
+    let trident = matches!(p.kind, ProjectileKind::Trident);
     let mut ticker = Ticker {
         p,
         st: &mut st,
         scene,
     };
     match outcome {
+        EntityHit::Hurt | EntityHit::Refused if trident => ticker.trident_bounce(),
         EntityHit::Hurt => {
             ticker.hit_sound();
             // A piercing arrow flies on (`getPierceLevel() <= 0` discards).
@@ -501,7 +511,16 @@ impl Ticker<'_, '_, '_, '_> {
                 p.z,
             ))
     }
+    /// Whether this is a `ThrownTrident` (`AbstractArrow` with its own water
+    /// inertia, sounds and hit).
+    fn trident(&self) -> bool {
+        matches!(self.p.kind, ProjectileKind::Trident)
+    }
     fn tick(&mut self, targets: &[(Who, Aabb)]) -> Hit {
+        // ThrownTrident.tick.
+        if self.trident() && self.st.in_ground_time > 4 {
+            self.st.dealt_damage = true;
+        }
         let physics = !self.st.no_physics;
         let movement = self.p.velocity;
         let block_pos = self.block_position();
@@ -549,8 +568,9 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.in_ground_time = 0;
         let original = self.position();
         if self.st.was_touching_water {
-            // getWaterInertia, then the bubbles behind it.
-            self.p.velocity = self.p.velocity.scale(f64::from(0.6f32));
+            // getWaterInertia (0.99 for a trident), then the bubbles behind it.
+            let inertia = if self.trident() { 0.99f32 } else { 0.6f32 };
+            self.p.velocity = self.p.velocity.scale(f64::from(inertia));
             let v = self.p.velocity;
             for _ in 0..4 {
                 self.st.events.push(ArrowEvent::Particle {
@@ -687,6 +707,8 @@ impl Ticker<'_, '_, '_, '_> {
             .expand_towards(self.p.velocity)
             .inflate(Vec3::new(1.0, 1.0, 1.0));
         let mut best: Option<(Who, Vec3, f64)> = None;
+        // ThrownTrident.findHitEntity: none once it has dealt damage.
+        let targets = if self.st.dealt_damage { &[] } else { targets };
         for (who, b) in targets {
             if Some(*who) == self.p.owner && !self.p.left_owner || !b.intersects(area) {
                 continue;
@@ -757,12 +779,33 @@ impl Ticker<'_, '_, '_, '_> {
     /// `playSound(soundEvent, 1, 1.2 / (random * 0.2 + 0.9))`.
     fn hit_sound(&mut self) {
         let pitch = 1.2 / (self.st.random.next_float() * 0.2 + 0.9);
+        let sound = if self.trident() {
+            ArrowSound::TridentHitGround
+        } else {
+            ArrowSound::HitGround
+        };
         self.st.events.push(ArrowEvent::Sound {
-            sound: ArrowSound::HitGround,
+            sound,
             volume: 1.0,
             pitch,
         });
     }
+    /// `ThrownTrident.onHitEntity` after the hurt, whether it landed or not:
+    /// the hit sound, then `deflect(REVERSE, ..., (0.02, 0.2, 0.02))`. The
+    /// trident keeps flying (it has dealt its damage) and falls.
+    fn trident_bounce(&mut self) {
+        self.st.dealt_damage = true;
+        self.st.events.push(ArrowEvent::Sound {
+            sound: ArrowSound::TridentHit,
+            volume: 1.0,
+            pitch: 1.0,
+        });
+        // ProjectileDeflection.REVERSE.
+        let rotation = 170.0 + self.st.random.next_float() * 20.0;
+        let v = self.p.velocity;
+        self.p.velocity = Vec3::new(v.x * (-0.02 * 0.5), v.y * (-0.2 * 0.5), v.z * (-0.02 * 0.5));
+        self.p.yaw += rotation;
+    }
     /// `onHitEntity` when the entity took no damage: `deflect(REVERSE, 0.2)`,
     /// a half turn give or take ten degrees at a tenth of the speed; one
     /// left almost still drops its pickup (ALLOWED) and is discarded.

crates/horizon-client/src/biome.rs

@@ -1,7 +1,7 @@
 //! Biome colours from the pinned biome definitions and colormaps
 //! (`Biome.getGrassColor`/`getFoliageColor`/..., `BlockTintSources`).
 use crate::Result;
-use horizon_core::{noise::SimplexNoise, random::LegacyRandom};
+use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom};
 use serde_json::Value;
 use std::{collections::HashMap, fs, path::Path};
 
@@ -33,6 +33,8 @@ pub struct BiomeInfo {
     pub increased_fire_burnout: bool,
     pub name: String,
     pub temperature: f32,
+    /// `temperature_modifier: frozen` (the frozen oceans).
+    pub frozen: bool,
     pub downfall: f32,
     pub precipitation: bool,
     pub grass: u32,
@@ -45,6 +47,26 @@ pub struct BiomeInfo {
     pub fog: Option<u32>,
     pub water_fog: u32,
 }
+impl BiomeInfo {
+    /// `Biome.getHeightAdjustedTemperature`: the frozen modifier, then cooler
+    /// with height above `sea_level + 17`.
+    pub fn temperature_at(&self, pos: BlockPos, sea_level: i32) -> f32 {
+        use horizon_world::worldgen::biome_temperature::{
+            BiomeTemperatureSettings, TemperatureModifier,
+        };
+        BiomeTemperatureSettings {
+            base_temperature: self.temperature,
+            modifier: if self.frozen {
+                TemperatureModifier::Frozen
+            } else {
+                TemperatureModifier::None
+            },
+            has_precipitation: self.precipitation,
+            downfall: self.downfall,
+        }
+        .height_adjusted(pos, sea_level)
+    }
+}
 pub struct Biomes {
     pub list: Vec<BiomeInfo>,
     pub index: HashMap<String, u16>,
@@ -135,6 +157,7 @@ impl Biomes {
                     .as_bool()
                     .unwrap_or(false),
                 temperature,
+                frozen: v["temperature_modifier"].as_str() == Some("frozen"),
                 downfall,
                 precipitation: v["has_precipitation"].as_bool().unwrap_or(true),
                 grass: color(&effects["grass_color"])

crates/horizon-client/src/blocks.rs

@@ -90,7 +90,7 @@ pub const MAP_COLORS: [u32; 62] = [
     14200723, 8365974,
 ];
 /// The 12 edges of the unit cube (outline data predating the export).
-fn cube_edges() -> Vec<[f64; 6]> {
+pub fn cube_edges() -> Vec<[f64; 6]> {
     let mut edges = Vec::new();
     for a in 0..3 {
         for (u, v) in [(0., 0.), (1., 0.), (0., 1.), (1., 1.)] {

crates/horizon-client/src/bundle.rs

@@ -1,6 +1,7 @@
 //! `BundleContents.Mutable`: what a bundle takes in and gives back, by
 //! weight. The menus (`menu`, `lan::menu`) run `BundleItem`'s click
 //! overrides on it.
+use crate::item_data::BundleSelected;
 use crate::items::{ItemStack, Items};
 use horizon_world::nbt::Tag;
 
@@ -97,6 +98,8 @@ pub fn can_be_in_bundle(stack: &ItemStack) -> bool {
 pub struct Contents {
     items: Vec<ItemStack>,
     weight: Weight,
+    /// `selectedItem`: an index into `items`, -1 for none.
+    selected: i32,
 }
 
 impl Contents {
@@ -104,9 +107,11 @@ impl Contents {
     pub fn of(items: &Items, stack: &ItemStack) -> Option<Self> {
         let inside = contents_of(items, stack)?.to_vec();
         let weight = contents_weight(items, &inside);
+        let selected = stack.data().map_or(-1, |d| d.bundle_selected.0);
         Some(Self {
             items: inside,
             weight,
+            selected,
         })
     }
 
@@ -154,18 +159,26 @@ impl Contents {
         amount
     }
 
-    /// `removeOne`: the first stack (Horizon keeps no selected item).
+    /// `removeOne`: the selected stack, else the first; nothing is selected after.
     pub fn remove_one(&mut self, items: &Items) -> Option<ItemStack> {
         if self.items.is_empty() {
             return None;
         }
-        let stack = self.items.remove(0);
+        let at =
+            usize::try_from(self.selected).map_or(0, |i| if i < self.items.len() { i } else { 0 });
+        let stack = self.items.remove(at);
         self.weight = self
             .weight
             .sub(item_weight(items, &stack).times(stack.count));
+        self.selected = -1;
         Some(stack)
     }
 
+    /// `getSelectedItemIndex`.
+    pub fn selected(&self) -> i32 {
+        self.selected
+    }
+
     /// The stacks inside, in display order (the first is the next out).
     pub fn items(&self) -> &[ItemStack] {
         &self.items
@@ -200,11 +213,28 @@ impl Contents {
 
     /// `toImmutable`, written back into the bundle's component.
     pub fn store(self, bundle: &mut ItemStack) {
-        bundle.data_mut().bundle_contents = self.items;
+        let data = bundle.data_mut();
+        data.bundle_contents = self.items;
+        data.bundle_selected = BundleSelected(self.selected);
         bundle.tidy();
     }
 }
 
+/// `BundleItem.toggleSelectedItem`: select `index`, or nothing when it is the
+/// selected one already or outside the contents.
+pub fn toggle_selected(bundle: &mut ItemStack, index: i32) {
+    let Some(data) = bundle.extra.as_deref_mut() else {
+        return;
+    };
+    let inside = (0..data.bundle_contents.len() as i32).contains(&index);
+    let selected = if data.bundle_selected.0 != index && inside {
+        index
+    } else {
+        -1
+    };
+    data.bundle_selected = BundleSelected(selected);
+}
+
 #[cfg(test)]
 mod tests {
     use super::Weight;
@@ -232,8 +262,10 @@ pub struct TooltipLayout {
     /// The component's own width (96) and height, the text's excluded.
     pub width: f32,
     pub height: f32,
-    /// Each slot's top-left and the stack in it, in reading order.
+    /// Each slot's top-left and the stack in it, in drawing order.
     pub slots: Vec<([f32; 2], ItemStack)>,
+    /// The position in `slots` of the selected item, which is drawn highlighted.
+    pub selected: Option<usize>,
     /// The `+N` of the items past the grid: its top-left and the count.
     pub overflow: Option<([f32; 2], u32)>,
     /// The progress bar's top-left, its fill's width out of 94, and whether
@@ -266,6 +298,7 @@ pub fn tooltip_layout(
             width: 96.0,
             height: description_height + 13.0 + 8.0,
             slots: Vec::new(),
+            selected: None,
             overflow: None,
             bar: [x + offset, y + description_height + 4.0],
             fill: 0.0,
@@ -282,6 +315,7 @@ pub fn tooltip_layout(
     let x_start = x + offset + 96.0;
     let y_start = y + grid_height;
     let mut slots = Vec::with_capacity(shown.len());
+    let mut selected = None;
     let mut overflow = None;
     // Rows fill bottom-up and columns right-to-left, as vanilla draws them.
     let mut slot = 0;
@@ -290,8 +324,13 @@ pub fn tooltip_layout(
             let at = [x_start - column as f32 * 24.0, y_start - row as f32 * 24.0];
             if hidden > 0 && row == 1 && column == 1 {
                 overflow = Some((at, hidden));
-            } else if let Some(stack) = shown.get(slot) {
-                slots.push((at, stack.clone()));
+            } else if slot < shown.len() {
+                // `extractSlot`: the cell of slot number n holds item `size - n`.
+                let index = shown.len() - 1 - slot;
+                if usize::try_from(contents.selected()) == Ok(index) {
+                    selected = Some(slots.len());
+                }
+                slots.push((at, shown[index].clone()));
                 slot += 1;
             }
         }
@@ -301,6 +340,7 @@ pub fn tooltip_layout(
         width: 96.0,
         height: grid_height + 13.0 + 8.0,
         slots,
+        selected,
         overflow,
         bar: [x + offset, y + grid_height + 4.0],
         // `Mth.mulAndTruncate(weight, 94)`, kept within the bar.
@@ -349,8 +389,8 @@ mod tooltip_tests {
         assert_eq!(layout.slots.len(), 12);
         assert_eq!(layout.overflow, None);
         assert_eq!(layout.height, 3.0 * 24.0 + 13.0 + 8.0);
-        // Rows fill bottom-up and columns right-to-left: the first item is in
-        // the bottom-right cell, the twelfth in the top-left.
+        // Rows fill bottom-up and columns right-to-left: the twelfth item is in
+        // the bottom-right cell, the first in the top-left.
         assert_eq!(layout.slots[0].0, [96.0 - 24.0, 3.0 * 24.0 - 24.0]);
         assert_eq!(&*layout.slots[0].1.item, "minecraft:stone");
         assert_eq!(layout.slots[11].0, [0.0, 0.0]);

crates/horizon-client/src/chunk_map.rs

@@ -76,14 +76,11 @@ impl<'a> IntoIterator for &'a ChunkMap {
     }
 }
 impl crate::light::LightWorld for ChunkMap {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32> {
-        self.columns.state(x, y, z)
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<crate::chunk::Section>> {
+        self.columns.section(cx, s, cz)
     }
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
-        self.columns.light(x, y, z)
-    }
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
-        self.columns.set_light(x, y, z, packed);
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: crate::chunk::Light) {
+        self.columns.set_section_light(cx, s, cz, light);
     }
 }
 
@@ -106,7 +103,13 @@ mod tests {
         for column in map.values_mut() {
             Arc::make_mut(column).light_loaded = true;
         }
-        crate::light::LightWorld::set_light(&mut map, 0, 0, 0, 0);
+        crate::light::LightWorld::set_section_light(
+            &mut map,
+            0,
+            0,
+            0,
+            crate::chunk::Light::Uniform(0),
+        );
         assert_eq!(inserted, map.membership_revision());
         map.remove(&(0, 0));
         map.insert((1, 0), chunk);

crates/horizon-client/src/enchant.rs

@@ -545,6 +545,32 @@ impl Enchantments {
         }
         out
     }
+    /// `EnchantmentHelper.forEachModifier` as an item's tooltip lists them: the
+    /// `minecraft:attributes` effects of `stack`'s enchantments as rows of
+    /// (attribute, id, amount, operation, slot group), one per slot group the
+    /// enchantment lists.
+    pub fn modifier_rows(&self, stack: &ItemStack) -> Vec<(String, String, f64, String, String)> {
+        let mut rows = Vec::new();
+        for (id, level) in stack.enchantments() {
+            let Some(e) = self.get(id) else { continue };
+            for a in e.effects["minecraft:attributes"]
+                .as_array()
+                .into_iter()
+                .flatten()
+            {
+                for slot in &e.slots {
+                    rows.push((
+                        a["attribute"].as_str().unwrap_or("").to_owned(),
+                        a["id"].as_str().unwrap_or("").to_owned(),
+                        f64::from(level_value(&a["amount"], *level)),
+                        a["operation"].as_str().unwrap_or("add_value").to_owned(),
+                        slot.clone(),
+                    ));
+                }
+            }
+        }
+        rows
+    }
     /// Sum of `add_value` amounts of one attribute from enchantments on `stack`.
     pub fn attribute_add(&self, stack: Option<&ItemStack>, attribute: &str) -> f64 {
         stack.map_or(0.0, |s| {

crates/horizon-client/src/entity.wgsl

@@ -219,9 +219,22 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
+fn celestial_color(in: Out) -> vec4<f32> {
+    return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
+}
 @fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {
-    let color = textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
-    return color;
+    return celestial_color(in);
+}
+
+// The sky's celestial pass (sun, moon, the End sky): fs_celestial's light,
+// premultiplied for an additive (one, one) blend, and as alpha how much of it
+// the texel adds, which the blend takes off the frame's alpha. HDR output
+// (hdr.wgsl) lifts only where that left it low: the sun's and moon's discs, not
+// the dark rest of their quads or the dim End sky.
+@fragment fn fs_sky_celestial(in: Out) -> @location(0) vec4<f32> {
+    let color = celestial_color(in);
+    let added = color.rgb * color.a;
+    return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
 }
 
 // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).

crates/horizon-client/src/entity_nbt.rs

@@ -180,7 +180,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("Silent", m.silent),
         ("NoGravity", m.no_gravity),
         ("Glowing", m.glowing),
-        ("Invulnerable", m.invulnerable_flag),
     ] {
         if on {
             map.insert(key.into(), Tag::Byte(1));
@@ -188,6 +187,26 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             map.remove(&horizon_world::nbt::JavaString::from(key));
         }
     }
+    map.insert(
+        "Invulnerable".into(),
+        Tag::Byte(i8::from(m.invulnerable_flag)),
+    );
+    map.insert(
+        "LeftHanded".into(),
+        Tag::Byte(i8::from(m.extra.left_handed)),
+    );
+    // Keys of older formats that structure templates still carry.
+    for key in [
+        "HandItems",
+        "ArmorItems",
+        "HandDropChances",
+        "ArmorDropChances",
+        "Dimension",
+        "HurtByTimestamp",
+        "Leashed",
+    ] {
+        map.remove(&horizon_world::nbt::JavaString::from(key));
+    }
     if m.ticks_frozen > 0 {
         map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
     } else {
@@ -197,7 +216,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("AbsorptionAmount", Tag::Float(0)),
         ("FallFlying", Tag::Byte(0)),
         ("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
-        ("LeftHanded", Tag::Byte(0)),
+        ("current_impulse_context_reset_grace_time", Tag::Int(0)),
         (
             "Brain",
             Tag::compound([("memories", Tag::Compound(Compound::new()))]),
@@ -209,7 +228,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     // Only breedable animals have an age; a loaded creature that was saved without
     // one (a frog) stays without.
     let aged = raw.is_none_or(|r| r.get("Age").is_some());
-    if m.kind.category == "creature" && aged {
+    if (m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin) && aged {
         map.insert("Age".into(), Tag::Int(m.extra.age));
         map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
         map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
@@ -225,7 +244,51 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     if is_animal(id) {
         map.insert("InLove".into(), Tag::Int(m.extra.in_love.max(0)));
     }
+    let species = m.species();
+    if let Some((_, variant)) =
+        crate::mobs::finalize::species_variant_component(species, m.extra.variant)
+    {
+        map.insert("variant".into(), string(&variant));
+    }
+    if species == crate::mobs::Species::Chicken {
+        map.insert("EggLayTime".into(), Tag::Int(m.extra.egg_time));
+    }
+    let sounds = crate::mobs::finalize::sound_variants(species);
+    if !sounds.is_empty() {
+        let sound = m.extra.sound_variant.and_then(|i| sounds.get(i as usize));
+        let sound = sound.copied().unwrap_or("classic");
+        map.insert(
+            "sound_variant".into(),
+            string(&format!("minecraft:{sound}")),
+        );
+    }
     match id {
+        // Fox.addAdditionalSaveData; Horizon models only the type.
+        "minecraft:fox" => {
+            let kind = if m.extra.variant == 1 { "snow" } else { "red" };
+            map.insert("Type".into(), string(kind));
+            for (key, value) in [
+                ("Trusted", Tag::List(Vec::new())),
+                ("Sleeping", Tag::Byte(0)),
+                ("Sitting", Tag::Byte(0)),
+                ("Crouching", Tag::Byte(0)),
+            ] {
+                map.entry(key.into()).or_insert(value);
+            }
+        }
+        "minecraft:rabbit" => {
+            map.insert("RabbitType".into(), Tag::Int(i32::from(m.extra.variant)));
+            map.entry("MoreCarrotTicks".into()).or_insert(Tag::Int(0));
+        }
+        "minecraft:goat" => {
+            map.insert(
+                "IsScreamingGoat".into(),
+                Tag::Byte(i8::from(m.extra.screaming)),
+            );
+            let [left, right] = m.extra.lost_horns;
+            map.insert("HasLeftHorn".into(), Tag::Byte(i8::from(!left)));
+            map.insert("HasRightHorn".into(), Tag::Byte(i8::from(!right)));
+        }
         "minecraft:creeper" => {
             for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3))] {
                 map.entry(key.into()).or_insert(value);
@@ -241,10 +304,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::CAT_VARIANTS[(m.extra.variant as usize).min(10)];
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:wolf" => {
             if let Some(owner) = m.extra.owner {
@@ -254,12 +313,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::WOLF_VARIANTS[(m.extra.variant as usize).min(8)].0;
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
+            // Only Piglin.addAdditionalSaveData writes CannotHunt.
+            if id == "minecraft:piglin_brute" {
+                map.remove(&"CannotHunt".into());
+            }
             map.insert(
                 "IsImmuneToZombification".into(),
                 Tag::Byte(i8::from(m.extra.flag2)),
@@ -288,6 +347,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         | "minecraft:trader_llama" => {
             map.insert("Tame".into(), Tag::Byte(i8::from(m.extra.tame)));
             map.insert("Temper".into(), Tag::Int(i32::from(m.extra.variant3)));
+            // AbstractHorse.addAdditionalSaveData; Horizon models neither.
+            for key in ["EatingHaystack", "Bred"] {
+                map.entry(key.into()).or_insert(Tag::Byte(0));
+            }
             if let Some(owner) = m.extra.owner {
                 map.insert("Owner".into(), Tag::IntArray(owner.to_vec()));
             }
@@ -498,8 +561,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 )])
             });
         }
-        "minecraft:zombie" => {
-            map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+        "minecraft:zombie" | "minecraft:husk" | "minecraft:drowned" => {
             for (key, value) in [
                 ("DrownedConversionTime", Tag::Int(-1)),
                 ("InWaterTime", Tag::Int(-1)),
@@ -532,6 +594,21 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             Tag::Byte(i8::from(m.extra.can_break_doors)),
         );
     }
+    if matches!(
+        id,
+        "minecraft:zombie"
+            | "minecraft:husk"
+            | "minecraft:drowned"
+            | "minecraft:zombie_villager"
+            | "minecraft:zombified_piglin"
+            | "minecraft:piglin"
+            | "minecraft:zoglin"
+    ) {
+        map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+    }
+    if let Some(a) = m.extra.attributes.as_deref() {
+        put_attributes(map, m, a);
+    }
     crate::mobs::raider::write_nbt(m, map);
     crate::mobs::riders::write_nbt(m, map);
     // LivingEntity equipment: what the mob holds now.
@@ -614,6 +691,89 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     }
     tag
 }
+/// `AttributeMap.pack` for the attributes with a base or permanent modifier
+/// finalizeSpawn set, over the saved list.
+fn put_attributes(map: &mut Compound, m: &Mob, a: &crate::mobs::finalize::Attributes) {
+    use crate::mobs::finalize::{self, Attr, Op};
+    let mut list = match map.get(&"attributes".into()) {
+        Some(Tag::List(l)) => l.clone(),
+        _ => Vec::new(),
+    };
+    for attr in Attr::ALL {
+        let modifiers: Vec<Tag> = a
+            .modifiers
+            .iter()
+            .filter(|x| x.attr == attr)
+            .map(|x| {
+                let op = match x.op {
+                    Op::AddValue => "add_value",
+                    Op::AddMultipliedBase => "add_multiplied_base",
+                    Op::AddMultipliedTotal => "add_multiplied_total",
+                };
+                Tag::compound([
+                    ("id", string(x.id)),
+                    ("amount", Tag::Double(x.amount.to_bits())),
+                    ("operation", string(op)),
+                ])
+            })
+            .collect();
+        if modifiers.is_empty() && !a.bases.iter().any(|(b, _)| *b == attr) {
+            continue;
+        }
+        let id = format!("minecraft:{}", attr.name());
+        let mut entry = vec![
+            ("id", string(&id)),
+            ("base", Tag::Double(finalize::base_value(m, attr).to_bits())),
+        ];
+        if !modifiers.is_empty() {
+            entry.push(("modifiers", Tag::List(modifiers)));
+        }
+        let entry = Tag::compound(entry);
+        match list
+            .iter_mut()
+            .find(|t| text(t.get("id")).as_deref() == Some(id.as_str()))
+        {
+            Some(t) => *t = entry,
+            None => list.push(entry),
+        }
+    }
+    map.insert("attributes".into(), Tag::List(list));
+}
+/// `Brain.Packed`: the memories finalizeSpawn set, over the saved ones.
+pub fn put_brain(map: &mut Compound, m: &Mob, dimension: &str) {
+    if m.extra.memories.is_empty() {
+        return;
+    }
+    let mut memories = match map.get(&"Brain".into()).and_then(|b| b.get("memories")) {
+        Some(Tag::Compound(c)) => c.clone(),
+        _ => Compound::new(),
+    };
+    for &(name, value, ttl) in &m.extra.memories {
+        let value = match name {
+            "hunted_recently" => Tag::Byte(value as i8),
+            "home" => match m.extra.home {
+                Some(p) => Tag::compound([
+                    ("dimension", string(dimension)),
+                    ("pos", Tag::IntArray(p.to_vec())),
+                ]),
+                None => continue,
+            },
+            _ => Tag::Int(value as i32),
+        };
+        let mut memory = vec![("value", value)];
+        if ttl != i64::MAX {
+            memory.push(("ttl", Tag::Long(ttl)));
+        }
+        memories.insert(
+            format!("minecraft:{name}").as_str().into(),
+            Tag::compound(memory),
+        );
+    }
+    map.insert(
+        "Brain".into(),
+        Tag::compound([("memories", Tag::Compound(memories))]),
+    );
+}
 /// `CustomName`: a text component saved as a string or a `{text: ..}` compound.
 fn custom_name(tag: &Tag) -> Option<String> {
     match tag.get("CustomName")? {
@@ -633,6 +793,22 @@ pub fn name_text(tag: &Tag) -> Text {
         t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
     }
 }
+/// Mob.finalizeSpawn's follow range bonus in the saved attributes.
+pub(crate) fn spawn_bonus(tag: &Tag) -> Option<f64> {
+    let Some(Tag::List(attrs)) = tag.get("attributes") else {
+        return None;
+    };
+    let range = attrs
+        .iter()
+        .find(|a| text(a.get("id")).as_deref() == Some("minecraft:follow_range"))?;
+    let Some(Tag::List(modifiers)) = range.get("modifiers") else {
+        return None;
+    };
+    let bonus = modifiers
+        .iter()
+        .find(|x| text(x.get("id")).as_deref() == Some("minecraft:random_spawn_bonus"))?;
+    float(bonus.get("amount"))
+}
 pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
     let kind = types.get(&self::kind(tag)?)?.clone();
     let position = position(tag)?;
@@ -658,7 +834,18 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             }
         }
     }
+    if let Some(bonus) = spawn_bonus(tag) {
+        use crate::mobs::finalize::{Attr, Op, add_modifier};
+        let id = "minecraft:random_spawn_bonus";
+        add_modifier(&mut m, Attr::FollowRange, id, bonus, Op::AddMultipliedBase);
+    }
     m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
+    // LivingEntity.setHealth clamps to the max health: a horse or llama is made
+    // with the type's and saved before it drops to the one it rolled. (Only
+    // the base is read here, so the clamp would cut a leader zombie's bonus.)
+    if crate::mobs::equine::is_equine(m.species()) {
+        m.health = m.health.min(m.attrs.max_health);
+    }
     m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
     // What it holds (equipment.mainhand / offhand), when saved.
     if let Some(eq) = tag.get("equipment") {
@@ -699,7 +886,8 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     m.extra.pick_up_loot = flag(tag, "CanPickUpLoot");
     m.custom_name = custom_name(tag);
     m.custom_name_text = tag.get("CustomName").map(name_text);
-    if m.kind.category == "creature" {
+    m.extra.left_handed = flag(tag, "LeftHanded");
+    if m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin {
         m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32;
         m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32;
         m.extra.age_locked = flag(tag, "AgeLocked");
@@ -793,20 +981,45 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             m.extra.vector[0] = 0.7;
         }
     }
+    if crate::mobs::finalize::species_variant_component(m.species(), 0).is_some()
+        && let Some(v) = text(tag.get("variant"))
+    {
+        m.extra.variant = crate::mobs::finalize::variant_index(m.species(), &v);
+    }
+    if m.species() == crate::mobs::Species::Chicken
+        && let Some(t) = number(tag.get("EggLayTime"))
+    {
+        m.extra.egg_time = t as i32;
+    }
+    if let Some(v) = text(tag.get("sound_variant")) {
+        let v = v.trim_start_matches("minecraft:");
+        let sounds = crate::mobs::finalize::sound_variants(m.species());
+        m.extra.sound_variant = sounds.iter().position(|n| *n == v).map(|i| i as u8);
+    }
+    match m.species() {
+        crate::mobs::Species::Fox => {
+            m.extra.variant = u8::from(text(tag.get("Type")).as_deref() == Some("snow"));
+        }
+        crate::mobs::Species::Rabbit => {
+            // Rabbit.Variant.byId: an unknown id is brown.
+            m.extra.variant = match number(tag.get("RabbitType")).unwrap_or(0) {
+                v @ (0..=5 | 99) => v as u8,
+                _ => 0,
+            };
+        }
+        crate::mobs::Species::Goat => {
+            m.extra.screaming = flag(tag, "IsScreamingGoat");
+            let horn = |key| number(tag.get(key)).is_some_and(|v| v == 0);
+            m.extra.lost_horns = [horn("HasLeftHorn"), horn("HasRightHorn")];
+        }
+        _ => {}
+    }
     if m.species() == crate::mobs::Species::Cat {
         m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner"));
         m.extra.tame = m.extra.owner.is_some();
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::CAT_VARIANTS
-                .iter()
-                .position(|n| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if m.species() == crate::mobs::Species::Wolf {
         let health = m.health;
@@ -817,14 +1030,6 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::WOLF_VARIANTS
-                .iter()
-                .position(|(n, _)| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if matches!(
         m.species(),
@@ -2425,6 +2630,123 @@ mod sheep_nbt_tests {
         let back = mob_from_nbt(&tag, &types, 2).unwrap();
         assert_eq!((back.extra.color, back.extra.sheared), (14, true));
     }
+
+    #[test]
+    fn farm_animals_keep_their_variant_and_sound_variant() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let mut m = Mob::new(
+            1,
+            types["minecraft:pig"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(
+            text(tag.get("variant")).as_deref(),
+            Some("minecraft:temperate")
+        );
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:classic")
+        );
+        // Spawned in a warm biome with the mini sounds.
+        (m.extra.variant, m.extra.sound_variant) = (1, Some(2));
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:warm"));
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:mini")
+        );
+        let back = mob_from_nbt(&tag, &types, 2).unwrap();
+        assert_eq!((back.extra.variant, back.extra.sound_variant), (1, Some(2)));
+        let mut hen = Mob::new(
+            3,
+            types["minecraft:chicken"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        (hen.extra.variant, hen.extra.egg_time) = (2, 7795);
+        let tag = mob_to_nbt(&hen, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:cold"));
+        let back = mob_from_nbt(&tag, &types, 4).unwrap();
+        assert_eq!((back.extra.variant, back.extra.egg_time), (2, 7795));
+        // The sound variants are indices into the registries finalizeSpawn draws from.
+        use crate::mobs::{Species, finalize};
+        let registries = finalize::SpawnRegistries::load(&root);
+        for (species, registry) in [
+            (Species::Pig, &registries.pig_sound),
+            (Species::Cow, &registries.cow_sound),
+            (Species::Chicken, &registries.chicken_sound),
+            (Species::Cat, &registries.cat_sound),
+            (Species::Wolf, &registries.wolf_sound),
+        ] {
+            assert_eq!(
+                finalize::sound_variants(species),
+                registry.names,
+                "{species:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn foxes_rabbits_and_goats_keep_their_kind() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let new = |kind: &str| Mob::new(1, types[kind].clone(), Vec3::new(0.0, 4.0, 0.0), 0.0);
+        let round_trip = |m: &Mob| {
+            let tag = mob_to_nbt(m, [1, 2, 3, 4], None);
+            (mob_from_nbt(&tag, &types, 2).unwrap(), tag)
+        };
+        let mut fox = new("minecraft:fox");
+        fox.extra.variant = 1;
+        let (back, tag) = round_trip(&fox);
+        assert_eq!(text(tag.get("Type")).as_deref(), Some("snow"));
+        assert_eq!(number(tag.get("Sleeping")), Some(0));
+        assert_eq!(back.extra.variant, 1);
+        let mut rabbit = new("minecraft:rabbit");
+        rabbit.extra.variant = 4;
+        let (back, tag) = round_trip(&rabbit);
+        assert_eq!(number(tag.get("RabbitType")), Some(4));
+        assert_eq!(back.extra.variant, 4);
+        let mut goat = new("minecraft:goat");
+        (goat.extra.screaming, goat.extra.lost_horns) = (true, [false, true]);
+        let (back, tag) = round_trip(&goat);
+        assert_eq!(number(tag.get("HasRightHorn")), Some(0));
+        assert_eq!(
+            (back.extra.screaming, back.extra.lost_horns),
+            (true, [false, true])
+        );
+        // A goat saved without horn flags has both, as vanilla reads it.
+        let bare = Tag::compound([
+            ("id", string("minecraft:goat")),
+            ("Pos", doubles(&[0.5, 64.0, 0.5])),
+        ]);
+        assert_eq!(
+            mob_from_nbt(&bare, &types, 3).unwrap().extra.lost_horns,
+            [false; 2]
+        );
+    }
 }
 
 #[cfg(test)]

crates/horizon-client/src/falling_block.rs

@@ -35,6 +35,18 @@ impl Damage {
             ..Self::default()
         }
     }
+    /// A block that starts to fall: anvils hurt, and a brushable block
+    /// breaks where it lands (BrushableBlock.tick: disableDrop).
+    pub fn falling(block: &str) -> Self {
+        if block.ends_with("anvil") {
+            Self::anvil()
+        } else {
+            Self {
+                cancel_drop: block.starts_with("minecraft:suspicious_"),
+                ..Self::default()
+            }
+        }
+    }
     pub fn from_nbt(tag: &Tag, anvil: bool) -> Self {
         Self {
             hurt_entities: number(tag.get("HurtEntities")).map_or(anvil, |v| v != 0),
@@ -181,6 +193,14 @@ pub fn hurt_mobs(mobs: &mut [Mob], position: Vec3, amount: f32) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[test]
+    fn only_brushable_blocks_break_where_they_land() {
+        assert!(Damage::falling("minecraft:suspicious_gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:suspicious_sand").cancel_drop);
+        assert!(!Damage::falling("minecraft:gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:chipped_anvil").hurt_entities);
+    }
+
     #[test]
     fn impact_uses_ceil_distance_capped_damage_and_positive_damage_wear() {
         let damage = Damage::anvil();

crates/horizon-client/src/game.rs

@@ -18,6 +18,7 @@ mod boats;
 mod books;
 mod bossbars;
 mod breezes;
+mod bundles;
 mod campfire;
 mod campfire_douse;
 mod cartography;
@@ -102,7 +103,12 @@ mod maps;
 mod minecarts;
 mod mob_blocks;
 mod mob_gear;
+mod mod_browser;
+#[cfg(feature = "mods")]
+mod mod_browser_recipes;
 mod mod_input;
+#[cfg(feature = "mods")]
+mod mod_recipes;
 mod mod_render;
 mod mods;
 mod mount_menu;
@@ -151,6 +157,7 @@ mod scoreboard;
 mod screens;
 mod sculk;
 mod sculk_fixture;
+mod server_links;
 mod server_mods;
 mod server_packs;
 mod server_travel;
@@ -370,7 +377,7 @@ impl Options {
             match arg.as_str() {
                 "--help" | "-h" => {
                     println!(
-                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
+                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --quickPlaySingleplayer WORLD  Open this world of saves/ at start, only if it exists (vanilla's)\n  --quickPlayMultiplayer HOST[:PORT]  The same as --server (vanilla's name)\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
                         horizon_core::VANILLA_VERSION
                     );
                     return Ok(None);
@@ -425,6 +432,16 @@ impl Options {
                         "--width" => o.window_size[0] = value.parse::<u32>()?.max(1),
                         "--height" => o.window_size[1] = value.parse::<u32>()?.max(1),
                         "--world" => o.world = Some(value),
+                        // Vanilla's quick play (Main, QuickPlay.joinSingleplayerWorld): only a
+                        // world that exists opens; else the title screen. --world also creates one.
+                        "--quickPlaySingleplayer" => {
+                            let folder = std::env::current_dir()?.join("saves").join(&value);
+                            if folder.join("level.dat").is_file() {
+                                o.world = Some(value);
+                            } else {
+                                eprintln!("Quick play: there is no world {value} in saves/");
+                            }
+                        }
                         "--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?),
                         "--benchmark" => {
                             if horizon_client::benchmark::scenes(&value).is_none() {
@@ -435,7 +452,7 @@ impl Options {
                             }
                             o.benchmark = Some(value);
                         }
-                        "--server" => o.server = Some(value),
+                        "--server" | "--quickPlayMultiplayer" => o.server = Some(value),
                         "--name" => o.player_name = Some(value),
                         "--session-file" => session_file = Some(value),
                         "--control-socket" => o.control = Some(value.into()),
@@ -492,6 +509,12 @@ enum Screen {
     Friends,
     /// CommandBlockEditScreen (game/command_blocks.rs).
     CommandBlock,
+    /// ServerLinksDialogScreen: a server's links (game/server_links.rs).
+    ServerLinks,
+    /// ConfirmLinkScreen for a server link (game/server_links.rs).
+    ConfirmLink,
+    /// DialogScreen.WarningScreen: the note about custom screens.
+    DialogWarning,
     /// WinScreen: the end poem and the credits (game/win.rs).
     Win,
     /// A `ui` mod's own screen, or its settings page from Options > Mods
@@ -1260,6 +1283,8 @@ struct Game<'a> {
     inv_clicks: horizon_client::container_screen::Clicks,
     /// The Mouse Tweaks extra's drag and wheel (`tweaks`).
     tweaks: tweaks::Tweaks,
+    /// The wheel and hovered slot of `BundleMouseActions`.
+    bundle_mouse: bundles::BundleMouse,
     /// The last inventory click, for the double click that gathers a stack.
     last_inv_click: Option<(std::time::Instant, usize, bool)>,
     /// `lastQuickMoved`: what the last Shift click moved, which a Shift
@@ -1427,6 +1452,10 @@ struct Game<'a> {
     titles: titles::Titles,
     /// `Hud.toolHighlightTimer`: the selected item name.
     tool_highlight: horizon_client::hud_overlays::ToolHighlight,
+    /// `Hud.autosaveIndicatorValue`.
+    saving_indicator: horizon_client::hud_overlays::SavingIndicator,
+    /// This game's world is autosaving this tick (`MinecraftServer.isSaving`).
+    autosaving: bool,
     applied_modifiers: Vec<(String, String)>,
     experience: Experience,
     orbs: Vec<ExperienceOrb>,
@@ -1653,12 +1682,13 @@ struct Game<'a> {
     guest_use: Option<GuestUse>,
     /// Level events of this tick for the guests, and the guest acting now.
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
+    lan_cushion_breaks: Vec<(horizon_world::registry::BlockStateId, [f64; 3])>,
     /// Block events (position, b0, b1, state) and entity events (id, event,
     /// position) for the guests.
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
     /// Successful crits (attacking guest, hit entity), queued while the hub is taken.
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Global level events for every guest (`ServerLevel.globalLevelEvent`).
     lan_global_events: Vec<(i32, [i32; 3], i32)>,
     /// `ContainerOpenersCounter`: how many players (the host and the guests)
@@ -1676,6 +1706,9 @@ struct Game<'a> {
     /// The acting guest's cooldowns, as (item, ticks): their packet needs the
     /// hub's item registry, which the guest's turn does not hold.
     guest_cooldowns: Vec<(Arc<str>, i32)>,
+    /// The acting guest's own entity events (`ServerPlayer.connection.send`),
+    /// sent with their entity id, which the guest's turn does not hold.
+    guest_entity_events: Vec<i8>,
     /// `broadcastToAdmins` lines a guest's command queued, sent once it
     /// returns: the line, whether operators get it and whether the console
     /// logs it.
@@ -1710,6 +1743,8 @@ struct Game<'a> {
     restore_player_state: bool,
     stats_ui: stats_screen::StatsUi,
     adv_ui: advancements_screen::AdvUi,
+    /// The Server Links screens' state (game/server_links.rs).
+    links_ui: server_links::LinksUi,
     camera_type: perspective::CameraType,
     fangs: fangs::FangState,
     /// The local player as a model (third person, the inventory).
@@ -1806,9 +1841,46 @@ impl Game<'_> {
     fn reach(&self) -> f64 {
         if self.creative { 5.0 } else { 4.5 }
     }
+    /// Outline shapes that depend on more than the block state, as one box
+    /// in block space: `LightBlock` and `ScaffoldingBlock.getShape` are a full
+    /// block while the main hand holds the block's own item
+    /// (`CollisionContext.isHoldingItem`), and `ShulkerBoxBlock.getShape`
+    /// grows with the lid (`ShulkerBoxBlockEntity.getBoundingBox`).
+    fn context_outline(&self, pos: [i32; 3], state: BlockStateId) -> Option<[f64; 6]> {
+        let name = &self.res.facts().get(state).name;
+        if matches!(&**name, "minecraft:light" | "minecraft:scaffolding") {
+            return self
+                .held()
+                .is_some_and(|s| *s.item == **name)
+                .then_some([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
+        }
+        if !name.ends_with("shulker_box") {
+            return None;
+        }
+        let progress = self.be_anims.shulkers.get(&pos).map_or(0.0, |s| s.progress);
+        let facing = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("facing").cloned());
+        let d = facing_offset(facing.as_deref().unwrap_or("up"));
+        let mut b = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
+        for a in 0..3 {
+            match d[a] {
+                1 => b[a + 3] += 0.5 * f64::from(progress),
+                -1 => b[a] -= 0.5 * f64::from(progress),
+                _ => {}
+            }
+        }
+        Some(b)
+    }
     /// A block's outline boxes in world space (`getShape` plus the random offset).
     fn outline_boxes(&self, pos: [i32; 3]) -> Vec<[f64; 6]> {
         let state = self.world.block(pos[0], pos[1], pos[2]);
+        if let Some(b) = self.context_outline(pos, state) {
+            return vec![std::array::from_fn(|i| f64::from(pos[i % 3]) + b[i])];
+        }
         let f = self.res.facts().get(state);
         let o = if f.outline_offset {
             self.pack
@@ -2103,6 +2175,33 @@ impl Game<'_> {
     }
     /// `TerrainParticle` at `pos`: the model's particle sprite and tint source
     /// 0's `colorAsTerrainParticle` (white when the block has none).
+    /// `HoneyBlock.showSlideParticles` (entity event 53): five honey block
+    /// particles at the entity.
+    fn honey_slide_particles(&mut self, at: [f64; 3]) {
+        use horizon_client::particles::{ParticleOptions, ParticleType};
+        let Some(honey) = self
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:honey_block")
+        else {
+            return;
+        };
+        let block = [
+            at[0].floor() as i32,
+            at[1].floor() as i32,
+            at[2].floor() as i32,
+        ];
+        if let Some((sprite, tint)) = self.particle_sprite(honey, block) {
+            for _ in 0..5 {
+                self.particles.add(
+                    &ParticleOptions::block(ParticleType::Block, sprite.clone(), tint),
+                    at,
+                    [0.0; 3],
+                );
+            }
+        }
+    }
     fn particle_sprite(&self, state: BlockStateId, pos: [i32; 3]) -> Option<(String, u32)> {
         let sprite = Self::block_particle_sprite(&self.pack, state)?;
         let chunks = &self.world.chunks;
@@ -2320,11 +2419,18 @@ impl Game<'_> {
             yaw.cos() * pitch.cos() * 0.3 + spread.sin() * strength,
         ];
         self.spawn_item(thrown, [eye[0], eye[1] - 0.3, eye[2]], v, 40);
-        if thrown_from_hand && self.lan_acting.is_none() {
-            let uuid = self.level.ensure_player_uuid();
+        if thrown_from_hand {
+            let uuid = self.acting_player_uuid();
             self.dropped.last_mut().unwrap().thrower = Some(uuid);
         }
     }
+    /// The UUID of the player acting: the guest whose turn it is, else the host.
+    pub(super) fn acting_player_uuid(&mut self) -> [i32; 4] {
+        match self.lan_acting_uuid {
+            Some(guest) => horizon_client::lan::playerdata::uuid_ints(guest),
+            None => self.level.ensure_player_uuid(),
+        }
+    }
     fn tick_items(&mut self) {
         let mut items = std::mem::take(&mut self.dropped);
         // ServerLevel.tick: only entities in entity-ticking chunks tick.
@@ -2897,6 +3003,16 @@ impl Game<'_> {
                     data,
                 } => self.sculk_charge_event(pos, data),
                 LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos),
+                // LevelEventHandler 2019 and 2020: the crack on a face of the
+                // block being mined, with its hit sound for 2020.
+                LevelEvent::LevelEvent {
+                    id: id @ (2019 | 2020),
+                    pos,
+                    data,
+                } => {
+                    let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize];
+                    self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020);
+                }
                 LevelEvent::LevelEvent { id: 2004, pos, .. } => {
                     self.spawner_burst([pos.x, pos.y, pos.z])
                 }
@@ -2916,6 +3032,11 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.dragon_egg_particles([pos.x, pos.y, pos.z], data),
+                LevelEvent::LevelEvent {
+                    id: 2016,
+                    pos,
+                    data,
+                } => self.shulker_teleport_particles([pos.x, pos.y, pos.z], data),
                 LevelEvent::LevelEvent {
                     id: 2017,
                     pos,
@@ -2929,6 +3050,17 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.smash_dust(pos, data),
+                // LevelEventHandler 2002 and 2007: a potion's splash.
+                LevelEvent::LevelEvent {
+                    id: 2002,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, false),
+                LevelEvent::LevelEvent {
+                    id: 2007,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, true),
                 LevelEvent::LevelEvent {
                     id: id @ 3002..=3005,
                     pos,
@@ -2964,6 +3096,8 @@ impl Game<'_> {
                         1044 => Some(("minecraft:block.smithing_table.use", 1.0)),
                         // LevelEvent.SOUND_PAGE_TURN (a lectern's page).
                         1043 => Some(("minecraft:item.book.page_turn", 1.0)),
+                        // LevelEvent.SOUND_SPLASH_POTION and its instant twin.
+                        1053 | 1054 => Some(("minecraft:entity.splash_potion.break", 1.0)),
                         _ => None,
                     };
                     if let Some((name, volume)) = sound {
@@ -2973,7 +3107,7 @@ impl Game<'_> {
                                     - self.world.random.next_float())
                                     * 0.8
                             }
-                            1029 | 1030 | 1042 | 1043 | 1044 => {
+                            1029 | 1030 | 1042 | 1043 | 1044 | 1053 | 1054 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
                             1019 | 1021 => {
@@ -2983,7 +3117,7 @@ impl Game<'_> {
                             }
                             _ => 1.0,
                         };
-                        if matches!(id, 1019 | 1021 | 1029 | 1030) {
+                        if matches!(id, 1019 | 1021 | 1029 | 1030 | 1053 | 1054) {
                             // Clients play the anvil sound from its level event;
                             // capturing it also sends a duplicate sound packet.
                             self.audio.play_unshared(name, c, volume, pitch);
@@ -3032,11 +3166,9 @@ impl Game<'_> {
                         drop_item: true,
                         fall_distance: 0.0,
                         stuck: Vec3::ZERO,
-                        damage: if self.res.facts().get(state).name.ends_with("anvil") {
-                            horizon_client::falling_block::Damage::anvil()
-                        } else {
-                            Default::default()
-                        },
+                        damage: horizon_client::falling_block::Damage::falling(
+                            &self.res.facts().get(state).name,
+                        ),
                         saved: None,
                     });
                 }
@@ -3139,6 +3271,31 @@ impl Game<'_> {
                 LevelEvent::BlockEntityEvent { pos, a, b, .. } => {
                     self.block_entity_event([pos.x, pos.y, pos.z], a, b)
                 }
+                // NoteBlock.triggerEvent: a NOTE particle above, coloured by
+                // the note (`note / 24.0` in the x speed).
+                LevelEvent::BlockEvent {
+                    pos,
+                    state,
+                    kind: "note_particle",
+                } => {
+                    use horizon_client::particles::{ParticleOptions, ParticleType};
+                    let note = self
+                        .pack
+                        .assets
+                        .registry
+                        .state(state)
+                        .and_then(|s| s.properties.get("note")?.parse::<f64>().ok())
+                        .unwrap_or(0.0);
+                    self.particles.add(
+                        &ParticleOptions::simple(ParticleType::Note),
+                        [
+                            f64::from(pos.x) + 0.5,
+                            f64::from(pos.y) + 1.2,
+                            f64::from(pos.z) + 0.5,
+                        ],
+                        [note / 24.0, 0.0, 0.0],
+                    );
+                }
                 LevelEvent::GrowTree { .. }
                 | LevelEvent::PlaceFeature { .. }
                 | LevelEvent::BlockEvent { .. } => {}
@@ -3514,7 +3671,7 @@ impl Game<'_> {
         } else if let Some(tag) = spill::saved_entity(&self.world, pos) {
             self.pending.record_saved(pos, &tag);
         }
-        self.creaking_heart_broken(pos);
+        self.creaking_heart_broken(pos, true);
         let hive = match self.world.block_entities.get(&key) {
             Some(BlockEntity::Beehive(h)) => self.hive_state(pos).map(|s| ((**h).clone(), s)),
             _ => None,
@@ -4073,6 +4230,7 @@ impl Game<'_> {
         if &*stack.item == "minecraft:spyglass" {
             // SpyglassItem.USE_DURATION, then finishUsingItem.
             if ticks + 1 >= 1200 {
+                self.send_use_item_complete();
                 self.stop_spyglass();
                 self.using = None;
             } else {
@@ -4094,6 +4252,7 @@ impl Game<'_> {
         }
         if ticks >= duration {
             self.using = None;
+            self.send_use_item_complete();
             // ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
             self.apply_use_cooldown(&stack);
             self.finish_consuming(&info, consumable, &stack);
@@ -4112,6 +4271,17 @@ impl Game<'_> {
             _ => {}
         }
     }
+    /// `ServerPlayerGameMode.tick` while a player digs: level event 2020 every
+    /// fourth tick since the START (the hit sound), else 2019 (the crack only),
+    /// for everyone around, the digger included (`levelEvent(null, ...)`).
+    fn destroy_progress_event(&mut self, pos: [i32; 3], face: [i32; 3], ticks: u32) {
+        let id = if ticks.is_multiple_of(4) { 2020 } else { 2019 };
+        let direction = horizon_core::geometry::Direction::ALL
+            .iter()
+            .position(|d| d.normal() == face)
+            .unwrap_or(1);
+        self.level_event_at(id, pos, direction as i32);
+    }
     fn tick_mining(&mut self) -> Result<()> {
         if self.destroy_delay > 0 {
             self.destroy_delay -= 1;
@@ -4155,6 +4325,11 @@ impl Game<'_> {
         let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
         let facts = self.res.facts().get(state);
         if facts.hardness < 0.0 {
+            // The server still counts its destroy ticks on an unbreakable block.
+            let m = self.mining.as_mut().ok_or("mining")?;
+            m.ticks += 1;
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
             return Ok(());
         }
         // Player.getDestroySpeed / BlockBehaviour.getDestroyProgress.
@@ -4185,26 +4360,15 @@ impl Game<'_> {
         } else {
             speed / facts.hardness / if harvest { 30.0 } else { 100.0 }
         };
-        let hit_sound = facts.sounds.clone();
         self.swing_arm();
         let m = self.mining.as_mut().ok_or("mining")?;
         m.progress += progress;
         m.ticks += 1;
-        let crack = (m.pos, hit.face);
-        if m.ticks % 4 == 1 {
-            let c = [
-                f64::from(m.pos[0]) + 0.5,
-                f64::from(m.pos[1]) + 0.5,
-                f64::from(m.pos[2]) + 0.5,
-            ];
-            self.audio.play(
-                &hit_sound.hit,
-                Some(c),
-                (hit_sound.volume + 1.0) / 8.0,
-                hit_sound.pitch * 0.5,
-            );
+        // An instant break at START sends no destroy events.
+        if m.progress < 1.0 || m.ticks > 1 {
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
         }
-        self.crack_particle(crack.0, crack.1, state);
         let m = self.mining.as_mut().ok_or("mining")?;
         // ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
         // insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
@@ -4306,6 +4470,12 @@ impl Game<'_> {
                 // The world's spawn from the start, not only once saved: a bed set
                 // before the first save must not become it.
                 self.level.world_spawn.get_or_insert([x, y, z]);
+                // The "Bonus Chest" create-world option, placed once with the spawn.
+                if horizon_client::save::WorldGen::read(&self.world_root)
+                    .is_some_and(|g| g.bonus_chest)
+                {
+                    self.place_bonus_chest([x, y, z])?;
+                }
             }
             let s = self
                 .level
@@ -4409,7 +4579,11 @@ impl Game<'_> {
             self.world.weather.tick_levels();
             self.tick_weather_effects();
         }
-        if self.ticks.is_multiple_of(6000) {
+        self.autosaving = self.ticks.is_multiple_of(6000);
+        if let Some(serving) = &self.serving {
+            serving.set_saving(self.autosaving);
+        }
+        if self.autosaving {
             self.save_game_with(false)?;
         }
         if running {
@@ -4515,6 +4689,22 @@ impl Game<'_> {
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
         let crouching = player.pose == horizon_client::pose::Pose::Crouching;
+        // `LivingEntity.baseTick` (Soul Speed) comes before `aiStep` (the
+        // glide's wear): both draw from the level random.
+        if let Some((at, velocity)) = self.tick_soul_speed() {
+            self.particles.send_particles(
+                &horizon_client::particles::ParticleOptions::simple(
+                    horizon_client::particles::ParticleType::Soul,
+                ),
+                at,
+                velocity,
+                1.0,
+                0,
+            );
+            if let Some(host) = self.lan.as_ref() {
+                lan_particles::send_soul_particle(host, at, velocity);
+            }
+        }
         // `ItemStack.hurtAndBreak` for the glide: Unbreaking can save the wear.
         if glider_wear > 0
             && !self.creative
@@ -4604,9 +4794,32 @@ impl Game<'_> {
                     };
                     self.audio.play(name, Some(feet), volume, pitch);
                 }
+                // LivingEntity.checkFallDamage: the block's crumbs where the fall landed.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(None, state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
+                MotionEvent::HoneySlide {
+                    sound, particles, ..
+                } => {
+                    if sound {
+                        self.audio
+                            .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
+                    }
+                    if particles {
+                        self.honey_slide_particles(feet);
+                        // The server's event 53 reaches the guests too.
+                        let id = self.lan.as_ref().map(|h| h.host_entity);
+                        if let Some(id) = id {
+                            self.lan_entity_event(id, 53, feet);
+                        }
+                    }
+                }
                 MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
                 MotionEvent::CauldronExtinguish { pos } => self.cauldron_extinguish(pos),
                 MotionEvent::InsideWitherRose => self.wither_rose_contact(),
@@ -4709,6 +4922,7 @@ impl Game<'_> {
     /// What the tick runs after the local player's own update: effects, the
     /// world's entities and blocks, and the network hub.
     fn tick_world(&mut self, running: bool) -> Result<()> {
+        self.share_spawn_conditions();
         self.update_chunk_tickets();
         horizon_client::spans::time("tick_effects", || self.tick_effects(running));
         // Player.tick's ItemCooldowns.tick for the window's player (a
@@ -4716,6 +4930,7 @@ impl Game<'_> {
         self.shield_cooldown = self.shield_cooldown.saturating_sub(1);
         self.cooldowns.tick();
         horizon_client::spans::time("tick_using", || self.tick_using());
+        self.tick_bundle_hover();
         horizon_client::spans::time("tick_hud", || self.tick_hud());
         // The player's digging comes in with its packets, before the level
         // ticks; ServerLevel.tick then runs the scheduled and random block
@@ -4918,6 +5133,9 @@ impl Game<'_> {
                     | Screen::Advancements
                     | Screen::WorldOptions
                     | Screen::Friends
+                    | Screen::ServerLinks
+                    | Screen::ConfirmLink
+                    | Screen::DialogWarning
                     | Screen::CommandBlock
             ) || self.book.is_some()
                 || self.win_screen_pauses())
@@ -5401,9 +5619,13 @@ impl Game<'_> {
             Screen::Advancements => self.draw_advancements(&mut batch),
             Screen::WorldOptions => self.draw_world_options(&mut batch),
             Screen::Friends => self.draw_friends_screen(&mut batch),
+            Screen::ServerLinks => self.draw_server_links(&mut batch),
+            Screen::ConfirmLink => self.draw_confirm_link(&mut batch),
+            Screen::DialogWarning => self.draw_dialog_warning(&mut batch),
             Screen::CommandBlock => self.draw_command_block(&mut batch),
             Screen::Inventory => {
                 self.draw_inventory(&mut batch);
+                self.draw_mod_browser(&mut batch);
             }
             Screen::Creative => {
                 self.draw_creative(&mut batch);
@@ -5412,6 +5634,7 @@ impl Game<'_> {
             Screen::Mod => self.draw_mod_screen(&mut batch),
             Screen::Playing | Screen::Options | Screen::Win => {}
         }
+        self.draw_saving_indicator(&mut batch);
         self.draw_toasts(&mut batch);
         self.draw_pack_toasts(&mut batch);
         self.remote_hud(&mut batch);
@@ -5796,6 +6019,7 @@ impl Game<'_> {
         self.last_inv_click = None;
     }
     pub(super) fn close_container(&mut self) {
+        self.mod_browser_closed();
         self.reset_inventory_clicks();
         self.close_station();
         self.mount_closed();
@@ -5911,6 +6135,12 @@ impl Game<'_> {
     /// Several clicks on one menu instance (a quick craft drag is three).
     fn menu_ops(&mut self, ops: &[(Option<usize>, i32, horizon_client::menu::Input)]) -> bool {
         use horizon_client::menu::Input;
+        // BundleMouseActions.onSlotClicked: a Shift click or a swap clears the bundle's selection.
+        for &(slot, _, input) in ops {
+            if let (Some(slot), Input::QuickMove | Input::Swap) = (slot, input) {
+                self.unselect_bundle(slot);
+            }
+        }
         if self.remote.is_some() && self.screen == Screen::Inventory {
             // On a server the clicks are the server's: predicted and sent.
             return self.remote_menu_ops(ops);
@@ -6523,6 +6753,9 @@ impl Game<'_> {
     fn inventory_press(&mut self, right: bool) {
         use horizon_client::container_screen::Target;
         use horizon_client::menu::Input;
+        if self.mod_browser_press(right) {
+            return;
+        }
         if !right && self.sort_press() {
             return;
         }
@@ -6706,24 +6939,8 @@ impl Game<'_> {
     }
     /// `hasClickedOutside` of the open screen at the cursor.
     fn clicked_outside(&self, batch: &HudBatch) -> bool {
-        use horizon_client::container_screen::{Book, Image, clicked_outside};
-        let (ox, oy) = self.inventory_origin(batch);
-        let (shift, width, height) = if self.screen == Screen::Creative {
-            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
-        } else {
-            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
-                Some(stations::Kind::Merchant) => (-50.0, 276),
-                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
-                _ => (0.0, 176),
-            };
-            (shift, width, self.screen_height() as i32)
-        };
-        let image = Image {
-            left: (ox + shift) as i32,
-            top: oy as i32,
-            width,
-            height,
-        };
+        use horizon_client::container_screen::{Book, clicked_outside};
+        let image = self.container_image(batch);
         let book = self
             .recipe_book_area(batch)
             .map(|(visible, tab_hovered)| Book {
@@ -6737,6 +6954,26 @@ impl Game<'_> {
             book,
         )
     }
+    /// The open container screen's window: its place and size.
+    fn container_image(&self, batch: &HudBatch) -> horizon_client::container_screen::Image {
+        let (ox, oy) = self.inventory_origin(batch);
+        let (shift, width, height) = if self.screen == Screen::Creative {
+            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
+        } else {
+            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
+                Some(stations::Kind::Merchant) => (-50.0, 276),
+                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
+                _ => (0.0, 176),
+            };
+            (shift, width, self.screen_height() as i32)
+        };
+        horizon_client::container_screen::Image {
+            left: (ox + shift) as i32,
+            top: oy as i32,
+            width,
+            height,
+        }
+    }
     /// A click outside the window (slot id -999): `THROW` does nothing; a
     /// `PICKUP` drops the carried stack (left) or one of it (right), thrown
     /// from the hand (`AbstractContainerMenu.doClick`, `LivingEntity.drop`).
@@ -6897,7 +7134,7 @@ impl Game<'_> {
         }
     }
     fn click_inventory(&mut self, right: bool) {
-        if self.mount_click(right) {
+        if self.mod_browser_press(right) || self.mount_click(right) {
             return;
         }
         if self.recipe_book_click(right) {
@@ -7229,7 +7466,12 @@ impl Game<'_> {
         self.see_through_vertices = see_through;
         // Entity shadows (EntityRenderer.extractShadow).
         self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
-        if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
+        let shadow_sprite = self
+            .settings
+            .entity_shadows
+            .then(|| self.gui.atlas.sprites.get("misc/shadow").copied())
+            .flatten();
+        if let Some(sprite) = shadow_sprite {
             let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
             let darken = self.sky_darken();
             let a = alpha;
@@ -7628,7 +7870,7 @@ impl Game<'_> {
     /// strength and whether it is a critical hit): the weapon and effects
     /// scaled by the attack strength, a mace's smash, the critical hit, then
     /// enchantments.
-    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool) {
+    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool, bool) {
         let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
         // Riptide's spin replaces the attack damage attribute.
         let spin = self.player.as_ref().map_or(0.0, |p| p.auto_spin_attack_dmg);
@@ -7656,8 +7898,9 @@ impl Game<'_> {
             amount *= 1.5;
         }
         // Enchantment damage (sharpness, smite, bane) scaled by the attack strength.
-        amount += self.enchant_damage_bonus(target_kind) * scale;
-        (amount, scale, crit)
+        let magic_boost = self.enchant_damage_bonus(target_kind) * scale;
+        amount += magic_boost;
+        (amount, scale, crit, magic_boost > 0.0)
     }
     /// `Player.getAttackStrengthScale(0.5)`.
     fn attack_strength_scale(&self) -> f32 {
@@ -7844,7 +8087,7 @@ impl Game<'_> {
     pub(super) fn attack_mob(&mut self, index: usize) {
         let target_kind = self.mobs[index].kind.id.clone();
         let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
-        let (amount, scale, crit) = self.melee_damage(&target_kind);
+        let (amount, scale, crit, magic) = self.melee_damage(&target_kind);
         let sweep = self.sweep_attack_position(scale, crit);
         let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
         self.attack_ticks = 0;
@@ -7907,6 +8150,18 @@ impl Game<'_> {
                     feet,
                     width,
                     height,
+                    false,
+                );
+            }
+            // Player.attackVisualEffects: magicCrit when the enchantments added damage.
+            if magic {
+                self.critical_hit(
+                    self.lan_acting,
+                    self.mobs[index].id as i32,
+                    feet,
+                    width,
+                    height,
+                    true,
                 );
             }
             if actual > 2.0 {
@@ -8069,6 +8324,7 @@ impl Game<'_> {
         creative: bool,
         create: Option<&horizon_client::title::WorldOptions>,
     ) -> Result<()> {
+        world_loading::world_data_used();
         if self.defer_world_entry(PendingWorldEntry::Local {
             folder: folder.to_owned(),
             name: name.map(str::to_owned),
@@ -8134,6 +8390,7 @@ impl Game<'_> {
         );
         self.session_lock = Some(session_lock);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         self.score = Default::default();
         self.fns = Default::default();
         self.bosses = Default::default();
@@ -8272,6 +8529,7 @@ impl Game<'_> {
             seed,
         )?;
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         Ok((streaming, save))
     }
     /// Change dimension through a portal (Entity.changeDimension with
@@ -10756,6 +11014,17 @@ impl Game<'_> {
                         [0.0; 3]
                     };
                     let p = h.pos.map(f64::from);
+                    if let Some(b) = self.context_outline(h.pos, state) {
+                        return horizon_client::blocks::cube_edges()
+                            .iter()
+                            .map(|e| {
+                                std::array::from_fn(|i| {
+                                    let k = i % 3;
+                                    p[k] + b[k] + e[i] * (b[k + 3] - b[k])
+                                })
+                            })
+                            .collect();
+                    }
                     f.outline_edges
                         .iter()
                         .map(|e| std::array::from_fn(|i| p[i % 3] + o[i % 3] + e[i]))
@@ -11147,6 +11416,10 @@ impl Game<'_> {
                 Screen::GameModeSwitcher => self.close_gamemode_switcher(false),
                 Screen::Dead => {}
                 Screen::Stats | Screen::Friends => self.screen = Screen::Paused,
+                Screen::ServerLinks => self.screen = Screen::Paused,
+                // ConfirmScreen.keyPressed: Escape answers no; both return to
+                // the Server Links screen they came from.
+                Screen::ConfirmLink | Screen::DialogWarning => self.screen = Screen::ServerLinks,
                 Screen::Advancements => self.close_advancements(),
                 Screen::WorldOptions => self.world_options_escape(),
                 Screen::CommandBlock => self.close_command_block(),
@@ -11215,8 +11488,10 @@ impl Game<'_> {
             // key.swapOffhand: on a server, ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND
             // (the server swaps the hands and sends both slots back; spectators can't).
             KeyCode::KeyF if self.screen == Screen::Playing && self.remote.is_some() => {
-                if !self.spectator() {
-                    self.remote_swap_hands();
+                if !self.spectator()
+                    && let Some(r) = self.remote.as_mut()
+                {
+                    r.pending_keys.push(key);
                 }
             }
             KeyCode::KeyF if self.screen == Screen::Playing => {
@@ -11313,11 +11588,28 @@ impl Game<'_> {
         }
         Ok(())
     }
-    /// LOD Distance as far terrain uses it (`Graphics::lod_distance_on`).
+    /// LOD Distance and Far Detail Reduced as chosen: the player's LOD
+    /// Distance when it is on, else a mod's far terrain
+    /// (`render.set-far-terrain`).
+    fn far_terrain_choice(&self) -> (u32, bool) {
+        let g = &self.settings.horizon;
+        let reduced = g.far_detail == horizon_client::graphics::FarDetail::Reduced;
+        if g.lod_distance > 0 {
+            return (g.lod_distance, reduced);
+        }
+        match self.mod_far_terrain() {
+            Some(f) => (f.distance, reduced || f.reduced),
+            None => (0, reduced),
+        }
+    }
+    /// LOD Distance as far terrain uses it (`graphics::lod_distance_capped`).
     fn lod_distance(&self) -> u32 {
+        let (distance, _) = self.far_terrain_choice();
         match &self.renderer {
-            Some(renderer) => self.settings.horizon.lod_distance_on(&renderer.info),
-            None => self.settings.horizon.lod_distance.min(1024),
+            Some(renderer) => {
+                horizon_client::graphics::lod_distance_capped(distance, &renderer.info)
+            }
+            None => distance.min(1024),
         }
     }
     /// Only enabled LOD worlds extend the renderer's range, never simulation.
@@ -11338,7 +11630,7 @@ impl Game<'_> {
         }
     }
     fn prepare_lod(&mut self) {
-        let enabled = self.settings.horizon.lod_distance > 0
+        let enabled = self.far_terrain_choice().0 > 0
             && self.renderer.is_some()
             && self.player.is_some()
             && self.title.is_none()
@@ -11435,6 +11727,7 @@ impl Game<'_> {
         {
             log::warn!("Horizon: failed to save unloaded chunks: {e}");
         }
+        let (far_distance, far_reduced) = self.far_terrain_choice();
         if let Some(renderer) = self.renderer.as_mut() {
             let g = &self.settings.horizon;
             let budgeted = g.chunk_updates > 0 || g.upload_budget_kib > 0;
@@ -11488,12 +11781,10 @@ impl Game<'_> {
             }
             renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z)));
             if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) {
-                let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info);
+                let lod_distance =
+                    horizon_client::graphics::lod_distance_capped(far_distance, &renderer.info);
                 lod.set_near_loading(self.streaming.busy());
-                lod.set_reduced_detail(
-                    self.settings.horizon.far_detail
-                        == horizon_client::graphics::FarDetail::Reduced,
-                );
+                lod.set_reduced_detail(far_reduced);
                 // The covered columns change only with the complete ones and
                 // the render area: rebuilt then, not every frame.
                 let at = (
@@ -11816,6 +12107,7 @@ impl ApplicationHandler for Game<'_> {
                     }
                     if self.screen == Screen::Inventory
                         && d != 0.0
+                        && !self.bundle_scroll(scaled(raw_x), scaled(raw_y))
                         && !self.tweak_scroll(d, self.inventory_target().0)
                     {
                         self.station_scroll(d);
@@ -11826,6 +12118,9 @@ impl ApplicationHandler for Game<'_> {
                     if self.screen == Screen::WorldOptions && d != 0.0 {
                         self.world_options_scroll(d);
                     }
+                    if self.screen == Screen::ServerLinks && d != 0.0 {
+                        self.server_links_scroll(d);
+                    }
                     if self.screen == Screen::Advancements {
                         self.advancements_scroll(scaled(raw_x) as f32, d);
                     }
@@ -12017,6 +12312,15 @@ impl ApplicationHandler for Game<'_> {
                         Screen::WorldOptions if pressed && button == MouseButton::Left => {
                             self.world_options_click()
                         }
+                        Screen::ServerLinks if pressed && button == MouseButton::Left => {
+                            self.server_links_click()?
+                        }
+                        Screen::ConfirmLink if pressed && button == MouseButton::Left => {
+                            self.confirm_link_click()
+                        }
+                        Screen::DialogWarning if pressed && button == MouseButton::Left => {
+                            self.dialog_warning_click()?
+                        }
                         Screen::WorldOptions if button == MouseButton::Left => {
                             self.world_options_release()
                         }
@@ -12117,6 +12421,14 @@ impl ApplicationHandler for Game<'_> {
                     // The recipe book's search box takes every key but Escape.
                     self.recipe_key(&event);
                 }
+                WindowEvent::KeyboardInput { event, .. }
+                    if self.mod_browser_typing()
+                        && event.state == ElementState::Pressed
+                        && !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
+                {
+                    // A mod's item panel's search box, as the recipe book's.
+                    self.mod_browser_key(&event);
+                }
                 WindowEvent::KeyboardInput { event, .. }
                     if self.station_typing()
                         && event.state == ElementState::Pressed
@@ -12597,6 +12909,7 @@ impl<'a> Game<'a> {
             craft_table: None,
             inv_drag: None,
             tweaks: Default::default(),
+            bundle_mouse: Default::default(),
             inv_clicks: Default::default(),
             last_inv_click: None,
             last_quick_moved: None,
@@ -12658,7 +12971,14 @@ impl<'a> Game<'a> {
             level,
             session_lock: None,
             audio,
-            music: Default::default(),
+            music: {
+                // The manager starts with the saved option (MusicManager's constructor).
+                let mut music = horizon_client::music::MusicManager::default();
+                music.frequency = horizon_client::music::MusicFrequency::parse(
+                    &settings.file.name("musicFrequency"),
+                );
+                music
+            },
             ambience: Default::default(),
             sound_paused: false,
             cart_sounds: HashSet::new(),
@@ -12702,6 +13022,8 @@ impl<'a> Game<'a> {
             command_source: None,
             titles: Default::default(),
             tool_highlight: Default::default(),
+            saving_indicator: Default::default(),
+            autosaving: false,
             applied_modifiers: Vec::new(),
             experience: Experience::default(),
             orbs: Vec::new(),
@@ -12846,6 +13168,7 @@ impl<'a> Game<'a> {
             forced_hit: None,
             guest_use: None,
             lan_events: Vec::new(),
+            lan_cushion_breaks: Vec::new(),
             lan_block_events: Vec::new(),
             lan_entity_events: Vec::new(),
             lan_critical_hits: Vec::new(),
@@ -12854,6 +13177,7 @@ impl<'a> Game<'a> {
             lan_acting: None,
             guest_packets: Vec::new(),
             guest_cooldowns: Vec::new(),
+            guest_entity_events: Vec::new(),
             lan_acting_name: None,
             lan_acting_uuid: None,
             chat_capture: None,
@@ -12880,6 +13204,7 @@ impl<'a> Game<'a> {
             restore_player_state: true,
             stats_ui: Default::default(),
             adv_ui: Default::default(),
+            links_ui: Default::default(),
             camera_type: Default::default(),
             fangs: Default::default(),
             player_model: None,
@@ -13025,6 +13350,17 @@ impl Game<'_> {
         if self.rest_loader.is_some() {
             return Ok(());
         }
+        let on_world_screens = self.title.as_ref().is_some_and(|title| {
+            !matches!(
+                title.mode,
+                horizon_client::title::Mode::Main | horizon_client::title::Mode::Multiplayer(_)
+            )
+        });
+        world_loading::preload_world_data(
+            on_world_screens,
+            &self.options.resources,
+            self.pack.assets.registry,
+        );
         if std::mem::take(&mut self.pending_pack_reload) {
             self.reload_packs();
         }

crates/horizon-client/src/game/agent.rs

@@ -419,6 +419,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
@@ -707,9 +710,12 @@ impl Game<'_> {
             // the recipe buttons of the page, page arrows, filter and tabs.
             let book = self.recipe_book_targets();
             if !book.is_empty() {
+                let (open, filtering) = self.recipe_book_flags().unwrap_or_default();
                 v["recipe_book"] = json!({
                     "targets": book.iter().map(|t| t.rect).collect::<Vec<_>>(),
                     "known": self.recipe_book_known(),
+                    "open": open,
+                    "filtering": filtering,
                 });
             }
             v["slot_ids"] = json!(

crates/horizon-client/src/game/boats.rs

@@ -862,7 +862,7 @@ impl Game<'_> {
         let a = alpha as f32;
         let range = super::entity_culling::default_range(
             glam::DVec3::new(WIDTH, HEIGHT, WIDTH),
-            self.settings.entity_distance,
+            self.view_scale(),
         );
         for b in &self.boats {
             let entity_start = out.len();

crates/horizon-client/src/game/books.rs

@@ -1009,9 +1009,12 @@ impl Game<'_> {
             }
         };
         let indicator = |batch: &mut HudBatch, page: usize, count: usize| {
-            let text = tr("book.pageIndicator", "Page %s of %s")
-                .replacen("%s", &(page + 1).to_string(), 1)
-                .replacen("%s", &count.max(1).to_string(), 1);
+            // BookViewScreen.getPageNumberMessage: 26.3's en_us template is
+            // positional ("Page %1$s of %2$s").
+            let text = horizon_protocol::text::format_java(
+                &tr("book.pageIndicator", "Page %1$s of %2$s"),
+                &[(page + 1).to_string(), count.max(1).to_string()],
+            );
             let tw = HudBatch::text_width(atlas, &text);
             batch.text(atlas, &text, left + 148.0 - tw, top + 16.0, BLACK, false);
         };

crates/horizon-client/src/game/bundles.rs

@@ -0,0 +1,103 @@
+//! `BundleMouseActions`: the wheel over a bundle in a container screen selects
+//! one of the items it shows, which a click that takes one out of it then takes
+//! (`BundleContents.Mutable.removeOne`). Moving off the bundle clears the
+//! selection. On a server the selection is sent to it (`ServerboundSelectBundleItemPacket`).
+use super::{Game, Screen};
+use horizon_client::{
+    bundle::{Contents, toggle_selected},
+    mouse::ScrollWheelHandler,
+};
+use horizon_protocol::packets::play::{self, Serverbound as S};
+
+#[derive(Default)]
+pub(super) struct BundleMouse {
+    wheel: ScrollWheelHandler,
+    /// The slot under the cursor at the last tick (`AbstractContainerScreen.hoveredSlot`).
+    hovered: Option<usize>,
+}
+
+impl Game<'_> {
+    /// A slot a bundle can be selected in: the player's inventory, the off hand and a
+    /// container's own slots. A server only knows these in the inventory and chest-like menus.
+    fn bundle_slot(&mut self, slot: usize) -> bool {
+        (slot < 36 || slot == 504 || (300..500).contains(&slot))
+            && (self.remote.is_none() || self.remote_storage_open())
+            && (slot < 36 || slot == 504 || self.slots().contains(&slot))
+    }
+
+    /// `BundleMouseActions.onMouseScrolled`: the wheel over a bundle moves the selection
+    /// through the items its tooltip shows. True when the bundle took the wheel.
+    pub(super) fn bundle_scroll(&mut self, x: f64, y: f64) -> bool {
+        let Some(slot) = self.inventory_target().0 else {
+            return false;
+        };
+        if !self.bundle_slot(slot) {
+            return false;
+        }
+        let stack = self.slot_mut(slot).clone();
+        let items = self.res.items();
+        let Some(bundle) = stack.filter(|s| items.get(&s.item).is_some_and(|i| i.bundle)) else {
+            return false;
+        };
+        let shown = Contents::of(items, &bundle).map_or(0, |c| c.shown_count());
+        if shown == 0 {
+            return false;
+        }
+        let (wheel_x, wheel_y) = self.bundle_mouse.wheel.on_mouse_scroll(x, y);
+        let wheel = if wheel_y == 0 { -wheel_x } else { wheel_y };
+        if wheel != 0 {
+            let selected = bundle.data().map_or(-1, |d| d.bundle_selected.0);
+            let next = ScrollWheelHandler::next_selection(f64::from(wheel), selected, shown as i32);
+            if next != selected {
+                self.select_bundle(slot, next);
+            }
+        }
+        true
+    }
+
+    /// `BundleMouseActions.toggleSelectedBundleItem`: the stack here and, on a server, there.
+    fn select_bundle(&mut self, slot: usize, index: i32) {
+        if let Some(stack) = self.slot_mut(slot) {
+            toggle_selected(stack, index);
+        }
+        if self.remote.is_some() {
+            let (_, menu) = self.remote_menu();
+            if let Some(menu_slot) = Self::menu_slot_index(&menu, slot) {
+                self.send(S::SelectBundleItem(play::SelectBundleItem {
+                    slot: menu_slot as i32,
+                    index,
+                }));
+            }
+        }
+    }
+
+    /// `BundleMouseActions.unselectedBundleItem` for the bundle in `slot`, if it has a selection.
+    pub(super) fn unselect_bundle(&mut self, slot: usize) {
+        if !self.bundle_slot(slot) {
+            return;
+        }
+        let selected = self
+            .slot_mut(slot)
+            .as_ref()
+            .and_then(|s| s.data())
+            .is_some_and(|d| d.bundle_selected.0 >= 0);
+        if selected {
+            self.select_bundle(slot, -1);
+        }
+    }
+
+    /// `AbstractContainerScreen.onStopHovering` (and `onClose`): leaving a slot, or the
+    /// screen, clears the bundle's selection.
+    pub(super) fn tick_bundle_hover(&mut self) {
+        let now = if self.screen == Screen::Inventory {
+            self.inventory_target().0
+        } else {
+            None
+        };
+        if let Some(left) = std::mem::replace(&mut self.bundle_mouse.hovered, now)
+            && Some(left) != now
+        {
+            self.unselect_bundle(left);
+        }
+    }
+}

crates/horizon-client/src/game/client_ambient.rs

@@ -4,8 +4,12 @@
 //! on the game that has the window, in-frame or following a server, never on
 //! a server: nothing of them goes over the network.
 use super::Game;
+use horizon_client::blocks::RenderShape;
 use horizon_client::mobs::{MobEvent, ambient};
-use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_client::motion::{LAVA, WATER};
+use horizon_client::particles::{ParticleEngine, ParticleOptions, ParticleType};
+use horizon_client::pose::Pose;
+use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
     pub(super) fn tick_client_ambient(&mut self) {
@@ -33,5 +37,209 @@ impl Game<'_> {
             }
         }
         self.eye_particles();
+        self.sprint_dust();
+        self.effect_swirls();
+    }
+
+    /// `Entity.baseTick`'s `spawnSprintParticle` on a client: dust of the
+    /// block under a sprinting player's feet streams back from them every
+    /// tick, for the window's own player and for the other players it sees.
+    fn sprint_dust(&mut self) {
+        // Each runner's feet, movement and supporting block.
+        let mut runners: Vec<(Vec3, Vec3, Option<[i32; 3]>)> = Vec::new();
+        // Entity.canSpawnSprintParticle.
+        if let Some(p) = self.player.as_ref()
+            && p.sprinting
+            && !p.spectator
+            && p.pose != Pose::Crouching
+            && !p.health.dead_or_dying()
+            && !p.fluids.was_touching_water
+            && !p.is_in_lava()
+            && p.fluid_height(WATER) <= 0.0
+            && p.fluid_height(LAVA) <= 0.0
+        {
+            let support = p.ground.supporting_block.map(|b| [b.x, b.y, b.z]);
+            runners.push((p.position, p.velocity, support));
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            // Another player's fluids aren't known here: none where they stand.
+            let feet = [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ];
+            if m.extra.sprinting
+                && !m.extra.crouching
+                && m.alive()
+                && &*m.kind.id == "minecraft:player"
+                && self
+                    .res
+                    .facts()
+                    .get(self.world.block(feet[0], feet[1], feet[2]))
+                    .fluid_level
+                    == 0
+            {
+                runners.push((m.position, m.position.subtract(m.previous), None));
+            }
+        }
+        for (position, movement, support) in runners {
+            // Entity.getOnPosLegacy: getOnPos(0.2).
+            let below = (position.y - f64::from(0.2f32)).floor() as i32;
+            let tall = |game: &Self, s: [i32; 3]| {
+                let name = game.block_name(s);
+                [
+                    "minecraft:fences",
+                    "minecraft:walls",
+                    "minecraft:fence_gates",
+                ]
+                .iter()
+                .any(|tag| game.block_in_tag(tag, &name))
+            };
+            let at = match support {
+                Some(s) if tall(self, s) => s,
+                Some(s) => [s[0], below, s[2]],
+                None => [position.x.floor() as i32, below, position.z.floor() as i32],
+            };
+            let state = self.world.block(at[0], at[1], at[2]);
+            if self.res.facts().get(state).render_shape == RenderShape::Invisible {
+                continue;
+            }
+            let Some((sprite, tint)) = self.particle_sprite(state, at) else {
+                continue;
+            };
+            let width = f64::from(0.6f32);
+            let r = self.particles.random();
+            let mut x = position.x + (r.next_double() - 0.5) * width;
+            let mut z = position.z + (r.next_double() - 0.5) * width;
+            // Clamped into the block when the feet are in another column.
+            if position.x.floor() as i32 != at[0] {
+                x = x.clamp(f64::from(at[0]), f64::from(at[0]) + 1.0);
+            }
+            if position.z.floor() as i32 != at[2] {
+                z = z.clamp(f64::from(at[2]), f64::from(at[2]) + 1.0);
+            }
+            self.particles.add(
+                &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                [x, position.y + 0.1, z],
+                [movement.x * -4.0, 1.5, movement.z * -4.0],
+            );
+        }
+    }
+
+    /// `LivingEntity.tickEffects` on a client: the swirls around an entity
+    /// with visible effects, from the particles its synched data lists. The
+    /// window's player has its own effects, a server's mobs and players the
+    /// list the server sent, and the mobs and guests of a game in the frame
+    /// theirs.
+    fn effect_swirls(&mut self) {
+        if let Some(p) = self.player.as_ref() {
+            let effects = &self.potions.effects.list;
+            let list: Vec<_> = effects
+                .iter()
+                .filter(|e| e.visible)
+                .filter_map(|e| effect_particle(e.id, e.ambient))
+                .collect();
+            let ambient = effects.iter().filter(|e| e.visible).all(|e| e.ambient);
+            let invisible = effects.iter().any(|e| e.id == "invisibility");
+            let size = (
+                f64::from(p.dimensions.width),
+                f64::from(p.dimensions.height),
+            );
+            swirl(
+                &mut self.particles,
+                p.position,
+                size,
+                &list,
+                ambient,
+                invisible,
+            );
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            if !m.alive() {
+                continue;
+            }
+            let size = (f64::from(m.width()), f64::from(m.height()));
+            let invisible = m.invisible || m.has_effect("minecraft:invisibility");
+            if m.extra.effect_particles.is_empty() {
+                // A mob of this game: its own effects, visible and not ambient.
+                if m.extra.effects.is_empty() {
+                    continue;
+                }
+                let list: Vec<_> = m
+                    .extra
+                    .effects
+                    .iter()
+                    .filter(|e| !m.extra.hidden_effects.contains(&e.0))
+                    .filter_map(|e| effect_particle(e.0, false))
+                    .collect();
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    &list,
+                    false,
+                    invisible,
+                );
+            } else {
+                let list = &m.extra.effect_particles;
+                let ambient = m.extra.effect_ambient;
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    list,
+                    ambient,
+                    invisible,
+                );
+            }
+        }
     }
 }
+
+/// `MobEffect.particleFactory`: the omens have particles of their own, any
+/// other effect an entity effect in its colour, faint when ambient.
+pub(super) fn effect_particle(effect: &str, ambient: bool) -> Option<ParticleOptions> {
+    Some(match effect.trim_start_matches("minecraft:") {
+        "trial_omen" => ParticleOptions::simple(ParticleType::TrialOmen),
+        "raid_omen" => ParticleOptions::simple(ParticleType::RaidOmen),
+        other => {
+            let color = horizon_client::brewing::effect(other)?.color;
+            let channel = |shift: u32| ((color >> shift) & 255) as f32 / 255.0;
+            // MobEffect.AMBIENT_ALPHA is 38 of 255.
+            let alpha = if ambient { 38.0 / 255.0 } else { 1.0 };
+            ParticleOptions::colored(
+                ParticleType::EntityEffect,
+                [channel(16), channel(8), channel(0), alpha],
+            )
+        }
+    })
+}
+
+/// One tick of `LivingEntity.tickEffects`' client branch: a one in four
+/// chance (one in fifteen while invisible, a fifth of either when all the
+/// effects are ambient) of one of the particles at a random spot of the box.
+fn swirl(
+    particles: &mut ParticleEngine,
+    feet: Vec3,
+    size: (f64, f64),
+    list: &[ParticleOptions],
+    ambient: bool,
+    invisible: bool,
+) {
+    if list.is_empty() {
+        return;
+    }
+    let bound = if invisible { 15 } else { 4 } * if ambient { 5 } else { 1 };
+    let r = particles.random();
+    let Ok(0) = r.next_int_bound(bound) else {
+        return;
+    };
+    // Util.getRandom, then getRandomX(0.5), getRandomY and getRandomZ.
+    let pick = r.next_int_bound(list.len() as i32).unwrap_or_default() as usize;
+    let x = feet.x + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    let y = feet.y + size.1 * r.next_double();
+    let z = feet.z + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    particles.add(&list[pick], [x, y, z], [1.0; 3]);
+}

crates/horizon-client/src/game/combat.rs

@@ -10,6 +10,9 @@ struct Entry {
     fall_distance: f32,
     /// The causing entity: its id (for comparisons) and display name.
     attacker: Option<(u32, Text)>,
+    /// The direct entity's display name when no entity caused the damage
+    /// (`DamageSource.directEntity`: a potion with no thrower, a cloud).
+    direct: Option<Text>,
 }
 #[derive(Default)]
 pub(super) struct CombatTracker {
@@ -19,6 +22,8 @@ pub(super) struct CombatTracker {
     /// Attackers of damage dealt this tick, claimed by the matching
     /// `RecordedDamage` event.
     pending: Vec<(String, (u32, Text))>,
+    /// `pending` for a direct entity with no causing entity: only its name.
+    pending_direct: Vec<(String, Text)>,
     /// `LivingEntity.lastHurtByMob` and its timestamp (the kill credit).
     last_hurt_by: Option<((u32, Text), i64)>,
     /// The mob the player last hurt (`getLastHurtMob`) and when.
@@ -66,6 +71,14 @@ impl Game<'_> {
             .pending
             .push((damage_type.to_owned(), (id, name)));
     }
+    /// The `DamageSource.directEntity` of the next `damage_type` damage when
+    /// nothing caused it (a splash potion nobody threw): the death message
+    /// names it instead (`getLocalizedDeathMessage`). It is no kill credit.
+    pub(super) fn note_direct_entity(&mut self, damage_type: &str, name: Text) {
+        self.combat
+            .pending_direct
+            .push((damage_type.to_owned(), name));
+    }
     /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the
     /// source's `DamageEffects` (`Player.getHurtSound`).
     pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) {
@@ -94,6 +107,15 @@ impl Game<'_> {
                 .iter()
                 .position(|(t, _)| *t == name)
                 .map(|i| self.combat.pending.remove(i).1);
+            let direct = match attacker {
+                Some(_) => None,
+                None => self
+                    .combat
+                    .pending_direct
+                    .iter()
+                    .position(|(t, _)| *t == name)
+                    .map(|i| self.combat.pending_direct.remove(i).1),
+            };
             let (fall_location, fall_distance) = self.fall_location();
             let now = self.world.game_time;
             if let Some(a) = &attacker {
@@ -111,10 +133,12 @@ impl Game<'_> {
                 fall_location,
                 fall_distance,
                 attacker,
+                direct,
             });
             self.combat.last_damage = now;
         }
         self.combat.pending.clear();
+        self.combat.pending_direct.clear();
         self.combat.fall_before = self.player.as_ref().map_or(0.0, |p| p.fall_distance);
     }
     /// `FallLocation.getCurrentFallLocation` and the fall distance so far.
@@ -224,6 +248,7 @@ impl Game<'_> {
         let entries = std::mem::take(&mut self.combat.entries);
         let killing = entries.last().expect("checked above");
         let killer = killing.attacker.clone();
+        let direct = killing.direct.clone();
         if def.1 == "fall_variants"
             && let Some(knock) = knock.and_then(|i| entries.get(i))
         {
@@ -248,15 +273,22 @@ impl Game<'_> {
                 .append(Text::literal("]"));
             return Text::translate(&format!("{key}.message"), &[me, link]);
         }
+        // `getLocalizedDeathMessage`: the causing entity's name, or the
+        // direct entity's when nothing caused the damage.
         if let Some((_, name)) = killer {
             return Text::translate(&key, &[me, name]);
         }
+        if let Some(name) = direct {
+            return Text::translate(&key, &[me, name]);
+        }
         // getKillCredit: the last mob that hurt the player in the past 100 ticks.
         if let Some(((_, name), at)) = &self.combat.last_hurt_by
             && self.world.game_time - at <= 100
         {
             return Text::translate(&format!("{key}.player"), &[me, name.clone()]);
         }
+        // No entity at all: the one-argument message, as vanilla sends it (a
+        // template that names a killer then shows as written).
         Text::translate(&key, &[me])
     }
 }

crates/horizon-client/src/game/commands.rs

@@ -541,8 +541,7 @@ impl Game<'_> {
                     .enumerate()
                     // The kinds /data can write (entity_nbt).
                     .filter(|(_, p)| {
-                        p.arrow.is_some()
-                            || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
+                        p.is_arrow() || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
                     })
                     .map(|(i, _)| Target::Projectile(i)),
             );

crates/horizon-client/src/game/commands/effects.rs

@@ -91,7 +91,12 @@ impl Game<'_> {
                 }
                 Target::Mob(id) => match self.mobs.iter_mut().find(|m| m.id == id) {
                     Some(m) => {
-                        m.add_effect(namespaced(effect.id), duration, amplifier);
+                        let name = namespaced(effect.id);
+                        m.add_effect(name, duration, amplifier);
+                        m.extra.hidden_effects.retain(|h| *h != name);
+                        if !particles {
+                            m.extra.hidden_effects.push(name);
+                        }
                         true
                     }
                     None => false,
@@ -154,6 +159,10 @@ impl Game<'_> {
                         m.extra
                             .effects
                             .retain(|x| e.is_some_and(|e| x.0 != namespaced(e.id)));
+                        let left = &m.extra.effects;
+                        m.extra
+                            .hidden_effects
+                            .retain(|h| left.iter().any(|x| x.0 == *h));
                         m.extra.effects.len() != before
                     }
                     None => false,

crates/horizon-client/src/game/commands/execute.rs

@@ -145,9 +145,42 @@ impl Game<'_> {
                 .iter()
                 .find(|m| m.id == id)
                 .map_or(0.0, |m| m.eye_y() - m.position.y),
-            _ => 0.0,
+            // ArmorStand.getDefaultDimensions: a marker's are empty, a small
+            // stand's are BABY_DIMENSIONS, whose eye height is 0.9875F.
+            Target::Stand(id) => match self.armor_stands.iter().find(|a| a.id == id) {
+                Some(a) if a.marker => 0.0,
+                Some(a) if a.small => f64::from(0.9875f32),
+                _ => self.type_eye_height(&self.target_type(t)),
+            },
+            // Entity.getEyeHeight: the type's dimensions.
+            _ => self.type_eye_height(&self.target_type(t)),
         }
     }
+    /// `EntityType.getDimensions().eyeHeight()` from `entity-types.json`,
+    /// read once: a float, widened as `Entity.getEyeY` does.
+    fn type_eye_height(&self, ty: &str) -> f64 {
+        static EYE_HEIGHTS: std::sync::OnceLock<std::collections::HashMap<String, f64>> =
+            std::sync::OnceLock::new();
+        EYE_HEIGHTS
+            .get_or_init(|| {
+                std::fs::read(self.options.resources.join("entity-types.json"))
+                    .ok()
+                    .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
+                    .and_then(|v| {
+                        v.as_object().map(|o| {
+                            o.iter()
+                                .filter_map(|(k, t)| {
+                                    Some((k.clone(), f64::from(t["eye_height"].as_f64()? as f32)))
+                                })
+                                .collect()
+                        })
+                    })
+                    .unwrap_or_default()
+            })
+            .get(ty)
+            .copied()
+            .unwrap_or(0.0)
+    }
     /// EntityAnchorArgument.Anchor.apply.
     pub(super) fn anchor_position(&self, s: &Source) -> [f64; 3] {
         match s.entity {
@@ -467,9 +500,10 @@ impl Game<'_> {
             "positioned" if c.has("as") => targets(self)?
                 .into_iter()
                 .filter_map(|t| {
+                    // withPosition keeps the anchor (only `positioned <pos>`
+                    // resets it to the feet).
                     Some(Source {
                         pos: self.target_position(t)?,
-                        eyes: false,
                         ..s
                     })
                 })
@@ -606,6 +640,72 @@ impl Game<'_> {
                     .collect(),
                 _ => Vec::new(),
             },
+            // Leashable.getLeashHolder: a fence knot is not an entity here.
+            Some("leasher") => match entity {
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id)
+                    .and_then(|m| m.extra.leash.map(|holder| (holder, m.extra.leash_player)))
+                    .and_then(|(holder, player)| match holder {
+                        // The player who tied it (the host's when unrecorded).
+                        horizon_client::mobs::leash::Holder::Player => {
+                            let uuid = player.or(self.level.player_uuid)?;
+                            self.target_by_uuid(horizon_client::lan::playerdata::ints_uuid(uuid))
+                        }
+                        horizon_client::mobs::leash::Holder::Mob(i) => Some(Target::Mob(i)),
+                        horizon_client::mobs::leash::Holder::Knot(_) => None,
+                    })
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
+            // TraceableEntity.getOwner: who shot a projectile, who threw an
+            // item, who summoned a vex.
+            Some("origin") => match entity {
+                Target::Projectile(i) => self
+                    .creatures
+                    .projectiles
+                    .get(i)
+                    .and_then(|p| match (p.owner?, p.guest) {
+                        // A guest's shot: `Who::Player` is them.
+                        (horizon_client::mobs::Who::Player, Some(conn))
+                            if self.lan_acting == Some(conn) =>
+                        {
+                            Some(Target::Player)
+                        }
+                        (horizon_client::mobs::Who::Player, Some(conn)) => {
+                            Some(Target::Guest(conn))
+                        }
+                        (horizon_client::mobs::Who::Player, None) => Some(Target::Player),
+                        (horizon_client::mobs::Who::Mob(id), _) => Some(Target::Mob(id)),
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Item(id) => self
+                    .dropped
+                    .iter()
+                    .find(|d| d.id == id)
+                    .and_then(|d| d.thrower)
+                    .and_then(|words| {
+                        let uuid = words
+                            .iter()
+                            .fold(0u128, |all, w| all << 32 | u128::from(*w as u32));
+                        self.target_by_uuid(uuid)
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id && m.kind.id == "minecraft:vex")
+                    .map(|m| m.extra.counter2 as u32)
+                    .filter(|owner| *owner != 0)
+                    .map(Target::Mob)
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
             Some("vehicle") => self.ride_vehicle(entity).into_iter().collect(),
             Some("controller") | Some("passengers") => match entity {
                 Target::Mob(id) if self.mobs.iter().any(|m| m.id == id && m.rider.is_some()) => {
@@ -807,10 +907,12 @@ impl Game<'_> {
                 .coords(c, "pos")
                 .map(|co| co.block(self.source_position(), self.source_rotation()));
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);
-            return Ok(flag(
-                dimension == self.dim
-                    && p.is_some_and(|p| self.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4))),
-            ));
+            // ExecuteCommand.isChunkLoaded: ENTITY_TICKING, which is past lit.
+            let loaded = |p: [i32; 3]| {
+                let key = (p[0] >> 4, p[2] >> 4);
+                self.world.chunks.contains_key(&key) && self.streaming.is_lit(key.0, key.1)
+            };
+            return Ok(flag(dimension == self.dim && p.is_some_and(loaded)));
         }
         if c.has("dimension") {
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);

crates/horizon-client/src/game/commands/pregen.rs

@@ -244,7 +244,11 @@ impl Game<'_> {
     /// hand them the next jobs as soon as each one is done, rather than once
     /// a tick.
     pub(in crate::game) fn pump_pregen(&mut self, until: Instant) {
-        while self.pregen_runs_here() {
+        // Force-loaded chunks too: decorating in vanilla's order, a chunk
+        // waits for its neighbours far more often than once a tick allows.
+        while self.pregen_runs_here()
+            || (!self.streaming.forced.is_empty() && self.streaming.busy())
+        {
             let now = Instant::now();
             if now >= until {
                 break;

crates/horizon-client/src/game/commands/terrain_cmds.rs

@@ -120,6 +120,9 @@ impl Game<'_> {
                         tracker.track(&holder(chunk_text(x, z)), i32::from(changed));
                     }
                 }
+                if add {
+                    self.streaming.rank_forced(cx0, cz0, cx1, cz1);
+                }
                 let (lo, hi) = (chunk_text(cx0, cz0), chunk_text(cx1, cz1));
                 let verb = if add { "added" } else { "removed" };
                 let (message, total) = tracker.message(

crates/horizon-client/src/game/commands/text_commands.rs

@@ -14,10 +14,11 @@ impl Game<'_> {
             serde_json::from_str(json).map_err(|e| err("argument.component.invalid", &[&e]))?;
         // NbtContents.resolve: the path's values in the entity, block or
         // storage data, rich-styled (or plain, or interpreted), ", "-joined.
+        // ScoreContents.resolve: the holder's score in the objective.
         let nbt_values = std::cell::RefCell::new(Vec::new());
         {
             let mut collect = |o: &serde_json::Map<String, serde_json::Value>| {
-                if o.contains_key("nbt") {
+                if o.contains_key("nbt") || o.contains_key("score") {
                     nbt_values.borrow_mut().push(o.clone());
                 }
             };
@@ -40,7 +41,11 @@ impl Game<'_> {
         }
         let mut resolved: Vec<(serde_json::Map<String, serde_json::Value>, Text)> = Vec::new();
         for o in nbt_values.into_inner() {
-            let t = self.resolve_nbt_component(&o);
+            let t = if o.contains_key("score") {
+                self.resolve_score_component(&o)?
+            } else {
+                self.resolve_nbt_component(&o)
+            };
             resolved.push((o, t));
         }
         let mut resolve = |raw: &str| -> Text {
@@ -73,6 +78,54 @@ impl Game<'_> {
             },
         ))
     }
+    /// The text of a `score` component (ScoreContents.resolve): the named
+    /// holder's score, `*` being the player the command runs for.
+    fn resolve_score_component(
+        &mut self,
+        o: &serde_json::Map<String, serde_json::Value>,
+    ) -> R<Text> {
+        let score = o.get("score");
+        let field = |k: &str| score.and_then(|s| s.get(k)).and_then(|v| v.as_str());
+        let (name, objective) = (
+            field("name").unwrap_or(""),
+            field("objective").unwrap_or(""),
+        );
+        // findTargetName: a selector that matches one entity is that entity,
+        // one that matches none is just the name.
+        let mut reader = horizon_client::command::Reader::new(name);
+        let ty = horizon_client::command::args::ArgType::Entity {
+            single: false,
+            players: false,
+        };
+        let mut holder = name.to_owned();
+        if let Ok(Arg::Entity(sel)) = ty.parse(&mut reader, &self.ui.registries)
+            && !reader.can_read()
+        {
+            let found = self.select(&sel);
+            if found.len() > 1 {
+                return Err(err("argument.entity.toomany", &[]));
+            }
+            if let Some(t) = found.first().and_then(|t| self.holder_name(*t)) {
+                holder = t;
+            }
+        }
+        if holder == "*" {
+            holder = self.acting_player_name().to_owned();
+        }
+        let board = &self.score.board;
+        let (Some(objective), Some(score)) =
+            (board.objective(objective), board.score(&holder, objective))
+        else {
+            return Ok(Text::empty());
+        };
+        // numberFormatOrDefault(StyledFormat.NO_STYLE).
+        let format = (score.number_format.clone())
+            .or_else(|| objective.number_format.clone())
+            .unwrap_or(horizon_client::scoreboard::NumberFormat::Styled(
+                serde_json::json!({}),
+            ));
+        Ok(format.format(score.value))
+    }
     /// The text of an `nbt` component.
     fn resolve_nbt_component(&mut self, o: &serde_json::Map<String, serde_json::Value>) -> Text {
         use horizon_world::nbt::Tag;
@@ -136,28 +189,40 @@ impl Game<'_> {
         }
         out
     }
-    fn player_targets(&mut self, ctx: &Context) -> R<usize> {
-        // Only the local player can receive messages and titles.
+    /// The players the command reaches: the window's own and the LAN guests.
+    fn player_targets(&mut self, ctx: &Context) -> R<Vec<Target>> {
         let targets = self.entities(ctx, "targets", true)?;
-        Ok(targets.iter().filter(|t| **t == Target::Player).count())
+        Ok(targets
+            .into_iter()
+            .filter(|t| matches!(t, Target::Player | Target::Guest(_)))
+            .collect())
     }
     pub(super) fn cmd_tellraw(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
+        let players = self.player_targets(ctx)?;
         let message = self.component_arg(ctx, "message")?;
-        if n > 0 {
-            self.system_message(message);
+        // Each player's chat (a guest's through the connection).
+        for &t in &players {
+            self.for_player(t, |g| g.system_message(message.clone()));
         }
-        Ok(n as i32)
+        Ok(players.len() as i32)
     }
     pub(super) fn cmd_title(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
-        let name = self.target_name(Target::Player);
+        let players = self.player_targets(ctx)?;
+        let n = players.len();
+        let name = players
+            .first()
+            .map_or_else(Text::empty, |t| self.target_name(*t));
         let single = n == 1;
         let key = if ctx.has("clear") {
-            self.titles_or_packet(Titles::clear, C::ClearTitles(play::Bool1 { value: false }));
+            self.titles_or_packet(
+                &players,
+                Titles::clear,
+                C::ClearTitles(play::Bool1 { value: false }),
+            );
             "cleared"
         } else if ctx.has("reset") {
             self.titles_or_packet(
+                &players,
                 |t| {
                     t.clear();
                     t.reset_times();
@@ -172,6 +237,7 @@ impl Game<'_> {
             };
             let (fade_in, stay, fade_out) = (get("fadeIn"), get("stay"), get("fadeOut"));
             self.titles_or_packet(
+                &players,
                 |t| t.set_times(fade_in, stay, fade_out),
                 C::SetTitlesAnimation(play::TitlesAnimation {
                     fade_in,
@@ -186,13 +252,17 @@ impl Game<'_> {
                 text: component_nbt(&text.component()),
             };
             if ctx.has("subtitle") {
-                self.titles_or_packet(|t| t.set_subtitle(text), C::SetSubtitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_subtitle(text), C::SetSubtitleText(sent));
                 "show.subtitle"
             } else if ctx.has("actionbar") {
-                self.titles_or_packet(|t| t.set_overlay(text, false), C::SetActionBarText(sent));
+                self.titles_or_packet(
+                    &players,
+                    |t| t.set_overlay(text, false),
+                    C::SetActionBarText(sent),
+                );
                 "show.actionbar"
             } else {
-                self.titles_or_packet(|t| t.set_title(text), C::SetTitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_title(text), C::SetTitleText(sent));
                 "show.title"
             }
         };
@@ -207,13 +277,27 @@ impl Game<'_> {
         self.feedback(message);
         Ok(n as i32)
     }
-    /// The player the title is for: the guest acting now is sent the packet
-    /// (TitleCommand's `connection.send`), the window's own player shows it.
-    fn titles_or_packet(&mut self, local: impl FnOnce(&mut Titles), packet: C) {
-        if self.lan_acting.is_some() {
-            self.guest_packets.push(packet);
-        } else {
-            local(&mut self.titles);
+    /// TitleCommand's `connection.send` for each player: a guest is sent the
+    /// packet, the window's own player shows it.
+    fn titles_or_packet(&mut self, players: &[Target], local: impl FnOnce(&mut Titles), packet: C) {
+        let mut local = Some(local);
+        for &t in players {
+            match t {
+                Target::Player if self.lan_acting.is_some() => {
+                    self.guest_packets.push(packet.clone());
+                }
+                Target::Player => {
+                    if let Some(local) = local.take() {
+                        local(&mut self.titles);
+                    }
+                }
+                Target::Guest(conn) => {
+                    if let Some(host) = self.lan.as_ref() {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                _ => {}
+            }
         }
     }
 }

crates/horizon-client/src/game/commands/world_cmds.rs

@@ -115,6 +115,7 @@ impl Game<'_> {
             "in_fire" | "campfire" | "hot_floor" => DamageKind::InFire,
             "lava" => DamageKind::Lava,
             "drown" => DamageKind::Drown,
+            "dry_out" => DamageKind::DryOut,
             "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic,
             "sting" => DamageKind::Sting,
             "cactus" | "sweet_berry_bush" => DamageKind::Cactus,
@@ -140,27 +141,37 @@ impl Game<'_> {
             Some(Arg::Entity(_)) => self.entities(ctx, "entity", false)?.first().copied(),
             _ => None,
         };
+        let cause = match ctx.get("cause") {
+            Some(Arg::Entity(_)) => self.entities(ctx, "cause", false)?.first().copied(),
+            _ => None,
+        };
         let from = match ctx.get("location") {
             Some(Arg::Coords(_)) => self.position_arg(ctx, "location"),
             _ => by.and_then(|t| self.target_position(t)),
         };
         let hurt = match target {
+            // The causing mob is the one the hit is credited to and thorns
+            // answer; the source position gives the knockback its direction.
             Target::Player => {
-                if self.creative || self.spectator() {
+                // `DamageSource(type, cause, by)`: the death message names the
+                // causing entity, else the direct one. A mob is noted by
+                // `hurt_player_from`, a player here.
+                if let Some(t @ (Target::Player | Target::Guest(_))) = cause.or(by) {
+                    let name = self.target_name(t);
+                    self.note_direct_entity(&ty, name);
+                }
+                if self.spectator() {
                     false
-                } else if let Some(player) = self.player.as_mut() {
-                    match self.motion.health.damage.id(&ty) {
-                        Some(id) => player
-                            .hurt(&self.motion.health, self.world.health_rules, id, amount)
-                            .unwrap_or(false),
-                        None => false,
-                    }
                 } else {
-                    false
+                    let attacker = match cause.or(by) {
+                        Some(Target::Mob(i)) => Some(Some(i)),
+                        _ => Some(None),
+                    };
+                    self.hurt_player_from(amount, from, &ty, attacker)
                 }
             }
             Target::Mob(id) => {
-                let attacker = by.and_then(|t| match t {
+                let attacker = cause.or(by).and_then(|t| match t {
                     Target::Player => Some(Who::Player),
                     Target::Mob(i) => Some(Who::Mob(i)),
                     _ => None,
@@ -301,9 +312,18 @@ impl Game<'_> {
             float("minVolume", 0.0),
         );
         let range = if volume > 1.0 { 16.0 * volume } else { 16.0 };
+        // PlaySoundCommand: one seed for every player.
+        let seed = self.world.random.next_long();
+        let here = self.dim.id();
         let mut tracker = Tracker::default();
         for t in targets {
-            if t != Target::Player {
+            if !matches!(t, Target::Player | Target::Guest(_)) {
+                continue;
+            }
+            // Only players in the source's level hear it.
+            if let Target::Guest(conn) = t
+                && self.command_guest(conn).is_none_or(|g| g.dimension != here)
+            {
                 continue;
             }
             let Some(p) = self.target_position(t) else {
@@ -327,8 +347,26 @@ impl Game<'_> {
             } else {
                 (pos, volume)
             };
-            self.audio.play_on(source, &sound, Some(at), v, pitch);
-            tracker.mark(&holder(Text::literal(self.acting_player_name())));
+            // The connection is sent the sound; the window's own player
+            // plays it.
+            let guest = match t {
+                Target::Guest(conn) => Some(conn),
+                _ => self.lan_acting,
+            };
+            match guest.and_then(|conn| Some((conn, self.lan.as_ref()?))) {
+                Some((conn, host)) => {
+                    let packet = host
+                        .hub
+                        .sound_packet(&sound, at, v, pitch, source as i32, seed);
+                    if t == Target::Player {
+                        self.guest_packets.push(packet);
+                    } else {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                None => self.audio.play_on(source, &sound, Some(at), v, pitch),
+            }
+            tracker.mark(&holder(self.target_name(t)));
         }
         let name = Text::literal(sound.clone());
         let (message, total) = tracker.message(
@@ -605,8 +643,10 @@ impl Game<'_> {
         let reached = reached.len() as i32;
         if !local {
         } else if count <= 0 {
-            // No count: one particle with the delta as velocity.
-            self.particles.create(&options, pos, delta);
+            // handleParticleEvent, count 0: one particle, the speed times
+            // the delta as velocity (both sent as floats, multiplied as floats).
+            self.particles
+                .create(&options, pos, delta.map(|d| f64::from(speed * d as f32)));
         } else {
             for _ in 0..count {
                 let r = self.particles.random();

crates/horizon-client/src/game/consume.rs

@@ -19,7 +19,17 @@ use std::convert::Infallible;
 
 type ItemConsumable = Consumable<String, ConsumeEffect>;
 
+/// `EntityEvent.USE_ITEM_COMPLETE`: the server finished the player's use.
+pub(super) const USE_ITEM_COMPLETE_EVENT: i8 = 9;
+
 impl Game<'_> {
+    /// `ServerPlayer.completeUsingItem`: the player's own client is told
+    /// first, and completes the use itself (eating the food there too).
+    pub(super) fn send_use_item_complete(&mut self) {
+        if self.lan_acting.is_some() {
+            self.guest_entity_events.push(USE_ITEM_COMPLETE_EVENT);
+        }
+    }
     /// `Consumable.emitParticlesAndSounds(user.getRandom(), user, stack, count)`.
     pub(super) fn emit_consume(
         &mut self,

crates/horizon-client/src/game/control.rs

@@ -628,6 +628,9 @@ impl Game<'_> {
                     // The port, or the game rules' search and number boxes.
                     Screen::WorldOptions if text == "\\b" => self.world_options_text(None),
                     Screen::WorldOptions => self.world_options_text(Some(text)),
+                    Screen::Inventory if self.mod_browser_typing() => {
+                        self.mod_browser_text((text != "\\b").then_some(text), text == "\\b")
+                    }
                     Screen::Inventory if self.recipe_search_focused() => {
                         self.recipe_text(Some(text), false)
                     }
@@ -875,6 +878,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
@@ -1080,6 +1086,9 @@ impl Game<'_> {
             "flashes": self.lightning_seen[1], "flash": self.flash});
         // Primed TNT, falling blocks, projectiles, tridents and end crystals.
         status["projectiles"] = json!(self.projectiles_status());
+        let mut fangs_vertices = Vec::new();
+        self.fangs_geometry(glam::DVec3::ZERO, 0.5, &mut fangs_vertices);
+        status["fangs_vertices"] = json!(fangs_vertices.len());
         status["maps"] = json!(self.maps_status());
         // The particles made so far, by type.
         status["particles"] = json!(self.particles.made());

crates/horizon-client/src/game/creaking.rs

@@ -218,8 +218,9 @@ impl Game<'_> {
         );
     }
     /// `CreakingHeartBlock.playerWillDestroy`: the heart's creaking twitches to
-    /// death and a natural heart drops experience.
-    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3]) {
+    /// death and a natural heart drops experience. `onExplosionHit` does the
+    /// same for the creaking (`by_player` false), without the experience.
+    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3], by_player: bool) {
         let key = (pos[0], pos[1], pos[2]);
         if !matches!(
             self.world.block_entities.get(&key),
@@ -242,7 +243,7 @@ impl Game<'_> {
             .state(state)
             .and_then(|s| s.properties.get("natural").cloned())
             .is_some_and(|v| v == "true");
-        if natural && !self.creative && !self.spectator() {
+        if by_player && natural && !self.creative && !self.spectator() {
             let xp = 20 + self.world.random.next_int_bound(5).unwrap_or(0) as u32;
             self.spawn_orbs(
                 [

crates/horizon-client/src/game/creatures.rs

@@ -18,6 +18,7 @@ use horizon_client::{
         spawning::{self, BiomeFacts},
     },
     projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld},
+    text::Text,
 };
 use horizon_core::{
     geometry::{Aabb, Vec3, traverse_blocks},
@@ -430,6 +431,12 @@ impl Game<'_> {
             ),
         }
     }
+    /// What the generator finalizes this level's structure mobs with.
+    pub(super) fn share_spawn_conditions(&self) {
+        if let Some(terrain) = self.end.locator() {
+            terrain.set_spawn_conditions(self.difficulty_id() as u8, self.world.day_time);
+        }
+    }
     /// `ServerLevel.getCurrentDifficultyAt`.
     pub(super) fn local_difficulty(&self, at: [f64; 3]) -> spawning::LocalDifficulty {
         use horizon_world::food::Difficulty;
@@ -526,6 +533,8 @@ impl Game<'_> {
             _ => Vec::new(),
         };
         let mut guest_events = Vec::new();
+        // The mobs whose bodies go this tick: (id, feet, width, height).
+        let mut gone = Vec::new();
         let level_random;
         {
             // The level random, lent to the mobs (brain behaviours draw from
@@ -598,6 +607,11 @@ impl Game<'_> {
                 let from = events.len();
                 let kept = m.tick(&w, &mut scratch, &mut events);
                 horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes);
+                // LivingEntity.tickDeath: after twenty ticks the body is removed.
+                if !kept && !m.removed && !m.alive() && m.death_time >= 20 {
+                    let (width, height) = (f64::from(m.width()), f64::from(m.height()));
+                    gone.push((m.id, m.position, width, height));
+                }
                 if let Some(conn) = seen_guest {
                     // ShulkerBullet.finalTarget is the guest's entity: the
                     // bullet homes on it while the projectiles tick, where
@@ -656,6 +670,12 @@ impl Game<'_> {
         }
         self.mobs.append(&mut mobs);
         self.died = died;
+        // ... and entity event 60 goes out as it is: the poof.
+        for (id, at, width, height) in gone {
+            let at = [at.x, at.y, at.z];
+            self.lan_entity_event(id as i32, 60, at);
+            self.death_poof(at, width, height);
+        }
         self.sync_riders();
         self.tick_skeleton_traps();
         self.tick_apparition();
@@ -682,6 +702,22 @@ impl Game<'_> {
         self.handle_mob_events(queued)?;
         Ok(())
     }
+    /// `LivingEntity.makePoofParticles` (entity event 60) about a mob's box.
+    pub(super) fn death_poof(&mut self, at: [f64; 3], width: f64, height: f64) {
+        let options = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::Poof,
+        );
+        for _ in 0..20 {
+            let r = self.particles.level_random();
+            let xa = r.next_gaussian() * 0.02;
+            let ya = r.next_gaussian() * 0.02;
+            let za = r.next_gaussian() * 0.02;
+            let x = at[0] + width * (2.0 * r.next_double() - 1.0) - xa * 10.0;
+            let y = at[1] + height * r.next_double() - ya * 10.0;
+            let z = at[2] + width * (2.0 * r.next_double() - 1.0) - za * 10.0;
+            self.particles.add(&options, [x, y, z], [xa, ya, za]);
+        }
+    }
     /// LivingEntity.die / dropAllDeathLoot.
     fn mob_died(&mut self, m: &Mob) {
         let killer = self.last_hurt_by_player.remove(&m.id);
@@ -944,6 +980,21 @@ impl Game<'_> {
                         }
                     }
                 }
+                MobEvent::Shift { target, delta } => {
+                    let d = Vec3::new(delta[0], delta[1], delta[2]);
+                    match target {
+                        Who::Player => {
+                            if let Some(p) = self.player.as_mut() {
+                                p.position = p.position.add_vector(d);
+                            }
+                        }
+                        Who::Mob(id) => {
+                            if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
+                                m.position = m.position.add_vector(d);
+                            }
+                        }
+                    }
+                }
                 MobEvent::Wololo { mob } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) {
                         // DyeColor.RED.
@@ -1078,6 +1129,11 @@ impl Game<'_> {
                     self.next_entity += 1;
                     p.id = self.next_entity;
                     let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]);
+                    // LlamaSpit.recreateFromPacket: the spit's burst on the client.
+                    if p.kind == ProjectileKind::LlamaSpit {
+                        let v = p.velocity;
+                        self.particles.llama_spit_burst(at, [v.x, v.y, v.z]);
+                    }
                     self.creatures.projectiles.push(p);
                     self.projectile_event("minecraft:projectile_shoot", owner, at);
                 }
@@ -1640,11 +1696,34 @@ impl Game<'_> {
     pub(super) fn mob_hits_player_kind(&mut self, amount: f32, from: [f64; 3], kind: &str) {
         self.mob_hits_player(amount, from, kind);
     }
+    /// Damage whose causing mob is known (`cause`, or none): not guessed
+    /// from the mob nearest to `from`.
+    pub(super) fn mob_hits_player_caused(
+        &mut self,
+        amount: f32,
+        from: [f64; 3],
+        kind: &str,
+        cause: Option<u32>,
+    ) {
+        self.hurt_player_from(amount, Some(from), kind, Some(cause));
+    }
     pub(super) fn mob_hits_player(
         &mut self,
         amount: f32,
         from: [f64; 3],
         damage_type: &str,
+    ) -> bool {
+        self.hurt_player_from(amount, Some(from), damage_type, None)
+    }
+    /// `hurtServer` on the player. `from` is the source's position (none: no
+    /// direction), `known`: the causing mob when it is given (`/damage`),
+    /// else the melee attacker is the mob nearest to `from`.
+    pub(super) fn hurt_player_from(
+        &mut self,
+        amount: f32,
+        from: Option<[f64; 3]>,
+        damage_type: &str,
+        known: Option<Option<u32>>,
     ) -> bool {
         // ServerPlayer.canHarmPlayer refused another player's projectile.
         if self.creative || self.combat.refuse_player_hit {
@@ -1657,23 +1736,26 @@ impl Game<'_> {
             .damage_tags
             .get("minecraft:is_projectile")
             .is_some_and(|t| t.contains(damage_type));
-        let blocking = self.player_blocking(Some(from), damage_type, false);
+        let blocking = self.player_blocking(from, damage_type, false);
         let raised = blocking.is_some();
         // Melee: the attacker stands at `from` (another player's hit has no mob behind it).
-        let attacker = (!projectile && damage_type != "minecraft:player_attack")
-            .then(|| {
-                self.mobs
-                    .iter()
-                    .filter(|m| m.alive())
-                    .min_by(|a, b| {
-                        let d = |m: &horizon_client::mobs::Mob| {
-                            (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
-                        };
-                        d(a).total_cmp(&d(b))
-                    })
-                    .map(|m| m.id)
-            })
-            .flatten();
+        let attacker = match known {
+            Some(known) => known,
+            None => from
+                .filter(|_| !projectile && damage_type != "minecraft:player_attack")
+                .and_then(|from| {
+                    self.mobs
+                        .iter()
+                        .filter(|m| m.alive())
+                        .min_by(|a, b| {
+                            let d = |m: &horizon_client::mobs::Mob| {
+                                (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
+                            };
+                            d(a).total_cmp(&d(b))
+                        })
+                        .map(|m| m.id)
+                }),
+        };
         // The causing entity for the death message.
         let owner = self.combat.projectile_owner.take();
         if let Some(a) = attacker.or(owner) {
@@ -1701,7 +1783,10 @@ impl Game<'_> {
             // LivingEntity.hurtServer's dealDefaultKnockback: not inside the
             // hurt cooldown (a stronger hit there only adds its difference).
             if o.knockback {
-                let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
+                // No source position: a random direction.
+                let (xd, zd) = from.map_or((0.0, 0.0), |from| {
+                    (from[0] - player.position.x, from[2] - player.position.z)
+                });
                 self.knock_back_player(f64::from(0.4_f32), xd, zd);
                 if let Some(p) = self.player.as_mut()
                     && let Some(r) = p.hurt_log.last_mut()
@@ -2039,6 +2124,33 @@ impl Game<'_> {
             None => self.projectile_hit(p, hit),
         }
     }
+    /// What an arrow or a thrown trident hits an entity of type `victim`
+    /// for (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a
+    /// trident's 8 through `EnchantmentHelper.modifyDamage` of the trident
+    /// (Impaling's `minecraft:damage` on `#sensitive_to_impaling`).
+    fn shot_damage(&mut self, shot: &mut Projectile, victim: Option<&str>) -> f32 {
+        if !matches!(shot.kind, ProjectileKind::Trident) {
+            return arrow_damage(shot, &mut self.world.random) + shot.bonus.damage;
+        }
+        let Some(trident) = shot.arrow.as_ref().map(|a| a.pickup_item.clone()) else {
+            return 8.0;
+        };
+        let ctx = horizon_client::enchant::EffectContext {
+            this: victim,
+            attacker: (shot.owner == Some(Who::Player)).then_some("minecraft:player"),
+            direct_attacker: Some("minecraft:trident"),
+            damage_type: Some("minecraft:trident"),
+            items: Some(self.res.items()),
+            ..Default::default()
+        };
+        self.res.stations().enchantments.modify_value(
+            Some(&trident),
+            "minecraft:damage",
+            &ctx,
+            &mut self.world.random,
+            8.0,
+        )
+    }
     /// What an arrow's tick asked for: its particles and sounds.
     fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) {
         use horizon_client::arrows::{ArrowEvent, ArrowParticle, ArrowSound, BlockReaction};
@@ -2067,6 +2179,8 @@ impl Game<'_> {
                     ArrowSound::Splash => "minecraft:entity.generic.splash",
                     ArrowSound::HitGround => "minecraft:entity.arrow.hit",
                     ArrowSound::Extinguish => "minecraft:entity.generic.extinguish_fire",
+                    ArrowSound::TridentHitGround => "minecraft:item.trident.hit_ground",
+                    ArrowSound::TridentHit => "minecraft:item.trident.hit",
                 };
                 self.audio
                     .play(name, Some([at.x, at.y, at.z]), volume, pitch);
@@ -2216,11 +2330,11 @@ impl Game<'_> {
             && id >= super::dragon::SPECIAL
         {
             let by_player = p.owner == Some(Who::Player);
-            if let ProjectileKind::Arrow { .. } = p.kind {
+            if p.arrow.is_some() {
                 // AbstractArrow.onHitEntity: spent if the part or crystal took
                 // it, else turned back (a perched dragon sets it alight first).
                 let mut arrow = p.clone();
-                let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+                let amount = self.shot_damage(&mut arrow, None);
                 let outcome = match self.hit_special(id, amount, by_player, true) {
                     super::dragon::Hurt::Landed { .. } => EntityHit::Hurt,
                     super::dragon::Hurt::Refused => EntityHit::Refused,
@@ -2241,17 +2355,15 @@ impl Game<'_> {
             self.hit_special(id, amount, by_player, false);
             return Ok(());
         }
-        if let (
-            ProjectileKind::Arrow { .. },
-            Hit::Entity {
+        if p.arrow.is_some()
+            && let Hit::Entity {
                 who: Who::Mob(id), ..
-            },
-        ) = (&p.kind, hit)
+            } = hit
             && let Some(i) = self.carts.iter().position(|c| c.id == id)
         {
             // AbstractArrow.onHitEntity on a minecart.
             let mut arrow = p.clone();
-            let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+            let amount = self.shot_damage(&mut arrow, None);
             let burning = p.arrow.as_ref().is_some_and(|a| a.on_fire());
             let creative = p.owner == Some(Who::Player) && self.creative;
             self.arrow_hits_cart(i, amount, p.velocity, burning, creative);
@@ -2262,7 +2374,7 @@ impl Game<'_> {
         // Projectile.onHit: the landing is heard.
         self.projectile_event("minecraft:projectile_land", p.owner, atp);
         let source_kind = match p.kind {
-            ProjectileKind::Arrow { .. } => DamageKind::Arrow,
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => DamageKind::Arrow,
             ProjectileKind::SmallFireball | ProjectileKind::LargeFireball { .. } => {
                 DamageKind::Fireball
             }
@@ -2274,6 +2386,40 @@ impl Game<'_> {
             from: Some([p.previous.x, p.previous.y, p.previous.z]),
         };
         match (&p.kind, hit) {
+            // ThrownTrident.onHitEntity: 8 damage (Impaling on aquatic mobs),
+            // dealt whether or not the hurt lands, then it bounces off.
+            (ProjectileKind::Trident, Hit::Entity { who, .. }) => {
+                let mut trident = p.clone();
+                let victim = match who {
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map(|m| m.kind.id.clone()),
+                    Who::Player => Some("minecraft:player".to_owned()),
+                };
+                let amount = self.shot_damage(&mut trident, victim.as_deref());
+                let hurt = match who {
+                    Who::Player => self.mob_hits_player(
+                        amount,
+                        [p.previous.x, p.previous.y, p.previous.z],
+                        "minecraft:trident",
+                    ),
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter_mut()
+                        .find(|m| m.id == id)
+                        .is_some_and(|m| m.damage(amount, source)),
+                };
+                let outcome = if hurt {
+                    EntityHit::Hurt
+                } else {
+                    EntityHit::Refused
+                };
+                self.finish_arrow_hit(trident, outcome);
+            }
+            // AbstractArrow.onHitBlock plays its sound itself (ArrowEvent).
+            (ProjectileKind::Trident, Hit::Block { .. }) => {}
             (ProjectileKind::Arrow { effect, .. }, Hit::Entity { who, .. }) => {
                 let mut arrow = p.clone();
                 let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
@@ -2495,14 +2641,30 @@ impl Game<'_> {
                     if d2 < 16.0 && !self.creative {
                         let scale = 1.0 - d2.sqrt() / 4.0;
                         let t = (f64::from(*ticks) * scale + 0.5) as i32;
-                        if let Some(owner) = self.combat.projectile_owner {
-                            self.note_attacker("minecraft:indirect_magic", owner);
-                        }
                         match *effect {
-                            "minecraft:instant_damage" => self.hurt_player_by(
-                                "minecraft:indirect_magic",
-                                6.0 * (1 << *amplifier) as f32 * scale as f32,
-                            ),
+                            "minecraft:instant_damage" => {
+                                // indirectMagic(potion, owner), built where the
+                                // hurt happens: the thrower, or the potion
+                                // itself when it has none. A status effect
+                                // deals no damage, so it records no source.
+                                let owner = self
+                                    .combat
+                                    .projectile_owner
+                                    .filter(|id| self.mob_display_name(*id).is_some());
+                                match owner {
+                                    Some(owner) => {
+                                        self.note_attacker("minecraft:indirect_magic", owner)
+                                    }
+                                    None => self.note_direct_entity(
+                                        "minecraft:indirect_magic",
+                                        Text::translate("entity.minecraft.splash_potion", &[]),
+                                    ),
+                                }
+                                self.hurt_player_by(
+                                    "minecraft:indirect_magic",
+                                    6.0 * (1 << *amplifier) as f32 * scale as f32,
+                                )
+                            }
                             e if t > 20 => self.give_player_effect(e, t, *amplifier),
                             _ => {}
                         }
@@ -3259,7 +3421,7 @@ impl Game<'_> {
     pub(super) fn mob_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let atlas = &self.gui.atlas;
         let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
-        let scale = f64::from(self.settings.entity_distance);
+        let scale = self.view_scale();
         for mob in &self.mobs {
             let entity_start = out.len();
             // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws.
@@ -3268,9 +3430,16 @@ impl Game<'_> {
             }
             let d = glam::DVec3::new(mob.position.x, mob.position.y, mob.position.z) - camera;
             // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's
-            // mean edge, scaled by the entity distance option.
+            // mean edge, scaled by the view scale. RemotePlayer's box counts
+            // ten times.
             let (w, h, _) = mob.dims();
-            let range = (w + h + w) / 3.0 * 64.0 * scale;
+            let edge = (w + h + w) / 3.0
+                * if &*mob.kind.id == "minecraft:player" {
+                    10.0
+                } else {
+                    1.0
+                };
+            let range = edge * 64.0 * scale;
             if d.length_squared() >= range * range {
                 continue;
             }
@@ -3411,6 +3580,30 @@ impl Game<'_> {
                 }
                 continue;
             }
+            // ThrownTridentRenderer.
+            if matches!(a.kind, ProjectileKind::Trident) {
+                let Some(model) = self.trident_model.as_ref() else {
+                    continue;
+                };
+                let Some(r) = atlas.sprites.get("entity/trident/trident").copied() else {
+                    continue;
+                };
+                let m = glam::Mat4::from_translation(c)
+                    * glam::Mat4::from_rotation_y((a.yaw - 90.0).to_radians())
+                    * glam::Mat4::from_rotation_z((a.pitch + 90.0).to_radians());
+                let poses = horizon_client::mobs::anim::Poses::new(model);
+                horizon_client::mobs::render::draw(
+                    model,
+                    m,
+                    &poses,
+                    [r.u0, r.v0, r.u1, r.v1],
+                    0xFFFF_FFFF,
+                    packed,
+                    0,
+                    out,
+                );
+                continue;
+            }
             // WindChargeRenderer.
             if matches!(
                 a.kind,
@@ -3524,6 +3717,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool)
         K::InFire => "minecraft:in_fire",
         K::Lava => "minecraft:lava",
         K::Drown => "minecraft:drown",
+        K::DryOut => "minecraft:dry_out",
         K::Magic => "minecraft:magic",
         K::Sting => "minecraft:sting",
         K::Cactus => "minecraft:cactus",

crates/horizon-client/src/game/cushions.rs

@@ -348,11 +348,15 @@ impl Game<'_> {
         let Some(state) = self.pack.assets.registry.default_state(&name) else {
             return;
         };
-        let at = [
-            c.position.x.floor() as i32,
-            c.position.y.floor() as i32,
-            c.position.z.floor() as i32,
-        ];
+        let p = c.position;
+        // Entity.getY(2/3) is relative to the cushion's quarter-block height.
+        let particle_at = [p.x, p.y + 0.25 * (2.0 / 3.0), p.z];
+        // Guest actions temporarily take self.lan; flush once the hub is back.
+        // Queue before resolving a sprite: a dedicated server has no renderer.
+        if self.audio.capture.is_some() {
+            self.lan_cushion_breaks.push((state, particle_at));
+        }
+        let at = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
         let Some((sprite, tint)) = self.particle_sprite(state, at) else {
             return;
         };
@@ -361,14 +365,8 @@ impl Game<'_> {
             sprite,
             tint,
         );
-        let p = c.position;
-        self.particles.send_particles(
-            &options,
-            [p.x, p.y + 0.666_666_7, p.z],
-            [0.25, 0.0625, 0.25],
-            0.05,
-            10,
-        );
+        self.particles
+            .send_particles(&options, particle_at, [0.25, 0.0625, 0.25], 0.05, 10);
     }
 
     /// `BlockAttachedEntity.tick`: survive and burn checks after the post-increment reaches 100.
@@ -455,8 +453,7 @@ impl Game<'_> {
                 glam::DVec3::new(lo.x, lo.y, lo.z),
                 glam::DVec3::new(hi.x, hi.y, hi.z),
             );
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }

crates/horizon-client/src/game/dedicated.rs

@@ -24,6 +24,7 @@ use horizon_client::{
 use horizon_protocol::text::translatable;
 use horizon_world::nbt::{JavaString, Tag};
 use std::{
+    io::Write,
     path::PathBuf,
     sync::{Arc, Mutex, OnceLock, mpsc},
     time::{Duration, Instant},
@@ -89,7 +90,9 @@ fn log_from(thread: &str, level: &str, message: &str) {
         }
     });
     // Log4j's %d{HH:mm:ss}: the local time, as in logs/latest.log.
-    println!(
+    // The launcher can close its stdout pipe while the server keeps running.
+    let _ = writeln!(
+        std::io::stdout().lock(),
         "[{}] [{thread}/{level}]: {message}",
         chrono::Local::now().format("%H:%M:%S")
     );
@@ -618,6 +621,22 @@ impl Game<'_> {
                 log_ips: props.log_ips,
             }),
             resource_pack: props.resource_pack.clone(),
+            // DedicatedServer.serverLinks: `bug-report-link` as the only link
+            // (ServerLinks.KnownLinkType.BUG_REPORT is id 0).
+            server_links: if props.bug_report_link.is_empty() {
+                Vec::new()
+            } else if super::server_links::valid_untrusted_uri(&props.bug_report_link) {
+                vec![horizon_protocol::packets::configuration::ServerLink {
+                    kind: horizon_protocol::packets::configuration::ServerLinkKind::Known(0),
+                    link: props.bug_report_link.clone(),
+                }]
+            } else {
+                log(
+                    "WARN",
+                    &format!("Failed to parse bug link {}", props.bug_report_link),
+                );
+                Vec::new()
+            },
         };
         let config = HubConfig {
             default_game_mode: game_mode,
@@ -654,6 +673,9 @@ impl Game<'_> {
         // DedicatedServer.initServer ends with saveEverything(false, true, true).
         self.save_game()?;
         self.log_saved_levels();
+        if let Some(host) = self.lan.as_mut() {
+            host.hub.entity_range_percent = props.entity_broadcast_range_percentage;
+        }
         let mut state = ServerState {
             lists,
             console,
@@ -1308,3 +1330,110 @@ fn png_size(bytes: &[u8]) -> Option<(u32, u32)> {
     let h = u32::from_be_bytes(bytes[20..24].try_into().ok()?);
     Some((w, h))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{capture_log, log, log_from};
+    use std::{
+        fs,
+        io::{self, BufRead, BufReader, Read, Write},
+        process::{Command, Stdio},
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    const LOGIN: &str = "Player[/127.0.0.1:0] logged in with entity id 2 at (0.5, 115.0, 0.5)";
+    const WARNING: &str = "Authentication warning";
+    const READY: &str = "horizon-console-log-ready\n";
+    const CHILD_HOME: &str = "HORIZON_TEST_CONSOLE_LOG_HOME";
+
+    fn assert_log_lines(text: &str) {
+        let expected = [
+            format!("] [Server thread/INFO]: {LOGIN}"),
+            format!("] [User Authenticator #1/WARN]: {WARNING}"),
+        ];
+        assert_eq!(text.lines().count(), expected.len());
+        for (line, suffix) in text.lines().zip(expected) {
+            assert!(line.starts_with('['));
+            assert!(chrono::NaiveTime::parse_from_str(&line[1..9], "%H:%M:%S").is_ok());
+            assert_eq!(&line[9..], suffix);
+        }
+    }
+
+    #[test]
+    fn console_logging_survives_closed_stdout() {
+        if let Some(home) = std::env::var_os(CHILD_HOME) {
+            horizon_client::logging::init(std::path::Path::new(&home), "Server thread");
+            // Let the parent close the real stdout pipe only after libtest's startup output.
+            io::stdout().write_all(READY.as_bytes()).unwrap();
+            io::stdout().flush().unwrap();
+            io::stdin().read_exact(&mut [0]).unwrap();
+            std::thread::Builder::new()
+                .name("Server thread".into())
+                .spawn(|| {
+                    let captured = capture_log(|| {
+                        log("INFO", LOGIN);
+                        log_from("User Authenticator #1", "WARN", WARNING);
+                    });
+                    assert_eq!(captured, [LOGIN, WARNING]);
+                    horizon_client::logging::flush();
+                })
+                .unwrap()
+                .join()
+                .unwrap();
+            // Libtest's final status also writes to stdout; only the game logger is under test.
+            std::process::exit(0);
+        }
+
+        for closed_stdout in [false, true] {
+            let unique = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let home = std::env::temp_dir().join(format!(
+                "horizon-console-log-test-{}-{unique}",
+                std::process::id()
+            ));
+            fs::create_dir(&home).unwrap();
+            let mut child = Command::new(std::env::current_exe().unwrap())
+                .args([
+                    "--exact",
+                    "game::dedicated::tests::console_logging_survives_closed_stdout",
+                    "--nocapture",
+                ])
+                .env(CHILD_HOME, &home)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            let mut stdout = BufReader::new(child.stdout.take().unwrap());
+            loop {
+                let mut line = String::new();
+                assert!(
+                    stdout.read_line(&mut line).unwrap() > 0,
+                    "child was not ready"
+                );
+                if line.ends_with(READY) {
+                    break;
+                }
+            }
+            if closed_stdout {
+                drop(stdout); // No reader remains: the next console write gets EPIPE.
+            } else {
+                child.stdout = Some(stdout.into_inner());
+            }
+            child.stdin.take().unwrap().write_all(&[1]).unwrap();
+            let output = child.wait_with_output().unwrap();
+            assert!(
+                output.status.success(),
+                "closed_stdout={closed_stdout}: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            if !closed_stdout {
+                assert_log_lines(std::str::from_utf8(&output.stdout).unwrap());
+            }
+            assert_log_lines(&fs::read_to_string(home.join("logs/latest.log")).unwrap());
+            fs::remove_dir_all(home).unwrap();
+        }
+    }
+}

crates/horizon-client/src/game/dispenser.rs

@@ -982,7 +982,7 @@ impl Game<'_> {
             | "minecraft:lingering_potion" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
                 shot.shoot(&mut own, dir, power, uncertainty);
-                self.launch_thrown(one, at, shot.velocity);
+                self.launch_thrown(one, at, shot.velocity, None);
             }
             "minecraft:firework_rocket" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);

crates/horizon-client/src/game/dragon.rs

@@ -2157,11 +2157,14 @@ impl Game<'_> {
     }
     /// Damage from the dragon, which is its causing entity
     /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the
-    /// death message names it.
+    /// death message names it, or the cloud once the dragon is gone.
     fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) {
         if let Some(id) = self.dragon.as_ref().map(|d| d.id) {
             let name = Text::translate("entity.minecraft.ender_dragon", &[]);
             self.note_named_attacker(damage_type, id, name);
+        } else if damage_type == "minecraft:indirect_magic" {
+            let name = Text::translate("entity.minecraft.area_effect_cloud", &[]);
+            self.note_direct_entity(damage_type, name);
         }
         self.hurt_player_by(damage_type, amount);
     }
@@ -2598,7 +2601,9 @@ impl Game<'_> {
     }
     pub(super) fn fight_ready(&mut self) -> bool {
         self.load_fight();
-        self.fight.loaded
+        // spawnExitPortal runs from scanState and the dragon's death, both
+        // only with players in the fight.
+        self.fight.loaded && self.fight.players
     }
     pub(super) fn exit_portal(&self) -> Option<[i32; 3]> {
         self.fight.exit_portal

crates/horizon-client/src/game/enchant_effects.rs

@@ -3,10 +3,14 @@
 //! unbreaking (`minecraft:item_damage`), sharpness/smite/bane and power
 //! (`minecraft:damage`), knockback, fire aspect, infinity (`minecraft:ammo_use`),
 //! thorns (`minecraft:post_attack`), mending (`minecraft:repair_with_xp`) and
-//! the armor attribute effects (respiration, depth strider, ...).
+//! the armor attribute effects (respiration, depth strider, ...) and Soul
+//! Speed's `location_changed` and `tick` effects.
 use super::Game;
-use horizon_client::{enchant::EffectContext, items::ItemStack};
-use horizon_core::random::RandomSource;
+use horizon_client::{
+    enchant::{EffectContext, Enchantments, level_value},
+    items::ItemStack,
+};
+use horizon_core::{position::BlockPos, random::RandomSource};
 
 /// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`).
 #[derive(Clone, Copy)]
@@ -458,6 +462,134 @@ impl Game<'_> {
         }
         ignite
     }
+    /// Soul Speed (`data/minecraft/enchantment/soul_speed.json`), the parts of
+    /// `Enchantment.runLocationChangedEffects` and `tick` that file uses. The
+    /// `location_changed` effects run when the player enters a new block, lands,
+    /// or its boots change:
+    /// - the speed and movement efficiency modifiers turn on over a soul speed
+    ///   block (not flying, not riding) and stay on while airborne, then off
+    ///   (`enchantment_active_check`);
+    /// - the boots lose 1 durability with a 4% chance when on such a block.
+    ///
+    /// Every fifth tick the player walking on one also gets a soul particle
+    /// (returned as its position and velocity, for the caller to show or send
+    /// to the players around) and sometimes a sound. Runs for the window's own
+    /// player and for each guest on the server (`guest_server_tick`); a remote
+    /// client leaves it to its server.
+    pub(super) fn tick_soul_speed(&mut self) -> Option<([f64; 3], [f64; 3])> {
+        const ID: &str = "minecraft:soul_speed";
+        let player = self.player.as_mut()?;
+        if player.client_side {
+            return None;
+        }
+        let level = self.armor[3]
+            .as_ref()
+            .map_or(0, |s| s.enchantment_level(ID));
+        let position = player.position;
+        let (on_ground, flying) = (player.ground.on_ground, player.flying);
+        let moved = position.subtract(player.old_position);
+        let (tick, width) = (player.health.tick_count, player.dimensions.width);
+        let fx = &mut player.location_effects;
+        let on_soul = fx.on_soul_speed_block;
+        let block = BlockPos::containing(position);
+        let changed_block = fx.block.replace(block) != Some(block);
+        let landed = std::mem::take(&mut fx.landed);
+        // Changed boots: `stopLocationBasedEffects`, then the effects run again.
+        let equipped = std::mem::replace(&mut fx.boots_level, level) != level;
+        let was_active = fx.applied_level;
+        let mut active = was_active > 0 && !equipped;
+        let mut wear = false;
+        if level > 0 && (changed_block || landed || equipped) {
+            let riding = self.riding.is_some();
+            let wanted = !riding && !flying && (on_soul || (active && !on_ground));
+            active = wanted;
+            // `random_chance` is the first term of the wear's `all_of`: it
+            // draws from the level random before the block is looked at.
+            let roll = self.world.random.next_float() < 0.04;
+            wear = roll && on_ground && on_soul;
+        }
+        fx.applied_level = if active { level } else { 0 };
+        // `Entity.getKnownMovement` horizontal speed of at least 1.0E-5.
+        let walking = moved.x * moved.x + moved.z * moved.z >= 1.0e-10;
+        let tick_effects = level > 0 && !flying && on_ground && walking && on_soul && tick % 5 == 0;
+        // The attribute effects were applied to the player before: swap them.
+        if was_active > 0 && (!active || equipped) {
+            for (attribute, id, _, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, was_active)
+            {
+                let _ = player.set_modifier(&attribute, &id, 0.0, &op, false);
+            }
+        }
+        if active && (was_active == 0 || equipped) {
+            for (attribute, id, amount, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, level)
+            {
+                let _ = player.set_modifier(&attribute, &id, amount, &op, true);
+            }
+        }
+        if wear && !self.creative {
+            self.wear_boots(1);
+        }
+        if level == 0 {
+            return None;
+        }
+        let r = &mut self.world.random;
+        // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
+        // back against the movement (-0.2) and up (0.1).
+        let particle = tick_effects.then(|| {
+            let x = position.x + (r.next_double() - 0.5) * f64::from(width);
+            let z = position.z + (r.next_double() - 0.5) * f64::from(width);
+            (
+                [x, position.y + 0.1, z],
+                [moved.x * -0.2, 0.1, moved.z * -0.2],
+            )
+        });
+        // `play_sound`: its `random_chance` (35%) comes first in its `all_of`,
+        // so the level random is drawn every tick the boots are worn; volume
+        // 0.6, pitch 0.6 to 1.0.
+        if r.next_float() < 0.35 && tick_effects {
+            let pitch = r.next_float() * 0.4 + 0.6;
+            self.audio.play(
+                "minecraft:particle.soul_escape",
+                Some([position.x, position.y, position.z]),
+                0.6,
+                pitch,
+            );
+        }
+        particle
+    }
+    /// `ItemStack.hurtAndBreak` on the worn boots (`change_item_damage`):
+    /// Unbreaking applies, and they break when worn out.
+    fn wear_boots(&mut self, amount: u32) {
+        let Some(stack) = self.armor[3].clone() else {
+            return;
+        };
+        let loss = self.durability_loss(&stack, amount);
+        let max = self
+            .res
+            .items()
+            .get(&stack.item)
+            .map_or(0, |info| info.max_damage);
+        if max == 0 {
+            return;
+        }
+        let Some(boots) = self.armor[3].as_mut() else {
+            return;
+        };
+        boots.damage += loss;
+        if boots.damage >= max {
+            self.armor[3] = None;
+            if let Some(eye) = self.eye_position() {
+                self.audio.play(
+                    "minecraft:entity.item.break",
+                    Some(eye),
+                    0.8,
+                    0.8 + self.world.random.next_float() * 0.4,
+                );
+            }
+            self.apply_equipment();
+        }
+    }
     /// Enchantment attribute modifiers of worn armor (respiration, depth strider...).
     /// Each piece's modifier id ends with its slot (`EnchantmentAttributeEffect.idForSlot`),
     /// so the same enchantment on two pieces stacks instead of replacing itself.
@@ -481,3 +613,28 @@ impl Game<'_> {
         self.potions.enchant_modifiers = wanted;
     }
 }
+
+/// Soul Speed's `attribute` effects at `level` (attribute, id, amount, operation),
+/// the id taking the boots slot like `EnchantmentAttributeEffect.idForSlot`.
+fn soul_speed_modifiers(
+    enchantments: &Enchantments,
+    level: u32,
+) -> Vec<(String, String, f64, String)> {
+    let Some(e) = enchantments.get("minecraft:soul_speed") else {
+        return Vec::new();
+    };
+    e.effects["minecraft:location_changed"][0]["effect"]["effects"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|a| a["type"] == "minecraft:attribute")
+        .map(|a| {
+            (
+                a["attribute"].as_str().unwrap_or("").to_owned(),
+                format!("{}/feet", a["id"].as_str().unwrap_or("")),
+                f64::from(level_value(&a["amount"], level)),
+                a["operation"].as_str().unwrap_or("add_value").to_owned(),
+            )
+        })
+        .collect()
+}

crates/horizon-client/src/game/end.rs

@@ -19,7 +19,7 @@ use horizon_core::{
 use std::{collections::HashMap, sync::Arc};
 
 /// ServerLevel.END_SPAWN_POINT.
-const END_SPAWN: [i32; 3] = [100, 50, 0];
+pub(super) const END_SPAWN: [i32; 3] = [100, 50, 0];
 /// EnderDragonFight gateway ring radius and height.
 const GATEWAY_RADIUS: f64 = 96.0;
 const GATEWAY_Y: i32 = 75;

crates/horizon-client/src/game/entity_culling.rs

@@ -60,12 +60,27 @@ impl Game<'_> {
     }
 }
 
+impl Game<'_> {
+    /// Entity.setViewScale (LevelExtractor.extractVisibleEntities): the entity
+    /// distance option times the render distance's boost — 1 at 8 chunks, 2.5
+    /// at 20 or more. The render distance is the client setting, capped by
+    /// the server's view distance when connected
+    /// (Options.getEffectiveRenderDistance).
+    pub(super) fn view_scale(&self) -> f64 {
+        let distance = match &self.remote {
+            Some(r) => self.settings.render_distance.min(r.view_distance),
+            None => self.settings.render_distance,
+        };
+        (f64::from(distance) / 8.0).clamp(1.0, 2.5) * f64::from(self.settings.entity_distance)
+    }
+}
+
 /// Entity.shouldRenderAtSqrDistance's default range: 64 times the bounding
-/// box's mean edge, scaled by the entity distance option.
-pub(super) fn default_range(size: glam::DVec3, view_scale: f32) -> f64 {
+/// box's mean edge, scaled by the view scale.
+pub(super) fn default_range(size: glam::DVec3, view_scale: f64) -> f64 {
     let edge = (size.x + size.y + size.z) / 3.0;
     let edge = if edge.is_nan() { 1.0 } else { edge };
-    edge * 64.0 * f64::from(view_scale)
+    edge * 64.0 * view_scale
 }
 
 impl Game<'_> {

crates/horizon-client/src/game/explosion.rs

@@ -572,16 +572,16 @@ impl Game<'_> {
         let pitch = (1.0 + (client_float() - client_float()) * 0.2) * 0.7;
         self.audio
             .play("minecraft:entity.generic.explode", Some(center), 4.0, pitch);
-        let block_count = if interaction == BlockInteraction::Keep {
-            0
-        } else {
-            targets.len()
-        };
+        // ServerLevel.explode sends toBlow.size() whatever the interaction, and
+        // `ServerExplosion.isSmall` also covers an explosion that keeps blocks.
+        let block_count = targets.len();
+        let small = radius < 2.0 || interaction == BlockInteraction::Keep;
         let (world, facts) = (&self.world, self.res.facts());
-        self.particles.explosion(center, radius, block_count, &|b| {
-            facts.is_air(world.block(b[0], b[1], b[2]))
-        });
-        self.lan_explode(center, radius, block_count);
+        self.particles
+            .explosion(center, small, block_count, radius, &|b| {
+                facts.is_air(world.block(b[0], b[1], b[2]))
+            });
+        self.lan_explode(center, small, radius, block_count);
         Ok(())
     }
     /// `BlockBehaviour.onExplosionHit` (TNT: `wasExploded` primes a short fuse).
@@ -598,6 +598,11 @@ impl Game<'_> {
         }
         let name = self.res.facts().get(state).name.clone();
         let is_tnt = &*name == "minecraft:tnt";
+        // CreakingHeartBlock.onExplosionHit: its creaking dies (no
+        // experience, as Horizon does not track a TNT's owner).
+        if &*name == "minecraft:creaking_heart" {
+            self.creaking_heart_broken(pos, false);
+        }
         // Block.onExplosionHit: the drops copy from the block entity, which
         // then spills its contents as the block turns to air.
         let key = (pos[0], pos[1], pos[2]);

crates/horizon-client/src/game/falling_damage.rs

@@ -64,6 +64,25 @@ impl Game<'_> {
                     pos: BlockPos::new(pos[0], pos[1], pos[2]),
                     data: 0,
                 });
+            } else if self
+                .res
+                .facts()
+                .get(block.state)
+                .name
+                .starts_with("minecraft:suspicious_")
+            {
+                // BrushableBlock.onBrokenAfterFall.
+                let at = BlockPos::new(pos[0], pos[1], pos[2]);
+                self.level_events.push(LevelEvent::LevelEvent {
+                    id: 2001,
+                    pos: at,
+                    data: block.state.0 as i32,
+                });
+                self.level_events.push(LevelEvent::GameEvent {
+                    pos: at,
+                    event: "minecraft:block_destroy",
+                    state: None,
+                });
             }
             return;
         }

crates/horizon-client/src/game/fangs.rs

@@ -7,12 +7,13 @@ use std::sync::Arc;
 
 #[derive(Clone, Debug)]
 pub(super) struct Fangs {
-    pos: [f64; 3],
-    yaw: f32,
+    pub id: u32,
+    pub pos: [f64; 3],
+    pub yaw: f32,
     warmup: i32,
-    life: i32,
+    pub life: i32,
     owner: u32,
-    started: bool,
+    pub started: bool,
 }
 #[derive(Default)]
 pub(super) struct FangState {
@@ -21,6 +22,11 @@ pub(super) struct FangState {
 }
 impl Game<'_> {
     pub(super) fn add_fangs(&mut self, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
+        self.next_entity += 1;
+        self.insert_fangs(self.next_entity, at, yaw, delay, owner);
+    }
+
+    pub(super) fn insert_fangs(&mut self, id: u32, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
         if self.fangs.model.is_none() {
             self.fangs.model = horizon_client::mobs::load_model(
                 &self.options.resources,
@@ -29,6 +35,7 @@ impl Game<'_> {
             .map(Arc::new);
         }
         self.fangs.list.push(Fangs {
+            id,
             pos: at,
             yaw,
             warmup: delay,
@@ -37,6 +44,30 @@ impl Game<'_> {
             started: false,
         });
     }
+    /// `EvokerFangs.handleEntityEvent`: only event 4 starts a client attack.
+    pub(super) fn remote_fangs_event(&mut self, id: u32, event: i8) {
+        if event == 4
+            && let Some(f) = self.fangs.list.iter_mut().find(|f| f.id == id)
+        {
+            f.started = true;
+            self.audio.play_unshared(
+                "minecraft:entity.evoker_fangs.attack",
+                Some(f.pos),
+                1.0,
+                1.0,
+            );
+        }
+    }
+
+    /// `EvokerFangs.tick`: clients only advance animation, never damage or discard.
+    pub(super) fn tick_remote_fangs(&mut self) {
+        for f in &mut self.fangs.list {
+            if f.started {
+                f.life -= 1;
+            }
+        }
+    }
+
     /// `EvokerFangs.tick`.
     pub(super) fn tick_fangs(&mut self) {
         let mut list = std::mem::take(&mut self.fangs.list);
@@ -50,7 +81,8 @@ impl Game<'_> {
             }
             if !f.started {
                 f.started = true;
-                self.audio.play(
+                self.lan_entity_event(f.id as i32, 4, f.pos);
+                self.audio.play_unshared(
                     "minecraft:entity.evoker_fangs.attack",
                     Some(f.pos),
                     1.0,
@@ -71,12 +103,23 @@ impl Game<'_> {
         let b = horizon_core::geometry::Aabb::new(lo, hi);
         // Every player in the box, the server's players too.
         let pos = f.pos;
+        // `EvokerFangs.dealDamageTo`: indirectMagic(fangs, owner) while the
+        // owner lives, plain magic (nobody to name) once it is gone.
+        let owner = self
+            .mobs
+            .iter()
+            .any(|m| m.id == f.owner && m.alive())
+            .then_some(f.owner);
         let bite = move |g: &mut Self| {
             if let Some(p) = g.player_view()
                 && p.alive
                 && p.bounds.intersects(b)
             {
-                g.mob_hits_player_kind(6.0, pos, "minecraft:indirect_magic");
+                let kind = match owner {
+                    Some(_) => "minecraft:indirect_magic",
+                    None => "minecraft:magic",
+                };
+                g.mob_hits_player_caused(6.0, pos, kind, owner);
             }
         };
         bite(self);

crates/horizon-client/src/game/frames.rs

@@ -311,8 +311,9 @@ impl Game<'_> {
         let sprites = &self.gui.atlas.sprites;
         let mut maps: Vec<(i32, glam::Mat4, u32)> = Vec::new();
         let mut items: Vec<(ItemStack, u32, glam::Mat4, u8)> = Vec::new();
-        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at 100%.
-        let range = 16.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at a view scale
+        // of 1.
+        let range = 16.0 * 64.0 * self.view_scale();
         for f in &self.item_frames {
             let entity_start = out.len();
             let map = f.item.as_ref().and_then(super::maps::map_id);

crates/horizon-client/src/game/initial_spawn.rs

@@ -20,7 +20,8 @@ use horizon_core::{
 };
 use horizon_world::{
     block_collision::BlockCollisionRegistry, collision_context::CollisionContext,
-    heightmap::HeightmapType, worldgen::terrain::TerrainBlockStates,
+    heightmap::HeightmapType, level::flags::UPDATE_CLIENTS, registry::BlockStateId,
+    worldgen::terrain::TerrainBlockStates,
 };
 
 /// The loaded world as the spawn searches query it.
@@ -121,33 +122,102 @@ impl Game<'_> {
         }
         Ok(Some([ox * 16 + 8, height, oz * 16 + 8]))
     }
+    /// MinecraftServer.setInitialSpawn's bonus chest: BonusChestFeature.place
+    /// in the spawn chunk, a chest with the spawn bonus loot and a torch on
+    /// each side that can hold one, on the first free column of a shuffled
+    /// walk over the chunk. Skipped while the chunk is not loaded.
+    pub(super) fn place_bonus_chest(&mut self, origin: [i32; 3]) -> Result<()> {
+        use horizon_client::containers::BlockEntity;
+        let (cx, cz) = (origin[0] >> 4, origin[2] >> 4);
+        let registry = &self.pack.assets.registry;
+        let (Some(chest), Some(torch)) = (
+            registry.default_state("minecraft:chest"),
+            registry.default_state("minecraft:torch"),
+        ) else {
+            return Ok(());
+        };
+        if !self.streaming.is_lit(cx, cz) {
+            return Ok(());
+        }
+        // `level.getRandom()`. Util.toShuffledList of the chunk's x and z.
+        let random = &mut self.world.random;
+        let mut shuffled = |min: i32| -> [i32; 16] {
+            let mut values: [i32; 16] = std::array::from_fn(|i| min + i as i32);
+            for end in (2..=16usize).rev() {
+                let other = random.next_int_bound(end as i32).unwrap_or(0) as usize;
+                values.swap(end - 1, other);
+            }
+            values
+        };
+        let (xs, zs) = (shuffled(cx * 16), shuffled(cz * 16));
+        for x in xs {
+            for z in zs {
+                let y = self
+                    .spawn_columns()
+                    .height(HeightmapType::MotionBlockingNoLeaves, x, z);
+                if self.world.block(x, y, z) != self.world.air && !self.collision_empty([x, y, z]) {
+                    continue;
+                }
+                self.set_block_clients([x, y, z], chest)?;
+                let seed = self.world.random.next_long();
+                self.world
+                    .block_entities
+                    .insert((x, y, z), BlockEntity::Chest(Vec::new()));
+                self.load_block_entity_nbt(
+                    [x, y, z],
+                    &format!(
+                        "{{LootTable:\"minecraft:chests/spawn_bonus_chest\",LootTableSeed:{seed}L}}"
+                    ),
+                );
+                for [dx, dz] in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
+                    let at = [x + dx, y, z + dz];
+                    let survives = self.with_level(|b, level, ticks| {
+                        b.can_survive(level, ticks, BlockPos::new(at[0], at[1], at[2]), torch)
+                    });
+                    if survives {
+                        self.set_block_clients(at, torch)?;
+                    }
+                }
+                return Ok(());
+            }
+        }
+        Ok(())
+    }
+    /// `Level.setBlock(pos, state, UPDATE_CLIENTS)`: no neighbour updates.
+    fn set_block_clients(&mut self, pos: [i32; 3], state: BlockStateId) -> Result<()> {
+        self.with_level(|b, level, ticks| {
+            b.set_block(
+                level,
+                ticks,
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                state,
+                UPDATE_CLIENTS,
+            );
+        });
+        self.process_level_events()
+    }
+    /// The block at `pos` has no collision shape.
+    fn collision_empty(&self, pos: [i32; 3]) -> bool {
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        self.collision
+            .collision_shape_with_context(
+                &mut scene,
+                self.world.block(pos[0], pos[1], pos[2]),
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                &CollisionContext::empty(false),
+            )
+            .is_ok_and(|shape| shape.is_empty())
+    }
     /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a
     /// player who has no position yet. None while a candidate's chunk loads.
     pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result<Option<Vec3>> {
         let mut finder = match self.player_spawn {
             Some(finder) => finder,
-            None if self.level.game_mode == 2 => {
-                // Adventure mode: the suggestion itself.
-                let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
-                finder.next_candidate();
-                finder
-            }
-            None => {
-                let mut radius = self.ui.rules.int("respawn_radius").max(0);
-                let to_border = self
-                    .border
-                    .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
-                    .floor() as i32;
-                if to_border < radius {
-                    radius = to_border;
-                }
-                if to_border <= 1 {
-                    radius = 1;
-                }
-                PlayerSpawnFinder::new(suggestion, radius, |n| {
-                    entity_random().next_int_bound(n).unwrap_or(0)
-                })
-            }
+            None => self.spawn_finder(suggestion),
         };
         let found = loop {
             let Some(candidate) = finder.next_candidate() else {
@@ -176,6 +246,58 @@ impl Game<'_> {
         self.player_spawn = found.is_none().then_some(finder);
         Ok(found)
     }
+    /// A new PlayerSpawnFinder around `suggestion`: the respawn radius, cut
+    /// by the world border; the suggestion itself in adventure mode.
+    fn spawn_finder(&self, suggestion: [i32; 3]) -> PlayerSpawnFinder {
+        if self.level.game_mode == 2 {
+            let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
+            finder.next_candidate();
+            return finder;
+        }
+        let mut radius = self.ui.rules.int("respawn_radius").max(0);
+        let to_border = self
+            .border
+            .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
+            .floor() as i32;
+        if to_border < radius {
+            radius = to_border;
+        }
+        if to_border <= 1 {
+            radius = 1;
+        }
+        PlayerSpawnFinder::new(suggestion, radius, |n| {
+            entity_random().next_int_bound(n).unwrap_or(0)
+        })
+    }
+    /// ServerPlayer.adjustSpawnLocation for a server's new player: where
+    /// PlayerSpawnFinder.findSpawn puts their feet around the world spawn
+    /// (`spawn`, the feet there), so that players new to a world don't all
+    /// stand in one spot. Vanilla waits for each candidate's chunk; a server
+    /// tick can't, so a candidate in a chunk not loaded yet is passed over,
+    /// and `spawn` stays when the search never reaches a loaded column.
+    pub(super) fn server_player_spawn(&self, spawn: [f64; 3]) -> [f64; 3] {
+        let suggestion = spawn.map(|v| v.floor() as i32);
+        let mut finder = self.spawn_finder(suggestion);
+        while let Some(candidate) = finder.next_candidate() {
+            let (x, z) = match candidate {
+                SpawnCandidate::Column(x, z) => (x, z),
+                SpawnCandidate::Suggestion => (suggestion[0], suggestion[2]),
+            };
+            if !self.streaming.is_lit(x >> 4, z >> 4) {
+                continue;
+            }
+            let feet = match candidate {
+                SpawnCandidate::Column(x, z) => level_respawn_pos(&self.spawn_columns(), x, z)
+                    .filter(|&pos| self.player_fits(pos))
+                    .map(bottom_center),
+                SpawnCandidate::Suggestion => Some(self.fixup_spawn_height(suggestion)),
+            };
+            if let Some(feet) = feet {
+                return [feet.x, feet.y, feet.z];
+            }
+        }
+        spawn
+    }
     /// PlayerSpawnFinder.noCollisionNoLiquid: a player's box standing at the
     /// block's bottom centre touches no block or liquid.
     fn player_fits(&self, pos: [i32; 3]) -> bool {

crates/horizon-client/src/game/integrated.rs

@@ -52,6 +52,8 @@ struct Flags {
     /// server follows while it runs (IntegratedServer.tickServer).
     render_distance: AtomicI32,
     simulation_distance: AtomicI32,
+    /// `MinecraftServer.isCurrentlySaving`: the server is autosaving.
+    saving: AtomicBool,
 }
 
 /// Work the window hands its server thread (`MinecraftServer.execute`).
@@ -69,6 +71,10 @@ impl Integrated {
     pub fn smoothed_tick_ms(&self) -> f32 {
         f32::from_bits(self.flags.smoothed_tick_ms.load(Ordering::Relaxed))
     }
+    /// `MinecraftServer.isCurrentlySaving`.
+    pub fn is_saving(&self) -> bool {
+        self.flags.saving.load(Ordering::Relaxed)
+    }
     /// `IntegratedServer.tickServer` skips the world while the game is paused.
     pub fn set_paused(&self, paused: bool) {
         self.flags.paused.store(paused, Ordering::Relaxed);
@@ -148,6 +154,12 @@ pub(super) struct Serving {
     /// is out of its place: applied after the tick.
     pending: Option<Publish>,
 }
+impl Serving {
+    /// The window reads this as `MinecraftServer.isCurrentlySaving`.
+    pub(super) fn set_saving(&self, saving: bool) {
+        self.flags.saving.store(saving, Ordering::Relaxed);
+    }
+}
 enum Publish {
     Open(TcpListener, LanSettings),
     Close,

crates/horizon-client/src/game/lan.rs

@@ -11,7 +11,7 @@ use horizon_client::{
         chunks::ChunkEncoder,
         data::SyncData,
         entity::{EntityState, States},
-        hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
+        hub::{BodyFlags, HostEvent, HostState, Hub, HubConfig, TickCtx},
         playerdata,
     },
     mobs::{Mob, Who, leash::Holder},
@@ -21,14 +21,28 @@ use horizon_core::geometry::Vec3;
 use horizon_protocol::{
     crypto::offline_uuid,
     entity_data::{Value, serializer},
+    packets::play::{self, Clientbound as C},
 };
 use std::{
     collections::HashMap,
-    sync::{Arc, OnceLock},
+    sync::{Arc, Mutex},
 };
 
 /// The registries and tags are the same for every world: load them once.
-static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
+static SYNC: Mutex<Option<std::result::Result<Arc<SyncData>, String>>> = Mutex::new(None);
+
+/// The registries and tags a server sends, loaded from `root` the first time.
+pub(super) fn sync_data(root: &std::path::Path) -> std::result::Result<Arc<SyncData>, String> {
+    let mut sync = SYNC.lock().unwrap_or_else(|e| e.into_inner());
+    sync.get_or_insert_with(|| SyncData::load(root).map(Arc::new))
+        .clone()
+}
+
+/// Let go of what `sync_data` loaded: for a preload no world used
+/// (game/world_loading.rs).
+pub(super) fn forget_sync_data() {
+    *SYNC.lock().unwrap_or_else(|e| e.into_inner()) = None;
+}
 
 /// The settings of the open world (WorldOptionsScreen's multiplayer section).
 #[derive(Clone, Copy, Debug)]
@@ -178,6 +192,17 @@ fn mob_meta(
         meta.push((9, serializer::FLOAT, Value::Float(health)));
     }
     defaults.push((9, serializer::FLOAT, Value::Float(1.0)));
+    // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID: the
+    // swirls of its effects (the ones a mob has are visible, not ambient).
+    meta.extend(
+        hub.effect_meta(
+            (m.extra.effects.iter())
+                .filter(|e| !m.extra.hidden_effects.contains(&e.0))
+                .map(|e| (e.0, false)),
+        ),
+    );
+    defaults.push((10, serializer::PARTICLES, Value::Particles(Vec::new())));
+    defaults.push((11, serializer::BOOLEAN, Value::Bool(false)));
     // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4 (what
     // draws a vindicator's axe, a skeleton's drawn bow, a piglin's raised
     // weapon).
@@ -223,6 +248,27 @@ fn mob_meta(
             }
             defaults.push((16, serializer::BYTE, Value::Byte(0)));
         }
+        // SnowGolem.DATA_PUMPKIN_ID: 16 while the pumpkin is on (the default).
+        "minecraft:snow_golem" => {
+            if e.sheared {
+                meta.push((16, serializer::BYTE, Value::Byte(0)));
+            }
+            defaults.push((16, serializer::BYTE, Value::Byte(16)));
+        }
+        // MushroomCow.DATA_TYPE: 0 red, 1 brown.
+        "minecraft:mooshroom" => {
+            if e.variant == 1 {
+                meta.push((17, serializer::INT, Value::Int(1)));
+            }
+            defaults.push((17, serializer::INT, Value::Int(0)));
+        }
+        // Piglin.DATA_IS_DANCING (after the baby flag and the crossbow charge).
+        "minecraft:piglin" => {
+            if e.scratch[0] > 0 {
+                meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared.
         "minecraft:sheep" => {
             let value = (e.color & 15) | if e.sheared { 16 } else { 0 };
@@ -337,6 +383,14 @@ fn mob_meta(
             }
             defaults.push((17, serializer::BOOLEAN, Value::Bool(false)));
         }
+        // PolarBear.DATA_STANDING_ID (after AgeableMob's two): the bear
+        // rears up; the client animates it.
+        "minecraft:polar_bear" => {
+            if e.flag {
+                meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose.
         "minecraft:evoker" | "minecraft:illusioner" => {
             if e.variant2 != 0 {
@@ -562,10 +616,7 @@ impl Game<'_> {
         config: HubConfig,
         host: Option<u128>,
     ) -> Result<()> {
-        let root = self.options.resources.clone();
-        let sync = SYNC
-            .get_or_init(|| SyncData::load(&root).map(Arc::new))
-            .clone()?;
+        let sync = sync_data(&self.options.resources)?;
         let biome_names: Vec<String> = self
             .res
             .biomes()
@@ -665,6 +716,7 @@ impl Game<'_> {
         self.audio.capture = None;
         self.lan_events.clear();
         self.lan_critical_hits.clear();
+        self.lan_cushion_breaks.clear();
         self.streaming.extra.clear();
         if announce {
             self.system_message(Text::translate(
@@ -835,6 +887,16 @@ impl Game<'_> {
             living_flags: living_flags(self.using)
                 | if p.auto_spin_attack_ticks > 0 { 4 } else { 0 },
             bed: self.sleeping,
+            body: BodyFlags {
+                gliding: p.fall_flying,
+                swimming: p.swimming,
+                crawling: p.pose == horizon_client::pose::Pose::Swimming && !p.swimming,
+                crouching: p.pose == horizon_client::pose::Pose::Crouching,
+                spin_attack: p.auto_spin_attack_ticks > 0,
+                on_fire: p.fire_ticks > 0,
+                invisible: self.potions.effects.get("invisibility").is_some(),
+                glowing: self.potions.effects.get("glowing").is_some(),
+            },
         })
     }
 
@@ -952,6 +1014,16 @@ impl Game<'_> {
                 host.hub.block_event(pos, b0, b1, state);
             }
             let entities = states.as_slice();
+            // An entity that left the level since the last tick (a snowball
+            // that hit) is dropped by the tracker below: its event goes out
+            // first, as `Level.broadcastEntityEvent` precedes the discard.
+            let (gone, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.lan_entity_events)
+                .into_iter()
+                .partition(|(id, ..)| !entities.iter().any(|e| e.id == *id));
+            self.lan_entity_events = later;
+            for (id, event, at) in gone {
+                host.hub.entity_event(id, event, at);
+            }
             let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
             let events = {
                 let clock_rate = self.network_clock_rate();
@@ -1128,8 +1200,17 @@ impl Game<'_> {
             g.game_mode = default_mode;
         }
         if !known {
-            g.position = spawn;
-            g.previous_position = spawn;
+            // ServerPlayer.adjustSpawnLocation: a player new to the world
+            // stands where PlayerSpawnFinder puts them, not all on one spot
+            // (it reads the loaded level, which holds the spawn when it is
+            // the overworld).
+            let feet = if self.dim == super::Dim::Overworld {
+                self.server_player_spawn(spawn)
+            } else {
+                spawn
+            };
+            g.position = feet;
+            g.previous_position = feet;
             g.health = 20.0;
             g.food = 20;
             g.dimension = super::Dim::Overworld.id().to_owned();
@@ -1188,8 +1269,9 @@ impl Game<'_> {
                 horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => {
                     // The acting guest does not predict the egg's teleport
                     // particles, bone meal's growth, or anvil result sounds
-                    // (these levelEvent calls name no excluded player).
-                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
+                    // (these levelEvent calls name no excluded player), nor
+                    // the digger's own crack and hit sound (2019, 2020).
+                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) {
                         None
                     } else {
                         self.lan_acting
@@ -1224,8 +1306,9 @@ impl Game<'_> {
             self.lan_entity_events.push((id, event, at));
         }
     }
-    /// `ServerPlayer.crit`: this window's emitter, and an animation for the
-    /// attacker's client and observers once the hub is back in place.
+    /// `ServerPlayer.crit` (or `magicCrit` when `magic`): this window's
+    /// emitter, and an animation for the attacker's client and observers once
+    /// the hub is back in place.
     pub(super) fn critical_hit(
         &mut self,
         attacker: Option<u32>,
@@ -1233,21 +1316,50 @@ impl Game<'_> {
         feet: [f64; 3],
         width: f64,
         height: f64,
+        magic: bool,
     ) {
         use horizon_client::particles::{ParticleOptions, ParticleType};
-        self.particles.tracking_emitter(
-            ParticleOptions::simple(ParticleType::Crit),
-            feet,
-            width,
-            height,
-        );
+        let particle = if magic {
+            ParticleType::EnchantedHit
+        } else {
+            ParticleType::Crit
+        };
+        self.particles
+            .tracking_emitter(ParticleOptions::simple(particle), feet, width, height);
         if self.audio.capture.is_some() {
-            self.lan_critical_hits.push((attacker, id));
+            self.lan_critical_hits.push((attacker, id, magic));
         }
     }
     /// Send the tick's level events, sounds and mob animations.
     fn lan_flush_effects(&mut self, host: &mut LanHost) {
         let critical_hits = std::mem::take(&mut self.lan_critical_hits);
+        for (state, at) in std::mem::take(&mut self.lan_cushion_breaks) {
+            if let Some(id) = host
+                .hub
+                .registry_id("minecraft:particle_type", "minecraft:block")
+            {
+                host.hub.broadcast_near(
+                    at,
+                    32.0,
+                    &C::LevelParticles(play::LevelParticles {
+                        particle: horizon_protocol::entity_data::Particle {
+                            id,
+                            data: Some(horizon_protocol::entity_data::ParticleData::State(
+                                state.0 as i32,
+                            )),
+                        },
+                        override_limiter: false,
+                        always_show: false,
+                        pos: at,
+                        dist: [0.25, 0.0625, 0.25],
+                        max_speed: [0.05; 3],
+                        count: 10,
+                        randomization: 0,
+                    }),
+                    None,
+                );
+            }
+        }
         for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) {
             if kind == 2001 {
                 host.broken
@@ -1320,13 +1432,13 @@ impl Game<'_> {
             seen.insert(m.id, (m.hurt_time, dead, swing));
         }
         host.mob_state.insert(self.dim, seen);
-        for (attacker, target) in critical_hits {
+        for (attacker, target, magic) in critical_hits {
             let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| {
                 host.hub.guest(conn).map(|g| g.entity_id)
             }) else {
                 continue;
             };
-            host.hub.critical_hit(attacker, target);
+            host.hub.critical_hit(attacker, target, magic);
         }
     }
 
@@ -1409,6 +1521,13 @@ impl Game<'_> {
                 .each_ref()
                 .map(|s| s.as_ref().map(|s| s.item.clone()));
             m.extra.crouching = g.sneaking;
+            m.extra.sprinting = g.sprinting;
+            // LivingEntity.DATA_EFFECT_PARTICLES: the swirls of its visible effects.
+            let visible = || g.effects.list.iter().filter(|e| e.visible);
+            m.extra.effect_particles = visible()
+                .filter_map(|e| super::client_ambient::effect_particle(e.id, e.ambient))
+                .collect();
+            m.extra.effect_ambient = visible().all(|e| e.ambient);
             // Lying in its bed (LivingEntity.getBedOrientation).
             m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b));
             // LivingEntity.updateSwingTime: the arm swing lan_swings started.

crates/horizon-client/src/game/lan_actions.rs

@@ -165,6 +165,8 @@ pub(super) struct GuestSwap {
     acting: (Option<u32>, Option<String>, Option<u128>),
     /// The packets queued for that guest.
     packets: Vec<play::Clientbound>,
+    /// The entity events queued for that guest.
+    entity_events: Vec<i8>,
     /// The host's count of swings started, kept while the guest acts.
     swings: u32,
     /// How many projectiles there were: those added since are the guest's.
@@ -389,6 +391,7 @@ impl Game<'_> {
             self.lan_acting_uuid.replace(g.uuid),
         );
         let packets = std::mem::take(&mut self.guest_packets);
+        let entity_events = std::mem::take(&mut self.guest_entity_events);
         let swings = self.swings_started;
         let projectiles = self.creatures.projectiles.len();
         let modifiers = std::mem::replace(
@@ -449,6 +452,7 @@ impl Game<'_> {
             death_cause,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -508,6 +512,7 @@ impl Game<'_> {
             combat,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -529,6 +534,17 @@ impl Game<'_> {
         for packet in std::mem::replace(&mut self.guest_packets, packets) {
             host.hub.send_to(conn, &packet);
         }
+        // ServerPlayer.connection.send: the guest's own entity events.
+        let entity_id = host.hub.guests[i].entity_id;
+        for event in std::mem::replace(&mut self.guest_entity_events, entity_events) {
+            host.hub.send_to(
+                conn,
+                &C::EntityEvent(play::EntityEvent {
+                    id: entity_id,
+                    event,
+                }),
+            );
+        }
         // ServerItemCooldowns.onCooldownStarted: the guest's own cooldown.
         for (group, duration) in std::mem::take(&mut self.guest_cooldowns) {
             host.hub.send_to(
@@ -1216,6 +1232,12 @@ impl Game<'_> {
             {
                 self.guest_carried_back(host, gi);
             }
+            S::SelectBundleItem(p) => {
+                if !spectator && let Ok(slot) = usize::try_from(p.slot) {
+                    host.hub
+                        .select_bundle_item(conn, slot, p.index, &mut self.world);
+                }
+            }
             S::ContainerClick(p) => {
                 let rules = ItemRules(self.res.items());
                 let slots = host.hub.guests[gi]
@@ -1910,21 +1932,8 @@ impl Game<'_> {
                 continue;
             }
             let play = host.play.entry(conn).or_default();
-            // Player.tick's ItemCooldowns.tick, once a tick for each player
-            // (the shield an axe disabled, a thrown pearl).
-            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerGamePacketListenerImpl.tick's dropSpamThrottler.
             play.creative_drops = play.creative_drops.saturating_sub(1);
-            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
-            // the guest (a duration of 0 removes it).
-            for group in play.cooldowns.tick() {
-                host.hub.send_to(
-                    conn,
-                    &C::Cooldown(play::Cooldown {
-                        group: group.to_string(),
-                        duration: 0,
-                    }),
-                );
-            }
             let digging = play.digging;
             let using = play.using.is_some();
             let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100;
@@ -1961,6 +1970,24 @@ impl Game<'_> {
                     play.digging = None;
                 }
             }
+            // Player.tick's ItemCooldowns.tick, once a tick for each player
+            // (the shield an axe disabled, a thrown pearl), after
+            // LivingEntity.tick's use: an entry a finished use starts has 20
+            // ticks left when the next tick's packets are handled, as the
+            // guest's own client counts.
+            let play = host.play.entry(conn).or_default();
+            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
+            // the guest (a duration of 0 removes it).
+            for group in play.cooldowns.tick() {
+                host.hub.send_to(
+                    conn,
+                    &C::Cooldown(play::Cooldown {
+                        group: group.to_string(),
+                        duration: 0,
+                    }),
+                );
+            }
             // Player.tick: a different main-hand item resets the attack
             // strength, and detectEquipmentUpdates gives the guest its modifiers.
             let g = &host.hub.guests[gi];
@@ -2183,6 +2210,7 @@ impl Game<'_> {
         let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height());
         let at = g.position;
         let sneaking = g.sneaking;
+        let mut soul = None;
         let events = self.as_guest(host, conn, |game| {
             let (rules, motion) = (game.world.health_rules, game.motion);
             let health = &motion.health;
@@ -2252,6 +2280,7 @@ impl Game<'_> {
             w.player.shift_key_down = sneaking;
             w.player.freeze_immune = freeze_immune;
             let _ = w.server_block_damage(start);
+            let _ = w.update_soul_speed_block();
             let _ = w.tick_environment_damage();
             let _ = w.apply_fire_contact();
             let _ = w.server_hazards_tick(in_wall);
@@ -2279,6 +2308,9 @@ impl Game<'_> {
             // LivingEntity.baseTick: outside the world border, then tickEffects.
             game.border_damage();
             game.tick_mob_effects();
+            // Soul Speed's effects (LivingEntity.baseTick's location_changed
+            // and tick effects); its particle goes to the players around.
+            soul = game.tick_soul_speed();
             let Some(player) = game.player.as_mut() else {
                 return (Vec::new(), None);
             };
@@ -2307,11 +2339,42 @@ impl Game<'_> {
         let Some((events, marked)) = events else {
             return;
         };
+        if let Some((at, velocity)) = soul {
+            super::lan_particles::send_soul_particle(host, at, velocity);
+        }
         self.as_guest(host, conn, |game| game.tick_player_sculk_events());
         for event in events {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
+                // LivingEntity.checkFallDamage: the crumbs reach every player.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(Some(host), state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
+                // HoneyBlock.maybeDoSlideEffects: the sound reaches the
+                // others (Player.playSound excludes the player, whose client
+                // plays it), the entity event 53 everyone around.
+                MotionEvent::HoneySlide {
+                    sound, particles, ..
+                } => {
+                    let Some((id, at)) = host.hub.guest(conn).map(|g| (g.entity_id, g.position))
+                    else {
+                        continue;
+                    };
+                    if sound {
+                        let name = "minecraft:block.honey_block.slide";
+                        let source = horizon_client::settings::sound_source(name) as i32;
+                        self.audio.play_unshared(name, Some(at), 1.0, 1.0);
+                        host.hub.sound(name, at, 1.0, 1.0, source, Some(conn));
+                    }
+                    if particles {
+                        self.honey_slide_particles(at);
+                        host.hub.entity_event(id, 53, at);
+                    }
+                }
                 _ => {}
             }
         }

crates/horizon-client/src/game/lan_entities.rs

@@ -304,6 +304,9 @@ impl Game<'_> {
             None => 0,
         };
         let at = |p: horizon_core::geometry::Vec3| [p.x, p.y, p.z];
+        for f in &self.fangs.list {
+            out.push(state(f.id, "minecraft:evoker_fangs", f.pos, f.yaw, false));
+        }
         // LightningBolt: each client draws and flashes its own.
         for b in self.bolts.iter().filter(|b| b.id != 0) {
             out.push(state(b.id, "minecraft:lightning_bolt", b.at, 0.0, false));
@@ -354,6 +357,20 @@ impl Game<'_> {
                         a.is_some_and(|a| a.in_ground) || p.stuck,
                     ));
                 }
+                // ThrownTrident.ID_LOYALTY (none for a mob's) and ID_FOIL, on
+                // AbstractArrow's flags.
+                K::Trident => {
+                    let a = p.arrow.as_deref();
+                    e.meta.extend(arrow_meta(
+                        false,
+                        a.is_some_and(|a| a.no_physics),
+                        0,
+                        a.is_some_and(|a| a.in_ground) || p.stuck,
+                    ));
+                    if a.is_some_and(|a| a.pickup_item.has_any_enchantments()) {
+                        e.meta.push((12, serializer::BOOLEAN, Value::Bool(true)));
+                    }
+                }
                 // WitherSkull.DATA_DANGEROUS.
                 K::WitherSkull { dangerous: true } => {
                     e.meta.push((8, serializer::BOOLEAN, Value::Bool(true)));

crates/horizon-client/src/game/lan_particles.rs

@@ -1,7 +1,8 @@
 //! Particles a server sends its players and its clients draw:
 //! `ClientboundLevelParticlesPacket` (`ServerLevel.sendParticles`, which
 //! `/particle` uses) and `ClientboundExplodePacket` (`ServerLevel.explode`).
-use super::Game;
+use super::{Game, lan::LanHost};
+use horizon_client::lan::hub::Hub;
 use horizon_client::particles::{ParticleOptions, ParticleType};
 use horizon_core::{geometry::Vec3, random::RandomSource};
 use horizon_protocol::{
@@ -24,6 +25,35 @@ fn rgb(c: [f32; 4]) -> [f32; 3] {
     [c[0], c[1], c[2]]
 }
 
+/// `ServerLevel.sendParticles` of one soul particle moving by `velocity`
+/// (Soul Speed's `spawn_particles`): sent to the players within 32 blocks.
+pub(super) fn send_soul_particle(host: &super::lan::LanHost, at: [f64; 3], velocity: [f64; 3]) {
+    let Some(id) = host
+        .hub
+        .registry_id("minecraft:particle_type", "minecraft:soul")
+    else {
+        return;
+    };
+    let packet = C::LevelParticles(play::LevelParticles {
+        particle: Particle { id, data: None },
+        override_limiter: false,
+        always_show: false,
+        pos: at,
+        dist: velocity.map(|v| v as f32),
+        max_speed: [1.0; 3],
+        count: 0,
+        randomization: 0,
+    });
+    for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+        let distance: f64 = (0..3)
+            .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+            .sum();
+        if distance < 32.0 * 32.0 {
+            g.send(&packet);
+        }
+    }
+}
+
 impl Game<'_> {
     /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point.
     /// Keep the local event's rendering; connected players receive one at rest.
@@ -52,6 +82,66 @@ impl Game<'_> {
         }
     }
 
+    /// `LivingEntity.checkFallDamage`'s `ServerLevel.sendParticles` of the
+    /// landing block's crumbs: drawn in this window, when it has one, and
+    /// sent to each player within 32 blocks. `host` is the hub of a guest's
+    /// turn, which is out of `self.lan` meanwhile.
+    pub(super) fn landing_dust(
+        &mut self,
+        host: Option<&LanHost>,
+        state: BlockStateId,
+        at: Vec3,
+        count: i32,
+        speed: f64,
+    ) {
+        let at = [at.x, at.y, at.z];
+        if self.serving.is_none() && self.options.dedicated.is_none() {
+            let block = [
+                at[0].floor() as i32,
+                (at[1] - 0.2).floor() as i32,
+                at[2].floor() as i32,
+            ];
+            if let Some((sprite, tint)) = self.particle_sprite(state, block) {
+                self.particles.send_particles(
+                    &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                    at,
+                    [0.0; 3],
+                    speed,
+                    count as u32,
+                );
+            }
+        }
+        let Some(hub) = host.or(self.lan.as_ref()).map(|h| &h.hub) else {
+            return;
+        };
+        let Some(particle) = Self::hub_particle(
+            hub,
+            &ParticleOptions::simple(ParticleType::Block),
+            Some(state),
+        ) else {
+            return;
+        };
+        let packet = C::LevelParticles(play::LevelParticles {
+            particle,
+            override_limiter: false,
+            always_show: false,
+            pos: at,
+            dist: [0.0; 3],
+            max_speed: [speed as f32; 3],
+            count,
+            randomization: 0,
+        });
+        for g in hub.guests.iter().filter(|g| hub.here(g)) {
+            // ServerLevel compares the player's block centre, strictly within 32.
+            let distance: f64 = (0..3)
+                .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+                .sum();
+            if distance < 32.0 * 32.0 {
+                g.send(&packet);
+            }
+        }
+    }
+
     /// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's
     /// network id and the data it carries (`state` for the block particles).
     /// None while not serving, or for a particle whose data isn't sent from
@@ -60,13 +150,19 @@ impl Game<'_> {
         &self,
         options: &ParticleOptions,
         state: Option<BlockStateId>,
+    ) -> Option<Particle> {
+        Self::hub_particle(&self.lan.as_ref()?.hub, options, state)
+    }
+
+    /// `network_particle` for a hub that is out of `self.lan` meanwhile (a
+    /// guest's turn).
+    fn hub_particle(
+        hub: &Hub,
+        options: &ParticleOptions,
+        state: Option<BlockStateId>,
     ) -> Option<Particle> {
         let name = format!("minecraft:{}", options.ty.name());
-        let id = self
-            .lan
-            .as_ref()?
-            .hub
-            .registry_id("minecraft:particle_type", &name)?;
+        let id = hub.registry_id("minecraft:particle_type", &name)?;
         use ParticleType as T;
         let c = options.color;
         let data = match options.ty {
@@ -225,8 +321,14 @@ impl Game<'_> {
     /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
     /// sound and the push reach them on their own (the level's sounds, the
     /// motion a hurt player is sent), so the packet carries neither.
-    pub(super) fn lan_explode(&self, center: [f64; 3], radius: f32, block_count: usize) {
-        let emitter = if radius < 2.0 {
+    pub(super) fn lan_explode(
+        &self,
+        center: [f64; 3],
+        small: bool,
+        radius: f32,
+        block_count: usize,
+    ) {
+        let emitter = if small {
             "minecraft:explosion"
         } else {
             "minecraft:explosion_emitter"

crates/horizon-client/src/game/lan_pvp.rs

@@ -37,6 +37,8 @@ pub(super) struct Strike {
     amount: f32,
     scale: f32,
     crit: bool,
+    /// `Player.attack`'s `magicBoost > 0`: the enchantments added damage.
+    magic: bool,
     from: [f64; 3],
     sweep: Option<[f64; 3]>,
     /// `causeExtraKnockback`: its strength and direction (the attacker's
@@ -109,7 +111,7 @@ impl Game<'_> {
     pub(super) fn pvp_strike(&mut self) -> Option<Strike> {
         let p = self.player.as_ref()?;
         let from = [p.position.x, p.position.y, p.position.z];
-        let (amount, scale, crit) = self.melee_damage("minecraft:player");
+        let (amount, scale, crit, magic) = self.melee_damage("minecraft:player");
         let sweep = self.sweep_attack_position(scale, crit);
         let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
         let (xd, zd) = self.extra_knockback_direction();
@@ -125,6 +127,7 @@ impl Game<'_> {
             amount,
             scale,
             crit,
+            magic,
             from,
             sweep,
             knockback: (strength, xd, zd),
@@ -257,7 +260,7 @@ impl Game<'_> {
         } else {
             Default::default()
         };
-        if hurt && s.crit {
+        if hurt && (s.crit || s.magic) {
             let target = match victim {
                 Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
                 Victim::Guest(conn) => host
@@ -267,13 +270,17 @@ impl Game<'_> {
             };
             if let Some((id, p)) = target {
                 let d = p.dimensions;
-                self.critical_hit(
-                    s.attacker,
-                    id,
+                let (feet, width, height) = (
                     [p.position.x, p.position.y, p.position.z],
                     f64::from(d.width),
                     f64::from(d.height),
                 );
+                if s.crit {
+                    self.critical_hit(s.attacker, id, feet, width, height, false);
+                }
+                if s.magic {
+                    self.critical_hit(s.attacker, id, feet, width, height, true);
+                }
             }
         }
         // `Enchantment.doPostAttack`: thorns hurt the attacking player.

crates/horizon-client/src/game/leads.rs

@@ -104,6 +104,9 @@ impl Game<'_> {
             };
             let m = &mut self.mobs[i];
             if let Some(h) = holder {
+                if h == Holder::Player {
+                    m.extra.leash_player = Some(player_uuid);
+                }
                 m.extra.leash = Some(h);
                 m.extra.leash_pending = None;
             } else if m.age > 100 {
@@ -201,7 +204,9 @@ impl Game<'_> {
                 if self.mobs[index].extra.leash.is_some() {
                     self.break_leash(id, true, false);
                 }
+                let holder = self.acting_player_uuid();
                 self.mobs[index].extra.leash = Some(Holder::Player);
+                self.mobs[index].extra.leash_player = Some(holder);
                 self.lead_sound("tied", at);
                 // The lead is always used up.
                 if let Some(stack) = self.held_mut().as_mut() {

crates/horizon-client/src/game/level_particles.rs

@@ -3,6 +3,7 @@
 //! consumable's teleport (2017), electric sparks (3002), waxing (3003), wax
 //! off (3004) and scraping (3005).
 use super::Game;
+use horizon_client::items::ItemStack;
 use horizon_client::particles::{self, ParticleOptions, ParticleType};
 use horizon_core::{position::BlockPos, random::RandomSource};
 use horizon_world::level::LevelEvent;
@@ -12,6 +13,12 @@ impl Game<'_> {
         self.particles
             .block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
     }
+    /// Event 2016: `Shulker.teleportSomewhere`'s particles between the
+    /// shell's old and new cells.
+    pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
+        self.particles
+            .block_teleportation(pos, data, [8, 8, 8], self.settings.particles);
+    }
     /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
     pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
         self.particles
@@ -134,6 +141,92 @@ impl Game<'_> {
         // Each guest plays it from the global packet.
         self.audio.play_unshared(sound, at, volume, 1.0);
     }
+    /// `ClientLevel.addBreakingBlockEffects`: the block's hit sound (only for
+    /// `play_sound`) and one crumb on the face being mined; nothing for air.
+    pub(super) fn breaking_block_effects(
+        &mut self,
+        pos: [i32; 3],
+        face: [i32; 3],
+        play_sound: bool,
+    ) {
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if self.res.facts().is_air(state) {
+            return;
+        }
+        if play_sound {
+            let sounds = self.res.facts().get(state).sounds.clone();
+            // Each guest plays it from the level event itself.
+            self.audio.play_unshared(
+                &sounds.hit,
+                Some(pos.map(|v| f64::from(v) + 0.5)),
+                (sounds.volume + 1.0) / 8.0,
+                sounds.pitch * 0.5,
+            );
+        }
+        self.crack_particle(pos, face, state);
+    }
+    /// `LevelEventHandler.potionSplashParticles` (2002 with `Effect`, 2007
+    /// with `InstantEffect`): eight splash potion crumbs, and a hundred
+    /// spell particles in the potion's colour `data`, flung out in a disc.
+    pub(super) fn potion_splash_particles(&mut self, pos: BlockPos, data: i32, instant: bool) {
+        let ty = if instant {
+            ParticleType::InstantEffect
+        } else {
+            ParticleType::Effect
+        };
+        // Vec3.atBottomCenterOf.
+        let at = [
+            f64::from(pos.x) + 0.5,
+            f64::from(pos.y),
+            f64::from(pos.z) + 0.5,
+        ];
+        let crumb = self.item_particle(&ItemStack::new("minecraft:splash_potion", 1));
+        let r = self.particles.level_random();
+        let crumbs: Vec<[f64; 3]> = (0..8)
+            .map(|_| {
+                [
+                    r.next_gaussian() * 0.15,
+                    r.next_double() * 0.2,
+                    r.next_gaussian() * 0.15,
+                ]
+            })
+            .collect();
+        for v in crumbs {
+            self.particles.add(&crumb, at, v);
+        }
+        let channel = |shift: i32| ((data >> shift) & 0xFF) as f32 / 255.0;
+        let color = [channel(16), channel(8), channel(0)];
+        for _ in 0..100 {
+            let r = self.particles.level_random();
+            let dist = r.next_double() * 4.0;
+            let angle = r.next_double() * std::f64::consts::PI * 2.0;
+            let velocity = [
+                angle.cos() * dist,
+                0.01 + r.next_double() * 0.5,
+                angle.sin() * dist,
+            ];
+            let brightness = 0.75 + r.next_float() * 0.25;
+            let options = ParticleOptions {
+                color: [
+                    color[0] * brightness,
+                    color[1] * brightness,
+                    color[2] * brightness,
+                    1.0,
+                ],
+                scale: dist as f32,
+                ..ParticleOptions::simple(ty)
+            };
+            self.particles.add(
+                &options,
+                [
+                    at[0] + velocity[0] * 0.1,
+                    at[1] + 0.3,
+                    at[2] + velocity[2] * 0.1,
+                ],
+                velocity,
+            );
+        }
+    }
     /// Queue and play level event `id` at `pos` (`Level.levelEvent`).
     pub(super) fn level_event_at(&mut self, id: i32, pos: [i32; 3], data: i32) {
         self.level_events.push(LevelEvent::LevelEvent {

crates/horizon-client/src/game/levels.rs

@@ -75,7 +75,7 @@ pub(super) struct Parked {
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Only the per-level parts of these are used (`swap_level`).
     anims: BlockEntityAnims,
     raiding: Raiding,
@@ -109,6 +109,19 @@ pub(super) struct Levels {
     parked: HashMap<Dim, Parked>,
 }
 
+impl Levels {
+    /// The chunks of each level not in place (capability `world` lends
+    /// them to server mods for a call).
+    #[cfg_attr(not(feature = "mods"), allow(dead_code))]
+    pub(super) fn parked_chunks(
+        &mut self,
+    ) -> impl Iterator<Item = (Dim, &mut horizon_client::chunk_map::ChunkMap)> {
+        self.parked
+            .iter_mut()
+            .map(|(d, p)| (*d, &mut p.world.chunks))
+    }
+}
+
 impl Game<'_> {
     /// A new level for `dim`, opened from the save (`MinecraftServer.createLevels`).
     fn open_level(&self, dim: Dim) -> Result<Parked> {
@@ -179,6 +192,7 @@ impl Game<'_> {
         let mut locator = self.end.locator();
         swap(&mut locator, &mut p.locator);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         swap(&mut self.save, &mut p.save);
         swap(&mut self.block_ticks, &mut p.block_ticks);
         swap(&mut self.tick_chunks, &mut p.tick_chunks);
@@ -314,6 +328,8 @@ impl Game<'_> {
             };
             self.update_dedicated_streaming();
             self.update_world();
+            // What server mods set in this level since its last tick.
+            self.apply_mod_block_writes();
             result = if paused {
                 self.tick_lan(true);
                 Ok(())
@@ -384,7 +400,8 @@ impl Game<'_> {
         }
         *next += self.clock.tick_duration();
         if *next > now {
-            // A `/pregen` task keeps the workers fed until the next tick.
+            // A `/pregen` task or force-loaded chunks keep the workers fed
+            // until the next tick.
             self.pump_pregen(*next);
             let now = Instant::now();
             if *next > now {

crates/horizon-client/src/game/minecarts.rs

@@ -90,6 +90,8 @@ pub(super) struct Minecart {
     /// Chest minecarts: the loot table rolled into `items` on load, saved
     /// again while the items are still that roll.
     pub loot: Option<horizon_client::save::RolledLoot>,
+    /// `Entity.firstTick`: not ticked yet (saved as `HasTicked`).
+    pub first_tick: bool,
 }
 pub(super) const WIDTH: f64 = 0.98;
 pub(super) const HEIGHT: f64 = 0.7;
@@ -186,6 +188,7 @@ impl Minecart {
             fuse: -1,
             enabled: true,
             loot: None,
+            first_tick: true,
         }
     }
     pub fn bounds(&self) -> Aabb {
@@ -536,6 +539,7 @@ impl Game<'_> {
     }
     /// `AbstractMinecart.tick` for one cart; returns false once it is gone.
     fn tick_cart(&mut self, c: &mut Minecart, intent: [f64; 2]) -> bool {
+        c.first_tick = false;
         c.previous = c.position;
         c.previous_yaw = c.yaw;
         c.hurt_time = (c.hurt_time - 1).max(0);
@@ -1340,9 +1344,8 @@ impl Game<'_> {
             return;
         };
         // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's mean
-        // edge, scaled by the entity distance option.
-        let range =
-            (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // edge, scaled by the view scale.
+        let range = (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * self.view_scale();
         for c in &self.carts {
             let entity_start = out.len();
             let Some(model) = self.cart_models.models.get(&c.kind) else {
@@ -1509,6 +1512,10 @@ impl Minecart {
                 map.insert(JavaString::from(k), v);
             };
             put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
+            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
+            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
+            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
+            put("Fire", Tag::Short(0));
             match self.kind {
                 CartKind::Chest | CartKind::Hopper => {
                     put("Items", horizon_client::save::encode_items(&self.items));
@@ -1558,6 +1565,7 @@ impl Minecart {
             _ => 0.0,
         };
         c.flipped = int("FlippedRotation").unwrap_or(0) != 0;
+        c.first_tick = int("HasTicked").unwrap_or(0) != 0;
         if kind.slots() > 0 {
             c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
         }
@@ -1582,4 +1590,30 @@ mod tests {
         assert_eq!(display_offset(CartKind::CommandBlock), 6.0);
         assert_eq!(display_offset(CartKind::Rideable), 6.0);
     }
+
+    #[test]
+    fn a_cart_saves_as_never_ticked_until_it_ticks() {
+        use horizon_world::nbt::Tag;
+        let generated = Tag::compound([
+            ("id", Tag::String("minecraft:chest_minecart".into())),
+            (
+                "Pos",
+                Tag::List(
+                    [0.5f64, 40.5, 0.5]
+                        .map(|v| Tag::Double(v.to_bits()))
+                        .to_vec(),
+                ),
+            ),
+            ("HasTicked", Tag::Byte(1)),
+            ("Fire", Tag::Short(0)),
+        ]);
+        let mut cart = Minecart::from_nbt(&generated, 1, CartKind::Chest).unwrap();
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(1)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+        cart.first_tick = false;
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(0)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+    }
 }

crates/horizon-client/src/game/mob_blocks.rs

@@ -1,6 +1,7 @@
 //! Blocks mobs carry: block items in a hand (`ItemInHandLayer`) and the
 //! block an enderman holds (`CarriedBlockLayer`), drawn as shaded cubes like
-//! dropped block items.
+//! dropped block items. Also the block models mobs wear (`SnowGolemHeadLayer`,
+//! `MushroomCowMushroomLayer`).
 use super::Game;
 use horizon_client::{
     items::ItemStack,
@@ -218,6 +219,7 @@ impl Game<'_> {
     ) {
         self.captain_banner_geometry(mob, camera, alpha, light, out);
         self.held_item_geometry(mob, camera, alpha, light, true, out);
+        self.worn_block_geometry(mob, camera, alpha, light, out);
         if mob.species() == Species::Enderman
             && let Some(state) = mob.extra.carried
             && let Some((sprite, tint)) = self.block_face_sprite(state)
@@ -244,6 +246,76 @@ impl Game<'_> {
             );
         }
     }
+    /// `SnowGolemHeadLayer` and `MushroomCowMushroomLayer`: the carved pumpkin
+    /// on a snow golem's head, and the mushrooms on an adult mooshroom's back
+    /// and head, as baked block models.
+    fn worn_block_geometry(
+        &self,
+        mob: &Mob,
+        camera: glam::DVec3,
+        alpha: f64,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        use glam::{Mat4, Vec3};
+        let species = mob.species();
+        let on_head = match species {
+            Species::SnowGolem => !mob.extra.sheared,
+            Species::Mooshroom => !mob.is_baby(),
+            _ => false,
+        };
+        // The layers draw nothing on an invisible mob (the glow outline is not drawn).
+        if !on_head || horizon_client::mobs::trader::is_invisible(mob) {
+            return;
+        }
+        let registry = &self.pack.assets.registry;
+        let block = match species {
+            Species::SnowGolem => "minecraft:carved_pumpkin",
+            _ if mob.extra.variant == 1 => "minecraft:brown_mushroom",
+            _ => "minecraft:red_mushroom",
+        };
+        let Some(state) = registry.default_state(block) else {
+            return;
+        };
+        let alpha = alpha as f32;
+        let Some(head) = render::part_transform(mob, alpha, camera, self.res.mob_data(), "head")
+        else {
+            return;
+        };
+        let unit = Mat4::from_translation(Vec3::splat(-0.5));
+        let flip = Mat4::from_scale(Vec3::new(-1.0, -1.0, 1.0));
+        let at = |x: f32, y: f32, z: f32| Mat4::from_translation(Vec3::new(x, y, z));
+        let spin = |degrees: f32| Mat4::from_rotation_y(degrees.to_radians());
+        let transforms = if species == Species::SnowGolem {
+            vec![
+                head * at(0.0, -0.34375, 0.0)
+                    * spin(180.0)
+                    * Mat4::from_scale(Vec3::new(0.625, -0.625, -0.625))
+                    * unit,
+            ]
+        } else {
+            let base = render::base_transform(mob, alpha, camera);
+            vec![
+                base * at(0.2, -0.35, 0.5) * spin(-48.0) * flip * unit,
+                base * at(0.2, -0.35, 0.5)
+                    * spin(42.0)
+                    * at(0.1, 0.0, -0.6)
+                    * spin(-48.0)
+                    * flip
+                    * unit,
+                head * at(0.0, -0.7, -0.2) * spin(-78.0) * flip * unit,
+            ]
+        };
+        // The hurt tint reaches these blocks as it does the body.
+        let overlay = horizon_client::overlay::living(0.0, mob.hurt_time > 0 || mob.death_time > 0);
+        for t in transforms {
+            let start = out.len();
+            self.block_model_vertices(state, 0, t, light, true, out);
+            for vertex in &mut out[start..] {
+                vertex.layer = overlay;
+            }
+        }
+    }
     /// `ItemInHandLayer`: both hands through the item model pipeline; `lit`
     /// applies the level's diffuse lighting (off for GUI previews, which
     /// light the projected quads themselves).

crates/horizon-client/src/game/mod_browser.rs

@@ -0,0 +1,485 @@
+//! Capability `ui`'s panel beside container screens (WIT `interface
+//! browser`, docs/mods.md): the items a recipe viewer mod lists, drawn as
+//! the game's own item slots in pages right of the screen's window, with a
+//! search box under them. The mod says what the panel holds; the game pages
+//! it and tells the mod what the player clicked, typed, and which of the
+//! mod's keys went down over an item. With no mod showing a panel, each
+//! hook here returns after one check.
+use super::Game;
+#[cfg(feature = "mods")]
+use {
+    super::Screen,
+    horizon_client::{
+        hud::{HudBatch, rgba},
+        items::ItemStack,
+        ui::EditBox,
+    },
+    horizon_mods::{BrowserClick, BrowserEvent, BrowserStack},
+};
+
+#[cfg(not(feature = "mods"))]
+impl Game<'_> {
+    pub(super) fn draw_mod_browser(&mut self, _batch: &mut horizon_client::hud::HudBatch) {}
+    pub(super) fn mod_browser_press(&mut self, _right: bool) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_key(&mut self, _event: &winit::event::KeyEvent) {}
+    pub(super) fn mod_browser_text(&mut self, _text: Option<&str>, _backspace: bool) {}
+    pub(super) fn mod_browser_closed(&mut self) {}
+}
+
+/// One slot of the panel, in GUI pixels.
+#[cfg(feature = "mods")]
+const SLOT: f32 = 18.0;
+/// The most columns the panel takes, and the fewest it shows with.
+#[cfg(feature = "mods")]
+const COLUMNS: (usize, usize) = (12, 2);
+/// The gap between the window and the panel, and the screen's edges.
+#[cfg(feature = "mods")]
+const MARGIN: f32 = 8.0;
+
+/// The panel's state in the game.
+#[cfg(feature = "mods")]
+#[derive(Default)]
+pub(super) struct Browser {
+    /// The items' owner and version they were made from.
+    of: Option<(usize, u64)>,
+    /// The mod's items as stacks; `None` for an item the game doesn't have.
+    stacks: Vec<Option<ItemStack>>,
+    page: usize,
+    search: Option<EditBox>,
+    /// The search text the mod last heard.
+    sent: String,
+    /// `set-recipes`' recipes, shown instead of the items.
+    pub(super) recipes: Option<super::mod_browser_recipes::Pages>,
+}
+
+/// Where the panel's parts are this frame.
+#[cfg(feature = "mods")]
+pub(super) struct Layout {
+    /// The panel's whole area, for clicks that hit none of its parts.
+    pub(super) area: [f32; 4],
+    /// The grid's top left corner, its columns and rows.
+    pub(super) grid: (f32, f32),
+    pub(super) columns: usize,
+    pub(super) rows: usize,
+    /// The page arrows' row.
+    pub(super) arrows_y: f32,
+    pub(super) search: [f32; 4],
+}
+#[cfg(feature = "mods")]
+impl Layout {
+    fn per_page(&self) -> usize {
+        self.columns * self.rows
+    }
+    pub(super) fn width(&self) -> f32 {
+        self.columns as f32 * SLOT
+    }
+    fn slot(&self, n: usize) -> (f32, f32) {
+        (
+            self.grid.0 + (n % self.columns) as f32 * SLOT,
+            self.grid.1 + (n / self.columns) as f32 * SLOT,
+        )
+    }
+    /// The page arrows: backward, then forward.
+    pub(super) fn arrows(&self) -> [(f32, f32); 2] {
+        [
+            (self.grid.0, self.arrows_y),
+            (self.grid.0 + self.width() - 12.0, self.arrows_y),
+        ]
+    }
+}
+
+#[cfg(feature = "mods")]
+pub(super) fn inside(p: (f32, f32), [x, y, w, h]: [f32; 4]) -> bool {
+    p.0 >= x && p.1 >= y && p.0 < x + w && p.1 < y + h
+}
+
+#[cfg(feature = "mods")]
+impl Game<'_> {
+    fn browser_batch(&self) -> Option<HudBatch> {
+        let r = self.renderer.as_ref()?;
+        Some(HudBatch::new([r.config.width, r.config.height]))
+    }
+    /// The mod showing a panel, with its items made into stacks once per
+    /// `set-items`; none while no mod shows one or no container screen is up.
+    fn browser_sync(&mut self) -> Option<usize> {
+        if self.screen != Screen::Inventory || self.title.is_some() {
+            return None;
+        }
+        let Some((owner, version)) = self.mods.mods.browser_items().map(|(o, v, _)| (o, v)) else {
+            self.mods.browser.of = None;
+            self.mods.browser.stacks.clear();
+            return None;
+        };
+        if self.mods.browser.of != Some((owner, version)) {
+            let items = self.res.items();
+            let stacks = self
+                .mods
+                .mods
+                .browser_items()
+                .map_or_else(Vec::new, |(_, _, list)| {
+                    list.iter().map(|s| browser_stack(items, s)).collect()
+                });
+            self.mods.browser.stacks = stacks;
+            // The same title again (the mod updating its buttons) keeps the page.
+            let old = self.mods.browser.recipes.take();
+            self.mods.browser.recipes = self
+                .mods
+                .mods
+                .browser_recipes(owner)
+                .map(|shown| super::mod_browser_recipes::Pages::new(items, shown, old));
+            self.mods.browser.of = Some((owner, version));
+        }
+        Some(owner)
+    }
+    /// The panel's parts: right of the window, from the top of the screen to
+    /// the search box at its foot. None when the screen has no room for it.
+    fn browser_layout(&self, batch: &HudBatch) -> Option<Layout> {
+        let image = self.container_image(batch);
+        let left = (image.left + image.width) as f32 + MARGIN;
+        let right = batch.width - MARGIN;
+        let columns = (((right - left) / SLOT).floor().max(0.0) as usize).min(COLUMNS.0);
+        if columns < COLUMNS.1 {
+            return None;
+        }
+        let x = (left + (right - left - columns as f32 * SLOT) / 2.0).floor();
+        let arrows_y = MARGIN;
+        let top = arrows_y + 17.0 + 4.0;
+        let search = [x, batch.height - MARGIN - 16.0, columns as f32 * SLOT, 16.0];
+        let rows = ((search[1] - 4.0 - top) / SLOT).floor().max(0.0) as usize;
+        (rows > 0).then_some(Layout {
+            area: [left, 0.0, right - left, batch.height],
+            grid: (x, top),
+            columns,
+            rows,
+            arrows_y,
+            search,
+        })
+    }
+    fn browser_pages(&self, layout: &Layout) -> usize {
+        self.mods
+            .browser
+            .stacks
+            .len()
+            .div_ceil(layout.per_page())
+            .max(1)
+    }
+    /// The stack under the pointer on the panel, an item's or a recipe's,
+    /// as the mod sent it and as a stack.
+    fn browser_pointed_stack(&self, layout: &Layout) -> Option<(BrowserStack, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            if let Some((_, sent, stack)) = self.recipe_tab_hovered(layout) {
+                return Some((sent, stack));
+            }
+            let (_, _, sent, stack) = self.recipe_slot_hovered(layout)?;
+            return Some((sent, stack));
+        }
+        let (index, stack) = self.browser_hovered(layout)?;
+        let (_, _, items) = self.mods.mods.browser_items()?;
+        Some((items.get(index)?.clone(), stack))
+    }
+    /// The panel's item under the pointer: its index and stack.
+    fn browser_hovered(&self, layout: &Layout) -> Option<(usize, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            return None;
+        }
+        let first = self.mods.browser.page * layout.per_page();
+        (0..layout.per_page()).find_map(|n| {
+            let (x, y) = layout.slot(n);
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let stack = self.mods.browser.stacks.get(first + n)?.clone()?;
+            Some((first + n, stack))
+        })
+    }
+    fn browser_search(&mut self, layout: &Layout) -> &mut EditBox {
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit.focused = false;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        search
+    }
+
+    /// The items' page arrows and grid.
+    fn draw_browser_items(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let pages = self.browser_pages(layout);
+        self.mods.browser.page = self.mods.browser.page.min(pages - 1);
+        let page = self.mods.browser.page;
+        let cursor = self.cursor;
+        if pages > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let shown = [page > 0, page + 1 < pages];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, shown)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(shown))
+            {
+                if !shown {
+                    continue;
+                }
+                let hover = inside(cursor, [x, y, 12.0, 17.0]);
+                let suffix = if hover { "_highlighted" } else { "" };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        let first = page * layout.per_page();
+        for n in 0..layout.per_page() {
+            let Some(stack) = self.mods.browser.stacks.get(first + n) else {
+                break;
+            };
+            let Some(stack) = stack.clone() else {
+                continue;
+            };
+            let (x, y) = layout.slot(n);
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            let rect = [x + 1.0, y + 1.0, 16.0, 16.0];
+            if inside(cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &name,
+                rect,
+                true,
+                horizon_client::widgets::Kind::Button,
+            );
+        }
+    }
+    /// Draws the panel over the open container screen, then the carried
+    /// stack or the tooltip again so they stay on top of it.
+    pub(super) fn draw_mod_browser(&mut self, batch: &mut HudBatch) {
+        if self.browser_sync().is_none() {
+            return;
+        }
+        let Some(layout) = self.browser_layout(batch) else {
+            return;
+        };
+        let cursor = self.cursor;
+        if self.mods.browser.recipes.is_some() {
+            self.draw_browser_recipes(batch, &layout);
+        } else {
+            self.draw_browser_items(batch, &layout);
+        }
+        let hint = self.translate("gui.recipebook.search_hint", "Search...");
+        let search = self.browser_search(&layout);
+        // The hint shows in an empty box without focus, as the recipe book's.
+        search.suggestion = (search.value.is_empty() && !search.focused).then_some(hint);
+        let mut search = search.clone();
+        search.draw(batch, &self.gui.atlas, None);
+        self.mods.browser.search = Some(search);
+        if self.carried.is_some() {
+            self.draw_carried(batch);
+        } else if let Some(stack) = self.browser_pointed_stack(&layout) {
+            let lines = self.stack_tooltip(&stack.1);
+            self.draw_tooltip_lines(batch, &lines, cursor.0, cursor.1);
+        } else {
+            self.draw_slot_tooltip(batch);
+        }
+    }
+
+    /// A mouse press on a container screen: true when the panel took it
+    /// (its search box, page arrows, items or empty space; a click there
+    /// never throws the carried stack).
+    pub(super) fn mod_browser_press(&mut self, right: bool) -> bool {
+        let Some(owner) = self.browser_sync() else {
+            return false;
+        };
+        let Some(batch) = self.browser_batch() else {
+            return false;
+        };
+        let Some(layout) = self.browser_layout(&batch) else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let shift = self.has_shift_down();
+        let atlas = &self.gui.atlas;
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        if inside(cursor, layout.search) {
+            search.focused = true;
+            search.click(atlas, cursor.0, shift, false);
+            search.reset_blink();
+            return true;
+        }
+        search.focused = false;
+        if self.mods.browser.recipes.is_some() {
+            return self.browser_recipes_press(&layout, owner, right)
+                || inside(cursor, layout.area);
+        }
+        let pages = self.browser_pages(&layout);
+        let page = self.mods.browser.page;
+        let [back, forward] = layout.arrows();
+        let step = if pages > 1 && page > 0 && inside(cursor, [back.0, back.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if pages > 1
+            && page + 1 < pages
+            && inside(cursor, [forward.0, forward.1, 12.0, 17.0])
+        {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = step {
+            self.mods.browser.page = to;
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            return true;
+        }
+        if let Some((index, _)) = self.browser_hovered(&layout) {
+            let event = BrowserEvent::Clicked(BrowserClick {
+                index: index as u32,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        inside(cursor, layout.area)
+    }
+
+    /// Whether keys go to the panel's search box.
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        self.screen == Screen::Inventory
+            && self.mods.browser.of.is_some()
+            && self.mods.browser.search.as_ref().is_some_and(|s| s.focused)
+    }
+    /// A key press while the search box has focus.
+    pub(super) fn mod_browser_key(&mut self, event: &winit::event::KeyEvent) {
+        use winit::keyboard::PhysicalKey;
+        let shortcut = self.edit_shortcut(event);
+        let ctrl = self.has_control_down();
+        let shift = self.has_shift_down();
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if let Some(shortcut) = shortcut {
+            search.shortcut(shortcut, &mut self.clipboard);
+        } else {
+            let handled = match event.physical_key {
+                PhysicalKey::Code(code) => search.key(code, ctrl, shift),
+                _ => false,
+            };
+            if !handled
+                && !ctrl
+                && let Some(text) = &event.text
+            {
+                let text: String = text.chars().filter(|c| !c.is_control()).collect();
+                search.insert_text(&text);
+            }
+        }
+        search.reset_blink();
+        self.browser_searched();
+    }
+    /// Text typed (or one backspace) into the search box (`horizon-ctl type`).
+    pub(super) fn mod_browser_text(&mut self, text: Option<&str>, backspace: bool) {
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if backspace {
+            search.delete_chars(-1);
+        } else if let Some(text) = text {
+            search.insert_text(text);
+        }
+        self.browser_searched();
+    }
+    /// The mod hears the search text when it changed.
+    fn browser_searched(&mut self) {
+        let (Some((owner, _)), Some(search)) = (self.mods.browser.of, &self.mods.browser.search)
+        else {
+            return;
+        };
+        if search.value != self.mods.browser.sent {
+            let value = search.value.clone();
+            self.mods.browser.sent.clone_from(&value);
+            self.mods.browser.page = 0;
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Search(value));
+        }
+    }
+    /// The container screen closed: the search box lets go of the keys.
+    pub(super) fn mod_browser_closed(&mut self) {
+        if let Some(search) = self.mods.browser.search.as_mut() {
+            search.focused = false;
+        }
+    }
+    /// The item under the pointer on a container screen, for the mods' keys
+    /// (`browser`'s `key` event): the panel's, else a slot's.
+    pub(super) fn mod_browser_pointed(&mut self) -> Option<BrowserStack> {
+        let batch = self.browser_batch()?;
+        let stack = match self
+            .browser_sync()
+            .and_then(|_| self.browser_layout(&batch))
+        {
+            // The panel's stacks as the mod sent them.
+            Some(layout) if inside(self.cursor, layout.area) => {
+                return Some(self.browser_pointed_stack(&layout)?.0);
+            }
+            _ => {
+                let slot = self.slot_at(&batch, self.cursor.0, self.cursor.1)?;
+                self.slot_view(slot)?
+            }
+        };
+        Some(BrowserStack {
+            item: stack.item.to_string(),
+            count: stack.count,
+            components: super::mod_recipes::components(&stack),
+        })
+    }
+}
+
+/// A mod's item as a stack: an item the game has, its components read as
+/// `/give` reads them (ones it can't read are left out).
+#[cfg(feature = "mods")]
+pub(super) fn browser_stack(
+    items: &horizon_client::items::Items,
+    s: &BrowserStack,
+) -> Option<ItemStack> {
+    items.get(&s.item)?;
+    let (damage, extra) = if s.components.is_empty() {
+        (0, None)
+    } else {
+        horizon_client::item_data::command_components(&s.components).map_or((0, None), |tag| {
+            horizon_client::item_data::decode_components(Some(&tag))
+        })
+    };
+    Some(ItemStack {
+        item: s.item.as_str().into(),
+        count: s.count.clamp(1, 99),
+        damage,
+        extra,
+    })
+}

crates/horizon-client/src/game/mod_browser_recipes.rs

@@ -0,0 +1,523 @@
+//! `browser.set-recipes` (docs/mods.md): a mod's recipes shown in its item
+//! panel's place, laid out by the game with its own slots, arrows and
+//! buttons, paged to the panel's height, under a title and a back button.
+//! The mod hears clicks on their slots, their action buttons, the back
+//! button and page turns.
+use super::{
+    Game,
+    mod_browser::{Layout, browser_stack, inside},
+};
+use horizon_client::{
+    hud::{HudBatch, rgba},
+    items::ItemStack,
+};
+use horizon_mods::{BrowserEvent, BrowserLayout, BrowserSlotClick, BrowserStack, RecipePage};
+use std::time::Instant;
+
+const SLOT: f32 = 18.0;
+/// The title row's height, and the gap under each recipe.
+const TITLE: f32 = 18.0;
+/// A tab's step: an 18 px slot and a gap.
+const TAB: f32 = 20.0;
+const GAP: f32 = 6.0;
+
+/// One recipe as the game draws it.
+pub(super) struct Shown {
+    layout: BrowserLayout,
+    width: usize,
+    height: usize,
+    /// Each slot's stacks (the result last), as the mod sent them and as
+    /// stacks; a stack the game doesn't have is left out of the cycle.
+    slots: Vec<Vec<(BrowserStack, ItemStack)>>,
+    note: String,
+    action: Option<bool>,
+}
+
+/// The recipes a panel shows, and its page.
+pub(super) struct Pages {
+    title: String,
+    /// The tabs' icons and the selected one.
+    tabs: Vec<(BrowserStack, Option<ItemStack>)>,
+    tab: usize,
+    recipes: Vec<Shown>,
+    page: usize,
+    since: Instant,
+}
+
+impl Pages {
+    pub(super) fn new(
+        items: &horizon_client::items::Items,
+        shown: &RecipePage,
+        old: Option<Pages>,
+    ) -> Self {
+        let (title, list, tab) = (&shown.title, &shown.recipes, shown.tab as usize);
+        let kept = old.filter(|o| o.title == *title && o.tab == tab);
+        let cycle = |stacks: &[BrowserStack]| -> Vec<(BrowserStack, ItemStack)> {
+            stacks
+                .iter()
+                .filter_map(|s| Some((s.clone(), browser_stack(items, s)?)))
+                .collect()
+        };
+        let recipes = list
+            .iter()
+            .map(|r| {
+                let mut slots: Vec<_> = r.slots.iter().map(|s| cycle(s)).collect();
+                slots.push(cycle(&r.results));
+                Shown {
+                    layout: r.layout,
+                    width: r.width as usize,
+                    height: r.height as usize,
+                    slots,
+                    note: r.note.clone(),
+                    action: r.action,
+                }
+            })
+            .collect();
+        Self {
+            title: title.clone(),
+            tabs: shown
+                .tabs
+                .iter()
+                .map(|t| (t.clone(), browser_stack(items, t)))
+                .collect(),
+            tab,
+            recipes,
+            page: kept.as_ref().map_or(0, |o| o.page),
+            since: kept.map_or_else(Instant::now, |o| o.since),
+        }
+    }
+}
+
+impl Shown {
+    /// The inputs' block: its size and each input slot's place in it.
+    fn inputs(&self) -> ((f32, f32), Vec<(f32, f32)>) {
+        let row = |n: usize| (0..n).map(|i| (i as f32 * SLOT, 0.0)).collect();
+        match self.layout {
+            BrowserLayout::Grid => {
+                let (w, h) = (self.width.max(1), self.height.max(1));
+                let at = (0..w * h)
+                    .map(|i| ((i % w) as f32 * SLOT, (i / w) as f32 * SLOT))
+                    .collect();
+                ((w as f32 * SLOT, h as f32 * SLOT), at)
+            }
+            // The input over the flame.
+            BrowserLayout::Cooking => ((SLOT, 2.0 * SLOT), vec![(0.0, 0.0)]),
+            BrowserLayout::Single => ((SLOT, SLOT), row(1)),
+            BrowserLayout::Smithing => ((3.0 * SLOT, SLOT), row(3)),
+            BrowserLayout::Brewing => ((2.0 * SLOT, SLOT), row(2)),
+        }
+    }
+    /// The height of its slots, arrow and button, `room` wide.
+    fn block(&self, room: f32) -> f32 {
+        let h = self.inputs().0.1;
+        let (_, _, action) = self.places(room);
+        match self.action {
+            Some(_) => h.max(action.1 + 12.0),
+            None => h,
+        }
+    }
+    fn height(&self, room: f32) -> f32 {
+        let note = if self.note.is_empty() { 0.0 } else { 11.0 };
+        self.block(room) + note + GAP
+    }
+    /// Every slot's place from the recipe's corner (the result last), the
+    /// arrow's and the action button's: beside the result, or under it
+    /// when the panel is `room` wide and that doesn't fit.
+    fn places(&self, room: f32) -> (Vec<(f32, f32)>, (f32, f32), (f32, f32)) {
+        let ((w, h), mut at) = self.inputs();
+        // The mod's slots beyond the layout's are not shown.
+        at.truncate(self.slots.len() - 1);
+        let arrow = (w + 4.0, ((h - 16.0) / 2.0).floor());
+        let result = (w + 32.0, ((h - SLOT) / 2.0).floor());
+        let action = if result.0 + SLOT + 16.0 <= room {
+            (result.0 + SLOT + 4.0, ((h - 12.0) / 2.0).floor())
+        } else {
+            (result.0 + 3.0, result.1 + SLOT + 2.0)
+        };
+        while at.len() < self.slots.len() - 1 {
+            at.push((f32::NAN, f32::NAN));
+        }
+        at.push(result);
+        (at, arrow, action)
+    }
+}
+
+/// The tabs' places, in rows under the title row.
+fn tab_places(pages: &Pages, layout: &Layout) -> Vec<(f32, f32)> {
+    let per_row = ((layout.width() / TAB).floor() as usize).max(1);
+    (0..pages.tabs.len())
+        .map(|i| {
+            (
+                layout.grid.0 + (i % per_row) as f32 * TAB,
+                layout.grid.1 + TITLE + 3.0 + (i / per_row) as f32 * TAB,
+            )
+        })
+        .collect()
+}
+/// Where the recipes start: under the title row and the tabs.
+fn recipes_top(pages: &Pages, layout: &Layout) -> f32 {
+    let tabs = tab_places(pages, layout);
+    tabs.last()
+        .map_or(layout.grid.1 + TITLE, |&(_, y)| y + TAB + 3.0)
+}
+
+impl Game<'_> {
+    /// The first recipe of each page, filling the panel from the tabs to
+    /// the search box.
+    fn recipe_pages(pages: &Pages, layout: &Layout) -> Vec<usize> {
+        let room = layout.search[1] - 4.0 - recipes_top(pages, layout);
+        let mut starts = vec![0];
+        let mut used = 0.0;
+        for (i, r) in pages.recipes.iter().enumerate() {
+            let h = r.height(layout.width());
+            if used > 0.0 && used + h > room {
+                starts.push(i);
+                used = 0.0;
+            }
+            used += h;
+        }
+        starts
+    }
+    /// The recipes on the open page, each with its corner.
+    fn recipes_shown(&self, layout: &Layout) -> Vec<(usize, (f32, f32))> {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return Vec::new();
+        };
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let end = starts.get(page + 1).copied().unwrap_or(pages.recipes.len());
+        let mut y = recipes_top(pages, layout);
+        (starts[page]..end)
+            .map(|i| {
+                let at = (layout.grid.0, y);
+                y += pages.recipes[i].height(layout.width());
+                (i, at)
+            })
+            .collect()
+    }
+    fn back_button(&self, layout: &Layout) -> ([f32; 4], String) {
+        let label = self.translate("gui.back", "Back");
+        let w = HudBatch::text_width(&self.gui.atlas, &label) + 8.0;
+        ([layout.grid.0, layout.grid.1, w, 14.0], label)
+    }
+    /// What a slot of a shown recipe holds now: its stacks cycle once a second.
+    fn recipe_slot_now(&self, recipe: usize, slot: usize) -> Option<&(BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let stacks = pages.recipes.get(recipe)?.slots.get(slot)?;
+        let n = pages.since.elapsed().as_secs() as usize;
+        stacks.get(n % stacks.len().max(1))
+    }
+    /// The tab under the pointer: its index and icon.
+    pub(super) fn recipe_tab_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let places = tab_places(pages, layout);
+        places.iter().enumerate().find_map(|(i, &(x, y))| {
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let (sent, stack) = pages.tabs.get(i)?;
+            Some((i, sent.clone(), stack.clone()?))
+        })
+    }
+    /// The recipe slot under the pointer: recipe, slot, and its stack now.
+    pub(super) fn recipe_slot_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        self.recipes_shown(layout)
+            .into_iter()
+            .find_map(|(i, (x, y))| {
+                let (at, _, _) = pages.recipes[i].places(layout.width());
+                at.iter().enumerate().find_map(|(k, &(sx, sy))| {
+                    if !inside(self.cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                        return None;
+                    }
+                    let (mod_stack, stack) = self.recipe_slot_now(i, k)?.clone();
+                    Some((i, k, mod_stack, stack))
+                })
+            })
+    }
+
+    /// Draws the title row, the page's recipes and the page arrows.
+    pub(super) fn draw_browser_recipes(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let (title, pages_n) = (pages.title.clone(), starts.len());
+        let (back, label) = self.back_button(layout);
+        let atlas = &self.gui.atlas;
+        let hover = inside(cursor, back);
+        let sprite = if hover {
+            "gui/sprites/widget/button_highlighted"
+        } else {
+            "gui/sprites/widget/button"
+        };
+        horizon_client::ui::nine_slice(
+            batch,
+            atlas,
+            sprite,
+            back[0],
+            back[1],
+            back[2],
+            back[3],
+            u32::MAX,
+        );
+        batch.text(atlas, &label, back[0] + 4.0, back[1] + 3.0, u32::MAX, true);
+        horizon_client::widgets::record(&label, back, true);
+        let room = layout.width() - back[2] - 4.0;
+        // Cut to the panel with vanilla's ellipsis (CommonComponents.ELLIPSIS).
+        let shown = if atlas.font.fit(&title, room) >= title.chars().count() {
+            title
+        } else {
+            let fit = atlas.font.fit(&title, room - atlas.font.width("..."));
+            let kept: String = title.chars().take(fit).collect();
+            format!("{}...", kept.trim_end())
+        };
+        batch.text(
+            atlas,
+            &shown,
+            back[0] + back[2] + 4.0,
+            back[1] + 3.0,
+            u32::MAX,
+            true,
+        );
+        self.draw_recipe_tabs(batch, layout);
+        if pages_n > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let visible = [page > 0, page + 1 < pages_n];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, visible)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(visible))
+            {
+                if !visible {
+                    continue;
+                }
+                let suffix = if inside(cursor, [x, y, 12.0, 17.0]) {
+                    "_highlighted"
+                } else {
+                    ""
+                };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages_n}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        for (i, (x, y)) in self.recipes_shown(layout) {
+            let Some(r) = self.mods.browser.recipes.as_ref().map(|p| &p.recipes[i]) else {
+                break;
+            };
+            let (at, arrow, action) = r.places(layout.width());
+            let h = r.block(layout.width());
+            let (cooking, note, button) =
+                (r.layout == BrowserLayout::Cooking, r.note.clone(), r.action);
+            let atlas = &self.gui.atlas;
+            for &(sx, sy) in at.iter().filter(|p| p.0.is_finite()) {
+                batch.sprite(atlas, "gui/sprites/container/slot", x + sx, y + sy);
+            }
+            if cooking {
+                batch.sprite(
+                    atlas,
+                    "gui/sprites/container/furnace/lit_progress",
+                    x + 2.0,
+                    y + SLOT + 2.0,
+                );
+            }
+            batch.sprite(
+                atlas,
+                "gui/sprites/container/furnace/burn_progress",
+                x + arrow.0,
+                y + arrow.1,
+            );
+            if let Some(enabled) = button {
+                let rect = [x + action.0, y + action.1, 12.0, 12.0];
+                let sprite = match (enabled, inside(cursor, rect)) {
+                    (false, _) => "gui/sprites/widget/button_disabled",
+                    (true, true) => "gui/sprites/widget/button_highlighted",
+                    (true, false) => "gui/sprites/widget/button",
+                };
+                horizon_client::ui::nine_slice(
+                    batch,
+                    atlas,
+                    sprite,
+                    rect[0],
+                    rect[1],
+                    12.0,
+                    12.0,
+                    u32::MAX,
+                );
+                let color = if enabled {
+                    u32::MAX
+                } else {
+                    rgba(160, 160, 160, 255)
+                };
+                batch.text(atlas, "+", rect[0] + 3.0, rect[1] + 2.0, color, true);
+                horizon_client::widgets::record(&format!("+ {i}"), rect, enabled);
+            }
+            if !note.is_empty() {
+                batch.text(atlas, &note, x, y + h + 2.0, rgba(224, 224, 224, 255), true);
+            }
+            for (k, &(sx, sy)) in at.iter().enumerate().filter(|(_, p)| p.0.is_finite()) {
+                let Some((_, stack)) = self.recipe_slot_now(i, k).cloned() else {
+                    continue;
+                };
+                self.draw_item(batch, &stack, x + sx + 1.0, y + sy + 1.0);
+                if inside(cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                    batch.fill(
+                        &self.gui.atlas,
+                        x + sx + 1.0,
+                        y + sy + 1.0,
+                        16.0,
+                        16.0,
+                        rgba(255, 255, 255, 128),
+                    );
+                }
+                let name = self.pack.names.display_item(&stack.item);
+                horizon_client::widgets::record_as(
+                    &format!("{name} {i}:{k}"),
+                    [x + sx + 1.0, y + sy + 1.0, 16.0, 16.0],
+                    true,
+                    horizon_client::widgets::Kind::Button,
+                );
+            }
+        }
+    }
+
+    /// The tabs, on slots; the selected one framed.
+    fn draw_recipe_tabs(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let places = tab_places(pages, layout);
+        let tabs: Vec<Option<ItemStack>> = pages.tabs.iter().map(|t| t.1.clone()).collect();
+        let selected = pages.tab;
+        for (i, (&(x, y), stack)) in places.iter().zip(tabs).enumerate() {
+            let atlas = &self.gui.atlas;
+            batch.sprite(atlas, "gui/sprites/container/slot", x, y);
+            let Some(stack) = stack else {
+                continue;
+            };
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            // The selected tab: a white frame around its slot.
+            if i == selected {
+                let white = rgba(255, 255, 255, 255);
+                let atlas = &self.gui.atlas;
+                batch.fill(atlas, x - 1.0, y - 1.0, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y + SLOT, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y, 1.0, SLOT, white);
+                batch.fill(atlas, x + SLOT, y, 1.0, SLOT, white);
+            }
+            if inside(self.cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &format!("{name} tab"),
+                [x + 1.0, y + 1.0, 16.0, 16.0],
+                true,
+                horizon_client::widgets::Kind::Tab(i == selected),
+            );
+        }
+    }
+
+    /// A press on the recipes: true when it hit one of their parts.
+    pub(super) fn browser_recipes_press(
+        &mut self,
+        layout: &Layout,
+        owner: usize,
+        right: bool,
+    ) -> bool {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let [back_arrow, forward] = layout.arrows();
+        let turn = if page > 0 && inside(cursor, [back_arrow.0, back_arrow.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if page + 1 < starts.len() && inside(cursor, [forward.0, forward.1, 12.0, 17.0]) {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = turn {
+            if let Some(p) = self.mods.browser.recipes.as_mut() {
+                p.page = to;
+            }
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Page(starts[to] as u32));
+            return true;
+        }
+        if let Some((tab, _, _)) = self.recipe_tab_hovered(layout) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Tab(tab as u32));
+            return true;
+        }
+        if inside(cursor, self.back_button(layout).0) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods.mods.browser_event(owner, BrowserEvent::Back);
+            return true;
+        }
+        if let Some((recipe, slot, stack, _)) = self.recipe_slot_hovered(layout) {
+            let event = BrowserEvent::SlotClicked(BrowserSlotClick {
+                recipe: recipe as u32,
+                slot: slot as u32,
+                stack,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        let action = self.recipes_shown(layout).into_iter().find(|&(i, (x, y))| {
+            let r = &pages.recipes[i];
+            let (_, _, (ax, ay)) = r.places(layout.width());
+            r.action.is_some() && inside(cursor, [x + ax, y + ay, 12.0, 12.0])
+        });
+        if let Some((i, _)) = action {
+            if pages.recipes[i].action == Some(true) {
+                self.audio
+                    .play("minecraft:ui.button.click", None, 0.25, 1.0);
+                self.mods
+                    .mods
+                    .browser_event(owner, BrowserEvent::Action(i as u32));
+            }
+            return true;
+        }
+        false
+    }
+}

crates/horizon-client/src/game/mod_input.rs

@@ -31,6 +31,9 @@ impl Game<'_> {
     pub(super) fn mod_minimap(&self) -> Option<ModMinimap> {
         None
     }
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        None
+    }
 }
 
 /// A mod's zoom (`render.set-zoom`), clamped by the runtime.
@@ -51,6 +54,13 @@ pub(super) struct ModMinimap {
     pub(super) round: bool,
 }
 
+/// A mod's far terrain (`render.set-far-terrain`), clamped by the runtime.
+#[derive(Clone, Copy)]
+pub(super) struct ModFarTerrain {
+    pub(super) distance: u32,
+    pub(super) reduced: bool,
+}
+
 #[cfg(feature = "mods")]
 impl Game<'_> {
     /// The main hand's stack as `input` shows it; none when it is empty.
@@ -111,6 +121,18 @@ impl Game<'_> {
         if repeat || !self.mods.mods.has_keys() {
             return;
         }
+        // Over an item on a container screen, the mods' keys are `browser`
+        // events (a recipe viewer's R and U).
+        if pressed
+            && self.screen == Screen::Inventory
+            && self.title.is_none()
+            && !self.mod_browser_typing()
+            && let Some(name) = horizon_client::keybinds::key_name(key)
+            && let Some(stack) = self.mod_browser_pointed()
+        {
+            self.mods.mods.browser_key(name, &stack);
+            return;
+        }
         if pressed && (self.screen != Screen::Playing || self.title.is_some()) {
             return;
         }
@@ -178,4 +200,12 @@ impl Game<'_> {
             round: m.round,
         })
     }
+    /// The far terrain the first mod drawing one asks for.
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        let f = self.mods.mods.far_terrain()?;
+        Some(ModFarTerrain {
+            distance: f.distance,
+            reduced: f.reduced,
+        })
+    }
 }

crates/horizon-client/src/game/mod_recipes.rs

@@ -0,0 +1,274 @@
+//! Capability `recipes` (docs/mods.md): every item and recipe the game
+//! knows, made once for the mods that read them, and the recipe book's
+//! known displays. The recipes are the window's own data: the world's in
+//! single player, vanilla's on a server (a client is sent no others), while
+//! the known displays follow the server's book as the recipe book does.
+use super::Game;
+use horizon_client::{
+    crafting::Ingredient,
+    items::ItemStack,
+    recipe_book::{Category, Display},
+    stations::Smithing,
+};
+use horizon_mods::{Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+use std::{collections::HashMap, sync::Arc};
+
+/// Item id -> its index in [`Recipes::items`].
+struct Index(HashMap<Arc<str>, u32>);
+impl Index {
+    fn stack(&self, item: &str, count: u32, components: String) -> Option<RecipeStack> {
+        Some(RecipeStack {
+            item: *self.0.get(item)?,
+            count,
+            components,
+        })
+    }
+    fn of(&self, s: &ItemStack) -> Option<RecipeStack> {
+        self.stack(&s.item, s.count, components(s))
+    }
+    fn any(&self, i: &Ingredient) -> Vec<RecipeStack> {
+        i.1.iter()
+            .filter_map(|id| self.stack(id, 1, String::new()))
+            .collect()
+    }
+}
+
+/// A stack's components beyond its item's, as vanilla's item syntax writes
+/// them (`[minecraft:potion_contents={potion:"minecraft:swiftness"}]`), or "".
+pub(super) fn components(s: &ItemStack) -> String {
+    use horizon_world::nbt::Tag;
+    let Some(Tag::Compound(entries)) = horizon_client::item_data::encode_components(s) else {
+        return String::new();
+    };
+    let parts: Vec<String> = entries
+        .iter()
+        .map(|(k, v)| {
+            format!(
+                "{}={}",
+                k.to_string_lossy(),
+                horizon_client::snbt::to_snbt(v)
+            )
+        })
+        .collect();
+    format!("[{}]", parts.join(","))
+}
+
+fn recipe(id: String, kind: RecipeKind) -> Recipe {
+    Recipe {
+        id,
+        kind,
+        category: String::new(),
+        group: String::new(),
+        width: 0,
+        height: 0,
+        slots: Vec::new(),
+        results: Vec::new(),
+        cooking_time: 0,
+        experience: 0.0,
+        book_id: -1,
+    }
+}
+
+impl Game<'_> {
+    /// `recipes.give`: a creative player takes the stack as from the
+    /// creative inventory; a server hears it as `SetCreativeModeSlot`
+    /// through the inventory's sync, and refuses it unless creative.
+    pub(super) fn mod_give(&mut self, item: &str, count: u32, components: &str) {
+        let Some(max) = self.res.items().get(item).map(|i| i.max_stack) else {
+            return;
+        };
+        if !self.creative {
+            return;
+        }
+        let (damage, extra) = horizon_client::item_data::command_components(components)
+            .map_or((0, None), |tag| {
+                horizon_client::item_data::decode_components(Some(&tag))
+            });
+        let _ = self.give(ItemStack {
+            item: item.into(),
+            // One stack at most, as the creative inventory hands out.
+            count: count.min(max),
+            damage,
+            extra,
+        });
+    }
+    /// Capability `recipes`'s tables and known displays for this tick's
+    /// snapshot; nothing while no running mod reads them.
+    pub(super) fn mod_recipes(&mut self) -> (Option<Arc<Recipes>>, Arc<[i32]>) {
+        if !self.mods.mods.wants_recipes() {
+            return (None, Arc::from([]));
+        }
+        if self.mods.recipes.is_none() {
+            self.mods.recipes = Some(Arc::new(self.make_mod_recipes()));
+        }
+        let (version, known) = self.recipe_book_displays();
+        if self.mods.known_recipes.0 != Some(version) {
+            self.mods.known_recipes = (Some(version), known.into());
+        }
+        (self.mods.recipes.clone(), self.mods.known_recipes.1.clone())
+    }
+
+    fn make_mod_recipes(&mut self) -> Recipes {
+        let names = &self.pack.names;
+        let items = self.res.items();
+        let mut tags: HashMap<&str, Vec<String>> = HashMap::new();
+        for (tag, members) in &items.item_tags {
+            for m in members {
+                tags.entry(m).or_default().push(tag.clone());
+            }
+        }
+        let table: Vec<RecipeItem> = items
+            .registry_order
+            .iter()
+            .map(|id| RecipeItem {
+                id: id.to_string(),
+                name: names.display_item(id),
+                tags: tags.remove(&**id).map_or_else(Vec::new, |mut t| {
+                    t.sort();
+                    t
+                }),
+            })
+            .collect();
+        let index = Index(
+            items
+                .registry_order
+                .iter()
+                .enumerate()
+                .map(|(i, id)| (id.clone(), i as u32))
+                .collect(),
+        );
+        let mut out = Vec::new();
+        let cooking: HashMap<String, (u32, f32)> = self
+            .res
+            .recipes()
+            .cooking
+            .iter()
+            .map(|c| (format!("minecraft:{}", c.id), (c.time, c.experience)))
+            .collect();
+        for e in self.recipe_book_entries() {
+            let furnace = |c: Category| match c.name().split('_').next() {
+                Some("blast") => RecipeKind::Blasting,
+                Some("smoker") => RecipeKind::Smoking,
+                _ => RecipeKind::Smelting,
+            };
+            let kind = match &e.display {
+                Display::Shaped { .. } => RecipeKind::CraftingShaped,
+                Display::Shapeless(_) => RecipeKind::CraftingShapeless,
+                Display::Furnace(_) => furnace(e.category),
+            };
+            let mut r = recipe(e.id.clone(), kind);
+            r.category = e.category.name().to_owned();
+            r.group = e.group.clone().unwrap_or_default();
+            r.book_id = e.display_id;
+            r.slots = match &e.display {
+                Display::Shaped {
+                    width,
+                    height,
+                    cells,
+                } => {
+                    (r.width, r.height) = (*width as u32, *height as u32);
+                    cells
+                        .iter()
+                        .map(|c| c.as_ref().map_or_else(Vec::new, |i| index.any(i)))
+                        .collect()
+                }
+                Display::Shapeless(list) => list.iter().map(|i| index.any(i)).collect(),
+                Display::Furnace(i) => vec![index.any(i)],
+            };
+            // Requirements shown as other stacks (an arrow's potions): the
+            // requirement's index counts the filled slots only.
+            let filled: Vec<usize> = (0..r.slots.len())
+                .filter(
+                    |&k| !matches!(&e.display, Display::Shaped { cells, .. } if cells[k].is_none()),
+                )
+                .collect();
+            for (req, stacks) in &e.stacks {
+                if let Some(&k) = filled.get(*req) {
+                    r.slots[k] = stacks.iter().filter_map(|s| index.of(s)).collect();
+                }
+            }
+            r.results = e.results().iter().filter_map(|s| index.of(s)).collect();
+            if let Some(&(time, xp)) = cooking.get(&e.id) {
+                (r.cooking_time, r.experience) = (time, xp);
+            }
+            out.push(r);
+        }
+        for c in &self.res.recipes().cooking {
+            if c.kind == "minecraft:campfire_cooking" {
+                let mut r = recipe(format!("minecraft:{}", c.id), RecipeKind::Campfire);
+                r.group = c.group.clone();
+                r.slots = vec![index.any(&c.ingredient)];
+                r.results = index.of(&c.result).into_iter().collect();
+                (r.cooking_time, r.experience) = (c.time, c.experience);
+                out.push(r);
+            }
+        }
+        let stations = self.res.stations();
+        for s in &stations.recipes.stonecutting {
+            let mut r = recipe(s.id.clone(), RecipeKind::Stonecutting);
+            r.slots = vec![index.any(&s.input)];
+            r.results = index.of(&s.result).into_iter().collect();
+            out.push(r);
+        }
+        for s in &stations.recipes.smithing {
+            let (id, template, base, addition, results) = match s {
+                Smithing::Transform {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    result,
+                } => (
+                    id,
+                    template,
+                    base,
+                    addition,
+                    index.stack(result, 1, String::new()).into_iter().collect(),
+                ),
+                Smithing::Trim {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    ..
+                } => (id, template, base, addition, index.any(base)),
+            };
+            let mut r = recipe(id.clone(), RecipeKind::Smithing);
+            r.slots = vec![index.any(template), index.any(base), index.any(addition)];
+            r.results = results;
+            out.push(r);
+        }
+        for b in &stations.brewing.recipes {
+            let potion = |p: &horizon_client::brewing::PotionIngredient| -> Vec<RecipeStack> {
+                let mut item_ids: Vec<&String> = p.items.iter().collect();
+                item_ids.sort();
+                let mut potions: Vec<&String> = p.potions.iter().flatten().collect();
+                potions.sort();
+                item_ids
+                    .into_iter()
+                    .flat_map(|item| {
+                        let one = |c: String| index.stack(item, 1, c);
+                        if potions.is_empty() {
+                            one(String::new()).into_iter().collect::<Vec<_>>()
+                        } else {
+                            potions
+                                .iter()
+                                .filter_map(|p| {
+                                    one(format!("[minecraft:potion_contents={{potion:\"{p}\"}}]"))
+                                })
+                                .collect()
+                        }
+                    })
+                    .collect()
+            };
+            let mut r = recipe(b.id.clone(), RecipeKind::Brewing);
+            r.slots = vec![potion(&b.input), potion(&b.reagent)];
+            r.results = index.of(&b.output).into_iter().collect();
+            out.push(r);
+        }
+        Recipes {
+            items: table,
+            recipes: out,
+        }
+    }
+}

crates/horizon-client/src/game/mods.rs

@@ -63,6 +63,14 @@ pub(super) struct ModsState {
     /// What players did this tick, for server mods at its end.
     #[cfg(feature = "mods")]
     pub(super) events: Vec<ModEvent>,
+    /// A running server mod has capability `world`: its calls get the
+    /// levels' chunks to read.
+    #[cfg(feature = "mods")]
+    pub(super) world: bool,
+    /// Blocks server mods set, by dimension, made before that level's next
+    /// tick.
+    #[cfg(feature = "mods")]
+    pub(super) block_writes: Vec<(String, horizon_mods::BlockChange)>,
     /// `command.run` lines for this window's own world, run on the next tick:
     /// run at once, their chat lines would reach the mods while their output
     /// is still being shown, and a mod answering its own lines would recurse.
@@ -81,6 +89,15 @@ pub(super) struct ModsState {
     /// The HUD font's advances for `render.text-width`, made once.
     #[cfg(feature = "mods")]
     font_widths: std::sync::Arc<[f32]>,
+    /// Capability `recipes`'s tables, made once a mod reads them.
+    #[cfg(feature = "mods")]
+    pub(super) recipes: Option<std::sync::Arc<horizon_mods::Recipes>>,
+    /// The recipe book's known displays, and the book's version they are of.
+    #[cfg(feature = "mods")]
+    pub(super) known_recipes: (Option<u64>, std::sync::Arc<[i32]>),
+    /// Capability `ui`'s item panel beside container screens.
+    #[cfg(feature = "mods")]
+    pub(super) browser: super::mod_browser::Browser,
     /// Extras that are official mods now, being installed.
     #[cfg(feature = "mods")]
     pub(super) moved: super::moved_extras::MovedState,
@@ -293,6 +310,8 @@ impl Game<'_> {
         self.mods.mods.set_bindings(|id| chosen.keys_of(id));
         // Entries were replaced wholesale: a screen's owner index is stale.
         self.mods.screen = None;
+        // Content mods may have changed the items: remade on the next read.
+        self.mods.recipes = None;
         self.list_mods();
         self.sync_mod_commands();
         self.show_mod_output();
@@ -309,6 +328,7 @@ impl Game<'_> {
     /// The Mods page's rows, from what loaded.
     fn list_mods(&mut self) {
         self.mods.server = self.mods.mods.runs_server();
+        self.mods.world = self.mods.mods.wants_world();
         let dev = &self.mods.dev;
         self.settings.mods.installed = self
             .mods
@@ -351,7 +371,10 @@ impl Game<'_> {
     }
     /// The chat's tree after the running mods changed.
     fn sync_mod_commands(&mut self) {
-        let mut names = self.mods.mods.commands().peekable();
+        // In-frame, the window runs server mods too: their names, free text
+        // here (the server parses their arguments).
+        let server = self.mods.mods.server_commands().map(|c| c.name.as_str());
+        let mut names = self.mods.mods.commands().chain(server).peekable();
         self.mods.tree = names
             .peek()
             .is_some()
@@ -440,6 +463,7 @@ impl Game<'_> {
                 .map(|c| char::from_u32(c).map_or(6.0, |c| atlas.glyph_cell(c).1))
                 .collect();
         }
+        let (recipes, known_recipes) = self.mod_recipes();
         Snapshot {
             player,
             clock,
@@ -451,6 +475,10 @@ impl Game<'_> {
             font_widths: self.mods.font_widths.clone(),
             players,
             view_hit: self.mod_view_hit(),
+            recipes,
+            known_recipes,
+            placing: self.mod_recipe_screen(),
+            creative: self.creative,
         }
     }
     /// The first block along the player's view within
@@ -673,8 +701,10 @@ impl Game<'_> {
                     }
                     Text::literal(line).with_color(text::RED)
                 }
-                server
-                @ (Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. }) => {
+                server @ (Output::Tell { .. }
+                | Output::Broadcast { .. }
+                | Output::Reply { .. }
+                | Output::SetBlocks { .. }) => {
                     self.route_server_output(host.as_deref_mut(), server);
                     continue;
                 }
@@ -686,6 +716,18 @@ impl Game<'_> {
                     self.mods.shake.add(strength, seconds);
                     continue;
                 }
+                Output::PlaceRecipe { book_id, all } => {
+                    self.mod_place_recipe(book_id, all);
+                    continue;
+                }
+                Output::Give {
+                    item,
+                    count,
+                    components,
+                } => {
+                    self.mod_give(&item, count, &components);
+                    continue;
+                }
                 Output::CloseScreen { owner } => {
                     if self.mods.screen.as_ref().is_some_and(|s| s.owner == owner) {
                         self.close_mod_screen(false);

crates/horizon-client/src/game/mounts.rs

@@ -126,6 +126,19 @@ impl Game<'_> {
         if !equine::is_equine(species) || !m.alive() || Some(m.id) == self.riding {
             return false;
         }
+        // AbstractHorse.mobInteract: a horse a mob rides (`isVehicle`) has no
+        // seat, inventory or feeding to give. Camels seat two and check their
+        // passengers themselves.
+        let id = m.id;
+        if !matches!(species, Species::Camel | Species::CamelHusk)
+            && self
+                .mobs
+                .iter()
+                .any(|p| p.extra.mount == Some(id) && !p.removed && p.alive())
+        {
+            return false;
+        }
+        let m = &self.mobs[index];
         // AbstractHorse.mobInteract: shift + use opens a tamed adult's inventory.
         if !m.is_baby()
             && m.extra.tame

crates/horizon-client/src/game/music.rs

@@ -3,7 +3,7 @@
 use super::Game;
 use horizon_client::{
     blocks::Fluid,
-    music::{BackgroundMusic, Music, Situation},
+    music::{BackgroundMusic, Music, MusicFrequency, Situation},
     sound_engine::TickContext,
 };
 
@@ -11,6 +11,11 @@ impl Game<'_> {
     /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick.
     pub(super) fn tick_music(&mut self) {
         let (music, volume) = self.situational_music();
+        // Options.musicFrequency's listener: MusicManager.setMinutesBetweenSongs.
+        let frequency = MusicFrequency::parse(&self.settings.file.name("musicFrequency"));
+        if frequency != self.music.frequency {
+            self.music.set_frequency(frequency, music.as_ref());
+        }
         // LevelLoadingScreen: no new track before the player is in the world.
         let loading = self.title.is_none() && self.player.is_none() && self.win.is_none();
         self.music

crates/horizon-client/src/game/nether_portal.rs

@@ -2,7 +2,9 @@
 //! `Entity.setAsInsidePortal` / `handlePortal` with `PortalProcessor`,
 //! `NetherPortalBlock.getPortalTransitionTime` and `getPortalDestination`
 //! (`PortalForcer` through `horizon_world::level::portal_travel`), and
-//! `LocalPlayer.handlePortalTransitionEffect`.
+//! `LocalPlayer.handlePortalTransitionEffect`. Items and mobs also go through
+//! End portals here (`EndPortalBlock.entityInside` / `getPortalDestination`);
+//! the player's End portals are game/end.rs's.
 //!
 //! Only one dimension is loaded at a time. The player's destination is found
 //! once the other dimension has loaded around it. An item or mob that goes
@@ -12,7 +14,7 @@ use super::{Dim, Game, Screen};
 use horizon_client::Result;
 use horizon_client::nether_portal::PortalState;
 use horizon_core::{
-    geometry::{Axis, Vec3},
+    geometry::{Aabb, Axis, Vec3},
     position::BlockPos,
     random::RandomSource,
 };
@@ -40,6 +42,32 @@ pub(super) struct Plan {
     offset: Vec3,
     width: f32,
     height: f32,
+    /// Through an End portal: `approximate` is the End's spawn point, or the
+    /// Overworld's shared spawn.
+    end: bool,
+}
+
+impl Plan {
+    /// `EndPortalBlock.getPortalDestination` for an entity other than a
+    /// player in `from`: the End's spawn point, or out of the End the
+    /// Overworld's shared spawn `world_spawn`.
+    fn end_portal(from: Dim, world_spawn: BlockPos, width: f32, height: f32) -> Self {
+        let (dim, approximate) = if from == Dim::End {
+            (Dim::Overworld, world_spawn)
+        } else {
+            let [x, y, z] = super::end::END_SPAWN;
+            (Dim::End, BlockPos::new(x, y, z))
+        };
+        Self {
+            dim,
+            approximate,
+            entry_x_axis: true,
+            offset: Vec3::ZERO,
+            width,
+            height,
+            end: true,
+        }
+    }
 }
 
 /// An entity on its way to a dimension that isn't loaded.
@@ -81,6 +109,89 @@ fn rotate_y(v: Vec3, degrees: f32) -> Vec3 {
 fn doubles(values: [f64; 3]) -> Tag {
     Tag::List(values.iter().map(|v| Tag::Double(v.to_bits())).collect())
 }
+/// Whether a `width` by `height` box moving from `from` to `to` meets the End
+/// portal at `pos`: `Entity.collidedWithShapeMovingFrom` against its
+/// entity-inside shape, y 6/16..12/16 of the block.
+fn touches_end_portal(from: Vec3, to: Vec3, width: f32, height: f32, pos: BlockPos) -> bool {
+    let half = f64::from(width) / 2.0;
+    let start = Aabb::new(
+        Vec3::new(from.x - half, from.y, from.z - half),
+        Vec3::new(from.x + half, from.y + f64::from(height), from.z + half),
+    );
+    let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
+    let shape = Aabb::new(
+        Vec3::new(x, y + 0.375, z),
+        Vec3::new(x + 1.0, y + 0.75, z + 1.0),
+    );
+    start.collided_along_vector(to.subtract(from), &[shape])
+}
+/// `PositionMoveRotation.calculateAbsolute` for an End portal's transition
+/// of an entity facing `[yaw, pitch]`: into the End it faces west and keeps
+/// its pitch (`Relative.X_ROT`); out of it both turn by the world spawn's
+/// angles (`Relative.ROTATION`). The pitch stays within ±90.
+fn end_portal_rotation(into_end: bool, [yaw, pitch]: [f32; 2], spawn: [f32; 2]) -> [f32; 2] {
+    let (yaw, pitch) = if into_end {
+        // Direction.WEST.toYRot().
+        (90.0, pitch)
+    } else {
+        (yaw + spawn[0], pitch + spawn[1])
+    };
+    [yaw, pitch.clamp(-90.0, 90.0)]
+}
+/// A waiting entity as `horizon_portal_arrivals.dat` keeps it.
+fn arrival_tag(a: &Arrival) -> Tag {
+    let p = &a.plan;
+    Tag::compound([
+        ("dimension", Tag::String(p.dim.id().into())),
+        ("x", Tag::Int(p.approximate.x)),
+        ("y", Tag::Int(p.approximate.y)),
+        ("z", Tag::Int(p.approximate.z)),
+        ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
+        ("right", Tag::Double(p.offset.x.to_bits())),
+        ("up", Tag::Double(p.offset.y.to_bits())),
+        ("forward", Tag::Double(p.offset.z.to_bits())),
+        ("width", Tag::Float(p.width.to_bits())),
+        ("height", Tag::Float(p.height.to_bits())),
+        ("end", Tag::Int(i32::from(p.end))),
+        ("entity", a.tag.clone()),
+    ])
+}
+/// The waiting entity `arrival_tag` wrote.
+fn arrival_from_tag(a: &Tag) -> Option<Arrival> {
+    let int = |k: &str| match a.get(k) {
+        Some(Tag::Int(v)) => Some(*v),
+        _ => None,
+    };
+    let float = |k: &str| match a.get(k) {
+        Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
+        _ => None,
+    };
+    let double = |k: &str| match a.get(k) {
+        Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
+        _ => None,
+    };
+    let dim = Dim::from_id(&horizon_client::save::text(a.get("dimension"))?);
+    let (Some(x), Some(y), Some(z), Some(tag)) = (int("x"), int("y"), int("z"), a.get("entity"))
+    else {
+        return None;
+    };
+    Some(Arrival {
+        plan: Plan {
+            dim,
+            approximate: BlockPos::new(x, y, z),
+            entry_x_axis: int("x_axis").unwrap_or(1) != 0,
+            offset: Vec3::new(
+                double("right").unwrap_or(0.5),
+                double("up").unwrap_or(0.0),
+                double("forward").unwrap_or(0.0),
+            ),
+            width: float("width").unwrap_or(0.25),
+            height: float("height").unwrap_or(0.25),
+            end: int("end").unwrap_or(0) != 0,
+        },
+        tag: tag.clone(),
+    })
+}
 
 impl Game<'_> {
     /// The world border's extent.
@@ -146,8 +257,54 @@ impl Game<'_> {
             offset,
             width,
             height,
+            end: false,
         }
     }
+    /// The plan of an item or mob going through the portal block at `entry`:
+    /// an End portal's fixed destination, else the Nether portal's.
+    fn entity_plan(
+        &self,
+        entry: BlockPos,
+        at: Vec3,
+        width: f32,
+        height: f32,
+        reset_forward: bool,
+    ) -> Plan {
+        if !self.is_end_portal(self.world.block(entry.x, entry.y, entry.z)) {
+            return self.portal_plan(entry, at, width, height, reset_forward);
+        }
+        let spawn = self.level.world_spawn.unwrap_or_else(|| {
+            self.spawn.map_or([0, 64, 0], |s| {
+                [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]
+            })
+        });
+        Plan::end_portal(
+            self.dim,
+            BlockPos::new(spawn[0], spawn[1], spawn[2]),
+            width,
+            height,
+        )
+    }
+    fn is_end_portal(&self, state: horizon_world::registry::BlockStateId) -> bool {
+        &*self.res.facts().get(state).name == "minecraft:end_portal"
+    }
+    /// Where an item or mob through an End portal lands once `plan`'s level
+    /// has loaded around it: the bottom centre of the End's spawn point,
+    /// above the platform built below it (`EndPlatformFeature.createEndPlatform`);
+    /// out of the End, the top of the shared spawn's column
+    /// (`Entity.adjustSpawnLocation`).
+    fn end_portal_exit(&mut self, plan: &Plan) -> Vec3 {
+        let p = plan.approximate;
+        let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5);
+        if plan.dim == Dim::End {
+            if let Err(e) = self.end_arrival(centre) {
+                log::error!("End platform: {e}");
+            }
+            return centre;
+        }
+        let y = self.motion_top(p.x, p.z);
+        Vec3::new(centre.x, f64::from(y), centre.z)
+    }
     /// The nether portal blocks of the chunks within `radius` of `center`
     /// (the points of interest `PortalForcer` searches): loaded chunks as
     /// they are, the others as saved; chunks never generated have none.
@@ -520,9 +677,10 @@ impl Game<'_> {
             || self.ridden_by_guest(id)
             || self.mobs.iter().any(|m| m.extra.mount == Some(id))
     }
-    /// `NetherPortalBlock.entityInside` for the items, mobs and empty boats
-    /// and minecarts that moved this tick: the portal blocks their box swept
-    /// through.
+    /// `NetherPortalBlock.entityInside` and `EndPortalBlock.entityInside`
+    /// for the items, mobs and empty boats and minecarts that moved this
+    /// tick: the portal blocks their box swept through (an End portal's
+    /// transition time is 0 too).
     pub(super) fn find_entity_portals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -570,7 +728,7 @@ impl Game<'_> {
                 .set_inside(pos, ENTITY_DELAY);
         }
     }
-    /// The first nether portal block an entity box swept through
+    /// The first nether or End portal block an entity box swept through
     /// (`Entity.checkInsideBlocks`, whose first portal sets the entry).
     fn swept_portal(
         &self,
@@ -604,11 +762,9 @@ impl Game<'_> {
             bounds,
             1_000_000,
             |p, _| {
-                if self
-                    .res
-                    .behaviours()
-                    .portal_axis(self.world.block(p.x, p.y, p.z))
-                    .is_some()
+                let state = self.world.block(p.x, p.y, p.z);
+                if self.res.behaviours().portal_axis(state).is_some()
+                    || (self.is_end_portal(state) && touches_end_portal(from, to, width, height, p))
                 {
                     found = Some(p);
                     return false;
@@ -618,8 +774,8 @@ impl Game<'_> {
         );
         found
     }
-    /// Whether a section `reach` touches has a nether portal state in its
-    /// palette: without one, no block there is a portal. Palette answers are
+    /// Whether a section `reach` touches has a nether or End portal state in
+    /// its palette: without one, no block there is a portal. Palette answers are
     /// kept per chunk across ticks (`portal_sections`); a box over many
     /// sections is not checked.
     fn may_hold_portal(
@@ -656,9 +812,8 @@ impl Game<'_> {
             (z0..=z1).any(|cz| {
                 chunks.get(&(cx, cz)).is_some_and(|chunk| {
                     sections.get((cx, cz), chunk, |v| {
-                        behaviours
-                            .portal_axis(horizon_world::registry::BlockStateId(v))
-                            .is_some()
+                        let state = horizon_world::registry::BlockStateId(v);
+                        behaviours.portal_axis(state).is_some() || self.is_end_portal(state)
                     }) & y_mask
                         != 0
                 })
@@ -670,7 +825,7 @@ impl Game<'_> {
     fn send_through_portal(&mut self, id: u32, entry: BlockPos) {
         if let Some(i) = self.dropped.iter().position(|e| e.id == id) {
             let e = &self.dropped[i];
-            let plan = self.portal_plan(entry, e.position, 0.25, 0.25, false);
+            let plan = self.entity_plan(entry, e.position, 0.25, 0.25, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -686,7 +841,7 @@ impl Game<'_> {
             self.portals.dirty = true;
         } else if let Some(i) = self.mobs.iter().position(|m| m.id == id) {
             let m = &self.mobs[i];
-            let plan = self.portal_plan(entry, m.position, m.width(), m.height(), true);
+            let plan = self.entity_plan(entry, m.position, m.width(), m.height(), true);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -716,7 +871,7 @@ impl Game<'_> {
         } else if let Some(i) = self.boats.iter().position(|b| b.id == id) {
             let b = &self.boats[i];
             let (width, height) = (super::boats::WIDTH as f32, super::boats::HEIGHT as f32);
-            let plan = self.portal_plan(entry, b.position, width, height, false);
+            let plan = self.entity_plan(entry, b.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -741,7 +896,7 @@ impl Game<'_> {
                 super::minecarts::WIDTH as f32,
                 super::minecarts::HEIGHT as f32,
             );
-            let plan = self.portal_plan(entry, c.position, width, height, false);
+            let plan = self.entity_plan(entry, c.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -754,8 +909,8 @@ impl Game<'_> {
         }
     }
     /// Entities waiting for the loaded dimension whose exit area is loaded:
-    /// their exit portal (found or built), position, turned yaw and motion,
-    /// and portal cooldown; they join the world with the chunk entities.
+    /// their exit portal (found or built) or End destination, position,
+    /// turned yaw and motion, and portal cooldown; they join the world with the chunk entities.
     pub(super) fn resolve_arrivals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -772,21 +927,28 @@ impl Game<'_> {
             }
             let Arrival { plan, mut tag } = self.portals.arrivals.remove(i);
             self.portals.dirty = true;
-            let Some(exit) = self.nether_exit_portal(&plan) else {
-                continue;
-            };
-            let (at, rotation) = self.arrival(&plan, exit);
-            let motion = rotate_y(horizon_client::entity_nbt::motion(&tag), -rotation);
+            let motion = horizon_client::entity_nbt::motion(&tag);
             let [yaw, pitch] = horizon_client::entity_nbt::rotation(&tag);
+            let (at, motion, [yaw, pitch]) = if plan.end {
+                // Relative.DELTA: the motion is kept.
+                let at = self.end_portal_exit(&plan);
+                let into_end = plan.dim == Dim::End;
+                let turn =
+                    end_portal_rotation(into_end, [yaw, pitch], self.level.world_spawn_angle);
+                (at, motion, turn)
+            } else {
+                let Some(exit) = self.nether_exit_portal(&plan) else {
+                    continue;
+                };
+                let (at, rotation) = self.arrival(&plan, exit);
+                (at, rotate_y(motion, -rotation), [yaw + rotation, pitch])
+            };
             if let Tag::Compound(c) = &mut tag {
                 c.insert("Pos".into(), doubles([at.x, at.y, at.z]));
                 c.insert("Motion".into(), doubles([motion.x, motion.y, motion.z]));
                 c.insert(
                     "Rotation".into(),
-                    Tag::List(vec![
-                        Tag::Float((yaw + rotation).to_bits()),
-                        Tag::Float(pitch.to_bits()),
-                    ]),
+                    Tag::List(vec![Tag::Float(yaw.to_bits()), Tag::Float(pitch.to_bits())]),
                 );
                 // setPortalCooldown before the teleport, copied by restoreFrom.
                 c.insert("PortalCooldown".into(), Tag::Int(ENTITY_DELAY));
@@ -823,75 +985,117 @@ impl Game<'_> {
         let Some(Tag::List(list)) = root.get("arrivals") else {
             return;
         };
-        for a in list {
-            let int = |k: &str| match a.get(k) {
-                Some(Tag::Int(v)) => Some(*v),
-                _ => None,
-            };
-            let float = |k: &str| match a.get(k) {
-                Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
-                _ => None,
-            };
-            let double = |k: &str| match a.get(k) {
-                Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
-                _ => None,
-            };
-            let dim = match horizon_client::save::text(a.get("dimension")).as_deref() {
-                Some("minecraft:the_nether") => Dim::Nether,
-                Some(_) => Dim::Overworld,
-                None => continue,
-            };
-            let (Some(x), Some(y), Some(z), Some(tag)) =
-                (int("x"), int("y"), int("z"), a.get("entity"))
-            else {
-                continue;
-            };
-            self.portals.arrivals.push(Arrival {
-                plan: Plan {
-                    dim,
-                    approximate: BlockPos::new(x, y, z),
-                    entry_x_axis: int("x_axis").unwrap_or(1) != 0,
-                    offset: Vec3::new(
-                        double("right").unwrap_or(0.5),
-                        double("up").unwrap_or(0.0),
-                        double("forward").unwrap_or(0.0),
-                    ),
-                    width: float("width").unwrap_or(0.25),
-                    height: float("height").unwrap_or(0.25),
-                },
-                tag: tag.clone(),
-            });
-        }
+        self.portals
+            .arrivals
+            .extend(list.iter().filter_map(arrival_from_tag));
     }
     /// Write the waiting entities when they changed.
     pub(super) fn save_portal_arrivals(&mut self) {
         if !self.portals.dirty || self.remote.is_some() {
             return;
         }
-        let list = self
-            .portals
-            .arrivals
-            .iter()
-            .map(|a| {
-                let p = &a.plan;
-                Tag::compound([
-                    ("dimension", Tag::String(p.dim.id().into())),
-                    ("x", Tag::Int(p.approximate.x)),
-                    ("y", Tag::Int(p.approximate.y)),
-                    ("z", Tag::Int(p.approximate.z)),
-                    ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
-                    ("right", Tag::Double(p.offset.x.to_bits())),
-                    ("up", Tag::Double(p.offset.y.to_bits())),
-                    ("forward", Tag::Double(p.offset.z.to_bits())),
-                    ("width", Tag::Float(p.width.to_bits())),
-                    ("height", Tag::Float(p.height.to_bits())),
-                    ("entity", a.tag.clone()),
-                ])
-            })
-            .collect();
+        let list = self.portals.arrivals.iter().map(arrival_tag).collect();
         let root = Tag::compound([("arrivals", Tag::List(list))]);
         if horizon_client::save::write_dat(&self.arrivals_path(), root).is_ok() {
             self.portals.dirty = false;
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn end_portals_lead_to_the_end_spawn_and_back_to_the_world_spawn() {
+        let spawn = BlockPos::new(-7, 70, 12);
+        for from in [Dim::Overworld, Dim::Nether] {
+            let plan = Plan::end_portal(from, spawn, 0.9, 1.4);
+            assert_eq!(plan.dim, Dim::End);
+            assert_eq!(plan.approximate, BlockPos::new(100, 50, 0));
+            assert!(plan.end);
+        }
+        let plan = Plan::end_portal(Dim::End, spawn, 0.25, 0.25);
+        assert_eq!(plan.dim, Dim::Overworld);
+        assert_eq!(plan.approximate, spawn);
+    }
+
+    #[test]
+    fn the_end_portal_shape_takes_falling_items_and_standing_mobs() {
+        let portal = BlockPos::new(0, 100, 3);
+        let at = |y| Vec3::new(0.5, y, 3.5);
+        // A dropped item falling through the slab, or in it.
+        assert!(touches_end_portal(
+            at(100.6),
+            at(100.56),
+            0.25,
+            0.25,
+            portal
+        ));
+        // One tick's fall across the whole slab, in it at neither end.
+        assert!(touches_end_portal(at(101.0), at(99.9), 0.25, 0.25, portal));
+        // Resting below the slab (on the floor) or above it.
+        assert!(!touches_end_portal(
+            at(100.0),
+            at(100.0),
+            0.25,
+            0.25,
+            portal
+        ));
+        assert!(!touches_end_portal(
+            at(100.8),
+            at(100.8),
+            0.25,
+            0.25,
+            portal
+        ));
+        // A cow standing in the portal block.
+        assert!(touches_end_portal(at(100.0), at(100.0), 0.9, 1.4, portal));
+        // Beside it.
+        let beside = Vec3::new(2.0, 100.0, 3.5);
+        assert!(!touches_end_portal(beside, beside, 0.9, 1.4, portal));
+    }
+
+    #[test]
+    fn end_portals_turn_entities_like_their_teleport_transition() {
+        // Into the End: facing west, pitch kept.
+        assert_eq!(
+            end_portal_rotation(true, [-30.0, 20.0], [45.0, 10.0]),
+            [90.0, 20.0]
+        );
+        // Out of it: turned by the world spawn's yaw and pitch, pitch clamped.
+        assert_eq!(
+            end_portal_rotation(false, [-30.0, 20.0], [45.0, 10.0]),
+            [15.0, 30.0]
+        );
+        assert_eq!(
+            end_portal_rotation(false, [0.0, 80.0], [0.0, 30.0]),
+            [0.0, 90.0]
+        );
+    }
+
+    #[test]
+    fn waiting_arrivals_keep_their_end_destination_when_saved() {
+        let tag = Tag::compound([("id", Tag::String("minecraft:cow".into()))]);
+        for (from, dim) in [(Dim::Overworld, Dim::End), (Dim::End, Dim::Overworld)] {
+            let arrival = Arrival {
+                plan: Plan::end_portal(from, BlockPos::new(3, 64, -5), 0.9, 1.4),
+                tag: tag.clone(),
+            };
+            let back = arrival_from_tag(&arrival_tag(&arrival)).unwrap();
+            assert_eq!(back.plan.dim, dim);
+            assert_eq!(back.plan.approximate, arrival.plan.approximate);
+            assert!(back.plan.end);
+            assert_eq!(back.tag, tag);
+        }
+        // Arrivals saved before End portals were Nether portal plans.
+        let mut old = arrival_tag(&Arrival {
+            plan: Plan::end_portal(Dim::End, BlockPos::new(0, 64, 0), 0.25, 0.25),
+            tag,
+        });
+        if let Tag::Compound(c) = &mut old {
+            c.remove(&"end".into());
+        }
+        assert!(!arrival_from_tag(&old).unwrap().plan.end);
+    }
+}

crates/horizon-client/src/game/packs.rs

@@ -34,6 +34,10 @@ pub fn open_folder(dir: &Path) {
         log::warn!("Horizon: could not open {}: {e}", dir.display());
     }
 }
+/// `Util.getPlatform().openUri`: the system browser on the link.
+pub fn open_uri(uri: &str) {
+    open_folder(Path::new(uri));
+}
 /// The resource root to load from, given the vanilla root, the selection and
 /// a server's packs, which go on top (`Pack.Position.TOP`, fixed).
 pub fn startup_root(

crates/horizon-client/src/game/paintings.rs

@@ -267,8 +267,7 @@ impl Game<'_> {
             // measured from the box's centre (HangingEntity's position).
             let (lo, hi) = p.bounds();
             let (lo, hi) = (glam::DVec3::from(lo), glam::DVec3::from(hi));
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }

crates/horizon-client/src/game/persist.rs

@@ -357,7 +357,8 @@ impl Game<'_> {
     pub(super) fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
         self.next_entity += 1;
         let uuid = entity_nbt::uuid(&tag);
-        // Structure entities placed with finalizeEntities.
+        // Structure mobs that generation left to finish: saves from before
+        // they were finalized at placement, or a placement that could not.
         let mut tag = tag;
         let mut finalize = false;
         if let Tag::Compound(c) = &mut tag {
@@ -449,7 +450,8 @@ impl Game<'_> {
         }
     }
     /// An entity of a type Horizon does not simulate, kept as its compound.
-    fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
+    fn load_other(&mut self, mut tag: Tag, kind: &str) -> Option<u32> {
+        strip_finalize(&mut tag);
         let position = entity_nbt::position(&tag)?;
         let rotation = match tag.get("Rotation") {
             Some(Tag::List(l)) => {
@@ -1014,3 +1016,9 @@ impl Game<'_> {
         self.save.save_entities(chunks)
     }
 }
+/// Only a mob is finalized; another entity drops the request.
+fn strip_finalize(tag: &mut Tag) {
+    if let Tag::Compound(c) = tag {
+        c.remove(&"horizon:finalize".into());
+    }
+}

crates/horizon-client/src/game/potions.rs

@@ -12,6 +12,7 @@ use horizon_client::{
     hud_layout, hud_overlays, inventory_effects,
     items::ItemStack,
     mesher::Vertex,
+    text::Text,
 };
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
@@ -26,6 +27,9 @@ pub(super) struct ThrownPotion {
     position: Vec3,
     velocity: Vec3,
     age: u32,
+    /// `Projectile.getOwner`'s display name: the player who threw it (none
+    /// for a dispenser's).
+    owner: Option<Text>,
 }
 /// A mob's effect ids carry the `minecraft:` namespace.
 fn mob_effect_id(id: &str) -> Option<&'static str> {
@@ -47,7 +51,13 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
 impl Game<'_> {
     /// A splash potion, lingering potion or experience bottle in flight (the
     /// player's throws and dispensers both end up here).
-    pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) {
+    pub(super) fn launch_thrown(
+        &mut self,
+        stack: ItemStack,
+        position: Vec3,
+        velocity: Vec3,
+        owner: Option<Text>,
+    ) {
         self.potions.thrown.push(ThrownPotion {
             id: 0,
             stack,
@@ -55,6 +65,7 @@ impl Game<'_> {
             position,
             velocity,
             age: 0,
+            owner,
         });
     }
 }
@@ -135,6 +146,7 @@ impl PotionState {
             position: at,
             velocity,
             age: 0,
+            owner: None,
         });
     }
     /// ThrowableItemProjectile.DATA_ITEM_STACK: the potion it shows.
@@ -237,6 +249,7 @@ impl Game<'_> {
                     },
                     Vec3::new(eye[0], eye[1] - 0.1, eye[2]),
                     v,
+                    Some(self.player_display_text()),
                 );
                 self.swing_arm();
                 self.consume_held();
@@ -300,6 +313,7 @@ impl Game<'_> {
             return true;
         }
         self.using = None;
+        self.send_use_item_complete();
         self.post_entity_event("minecraft:drink", horizon_client::mobs::Who::Player);
         if ominous {
             self.drink_ominous_bottle(slot, stack);
@@ -548,15 +562,15 @@ impl Game<'_> {
                 }
             }
             if let Some(p) = hit {
-                landed.push((t.stack.clone(), p));
+                landed.push((t.stack.clone(), p, t.owner.clone()));
                 return false;
             }
             t.position = next;
             t.age < 1200 && t.position.y > -128.0
         });
         self.potions.thrown = thrown;
-        for (stack, at) in landed {
-            self.splash(&stack, at);
+        for (stack, at, owner) in landed {
+            self.splash(&stack, at, owner);
         }
     }
     /// `ThrowableProjectile.tick`'s `applyGravity` and `applyInertia`, which
@@ -664,6 +678,7 @@ impl Game<'_> {
         effects: &'static [(&'static str, i32, i32)],
         at: Vec3,
         scale: f64,
+        source: &Text,
     ) {
         if let Some(p) = self.player.as_ref() {
             let center = Vec3::new(
@@ -679,6 +694,18 @@ impl Game<'_> {
                     let instant = brewing::effect(id).is_some_and(|e| e.instant);
                     if instant {
                         if let Some(a) = horizon_client::effects::instant(id, *amp, intensity) {
+                            // HealOrHarmMobEffect.applyInstantaneousEffect with
+                            // a source: indirectMagic, not plain magic.
+                            let a = match a {
+                                EffectAction::Hurt("minecraft:magic", amount) => {
+                                    self.note_direct_entity(
+                                        "minecraft:indirect_magic",
+                                        source.clone(),
+                                    );
+                                    EffectAction::Hurt("minecraft:indirect_magic", amount)
+                                }
+                                a => a,
+                            };
                             self.apply_effect_action(a);
                         }
                     } else {
@@ -694,68 +721,47 @@ impl Game<'_> {
         }
     }
     /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash).
-    fn splash(&mut self, stack: &ItemStack, at: Vec3) {
+    fn splash(&mut self, stack: &ItemStack, at: Vec3, owner: Option<Text>) {
+        let block = [at.x, at.y, at.z].map(|v| v.floor() as i32);
         if &*stack.item == "minecraft:experience_bottle" {
             // ThrownExperienceBottle.onHit: the water-coloured splash (level
-            // event 2002) and 3 to 11 experience.
-            let pitch = self.world.random.next_float() * 0.1 + 0.9;
-            self.audio.play(
-                "minecraft:entity.splash_potion.break",
-                Some([at.x, at.y, at.z]),
-                1.0,
-                pitch,
-            );
-            for _ in 0..8 {
-                let v = [
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                    0.2,
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                ];
-                let p = horizon_client::particles::Particle::terrain(
-                    &mut self.world.random,
-                    [at.x, at.y, at.z],
-                    v,
-                    "item/splash_potion".into(),
-                    0x38_5DC6,
-                );
-                self.particles.push(p);
-            }
+            // event 2002, its sound 1053) and 3 to 11 experience.
+            self.level_event_at(2002, block, 0xFF38_5DC6u32 as i32);
+            self.level_event_at(1053, block, 0);
             let r = &mut self.world.random;
             let value = 3 + r.next_int_bound(5).unwrap_or(0) + r.next_int_bound(5).unwrap_or(0);
             self.spawn_orbs([at.x, at.y, at.z], value as u32);
             return;
         }
         let lingering = &*stack.item == "minecraft:lingering_potion";
-        let event = if lingering {
-            "minecraft:entity.lingering_potion.break"
-        } else {
-            "minecraft:entity.splash_potion.break"
-        };
-        let pitch = self.world.random.next_float() * 0.1 + 0.9;
-        self.audio.play(event, Some([at.x, at.y, at.z]), 1.0, pitch);
+        // AbstractThrownPotion.onHit: level event 2007 and sound 1054 for a
+        // potion with instant effects, 2002 and 1053 otherwise.
+        let potion = stack.potion().and_then(brewing::potion);
+        let instant = potion.is_some_and(|d| {
+            d.effects
+                .iter()
+                .any(|(id, ..)| brewing::effect(id).is_some_and(|e| e.instant))
+        });
         let color = brewing::potion_color(stack.potion());
-        for _ in 0..8 {
-            let v = [
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                0.2,
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-            ];
-            let p = horizon_client::particles::Particle::terrain(
-                &mut self.world.random,
-                [at.x, at.y, at.z],
-                v,
-                "item/splash_potion".into(),
-                color,
-            );
-            self.particles.push(p);
-        }
+        self.level_event_at(if instant { 2007 } else { 2002 }, block, color as i32);
+        self.level_event_at(if instant { 1054 } else { 1053 }, block, 0);
         let scale = if lingering { 0.25 } else { 1.0 };
-        let Some(def) = stack.potion().and_then(brewing::potion) else {
+        let Some(def) = potion else {
             return;
         };
         // Every player in range (`ThrownSplashPotion.applySplash` over
         // `LivingEntity`s, the players among them).
-        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale));
+        // Instant damage is indirectMagic(potion or cloud, owner), which the
+        // death message names by the owner, else by the potion or cloud.
+        let source = owner.unwrap_or_else(|| {
+            let entity = if lingering {
+                "entity.minecraft.area_effect_cloud"
+            } else {
+                "entity.minecraft.splash_potion"
+            };
+            Text::translate(entity, &[])
+        });
+        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale, &source));
         // Mobs take the instant effects (undead invert healing and harming).
         let undead = &self.res.stations().enchantments.entity_tags;
         let mut hits = Vec::new();

crates/horizon-client/src/game/raids.rs

@@ -235,7 +235,7 @@ impl Game<'_> {
         }
         out
     }
-    fn difficulty_id(&self) -> i32 {
+    pub(super) fn difficulty_id(&self) -> i32 {
         use horizon_world::food::Difficulty;
         match self.world.health_rules.difficulty {
             Difficulty::Peaceful => 0,