Merge pull request #2625 from ludovic111/feat/launcher-shortcuts

🤖 Agent: launcher-features-1: base main, merge-tree clean against main, CI verify + launcher green; queued.

.dockerignore

@@ -2,7 +2,6 @@
 target/
 .local/
 **/node_modules/
-website/
 benchmarks/
 packs/
 mods/

.gitattributes

@@ -2,5 +2,5 @@
 # where Git for Windows' core.autocrlf would check them out with CRLF.
 docs/launcher-commands.md text eol=lf
 docs/horizon-ctl-commands.md text eol=lf
-website/src/tokens.css text eol=lf
+crates/horizon-theme/tokens.css text eol=lf
 docs/api/*-reference.md text eol=lf

.github/workflows/ci.yml

@@ -73,6 +73,42 @@ jobs:
         run: |
           cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
           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
+  # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
+  launcher:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Does this pull request change the launcher or a crate it builds?
+        if: github.event_name == 'pull_request'
+        id: launcher
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python3 tools/ci/rust_changes.py --launcher "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
+      - name: Install Rust and the headers GPUI links against
+        if: steps.launcher.outputs.required != 'false'
+        run: |
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
+            libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
+          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+      - uses: Swatinem/rust-cache@v2
+        if: steps.launcher.outputs.required != 'false'
+        with:
+          workspaces: launcher
+          shared-key: launcher
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      - name: Check the launcher's formatting, lint and tests
+        if: steps.launcher.outputs.required != 'false'
+        working-directory: launcher
+        run: |
+          cargo +stable fmt --check
+          cargo +stable clippy --all-targets --locked -- -D warnings
+          cargo +stable test --locked --lib
   # Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
   # (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
   # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
@@ -108,6 +144,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/nightly.yml

@@ -8,7 +8,7 @@ name: nightly audit
 #   gh workflow run "nightly audit" -f dry_run=true    # the audit, without touching issues
 on:
   schedule:
-    # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:00 in Paris.
+    # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:07 in Paris today.
     - cron: '7 1 * * *'
     - cron: '7 2 * * *'
   workflow_dispatch:
@@ -31,14 +31,19 @@ jobs:
   audit:
     # The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform.
     runs-on: [self-hosted, horizon-game, macOS]
-    timeout-minutes: 150
+    timeout-minutes: 240  # every harness (~80 min) plus lan_integration (~40 min an attempt under load, retried)
     steps:
-      - name: 03:00 in Paris
+      - name: 03:07 in Paris
         id: when
+        env:
+          SCHEDULE: ${{ github.event.schedule }}
         run: |
-          hour=$(TZ=Europe/Paris date +%H)
-          if [[ "${{ github.event_name }}" == schedule && "$hour" != 03 ]]; then
-            echo "It is ${hour}:00 in Paris: the other schedule runs the audit."
+          # Which cron is 03:07 in Paris, from Paris's offset today: GitHub can start a schedule hours late, so the
+          # clock at start time can't tell (on 2026-10-26 both started after 04:00 Paris and both skipped).
+          offset=$(TZ=Europe/Paris date +%z)
+          ours=$([ "$offset" = +0200 ] && echo '7 1 * * *' || echo '7 2 * * *')
+          if [[ "${{ github.event_name }}" == schedule && "$SCHEDULE" != "$ours" ]]; then
+            echo "Paris is at UTC${offset} today: the '$ours' schedule runs the audit."
             echo "run=false" >> "$GITHUB_OUTPUT"
           else
             echo "run=true" >> "$GITHUB_OUTPUT"
@@ -66,7 +71,8 @@ jobs:
         run: |
           echo "since=$(date +%Y-%m-%dT%H:%M:%S)" >> "$GITHUB_OUTPUT"
           set +e
-          python3 tools/parity.py --all --timeout 1800 2>&1 | tee "$RUNNER_TEMP/audit.log"
+          # lan_integration (the whole lan_e2e suite) takes ~2,400 s under load, past the usual 1,800.
+          python3 tools/parity.py --all --timeout 3000 2>&1 | tee "$RUNNER_TEMP/audit.log"
           echo "exit=${PIPESTATUS[0]}" >> "$GITHUB_OUTPUT"
           { echo '```'; tail -40 "$RUNNER_TEMP/audit.log"; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
       - name: Issues for the harnesses that regressed

.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:
@@ -48,6 +48,9 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT"
       - name: The harnesses the merges since then can affect
+        id: harnesses
+        # A failure here is judged by the next step: the run passes when every failed harness passes again at HEAD.
+        continue-on-error: true
         env:
           PARITY_HOSTS: ''
           BASE_SHA: ${{ steps.base.outputs.sha }}
@@ -55,8 +58,8 @@ jobs:
           echo "Merges since ${BASE_SHA}:"
           git log --first-parent --format='  %h %s' "$BASE_SHA..HEAD"
           python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400
-      - name: The merge that broke them
-        if: failure()
+      - name: A flake, or the merge that broke them
+        if: steps.harnesses.outcome == 'failure'
         env:
           GH_TOKEN: ${{ github.token }}
           PARITY_HOSTS: ''
@@ -65,7 +68,7 @@ jobs:
           rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
           python3 tools/parity_main.py bisect "$BASE_SHA" --comment
       - name: Logs of the failed harnesses
-        if: failure()
+        if: steps.harnesses.outcome == 'failure'
         uses: actions/upload-artifact@v4
         with:
           name: parity-main-logs

.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` |
@@ -54,7 +57,8 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 Other top-level folders: `tools/` (harnesses and dev scripts), `tests/` (Python unit tests: `python3 -m
 unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/` (Java oracles),
-`website/` (playhorizon.dev; its paths are relative to `website/`), `docs/`, `.github/workflows/`.
+`docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private ludovic111/horizon-site: its build
+reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.
 
 ## Build and test fast
 
@@ -66,7 +70,7 @@ cargo build --profile fast -p horizon-client        # optimized, quick to link:
 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
 python3 tools/parity.py mob_ai sculk       # named harnesses
-python3 tools/lan_e2e.py --check chest     # two real games over LAN (host in-frame); --server-thread for the host on its server thread
+python3 tools/lan_e2e.py --check chest     # two real games over LAN (server-thread host); --in-frame compares the fallback
 python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 ```
 
@@ -117,16 +121,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` |
@@ -156,7 +160,7 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
    exactly as a LAN guest or a dedicated server's player does. This is what players run. Open
    `[server-thread]` issues list the gaps left.
 2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks
-   the world itself, one level that follows the player (`fn enter_dimension`). Most harnesses test this path.
+   the world itself, one level that follows the player (`fn enter_dimension`). Deterministic rule fixtures still use this path; player-facing integration uses the default server thread.
 
 LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths
 when you touch player-facing gameplay:
@@ -164,8 +168,8 @@ when you touch player-facing gameplay:
 ```sh
 cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T               # server thread
 cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame    # in-frame
-python3 tools/lan_e2e.py --check <name>                  # host in-frame, guest is a server client
-python3 tools/lan_e2e.py --server-thread --check <name>  # host on its server thread (portals, levels, distance, lava need it)
+python3 tools/lan_e2e.py --check <name>                  # host on its server thread, guest is a server client
+python3 tools/lan_e2e.py --in-frame --check <name>       # comparison (portals, levels, distance, lava need server-thread mode)
 python3 tools/parity.py dedicated_server server_entities server_player_damage
 ```
 

CONTRIBUTING.md

@@ -4,8 +4,8 @@ Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, a
 everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
 welcome on [Discord](https://discord.gg/HcTeMZxe5E).
 
-This repository holds the game, the launcher and the website, plus the tools, tests and docs that build, check and
-release them. Anything else (videos, Discord and other community material) lives elsewhere.
+This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
+The website (playhorizon.dev) is built in a separate repository from this one's README, `docs/api/` and roadmap. Anything else (videos, Discord and other community material) lives elsewhere.
 
 **Where to start: [playhorizon.dev/hub](https://playhorizon.dev/hub).** It shows what is being done now and next
 ([ROADMAP.md](ROADMAP.md) in the repository), the work board, good first tasks, and the forms to report a bug or

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"
@@ -1365,9 +1372,12 @@ dependencies = [
  "glam",
  "horizon-assets",
  "horizon-bench",
+ "horizon-client-core",
+ "horizon-command",
  "horizon-core",
  "horizon-dualsense",
  "horizon-friends",
+ "horizon-hdr",
  "horizon-mods",
  "horizon-protocol",
  "horizon-server-files",
@@ -1395,6 +1405,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"
@@ -1426,6 +1453,14 @@ dependencies = [
  "spake2",
 ]
 
+[[package]]
+name = "horizon-hdr"
+version = "0.1.0"
+dependencies = [
+ "ash",
+ "wgpu",
+]
+
 [[package]]
 name = "horizon-mod-sdk"
 version = "0.1.0"
@@ -1437,12 +1472,14 @@ dependencies = [
 name = "horizon-mods"
 version = "0.1.0"
 dependencies = [
+ "horizon-shader-api",
  "log",
  "minisign-verify",
  "serde",
  "serde_json",
  "sha2",
  "toml",
+ "wasmparser",
  "wasmtime",
  "wit-component",
  "wit-parser",
@@ -2082,6 +2119,13 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "minimap"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "minisign-verify"
 version = "0.3.0"
@@ -2953,6 +2997,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"
@@ -4140,6 +4191,28 @@ dependencies = [
  "wit-parser",
 ]
 
+[[package]]
+name = "wast"
+version = "254.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wat"
+version = "1.254.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e"
+dependencies = [
+ "wast",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.17"
@@ -4287,6 +4360,13 @@ dependencies = [
  "rustls-pki-types",
 ]
 
+[[package]]
+name = "welcome"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "wgpu"
 version = "30.0.1"
@@ -4998,6 +5078,7 @@ dependencies = [
  "wasm-encoder",
  "wasm-metadata",
  "wasmparser",
+ "wat",
  "wit-parser",
 ]
 

Cargo.toml

@@ -1,6 +1,45 @@
 [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-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", "mods/official/fps-overlay", "mods/official/keystrokes", "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/predator-missile",
+    "crates/horizon-mod-sdk/examples/welcome",
+    "crates/horizon-mod-sdk/examples/beacons",
+    "mods/official/fps-overlay",
+    "mods/official/keystrokes",
+    "mods/official/minimap",
+    "mods/official/zoom",
+    "xtask",
+    "mods/official/recipes",
+]
 resolver = "2"
 
 [workspace.package]

ROADMAP.md

@@ -134,7 +134,7 @@ Better tools for mod makers: a test runner that needs no game window, templates
 
 `cargo horizon-mod test` runs a mod's test scripts against a fake game snapshot ([#1816](https://github.com/ludovic111/horizon/issues/1816)) and, for server mods, scripted server events ([#1837](https://github.com/ludovic111/horizon/issues/1837)); the content template and the guides are merged ([#1859](https://github.com/ludovic111/horizon/issues/1859), [#1810](https://github.com/ludovic111/horizon/issues/1810), [docs/api/stability.md](docs/api/stability.md)). Left: templates for hud, server and machine mods, typed wrappers in the SDK, a frozen 0.1 compatibility mod that every runtime must load, a CI check that fails when a stable reference entry is removed without a new major version, and the SDK on crates.io once the API is stable.
 
-More: [website/docs/test-a-mod.md](website/docs/test-a-mod.md)
+More: [https://playhorizon.dev/docs/test-a-mod](https://playhorizon.dev/docs/test-a-mod)
 
 </details>
 
@@ -160,6 +160,66 @@ Translatable components resolved through the selected language for items, contai
 
 </details>
 
+#### Cooldowns drawn on items
+
+After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla.
+
+<details><summary>Technical</summary>
+
+Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763).
+
+More: [#1933](https://github.com/ludovic111/horizon/issues/1933)
+
+</details>
+
+#### Chat settings and team prefixes
+
+The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat.
+
+<details><summary>Technical</summary>
+
+Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce.
+
+More: [#1932](https://github.com/ludovic111/horizon/issues/1932) · [#1841](https://github.com/ludovic111/horizon/issues/1841)
+
+</details>
+
+#### A pointing hand over buttons
+
+The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3.
+
+<details><summary>Technical</summary>
+
+26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347).
+
+More: [#1897](https://github.com/ludovic111/horizon/issues/1897)
+
+</details>
+
+#### Ctrl+Backspace and scroll bars in menus
+
+Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable.
+
+<details><summary>Technical</summary>
+
+`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)).
+
+More: [#1884](https://github.com/ludovic111/horizon/issues/1884) · [#1931](https://github.com/ludovic111/horizon/issues/1931)
+
+</details>
+
+#### Chickens flap while they fall
+
+Chickens should flap their wings while they fall, not stand still in the air.
+
+<details><summary>Technical</summary>
+
+Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706).
+
+More: [#1892](https://github.com/ludovic111/horizon/issues/1892)
+
+</details>
+
 ### Rendering
 
 #### Shader packs, written again from scratch
@@ -250,7 +310,7 @@ Horizon should run well on small machines: integrated graphics, the Steam Deck,
 
 Partly done: an opt-in 60 FPS cap with fewer workers on battery, Far Detail Reduced for integrated GPUs and animated textures on the GPU (both shipped). Left: measured targets and fixes per class of machine (memory use, worker counts, startup) on a Steam Deck, old Intel and Apple Silicon Macs and 8 GB computers, reported on the Benchmarks page.
 
-More: [docs/benchmark.md](docs/benchmark.md) · [website/docs/performance.md](website/docs/performance.md)
+More: [docs/benchmark.md](docs/benchmark.md) · [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/performance)
 
 </details>
 
@@ -540,7 +600,9 @@ You can port a mod to Horizon with your own AI agent on your own computer. Horiz
 
 <details><summary>Technical</summary>
 
-A player runs their own agent locally with `horizon-ctl` and the MCP servers ([docs/agent-control.md](docs/agent-control.md)), `cargo horizon-mod`, `horizon-port-pack` and the parity harnesses as the check. Horizon writes the guide ([website/docs/agents.md](website/docs/agents.md), [docs/modpacks.md](docs/modpacks.md)) and runs no agents, accounts or keys for players. The No AI switch turns all of it off.
+A player runs their own agent locally with `horizon-ctl` and the MCP servers ([docs/agent-control.md](docs/agent-control.md)), `cargo horizon-mod`, `horizon-port-pack` and the parity harnesses as the check. Horizon writes the guide (playhorizon.dev/docs/agents, [docs/modpacks.md](docs/modpacks.md)) and runs no agents, accounts or keys for players. The No AI switch turns all of it off.
+
+More: [https://playhorizon.dev/docs/agents](https://playhorizon.dev/docs/agents)
 
 </details>
 
@@ -876,7 +938,9 @@ Run Horizon's built-in benchmark and share the report: every new computer makes
 
 <details><summary>Technical</summary>
 
-`horizon-launcher play --arg=--benchmark --arg=standard` writes a JSON report; `horizon-launcher data benchmark <report>` shows what would be sent and uploads it ([website/docs/performance.md](website/docs/performance.md)). Results from three installs with the same hardware appear on the Benchmarks page. Example: [#1711](https://github.com/ludovic111/horizon/issues/1711).
+`horizon-launcher play --arg=--benchmark --arg=standard` writes a JSON report; `horizon-launcher data benchmark <report>` shows what would be sent and uploads it (playhorizon.dev/docs/performance). Results from three installs with the same hardware appear on the Benchmarks page. Example: [#1711](https://github.com/ludovic111/horizon/issues/1711).
+
+More: [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/performance)
 
 </details>
 
@@ -902,56 +966,6 @@ Armour and tools in End city chests should come enchanted, as in vanilla.
 
 </details>
 
-#### Cooldowns drawn on items
-
-After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla.
-
-<details><summary>Technical</summary>
-
-Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763).
-
-</details>
-
-#### Chat settings and team prefixes
-
-The Hidden and Commands Only chat settings should hide chat, and team prefixes should appear before names in chat.
-
-<details><summary>Technical</summary>
-
-Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce.
-
-</details>
-
-#### A pointing hand over buttons
-
-The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3.
-
-<details><summary>Technical</summary>
-
-26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347).
-
-</details>
-
-#### Ctrl+Backspace and scroll bars in menus
-
-Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable.
-
-<details><summary>Technical</summary>
-
-`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)).
-
-</details>
-
-#### Chickens flap while they fall
-
-Chickens should flap their wings while they fall, not stand still in the air.
-
-<details><summary>Technical</summary>
-
-Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706).
-
-</details>
-
 ## Recently shipped
 
 - **OpenGL for old computers** (v0.2.63): Horizon now starts on old PCs whose graphics card has no Vulkan or DirectX 12 driver: it switches to OpenGL by itself, and Options > Graphics can pick OpenGL by hand. [#1917](https://github.com/ludovic111/horizon/issues/1917) · [#1920](https://github.com/ludovic111/horizon/issues/1920) · [#1936](https://github.com/ludovic111/horizon/issues/1936)

THIRD_PARTY_NOTICES.md

@@ -17,4 +17,5 @@ by The Pixelify Sans Project Authors, licensed under the SIL Open Font License 1
 
 `crates/horizon-theme/icons/pixel/*.svg` are icons from
 [Pixelarticons](https://github.com/halfmage/pixelarticons) by Gerrit Halfmann, under the MIT
-license (`crates/horizon-theme/icons/pixel/LICENSE-pixelarticons.txt`).
+license (`crates/horizon-theme/icons/pixel/LICENSE-pixelarticons.txt`). `star.svg` is Horizon's own, drawn on
+the same grid.

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

@@ -1,10 +1,11 @@
 //! `cargo horizon-mod check <file>`: what the registry checks of a submission,
 //! run anywhere: its kind's own checks (docs/api/mod-index.md), its signature
 //! when given a key, and for a mod a trial run in the sandbox: it must start,
-//! survive ticks, frames, a chat line and each of its commands, and import
-//! no more than its capabilities.
+//! survive ticks, frames, a chat line and each of its commands (a server mod:
+//! a player joining, chatting, typing them and leaving), and import no more
+//! than its capabilities.
 use horizon_mods::{
-    Clock, Mods, Output, Package, Player, Snapshot, Status,
+    Clock, GameMode, Mods, Output, Package, Player, ServerPlayer, Snapshot, Status,
     index::{self, Facts, Kind},
     manifest::component_imports,
 };
@@ -46,6 +47,7 @@ impl Report {
             "api": self.facts.api,
             "side": self.facts.side,
             "capabilities": self.facts.capabilities,
+            "api_level": self.facts.api_level,
             "game": self.facts.game,
             "requires": requires,
             "sha256": self.sha256,
@@ -69,6 +71,8 @@ impl Report {
         if let Some(side) = f.side {
             let side = serde_json::to_value(side).unwrap_or_default();
             out += &format!(", API {}, {}", f.api, side.as_str().unwrap_or("?"));
+        } else if self.kind == Kind::Shader {
+            out += &format!(", shader API {}", f.api);
         } else if !f.api.is_empty() {
             out += &format!(", format {}", f.api);
         }
@@ -84,6 +88,9 @@ impl Report {
             ")\n  {} bytes, SHA-256 {}, {signed}\n",
             self.size, self.sha256
         );
+        if let Some(level) = f.api_level {
+            out += &format!("  needs mod API level {level} or newer\n");
+        }
         for c in &f.capabilities {
             out += &format!("  may {}\n", c.describe());
         }
@@ -113,6 +120,7 @@ pub fn kind_of(path: &Path) -> Option<Kind> {
         "hmod" => Some(Kind::Mod),
         "hpack" => Some(Kind::Modpack),
         "zip" => Some(Kind::ResourcePack),
+        "hshader" => Some(Kind::Shader),
         _ => None,
     }
 }
@@ -191,46 +199,84 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
     if let Some(reason) = failed(&mods) {
         return Err(format!("it didn't start: {reason}"));
     }
-    report.commands = mods.commands().map(str::to_owned).collect();
+    let client: Vec<String> = mods.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 {
+        id: "00000000-0000-4000-8000-000000000001".into(),
+        name: "Steve".into(),
+        x: 0.5,
+        y: 64.0,
+        z: 0.5,
+        dimension: "minecraft:overworld".into(),
+        game_mode: GameMode::Survival,
+        health: 20.0,
+    };
+    let snapshot = |t: u64| Snapshot {
+        player: Some(Player {
+            x: 0.5 + t as f64 * 0.1,
+            y: 64.0,
+            z: 0.5,
+            yaw: 90.0,
+            pitch: 0.0,
+            health: 20.0,
+            food: 20,
+            dimension: "minecraft:overworld".into(),
+        }),
+        clock: Some(Clock {
+            game_time: t,
+            day_time: 1000 + t,
+        }),
+        players: vec![steve.clone()],
+        // The GUI of a 1280 x 720 window at scale 3.
+        gui_size: (427.0, 240.0),
+        ..Snapshot::default()
+    };
+    mods.set_snapshot(snapshot(0));
+    mods.player_joined(&steve);
     for t in 0..TICKS {
-        mods.set_snapshot(Snapshot {
-            player: Some(Player {
-                x: 0.5 + t as f64 * 0.1,
-                y: 64.0,
-                z: 0.5,
-                yaw: 90.0,
-                pitch: 0.0,
-                health: 20.0,
-                food: 20,
-                dimension: "minecraft:overworld".into(),
-            }),
-            clock: Some(Clock {
-                game_time: t,
-                day_time: 1000 + t,
-            }),
-            // The GUI of a 1280 x 720 window at scale 3.
-            gui_size: (427.0, 240.0),
-            ..Snapshot::default()
-        });
+        mods.set_snapshot(snapshot(t));
         mods.tick(t);
+        mods.server_tick(t);
         for _ in 0..FRAMES_PER_TICK {
             mods.frame(1.0 / 60.0);
         }
     }
     mods.chat("<Steve> hello");
-    for name in report.commands.clone() {
-        mods.command(&name);
+    mods.player_chat(&steve, "hello");
+    for name in &client {
+        mods.command(name);
     }
+    for name in &server {
+        mods.server_command(&steve, name);
+    }
+    mods.set_snapshot(Snapshot::default());
+    mods.player_left(&steve);
     for out in mods.drain() {
         report.output.push(match out {
             Output::Chat { text, .. } => format!("chat: {text}"),
-            Output::Feedback { text, error } => {
+            Output::Tell { text, .. } => format!("tell: {text}"),
+            Output::Broadcast { text, .. } => format!("broadcast: {text}"),
+            Output::Feedback { text, error } | Output::Reply { text, error, .. } => {
                 format!("{}: {text}", if error { "error" } else { "feedback" })
             }
             Output::Command { line } => format!("command: /{line}"),
+            Output::QuietCommands { lines, .. } => {
+                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")
             }
@@ -285,7 +331,7 @@ mod tests {
         .unwrap();
         assert!(e.contains("signature"), "{e}");
         let e = check(&pack, Kind::Shader, None, None).err().unwrap();
-        assert!(e.contains("shader packs open"), "{e}");
+        assert!(e.contains("horizon-shaders.toml"), "{e}");
         assert!(check(&pack, Kind::Mod, None, None).is_err());
     }
 }

crates/horizon-assets/src/item_model.rs

@@ -1031,19 +1031,22 @@ pub struct ItemModels {
 }
 
 impl ItemModels {
-    pub fn components(&self, stack: &StackView) -> Components {
-        let mut out = self
-            .prototypes
-            .get(&stack.item)
-            .cloned()
-            .unwrap_or_default();
+    /// The stack's components: its item's defaults with the stack's patch on top. A stack
+    /// with no patch (most stacks a screen draws) borrows the defaults instead of copying them.
+    pub fn components(&self, stack: &StackView) -> std::borrow::Cow<'_, Components> {
+        static NONE: Components = BTreeMap::new();
+        let prototype = self.prototypes.get(&stack.item).unwrap_or(&NONE);
+        if stack.patch.is_empty() {
+            return std::borrow::Cow::Borrowed(prototype);
+        }
+        let mut out = prototype.clone();
         for (key, value) in &stack.patch {
             match value {
                 Some(v) => out.insert(key.clone(), v.clone()),
                 None => out.remove(key),
             };
         }
-        out
+        std::borrow::Cow::Owned(out)
     }
     /// `ItemModelResolver.updateForTopItem`.
     pub fn resolve(&self, stack: &StackView, ctx: &Context, env: &dyn ItemEnv) -> ResolvedItem {

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(),
@@ -664,7 +664,9 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
         }
         "minecraft:trial_spawner" => {
             // `TrialSpawnerStateData.Packed` and `FullConfig`: every key is optional
-            // and defaulted by vanilla; they are kept as loaded.
+            // and defaulted by vanilla; they are kept as loaded. No `spawn_data` is
+            // added: an absent one loads as Optional.empty and is not stored, and
+            // an empty entity would keep the spawner from ever picking a mob.
             if let Tag::Compound(c) = tag {
                 for (k, v) in c {
                     let key = k.to_string_lossy();
@@ -676,12 +678,6 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
                     }
                 }
             }
-            if !f.out.contains_key(&"spawn_data".into()) {
-                f.put(
-                    "spawn_data",
-                    Tag::compound([("entity", Tag::Compound(Compound::new()))]),
-                );
-            }
         }
         "minecraft:vault" => {
             // `VaultConfig.DEFAULT` (when the config is absent): the trial key and the
@@ -827,6 +823,21 @@ mod tests {
         canonical(&snbt(s)).expect("known type")
     }
 
+    #[test]
+    fn a_trial_spawner_without_spawn_data_saves_none() {
+        let fresh = canon(
+            r#"{id:"minecraft:trial_spawner",x:1,y:2,z:3,normal_config:"minecraft:trial_chamber/ranged/skeleton/normal"}"#,
+        );
+        assert_eq!(fresh.get("spawn_data"), None);
+        let picked = canon(
+            r#"{id:"minecraft:trial_spawner",x:1,y:2,z:3,spawn_data:{entity:{id:"minecraft:skeleton"}}}"#,
+        );
+        assert_eq!(
+            picked.get("spawn_data"),
+            Some(&snbt(r#"{entity:{id:"minecraft:skeleton"}}"#))
+        );
+    }
+
     #[test]
     fn every_type_has_defaults() {
         for id in TYPES.iter().chain(NEWEST.iter()) {

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,9 +9,12 @@ 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" }
+horizon-hdr = { path = "../horizon-hdr" }
 horizon-world = { path = "../horizon-world" }
 horizon-protocol = { path = "../horizon-protocol" }
 # server.properties, eula.txt and the user lists, shared with horizon-server.

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/creative_mining_probe.rs

@@ -0,0 +1,48 @@
+use horizon_client::{
+    Result,
+    item_data::StackData,
+    items::{ItemStack, Items},
+};
+use horizon_world::nbt::Tag;
+use serde_json::Value;
+use std::{
+    fs::File,
+    io::{BufRead, BufReader, BufWriter, Write},
+    path::Path,
+};
+
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().collect();
+    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
+    let items = Items::catalog(&root)?;
+    let mut out = BufWriter::new(File::create(&args[2])?);
+    for line in BufReader::new(File::open(&args[1])?).lines() {
+        let row: Value = serde_json::from_str(&line?)?;
+        let mut stack = ItemStack::new(
+            row["item"].as_str().unwrap(),
+            row["count"].as_u64().unwrap() as u32,
+        );
+        match row["tool"].as_str().unwrap() {
+            "default" => {}
+            mode => {
+                let mut data = StackData::default();
+                let tool = if mode == "implicit" {
+                    Tag::compound([] as [(&str, Tag); 0])
+                } else {
+                    Tag::compound([(
+                        "can_destroy_blocks_in_creative",
+                        Tag::Byte(i8::from(mode == "allow")),
+                    )])
+                };
+                data.set_other("minecraft:tool", Some(tool));
+                stack.extra = Some(Box::new(data));
+            }
+        }
+        writeln!(
+            out,
+            "{}",
+            items.can_destroy_block(Some(&stack), row["creative"].as_bool().unwrap())
+        )?;
+    }
+    Ok(())
+}

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

@@ -0,0 +1,89 @@
+use horizon_client::{
+    Result,
+    cushion::{self, World},
+};
+use horizon_core::geometry::{Aabb, ShapeOp, Vec3, VoxelShape};
+use serde_json::Value;
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{BufRead, BufReader, BufWriter, Write},
+};
+
+struct Cell {
+    outline: VoxelShape,
+    collision: VoxelShape,
+    suffocating: bool,
+}
+struct Fixture(HashMap<[i32; 3], Cell>);
+impl World for Fixture {
+    fn outline_bounds(&self, p: [i32; 3]) -> Option<Aabb> {
+        self.0
+            .get(&p)?
+            .outline
+            .bounds()
+            .map(|b| b.move_by(Vec3::new(p[0] as f64, p[1] as f64, p[2] as f64)))
+    }
+    fn collision_shapes(&self, _: Aabb) -> Vec<VoxelShape> {
+        self.0
+            .iter()
+            .map(|(p, c)| {
+                c.collision
+                    .moved(Vec3::new(p[0] as f64, p[1] as f64, p[2] as f64))
+            })
+            .collect()
+    }
+    fn suffocating(&self, p: [i32; 3]) -> bool {
+        self.0.get(&p).is_some_and(|c| c.suffocating)
+    }
+}
+fn shape(value: &Value) -> Result<VoxelShape> {
+    let mut shape = VoxelShape::empty();
+    for b in value.as_array().unwrap() {
+        let f = |i: usize| b[i].as_f64().unwrap();
+        shape = shape.join(
+            &VoxelShape::from_box(Aabb::new(
+                Vec3::new(f(0), f(1), f(2)),
+                Vec3::new(f(3), f(4), f(5)),
+            ))?,
+            ShapeOp::OR,
+        )?;
+    }
+    Ok(shape)
+}
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().collect();
+    let mut out = BufWriter::new(File::create(&args[2])?);
+    for line in BufReader::new(File::open(&args[1])?).lines() {
+        let row: Value = serde_json::from_str(&line?)?;
+        let mut world = Fixture(HashMap::new());
+        for c in row["cells"].as_array().unwrap() {
+            let p = std::array::from_fn(|i| c[i].as_i64().unwrap() as i32);
+            world.0.insert(
+                p,
+                Cell {
+                    outline: shape(&c[3])?,
+                    collision: shape(&c[4])?,
+                    suffocating: c[5].as_bool().unwrap(),
+                },
+            );
+        }
+        let p = &row["pos"];
+        let (x, y, z) = (
+            p[0].as_f64().unwrap(),
+            p[1].as_f64().unwrap(),
+            p[2].as_f64().unwrap(),
+        );
+        let bounds = Aabb::new(
+            Vec3::new(x - 0.5, y, z - 0.5),
+            Vec3::new(x + 0.5, y + 0.25, z + 0.5),
+        );
+        writeln!(
+            out,
+            "{} {}",
+            cushion::can_place(&world, bounds),
+            cushion::survives(&world, bounds)
+        )?;
+    }
+    Ok(())
+}

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

@@ -9,7 +9,7 @@ use horizon_client::mesher::Vertex;
 use horizon_client::mobs::{
     Mob, MobData, MobTypes, Part, Species, allay,
     anim::{self, Poses, State},
-    aquatic, body_anim as b_anim, equine, guardian,
+    aquatic, bat, body_anim as b_anim, equine, guardian,
     keyframes::AnimationState,
     render, shulker, sniffer, species, tame,
 };
@@ -108,6 +108,22 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
     let flag = |k: &str| case[k].as_bool().unwrap_or(false);
     let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
     match species {
+        Species::Bat => {
+            mob.extra.flag = flag("isResting");
+            mob.anim.states[0].started = case["flyAnimationState"].as_f64().map(|v| v as f32);
+            mob.anim.states[1].started = case["restAnimationState"].as_f64().map(|v| v as f32);
+            if let Some(ticks) = case["@batTicks"].as_array() {
+                for (i, flags) in ticks.iter().enumerate() {
+                    mob.age = i as u32 + 1;
+                    bat::set_resting(mob, flags.as_i64().unwrap_or(0) & 1 != 0);
+                    if flag("@batInFrame") {
+                        bat::tick(mob);
+                    } else {
+                        bat::setup_animation_states(mob);
+                    }
+                }
+            }
+        }
         Species::Sheep => mob.extra.anim_ticks = num("eatTick") as i32,
         Species::Guardian | Species::ElderGuardian => {
             mob.anim.v[guardian::TAIL] = num("tailAnimation");
@@ -377,7 +393,7 @@ pub fn main() -> horizon_client::Result<()> {
             mob.extra.age = -24000;
         }
         mob.age = f("ageInTicks") as u32;
-        let state = State {
+        let mut state = State {
             pos: f("walkAnimationPos"),
             speed: f("walkAnimationSpeed"),
             age: f("ageInTicks"),
@@ -389,6 +405,20 @@ pub fn main() -> horizon_client::Result<()> {
         };
         let mut poses = Poses::new(&model);
         entity_state(&mut mob, def.species, case);
+        if let Some(ticks) = case["@walkTicks"].as_array() {
+            for speed in ticks {
+                mob.previous_limb_speed = mob.limb_speed;
+                mob.limb_speed += (speed.as_f64().unwrap() as f32 - mob.limb_speed) * 0.4;
+                mob.limb_position += mob.limb_speed;
+            }
+            if !case["@alive"].as_bool().unwrap() {
+                mob.health = 0.0;
+            }
+            let extracted = anim::state(&mob, f("@partial"));
+            state.pos = extracted.pos;
+            state.speed = extracted.speed;
+        }
+
         let flag = |k: &str| case[k].as_bool().unwrap_or(false);
         let num = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
         let started = |k: &str| AnimationState {
@@ -456,14 +486,6 @@ pub fn main() -> horizon_client::Result<()> {
                     roll_amount: num("rollAmount"),
                 },
             ),
-            Species::Bat => b_anim::bat(
-                p,
-                s,
-                flag("isResting"),
-                &started("flyAnimationState"),
-                &started("restAnimationState"),
-                &animations,
-            ),
             Species::Armadillo => b_anim::armadillo(
                 p,
                 s,
@@ -570,6 +592,7 @@ pub fn main() -> horizon_client::Result<()> {
                     pose,
                     num("maxCrossbowChageDuration"),
                     num("ticksUsingItem"),
+                    false,
                 );
             }
             Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator => {
@@ -590,7 +613,11 @@ pub fn main() -> horizon_client::Result<()> {
             }
             _ => anim::setup(&mob, s, p, &animations),
         }
-        out.push_str(&format!("{}\n", emit(&model, &mut poses, case, layer)));
+        let mut result = emit(&model, &mut poses, case, layer);
+        if case["@walkTicks"].is_array() {
+            result["walk"] = json!([state.pos, state.speed]);
+        }
+        out.push_str(&format!("{result}\n"));
     }
     fs::write(&args[2], out)?;
     Ok(())

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

@@ -23,6 +23,7 @@ fn stack(spec: &str) -> LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     };
     for e in parts {
         let (name, level) = e.rsplit_once(':').unwrap_or((e, "1"));

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

@@ -27,7 +27,9 @@ mod chat_screen_fixture;
 mod cloud_fixture;
 mod command_parse_fixture;
 mod container_screen_probe;
+mod creative_mining_probe;
 mod creative_search_fixture;
+mod cushion_placement_probe;
 mod emitter_particles_probe;
 mod enchanting_fixture;
 mod entity_anim_fixture;
@@ -83,6 +85,7 @@ mod sound_engine_fixture;
 mod sound_event_fixture;
 mod spawn_rules_fixture;
 mod sprint_probe;
+mod squid_client_probe;
 mod subtitle_fixture;
 mod tab_list_fixture;
 mod team_rules_fixture;
@@ -107,6 +110,9 @@ probes! {
     block_transform_fixture,
     breaking_fixture,
     camera_probe,
+    squid_client_probe,
+    creative_mining_probe,
+    cushion_placement_probe,
     cauldron_fixture,
     chat_screen_fixture,
     cloud_fixture,

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

@@ -49,6 +49,7 @@ struct Scenario {
     name: String,
     ticks: i32,
     time: i64,
+    difficulty: u8,
     rain: bool,
     thunder: bool,
     origin: [i32; 2],
@@ -85,11 +86,13 @@ fn parse(text: &str) -> Vec<Scenario> {
             "scenario" => {
                 s.name = f[1].to_owned();
                 s.time = 6000;
+                s.difficulty = 2;
                 for kv in &f[2..] {
                     let (k, v) = kv.split_once('=').unwrap_or((kv, ""));
                     match k {
                         "ticks" => s.ticks = v.parse().unwrap(),
                         "time" => s.time = v.parse().unwrap(),
+                        "difficulty" => s.difficulty = v.parse().unwrap(),
                         "rain" => s.rain = true,
                         "thunder" => s.thunder = true,
                         "levelseed" => {}
@@ -954,6 +957,10 @@ pub fn main() -> horizon_client::Result<()> {
             for flag in &spec.flags {
                 match flag.as_str() {
                     "persistent" => m.persistent = true,
+                    "named" => {
+                        m.custom_name = Some("Peaceful regression".into());
+                        m.persistent = true;
+                    }
                     "ridden" => {
                         m.extra.head = Some("minecraft:red_harness".into());
                         m.rider = Some(horizon_client::mobs::equine::Rider::default());
@@ -1050,6 +1057,7 @@ pub fn main() -> horizon_client::Result<()> {
                 velocity: Vec3::ZERO,
                 yaw: 0.0,
                 hero: false,
+                effects: Vec::new(),
                 uuid: PLAYER_UUID,
                 allies: Default::default(),
                 remote: false,
@@ -1090,7 +1098,7 @@ pub fn main() -> horizon_client::Result<()> {
                     block_tags: &items.block_tags,
                     biomes: &biomes,
                     mob_griefing: true,
-                    difficulty: LocalDifficulty::new(2, world.day_time, 0, 0.0),
+                    difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0),
                     end: false,
                     world_seed: 0,
                     // FlatLevelSource.getSeaLevel.

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

@@ -164,6 +164,8 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> {
         .iter()
         .filter_map(|e| match e {
             MotionEvent::Fall(e) => Some(e.trace()),
+            // The oracle's player wears no armor; the game applies this one.
+            MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt { .. }) => None,
             MotionEvent::Health(e) => Some(e.trace()),
             MotionEvent::Snowflake { position, velocity } => Some(format!(
                 "snowflake {:016x},{:016x},{:016x} {:016x},{:016x},{:016x}",

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

@@ -7,7 +7,7 @@ use horizon_client::{
     biome::{BiomeInfo, Biomes, GrassModifier},
     blocks::BlockFacts,
     chunk::{Chunk, Light, MIN_Y, index},
-    mesher::{MeshTables, Mesher, OPAQUE_LAYER, TerrainVertex},
+    mesher::{EMISSION_BITS, MeshTables, Mesher, OPAQUE_LAYER, TerrainVertex},
     models,
 };
 use horizon_core::biome::BiomeZoom;
@@ -161,7 +161,15 @@ fn scene(
                 .iter()
                 .map(|v| {
                     let ([x, y, z], [u, w]) = (v.pos, v.uv());
-                    json!([x, y, z, u, w, argb(v.color), light_coords(v.light)])
+                    json!([
+                        x,
+                        y,
+                        z,
+                        u,
+                        w,
+                        argb(v.color | EMISSION_BITS),
+                        light_coords(v.light)
+                    ])
                 })
                 .collect();
             quads.push(json!({"layer": layer, "sprite": sprite, "vertices": vertices}));

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

@@ -0,0 +1,51 @@
+use horizon_client::{
+    Result,
+    mobs::{Mob, MobTypes, aquatic},
+};
+use horizon_core::geometry::Vec3;
+use serde_json::Value;
+use std::{
+    fs::File,
+    io::{BufRead, BufReader, BufWriter, Write},
+    path::Path,
+    sync::Arc,
+};
+
+pub fn main() -> Result<()> {
+    let args: Vec<_> = crate::args().collect();
+    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
+    let types = MobTypes::load(&root)?;
+    let mut out = BufWriter::new(File::create(&args[2])?);
+    for line in BufReader::new(File::open(&args[1])?).lines() {
+        let row: Value = serde_json::from_str(&line?)?;
+        let kind = Arc::new(
+            types.types[&format!("minecraft:{}", row["species"].as_str().unwrap())].clone(),
+        );
+        let mut mob = Mob::new(1, kind, Vec3::ZERO, 0.0);
+        mob.fluids.in_water = row["water"].as_bool().unwrap();
+        mob.velocity = Vec3::new(
+            row["x"].as_f64().unwrap(),
+            row["y"].as_f64().unwrap(),
+            row["z"].as_f64().unwrap(),
+        );
+        mob.body_yaw = row["body"].as_f64().unwrap() as f32;
+        for (i, value) in row["v"].as_array().unwrap().iter().enumerate() {
+            mob.anim.v[i] = value.as_f64().unwrap() as f32;
+        }
+        if row["reset"].as_bool().unwrap() {
+            aquatic::squid_cycle_event(&mut mob);
+        }
+        let velocity = mob.velocity;
+        aquatic::squid_client_step(&mut mob);
+        assert_eq!(
+            velocity, mob.velocity,
+            "a remote animation must preserve packet velocity"
+        );
+        write!(out, "{:08x}", mob.body_yaw.to_bits())?;
+        for value in &mob.anim.v[..6] {
+            write!(out, " {:08x}", value.to_bits())?;
+        }
+        writeln!(out)?;
+    }
+    Ok(())
+}

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,
@@ -58,7 +61,10 @@ enum Animate {
     BubbleColumn {
         drag: bool,
     },
-    Fire,
+    /// `BaseFireBlock` (`SoulFireBlock.canBurn` is always true).
+    Fire {
+        soul: bool,
+    },
     /// An active sculk sensor.
     SculkSensor,
     /// Potent sulfur that is not dry.
@@ -101,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()),
@@ -116,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);
@@ -140,7 +161,8 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "bubble_column" => Animate::BubbleColumn {
             drag: prop("drag").as_deref() == Some("true"),
         },
-        "fire" | "soul_fire" => Animate::Fire,
+        "fire" => Animate::Fire { soul: false },
+        "soul_fire" => Animate::Fire { soul: true },
         "dried_ghast" => Animate::DriedGhast {
             waterlogged: prop("waterlogged").as_deref() == Some("true"),
         },
@@ -157,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;
@@ -190,6 +233,8 @@ pub struct AnimateTables {
     power_transmitter: Vec<bool>,
     /// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil).
     dried_ghast_sounds: Vec<bool>,
+    /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged).
+    burnable: Vec<bool>,
     /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`).
     ambient: Vec<Vec<(T, f32)>>,
 }
@@ -220,6 +265,21 @@ impl AnimateTables {
                 })
                 .collect()
         };
+        let behaviour: serde_json::Value =
+            serde_json::from_slice(&std::fs::read(root.join("block-behaviours.json"))?)?;
+        let ignite_odds = behaviour["fire"]["igniteOdds"].as_object();
+        let burnable = (0..registry.len() as u32)
+            .map(|id| {
+                // FireBlock.getIgniteOdds: a waterlogged state never burns.
+                registry.state(BlockStateId(id)).is_some_and(|s| {
+                    s.properties.get("waterlogged").map(String::as_str) != Some("true")
+                        && ignite_odds
+                            .and_then(|m| m.get(s.name.as_str()))
+                            .and_then(serde_json::Value::as_i64)
+                            .is_some_and(|odds| odds > 0)
+                })
+            })
+            .collect();
         let mut ambient = vec![Vec::new(); biomes.list.len()];
         for (name, &id) in &biomes.index {
             let path = root.join(format!(
@@ -248,6 +308,7 @@ impl AnimateTables {
             power_provider: by_state("minecraft:enchantment_power_provider"),
             power_transmitter: by_state("minecraft:enchantment_power_transmitter"),
             dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"),
+            burnable,
             ambient,
         })
     }
@@ -482,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,
@@ -663,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
@@ -683,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 {
@@ -955,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],
@@ -1103,7 +1218,7 @@ fn block_animate_tick(
                 }
             }
         }
-        Animate::Fire => {
+        Animate::Fire { soul } => {
             let r = engine.random();
             if next_int(r, 24) == 0 {
                 let (volume, pitch) = (1.0 + r.next_float(), r.next_float() * 0.7 + 0.3);
@@ -1115,6 +1230,55 @@ fn block_animate_tick(
                     pitch,
                 );
             }
+            // BaseFireBlock.animateTick: three large smoke above the fire, or
+            // two at each burnable neighbour's face when nothing burnable or
+            // sturdy supports it (SoulFireBlock.canBurn is always true).
+            let can_burn = |p: [i32; 3]| {
+                soul || tables
+                    .burnable
+                    .get(ctx.state(p).0 as usize)
+                    .copied()
+                    .unwrap_or(false)
+            };
+            let below = [pos[0], pos[1] - 1, pos[2]];
+            let sturdy = ctx.facts.get(ctx.state(below)).sturdy_full & (1 << 1) != 0;
+            if !can_burn(below) && !sturdy {
+                // (neighbour, coordinate axis, face at the axis' high end): the
+                // west, east, north, south and above faces, in vanilla order.
+                for (at, axis, high) in [
+                    ([pos[0] - 1, pos[1], pos[2]], 0usize, false),
+                    ([pos[0] + 1, pos[1], pos[2]], 0, true),
+                    ([pos[0], pos[1], pos[2] - 1], 2, false),
+                    ([pos[0], pos[1], pos[2] + 1], 2, true),
+                    ([pos[0], pos[1] + 1, pos[2]], 1, true),
+                ] {
+                    if !can_burn(at) {
+                        continue;
+                    }
+                    for _ in 0..2 {
+                        let r = engine.random();
+                        let d = [r.next_double(), r.next_double(), r.next_double()];
+                        let mut p = [fx + d[0], fy + d[1], fz + d[2]];
+                        // The face coordinate hugs the edge: `* 0.1F` (float).
+                        p[axis] = if high {
+                            f64::from(pos[axis]) + 1.0 - d[axis] * f64::from(0.1f32)
+                        } else {
+                            f64::from(pos[axis]) + d[axis] * f64::from(0.1f32)
+                        };
+                        add(engine, T::LargeSmoke, p, [0.0; 3]);
+                    }
+                }
+            } else {
+                for _ in 0..3 {
+                    let r = engine.random();
+                    let p = [
+                        fx + r.next_double(),
+                        fy + r.next_double() * 0.5 + 0.5,
+                        fz + r.next_double(),
+                    ];
+                    add(engine, T::LargeSmoke, p, [0.0; 3]);
+                }
+            }
         }
     }
 }
@@ -1138,32 +1302,71 @@ 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;
             for _ in 0..count {
-                make_campfire_smoke(engine, pos, signal);
+                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).
-pub fn make_campfire_smoke(engine: &mut ParticleEngine, pos: [i32; 3], signal: bool) {
+/// `CampfireBlock.makeParticles` (always visible, overriding the limiter);
+/// `smoking` adds the plain smoke puff at the logs.
+pub fn make_campfire_smoke(
+    engine: &mut ParticleEngine,
+    pos: [i32; 3],
+    signal: bool,
+    smoking: bool,
+) {
     let r = engine.random();
     let sign = |r: &mut LegacyRandom| if r.next_boolean() { 1.0 } else { -1.0 };
     let dx = r.next_double() / 3.0;
@@ -1177,6 +1380,17 @@ pub fn make_campfire_smoke(engine: &mut ParticleEngine, pos: [i32; 3], signal: b
         T::CampfireCosySmoke
     };
     engine.create(&ParticleOptions::simple(ty), [x, y, z], [0.0, 0.07, 0.0]);
+    if smoking {
+        let r = engine.random();
+        let dx = r.next_double() / 4.0 * sign(r);
+        let dz = r.next_double() / 4.0 * sign(r);
+        let at = [
+            f64::from(pos[0]) + 0.5 + dx,
+            f64::from(pos[1]) + 0.4,
+            f64::from(pos[2]) + 0.5 + dz,
+        ];
+        engine.create(&ParticleOptions::simple(T::Smoke), at, [0.0, 0.005, 0.0]);
+    }
 }
 
 #[cfg(test)]

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)]
@@ -156,7 +160,11 @@ pub struct ArrowState {
     /// `pickupItemStack`: what picking the arrow up gives.
     pub pickup_item: crate::items::ItemStack,
     pub no_physics: bool,
+    /// `AbstractArrow.getPierceLevel`.
     pub pierce: u8,
+    /// `piercingIgnoreEntityIds`: the entities a piercing arrow has gone
+    /// through (cleared when it sticks in a block).
+    pub pierced: Vec<Who>,
     /// `Entity.remainingFireTicks`.
     pub fire_ticks: i32,
     pub fall_distance: f64,
@@ -165,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,
@@ -199,6 +210,7 @@ impl ArrowState {
             pickup_item: crate::items::ItemStack::new("minecraft:arrow", 1),
             no_physics: false,
             pierce: 0,
+            pierced: Vec::new(),
             fire_ticks: 0,
             fall_distance: 0.0,
             fluids: EntityFluidInteraction::new([WATER, LAVA]),
@@ -206,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(),
@@ -362,6 +375,29 @@ fn bounds(at: Vec3) -> Aabb {
         Vec3::new(at.x + w, at.y + f64::from(HEIGHT), at.z + w),
     )
 }
+/// The bounding box of an arrow, or a thrown trident, at `at`.
+pub fn arrow_bounds(at: Vec3) -> Aabb {
+    bounds(at)
+}
+/// The blocks an arrow that moved from `from` to `to` was inside
+/// (`Entity.checkInsideBlocks`: the sweep of its box, 16 steps at most), for
+/// the blocks that react to it (`entityInside`).
+pub fn blocks_inside(from: Vec3, to: Vec3) -> Vec<BlockPos> {
+    let deflated = bounds(to).deflate(Vec3::new(
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+    ));
+    let mut inside = Vec::new();
+    let _ = sweep_intersected_blocks(from, to, deflated, 1_000_000, |p, iteration| {
+        if iteration >= 16 {
+            return false;
+        }
+        inside.push(p);
+        true
+    });
+    inside
+}
 /// `Projectile.lerpRotation`.
 fn lerp_rotation(mut old: f32, new: f32) -> f32 {
     while new - old < -180.0 {
@@ -423,18 +459,29 @@ 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();
-            ticker.st.removed = true;
+            // A piercing arrow flies on (`getPierceLevel() <= 0` discards).
+            if ticker.st.pierce == 0 {
+                ticker.st.removed = true;
+            }
         }
         EntityHit::Refused => ticker.turn_back(),
-        EntityHit::Deflected => {}
+        EntityHit::Deflected => {
+            // The deflection comes before `onHitEntity` adds the entity to
+            // `piercingIgnoreEntityIds`.
+            if ticker.st.pierce > 0 {
+                ticker.st.pierced.pop();
+            }
+        }
     }
     ticker.finish();
     p.stuck = st.in_ground;
@@ -464,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();
@@ -512,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 {
@@ -639,7 +696,8 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.life = 0;
     }
     /// `AbstractArrow.stepMoveAndHit`: the nearest entity on the way, else the
-    /// block (piercing is not modelled).
+    /// block. A piercing arrow that hits an entity here goes on from it next
+    /// tick (`finish_entity_hit`); vanilla's loop goes on within the same tick.
     fn step_move_and_hit(&mut self, from: Vec3, to: Vec3, targets: &[(Who, Aabb)]) -> Hit {
         let block = self.scene.clip(from, to);
         let end = block.map_or(to, |b| b.0);
@@ -649,10 +707,16 @@ 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;
             }
+            // canHitEntity: not an entity a piercing arrow has gone through.
+            if self.st.pierced.contains(who) {
+                continue;
+            }
             if let Some(at) = self.entity_hit(b, from, end, margin) {
                 // Sorted by the distance to the entity's position (the
                 // stable sort keeps the first of equals).
@@ -667,6 +731,15 @@ impl Ticker<'_, '_, '_, '_> {
         self.p.position = next;
         self.apply_effects_from_blocks(from, next);
         if let Some((who, at, _)) = best {
+            // AbstractArrow.onHitEntity: past pierce level + 1 entities the
+            // arrow is discarded before it hurts the next one.
+            if self.st.pierce > 0 {
+                if self.st.pierced.len() > usize::from(self.st.pierce) {
+                    self.st.removed = true;
+                    return Hit::None;
+                }
+                self.st.pierced.push(who);
+            }
             return Hit::Entity { who, at };
         }
         let Some((at, pos, face)) = block else {
@@ -706,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.
@@ -752,6 +846,7 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.shake = 7;
         self.p.set_critical(false);
         self.st.pierce = 0;
+        self.st.pierced.clear();
     }
     /// `Projectile.mayInteract`: a mob's arrows need `mob_griefing`.
     fn may_interact(&self) -> bool {

crates/horizon-client/src/benchmark.rs

@@ -323,10 +323,15 @@ const QUIET_MESHES_PER_S: f64 = 100.0;
 /// happened (`tools/perf_bench.py`'s `wait_loaded`). With `status.streaming`, the sections are
 /// drawn once no stage has held work for half a second: blocks changing after the load (fluids
 /// settling, random ticks) only remesh in bursts. Without it, meshing has to go quiet.
+///
+/// Right after a teleport (and at spawn) the game reports nothing queued and steady counts for over
+/// a second before it starts loading: the counts must change once, or stay full for 5 s, and the
+/// resident chunks reach [`view_chunks`], before "steady" means loaded.
 fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result<Instant, String> {
     let deadline = Instant::now() + LOAD_LIMIT;
     let (mut last, mut changed, mut meshing) = (None, Instant::now(), Instant::now());
     let mut previous: Option<(Instant, f64)> = None;
+    let (mut first, mut moved, began) = (None, false, Instant::now());
     while Instant::now() < deadline {
         let s = control.status();
         let now = Instant::now();
@@ -339,6 +344,19 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result<Insta
             (last, changed, previous, meshing) = (None, now, None, now);
         } else {
             let counts = (s["chunks"].as_u64(), s["generated_chunks"].as_u64());
+            let resident = counts.0.unwrap_or(0);
+            let min_chunks = view_chunks(s["render_distance"].as_u64().unwrap_or(0));
+            let first = *first.get_or_insert(counts);
+            moved = moved
+                || counts != first
+                || (min_chunks > 0
+                    && resident >= min_chunks
+                    && now - began > Duration::from_secs(5));
+            if min_chunks > 0 && (!moved || resident < min_chunks) {
+                (last, changed, previous, meshing) = (None, now, None, now);
+                thread::sleep(Duration::from_millis(50));
+                continue;
+            }
             if last != Some(counts) {
                 (last, changed) = (Some(counts), now);
             }
@@ -370,6 +388,12 @@ fn wait_loaded(control: &Control, near: impl Fn(&Value) -> bool) -> Result<Insta
     Err(format!("not loaded after {} s", LOAD_LIMIT.as_secs()))
 }
 
+/// 80% of the view circle (pi x RD^2): the game keeps 637 columns at RD 12 and 3725 at RD 32
+/// (`tools/perf_bench.py`'s `view_chunks`).
+fn view_chunks(distance: u64) -> u64 {
+    (0.8 * std::f64::consts::PI * (distance * distance) as f64) as u64
+}
+
 /// Vanilla's yaw facing from `start` to `end`.
 fn yaw(start: [f64; 3], end: [f64; 3]) -> f64 {
     (-(end[0] - start[0])).atan2(end[2] - start[2]).to_degrees()
@@ -420,6 +444,13 @@ mod tests {
         assert!(scenes("nether").is_none());
     }
 
+    #[test]
+    fn view_chunks_matches_perf_bench() {
+        assert_eq!(view_chunks(12), 361);
+        assert_eq!(view_chunks(32), 2573);
+        assert_eq!(view_chunks(0), 0);
+    }
+
     #[test]
     fn yaw_matches_vanilla() {
         // South (+Z) is 0, west (-X) 90, east (+X) -90.

crates/horizon-client/src/bin/horizon-ctl/commands.rs

@@ -143,6 +143,7 @@ const PAGES: Ty = Ty::Enum(&[
     "font",
     "packs",
     "mods",
+    "shader-packs",
     "graphics",
     "graphics-advanced",
     "extras",

crates/horizon-client/src/bin/horizon-ctl/main.rs

@@ -610,12 +610,17 @@ mod tests {
 
     #[test]
     fn unreachable_games_fail_with_status_3() {
-        let mut s = Session::new(std::env::temp_dir().join("horizon-ctl-nobody.sock"), None);
+        let home =
+            std::env::temp_dir().join(format!("horizon-ctl-unreachable-{}", std::process::id()));
+        std::fs::create_dir_all(&home).unwrap();
+        let mut s = Session::new(home.join("nobody.sock"), None);
+        s.home = home.clone();
         let f = s.run(&["state".to_owned()]).unwrap_err();
         assert_eq!(f.status, UNREACHABLE);
         assert_eq!(f.reply["kind"], "connection");
         let f = s.run(&["sleep".to_owned(), "x".to_owned()]).unwrap_err();
         assert_eq!(f.status, USAGE);
+        std::fs::remove_dir_all(home).unwrap();
     }
 
     #[test]

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};
 
@@ -28,8 +28,13 @@ pub struct BiomeInfo {
     pub spawn_costs: HashMap<String, crate::mobs::spawn_selection::SpawnCost>,
     /// The `gameplay/creature_world_gen_spawn_probability` attribute.
     pub creature_probability: f32,
+    /// The `gameplay/increased_fire_burnout` attribute (jungles, swamps, peaks,
+    /// mushroom fields).
+    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,
@@ -42,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>,
@@ -128,7 +153,11 @@ impl Biomes {
                     attributes["minecraft:gameplay/creature_world_gen_spawn_probability"]
                         .as_f64()
                         .unwrap_or(0.1) as f32,
+                increased_fire_burnout: attributes["minecraft:gameplay/increased_fire_burnout"]
+                    .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/block_entity_anim.rs

@@ -648,6 +648,61 @@ impl Conduit {
     }
 }
 
+/// What `ConduitBlockEntity.serverTick`'s 40-tick check decided.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ConduitCheck {
+    /// The shape changed: `CONDUIT_ACTIVATE` (true) or `CONDUIT_DEACTIVATE`.
+    pub toggled: Option<bool>,
+    /// The frame blocks counted, while the conduit is active: `applyEffects`
+    /// and `updateAndAttackTarget` follow (the attack needs 42 or more).
+    pub frames: Option<usize>,
+}
+
+/// `ConduitBlockEntity` (server side): what `serverTick` keeps between ticks.
+#[derive(Clone, Debug, Default)]
+pub struct ConduitServer {
+    shape: Conduit,
+    /// `destroyTarget`: the mob id of the enemy being struck.
+    pub target: Option<u32>,
+    next_ambient_sound: i64,
+}
+
+impl ConduitServer {
+    /// The `gameTime % 40` part of `serverTick`: the shape is checked again.
+    pub fn check(
+        &mut self,
+        pos: [i32; 3],
+        game_time: i64,
+        is_water: impl Fn([i32; 3]) -> bool,
+        is_frame: impl Fn([i32; 3]) -> bool,
+    ) -> Option<ConduitCheck> {
+        if game_time % 40 != 0 {
+            return None;
+        }
+        let active = self.shape.update_shape(pos, &is_water, &is_frame);
+        let toggled = (active != self.shape.is_active).then_some(active);
+        self.shape.is_active = active;
+        Some(ConduitCheck {
+            toggled,
+            frames: active.then_some(self.shape.effect_blocks.len()),
+        })
+    }
+    /// The sounds of an active conduit at the end of `serverTick`: whether
+    /// `CONDUIT_AMBIENT` (every 80 ticks) and `CONDUIT_AMBIENT_SHORT` (every
+    /// 60 to 99 ticks) play.
+    pub fn ambient(&mut self, game_time: i64, random: &mut impl RandomSource) -> (bool, bool) {
+        if !self.shape.is_active {
+            return (false, false);
+        }
+        let short = game_time > self.next_ambient_sound;
+        if short {
+            self.next_ambient_sound =
+                game_time + 60 + i64::from(random.next_int_bound(40).unwrap_or(0));
+        }
+        (game_time % 80 == 0, short)
+    }
+}
+
 /// `SkullBlockEntity` animation (client ticker of dragon and piglin heads).
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Skull {
@@ -832,6 +887,8 @@ pub struct BlockEntityAnims {
     pub gateways: FxHashMap<[i32; 3], EndGateway>,
     /// The integrated server's copies of the gateways (`portalTick`).
     pub gateway_servers: FxHashMap<[i32; 3], EndGateway>,
+    /// The integrated server's copies of the conduits (`serverTick`).
+    pub conduit_servers: FxHashMap<[i32; 3], ConduitServer>,
     /// The client level's random (conduit particles).
     pub random: LegacyRandom,
     /// [`Ticker`] by block state id (see [`BlockEntityAnims::classify`]).
@@ -854,6 +911,7 @@ impl Default for BlockEntityAnims {
             pots: FxHashMap::default(),
             gateways: FxHashMap::default(),
             gateway_servers: FxHashMap::default(),
+            conduit_servers: FxHashMap::default(),
             random: LegacyRandom::new(0x6c6576656c),
             kinds: Vec::new(),
             present: Vec::new(),
@@ -909,6 +967,7 @@ impl BlockEntityAnims {
         self.pots.retain(|p, _| keep(*p));
         self.gateways.retain(|p, _| keep(*p));
         self.gateway_servers.retain(|p, _| keep(*p));
+        self.conduit_servers.retain(|p, _| keep(*p));
     }
     /// `getOpenNess(partial)` of the chest or ender chest at `pos`.
     pub fn lid(&self, pos: [i32; 3], partial: f32) -> f32 {

crates/horizon-client/src/block_entity_render.rs

@@ -558,12 +558,11 @@ fn frac(x: f32) -> f32 {
 /// `StringSplitter.splitLines(...).get(0)` for plain text: the first line,
 /// wrapped at the last space that fits or mid-word when none does.
 fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> String {
-    let chars: Vec<char> = line.chars().collect();
     let mut width = 0.0;
     let mut last_space = None;
-    for (i, &c) in chars.iter().enumerate() {
+    for (i, c) in line.char_indices() {
         if c == '\n' {
-            return chars[..i].iter().collect();
+            return line[..i].to_owned();
         }
         if c == ' ' {
             last_space = Some(i);
@@ -572,9 +571,11 @@ fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> Stri
         if width > max_width {
             let end = match last_space {
                 Some(s) if s > 0 => s,
-                _ => i.max(1),
+                _ if i > 0 => i,
+                // The first char alone is too wide: take that one char.
+                _ => c.len_utf8(),
             };
-            return chars[..end].iter().collect();
+            return line[..end].to_owned();
         }
     }
     line.to_owned()
@@ -2098,4 +2099,13 @@ mod tests {
         assert_eq!(out[1].pos, [2.0, 0.0, 0.0]);
         assert_eq!(out[2].uv, [0.5, 0.5]);
     }
+
+    #[test]
+    fn first_line_wraps_on_bytes_without_splitting_a_char() {
+        let advance = |c: char| if c == ' ' { 4.0 } else { 6.0 };
+        assert_eq!(first_line("ab cd ef", 13.0, &advance), "ab");
+        assert_eq!(first_line("abcdef", 13.0, &advance), "ab");
+        assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}");
+        assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab");
+    }
 }

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,25 +159,82 @@ 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
+    }
+
+    /// `getNumberOfItemsToShow`: a full grid shows 11 and a `+N`, so the last
+    /// row keeps its fourth cell for the count.
+    pub fn shown_count(&self) -> usize {
+        let count = self.items.len();
+        let available: usize = if count > 12 { 11 } else { 12 };
+        let on_last_row = count % 4;
+        let empty = if on_last_row == 0 { 0 } else { 4 - on_last_row };
+        count.min(available.saturating_sub(empty))
+    }
+
+    /// The items the tooltip shows, and how many sit beyond them.
+    pub fn shown(&self) -> (&[ItemStack], u32) {
+        let n = self.shown_count();
+        let hidden = self.items[n..].iter().map(|s| s.count).sum();
+        (&self.items[..n], hidden)
+    }
+
+    /// The `Fraction` weight as the float the progress bar reads.
+    pub fn weight_fraction(&self) -> f32 {
+        self.weight.n as f32 / self.weight.d as f32
+    }
+
+    /// `Fraction.ONE`: a full bundle draws the full bar and says so.
+    pub fn is_full(&self) -> bool {
+        self.weight.n >= self.weight.d
+    }
+
     /// `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;
@@ -190,3 +252,184 @@ mod tests {
         assert_eq!(over.how_many(Weight::new(1, 64)), 0);
     }
 }
+
+// ------------------------------------------------------------- the tooltip
+
+/// `ClientBundleTooltip`'s geometry, relative to the tooltip box's top-left:
+/// the 96 pixel column of a 4 wide slot grid and the progress bar under it.
+#[derive(Clone, Debug, PartialEq)]
+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 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
+    /// the weight fills it (the full sprite).
+    pub bar: [f32; 2],
+    pub fill: f32,
+    pub full: bool,
+    /// `item.minecraft.bundle.empty` / `.full`, centred over the bar.
+    pub label: Option<&'static str>,
+    /// An empty bundle's description, wrapped at `width` from here.
+    pub empty_description: Option<[f32; 2]>,
+}
+
+/// The tooltip of a bundle's contents (`ClientBundleTooltip`), or None when
+/// the stack is not a bundle. `x`/`y` are the box's top-left, `box_width` the
+/// tooltip's width, which the component is centred in.
+pub fn tooltip_layout(
+    items: &Items,
+    stack: &ItemStack,
+    x: f32,
+    y: f32,
+    box_width: f32,
+) -> Option<TooltipLayout> {
+    let contents = Contents::of(items, stack)?;
+    let offset = ((box_width - 96.0) / 2.0).floor();
+    if contents.items().is_empty() {
+        // The description takes the top; the bar follows it.
+        let description_height = 9.0 * 2.0;
+        return Some(TooltipLayout {
+            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,
+            full: false,
+            label: Some("item.minecraft.bundle.empty"),
+            empty_description: Some([x + offset, y]),
+        });
+    }
+    let (shown, hidden) = contents.shown();
+    // `gridSizeY` counts `slotCount()` (at most twelve), not the slots the
+    // overflow count leaves room for.
+    let rows = contents.items().len().min(12).div_ceil(4).max(1);
+    let grid_height = rows as f32 * 24.0;
+    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;
+    for row in 1..=rows {
+        for column in 1..=4 {
+            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 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;
+            }
+        }
+    }
+    let weight = contents.weight_fraction();
+    Some(TooltipLayout {
+        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.
+        fill: (weight * 94.0).trunc().clamp(0.0, 94.0),
+        full: contents.is_full(),
+        label: if contents.is_full() {
+            Some("item.minecraft.bundle.full")
+        } else {
+            None
+        },
+        empty_description: None,
+    })
+}
+
+#[cfg(test)]
+mod tooltip_tests {
+    use super::*;
+
+    /// The prepared resources, when they are on this machine: the tooltip
+    /// asks the item registry whether a stack is a bundle.
+    fn items() -> Option<Items> {
+        let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client/26.3");
+        if !root.join("items.json").exists() {
+            return None;
+        }
+        let assets = crate::assets::Assets::load(&root).ok()?;
+        let facts = crate::blocks::BlockFacts::load(&root, assets.registry).ok()?;
+        Items::load(&root, assets.registry, &facts).ok()
+    }
+
+    fn bundle_with(counts: &[(&str, u32)]) -> ItemStack {
+        let mut bundle = ItemStack::new("minecraft:bundle", 1);
+        bundle.data_mut().bundle_contents = counts
+            .iter()
+            .map(|(item, n)| ItemStack::new(item, *n))
+            .collect();
+        bundle
+    }
+
+    #[test]
+    fn a_grid_shows_twelve_stacks_and_counts_the_rest() {
+        let Some(items) = items() else { return };
+        let twelve: Vec<(&str, u32)> = (0..12).map(|_| ("minecraft:stone", 1)).collect();
+        let layout = tooltip_layout(&items, &bundle_with(&twelve), 0.0, 0.0, 96.0).unwrap();
+        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 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]);
+        // A wider tooltip centres the 96 pixel column in it.
+        let centred = tooltip_layout(&items, &bundle_with(&twelve), 0.0, 0.0, 120.0).unwrap();
+        assert_eq!(centred.slots[0].0[0], 12.0 + 96.0 - 24.0);
+        // Thirteen stacks: `getNumberOfItemsToShow` leaves the last row room
+        // for the count, so 8 slots show and `+6` (four stones and two dirt)
+        // takes the first cell.
+        let mut counts = twelve;
+        counts.push(("minecraft:dirt", 2));
+        let layout = tooltip_layout(&items, &bundle_with(&counts), 0.0, 0.0, 96.0).unwrap();
+        assert_eq!(layout.slots.len(), 8);
+        assert_eq!(layout.overflow, Some(([96.0 - 24.0, 48.0], 6)));
+    }
+
+    #[test]
+    fn the_bar_fills_with_the_weight_and_an_empty_bundle_explains_itself() {
+        let Some(items) = items() else { return };
+        let layout = tooltip_layout(&items, &bundle_with(&[]), 4.0, 8.0, 96.0).unwrap();
+        assert!(layout.slots.is_empty());
+        assert_eq!(layout.fill, 0.0);
+        assert_eq!(layout.label, Some("item.minecraft.bundle.empty"));
+        assert_eq!(layout.empty_description, Some([4.0, 8.0]));
+        assert_eq!(layout.bar, [4.0, 8.0 + 18.0 + 4.0]);
+        // A bundle holding one 64 stack is full: the whole bar, the full label.
+        let layout = tooltip_layout(
+            &items,
+            &bundle_with(&[("minecraft:stone", 64)]),
+            0.0,
+            0.0,
+            96.0,
+        )
+        .unwrap();
+        assert!(layout.full);
+        assert_eq!(layout.fill, 94.0);
+        assert_eq!(layout.label, Some("item.minecraft.bundle.full"));
+        // Something that is not a bundle has no component.
+        let dirt = ItemStack::new("minecraft:dirt", 1);
+        assert!(tooltip_layout(&items, &dirt, 0.0, 0.0, 96.0).is_none());
+    }
+}

crates/horizon-client/src/chat_tests.rs

@@ -436,3 +436,34 @@ fn the_chat_option_filters_the_lines_both_ways() {
     chat.set_abilities(&font, ChatAbilities::new(ChatVisibility::Full));
     assert_eq!(shown(&chat), ["client", "server", "player"]);
 }
+
+/// The in-frame LAN host's chat: a guest's line is a player message, so the
+/// Chat option's player-message permission hides it at Commands Only and
+/// Hidden; command feedback (`/list`, `/tp`) is a system message and stays
+/// at Commands Only.
+#[test]
+fn a_guests_line_follows_the_player_message_permission() {
+    let font = font();
+    let shown = |visibility, source| {
+        let mut chat = Chat::default();
+        chat.set_abilities(&font, ChatAbilities::new(visibility));
+        chat.add_message(&font, Text::literal("line"), None, source, 0, false);
+        chat.messages.len()
+    };
+    for (visibility, player, system) in [
+        (ChatVisibility::Full, 1, 1),
+        (ChatVisibility::System, 0, 1),
+        (ChatVisibility::Hidden, 0, 0),
+    ] {
+        assert_eq!(
+            shown(visibility, ChatSource::Player),
+            player,
+            "{visibility:?}"
+        );
+        assert_eq!(
+            shown(visibility, ChatSource::Server),
+            system,
+            "{visibility:?}"
+        );
+    }
+}

crates/horizon-client/src/chunk.rs

@@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy {
     Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed))
 }
 
+/// Frees `columns` (`count` of them) on a short-lived thread of its own
+/// when there are many: a teleport or a dimension change drops a few
+/// thousand columns at once, and freeing their sections took the frame
+/// 15-20 ms. A few are freed here.
+pub fn free_columns<T: Send + 'static>(columns: T, count: usize) {
+    if count < 64 {
+        return;
+    }
+    // Should the thread not start, the closure drops `columns` here.
+    let _ = std::thread::Builder::new()
+        .name("Chunk freeing".into())
+        .spawn(move || drop(columns));
+}
+
 /// Sizes the block states' global palette for a registry of `states`.
 pub fn set_block_states(states: usize) {
     let bits = horizon_core::paletted::ceil_log2(states).max(16);
@@ -147,6 +161,9 @@ pub struct Chunk {
     /// Structure starts reaching into this chunk (`structures.References`):
     /// structure id and the start's chunk.
     pub structure_refs: Vec<(Arc<str>, (i32, i32))>,
+    /// The starts generation made in this chunk (`structures.starts`), saved
+    /// with the state their placement has reached by then.
+    pub structure_starts: Vec<Arc<horizon_world::worldgen::structure::start::StructureStart>>,
 }
 impl Chunk {
     pub fn empty(x: i32, z: i32) -> Self {
@@ -164,6 +181,7 @@ impl Chunk {
             block_entities: Vec::new(),
             block_names: Vec::new(),
             structure_refs: Vec::new(),
+            structure_starts: Vec::new(),
             postprocess: Vec::new(),
             saved: None,
             entities: Vec::new(),

crates/horizon-client/src/clipboard.rs

@@ -346,6 +346,11 @@ mod tests {
         assert_eq!(filter_text(s, true), "abc\nde\u{80}");
         assert_eq!(strip_formatting("§aRed§r §zx§"), "Red §zx§");
         assert_eq!(helper_clipboard_contents("§lone\r\ntwo"), "one\ntwo");
+        // TextFieldHelper.getClipboardContents runs before insertText's filter.
+        assert_eq!(
+            filter_text(&helper_clipboard_contents("§aHello"), false),
+            "Hello"
+        );
     }
 
     struct Field {

crates/horizon-client/src/container_screen.rs

@@ -275,4 +275,30 @@ mod tests {
             Release::Click(Input::QuickMove)
         );
     }
+
+    /// A press whose release never arrives (the pointer left the window, or
+    /// the screen closed first) leaves `isQuickCrafting` set; the next screen
+    /// starts with its own state, as `AbstractContainerScreen` does, so the
+    /// reset the game runs on open/close makes clicks work again.
+    #[test]
+    fn a_lost_release_does_not_wedge_the_next_screen() {
+        let mut clicks = Clicks::default();
+        let slot = Target::<usize>::Slot(3);
+        // Pressed with a stack carried: a quick craft drag starts, and its
+        // release is lost.
+        assert_eq!(clicks.press(&slot, Button::Left, false, false, false), None);
+        assert!(clicks.quick_crafting().is_some());
+        assert_eq!(
+            clicks.press(&slot, Button::Left, true, false, false),
+            None,
+            "the stuck drag swallows the next press"
+        );
+        // A new screen: fresh state, so the press is a normal click again.
+        clicks = Clicks::default();
+        assert!(clicks.quick_crafting().is_none());
+        assert_eq!(
+            clicks.press(&slot, Button::Left, true, false, false),
+            Some(Input::Pickup)
+        );
+    }
 }

crates/horizon-client/src/containers.rs

@@ -49,6 +49,17 @@ pub struct Furnace {
     /// rather than per item, and a save keeps it as the `RecipesUsed` compound.
     pub recipes_used: HashMap<String, u32>,
 }
+/// The key `recipes_used` keeps a recipe under: its full id, as vanilla's `ResourceKey<Recipe>`
+/// writes it in `RecipesUsed`. Horizon's own recipe ids are file names without the namespace, so
+/// keeping both forms would write a key twice, and vanilla refuses such a furnace
+/// ("Duplicate entry for key").
+pub fn recipe_used_key(id: &str) -> String {
+    if id.contains(':') {
+        id.to_owned()
+    } else {
+        format!("minecraft:{id}")
+    }
+}
 /// A hopper's slots: the only plain container with five.
 pub const HOPPER_SLOTS: usize = 5;
 
@@ -83,8 +94,68 @@ pub enum BlockEntity {
     Beehive(Box<crate::beehive::Beehive>),
     /// `CommandBlockEntity` of the three command blocks (`crate::command_block`).
     CommandBlock(Box<crate::command_block::CommandBlock>),
+    /// `CampfireBlockEntity` of campfires and soul campfires.
+    Campfire(Box<Campfire>),
     /// `SkullBlockEntity` of every skull and head block.
     Skull(Skull),
+    /// `DaylightDetectorBlockEntity`: no data, only the ticker
+    /// (`DaylightDetectorBlock.tickEntity`).
+    DaylightDetector,
+}
+/// `CampfireBlockEntity`: four cooking slots, each with its
+/// `cookingProgress` and `cookingTime` (the recipe's).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Campfire {
+    pub items: [Option<ItemStack>; 4],
+    pub progress: [i32; 4],
+    pub total: [i32; 4],
+}
+impl Campfire {
+    /// `placeFood`'s slot: the first empty one, given the item's
+    /// `campfire_cooking` time; it takes one item of `held`.
+    pub fn place_food(&mut self, held: &mut ItemStack, cooking_time: i32) -> bool {
+        let Some(slot) = self.items.iter().position(Option::is_none) else {
+            return false;
+        };
+        self.total[slot] = cooking_time;
+        self.progress[slot] = 0;
+        self.items[slot] = Some(ItemStack {
+            count: 1,
+            ..held.clone()
+        });
+        held.count = held.count.saturating_sub(1);
+        true
+    }
+    /// `cookTick` (lit): each item's progress rises by one; the slots whose
+    /// progress reached their cooking time give up their item (the caller
+    /// drops its result).
+    pub fn cook_tick(&mut self) -> Vec<(usize, ItemStack)> {
+        let mut done = Vec::new();
+        for i in 0..4 {
+            if self.items[i].is_none() {
+                continue;
+            }
+            self.progress[i] += 1;
+            if self.progress[i] >= self.total[i]
+                && let Some(item) = self.items[i].take()
+            {
+                done.push((i, item));
+            }
+        }
+        done
+    }
+    /// `cooldownTick` (unlit): the progress falls by two, no lower than 0.
+    /// Whether anything changed (`setChanged`).
+    pub fn cooldown_tick(&mut self) -> bool {
+        let mut changed = false;
+        for i in 0..4 {
+            if self.progress[i] > 0 {
+                changed = true;
+                self.progress[i] = (self.progress[i] - 2).clamp(0, self.total[i]);
+            }
+        }
+        changed
+    }
 }
 /// `SkullBlockEntity`: the player profile the head shows (kept as loaded:
 /// a compound, or a string when it names a player only), the note block
@@ -295,6 +366,9 @@ impl BlockEntity {
         if is_skull(name) {
             return Some(Self::Skull(Skull::default()));
         }
+        if name == "minecraft:daylight_detector" {
+            return Some(Self::DaylightDetector);
+        }
         if name == "minecraft:beacon" {
             return Some(Self::Beacon(Box::new(Beacon {
                 last_check_y: i32::MIN / 2,
@@ -304,6 +378,9 @@ impl BlockEntity {
         if name == "minecraft:brewing_stand" {
             return Some(Self::Brewing(Box::new(crate::brewing::BrewingStand::new())));
         }
+        if name == "minecraft:campfire" || name == "minecraft:soul_campfire" {
+            return Some(Self::Campfire(Box::default()));
+        }
         let size = match name {
             "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => 27,
             n if n.ends_with("copper_chest") => 27,
@@ -341,6 +418,8 @@ impl BlockEntity {
             Self::Beehive(_) => "minecraft:beehive",
             Self::CommandBlock(_) => "minecraft:command_block",
             Self::Skull(_) => "minecraft:skull",
+            Self::DaylightDetector => "minecraft:daylight_detector",
+            Self::Campfire(_) => "minecraft:campfire",
         }
     }
     pub fn contents(&self) -> Vec<ItemStack> {
@@ -357,11 +436,13 @@ impl BlockEntity {
             | Self::Vault(_)
             | Self::Beehive(_)
             | Self::CommandBlock(_)
-            | Self::Skull(_) => Vec::new(),
+            | Self::Skull(_)
+            | Self::DaylightDetector => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
             Self::Sculk(_) => Vec::new(),
             Self::Banner(_) => Vec::new(),
             Self::Crafter(c) => c.items.iter().flatten().cloned().collect(),
+            Self::Campfire(c) => c.items.iter().flatten().cloned().collect(),
         }
     }
     pub fn slots(&self) -> &[Option<ItemStack>] {
@@ -375,14 +456,17 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &[],
+            | Self::Skull(_)
+            | Self::DaylightDetector => &[],
             Self::Crafter(c) => &c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
             | Self::TrialSpawner(_)
             | Self::Vault(_)
             | Self::Beehive(_)
-            | Self::CommandBlock(_) => &[],
+            | Self::CommandBlock(_)
+            // Not a Container (only Clearable): hoppers don't reach in.
+            | Self::Campfire(_) => &[],
         }
     }
     pub fn slots_mut(&mut self) -> &mut [Option<ItemStack>] {
@@ -396,14 +480,16 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &mut [],
+            | Self::Skull(_)
+            | Self::DaylightDetector => &mut [],
             Self::Crafter(c) => &mut c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
             | Self::TrialSpawner(_)
             | Self::Vault(_)
             | Self::Beehive(_)
-            | Self::CommandBlock(_) => &mut [],
+            | Self::CommandBlock(_)
+            | Self::Campfire(_) => &mut [],
         }
     }
 }
@@ -638,7 +724,10 @@ impl Furnace {
                                     Some(out) => out.count += recipe.result.count,
                                     None => self.items[2] = Some(recipe.result.clone()),
                                 }
-                                *self.recipes_used.entry(recipe.id.clone()).or_insert(0) += 1;
+                                *self
+                                    .recipes_used
+                                    .entry(recipe_used_key(&recipe.id))
+                                    .or_insert(0) += 1;
                                 if let Some(i) = self.items[0].as_mut() {
                                     i.count -= 1;
                                     if i.count == 0 {
@@ -692,6 +781,41 @@ mod tests {
     use super::*;
     use horizon_core::random::{LegacyRandom, RandomSource};
 
+    #[test]
+    fn campfire_slots_take_food_cook_it_and_cool_down() {
+        let mut c = Campfire::default();
+        let mut beef = ItemStack::new("minecraft:beef", 2);
+        // placeFood: the first free slot, one item, its recipe's time.
+        assert!(c.place_food(&mut beef, 600));
+        assert_eq!(beef.count, 1);
+        assert_eq!(c.items[0].as_ref().map(|s| s.count), Some(1));
+        assert_eq!((c.progress[0], c.total[0]), (0, 600));
+        let mut fish = ItemStack::new("minecraft:cod", 1);
+        assert!(c.place_food(&mut fish, 3));
+        assert_eq!(c.items[1].as_ref().map(|s| &*s.item), Some("minecraft:cod"));
+        // cookTick: the cod is done on its third tick, the beef keeps cooking.
+        assert!(c.cook_tick().is_empty());
+        assert!(c.cook_tick().is_empty());
+        let done = c.cook_tick();
+        assert_eq!(done.len(), 1);
+        assert_eq!((done[0].0, &*done[0].1.item), (1, "minecraft:cod"));
+        assert!(c.items[1].is_none());
+        assert_eq!(c.progress[0], 3);
+        // cooldownTick: two a tick, never below zero.
+        assert!(c.cooldown_tick());
+        assert_eq!(c.progress[0], 1);
+        assert!(c.cooldown_tick());
+        assert_eq!(c.progress[0], 0);
+        // Full: four slots, no fifth.
+        for _ in 0..3 {
+            let mut more = ItemStack::new("minecraft:potato", 1);
+            assert!(c.place_food(&mut more, 600));
+        }
+        let mut fifth = ItemStack::new("minecraft:potato", 1);
+        assert!(!c.place_food(&mut fifth, 600));
+        assert_eq!(fifth.count, 1);
+    }
+
     /// A whole amount pays itself without a draw; a fraction is a chance of one more.
     #[test]
     fn create_experience_rounds_the_fraction_by_chance() {

crates/horizon-client/src/crafting.rs

@@ -1612,7 +1612,9 @@ impl Recipes {
     }
     /// The `experience` of the cooking recipe with this file name, and 0 for one this data
     /// pack does not have (a save from another pack can name it).
+    /// `id` with or without the `minecraft:` namespace (a furnace keeps the full id).
     pub fn cooking_experience(&self, id: &str) -> f32 {
+        let id = id.strip_prefix("minecraft:").unwrap_or(id);
         self.cooking
             .iter()
             .find(|c| c.id == id)

crates/horizon-client/src/creative.rs

@@ -1,9 +1,14 @@
 //! Creative inventory (CreativeModeInventoryScreen): vanilla's tabs and their
 //! contents as built by the game's own display generators
 //! (`creative-inventory.json`), a 9x5 scrolling grid and the search tab.
-use crate::{Result, items::ItemStack};
+use crate::{Result, items::ItemStack, ui::EditBox};
 use serde_json::Value;
-use std::{collections::HashMap, fs, path::Path};
+use std::{
+    collections::HashMap,
+    fs,
+    path::Path,
+    sync::{Arc, Mutex},
+};
 
 #[derive(Clone, Debug)]
 pub struct Tab {
@@ -35,13 +40,22 @@ pub struct Creative {
     pub scroll: f32,
     /// The scrollbar is held (scrolling): dragging moves it.
     pub scrolling: bool,
-    pub search: String,
-    /// When the search box took the focus (`EditBox.setFocused`): its
-    /// cursor blinks from then.
-    pub search_focused: std::time::Instant,
+    /// CreativeModeInventoryScreen's search box: an unbordered `EditBox` of 50.
+    pub search: EditBox,
     /// The search tab's stacks, in its display order.
     search_items: Vec<ItemStack>,
     search_index: Vec<SearchEntry>,
+    /// ItemPickerMenu.items: what the grid shows, filled when the tab or the
+    /// search changes (selectTab, refreshSearchResults), not on every frame.
+    shown: Mutex<Option<Shown>>,
+}
+/// The grid's stacks for one tab, search text and language.
+struct Shown {
+    tab: usize,
+    search: String,
+    /// A display name, so a language change refills the search results.
+    language: String,
+    items: Arc<[ItemStack]>,
 }
 /// Display names from the pinned en_us language file.
 #[derive(Default)]
@@ -284,10 +298,16 @@ impl Creative {
             selected: 0,
             scroll: 0.0,
             scrolling: false,
-            search: String::new(),
-            search_focused: std::time::Instant::now(),
+            search: {
+                let mut search = EditBox::new(0.0, 0.0, 80.0, 9.0);
+                search.bordered = false;
+                search.max_length = 50;
+                search.text_color = u32::MAX;
+                search
+            },
             search_items,
             search_index,
+            shown: Mutex::new(None),
         }
     }
     /// Where a stack comes in the creative tabs (the search tab lists them
@@ -300,18 +320,35 @@ impl Creative {
             .position(|s| s.same_item_same_components(stack))
             .or_else(|| items.iter().position(|s| s.item == stack.item))
     }
+    /// The tabs without their stacks: what the screen draws of them each frame.
+    pub fn tab_headers(&self) -> Vec<Tab> {
+        self.tabs
+            .iter()
+            .map(|t| Tab {
+                id: t.id.clone(),
+                title: t.title.clone(),
+                icon: t.icon.clone(),
+                items: Vec::new(),
+                top: t.top,
+                column: t.column,
+                search: t.search,
+                inventory: t.inventory,
+            })
+            .collect()
+    }
     pub fn tab(&self) -> &Tab {
         &self.tabs[self.selected.min(self.tabs.len() - 1)]
     }
     /// selectTab: a different tab empties the search box; the scrollbar goes to the top.
     pub fn select(&mut self, tab: usize) {
         if tab != self.selected {
-            self.search.clear();
+            self.search.set_value("");
         }
         self.selected = tab;
         self.scroll = 0.0;
         if self.tab().search {
-            self.search_focused = std::time::Instant::now();
+            self.search.focused = true;
+            self.search.reset_blink();
         }
     }
     /// The search tab's stacks.
@@ -380,17 +417,44 @@ impl Creative {
         })
         .collect()
     }
-    /// Items shown by the selected tab (the search tab filters by `search`).
-    pub fn items(&self, names: &Names) -> Vec<ItemStack> {
-        let tab = self.tab();
-        if tab.search {
-            return self
-                .search_results(&self.search, names)
+    /// Items shown by the selected tab (the search tab filters by `search`),
+    /// worked out again only when the tab, the search or the language changed.
+    pub fn items(&self, names: &Names) -> Arc<[ItemStack]> {
+        let tab = self.selected.min(self.tabs.len() - 1);
+        let search = if self.tab().search {
+            self.search.value.as_str()
+        } else {
+            ""
+        };
+        let language = names.display_get("itemGroup.search").unwrap_or_default();
+        let mut shown = self.shown.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(s) = shown.as_ref()
+            && s.tab == tab
+            && s.search == search
+            && s.language == language
+        {
+            return s.items.clone();
+        }
+        let items: Arc<[ItemStack]> = if self.tab().search {
+            self.search_results(search, names)
                 .into_iter()
                 .map(|i| self.search_items[i].clone())
-                .collect();
-        }
-        tab.items.clone()
+                .collect()
+        } else {
+            self.tab().items.as_slice().into()
+        };
+        *shown = Some(Shown {
+            tab,
+            search: search.to_owned(),
+            language,
+            items: items.clone(),
+        });
+        items
+    }
+    /// Drop the shown items, so the next `items` works them out again: a
+    /// reload can rename items without changing the Search label.
+    pub fn forget_items(&self) {
+        *self.shown.lock().unwrap_or_else(|e| e.into_inner()) = None;
     }
     pub fn rows(&self, names: &Names) -> usize {
         self.items(names).len().div_ceil(9)
@@ -754,13 +818,13 @@ mod tests {
             (1, false, true),
             (2, true, false),
         ] {
-            c.search = "anvil".into();
+            c.search.set_value("anvil");
             c.scroll = 0.5;
             c.select(selected);
             assert_eq!(c.selected, selected);
             assert_eq!(c.tab().inventory, inventory);
             assert_eq!(c.tab().search, search);
-            assert!(c.search.is_empty());
+            assert!(c.search.value.is_empty());
             assert_eq!(c.scroll, 0.0);
         }
     }
@@ -780,12 +844,12 @@ mod tests {
         assert_eq!(c.tabs[0].items[0].item.as_ref(), "minecraft:anvil");
         let mut c = c;
         c.select(1);
-        c.search = "anvil".into();
+        c.search.set_value("anvil");
         c.scroll = 0.5;
         c.select(1);
-        assert_eq!((c.search.as_str(), c.scroll), ("anvil", 0.0));
+        assert_eq!((c.search.value.as_str(), c.scroll), ("anvil", 0.0));
         c.select(0);
-        assert_eq!(c.search, "");
+        assert_eq!(c.search.value, "");
     }
 
     #[test]
@@ -899,4 +963,25 @@ mod tests {
         c.scroll = 1.0;
         assert_eq!(c.scroller_offset(), 95.0);
     }
+
+    #[test]
+    fn search_edits_at_its_cursor() {
+        use winit::keyboard::KeyCode;
+        let mut c = creative(0);
+        c.select(1);
+        c.search.insert_text("hello world");
+        for _ in 0..5 {
+            assert!(c.search.key(KeyCode::ArrowLeft, false, false));
+        }
+        c.search.insert_text("X");
+        assert_eq!(c.search.value, "hello Xworld");
+        c.search.key(KeyCode::Home, false, true);
+        c.search.insert_text("Y");
+        assert_eq!(c.search.value, "Yworld");
+        // Ctrl+Left jumps a word; one step right and Backspace deletes before the cursor.
+        c.search.key(KeyCode::ArrowLeft, true, false);
+        c.search.key(KeyCode::ArrowRight, false, false);
+        c.search.key(KeyCode::Backspace, false, false);
+        assert_eq!(c.search.value, "world");
+    }
 }

crates/horizon-client/src/cushion.rs

@@ -0,0 +1,59 @@
+//! Cushion placement and support checks (`Cushion.canBePlacedAt`/`wouldSurviveAt`).
+use horizon_core::geometry::{Aabb, ShapeOp, Vec3, VoxelShape};
+
+pub trait World {
+    fn outline_bounds(&self, pos: [i32; 3]) -> Option<Aabb>;
+    fn collision_shapes(&self, bounds: Aabb) -> Vec<VoxelShape>;
+    fn suffocating(&self, pos: [i32; 3]) -> bool;
+}
+
+pub fn blocks_in(a: Aabb) -> impl Iterator<Item = [i32; 3]> {
+    let (lo, hi) = (a.min_position(), a.max_position());
+    let (x0, y0, z0) = (
+        lo.x.floor() as i32,
+        lo.y.floor() as i32,
+        lo.z.floor() as i32,
+    );
+    let (x1, y1, z1) = (
+        hi.x.floor() as i32,
+        hi.y.floor() as i32,
+        hi.z.floor() as i32,
+    );
+    (y0..=y1).flat_map(move |y| (z0..=z1).flat_map(move |z| (x0..=x1).map(move |x| [x, y, z])))
+}
+
+pub fn survives(world: &impl World, bounds: Aabb) -> bool {
+    let (lo, hi) = (bounds.min_position(), bounds.max_position());
+    let anchor = Aabb::new(
+        Vec3::new(lo.x, lo.y - 0.015625, lo.z),
+        Vec3::new(hi.x.next_down(), lo.y, hi.z.next_down()),
+    );
+    // The extra eighth block expands the scan, not the intersection test.
+    let supported = blocks_in(anchor.expand_towards(Vec3::new(0.0, -0.125, 0.0))).any(|p| {
+        world
+            .outline_bounds(p)
+            .is_some_and(|shape| shape.intersects(anchor))
+    });
+    supported && !blocks_in(bounds.next_deflated()).all(|p| world.suffocating(p))
+}
+
+pub fn can_place(world: &impl World, bounds: Aabb) -> bool {
+    if !survives(world, bounds) {
+        return false;
+    }
+    let (lo, hi) = (bounds.min_position(), bounds.max_position());
+    let slab = Aabb::new(lo, Vec3::new(hi.x, lo.y + 0.015625, hi.z)).next_deflated();
+    let Ok(mut remaining) = VoxelShape::from_box(slab) else {
+        return false;
+    };
+    for shape in world.collision_shapes(slab) {
+        let Ok(next) = remaining.join(&shape, ShapeOp::ONLY_FIRST) else {
+            return false;
+        };
+        remaining = next;
+        if remaining.is_empty() {
+            return false;
+        }
+    }
+    true
+}

crates/horizon-client/src/debug_overlay.rs

@@ -221,18 +221,17 @@ pub fn scale(
 pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec<GuiDraw> {
     let mut out = vec![GuiDraw::Push(vec![PoseOp::Scale(scale, scale)])];
     for (lines, align_left) in [(columns[0], true), (columns[1], false)] {
-        let placed: Vec<(&String, i32, i32)> = lines
+        let placed: Vec<(&String, i32, i32, i32)> = lines
             .iter()
             .enumerate()
             .filter(|(_, l)| !l.is_empty())
             .map(|(i, l)| {
                 let w = font.width(l) as i32;
                 let left = if align_left { 2 } else { width - 2 - w };
-                (l, left, 2 + LINE_HEIGHT * i as i32)
+                (l, left, 2 + LINE_HEIGHT * i as i32, w)
             })
             .collect();
-        for (line, left, top) in &placed {
-            let w = font.width(line) as i32;
+        for (_, left, top, w) in &placed {
             out.push(fill(
                 left - 1,
                 top - 1,
@@ -241,7 +240,7 @@ pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec
                 BACKGROUND,
             ));
         }
-        for (line, left, top) in placed {
+        for (line, left, top, _) in placed {
             out.push(GuiDraw::Text {
                 text: Text::literal(line.clone()),
                 x: left,

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/entities.rs

@@ -10,6 +10,8 @@ use crate::{
 use horizon_core::geometry::{Aabb, Vec3};
 use horizon_world::block_collision::BlockCollisionRegistry;
 
+mod fluids;
+
 #[derive(Clone, Debug)]
 pub struct ItemEntity {
     pub health: i32,
@@ -93,6 +95,15 @@ impl ItemEntity {
                 self.health -= fire_damage as i32;
             }
         }
+        // CactusBlock.entityInside: `entity.hurt(cactus, 1.0)`. An item has no
+        // hurt cooldown, so it loses 1 health every tick it touches a cactus
+        // (5 health: gone in 5 ticks). Fire resistance does not help;
+        // `ItemStack.canBeHurtBy` only skips it for a damage_resistant stack.
+        if crate::motion::environment::cactus_contact(world, registry, self.bounds())
+            && !items.resists_cactus(&self.stack)
+        {
+            self.health -= 1;
+        }
         ItemEnvironmentTick {
             alive: self.health > 0,
             lava_hurt,
@@ -165,18 +176,16 @@ impl ItemEntity {
         facts: &BlockFacts,
         collision: &BlockCollisionRegistry<'_>,
         no_physics: bool,
+        fluids: &crate::motion::FluidResources,
     ) -> bool {
         self.ticks += 1;
         self.previous = self.position;
         if self.pickup_delay > 0 && self.pickup_delay != u32::MAX {
             self.pickup_delay -= 1;
         }
-        let eye = world.block(
-            self.position.x.floor() as i32,
-            (self.position.y + 0.1).floor() as i32,
-            self.position.z.floor() as i32,
-        );
-        let in_water = facts.get(eye).fluid == Fluid::Water;
+        // Entity.baseTick pushes before ItemEntity applies buoyancy and moves.
+        let (water_height, lava_height) = self.update_fluids(world, fluids);
+        let in_water = water_height > f64::from(0.1f32);
         if in_water {
             // ItemEntity.setUnderwaterMovement
             self.velocity = Vec3::new(
@@ -184,7 +193,7 @@ impl ItemEntity {
                 self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 },
                 self.velocity.z * 0.99,
             );
-        } else if facts.get(eye).fluid == Fluid::Lava {
+        } else if lava_height > f64::from(0.1f32) {
             self.velocity = Vec3::new(
                 self.velocity.x * 0.95,
                 self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 },
@@ -245,6 +254,8 @@ impl ItemEntity {
             }
         }
         self.age += 1;
+        // ItemEntity.tick refreshes immersion and pushes again after moving.
+        self.update_fluids(world, fluids);
         self.age < 6000 && self.position.y > -128.0
     }
     /// `ItemEntity.isMergable` at `age`: a stack below its size whose pickup
@@ -383,8 +394,29 @@ pub struct ExperienceOrb {
     pub value: u32,
     pub age: u32,
     pub on_ground: bool,
+    /// `ExperienceOrb.count`: orbs merged into this one; each pickup gives
+    /// `value` once and takes one off.
+    pub count: u32,
+    /// `Entity.tickCount`, which paces `ExperienceOrb.scanForMerges`.
+    pub ticks: u32,
 }
 impl ExperienceOrb {
+    pub fn bounds(&self) -> Aabb {
+        let h = 0.25;
+        Aabb::new(
+            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+            Vec3::new(
+                self.position.x + h,
+                self.position.y + 0.5,
+                self.position.z + h,
+            ),
+        )
+    }
+    /// `ExperienceOrb.canMerge(orb, id, value)` for an orb that is not removed:
+    /// the same value and ids a multiple of 40 apart.
+    pub fn can_merge(&self, id: u32, value: u32) -> bool {
+        self.value == value && (self.id as i32).wrapping_sub(id as i32) % 40 == 0
+    }
     /// ExperienceOrb.getExperienceValue: the largest orb size not above `value`.
     pub fn split(value: u32) -> u32 {
         [2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]
@@ -414,7 +446,9 @@ impl ExperienceOrb {
         facts: &BlockFacts,
         collision: &BlockCollisionRegistry<'_>,
         player: Option<[f64; 3]>,
+        next_float: &mut dyn FnMut() -> f32,
     ) -> bool {
+        self.ticks += 1;
         self.previous = self.position;
         let block = world.block(
             self.position.x.floor() as i32,
@@ -430,6 +464,14 @@ impl ExperienceOrb {
         } else {
             self.velocity.y -= 0.03;
         }
+        if facts.get(block).fluid == Fluid::Lava {
+            // ExperienceOrb.tick: lava throws the orb back out.
+            self.velocity = Vec3::new(
+                f64::from((next_float() - next_float()) * 0.2),
+                f64::from(0.2f32),
+                f64::from((next_float() - next_float()) * 0.2),
+            );
+        }
         if let Some(p) = player {
             let d = [
                 (p[0] - self.position.x) / 8.0,
@@ -447,15 +489,7 @@ impl ExperienceOrb {
                 );
             }
         }
-        let h = 0.25;
-        let bounds = Aabb::new(
-            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
-            Vec3::new(
-                self.position.x + h,
-                self.position.y + 0.5,
-                self.position.z + h,
-            ),
-        );
+        let bounds = self.bounds();
         let mut scene = SceneCollisions {
             world,
             binding: collision,
@@ -492,6 +526,31 @@ impl ExperienceOrb {
         self.age < 6000
     }
 }
+/// `ExperienceOrb.scanForMerges`, run by each orb on `tickCount % 20 == 1`:
+/// it absorbs the orbs that `canMerge` within 0.5 blocks of its box,
+/// adding their counts and keeping the smaller age.
+pub fn merge_orbs(orbs: &mut Vec<ExperienceOrb>) {
+    let mut removed = vec![false; orbs.len()];
+    for i in 0..orbs.len() {
+        if removed[i] || orbs[i].ticks % 20 != 1 {
+            continue;
+        }
+        let area = orbs[i].bounds().inflate(Vec3::new(0.5, 0.5, 0.5));
+        for j in 0..orbs.len() {
+            if j != i
+                && !removed[j]
+                && orbs[j].can_merge(orbs[i].id, orbs[i].value)
+                && orbs[j].bounds().intersects(area)
+            {
+                orbs[i].count += orbs[j].count;
+                orbs[i].age = orbs[i].age.min(orbs[j].age);
+                removed[j] = true;
+            }
+        }
+    }
+    let mut removed = removed.into_iter();
+    orbs.retain(|_| !removed.next().unwrap_or(false));
+}
 /// Player experience (Player.giveExperiencePoints / getXpNeededForNextLevel).
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Experience {
@@ -589,6 +648,57 @@ impl Painting {
         )
     }
 }
+/// The `DyeColor` ordinal of a colour name (`DyeColor.byName`), white when
+/// the name is unknown.
+pub fn dye_index(name: &str) -> u8 {
+    crate::mobs::render::DYE_NAMES
+        .iter()
+        .position(|n| *n == name)
+        .unwrap_or(0) as u8
+}
+/// A cushion (`Cushion`, a `BlockAttachedEntity`): a 1 x 0.25 block pillow
+/// that seats a player. It sits on the top face of a block, at the clicked
+/// height, and is coloured by its `DyeColor`.
+#[derive(Clone, Debug)]
+pub struct Cushion {
+    pub id: u32,
+    /// `Entity.position`: the bottom centre of the cushion.
+    pub position: Vec3,
+    /// `BlockAttachedEntity.pos` (the saved `block_pos`).
+    pub pos: [i32; 3],
+    pub yaw: f32,
+    /// `DyeColor` ordinal: white 0, orange 1, ..., black 15.
+    pub color: u8,
+    /// BlockAttachedEntity.ticksSinceLastCheck.
+    pub check_interval: u32,
+}
+impl Cushion {
+    /// `Entity.makeBoundingBox`: x and z half a block out, y to y + 0.25.
+    pub fn bounds(&self) -> ([f64; 3], [f64; 3]) {
+        let p = self.position;
+        (
+            [p.x - 0.5, p.y, p.z - 0.5],
+            [p.x + 0.5, p.y + 0.25, p.z + 0.5],
+        )
+    }
+    /// The `DyeColor` name of the cushion.
+    pub fn color_name(&self) -> &'static str {
+        crate::mobs::render::DYE_NAMES[usize::from(self.color.min(15))]
+    }
+    /// `Cushion.getCushionItemStackWithData`: the matching coloured item.
+    pub fn item(&self) -> String {
+        format!("minecraft:{}_cushion", self.color_name())
+    }
+    /// `Cushion.interact`'s seat: the vehicle's PASSENGER attachment
+    /// `(0, 0.25, 0)` less the player's `(0, 0.6, 0)`.
+    pub fn seat(&self) -> Vec3 {
+        Vec3::new(self.position.x, self.position.y - 0.35, self.position.z)
+    }
+    /// `Entity.getDismountLocationForPassenger`: on top of the cushion.
+    pub fn dismount(&self) -> Vec3 {
+        Vec3::new(self.position.x, self.position.y + 0.25, self.position.z)
+    }
+}
 /// An item frame or glow item frame (`ItemFrame`).
 #[derive(Clone, Debug)]
 pub struct ItemFrame {

crates/horizon-client/src/entities/fluids.rs

@@ -0,0 +1,216 @@
+//! Dropped-item immersion and currents through the shared vanilla fluid helpers.
+use super::ItemEntity;
+use crate::{
+    motion::{FluidResources, FluidTags, LAVA, WATER},
+    world::World,
+};
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    position::BlockPos,
+};
+use horizon_world::{
+    entity_fluid::{
+        CurrentTarget, EntityFluidInteraction, FluidInteractionWorld, FluidMembership,
+        FluidSections, FluidTagId,
+    },
+    fluid::{FluidHeightWorld, FluidKind, FluidState},
+    fluid_flow::{FluidFlowWorld, flow_at},
+    registry::BlockStateId,
+};
+type Error = std::convert::Infallible;
+struct ItemFluidWorld<'a> {
+    item: &'a mut ItemEntity,
+    world: &'a World,
+    fluids: &'a FluidResources,
+}
+impl ItemEntity {
+    pub(super) fn update_fluids(&mut self, world: &World, fluids: &FluidResources) -> (f64, f64) {
+        let mut interaction = EntityFluidInteraction::new([WATER, LAVA]);
+        let mut scene = ItemFluidWorld {
+            item: self,
+            world,
+            fluids,
+        };
+        if interaction.update(&mut scene, false, 4096).is_err() {
+            return (0.0, 0.0);
+        }
+        let water_height = interaction.fluid_height(&scene, WATER);
+        let lava_height = interaction.fluid_height(&scene, LAVA);
+        let _ = interaction.apply_current(&mut scene, WATER, 0.014);
+        let _ = interaction.apply_current(
+            &mut scene,
+            LAVA,
+            if world.fast_lava {
+                0.007
+            } else {
+                0.0023333333333333335
+            },
+        );
+        (water_height, lava_height)
+    }
+}
+impl FluidMembership for ItemFluidWorld<'_> {
+    fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool {
+        FluidTags.fluid_in_tag(kind, tag)
+    }
+}
+impl CurrentTarget for ItemFluidWorld<'_> {
+    type Error = Error;
+    fn is_player_class(&self) -> bool {
+        false
+    }
+    fn velocity(&mut self) -> Result<Vec3, Error> {
+        Ok(self.item.velocity)
+    }
+    fn add_delta_movement(&mut self, delta: Vec3) -> Result<(), Error> {
+        let v = self.item.velocity;
+        let sum = Vec3::new(v.x + delta.x, v.y + delta.y, v.z + delta.z);
+        if delta.is_finite() && sum.is_finite() {
+            self.item.velocity = sum;
+        }
+        Ok(())
+    }
+}
+impl FluidInteractionWorld for ItemFluidWorld<'_> {
+    type Error = Error;
+    type Chunk = ();
+    fn interaction_box(&mut self) -> Result<Option<Aabb>, Error> {
+        Ok(Some(
+            self.item.bounds().deflate(Vec3::new(0.001, 0.001, 0.001)),
+        ))
+    }
+    fn loaded_chunk(&mut self, x: i32, z: i32) -> Result<Option<()>, Error> {
+        Ok(self.world.chunks.contains_key(&(x, z)).then_some(()))
+    }
+    fn chunk_sections(&mut self, _: ()) -> Result<FluidSections<'_>, Error> {
+        static SECTIONS: [bool; crate::chunk::SECTIONS] = [true; crate::chunk::SECTIONS];
+        Ok(FluidSections {
+            minimum_section_y: crate::chunk::MIN_Y >> 4,
+            has_fluid: &SECTIONS,
+        })
+    }
+    fn bounding_box_min_y(&self) -> f64 {
+        self.item.position.y
+    }
+    fn block_x(&self) -> i32 {
+        self.item.position.x.floor() as i32
+    }
+    fn eye_y(&mut self) -> Result<f64, Error> {
+        Ok(self.item.position.y + f64::from(0.2125f32))
+    }
+    fn block_z(&self) -> i32 {
+        self.item.position.z.floor() as i32
+    }
+    fn fluid_state(&mut self, p: BlockPos) -> Result<FluidState, Error> {
+        Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z)))
+    }
+    fn fluid_height(&mut self, f: FluidState, p: BlockPos) -> Result<f32, Error> {
+        f.height_at(self, [p.x, p.y, p.z])
+    }
+    fn camera_height(&mut self, f: FluidState, p: BlockPos) -> Result<f32, Error> {
+        f.camera_height_at(self, [p.x, p.y, p.z])
+    }
+    fn flow(&mut self, f: FluidState, p: BlockPos) -> Result<Vec3, Error> {
+        flow_at(self, f, p)
+    }
+}
+impl FluidHeightWorld for ItemFluidWorld<'_> {
+    type Error = Error;
+    fn fluid(&mut self, p: [i32; 3]) -> Result<FluidState, Error> {
+        Ok(self.fluids.fluid(self.world.block(p[0], p[1], p[2])))
+    }
+    fn sturdy_down(&mut self, p: [i32; 3]) -> Result<bool, Error> {
+        let state = self.world.block(p[0], p[1], p[2]);
+        Ok(self.fluids.sturdy(state, Direction::Down))
+    }
+}
+impl FluidFlowWorld for ItemFluidWorld<'_> {
+    type Error = Error;
+    type Block = BlockStateId;
+    fn fluid(&mut self, p: BlockPos) -> Result<FluidState, Error> {
+        Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z)))
+    }
+    fn block(&mut self, p: BlockPos) -> Result<BlockStateId, Error> {
+        Ok(self.world.block(p.x, p.y, p.z))
+    }
+    fn blocks_fluid_flow(&self, s: BlockStateId) -> bool {
+        self.fluids.blocks_flow(s)
+    }
+    fn is_ice_class(&self, s: BlockStateId) -> bool {
+        self.fluids.ice(s)
+    }
+    fn is_face_sturdy(
+        &mut self,
+        s: BlockStateId,
+        _: BlockPos,
+        d: Direction,
+    ) -> Result<bool, Error> {
+        Ok(self.fluids.sturdy(s, d))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn items_follow_flowing_water_but_still_water_has_no_horizontal_push() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
+        let fluids = FluidResources::new(&assets, &facts).unwrap();
+        let collision = crate::collisions::load(&root, assets.registry).unwrap();
+        let mut world = World::test_scene(&assets, &render, 3).unwrap();
+        let stone = assets.registry.default_state("minecraft:stone").unwrap();
+        let water = assets.registry.default_state("minecraft:water").unwrap();
+        let mut state = assets.registry.state(water).unwrap().clone();
+        state.properties.insert("level".into(), "1".into());
+        let flowing = assets.registry.resolve(&state).unwrap();
+        for x in 19..=21 {
+            for z in 19..=21 {
+                world.set(x, 3, z, stone).unwrap();
+                world.set(x, 4, z, water).unwrap();
+            }
+        }
+        let at = Vec3::new(20.5, 4.0, 20.5);
+        let item = ItemEntity {
+            id: 1,
+            health: 5,
+            fire_ticks: 0,
+            stack: crate::items::ItemStack {
+                item: "minecraft:sugar_cane".into(),
+                count: 1,
+                damage: 0,
+                extra: None,
+            },
+            thrower: None,
+            position: at,
+            previous: at,
+            velocity: Vec3::ZERO,
+            on_ground: false,
+            age: 0,
+            pickup_delay: 0,
+            bob_offset: 0.0,
+            ticks: 0,
+        };
+        let mut still = item.clone();
+        assert!(still.tick(&world, &facts, &collision, false, &fluids));
+        assert_eq!(still.position.x, at.x);
+        assert_eq!(still.velocity.x, 0.0);
+        world.set(21, 4, 20, flowing).unwrap();
+        let mut carried = item;
+        assert!(carried.tick(&world, &facts, &collision, false, &fluids));
+        // First push is damped by buoyancy before motion, second follows drag.
+        assert!((carried.position.x - at.x - 0.014 * 0.99).abs() < 1e-12);
+        assert!((carried.velocity.x - (0.014 * 0.99 * 0.98 + 0.014)).abs() < 1e-12);
+        for _ in 0..20 {
+            carried.tick(&world, &facts, &collision, false, &fluids);
+        }
+        assert!(carried.position.x > at.x + 0.5);
+    }
+}

crates/horizon-client/src/entity.wgsl

@@ -166,12 +166,23 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
     if d >= end { return 1.0; }
     return (d - start) / (end - start);
 }
+// CRUMBLING_UV_BEGIN
+fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>, dimensions: vec2<u32>) -> vec2<f32> {
+    let size = vec2<f32>(dimensions);
+    // Undo stage_light's 16-bit quantization before adding local texels. Otherwise
+    // different stages can fall on opposite sides of a nearest-sampling boundary.
+    let origin = round(packed_origin * size);
+    let extent = max(round(sprite_size * size), vec2(1.0));
+    let local = min(floor(fract(uv) * extent), extent - vec2(1.0));
+    return (origin + local + vec2(0.5)) / size;
+}
+// CRUMBLING_UV_END
 @fragment fn fs_entity(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
     var uv = in.uv;
     if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
     if in.overlay == 11u || in.overlay == 12u {
         // Each crack's stage sprite origin comes in its light bytes (breaking::stage_light).
-        uv = in.wrap + fract(in.uv) * globals.crumbling_sprite.zw;
+        uv = crumbling_uv(in.uv, in.wrap, globals.crumbling_sprite.zw, textureDimensions(atlas));
     }
     var color = textureSample(atlas, atlas_sampler, uv) * select(in.back_color, in.color, front);
     if in.overlay == 9u || in.overlay == 10u {

crates/horizon-client/src/entity_nbt.rs

@@ -6,7 +6,7 @@
 //! survive a Horizon save.
 use crate::{
     arrows::Pickup,
-    entities::{ArmorStand, ExperienceOrb, ItemEntity, ItemFrame, Painting},
+    entities::{ArmorStand, Cushion, ExperienceOrb, ItemEntity, ItemFrame, Painting},
     mobs::{Mob, MobType, Who},
     projectiles::{Projectile, ProjectileKind},
     save::{
@@ -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));
@@ -260,11 +279,28 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 .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)),
             );
             map.insert("TimeInOverworld".into(), Tag::Int(m.extra.counter2));
+            if id == "minecraft:piglin" {
+                // InventoryCarrier.writeInventoryToTag.
+                map.insert(
+                    "Inventory".into(),
+                    Tag::List(
+                        m.extra
+                            .inventory
+                            .iter()
+                            .map(crate::save::item_to_nbt)
+                            .collect(),
+                    ),
+                );
+            }
         }
         "minecraft:horse"
         | "minecraft:donkey"
@@ -357,6 +393,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         "minecraft:bat" => {
             map.insert("BatFlags".into(), Tag::Byte(i8::from(m.extra.flag)));
         }
+        "minecraft:turtle" => {
+            map.insert("has_egg".into(), Tag::Byte(i8::from(m.extra.flag)));
+            if let Some(home) = m.extra.home {
+                map.insert("home_pos".into(), Tag::IntArray(home.to_vec()));
+            }
+        }
         "minecraft:creaking" => {
             // home_pos: the heart it is bound to.
             if let Some(home) = m.extra.home {
@@ -479,10 +521,8 @@ 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 [
-                ("CanBreakDoors", Tag::Byte(0)),
                 ("DrownedConversionTime", Tag::Int(-1)),
                 ("InWaterTime", Tag::Int(-1)),
             ] {
@@ -507,6 +547,28 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         }
         _ => {}
     }
+    // Zombie.addAdditionalSaveData: CanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        map.insert(
+            "CanBreakDoors".into(),
+            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.
@@ -589,6 +651,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")? {
@@ -608,6 +753,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)?;
@@ -633,6 +794,11 @@ 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);
     m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
     // What it holds (equipment.mainhand / offhand), when saved.
@@ -674,7 +840,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");
@@ -706,6 +873,16 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     ) {
         m.extra.flag2 = flag(tag, "IsImmuneToZombification");
         m.extra.counter2 = number(tag.get("TimeInOverworld")).unwrap_or(0) as i32;
+        if m.species() == crate::mobs::Species::Piglin
+            && let Some(Tag::List(items)) = tag.get("Inventory")
+        {
+            // InventoryCarrier.readInventoryFromTag (eight slots).
+            m.extra.inventory = items
+                .iter()
+                .filter_map(crate::save::item_from_nbt)
+                .take(8)
+                .collect();
+        }
     }
     if matches!(
         m.species(),
@@ -847,6 +1024,18 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     {
         crate::mobs::creaking::set_transient(&mut m, [home[0], home[1], home[2]]);
     }
+    if m.species() == crate::mobs::Species::Turtle {
+        // Turtle.readAdditionalSaveData: `home_pos` (else where it stands) and `has_egg`.
+        m.extra.flag = flag(tag, "has_egg");
+        m.extra.home = Some(match tag.get("home_pos") {
+            Some(Tag::IntArray(home)) if home.len() == 3 => [home[0], home[1], home[2]],
+            _ => [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ],
+        });
+    }
     if m.species() == crate::mobs::Species::Wither {
         m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32;
     }
@@ -925,6 +1114,10 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if !crate::mobs::finalize::ageable(m.species()) && flag(tag, "IsBaby") {
         crate::mobs::finalize::set_baby(&mut m, true);
     }
+    // Zombie.readAdditionalSaveData: setCanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        crate::mobs::doors::set_can_break_doors(&mut m, flag(tag, "CanBreakDoors"));
+    }
     crate::mobs::raider::read_nbt(&mut m, tag);
     crate::mobs::riders::read_nbt(&mut m, tag);
     // A mob saved mid-death finishes dying; one saved dead is dropped.
@@ -1043,18 +1236,18 @@ pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
         ("Health", Tag::Short(5)),
         ("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
         ("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
-        ("Count", Tag::Int(1)),
+        ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
     ] {
         put(&mut tag, key, value);
     }
     tag
 }
-/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
+/// One orb with its merged `Count`.
 pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
     let Some(position) = position(tag) else {
         return Vec::new();
     };
-    let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
+    let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
     let orb = ExperienceOrb {
         id: 0,
         position,
@@ -1063,8 +1256,10 @@ pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
         value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
         age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
         on_ground: flag(tag, "OnGround"),
+        count,
+        ticks: 0,
     };
-    vec![orb; count]
+    vec![orb]
 }
 
 /// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
@@ -1313,6 +1508,79 @@ pub fn painting_from_nbt(tag: &Tag) -> Option<([i32; 3], u8, String)> {
     let facing = (number(tag.get("facing")).unwrap_or(0) & 3) as u8;
     Some((pos, facing, text(tag.get("variant"))?))
 }
+/// Cushion.addAdditionalSaveData: the block it sits on and its colour.
+pub fn cushion_to_nbt(c: &Cushion, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
+    let base = Base {
+        id: "minecraft:cushion",
+        uuid,
+        position: c.position,
+        motion: Vec3::ZERO,
+        rotation: [c.yaw, 0.0],
+        on_ground: false,
+        fall_distance: 0.0,
+    };
+    let mut tag = base.tag(raw);
+    put(&mut tag, "block_pos", Tag::IntArray(c.pos.to_vec()));
+    put(&mut tag, "color", string(c.color_name()));
+    tag
+}
+/// The position, block position, yaw and colour of a saved cushion.
+pub fn cushion_from_nbt(tag: &Tag, id: u32) -> Option<Cushion> {
+    let position = position(tag)?;
+    let pos = match tag.get("block_pos") {
+        Some(Tag::IntArray(v)) if v.len() == 3 => [v[0], v[1], v[2]],
+        _ => [
+            position.x.floor() as i32,
+            position.y.floor() as i32,
+            position.z.floor() as i32,
+        ],
+    };
+    let yaw = match tag.get("Rotation") {
+        Some(Tag::List(l)) => l
+            .first()
+            .and_then(|v| crate::save::float(Some(v)))
+            .unwrap_or(0.0) as f32,
+        _ => 0.0,
+    };
+    let color =
+        crate::entities::dye_index(&text(tag.get("color")).unwrap_or_else(|| "white".into()));
+    Some(Cushion {
+        id,
+        position,
+        pos,
+        yaw,
+        color,
+        check_interval: 0,
+    })
+}
+
+#[cfg(test)]
+mod cushion_tests {
+    use super::*;
+
+    #[test]
+    fn cushion_save_preserves_color_anchor_rotation_and_unknown_data() {
+        let cushion = Cushion {
+            id: 7,
+            position: Vec3::new(-1.5, 64.5, 3.5),
+            pos: [-2, 64, 3],
+            yaw: 270.0,
+            color: 14,
+            check_interval: 55,
+        };
+        let raw = Tag::compound([("CustomName", string("Seat"))]);
+        let tag = cushion_to_nbt(&cushion, [1, 2, 3, 4], Some(&raw));
+        assert_eq!(text(tag.get("CustomName")).as_deref(), Some("Seat"));
+        let loaded = cushion_from_nbt(&tag, 8).unwrap();
+        assert_eq!(loaded.id, 8);
+        assert_eq!(loaded.position, cushion.position);
+        assert_eq!(loaded.pos, cushion.pos);
+        assert_eq!(loaded.yaw, cushion.yaw);
+        assert_eq!(loaded.color_name(), "red");
+        assert_eq!(loaded.check_interval, 0);
+        assert_eq!(loaded.bounds(), cushion.bounds());
+    }
+}
 /// ItemFrame.addAdditionalSaveData.
 pub fn item_frame_to_nbt(f: &ItemFrame, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     let (lo, hi) = f.bounds();
@@ -1840,7 +2108,7 @@ mod tests {
         assert_eq!(number(tag.get("Health")), Some(5));
     }
     #[test]
-    fn orbs_expand_their_count() {
+    fn orbs_keep_their_count() {
         let o = ExperienceOrb {
             id: 0,
             position: Vec3::new(1.0, 2.0, 3.0),
@@ -1849,12 +2117,14 @@ mod tests {
             value: 7,
             age: 3,
             on_ground: false,
+            count: 3,
+            ticks: 0,
         };
-        let mut tag = orb_to_nbt(&o, [0; 4]);
-        put(&mut tag, "Count", Tag::Int(3));
+        let tag = orb_to_nbt(&o, [0; 4]);
         let back = orbs_from_nbt(&tag);
-        assert_eq!(back.len(), 3);
+        assert_eq!(back.len(), 1);
         assert_eq!(back[0].value, 7);
+        assert_eq!(back[0].count, 3);
     }
 }
 
@@ -1919,12 +2189,39 @@ fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
     }
 }
 const AXOLOTL_VARIANTS: [&str; 5] = ["lucy", "wild", "gold", "cyan", "blue"];
+/// `Salmon.Variant` names, by id.
+const SALMON_SIZES: [&str; 3] = ["small", "medium", "large"];
+/// `TropicalFish.Pattern` names in enum order: the six small patterns, then
+/// the six large ones (the order of `extra.variant`).
+const TROPICAL_PATTERNS: [&str; 12] = [
+    "kob",
+    "sunstreak",
+    "snooper",
+    "dasher",
+    "brinely",
+    "spotty",
+    "flopper",
+    "stripey",
+    "glitter",
+    "blockfish",
+    "betty",
+    "clayfish",
+];
+/// `Bucketable.saveDefaultDataToBucketTag`, with the age an axolotl and a
+/// tadpole add (`saveToBucketTag`).
 pub fn bucket_data(m: &Mob) -> Tag {
-    let mut data = Tag::compound([
-        ("Age", Tag::Int(m.extra.age)),
-        ("AgeLocked", Tag::Byte(i8::from(m.extra.age_locked))),
-        ("Health", Tag::Float(m.health.to_bits())),
-    ]);
+    let mut data = Tag::compound([("Health", Tag::Float(m.health.to_bits()))]);
+    if matches!(
+        m.species(),
+        crate::mobs::Species::Axolotl | crate::mobs::Species::Tadpole
+    ) {
+        put(&mut data, "Age", Tag::Int(m.extra.age));
+        put(
+            &mut data,
+            "AgeLocked",
+            Tag::Byte(i8::from(m.extra.age_locked)),
+        );
+    }
     for (key, on) in [
         ("NoAI", m.no_ai),
         ("Silent", m.silent),
@@ -1954,6 +2251,29 @@ pub fn bucket_components(m: &Mob) -> crate::item_data::StackData {
             .unwrap_or(&"lucy");
         data.set_other("minecraft:axolotl/variant", Some(string(variant)));
     }
+    // Salmon.saveToBucketTag: the size.
+    if m.species() == crate::mobs::Species::Salmon {
+        let size = SALMON_SIZES
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"medium");
+        data.set_other("minecraft:salmon/size", Some(string(size)));
+    }
+    // TropicalFish.saveToBucketTag: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let dye = |i: u8| crate::mobs::render::DYE_NAMES[usize::from(i) & 15];
+        let pattern = TROPICAL_PATTERNS
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"kob");
+        data.set_other("minecraft:tropical_fish/pattern", Some(string(pattern)));
+        data.set_other(
+            "minecraft:tropical_fish/base_color",
+            Some(string(dye(m.extra.variant2))),
+        );
+        data.set_other(
+            "minecraft:tropical_fish/pattern_color",
+            Some(string(dye(m.extra.variant3))),
+        );
+    }
     data
 }
 pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
@@ -2004,6 +2324,39 @@ pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
     {
         m.extra.variant = id as u8;
     }
+    // Salmon.applyImplicitComponents: the size.
+    if m.species() == crate::mobs::Species::Salmon
+        && let Some(name) = text(components.other("minecraft:salmon/size"))
+        && let Some(id) = SALMON_SIZES
+            .iter()
+            .position(|&v| v == name.trim_start_matches("minecraft:"))
+    {
+        m.extra.variant = id as u8;
+    }
+    // TropicalFish.applyImplicitComponent: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let name = |key| text(components.other(key));
+        let dye = |key| {
+            name(key).and_then(|n| {
+                crate::mobs::render::DYE_NAMES
+                    .iter()
+                    .position(|&v| v == n.trim_start_matches("minecraft:"))
+            })
+        };
+        if let Some(id) = name("minecraft:tropical_fish/pattern").and_then(|n| {
+            TROPICAL_PATTERNS
+                .iter()
+                .position(|&v| v == n.trim_start_matches("minecraft:"))
+        }) {
+            m.extra.variant = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/base_color") {
+            m.extra.variant2 = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/pattern_color") {
+            m.extra.variant3 = id as u8;
+        }
+    }
 }
 
 #[cfg(test)]

crates/horizon-client/src/extras.rs

@@ -378,12 +378,6 @@ impl Cps {
 pub enum Item {
     Fullbright,
     DynamicLights,
-    Minimap,
-    MinimapCorner,
-    MinimapSize,
-    MinimapShape,
-    MinimapZoom,
-    MinimapRotate,
     AutoReconnect,
     MouseTweaks,
     MouseTweaksWheel,
@@ -402,13 +396,6 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
         Err("Lighting"),
         Ok(Fullbright),
         Ok(DynamicLights),
-        Err("Minimap"),
-        Ok(Minimap),
-        Ok(MinimapCorner),
-        Ok(MinimapSize),
-        Ok(MinimapShape),
-        Ok(MinimapZoom),
-        Ok(MinimapRotate),
         Err("Inventory"),
         Ok(MouseTweaks),
         Ok(MouseTweaksWheel),
@@ -418,32 +405,11 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
         Ok(AutoReconnect),
     ]
 }
-/// "1 block", "2 blocks", "½ block".
-fn block_count(n: f32) -> String {
-    if n < 1.0 {
-        "½ block".into()
-    } else if n == 1.0 {
-        "1 block".into()
-    } else {
-        format!("{n} blocks")
-    }
-}
-fn next<T: Copy + PartialEq>(all: &[T], current: T, back: bool) -> T {
-    let i = all.iter().position(|v| *v == current).unwrap_or(0);
-    let n = all.len();
-    all[if back { (i + n - 1) % n } else { (i + 1) % n }]
-}
 impl Item {
     pub fn caption(self) -> &'static str {
         match self {
             Item::Fullbright => "Fullbright",
             Item::DynamicLights => "Dynamic lights",
-            Item::MinimapCorner => "Corner",
-            Item::Minimap => "Minimap",
-            Item::MinimapSize => "Size",
-            Item::MinimapShape => "Shape",
-            Item::MinimapZoom => "Zoom",
-            Item::MinimapRotate => "Turn with the player",
             Item::AutoReconnect => "Auto-reconnect",
             Item::MouseTweaks => "Mouse Tweaks controls",
             Item::MouseTweaksWheel => "Scroll wheel moves items",
@@ -458,10 +424,9 @@ impl Item {
     pub fn parent(self) -> Option<Item> {
         use Item::*;
         Some(match self {
-            MinimapCorner | MinimapSize | MinimapShape | MinimapZoom | MinimapRotate => Minimap,
             MouseTweaksWheel => MouseTweaks,
             SortKey => Sort,
-            Fullbright | DynamicLights | Minimap | MouseTweaks | Sort | AutoReconnect | NoAi
+            Fullbright | DynamicLights | MouseTweaks | Sort | AutoReconnect | NoAi
             | AgentControl | DiscordPresence => {
                 return None;
             }
@@ -474,12 +439,6 @@ impl Item {
             Item::DynamicLights => {
                 "Torches and other light sources held, dropped or on fire light the blocks around them."
             }
-            Item::MinimapCorner => "Overlays in one corner stack.",
-            Item::Minimap => "A map of the loaded terrain around you, in map colours.",
-            Item::MinimapSize => "How big the map is on screen.",
-            Item::MinimapShape => "Square or round.",
-            Item::MinimapZoom => "Blocks per pixel: smaller shows more detail, larger more land.",
-            Item::MinimapRotate => "Forward is up; off keeps north up.",
             Item::AutoReconnect => {
                 "Rejoins a server after a lost connection or a restart, never after a kick or ban."
             }
@@ -511,7 +470,7 @@ impl Item {
         use crate::graphics_style::Cost;
         match self {
             Item::Fullbright => Some(Cost::None),
-            Item::Minimap | Item::DynamicLights => Some(Cost::Low),
+            Item::DynamicLights => Some(Cost::Low),
             Item::AutoReconnect | Item::MouseTweaks | Item::Sort => Some(Cost::None),
             _ => None,
         }
@@ -521,8 +480,6 @@ impl Item {
         Some(match self {
             Item::Fullbright => e.fullbright,
             Item::DynamicLights => e.dynamic_lights,
-            Item::Minimap => e.minimap,
-            Item::MinimapRotate => e.minimap_rotate,
             Item::AutoReconnect => e.auto_reconnect,
             Item::MouseTweaks => e.mouse_tweaks,
             Item::MouseTweaksWheel => e.mouse_tweaks_wheel,
@@ -537,38 +494,22 @@ impl Item {
     pub fn value(self, e: &Extras) -> String {
         match self {
             Item::SortKey => crate::keybinds::display_name(&e.sort_key).plain(),
-            Item::MinimapCorner => e.minimap_corner.label().into(),
-            Item::MinimapSize => MINIMAP_SIZES
-                .iter()
-                .find(|s| s.0 == e.minimap_size)
-                .map_or("Medium", |s| s.1)
-                .into(),
-            Item::MinimapShape => if e.minimap_round { "Round" } else { "Square" }.into(),
-            Item::MinimapZoom => format!("{} per pixel", block_count(e.minimap_zoom)),
             other => match other.switch(e) {
                 Some(true) => "On".into(),
                 _ => "Off".into(),
             },
         }
     }
-    /// A click (`back` for the right button). The sort key binds instead.
-    pub fn cycle(self, e: &mut Extras, back: bool) {
+    /// A click (`_back` for the right button: every item left is a switch,
+    /// so both flip it). The sort key binds instead.
+    pub fn cycle(self, e: &mut Extras, _back: bool) {
         match self {
             Item::Fullbright => e.fullbright = !e.fullbright,
             Item::DynamicLights => e.dynamic_lights = !e.dynamic_lights,
-            Item::Minimap => e.minimap = !e.minimap,
-            Item::MinimapRotate => e.minimap_rotate = !e.minimap_rotate,
             Item::AutoReconnect => e.auto_reconnect = !e.auto_reconnect,
             Item::MouseTweaks => e.mouse_tweaks = !e.mouse_tweaks,
             Item::MouseTweaksWheel => e.mouse_tweaks_wheel = !e.mouse_tweaks_wheel,
             Item::Sort => e.sort = !e.sort,
-            Item::MinimapCorner => e.minimap_corner = next(&Corner::ALL, e.minimap_corner, back),
-            Item::MinimapSize => {
-                let sizes: Vec<u8> = MINIMAP_SIZES.iter().map(|s| s.0).collect();
-                e.minimap_size = next(&sizes, e.minimap_size, back);
-            }
-            Item::MinimapShape => e.minimap_round = !e.minimap_round,
-            Item::MinimapZoom => e.minimap_zoom = next(&MINIMAP_ZOOMS, e.minimap_zoom, back),
             Item::NoAi => e.no_ai = !e.no_ai,
             Item::AgentControl => e.agent_control = !e.agent_control,
             Item::DiscordPresence => e.discord_presence = !e.discord_presence,
@@ -712,12 +653,9 @@ mod tests {
     #[test]
     fn items_cycle_through_their_values() {
         let mut e = Extras::default();
-        Item::MinimapCorner.cycle(&mut e, true);
-        assert_eq!(e.minimap_corner, Corner::TopLeft);
-        Item::MinimapZoom.cycle(&mut e, true);
-        assert_eq!(Item::MinimapZoom.value(&e), "½ block per pixel");
-        Item::MinimapSize.cycle(&mut e, false);
-        assert_eq!(Item::MinimapSize.value(&e), "Large");
+        Item::Sort.cycle(&mut e, true);
+        assert_eq!(Item::Sort.value(&e), "On");
+        // The minimap's old keys still parse, for the move to its mod.
         assert_eq!(
             Extras::parse("minimapSize:7\nminimapZoom:3").minimap_zoom,
             1.0

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/font.rs

@@ -1201,6 +1201,31 @@ mod tests {
         assert!(!font.take_patches().is_empty());
     }
 
+    /// A renderer rebuilt over the same font (the loading screen's handoff)
+    /// makes its atlas texture from the textures alone, so the glyphs it had
+    /// rasterized into the previous texture must be placed into the new one.
+    #[test]
+    fn a_rebuilt_atlas_gets_its_glyphs_again() {
+        let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x));
+        let default = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ab"]}]}"#;
+        let root = root(
+            "rebuild",
+            &[
+                ("assets/minecraft/font/default.json", default),
+                ("assets/minecraft/textures/font/a.png", &sheet),
+            ],
+        );
+        let font = load(&root);
+        let _ = std::fs::remove_dir_all(&root);
+        let first = font.glyph('a');
+        assert_eq!(font.take_patches().len(), 1);
+        font.reset_cache();
+        // Nothing is left over: drawing the character again places its pixels.
+        assert!(font.take_patches().is_empty());
+        assert_eq!(font.glyph('a').advance, first.advance);
+        assert_eq!(font.take_patches().len(), 1);
+    }
+
     #[test]
     fn provider_filters_follow_the_font_options() {
         let sheet = png(8, 8, |x, _| x < 4);

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

@@ -300,6 +300,8 @@ struct Glide {
 pub(super) struct Agent {
     task: Option<Task>,
     glide: Option<Glide>,
+    /// Control-fixture barrier: hold simulation and packet handling, not transport threads.
+    pub hold_server: bool,
 }
 
 pub(super) enum Handled {
@@ -479,6 +481,8 @@ impl Game<'_> {
                 "absorption": p.health.absorption(),
                 // The hurt animation's ticks left (the camera's hurt tilt).
                 "hurt_time": p.health.hurt_animation_time,
+                // LivingEntity.deathTime while dead (the camera's death roll).
+                "death_time": self.death_time(),
                 "air": p.air,
                 "food": p.health.food.food,
                 "saturation": p.health.food.saturation,
@@ -667,6 +671,7 @@ impl Game<'_> {
         });
         if let Some(chat) = &self.ui.chat_screen {
             v["chat_input"] = json!(chat.input.value);
+            v["chat_suggestions"] = json!(chat.suggestions_visible());
         }
         if self.title.is_some() {
             v["menu"] = self.title_value();

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

@@ -453,6 +453,11 @@ impl Game<'_> {
         }
         // ArmorStand.swapItem.
         match held {
+            // A player with infinite materials puts a copy of one on an empty
+            // slot and keeps the stack.
+            Some(h) if self.creative && current.is_none() => {
+                self.armor_stands[i].equipment[slot] = Some(ItemStack { count: 1, ..h });
+            }
             Some(h) if h.count > 1 => {
                 if current.is_some() {
                     return true;

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

@@ -515,8 +515,7 @@ impl Game<'_> {
         if self.carried.is_some() {
             self.draw_carried(batch);
         } else if let Some(stack) = stack_tip {
-            let lines = self.stack_tooltip(&stack);
-            self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
+            self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1);
         } else if let Some(key) = tooltip {
             let text = self.translate(&key, &key);
             self.draw_tooltip_lines(

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

@@ -5,10 +5,14 @@
 //! [`Game::block_anim`] and [`Game::chest_lid`].
 use super::Game;
 use horizon_client::{
-    block_entity_anim::{BellEntity, EndGateway, Shulker, ShulkerStatus, Ticker},
+    block_entity_anim::{
+        BellEntity, ConduitServer, ConduitTarget, EndGateway, Shulker, ShulkerStatus, Ticker,
+    },
     block_entity_render::BlockAnim,
     collisions::{SceneCollisions, no_collision_empty},
     containers::BlockEntity,
+    effects::EffectInstance,
+    mobs::{Damage, DamageKind},
     particles::{ParticleOptions, ParticleType},
     save::number,
     skins,
@@ -16,6 +20,7 @@ use horizon_client::{
 use horizon_core::{
     geometry::{Aabb, Vec3},
     position::BlockPos,
+    random::RandomSource,
 };
 use horizon_world::nbt::Tag;
 
@@ -218,7 +223,15 @@ impl Game<'_> {
     /// The client tickers of the loaded animated block entities, once per
     /// client tick (`ClientLevel.tickBlockEntities`).
     pub(super) fn tick_block_entity_anims(&mut self) {
+        // A server has no window, but its gateways and conduits still run
+        // their server tickers; a client of one only animates what it is sent.
+        if self.remote.is_none() {
+            self.tick_conduit_servers();
+        }
         let Some(r) = &self.renderer else {
+            if self.remote.is_none() {
+                self.tick_gateway_servers();
+            }
             return;
         };
         // Sorted by position: the order they tick in, and a quick lookup.
@@ -332,6 +345,7 @@ impl Game<'_> {
                     }
                 }
                 Ticker::Conduit => {
+                    let target = self.conduit_target(pos);
                     let world = &self.world;
                     let facts = self.res.facts();
                     let registry = self.pack.assets.registry;
@@ -351,7 +365,7 @@ impl Game<'_> {
                         time,
                         is_water,
                         is_frame,
-                        None,
+                        target,
                         self.particles.random(),
                     );
                     let nautilus = ParticleOptions::simple(ParticleType::Nautilus);
@@ -378,6 +392,273 @@ impl Game<'_> {
         }
         self.be_anims.present = positions;
     }
+    /// `ConduitBlockEntity.serverTick` of every conduit in the chunks that
+    /// tick blocks, with or without a renderer. The conduits are looked for
+    /// when the shape is checked, every 40 ticks (they have no block entity
+    /// of their own here).
+    fn tick_conduit_servers(&mut self) {
+        if self.world.game_time % 40 == 0 {
+            self.find_conduits();
+        }
+        let mut positions: Vec<[i32; 3]> = self.be_anims.conduit_servers.keys().copied().collect();
+        positions.sort_unstable();
+        for pos in positions {
+            self.tick_conduit_server(pos);
+        }
+    }
+    /// Sets `be_anims.conduit_servers` to the conduits in the
+    /// chunks that tick blocks, keeping the state of those already known.
+    fn find_conduits(&mut self) {
+        let levels = self.tickets.levels();
+        let kinds = &self.be_anims.kinds;
+        let is_conduit = |id: u32| matches!(kinds.get(id as usize), Some(Some(Ticker::Conduit)));
+        let mut found = Vec::new();
+        for (&(cx, cz), chunk) in &self.world.chunks {
+            if !levels.block_ticking_at(cx * 16, cz * 16) {
+                continue;
+            }
+            for (si, section) in chunk.sections.iter().enumerate() {
+                if !section.blocks.maybe_has(is_conduit) {
+                    continue;
+                }
+                for i in 0..4096 {
+                    if is_conduit(section.get(i)) {
+                        found.push([
+                            cx * 16 + (i & 15) as i32,
+                            horizon_client::chunk::MIN_Y + si as i32 * 16 + (i >> 8) as i32,
+                            cz * 16 + ((i >> 4) & 15) as i32,
+                        ]);
+                    }
+                }
+            }
+        }
+        let mut old = std::mem::take(&mut self.be_anims.conduit_servers);
+        for pos in found {
+            let known = old.remove(&pos).unwrap_or_default();
+            self.be_anims.conduit_servers.insert(pos, known);
+        }
+    }
+    /// `ConduitBlockEntity.serverTick` of the conduit at `pos`, in a chunk
+    /// that ticks blocks: the shape check every 40 ticks with its sounds, the
+    /// power for players in range, the hurt for an enemy, then the ambient
+    /// sounds.
+    fn tick_conduit_server(&mut self, pos: [i32; 3]) {
+        let state = self.world.block(pos[0], pos[1], pos[2]).0;
+        if self.be_anims.ticker(state) != Some(Ticker::Conduit) {
+            // Broken since the chunks were searched.
+            self.be_anims.conduit_servers.remove(&pos);
+            return;
+        }
+        if !self.tickets.levels().block_ticking_at(pos[0], pos[2])
+            || !self.border.contains(f64::from(pos[0]), f64::from(pos[2]))
+        {
+            return;
+        }
+        let time = self.world.game_time;
+        let mut conduit = self
+            .be_anims
+            .conduit_servers
+            .remove(&pos)
+            .unwrap_or_default();
+        let check = {
+            let world = &self.world;
+            let facts = self.res.facts();
+            let registry = self.pack.assets.registry;
+            let frames = self
+                .res
+                .items()
+                .block_tags
+                .get("minecraft:conduit_effect_block");
+            // Level.isWaterAt: the fluid at the position is water.
+            let is_water = |p: [i32; 3]| {
+                facts.get(world.block(p[0], p[1], p[2])).fluid
+                    == horizon_client::blocks::Fluid::Water
+            };
+            let is_frame = |p: [i32; 3]| {
+                registry
+                    .state(world.block(p[0], p[1], p[2]))
+                    .is_some_and(|s| frames.is_some_and(|f| f.contains(&s.name)))
+            };
+            conduit.check(pos, time, is_water, is_frame)
+        };
+        let centre = [
+            f64::from(pos[0]) + 0.5,
+            f64::from(pos[1]) + 0.5,
+            f64::from(pos[2]) + 0.5,
+        ];
+        if let Some(check) = check {
+            if let Some(active) = check.toggled {
+                let sound = if active {
+                    "minecraft:block.conduit.activate"
+                } else {
+                    "minecraft:block.conduit.deactivate"
+                };
+                self.audio.play(sound, Some(centre), 1.0, 1.0);
+            }
+            if let Some(frames) = check.frames {
+                self.conduit_apply_effects(pos, frames);
+                self.conduit_attack(&mut conduit, pos, frames >= 42);
+            }
+        }
+        let (ambient, short) = conduit.ambient(time, &mut self.world.random);
+        if ambient {
+            self.audio
+                .play("minecraft:block.conduit.ambient", Some(centre), 1.0, 1.0);
+        }
+        if short {
+            self.audio.play(
+                "minecraft:block.conduit.ambient_short",
+                Some(centre),
+                1.0,
+                1.0,
+            );
+        }
+        self.be_anims.conduit_servers.insert(pos, conduit);
+    }
+    /// `ConduitBlockEntity.applyEffects`: conduit power for every player
+    /// in water or rain within `frames / 7 * 16` blocks.
+    fn conduit_apply_effects(&mut self, pos: [i32; 3], frames: usize) {
+        let range = (frames / 7 * 16) as i64;
+        self.for_each_player(|g| {
+            let Some(p) = g.player.as_ref().filter(|p| !p.health.dead_or_dying()) else {
+                return;
+            };
+            if g.spectator() {
+                return;
+            }
+            let at = p.position;
+            let in_water = p.fluids.was_touching_water;
+            let top = at.y + f64::from(p.dimensions.height);
+            // BlockPos.closerThan: the squared distance under range squared.
+            let d = [at.x, at.y, at.z]
+                .map(|v| v.floor() as i64)
+                .iter()
+                .zip(pos)
+                .map(|(a, b)| (a - i64::from(b)).pow(2))
+                .sum::<i64>();
+            if d >= range * range || !(in_water || g.in_rain(at, top)) {
+                return;
+            }
+            let power = EffectInstance {
+                ambient: true,
+                ..EffectInstance::new("conduit_power", 260, 0)
+            };
+            g.potions.effects.add(power);
+        });
+    }
+    /// `Entity.isInRain`: rain at the block position or at the top of the box.
+    fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
+        let p = BlockPos::new(
+            at.x.floor() as i32,
+            at.y.floor() as i32,
+            at.z.floor() as i32,
+        );
+        let up = BlockPos::new(p.x, top.floor() as i32, p.z);
+        self.with_level(|b, level, _| b.is_raining_at(level, p) || b.is_raining_at(level, up))
+    }
+    /// `ConduitBlockEntity.updateAndAttackTarget`: while the conduit hunts
+    /// (42 frame blocks) its target stays until it dies or leaves the 8
+    /// blocks, else a random enemy in water or rain is chosen; the target
+    /// takes 4 magic damage.
+    fn conduit_attack(&mut self, conduit: &mut ConduitServer, pos: [i32; 3], hunting: bool) {
+        conduit.target = match conduit.target {
+            _ if !hunting => None,
+            None => self.conduit_new_target(pos),
+            Some(id) => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && !m.removed)
+                .filter(|m| {
+                    let at = [m.position.x, m.position.y, m.position.z].map(|v| v.floor() as i64);
+                    m.alive()
+                        && at
+                            .iter()
+                            .zip(pos)
+                            .map(|(a, b)| (a - i64::from(b)).pow(2))
+                            .sum::<i64>()
+                            < 64
+                })
+                .map(|m| m.id),
+        };
+        let Some(m) = conduit
+            .target
+            .and_then(|id| self.mobs.iter_mut().find(|m| m.id == id))
+        else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        m.damage(4.0, Damage::of(DamageKind::Magic));
+        self.audio
+            .play("minecraft:block.conduit.attack.target", Some(at), 1.0, 1.0);
+    }
+    /// `ConduitBlockEntity.selectNewTarget`: one of the enemies in water or
+    /// rain whose box meets the conduit's block inflated by 8.
+    fn conduit_new_target(&mut self, pos: [i32; 3]) -> Option<u32> {
+        let [x, y, z] = pos.map(f64::from);
+        let area = Aabb::new(
+            Vec3::new(x - 8.0, y - 8.0, z - 8.0),
+            Vec3::new(x + 9.0, y + 9.0, z + 9.0),
+        );
+        let near: Vec<(u32, bool, Vec3, f64)> = self
+            .mobs
+            .iter()
+            .filter(|m| m.hostile() && !m.removed && m.bounds().intersects(area))
+            .map(|m| {
+                let top = m.position.y + f64::from(m.height());
+                (m.id, m.fluids.in_water, m.position, top)
+            })
+            .collect();
+        let candidates: Vec<u32> = near
+            .into_iter()
+            .filter(|&(_, in_water, at, top)| in_water || self.in_rain(at, top))
+            .map(|(id, ..)| id)
+            .collect();
+        if candidates.is_empty() {
+            return None;
+        }
+        let pick = self
+            .world
+            .random
+            .next_int_bound(candidates.len() as i32)
+            .unwrap_or(0);
+        Some(candidates[pick as usize])
+    }
+    /// The conduit's `destroyTarget` as the client draws it.
+    fn conduit_target(&self, pos: [i32; 3]) -> Option<ConduitTarget> {
+        let id = self.be_anims.conduit_servers.get(&pos)?.target?;
+        let m = self.mobs.iter().find(|m| m.id == id && !m.removed)?;
+        Some(ConduitTarget {
+            position: [m.position.x, m.position.y, m.position.z],
+            eye_y: m.eye_y(),
+            width: m.width(),
+            height: m.height(),
+        })
+    }
+    /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the
+    /// gateways a server keeps a copy of, in block-ticking chunks
+    /// (`Level.tickBlockEntities`): the cooldown an entry started runs out,
+    /// and every 2400 ticks `triggerCooldown` sends its block event.
+    fn tick_gateway_servers(&mut self) {
+        let levels = self.tickets.levels();
+        let mut positions: Vec<[i32; 3]> = self
+            .be_anims
+            .gateway_servers
+            .keys()
+            .copied()
+            .filter(|p| levels.block_ticking_at(p[0], p[2]))
+            .collect();
+        positions.sort_unstable();
+        for pos in positions {
+            let triggered = self
+                .be_anims
+                .gateway_servers
+                .get_mut(&pos)
+                .is_some_and(EndGateway::portal_tick);
+            if triggered {
+                self.block_entity_event(pos, 1, 0);
+            }
+        }
+    }
     /// `EndGatewayBlock.entityInside` on the server: whether the gateway at
     /// `pos` let the entity in (`triggerCooldown`, with its block event).
     pub(super) fn gateway_enter(&mut self, pos: [i32; 3]) -> bool {

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

@@ -10,6 +10,7 @@ use horizon_client::{
     block_entities::{Pos, Ticking},
     containers::{BlockEntity, FurnaceKind, HOPPER_SLOTS},
 };
+use horizon_core::position::BlockPos;
 use horizon_world::registry::BlockStateId;
 
 impl Game<'_> {
@@ -56,6 +57,8 @@ impl Game<'_> {
                 Some(BlockEntity::Beehive(_)) => self.tick_beehive(pos),
                 Some(BlockEntity::Furnace(_)) => self.tick_furnace(pos)?,
                 Some(BlockEntity::Brewing(_)) => self.tick_brewing_stand(pos)?,
+                Some(BlockEntity::DaylightDetector) => self.tick_daylight_detector(pos),
+                Some(BlockEntity::Campfire(_)) => self.tick_campfire(pos)?,
                 _ => {}
             }
         }
@@ -92,7 +95,11 @@ impl Game<'_> {
                     | "minecraft:vault"
                     | "minecraft:beehive"
                     | "minecraft:bee_nest"
-                    | "minecraft:brewing_stand" => Ticking::Yes,
+                    | "minecraft:brewing_stand"
+                    | "minecraft:daylight_detector"
+                    // Lit, cookTick; unlit, cooldownTick.
+                    | "minecraft:campfire"
+                    | "minecraft:soul_campfire" => Ticking::Yes,
                     "minecraft:jukebox" => {
                         let record = registry
                             .state(state)
@@ -113,6 +120,16 @@ impl Game<'_> {
         let levels = self.tickets.levels();
         move |x, z| levels.block_ticking_at(x, z)
     }
+    /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
+    fn tick_daylight_detector(&mut self, pos: Pos) {
+        // It updates every 20 game ticks (the behaviour checks this too).
+        if self.world.game_time % 20 != 0 {
+            return;
+        }
+        let at = BlockPos::new(pos.0, pos.1, pos.2);
+        self.with_level(|b, level, ticks| b.tick_daylight_detector(level, ticks, at));
+        let _ = self.process_level_events();
+    }
     /// `AbstractFurnaceBlockEntity.serverTick` of the furnace at `pos`, and
     /// its block's `lit` following it.
     fn tick_furnace(&mut self, pos: Pos) -> Result<()> {

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

@@ -55,7 +55,7 @@ pub(super) struct Boat {
 /// `ChestBoat.CONTAINER_SIZE`.
 pub(super) const CHEST_SLOTS: usize = 27;
 pub(super) const WIDTH: f64 = 1.375;
-const HEIGHT: f64 = 0.5625;
+pub(super) const HEIGHT: f64 = 0.5625;
 impl Boat {
     pub fn new(id: u32, wood: Arc<str>, position: Vec3, yaw: f32) -> Self {
         Self {
@@ -587,6 +587,9 @@ impl Game<'_> {
     }
     /// The player's tick while riding: steer, tick the boat, sit in it.
     pub(super) fn tick_riding(&mut self, keys: Keys) -> horizon_client::Result<()> {
+        if self.tick_cushion_riding(keys) {
+            return Ok(());
+        }
         let Some(i) = self.boats.iter().position(|b| Some(b.id) == self.riding) else {
             if self.tick_cart_riding(keys) || self.tick_mount_riding(keys) {
                 return Ok(());

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

@@ -17,7 +17,6 @@ use horizon_client::{
 use horizon_core::position::BlockPos;
 use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
 use horizon_world::level::flags as level_flags;
-use std::time::Instant;
 use winit::{
     event::{ElementState, KeyEvent},
     keyboard::{KeyCode, PhysicalKey},
@@ -27,8 +26,24 @@ const BLACK: u32 = 0xFF00_0000;
 const PAGE_CHARS: usize = 1024;
 const MAX_PAGES: usize = 100;
 const LINES: usize = 14;
-/// `BookSignScreen`'s title box.
-const BOOK_TITLE: horizon_client::clipboard::FieldId = ("book.title", 0);
+
+fn book_title_box() -> ui::EditBox {
+    let mut edit = ui::EditBox::new(0.0, 0.0, 114.0, 9.0);
+    edit.bordered = false;
+    edit.max_length = 15;
+    edit.text_color = BLACK;
+    edit.focused = true;
+    edit
+}
+fn book_page_box() -> ui::EditBox {
+    let mut edit = ui::EditBox::new(0.0, 0.0, 114.0, 9.0);
+    edit.bordered = false;
+    edit.multiline = true;
+    edit.max_length = PAGE_CHARS;
+    edit.text_color = BLACK;
+    edit.focused = true;
+    edit
+}
 
 pub(super) enum BookScreen {
     Edit {
@@ -38,7 +53,10 @@ pub(super) enum BookScreen {
         page: usize,
         signing: bool,
         title: String,
-        opened: Instant,
+        /// BookSignScreen's title box (`EditBox` of 15).
+        title_edit: ui::EditBox,
+        /// BookEditScreen's page (`MultiLineEditBox`).
+        page_edit: ui::EditBox,
     },
     View {
         pages: Vec<String>,
@@ -84,13 +102,16 @@ impl Game<'_> {
                 if pages.is_empty() {
                     pages.push(String::new());
                 }
+                let mut page_edit = book_page_box();
+                page_edit.set_value(&pages[0]);
                 BookScreen::Edit {
                     slot: self.held_slot(),
                     pages,
                     page: 0,
                     signing: false,
                     title: String::new(),
-                    opened: Instant::now(),
+                    title_edit: book_title_box(),
+                    page_edit,
                 }
             }
             "minecraft:written_book" => BookScreen::View {
@@ -239,34 +260,24 @@ impl Game<'_> {
                 Some(KeyCode::PageDown) => self.turn_page(true),
                 _ => {}
             },
-            Some(BookScreen::Edit {
-                signing: true,
-                title,
-                ..
-            }) => match key {
+            Some(BookScreen::Edit { signing: true, .. }) => match key {
                 Some(KeyCode::Escape) => {
                     if let Some(BookScreen::Edit { signing, .. }) = self.book.as_mut() {
                         *signing = false;
                     }
                 }
-                Some(KeyCode::Backspace) => {
-                    if !self.text_selection.take(BOOK_TITLE, title) {
-                        title.pop();
-                    }
-                }
                 Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
-                    if !title.trim().is_empty() {
+                    let blank = self.book.as_ref().is_some_and(
+                        |b| matches!(b, BookScreen::Edit { title, .. } if title.trim().is_empty()),
+                    );
+                    if !blank {
                         self.save_book(true);
                     }
                 }
+                Some(key) if self.book_title_key(key) => {}
                 _ => {
                     if let Some(typed) = text {
-                        self.text_selection.take(BOOK_TITLE, title);
-                        for c in typed.chars().filter(|c| !c.is_control()) {
-                            if title.chars().count() < 15 {
-                                title.push(c);
-                            }
-                        }
+                        self.book_title_insert(typed);
                     }
                 }
             },
@@ -274,24 +285,13 @@ impl Game<'_> {
                 Some(KeyCode::Escape) => self.save_book(false),
                 Some(KeyCode::PageUp) => self.turn_page(false),
                 Some(KeyCode::PageDown) => self.turn_page(true),
-                Some(KeyCode::Backspace) => {
-                    if !self.take_page_selection() {
-                        self.edit_page(|p| {
-                            p.pop();
-                        })
-                    }
-                }
-                Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
-                    self.take_page_selection();
-                    self.type_into_page("\n")
-                }
+                Some(KeyCode::ArrowUp) => self.book_move_line(-1),
+                Some(KeyCode::ArrowDown) => self.book_move_line(1),
+                Some(KeyCode::Enter | KeyCode::NumpadEnter) => self.page_insert("\n"),
+                Some(key) if self.book_page_key(key) => {}
                 _ => {
                     if let Some(typed) = text {
-                        let typed: String = typed.chars().filter(|c| !c.is_control()).collect();
-                        if !typed.is_empty() {
-                            self.take_page_selection();
-                        }
-                        self.type_into_page(&typed);
+                        self.page_insert(typed);
                     }
                 }
             },
@@ -302,99 +302,258 @@ impl Game<'_> {
     pub(super) fn book_type(&mut self, text: &str) {
         let text = text.replace("\\n", "\n");
         match self.book.as_mut() {
-            Some(BookScreen::Edit {
-                signing: true,
-                title,
-                ..
-            }) => {
-                for c in text.chars().filter(|c| !c.is_control()) {
-                    if title.chars().count() < 15 {
-                        title.push(c);
-                    }
-                }
-            }
-            Some(BookScreen::Edit { .. }) => self.type_into_page(&text),
+            Some(BookScreen::Edit { signing: true, .. }) => self.book_title_insert(&text),
+            Some(BookScreen::Edit { .. }) => self.page_insert(&text),
             _ => {}
         }
     }
-    /// Before typing on a page: Select All's selection is cleared (true).
-    fn take_page_selection(&mut self) -> bool {
-        match self.book.as_mut() {
-            Some(BookScreen::Edit { pages, page, .. }) => self
-                .text_selection
-                .take(("book.page", *page), &mut pages[*page]),
-            _ => false,
+    /// `BookSignScreen.keyPressed` on the title box.
+    fn book_title_key(&mut self, key: KeyCode) -> bool {
+        let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+        let Some(BookScreen::Edit {
+            title, title_edit, ..
+        }) = self.book.as_mut()
+        else {
+            return false;
+        };
+        if !title_edit.key(key, ctrl, shift) {
+            return false;
         }
+        title.clone_from(&title_edit.value);
+        true
     }
-    /// Ctrl+A/C/V/X: the title box (an `EditBox` of 15) while signing, else
-    /// the page (`MultilineTextField.insertText`: line breaks kept, cut to
-    /// the 1024 characters left, rejected when it overflows the 14 lines).
-    pub(super) fn book_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
-        let font = &self.gui.atlas.font;
-        match self.book.as_mut() {
-            Some(BookScreen::Edit {
-                signing: true,
-                title,
-                ..
-            }) => {
-                Self::append_shortcut(
-                    &mut self.text_selection,
-                    &mut self.clipboard,
-                    BOOK_TITLE,
-                    title,
-                    shortcut,
-                    15,
-                );
-            }
-            Some(BookScreen::Edit { pages, page, .. }) => {
-                // truncateInsertionText counts the whole value, selection included.
-                let room = PAGE_CHARS.saturating_sub(pages[*page].chars().count());
-                self.text_selection.apply(
-                    ("book.page", *page),
-                    &mut pages[*page],
-                    shortcut,
-                    &mut self.clipboard,
-                    |value, pasted| {
-                        let text: String = horizon_client::clipboard::filter_text(pasted, true)
-                            .chars()
-                            .take(room)
-                            .collect();
-                        let next = format!("{value}{text}");
-                        font.split(&Text::literal(&next), 114.0).len() <= LINES && {
-                            *value = next;
-                            true
-                        }
-                    },
-                );
-            }
-            _ => {}
-        }
-    }
-    fn edit_page(&mut self, f: impl FnOnce(&mut String)) {
-        if let Some(BookScreen::Edit { pages, page, .. }) = self.book.as_mut() {
-            f(&mut pages[*page]);
-        }
-    }
-    /// MultiLineEditBox: characters that keep the page within 14 lines and 1024 characters.
-    fn type_into_page(&mut self, typed: &str) {
-        let Some(BookScreen::Edit { pages, page, .. }) = self.book.as_ref() else {
+    fn book_title_insert(&mut self, text: &str) {
+        let Some(BookScreen::Edit {
+            title, title_edit, ..
+        }) = self.book.as_mut()
+        else {
             return;
         };
-        let mut text = pages[*page].clone();
-        for c in typed.chars() {
-            let mut next = text.clone();
-            next.push(c);
-            if next.chars().count() <= PAGE_CHARS && self.book_lines(&next).len() <= LINES {
-                text = next;
+        title_edit.insert_text(text);
+        title.clone_from(&title_edit.value);
+    }
+    /// `BookEditScreen.keyPressed` on the page, apart from the line moves.
+    fn book_page_key(&mut self, key: KeyCode) -> bool {
+        let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+        let before = match self.book.as_ref() {
+            Some(BookScreen::Edit { page_edit, .. }) => Some((
+                page_edit.value.clone(),
+                page_edit.cursor,
+                page_edit.highlight,
+            )),
+            _ => return false,
+        };
+        let handled = if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+            page_edit.key(key, ctrl, shift)
+        } else {
+            false
+        };
+        if handled {
+            self.page_keep(before);
+        }
+        handled
+    }
+    /// One character at a time, so a page stops at the last character that fits.
+    fn page_insert(&mut self, text: &str) {
+        for c in text.chars() {
+            self.page_change(|edit| edit.insert_text(&c.to_string()));
+        }
+    }
+    /// Ctrl+A/C/V/X: the title box while signing, else the page.
+    pub(super) fn book_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
+        let signing = matches!(self.book, Some(BookScreen::Edit { signing: true, .. }));
+        if signing {
+            if let Some(BookScreen::Edit {
+                title, title_edit, ..
+            }) = self.book.as_mut()
+            {
+                title_edit.shortcut(shortcut, &mut self.clipboard);
+                title.clone_from(&title_edit.value);
+            }
+            return;
+        }
+        let before = match self.book.as_ref() {
+            Some(BookScreen::Edit { page_edit, .. }) => Some((
+                page_edit.value.clone(),
+                page_edit.cursor,
+                page_edit.highlight,
+            )),
+            _ => None,
+        };
+        if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+            page_edit.shortcut(shortcut, &mut self.clipboard);
+        }
+        self.page_keep(before);
+    }
+    /// Edit the page box, then keep it only within 14 lines and 1024 characters.
+    fn page_change(&mut self, f: impl FnOnce(&mut ui::EditBox)) -> bool {
+        let before = match self.book.as_ref() {
+            Some(BookScreen::Edit { page_edit, .. }) => Some((
+                page_edit.value.clone(),
+                page_edit.cursor,
+                page_edit.highlight,
+            )),
+            _ => return false,
+        };
+        let ran = if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+            f(page_edit);
+            true
+        } else {
+            false
+        };
+        ran && self.page_keep(before)
+    }
+    /// Write the page, or put the previous text back when it no longer fits.
+    fn page_keep(&mut self, before: Option<(String, usize, usize)>) -> bool {
+        let next = match self.book.as_ref() {
+            Some(BookScreen::Edit { page_edit, .. }) => page_edit.value.clone(),
+            _ => return false,
+        };
+        let ok = next.chars().count() <= PAGE_CHARS && self.book_lines(&next).len() <= LINES;
+        let Some(BookScreen::Edit {
+            pages,
+            page,
+            page_edit,
+            ..
+        }) = self.book.as_mut()
+        else {
+            return false;
+        };
+        if ok {
+            pages[*page].clone_from(&page_edit.value);
+        } else if let Some((value, cursor, highlight)) = before {
+            page_edit.value = value;
+            page_edit.cursor = cursor;
+            page_edit.highlight = highlight;
+        }
+        ok
+    }
+    /// ArrowUp and ArrowDown move a visual line, keeping the column.
+    fn book_move_line(&mut self, dir: isize) {
+        let shift = self.has_shift_down();
+        let (text, cursor) = match self.book.as_ref() {
+            Some(BookScreen::Edit {
+                pages,
+                page,
+                page_edit,
+                ..
+            }) => (pages[*page].clone(), page_edit.cursor),
+            _ => return,
+        };
+        let rows = self.page_rows(&text);
+        let (x, line) = self.caret_on(&text, &rows, cursor);
+        let next = (line as isize + dir).clamp(0, rows.len() as isize - 1) as usize;
+        let (start, end) = rows[next];
+        let chars: Vec<char> = text.chars().collect();
+        let slice: String = chars[start..end].iter().collect();
+        let pos = start + self.gui.atlas.font.fit(&slice, x);
+        if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+            page_edit.set_cursor(pos, shift);
+        }
+    }
+    /// Wrapped rows of a page as character ranges, the same breaks as `font.split`.
+    fn page_rows(&self, page: &str) -> Vec<(usize, usize)> {
+        let font = &self.gui.atlas.font;
+        let chars: Vec<char> = page.chars().collect();
+        let mut rows = Vec::new();
+        let mut start = 0;
+        while start < chars.len() {
+            let mut end = chars.len();
+            let mut next = chars.len();
+            let mut last_space = None;
+            for i in start..chars.len() {
+                if chars[i] == '\n' {
+                    end = i;
+                    next = i + 1;
+                    break;
+                }
+                if chars[i] == ' ' {
+                    last_space = Some(i);
+                }
+                let slice: String = chars[start..=i].iter().collect();
+                if font.width(&slice) > 114.0 {
+                    match last_space {
+                        Some(s) if s > start => {
+                            end = s;
+                            next = s + 1;
+                        }
+                        _ => {
+                            end = i.max(start + 1);
+                            next = end;
+                        }
+                    }
+                    break;
+                }
+            }
+            rows.push((start, end));
+            start = next;
+            if start == chars.len() && chars.last() == Some(&'\n') {
+                rows.push((chars.len(), chars.len()));
             }
         }
-        self.edit_page(|p| *p = text);
+        if rows.is_empty() {
+            rows.push((0, 0));
+        }
+        rows
+    }
+    /// GUI x of the caret and the row it sits on.
+    fn caret_on(&self, page: &str, rows: &[(usize, usize)], cursor: usize) -> (f32, usize) {
+        let chars: Vec<char> = page.chars().collect();
+        for (i, &(start, end)) in rows.iter().enumerate() {
+            if cursor <= end || i + 1 == rows.len() {
+                let take = cursor.saturating_sub(start).min(end.saturating_sub(start));
+                let prefix: String = chars.iter().skip(start).take(take).collect();
+                return (self.gui.atlas.font.width(&prefix), i);
+            }
+        }
+        (0.0, 0)
+    }
+    fn page_index_at(&self, page: &str, local_x: f32, local_y: f32) -> usize {
+        let rows = self.page_rows(page);
+        let line = (local_y / 9.0).floor().max(0.0) as usize;
+        let line = line.min(rows.len().saturating_sub(1));
+        let (start, end) = rows[line];
+        let chars: Vec<char> = page.chars().collect();
+        let slice: String = chars[start..end].iter().collect();
+        start + self.gui.atlas.font.fit(&slice, local_x.max(0.0))
+    }
+    /// A click on the centred title (`EditBox.onClick`).
+    fn book_title_click(&mut self, field_x: f32, mx: f32) {
+        let shift = self.has_shift_down();
+        let Some(BookScreen::Edit {
+            title, title_edit, ..
+        }) = self.book.as_mut()
+        else {
+            return;
+        };
+        let tx = field_x + ((114.0 - self.gui.atlas.font.width(title)) / 2.0).floor();
+        let rel = (mx - tx).max(0.0);
+        let pos = self.gui.atlas.font.fit(title, rel);
+        title_edit.set_cursor(pos, shift);
+    }
+    /// A click on the open page.
+    fn book_page_click(&mut self, origin_x: f32, origin_y: f32, mx: f32, my: f32) {
+        let shift = self.has_shift_down();
+        let text = match self.book.as_ref() {
+            Some(BookScreen::Edit { pages, page, .. }) => pages[*page].clone(),
+            _ => return,
+        };
+        let pos = self.page_index_at(&text, mx - origin_x, my - origin_y);
+        if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+            page_edit.set_cursor(pos, shift);
+        }
     }
     /// The page buttons (`pageForward` adds a page while editing).
     fn turn_page(&mut self, forward: bool) {
         let mut lectern_page = None;
         match self.book.as_mut() {
-            Some(BookScreen::Edit { pages, page, .. }) => {
+            Some(BookScreen::Edit {
+                pages,
+                page,
+                page_edit,
+                ..
+            }) => {
+                let before = *page;
                 if forward {
                     if *page + 1 >= pages.len() && pages.len() < MAX_PAGES {
                         pages.push(String::new());
@@ -405,6 +564,10 @@ impl Game<'_> {
                 } else if *page > 0 {
                     *page -= 1;
                 }
+                if *page != before {
+                    let text = pages[*page].clone();
+                    page_edit.set_value(&text);
+                }
             }
             Some(BookScreen::View {
                 lectern: Some(key), ..
@@ -764,6 +927,8 @@ impl Game<'_> {
                     if let Some(BookScreen::Edit { signing, .. }) = self.book.as_mut() {
                         *signing = false;
                     }
+                } else if inside(left + 36.0, 50.0, 114.0, 9.0) {
+                    self.book_title_click(left + 36.0, mx);
                 }
             }
             Some(BookScreen::Edit { page, .. }) => {
@@ -780,6 +945,8 @@ impl Game<'_> {
                 } else if inside(w / 2.0 + 2.0, 196.0, 98.0, 20.0) {
                     click(self);
                     self.save_book(false);
+                } else if inside(left + 36.0, 32.0, 114.0, 14.0 * 9.0) {
+                    self.book_page_click(left + 36.0, 32.0, mx, my);
                 }
             }
             Some(BookScreen::View {
@@ -865,7 +1032,7 @@ impl Game<'_> {
             BookScreen::Edit {
                 signing: true,
                 title,
-                opened,
+                title_edit,
                 ..
             } => {
                 let edit = tr("book.editTitle", "Enter Book Title:");
@@ -881,19 +1048,35 @@ impl Game<'_> {
                 // The title box: an unbordered, centred EditBox of 114 with
                 // black text and no shadow; the value alone is centred, the
                 // cursor follows it.
+                let value = &title_edit.value;
                 let x = left + 36.0;
-                let tx = x + ((114.0 - HudBatch::text_width(atlas, title)) / 2.0).floor();
-                horizon_client::ui::append_field(
-                    batch,
-                    atlas,
-                    title,
-                    (tx, 50.0, x + 114.0 - tx),
-                    (BLACK, false),
-                    15,
-                    self.text_selection.covers(BOOK_TITLE, title),
-                    true,
-                    opened.elapsed().as_millis(),
-                );
+                let tx = x + ((114.0 - HudBatch::text_width(atlas, value)) / 2.0).floor();
+                batch.text(atlas, value, tx, 50.0, BLACK, false);
+                if title_edit.cursor != title_edit.highlight {
+                    let (a, b) = (
+                        title_edit.cursor.min(title_edit.highlight),
+                        title_edit.cursor.max(title_edit.highlight),
+                    );
+                    let pre: String = value.chars().take(a).collect();
+                    let sel: String = value.chars().skip(a).take(b - a).collect();
+                    let sx = tx + HudBatch::text_width(atlas, &pre);
+                    batch.text_highlight(
+                        atlas,
+                        (sx, 49.0, HudBatch::text_width(atlas, &sel), 11.0),
+                        true,
+                    );
+                }
+                if title_edit.cursor_visible() {
+                    let pre: String = value.chars().take(title_edit.cursor).collect();
+                    batch.fill(
+                        atlas,
+                        tx + HudBatch::text_width(atlas, &pre),
+                        49.0,
+                        1.0,
+                        9.0,
+                        BLACK,
+                    );
+                }
                 let by = tr("book.byAuthor", "by %1$s").replace("%1$s", super::chat::PLAYER_NAME);
                 let tw = HudBatch::text_width(atlas, &by);
                 batch.text(
@@ -941,12 +1124,12 @@ impl Game<'_> {
             BookScreen::Edit {
                 pages,
                 page,
-                opened,
+                page_edit,
                 ..
             } => {
                 indicator(batch, *page, pages.len());
-                let blink = (opened.elapsed().as_millis() / 300) % 2 == 0;
-                let lines = self.book_lines(&pages[*page]);
+                let text = &pages[*page];
+                let lines = self.book_lines(text);
                 for (i, line) in lines.iter().take(LINES).enumerate() {
                     batch.text_styled(
                         atlas,
@@ -957,27 +1140,39 @@ impl Game<'_> {
                         false,
                     );
                 }
-                if blink {
-                    // The cursor after the last character.
-                    let last = lines
-                        .last()
-                        .map(|l| atlas.font.width_text(l))
-                        .unwrap_or(0.0);
-                    let row = lines.len().saturating_sub(1) as f32
-                        + if pages[*page].ends_with('\n') {
-                            1.0
-                        } else {
-                            0.0
-                        };
-                    let x = if pages[*page].ends_with('\n') {
-                        0.0
-                    } else {
-                        last
-                    };
+                let rows = self.page_rows(text);
+                let (sel_a, sel_b) = (
+                    page_edit.cursor.min(page_edit.highlight),
+                    page_edit.cursor.max(page_edit.highlight),
+                );
+                if sel_a != sel_b {
+                    let chars: Vec<char> = text.chars().collect();
+                    for (i, &(start, end)) in rows.iter().enumerate().take(LINES) {
+                        let from = sel_a.max(start);
+                        let to = sel_b.min(end);
+                        if from >= to {
+                            continue;
+                        }
+                        let pre: String = chars[start..from].iter().collect();
+                        let sel: String = chars[from..to].iter().collect();
+                        batch.text_highlight(
+                            atlas,
+                            (
+                                left + 36.0 + atlas.font.width(&pre),
+                                top + 29.0 + i as f32 * 9.0,
+                                atlas.font.width(&sel),
+                                9.0,
+                            ),
+                            true,
+                        );
+                    }
+                }
+                if page_edit.cursor_visible() {
+                    let (x, row) = self.caret_on(text, &rows, page_edit.cursor);
                     batch.fill(
                         atlas,
                         left + 36.0 + x,
-                        top + 29.0 + row * 9.0,
+                        top + 29.0 + row as f32 * 9.0,
                         1.0,
                         9.0,
                         BLACK,

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/campfire.rs

@@ -0,0 +1,190 @@
+//! Campfires' cooking: `CampfireBlock.useItemOn` (`CampfireBlockEntity.placeFood`)
+//! and the block entity's `cookTick` (lit) and `cooldownTick` (unlit). The
+//! items drawn on the fire are `campfire_geometry`'s; a server's clients get
+//! them through the block entity's update tag (`lan::chunks::entity_tag`).
+use super::Game;
+use horizon_assets::item_model::DisplayContext;
+use horizon_client::{
+    Result, block_entities::Pos, block_entity_render::vertex_light, containers::BlockEntity,
+    items::ItemStack, mesher::Vertex, mobs::Who,
+};
+use horizon_core::position::BlockPos;
+
+/// The `campfire_cooking` recipe kind (`RecipeType.CAMPFIRE_COOKING`).
+const KIND: &str = "minecraft:campfire_cooking";
+
+fn is_campfire(name: &str) -> bool {
+    name == "minecraft:campfire" || name == "minecraft:soul_campfire"
+}
+
+impl Game<'_> {
+    /// `CampfireBlock.useItemOn` with a held item that is a campfire recipe's
+    /// input (`RecipePropertySet.CAMPFIRE_INPUT`): on a server level the food
+    /// goes into the first free slot (`placeFood`), and the use is consumed
+    /// whether or not there was room. A client of a server leaves the placing
+    /// to the server. Whether the food went in; None when this isn't a
+    /// campfire use, so the item's own use runs.
+    pub(super) fn use_on_campfire(&mut self, pos: [i32; 3]) -> Result<Option<bool>> {
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if !is_campfire(&self.res.facts().get(state).name) {
+            return Ok(None);
+        }
+        let Some(held) = self.held().cloned() else {
+            return Ok(None);
+        };
+        let Some(time) = self.res.recipes().cook(KIND, &held).map(|r| r.time as i32) else {
+            return Ok(None);
+        };
+        // A client of a server predicts the placing; the server decides.
+        if self.remote.is_some() {
+            return Ok(Some(true));
+        }
+        let key = (pos[0], pos[1], pos[2]);
+        let placed = match self.world.block_entities.get_mut(&key) {
+            Some(BlockEntity::Campfire(c)) => {
+                let mut one = held.clone();
+                c.place_food(&mut one, time)
+            }
+            _ => false,
+        };
+        if placed {
+            // ItemStack.consumeAndReturn: creative keeps the item.
+            self.consume_held();
+            self.stats.custom("interact_with_campfire", 1);
+            self.post_block_game_event(
+                "minecraft:block_change",
+                pos,
+                Some(Who::Player),
+                Some(state),
+            );
+            self.mark_block_entity_updated(key);
+        }
+        Ok(Some(placed))
+    }
+
+    /// `CampfireBlockEntity.cookTick` of a lit campfire, `cooldownTick` of an
+    /// unlit one. A finished item's result (the recipe's, or the item itself
+    /// when no recipe takes it any more) drops at the block's corner
+    /// (`Containers.dropItemStack` at its integer position), then the clients
+    /// see the slot empty and a `block_change` goes out.
+    pub(super) fn tick_campfire(&mut self, pos: Pos) -> Result<()> {
+        let state = self.world.block(pos.0, pos.1, pos.2);
+        let lit = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("lit"))
+            .is_some_and(|v| v == "true");
+        let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else {
+            return Ok(());
+        };
+        // BlockEntity.setChanged: a timer that moved is saved with the
+        // chunk (no update to the clients, who don't see the timers).
+        let changed = if lit {
+            c.items.iter().any(Option::is_some)
+        } else {
+            c.cooldown_tick()
+        };
+        if changed {
+            self.world.modified.insert((pos.0 >> 4, pos.2 >> 4));
+        }
+        if !lit {
+            return Ok(());
+        }
+        let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else {
+            return Ok(());
+        };
+        let done = c.cook_tick();
+        for (_, item) in done {
+            let result = self
+                .res
+                .recipes()
+                .cook(KIND, &item)
+                .map_or_else(|| item.clone(), |r| r.result.clone());
+            self.campfire_drop(pos, result);
+            self.mark_block_entity_updated(pos);
+            self.post_block_game_event(
+                "minecraft:block_change",
+                [pos.0, pos.1, pos.2],
+                None,
+                Some(state),
+            );
+        }
+        Ok(())
+    }
+
+    /// `CampfireRenderer`: each cooking item lies on the fire, slot `i`
+    /// turned to `Direction.from2DDataValue((i + facing) % 4)`, laid flat
+    /// (90° about X), at a corner and three eighths of its size, drawn as a
+    /// FIXED item seeded by the block's position plus the slot.
+    pub(super) fn campfire_geometry(&self, camera: glam::DVec3, out: &mut Vec<Vertex>) {
+        for (key, entity) in &self.world.block_entities {
+            let BlockEntity::Campfire(c) = entity else {
+                continue;
+            };
+            if c.items.iter().all(Option::is_none) {
+                continue;
+            }
+            let at = glam::DVec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2));
+            if at.distance_squared(camera) >= 64.0 * 64.0 {
+                continue;
+            }
+            // Direction.get2DDataValue: south 0, west 1, north 2, east 3.
+            let state = self.world.block(key.0, key.1, key.2);
+            let facing = match self
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get("facing"))
+                .map(String::as_str)
+            {
+                Some("west") => 1,
+                Some("north") => 2,
+                Some("east") => 3,
+                _ => 0,
+            };
+            let light = vertex_light(self.world.light(key.0, key.1, key.2));
+            let packed = BlockPos::new(key.0, key.1, key.2).pack();
+            for (i, stack) in c.items.iter().enumerate() {
+                let Some(stack) = stack else {
+                    continue;
+                };
+                let seed = (packed as i32).wrapping_add(i as i32);
+                let item = self.resolve_item(stack, DisplayContext::Fixed, None, seed);
+                if item.is_empty() {
+                    continue;
+                }
+                // Direction.toYRot: 90° per 2D step from south.
+                let yaw = -(((i + facing) % 4) as f32 * 90.0);
+                let pose = glam::Mat4::from_translation(
+                    (at - camera).as_vec3() + glam::Vec3::new(0.5, 0.449_218_75, 0.5),
+                ) * glam::Mat4::from_rotation_y(yaw.to_radians())
+                    * glam::Mat4::from_rotation_x(90f32.to_radians())
+                    * glam::Mat4::from_translation(glam::Vec3::new(-0.3125, -0.3125, 0.0))
+                    * glam::Mat4::from_scale(glam::Vec3::splat(0.375));
+                self.submit_item_world(&item, pose, light, out);
+            }
+        }
+    }
+
+    /// `Containers.dropItemStack(level, x, y, z, stack)` at the block's
+    /// integer position.
+    fn campfire_drop(&mut self, pos: Pos, stack: ItemStack) {
+        let at = BlockPos::new(pos.0, pos.1, pos.2);
+        for piece in
+            horizon_world::level::removal::drop_item_stack(&mut self.world.random, at, stack.count)
+        {
+            self.spawn_item(
+                ItemStack {
+                    count: piece.count,
+                    ..stack.clone()
+                },
+                piece.pos,
+                piece.motion,
+                0,
+            );
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+//! `CampfireBlock.useItemOn`: an item in `#minecraft:douses_campfires` (the
+//! shovels) put on a lit campfire puts it out.
+use super::Game;
+use horizon_client::{Result, animate_tick::make_campfire_smoke, items::ItemStack};
+
+impl Game<'_> {
+    /// `CampfireBlock.useItemOn` with `held` in the hand that acts, the block
+    /// at `pos` clicked: true when it doused a lit campfire (SUCCESS).
+    pub(super) fn use_campfire_douse(
+        &mut self,
+        pos: [i32; 3],
+        held: Option<&ItemStack>,
+    ) -> Result<bool> {
+        let Some(tool) = held.filter(|s| {
+            self.res
+                .items()
+                .item_tags
+                .get("minecraft:douses_campfires")
+                .is_some_and(|members| members.contains(&*s.item))
+        }) else {
+            return Ok(false);
+        };
+        let registry = self.pack.assets.registry;
+        let Some(mut state) = registry
+            .state(self.world.block(pos[0], pos[1], pos[2]))
+            .filter(|s| matches!(&*s.name, "minecraft:campfire" | "minecraft:soul_campfire"))
+            .filter(|s| s.properties.get("lit").map(String::as_str) == Some("true"))
+            .cloned()
+        else {
+            return Ok(false);
+        };
+        // Level event 1009 (SOUND_EXTINGUISH_FIRE) goes to every player.
+        self.level_event_at(1009, pos, 0);
+        // CampfireBlock.douse: the acting client's own smoke (twenty puffs),
+        // then the block change game event from the player.
+        if self.lan_acting.is_none() {
+            let signal = state.properties.get("signal_fire").map(String::as_str) == Some("true");
+            for _ in 0..20 {
+                make_campfire_smoke(&mut self.particles, pos, signal, true);
+            }
+        }
+        self.post_block_game_event("minecraft:block_change", pos, self.sculk_actor(), None);
+        state.properties.insert("lit".into(), "false".into());
+        if let Ok(unlit) = registry.resolve(&state) {
+            self.level_set(pos, unlit)?;
+        }
+        let used = tool.clone();
+        self.damage_held(1);
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, &used);
+        Ok(true)
+    }
+}

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

@@ -464,7 +464,28 @@ impl Game<'_> {
             return;
         }
         // The Chat option's Hidden level takes the server's messages too.
-        if !self.ui.chat.shows(ChatSource::Server) {
+        self.local_chat_line(text, Some(SYSTEM_INDICATOR), ChatSource::Server);
+    }
+    /// A player's chat line on the window's own chat: a LAN guest's message
+    /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener`
+    /// checks `canReceivePlayerMessages` for these, so Commands Only and
+    /// Hidden drop them; command feedback (`/list`, `/tp`) is a system
+    /// message and takes the system-message permission instead.
+    pub(super) fn player_message(&mut self, text: Text) {
+        if let Some(capture) = self.chat_capture.as_mut() {
+            capture.push(text);
+            return;
+        }
+        // A server's client receives the line as a packet (PlayerChat or
+        // DisguisedChat) and filters it there.
+        if self.remote.is_none() {
+            self.local_chat_line(text, None, ChatSource::Player);
+        }
+    }
+    /// A line on the window's own chat when the Chat option lets `source`
+    /// through; running mods hear it.
+    fn local_chat_line(&mut self, text: Text, indicator: Option<u32>, source: ChatSource) {
+        if !self.ui.chat.shows(source) {
             return;
         }
         let focused = self.screen == Screen::Chat;
@@ -472,8 +493,8 @@ impl Game<'_> {
         self.ui.chat.add(
             &self.gui.atlas,
             text,
-            Some(SYSTEM_INDICATOR),
-            ChatSource::Server,
+            indicator,
+            source,
             self.ticks,
             focused,
         );
@@ -602,7 +623,10 @@ impl Game<'_> {
             return;
         }
         if let Some(command) = message.strip_prefix('/') {
-            self.run_command(command);
+            // A client mod's command first, then a server mod's, as on a server.
+            if !self.mod_command(command) && !self.local_server_mod_command(command) {
+                self.run_command(command);
+            }
         } else {
             let line = Text::translate(
                 "chat.type.text",
@@ -622,6 +646,7 @@ impl Game<'_> {
                 self.mods_chat(&line);
             }
             self.lan_host_chat(message);
+            self.mod_player_chat(super::server_mods::Who::Local, message);
         }
     }
     pub(super) fn chat_scroll(&mut self, amount: f32) {
@@ -757,6 +782,7 @@ impl Game<'_> {
             max_snow_accumulation_height: r.int("max_snow_accumulation_height"),
             spawn_mobs: r.bool("spawn_mobs"),
             spawn_monsters: r.bool("spawn_monsters"),
+            fire_spread_radius_around_player: r.int("fire_spread_radius_around_player"),
         }
     }
     /// Apply rules mirrored in other state (natural regeneration, difficulty).

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/clipboard.rs

@@ -63,8 +63,8 @@ impl Game<'_> {
             }
         }
     }
-    /// Typing or a backspace in a field of the title screens: in the server
-    /// screens' append-only fields Select All's selection is replaced first.
+    /// Typing or a backspace in a title-screen field. A field that still only
+    /// appends replaces a Select All selection before the edit.
     pub(super) fn title_edit(&mut self, typed: Option<&str>, backspace: bool) {
         let Some(title) = self.title.as_mut() else {
             return;
@@ -86,42 +86,31 @@ impl Game<'_> {
     }
     /// Shortcuts in the creative inventory's search box (an `EditBox` of 50).
     pub(super) fn creative_search_shortcut(&mut self, shortcut: EditShortcut) {
-        if Self::append_shortcut(
-            &mut self.text_selection,
-            &mut self.clipboard,
-            CREATIVE_SEARCH,
-            &mut self.creative_screen.search,
-            shortcut,
-            CREATIVE_SEARCH_CHARS,
-        ) {
+        if self
+            .creative_screen
+            .search
+            .shortcut(shortcut, &mut self.clipboard)
+        {
             self.creative_screen.scroll = 0.0;
         }
     }
     /// A backspace in the creative search box: with Ctrl, the whole word
     /// before the caret (`EditBox.deleteWords(-1)`), otherwise one character.
-    /// A Select All selection is what it deletes, as in `EditBox.keyPressed`.
+    /// A selection is what it deletes, as in `EditBox.keyPressed`.
     pub(super) fn creative_search_backspace(&mut self, ctrl: bool) {
-        let search = &mut self.creative_screen.search;
-        if !self.text_selection.take(CREATIVE_SEARCH, search) {
-            if ctrl {
-                horizon_client::ui::delete_words(search, -1);
-            } else {
-                search.pop();
-            }
-        }
+        self.creative_screen
+            .search
+            .key(KeyCode::Backspace, ctrl, false);
         self.creative_screen.scroll = 0.0;
     }
     /// Typing in the creative search box.
     pub(super) fn creative_search_edit(&mut self, typed: Option<&str>) {
-        let search = &mut self.creative_screen.search;
-        self.text_selection.take(CREATIVE_SEARCH, search);
         if let Some(text) = typed {
-            clipboard::append_limited(search, text, CREATIVE_SEARCH_CHARS);
+            self.creative_screen.search.insert_text(text);
+            self.creative_screen.scroll = 0.0;
         }
-        self.creative_screen.scroll = 0.0;
     }
 }
 
 /// `CreativeModeInventoryScreen`'s search box: `setMaxLength(50)`.
 pub(super) const CREATIVE_SEARCH_CHARS: usize = 50;
-pub(super) const CREATIVE_SEARCH: horizon_client::clipboard::FieldId = ("creative.search", 0);

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.
@@ -31,6 +36,10 @@ pub(super) struct CombatTracker {
     /// The mob exploding now (`ServerExplosion.source`): its team's friendly
     /// fire decides whom the blast may hurt.
     pub(super) explosion_source: Option<u32>,
+    /// Charged creepers whose blast just went off and that have not dropped
+    /// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list,
+    /// but the mobs they killed still ask for their loot.
+    pub(super) charged_exploders: Vec<u32>,
     /// The player's fall distance before this tick's movement (as of the
     /// end of the last one).
     fall_before: f64,
@@ -52,11 +61,24 @@ impl Game<'_> {
     /// Remember who deals the next `damage_type` damage to the player.
     pub(super) fn note_attacker(&mut self, damage_type: &str, mob: u32) {
         if let Some(name) = self.mob_display_name(mob) {
-            self.combat
-                .pending
-                .push((damage_type.to_owned(), (mob, name)));
+            self.note_named_attacker(damage_type, mob, name);
         }
     }
+    /// `note_attacker` for an entity that is not one of `self.mobs` (the
+    /// ender dragon).
+    pub(super) fn note_named_attacker(&mut self, damage_type: &str, id: u32, name: Text) {
+        self.combat
+            .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]) {
@@ -85,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 {
@@ -102,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.
@@ -215,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))
         {
@@ -239,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

@@ -85,16 +85,16 @@ fn format_double(v: f64) -> String {
 
 impl Game<'_> {
     /// Commands.performCommand for a line without its slash.
-    pub(super) fn run_command(&mut self, command: &str) {
+    pub(super) fn run_command(&mut self, command: &str) -> bool {
         if self.mod_command(command) {
-            return;
+            return true;
         }
         let d = vanilla::game_dispatcher();
         let parse = d.parse(command, &self.ui.registries);
         let result = match parse.executable() {
             Err(e) => {
                 self.syntax_failure(&e, command);
-                return;
+                return false;
             }
             Ok((ctx, _)) => {
                 let ctx = ctx.clone();
@@ -103,6 +103,7 @@ impl Game<'_> {
                 self.run_chain(&root, &ctx)
             }
         };
+        let ok = result.is_ok();
         if let Err(e) = result {
             if e.input.is_some() {
                 self.syntax_failure(&e, command);
@@ -114,6 +115,20 @@ impl Game<'_> {
         if self.player.is_some() {
             self.check_inventory_trigger();
         }
+        ok
+    }
+    /// `run_command` with its output suppressed
+    /// (`CommandSourceStack.withSuppressedOutput`): the player's own source,
+    /// rights and checks, no feedback and no failure in the chat.
+    pub(super) fn run_command_quietly(&mut self, command: &str) -> bool {
+        let quiet = execute::Source {
+            silent: true,
+            ..self.player_source()
+        };
+        let outer = self.command_source.replace(quiet);
+        let ok = self.run_command(command);
+        self.command_source = outer;
+        ok
     }
     fn syntax_failure(&mut self, e: &CommandError, command: &str) {
         self.command_failure(e.message.clone());
@@ -526,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)),
             );
@@ -1097,6 +1111,12 @@ impl Game<'_> {
             Target::Player => {
                 // ServerPlayer.teleport: removeVehicle before placing the player.
                 self.stop_riding();
+                // A server's player teleported within their level is placed
+                // there at once: the arrival they were waiting for elsewhere
+                // in it (whose chunks lose their tickets) is abandoned.
+                if let Some(conn) = self.lan_acting {
+                    self.server_trips.retain(|trip| !trip.is(conn));
+                }
                 if let Some(p) = self.player.as_mut() {
                     p.position = v;
                     p.velocity = Vec3::new(0.0, 0.0, 0.0);
@@ -1676,6 +1696,8 @@ impl Game<'_> {
                         value: 0,
                         age: 0,
                         on_ground: false,
+                        count: 1,
+                        ticks: 0,
                     });
                     name = Text::translate("entity.minecraft.experience_orb", &[]);
                 }
@@ -1864,11 +1886,12 @@ impl Game<'_> {
                 }
             }
         }
-        let Some((_, new)) = horizon_client::save::decode_block_entity(&tag) else {
+        let Some((_, mut new)) = horizon_client::save::decode_block_entity(&tag) else {
             return false;
         };
+        let rolled = self.take_loot_table(key, &tag, &mut new);
         let after = horizon_client::save::encode_block_entity(key, &new, &name);
-        if after == before {
+        if after == before && !rolled {
             return false;
         }
         self.world.block_entities.insert(key, new);
@@ -1876,6 +1899,79 @@ impl Game<'_> {
         let _ = self.world.set(pos[0], pos[1], pos[2], state);
         true
     }
+    /// RandomizableContainer.tryLoadLootTable for a tag a command gives a
+    /// container (`setblock`, `data`): an empty container with a `LootTable`
+    /// is rolled now, as a loaded chunk's are (`save::roll_loaded_loot`), and
+    /// the roll is kept with its chunk, so that the container saves, and
+    /// `data get` shows, its table and seed until its items change. A tag
+    /// without one drops what the container had. True when it had a table.
+    pub(super) fn take_loot_table(
+        &mut self,
+        key: (i32, i32, i32),
+        tag: &horizon_world::nbt::Tag,
+        entity: &mut horizon_client::containers::BlockEntity,
+    ) -> bool {
+        use horizon_client::{containers::BlockEntity, save, structure_blocks};
+        let table = save::text(tag.get("LootTable"));
+        let rolled = match (table, entity) {
+            (Some(table), BlockEntity::Chest(slots)) if slots.iter().all(Option::is_none) => {
+                let loot = structure_blocks::loot_data(&self.options.resources);
+                let at = Vec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2));
+                let biome = self.biome_name_at(at).unwrap_or_default();
+                Some(structure_blocks::roll_container(
+                    slots,
+                    loot.as_deref(),
+                    table,
+                    structure_blocks::loot_seed(tag),
+                    key,
+                    &biome,
+                ))
+            }
+            _ => None,
+        };
+        let Some(chunk) = self.world.chunks.get_mut(&(key.0 >> 4, key.2 >> 4)) else {
+            return false;
+        };
+        let held = |c: &horizon_client::chunk::Chunk| {
+            c.saved
+                .as_ref()
+                .is_some_and(|s| s.rolled_loot.iter().any(|r| r.pos == key))
+        };
+        if rolled.is_none() && !held(chunk) {
+            return false;
+        }
+        let chunk = std::sync::Arc::make_mut(chunk);
+        let mut extras = chunk
+            .saved
+            .take()
+            .map(std::sync::Arc::unwrap_or_clone)
+            .unwrap_or_default();
+        extras.rolled_loot.retain(|r| r.pos != key);
+        let taken = rolled.is_some();
+        extras.rolled_loot.extend(rolled);
+        chunk.saved = Some(std::sync::Arc::new(extras));
+        taken
+    }
+    /// The loot table and seed a container still holding its roll saves
+    /// (`RolledLoot::restore`), in place of its items.
+    pub(super) fn restore_loot_table(
+        &self,
+        key: (i32, i32, i32),
+        tag: &mut horizon_world::nbt::Tag,
+    ) {
+        let horizon_world::nbt::Tag::Compound(map) = tag else {
+            return;
+        };
+        let rolled = self
+            .world
+            .chunks
+            .get(&(key.0 >> 4, key.2 >> 4))
+            .and_then(|c| c.saved.as_ref())
+            .and_then(|s| s.rolled_loot.iter().find(|r| r.pos == key));
+        if let Some(r) = rolled {
+            r.restore(map);
+        }
+    }
     fn cmd_fill(&mut self, ctx: &Context) -> R<i32> {
         let a = self.block_pos_arg(ctx, "from")?;
         let b = self.block_pos_arg(ctx, "to")?;
@@ -2572,38 +2668,7 @@ impl Game<'_> {
     /// `PoiTypes`: the point of interest type of a block state.
     fn poi_type(&self, state: horizon_world::registry::BlockStateId) -> Option<&'static str> {
         let s = self.pack.assets.registry.state(state)?;
-        let name = s.name.strip_prefix("minecraft:")?;
-        Some(match name {
-            "blast_furnace" => "minecraft:armorer",
-            "smoker" => "minecraft:butcher",
-            "cartography_table" => "minecraft:cartographer",
-            "brewing_stand" => "minecraft:cleric",
-            "composter" => "minecraft:farmer",
-            "barrel" => "minecraft:fisherman",
-            "fletching_table" => "minecraft:fletcher",
-            "cauldron" | "lava_cauldron" | "water_cauldron" | "powder_snow_cauldron" => {
-                "minecraft:leatherworker"
-            }
-            "lectern" => "minecraft:librarian",
-            "stonecutter" => "minecraft:mason",
-            "loom" => "minecraft:shepherd",
-            "smithing_table" => "minecraft:toolsmith",
-            "grindstone" => "minecraft:weaponsmith",
-            "bell" => "minecraft:meeting",
-            "beehive" => "minecraft:beehive",
-            "bee_nest" => "minecraft:bee_nest",
-            "nether_portal" => "minecraft:nether_portal",
-            "lodestone" => "minecraft:lodestone",
-            "test_instance_block" => "minecraft:test_instance",
-            n if n.ends_with("_bed") => {
-                if s.properties.get("part").map(String::as_str) != Some("head") {
-                    return None;
-                }
-                "minecraft:home"
-            }
-            n if n.ends_with("lightning_rod") => "minecraft:lightning_rod",
-            _ => return None,
-        })
+        horizon_client::save::poi_type(s).map(|(kind, _)| kind)
     }
     /// `LocateCommand.locatePoi`: `PoiManager.findClosestWithType` within
     /// 256 blocks of the source, over the loaded chunks.

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

@@ -286,6 +286,7 @@ impl Game<'_> {
                 if let Tag::Compound(c) = &mut tag {
                     c.remove(&"keepPacked".into());
                 }
+                self.restore_loot_table(key, &mut tag);
                 Ok(tag)
             }
             DataRef::Storage(id) => Ok(self.score.storage.get(id)),
@@ -296,7 +297,8 @@ impl Game<'_> {
             DataRef::Entity(t) => self.apply_entity_nbt(*t, tag),
             DataRef::Block(p) => {
                 let key = (p[0], p[1], p[2]);
-                if let Some((_, new)) = save::decode_block_entity(&tag) {
+                if let Some((_, mut new)) = save::decode_block_entity(&tag) {
+                    self.take_loot_table(key, &tag, &mut new);
                     self.world.block_entities.insert(key, new);
                     let state = self.world.block(p[0], p[1], p[2]);
                     // Redraw what shows the block entity (signs, banners).

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()) => {

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

@@ -49,26 +49,12 @@ impl Game<'_> {
         let mut tracker = Tracker::default();
         for &t in &targets {
             let h = holder(self.target_name(t));
-            // ServerRecipeBook.addRecipes/removeRecipes count recipe book
-            // displays (a transmute recipe has one per material count).
-            let mut n = 0;
-            // ServerPlayer.awardRecipes / resetRecipes: the displays changed.
-            let index = &self.res.stations().recipe_index;
-            n += if give {
-                let (count, unlocked) = self.level.recipe_book.add_recipes(index, &recipes);
-                self.recipe_unlocked(&unlocked);
-                count as i32
-            } else {
-                let removed = self.level.recipe_book.remove_recipes(index, &recipes);
-                let count = removed.len() as i32;
-                // A network player's client drops them from its book.
-                if self.lan_acting.is_some() && !removed.is_empty() {
-                    self.guest_packets.push(C::RecipeBookRemove(
-                        horizon_protocol::packets::recipes::RecipeBookRemove { ids: removed },
-                    ));
-                }
-                count
-            };
+            // ServerPlayer.awardRecipes / resetRecipes on the target's own
+            // ServerRecipeBook: a guest's is swapped in for the call, and the
+            // packets go to its client.
+            let n = self
+                .for_player(t, |g| g.change_recipes(give, &recipes))
+                .unwrap_or(0);
             tracker.track(&h, n);
         }
         let verb = if give { "give" } else { "take" };
@@ -92,6 +78,27 @@ impl Game<'_> {
         Ok(total)
     }
 
+    /// ServerRecipeBook.addRecipes/removeRecipes for the player in place: how
+    /// many recipe book displays changed (a transmute recipe has one per
+    /// material count).
+    fn change_recipes(&mut self, give: bool, recipes: &[String]) -> i32 {
+        let index = &self.res.stations().recipe_index;
+        if give {
+            let (count, unlocked) = self.level.recipe_book.add_recipes(index, recipes);
+            self.recipe_unlocked(&unlocked);
+            return count as i32;
+        }
+        let removed = self.level.recipe_book.remove_recipes(index, recipes);
+        let count = removed.len() as i32;
+        // A network player's client drops them from its book.
+        if self.lan_acting.is_some() && !removed.is_empty() {
+            self.guest_packets.push(C::RecipeBookRemove(
+                horizon_protocol::packets::recipes::RecipeBookRemove { ids: removed },
+            ));
+        }
+        count
+    }
+
     // ---- /damage ----------------------------------------------------------------
 
     fn damage_kind(ty: &str) -> DamageKind {
@@ -108,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,
@@ -133,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,
@@ -294,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 {
@@ -320,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(
@@ -598,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/composter.rs

@@ -5,6 +5,7 @@
 use super::{Game, commands::compute::ComputeContext};
 use horizon_client::{
     items::ItemStack,
+    mobs::villager,
     particles::{ParticleOptions, ParticleType},
 };
 use horizon_core::{position::BlockPos, random::RandomSource};
@@ -86,6 +87,82 @@ impl Game<'_> {
         self.composter_add(pos, &layers);
         (stack.count > 0).then_some(stack)
     }
+    /// `WorkAtComposter.compostItems` for the villager at `mob`: a full
+    /// composter is emptied, then up to 20 wheat or beetroot seeds go in
+    /// (keeping 10 of each kind) until the composter reaches level 7. Level
+    /// event 1500 plays once, at the end.
+    pub(super) fn villager_compost_items(&mut self, mob: usize, pos: [i32; 3]) {
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        let Some(mut before) = self.composter_level(pos) else {
+            return;
+        };
+        if before == 8 {
+            self.with_level(|b, level, ticks| b.composter_extract(level, ticks, at));
+            let _ = self.process_level_events();
+            before = 0;
+        }
+        let mut remaining = 20;
+        let mut amounts: Vec<(std::sync::Arc<str>, i32)> = Vec::new();
+        let slots = villager::ext(&self.mobs[mob]).map_or(0, |e| e.inventory.len());
+        'slots: for slot in (0..slots).rev() {
+            if remaining <= 0 {
+                break;
+            }
+            let stack = villager::ext_mut(&mut self.mobs[mob]).inventory[slot].clone();
+            if !matches!(
+                &*stack.item,
+                "minecraft:wheat_seeds" | "minecraft:beetroot_seeds"
+            ) {
+                continue;
+            }
+            let known = amounts.iter().position(|(item, _)| *item == stack.item);
+            let total = known.map_or(0, |k| amounts[k].1) + stack.count as i32;
+            match known {
+                Some(k) => amounts[k].1 = total,
+                None => amounts.push((stack.item.clone(), total)),
+            }
+            let uses = (total - 10).min(remaining).min(stack.count as i32);
+            if uses <= 0 {
+                continue;
+            }
+            remaining -= uses;
+            for _ in 0..uses {
+                self.villager_insert_item(mob, slot, &stack, pos);
+                if self.composter_level(pos) == Some(7) {
+                    break 'slots;
+                }
+            }
+        }
+        let after = self.composter_level(pos).unwrap_or(before);
+        self.with_level(|b, level, ticks| {
+            b.composter_fill_effects(level, ticks, at, after != before)
+        });
+        let _ = self.process_level_events();
+    }
+    /// `ComposterBlock.insertItem` with a villager's stack: below level 7 a
+    /// compostable item is used up and may add a layer.
+    fn villager_insert_item(&mut self, mob: usize, slot: usize, stack: &ItemStack, pos: [i32; 3]) {
+        if self.composter_level(pos).is_none_or(|level| level >= 7) {
+            return;
+        }
+        let Some(layers) = self.compostable(stack) else {
+            return;
+        };
+        let context = ComputeContext {
+            block: Some(pos),
+            target: None,
+        };
+        let layers = self.provider_int(&layers, &context, 0).unwrap_or(0);
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        self.with_level(|b, level, ticks| b.composter_layer(level, ticks, at, layers));
+        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
+        let _ = self.process_level_events();
+        let inventory = &mut villager::ext_mut(&mut self.mobs[mob]).inventory;
+        inventory[slot].count -= 1;
+        if inventory[slot].count == 0 {
+            inventory.remove(slot);
+        }
+    }
     /// `ComposterBlock.handleFill` (level event 1500) on the client: the
     /// fill sound and ten composter particles above the compost.
     pub(super) fn composter_fill_event(&mut self, pos: BlockPos, success: bool) {

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

@@ -11,6 +11,9 @@ use winit::{event::MouseButton, event_loop::ActiveEventLoop, keyboard::KeyCode};
 
 const HELP: &[&str] = &[
     "status                         game, player, streaming and renderer state",
+    "simulation                     authoritative projectiles in the owner's level",
+    "server-hold on|off             hold simulation and player packets at a control-fixture barrier",
+    "stall MILLISECONDS             stall the window thread (0..5000), leaving transport alive",
     "key KEY down|up|tap|repeat     press, release or auto-repeat a key (w a s d space shift ctrl e q esc f3 1-9 arrows ...)",
     "release                        release every key and mouse button",
     "mouse left|right|middle down|up|click",
@@ -238,6 +241,47 @@ impl Game<'_> {
             }
             "sculk" => Ok(Some(self.sculk_command(&words)?)),
             "status" => Ok(Some(self.control_status())),
+            "stall" => {
+                let millis: u64 = arg(1)?.parse()?;
+                if millis > 5000 {
+                    return Err("stall is limited to 5000 milliseconds".into());
+                }
+                std::thread::sleep(Duration::from_millis(millis));
+                ok()
+            }
+            "simulation" => {
+                self.require_world()?;
+                let value = if let Some(server) = &self.integrated {
+                    server
+                        .call(|g| {
+                            g.in_owner_level(|g| {
+                                json!({ "game_time": g.world.game_time, "projectiles": g.projectiles_status() })
+                            })
+                        })
+                        .ok_or("the integrated server stopped")?
+                } else {
+                    json!({ "game_time": self.world.game_time, "projectiles": self.projectiles_status() })
+                };
+                Ok(Some(value))
+            }
+            "server-hold" => {
+                self.require_world()?;
+                let held = match arg(1)? {
+                    "on" => true,
+                    "off" => false,
+                    _ => return Err("server-hold on|off".into()),
+                };
+                if let Some(server) = &self.integrated {
+                    server
+                        .call(move |g| g.agent.hold_server = held)
+                        .ok_or("the integrated server stopped")?;
+                } else if self.remote.is_some() {
+                    return Err("server-hold requires the world's host".into());
+                } else {
+                    self.agent.hold_server = held;
+                }
+                ok()
+            }
             "pad" => Ok(Some(self.pad_command(&words)?)),
             "key" => {
                 let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?;
@@ -508,10 +552,23 @@ impl Game<'_> {
             "mobs" => {
                 self.require_world()?;
                 let radius: f64 = words.get(1).map_or(Ok(64.0), |r| r.parse())?;
+                if let Some(server) = &self.integrated {
+                    let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position);
+                    let value = server
+                        .call(move |g| g.in_owner_level(|g| g.control_mobs_at(radius, center)))
+                        .ok_or("the integrated server stopped")?;
+                    return Ok(Some(value));
+                }
                 Ok(Some(self.control_mobs(radius)))
             }
             "hurtlog" => {
                 self.require_world()?;
+                if let Some(server) = &self.integrated {
+                    let value = server
+                        .call(|g| g.control_hurt_log())
+                        .ok_or("the integrated server stopped")?;
+                    return Ok(Some(value));
+                }
                 Ok(Some(self.control_hurt_log()))
             }
             "resume" => {
@@ -571,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)
                     }
@@ -612,6 +672,7 @@ impl Game<'_> {
                     "font" => Page::Font,
                     "packs" => Page::Packs,
                     "mods" => Page::Mods,
+                    "shader-packs" => Page::ShaderPacks,
                     "graphics" => Page::Graphics,
                     "graphics-advanced" => Page::GraphicsAdvanced,
                     "extras" => Page::Extras,
@@ -625,6 +686,10 @@ impl Game<'_> {
                 }
                 self.open_options(self.title.is_some());
                 self.ui.options.show(page);
+                if page == Page::ShaderPacks {
+                    self.settings.shader_packs =
+                        horizon_client::shader_pack_list::scan(&Self::shader_packs_dir());
+                }
                 ok()
             }
             "chat-log" => {
@@ -1018,6 +1083,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/crossbow.rs

@@ -6,6 +6,7 @@
 //! finds the ammo for bows and crossbows.
 use super::{Game, shield::OFFHAND_SLOT, view_vector};
 use horizon_client::{
+    enchant::EffectContext,
     items::ItemStack,
     mobs::Who,
     projectiles::{Projectile, ProjectileKind},
@@ -152,6 +153,20 @@ impl Game<'_> {
         };
         let charged = std::mem::take(&mut bow.data_mut().charged);
         bow.tidy();
+        let weapon = bow.clone();
+        // AbstractArrow's constructor: `getPiercingCount` of the weapon.
+        let pierce = self
+            .res
+            .stations()
+            .enchantments
+            .modify_value(
+                Some(&weapon),
+                "minecraft:projectile_piercing",
+                &EffectContext::default(),
+                &mut self.world.random,
+                0.0,
+            )
+            .clamp(0.0, 127.0) as u8;
         let count = charged.len();
         // getShootingPower: a rocket among them slows every shot.
         let power = if charged.iter().any(|s| &*s.item == FIREWORK_ROCKET) {
@@ -204,6 +219,7 @@ impl Game<'_> {
                 if let Some(a) = arrow.arrow.as_mut() {
                     a.set_item(ammo);
                     a.set_owner(Some(Who::Player));
+                    a.pierce = pierce;
                 }
                 arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0);
                 self.creatures.projectiles.push(arrow);

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

@@ -0,0 +1,494 @@
+//! Cushions: `CushionItem.useOn` placement on the top face of a block,
+//! `Cushion.canBePlacedAt`/`survives`, `Cushion.interact` (sit),
+//! `BlockAttachedEntity.hurtServer` (break, dropping the matching colour),
+//! `BlockAttachedEntity.tick` and `CushionRenderer`.
+//!
+//! A cushion is a `BlockAttachedEntity`, not a block: it has no block state,
+//! only an entity whose `Pos` is the click point's height. Placement uses
+//! outline bounds, collision shapes and suffocation predicates.
+use super::{Game, Hit, view_vector};
+use horizon_client::entities::{Cushion, dye_index};
+use horizon_client::items::ItemStack;
+use horizon_client::mobs::anim::Poses;
+use horizon_core::geometry::{Aabb, Vec3};
+use winit::keyboard::KeyCode;
+
+/// `Direction.fromYRot(yaw).toYRot()`: the nearest 90 degree step.
+pub(crate) fn snap_yaw(yaw: f32) -> f32 {
+    (((f64::from(yaw) / 90.0 + 0.5).floor() as i64) & 3) as f32 * 90.0
+}
+
+fn aabb(bounds: ([f64; 3], [f64; 3])) -> Aabb {
+    Aabb::new(
+        Vec3::new(bounds.0[0], bounds.0[1], bounds.0[2]),
+        Vec3::new(bounds.1[0], bounds.1[1], bounds.1[2]),
+    )
+}
+
+fn overlaps(a: Aabb, b: Aabb) -> bool {
+    a.intersects(b)
+}
+use horizon_client::cushion::blocks_in;
+
+struct PlacementWorld<'a, 'r>(&'a Game<'r>);
+impl horizon_client::cushion::World for PlacementWorld<'_, '_> {
+    fn outline_bounds(&self, p: [i32; 3]) -> Option<Aabb> {
+        let boxes = self.0.outline_boxes(p);
+        let mut shape = *boxes.first()?;
+        for b in &boxes[1..] {
+            for k in 0..3 {
+                shape[k] = shape[k].min(b[k]);
+                shape[k + 3] = shape[k + 3].max(b[k + 3]);
+            }
+        }
+        Some(Aabb::new(
+            Vec3::new(shape[0], shape[1], shape[2]),
+            Vec3::new(shape[3], shape[4], shape[5]),
+        ))
+    }
+
+    fn collision_shapes(&self, bounds: Aabb) -> Vec<horizon_core::geometry::VoxelShape> {
+        let binding = self.0.res.collision();
+        let mut world = horizon_client::collisions::SceneCollisions {
+            world: &self.0.world,
+            binding,
+            subject: None,
+        };
+        // Include neighbour blocks whose collision shape can reach outside their cell.
+        blocks_in(bounds.inflate(Vec3::new(1.0, 1.0, 1.0)))
+            .filter_map(|p| {
+                let state = self.0.world.block(p[0], p[1], p[2]);
+                binding
+                    .collision_shape(&mut world, state, p)
+                    .ok()
+                    .map(|s| s.moved(Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]))))
+            })
+            .collect()
+    }
+    fn suffocating(&self, p: [i32; 3]) -> bool {
+        let state = self.0.world.block(p[0], p[1], p[2]);
+        let facts = self.0.res.facts().get(state);
+        let name = facts.name.as_ref();
+        // Blocks' explicit predicates, then the default causes_suffocation/full-shape rule.
+        match name {
+            "minecraft:dirt_path"
+            | "minecraft:farmland"
+            | "minecraft:mud"
+            | "minecraft:soul_sand" => true,
+            "minecraft:piston" | "minecraft:sticky_piston" => self
+                .0
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .is_some_and(|s| s.properties.get("extended").is_some_and(|p| p == "false")),
+            "minecraft:mangrove_roots" | "minecraft:moving_piston" => false,
+            _ if name.ends_with("_leaves")
+                || name.ends_with("glass")
+                || name.ends_with("copper_grate") =>
+            {
+                false
+            }
+            // ShulkerBoxBlock: suffocating while closed; a box seen open
+            // here is rare enough to count as closed.
+            _ if name.ends_with("shulker_box") => true,
+            _ => {
+                facts.full_collision
+                    && self
+                        .0
+                        .res
+                        .items()
+                        .block_in_tag("minecraft:causes_suffocation", name)
+            }
+        }
+    }
+}
+
+impl Game<'_> {
+    /// The cushion under the crosshair, its distance and the hit point.
+    pub(super) fn cushion_hit(&self) -> Option<(usize, f64, [f64; 3])> {
+        let eye = self.eye_position()?;
+        let dir = view_vector(self.yaw, self.pitch);
+        let reach: f64 = if self.creative { 5.0 } else { 3.0 };
+        let mut best: Option<(usize, f64, [f64; 3])> = None;
+        for (i, c) in self.cushions.iter().enumerate() {
+            let Some(d) = super::ray_box(eye, dir, reach, aabb(c.bounds())) else {
+                continue;
+            };
+            if best.is_none_or(|b| d < b.1) {
+                best = Some((i, d, std::array::from_fn(|k| eye[k] + dir[k] * d)));
+            }
+        }
+        best
+    }
+
+    pub(super) fn cushion_survives(&self, c: &Cushion) -> bool {
+        horizon_client::cushion::survives(&PlacementWorld(self), aabb(c.bounds()))
+    }
+
+    /// `Cushion.destroyIfInFire`: a fire-tagged block inside the deflated box.
+    fn cushion_in_fire(&self, c: &Cushion) -> bool {
+        let bounds = aabb(c.bounds()).next_deflated();
+        blocks_in(bounds).any(|p| {
+            let facts = self.res.facts().get(self.world.block(p[0], p[1], p[2]));
+            self.res.items().block_in_tag("minecraft:fire", &facts.name)
+        })
+    }
+
+    /// `CushionItem.useOn`: on the top face only, spawning at the click's
+    /// height above the clicked block (or the replaceable block itself).
+    pub(super) fn place_cushion(&mut self, hit: &Hit, stack: &ItemStack) -> bool {
+        let Some(info) = self.res.items().get(&stack.item).cloned() else {
+            return false;
+        };
+        let Some(default_color) = info.cushion_color.as_deref() else {
+            return false;
+        };
+        let color_override = stack
+            .data()
+            .and_then(|d| d.other("minecraft:cushion/color"))
+            .and_then(|tag| match tag {
+                horizon_world::nbt::Tag::String(s) => Some(s.to_string_lossy()),
+                _ => None,
+            });
+        let color = dye_index(color_override.as_deref().unwrap_or(default_color));
+        // CushionItem.recalculateContextForSpecialCollisionShapes: open containers
+        // (cauldrons, hoppers and composters) use the collision ray's actual height.
+        let mut adjusted = Hit {
+            pos: hit.pos,
+            face: hit.face,
+            point: hit.point,
+        };
+        let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
+        if self.res.items().block_in_tag(
+            "minecraft:cushion_uses_collision_shape",
+            &self.res.facts().get(state).name,
+        ) && let Some(eye) = self.eye_position()
+        {
+            let start = Vec3::new(eye[0], eye[1], eye[2]);
+            let point = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
+            let end = point.add_vector(point.subtract(start).normalize().scale(0.001));
+            let binding = self.res.collision();
+            let mut world = horizon_client::collisions::SceneCollisions {
+                world: &self.world,
+                binding,
+                subject: None,
+            };
+            if let Ok(shape) = binding.collision_shape(&mut world, state, hit.pos)
+                && let Some(result) = shape.clip(
+                    start,
+                    end,
+                    horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
+                )
+            {
+                adjusted.face = result.direction.normal();
+                adjusted.point = [result.location.x, result.location.y, result.location.z];
+            }
+        }
+        let hit = &adjusted;
+        if hit.face != [0, 1, 0] {
+            return false;
+        }
+        // BlockPlaceContext: a replaceable clicked block is replaced.
+        let clicked = self
+            .res
+            .facts()
+            .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]));
+        let pos = if clicked.replaceable {
+            hit.pos
+        } else {
+            std::array::from_fn(|i| hit.pos[i] + hit.face[i])
+        };
+        // `Vec3.atCenterOfWithY(clickedPos, clickLocation.y)`.
+        let y = hit.point[1];
+        let position = Vec3::new(f64::from(pos[0]) + 0.5, y, f64::from(pos[2]) + 0.5);
+        let bounds = aabb((
+            [position.x - 0.5, position.y, position.z - 0.5],
+            [position.x + 0.5, position.y + 0.25, position.z + 0.5],
+        ));
+        if !horizon_client::cushion::can_place(&PlacementWorld(self), bounds) {
+            return false;
+        }
+        // `getEntitiesOfClass(Cushion.class, spawnAABB).isEmpty()`.
+        if self
+            .cushions
+            .iter()
+            .any(|c| overlaps(aabb(c.bounds()), bounds))
+        {
+            return false;
+        }
+        self.next_entity += 1;
+        let id = self.next_entity;
+        // `BlockAttachedEntity.setPos`: `BlockPos.containing(position)`.
+        let attached = [
+            position.x.floor() as i32,
+            position.y.floor() as i32,
+            position.z.floor() as i32,
+        ];
+        self.cushions.push(Cushion {
+            id,
+            position,
+            pos: attached,
+            yaw: snap_yaw(self.yaw),
+            color,
+            check_interval: 0,
+        });
+        self.world
+            .modified
+            .insert((attached[0] >> 4, attached[2] >> 4));
+        // `destroyIfInFire`: placed into fire, it breaks at once.
+        let placed = self.cushions.len() - 1;
+        if self.cushion_in_fire(&self.cushions[placed]) {
+            self.break_cushion(placed, false);
+        }
+        self.audio.play(
+            "minecraft:entity.cushion.place",
+            Some([position.x, position.y, position.z]),
+            0.75,
+            0.8,
+        );
+        let ctx = self.who_context(Some(horizon_client::mobs::Who::Player), None);
+        self.post_game_event(
+            "minecraft:entity_place",
+            [position.x, position.y, position.z],
+            ctx,
+        );
+        if !self.creative {
+            self.consume_held();
+        }
+        true
+    }
+
+    /// `Cushion.interact`: sit down unless sneaking or already occupied.
+    pub(super) fn interact_cushion(&mut self) -> bool {
+        let Some((i, d, _)) = self.cushion_hit() else {
+            return false;
+        };
+        if !self.before_block(d) {
+            return false;
+        }
+        // isSecondaryUseActive.
+        if self.keys.contains(&KeyCode::ShiftLeft) {
+            return false;
+        }
+        let id = self.cushions[i].id;
+        let occupied = self.riding == Some(id)
+            || self
+                .lan
+                .as_ref()
+                .is_some_and(|h| h.hub.guests.iter().any(|g| g.vehicle == Some(id)));
+        // `Cushion.interact`: an occupied cushion (`isVehicle`) passes.
+        if occupied {
+            return false;
+        }
+        // `Player.startRiding` gives up the vehicle it already has; the
+        // client never sends that click, so pass instead.
+        if self.riding.is_some() {
+            return false;
+        }
+        self.riding = Some(id);
+        let p = self.cushions[i].position;
+        self.audio.play(
+            "minecraft:entity.cushion.sit",
+            Some([p.x, p.y, p.z]),
+            1.0,
+            1.0,
+        );
+        self.swing_arm();
+        true
+    }
+
+    /// `Cushion.hurtServer` from a player: killed, then the item dropped.
+    pub(super) fn attack_cushion(&mut self) -> bool {
+        let Some((i, d, _)) = self.cushion_hit() else {
+            return false;
+        };
+        if !self.before_block(d) || self.mob_hit().is_some_and(|m| m.1 < d) {
+            return false;
+        }
+        // `skipAttackInteraction` when `mayInteract` is false.
+        if !self.may_build() {
+            return true;
+        }
+        self.break_cushion(i, true);
+        true
+    }
+
+    /// `Cushion.dropItem`: the break sound and particles, then the coloured
+    /// item unless drops are off or the breaker has infinite materials.
+    pub(super) fn break_cushion(&mut self, index: usize, by_player: bool) {
+        let c = self.cushions.remove(index);
+        let p = c.position;
+        self.world.modified.insert((c.pos[0] >> 4, c.pos[2] >> 4));
+        if self.riding == Some(c.id) {
+            self.riding = None;
+        }
+        self.audio.play(
+            "minecraft:entity.cushion.break",
+            Some([p.x, p.y, p.z]),
+            1.0,
+            1.0,
+        );
+        self.cushion_break_particles(&c);
+        if !self.ui.rules.bool("entity_drops") || (by_player && self.creative) {
+            return;
+        }
+        let stack = ItemStack {
+            item: std::sync::Arc::from(c.item()),
+            count: 1,
+            damage: 0,
+            extra: None,
+        };
+        self.spawn_item(stack, [p.x, p.y, p.z], [0.0; 3], 10);
+    }
+
+    /// `Cushion.showBreakingParticles`: ten of the matching wool block.
+    fn cushion_break_particles(&mut self, c: &Cushion) {
+        let name = format!("minecraft:{}_wool", c.color_name());
+        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 Some((sprite, tint)) = self.particle_sprite(state, at) else {
+            return;
+        };
+        let options = horizon_client::particles::ParticleOptions::block(
+            horizon_client::particles::ParticleType::Block,
+            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,
+        );
+    }
+
+    /// `BlockAttachedEntity.tick`: survive and burn checks after the post-increment reaches 100.
+    pub(super) fn tick_cushions(&mut self) {
+        let ticking = self.entity_ticking_area();
+        let mut i = 0;
+        while i < self.cushions.len() {
+            let p = self.cushions[i].position;
+            if !ticking(p.x.floor() as i32, p.z.floor() as i32) {
+                i += 1;
+                continue;
+            }
+            let previous = self.cushions[i].check_interval;
+            self.cushions[i].check_interval += 1;
+            if previous < 100 {
+                i += 1;
+                continue;
+            }
+            self.cushions[i].check_interval = 0;
+            let c = self.cushions[i].clone();
+            if self.cushion_in_fire(&c) || !self.cushion_survives(&c) {
+                self.break_cushion(i, false);
+                continue;
+            }
+            i += 1;
+        }
+    }
+
+    /// `Player.rideTick` on a cushion: hold the seat, and get up on sneak.
+    pub(super) fn tick_cushion_riding(&mut self, keys: super::Keys) -> bool {
+        let Some(c) = self
+            .cushions
+            .iter()
+            .find(|c| Some(c.id) == self.riding)
+            .cloned()
+        else {
+            return false;
+        };
+        if keys.shift {
+            let at = c.dismount();
+            self.riding = None;
+            if let Some(p) = self.player.as_mut() {
+                self.previous_position = p.position;
+                p.position = at;
+                p.velocity = Vec3::ZERO;
+                p.fall_distance = 0.0;
+            }
+            // `Cushion.removePassenger`: the get-up sound for a rider that
+            // left rather than one whose cushion was killed.
+            self.audio.play(
+                "minecraft:entity.cushion.get_up",
+                Some([c.position.x, c.position.y, c.position.z]),
+                1.0,
+                1.0,
+            );
+            return true;
+        }
+        let seat = c.seat();
+        if let Some(p) = self.player.as_mut() {
+            self.previous_position = p.position;
+            p.position = seat;
+            p.velocity = Vec3::ZERO;
+            p.fall_distance = 0.0;
+        }
+        true
+    }
+
+    /// `CushionRenderer`: the coloured model, rotated to the nearest
+    /// direction, with its bottom on the cushion's position.
+    pub(super) fn cushion_geometry(
+        &self,
+        camera: glam::DVec3,
+        out: &mut Vec<horizon_client::mesher::Vertex>,
+    ) {
+        let Some(model) = self.cushion_model.as_ref() else {
+            return;
+        };
+        let sprites = &self.gui.atlas.sprites;
+        for c in &self.cushions {
+            let entity_start = out.len();
+            let a = aabb(c.bounds());
+            let (lo, hi) = (a.min_position(), a.max_position());
+            let (lo, hi) = (
+                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);
+            if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
+                continue;
+            }
+            let Some(uv) = sprites
+                .get(&format!("entity/cushion/{}_cushion", c.color_name()))
+                .map(|r| [r.u0, r.v0, r.u1, r.v1])
+            else {
+                continue;
+            };
+            let p = glam::DVec3::new(c.position.x, c.position.y, c.position.z) - camera;
+            let base = glam::Mat4::from_translation(p.as_vec3())
+                * glam::Mat4::from_rotation_y((180.0 - snap_yaw(c.yaw)).to_radians())
+                * glam::Mat4::from_rotation_x(std::f32::consts::PI)
+                * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.25, 0.0));
+            // `EntityRenderer.getPackedLightCoords` probes at the eye height.
+            let l = self.world.light(
+                c.position.x.floor() as i32,
+                (c.position.y + 0.2125).floor() as i32,
+                c.position.z.floor() as i32,
+            );
+            let packed = (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8);
+            horizon_client::mobs::render::draw(
+                model,
+                base,
+                &Poses::new(model),
+                uv,
+                0xFFFF_FFFF,
+                packed,
+                0,
+                out,
+            );
+            self.cull_entity_vertices(out, entity_start);
+        }
+    }
+}