diff --git a/.github/nightly-reviewers.txt b/.github/nightly-reviewers.txt new file mode 100644 index 000000000..a2f9606aa --- /dev/null +++ b/.github/nightly-reviewers.txt @@ -0,0 +1,7 @@ +# Trusted reviewers: they pick the pull requests the Nightly holds with `/nightly 2640 2642` in any issue or pull +# request (docs/release-flow.md "Nightly channel", tools/ci/nightly_set.py). Ludovic is always allowed and isn't +# listed. One GitHub login per line, with who added it and when. Removing a line revokes that login at once. +# A line with only `paused` stops every reviewer's `/nightly` (Ludovic's still work). +kacpherek # added by Ludovic, 2026-10-27 +rdbtCVS # added by Ludovic, 2026-10-27 +Online5277 # added by Ludovic, 2026-10-27 (his top three by merged pull requests) diff --git a/.github/workflows/game-build.yml b/.github/workflows/game-build.yml new file mode 100644 index 000000000..7e075ea63 --- /dev/null +++ b/.github/workflows/game-build.yml @@ -0,0 +1,291 @@ +name: game build +# Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server and Windows on +# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json). Called by +# release.yml (the releases) and nightly-build.yml (the opt-in Nightly), always from main's copy of this file: the +# caller's commit, never the one being built. It holds no secrets: signing the checksums is the callers' own job, +# which never runs what this one built. See docs/release-flow.md. +on: + workflow_call: + inputs: + ref: + description: The commit to build + type: string + required: true + version: + description: The version built in (HORIZON_VERSION), e.g. 0.2.81 or nightly-2026-10-28 + type: string + required: true + nightly: + description: A nightly's " " (HORIZON_NIGHTLY), shown by the game; empty for a release + type: string + default: '' + trusted: + # Only release.yml says true: it builds main. A nightly can hold pull requests nobody reviewed yet, whose + # build scripts and tests run here and could rewrite target/, the cargo home or a compiler cache. So an + # untrusted build never runs on the release runner, never saves the Rust cache (its key is its own anyway), + # and a trusted one never reads the machine's shared sccache, which pull requests' jobs write + # (tests/test_nightly.py pins all of it). + description: The source is main (a release); false for anything else (a nightly) + type: boolean + default: false + developer_id: + description: Sign the macOS programs with Developer ID and notarize the zip (the runner's keychain) + type: boolean + default: true +permissions: + contents: read +jobs: + exporters: + # This runner holds the maintainer's own pinned Minecraft jars. Only our classes leave it. An untrusted build + # goes to the Mac mini runner that already runs pull requests' parity jobs (macOS + horizon-game: + # ludovics-mac-mini), never the release runner (MAC_RUNNER: ludovics-mac-mini-release) nor parity-main's. + runs-on: ${{ inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-game"]') }} + # Three full preparations (two isolated, one batched) besides the compile. + timeout-minutes: 60 + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ inputs.ref }} + persist-credentials: false + clean: true + - uses: dtolnay/rust-toolchain@stable + - run: bash tools/ci/runner-env.sh + env: + HORIZON_NO_SCCACHE: ${{ inputs.trusted && '1' || '' }} + - run: bash tools/ci/vanilla-data.sh + - name: Compile and validate original exporters against the pinned jars + shell: bash + run: | + set -euo pipefail + # target/ is gone after the clean checkout, and vanilla-data.sh builds the preparer only when it + # prepares afresh. + cargo build --release --locked -p horizon-prepare + # Compiled here, never taken from the runner's shared preparations: pull requests' parity jobs + # write those (vanilla-data.sh links .local/exporters to them). + rm -rf .local/exporters + bundle=$(target/release/horizon-prepare compile-exporters --root "$PWD" | tail -1) + mkdir -p exporters + cp -R "$bundle/server" "$bundle/client" "$bundle/manifest.json" exporters/ + # Only our classes and their manifest leave this runner. + stray=$(find exporters -type f ! -path exporters/manifest.json \ + ! \( -name '*.class' \( -path 'exporters/server/dev/horizonlab/parity/*' -o -path 'exporters/client/dev/horizonlab/parity/*' \) \)) + [ -z "$stray" ] || { echo "::error::not one of our classes: $stray"; exit 1; } + python3 tools/check_prepare_exporters.py --binary target/release/horizon-prepare + - uses: actions/upload-artifact@v4 + with: + name: original-exporters + path: exporters/ + if-no-files-found: error + retention-days: 3 + + build: + needs: exporters + name: build ${{ matrix.name }} + strategy: + fail-fast: false + matrix: + include: + - name: linux + os: ubuntu-22.04 + dir: horizon-linux-x86_64 + asset: horizon-linux-x86_64.tar.gz + # The server build too: packaging/server/install.sh installs it on Linux. + server_dir: horizon-server-linux-x86_64 + server_asset: horizon-server-linux-x86_64.tar.gz + - name: windows + os: windows-latest + dir: horizon-windows-x64 + asset: horizon-windows-x64.zip + exe: .exe + # The C runtime linked in, so the game runs without the Visual C++ redistributable. + rustflags: -C target-feature=+crt-static + - name: macos + mac: true + dir: horizon-macos-arm64 + asset: horizon-macos-arm64.zip + runs-on: ${{ matrix.mac && (inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-game"]')) || matrix.os }} + # Notarizing the zip can take a few minutes. + timeout-minutes: ${{ matrix.mac && 60 || 40 }} + env: + RUSTFLAGS: ${{ matrix.rustflags }} + # The release's version, built in (horizon_core::release): --version, user agents, crash reports and + # telemetry say it. No version-bump commits. + HORIZON_VERSION: ${{ inputs.version }} + # A nightly's date and commit ("2026-10-28 0c02067"), which the game shows; empty for a release. + HORIZON_NIGHTLY: ${{ inputs.nightly }} + defaults: + run: + shell: bash + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ inputs.ref }} + persist-credentials: false + # Always from a clean checkout, the Mac mini's runner too: its work folder is shared with pull requests' + # parity jobs, and nothing they leave (target/, an untracked .cargo/config.toml, a build script's output) + # may end up in a release. target/ is rebuilt from scratch; .local/ is relinked by vanilla-data.sh, which + # keeps its preparations outside the checkout. + clean: true + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + if: runner.environment == 'github-hosted' + with: + # A release restores only what a release saved: an untrusted build has its own key and saves nothing. + shared-key: ${{ inputs.trusted && 'release' || 'nightly' }}-${{ matrix.name }} + save-if: ${{ inputs.trusted }} + - name: ALSA and udev headers + if: runner.os == 'Linux' + run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev + - name: Build the client, horizon-ctl, horizon-prepare and horizon-server + # `horizon-client/mods`: every released game runs code mods (the feature is off in dev builds). + run: cargo build --release --locked --features horizon-client/mods -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server + - name: Every program the release folder takes was built + run: | + for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do + test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; } + done + - name: The signing keychain, unlocked + if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id + env: + MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }} + run: packaging/macos/keychain.sh unlock + - name: Signed with Developer ID and the hardened runtime + # Before the checks below, so they run the programs as players will. + if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id + env: + MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }} + run: | + for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do + codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \ + --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary" + codesign --verify --strict --verbose=2 "target/release/$binary" + done + - name: Only system libraries + # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard + # loader and libraries every desktop distribution has. macOS: only the system's own libraries. + run: | + for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do + file="target/release/$binary${{ matrix.exe }}" + if [[ "$RUNNER_OS" == macOS ]]; then + others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true) + [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; } + else + ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_imports.py "$file" + fi + done + - name: Every program starts + run: | + set -euo pipefail + bin=target/release + "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources' + "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null + "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir' + # The version is the release's. + for binary in horizon-prepare horizon-server; do + out=$("$bin/$binary${{ matrix.exe }}" --version | tr -d '\r') + echo "$out" + [[ "$out" == "$binary $HORIZON_VERSION" ]] || { echo "::error::expected $binary $HORIZON_VERSION"; exit 1; } + done + - name: Tools from the runner + if: runner.environment == 'self-hosted' + env: + HORIZON_NO_SCCACHE: ${{ inputs.trusted && '1' || '' }} + run: bash tools/ci/runner-env.sh + - name: Resources prepared from the runner's own Minecraft + if: runner.environment == 'self-hosted' + run: bash tools/ci/vanilla-data.sh + - name: The game runs (offscreen, a new world, 1500 frames) + if: runner.environment == 'self-hosted' + run: | + set -euo pipefail + # From a scratch folder: the game keeps its saves and options in the folder it starts in. + home="$RUNNER_TEMP/horizon-smoke" + rm -rf "$home" && mkdir -p "$home" + version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1) + client="$PWD/target/release/horizon-client" + resources="$PWD/.local/horizon-client/$version" + (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \ + --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \ + --smoke-report "$home/smoke.json" > "$home/client.log" 2>&1) || { tail -40 "$home/client.log"; exit 1; } + python3 - "$home/smoke.json" <<'EOF' + import json, sys + report = json.load(open(sys.argv[1])) + print(json.dumps(report)) + if report.get("error") is not None or report.get("frames", 0) < 1500 or not report.get("chunks") \ + or not report.get("meshed_sections") or not report.get("player"): + sys.exit("the smoke run did not draw a world") + EOF + # Published with the release; the publish job checks it again before it publishes anything. + cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json" + - uses: actions/upload-artifact@v4 + if: runner.environment == 'self-hosted' + with: + name: smoke-test.json + path: ${{ runner.temp }}/smoke-test.json + if-no-files-found: error + retention-days: 3 + - uses: actions/download-artifact@v4 + with: + name: original-exporters + path: exporters + - name: Package + run: | + set -euo pipefail + cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}" + cd dist + rm -f "${{ matrix.asset }}" + case "${{ matrix.asset }}" in + *.tar.gz) tar czf "${{ matrix.asset }}" "${{ matrix.dir }}" ;; + *) if [[ "$RUNNER_OS" == Windows ]]; then 7z a -tzip "${{ matrix.asset }}" "${{ matrix.dir }}" > /dev/null + else + # Without resource forks and extended attributes: plain ditto adds an + # AppleDouble `._` file beside every file that has any. + ditto -c -k --norsrc --noextattr --noqtn --keepParent "${{ matrix.dir }}" "${{ matrix.asset }}" + if unzip -Z1 "${{ matrix.asset }}" | grep -E '(^|/)(\._|__MACOSX/)'; then + echo "::error::macOS metadata files in ${{ matrix.asset }}"; exit 1 + fi + fi ;; + esac + ls -l "${{ matrix.asset }}" + - name: Notarized + # A zip of programs can't be stapled: Gatekeeper asks Apple the first time each one runs. + if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id + run: | + for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do + codesign --verify --strict "dist/${{ matrix.dir }}/$binary" + done + packaging/macos/notarize.sh "dist/${{ matrix.asset }}" + - uses: actions/upload-artifact@v4 + with: + name: ${{ matrix.asset }} + path: dist/${{ matrix.asset }} + if-no-files-found: error + retention-days: 3 + - name: The server build (the game without sound or controllers, as horizon-engine) + if: matrix.server_asset + run: | + set -euo pipefail + # After the client is packaged: target/release/horizon-client is rebuilt without the audio and + # controllers features, so it needs neither libasound nor libudev (minimal server images lack them), + # and with code mods like the client. + cargo build --release --locked -p horizon-client --no-default-features --features mods --bin horizon-client + cargo run --locked -p xtask -- package-server target/release/horizon-client "dist/${{ matrix.server_dir }}" + folder="dist/${{ matrix.server_dir }}" + python3 tools/check_imports.py --server "$folder/horizon-engine" "$folder/horizon-server" "$folder/horizon-prepare" + "$folder/horizon-engine" --help | grep -q -- '--resources' + [[ "$("$folder/horizon-server" --version)" == "horizon-server $HORIZON_VERSION" ]] + cd dist + rm -f "${{ matrix.server_asset }}" + tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}" + ls -l "${{ matrix.server_asset }}" + - uses: actions/upload-artifact@v4 + if: matrix.server_asset + with: + name: ${{ matrix.server_asset }} + path: dist/${{ matrix.server_asset }} + if-no-files-found: error + retention-days: 3 + - name: The signing keychain, locked again + if: always() && runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id + run: packaging/macos/keychain.sh lock + diff --git a/.github/workflows/nightly-build.yml b/.github/workflows/nightly-build.yml new file mode 100644 index 000000000..24b6974a5 --- /dev/null +++ b/.github/workflows/nightly-build.yml @@ -0,0 +1,229 @@ +name: nightly build +run-name: nightly build${{ inputs.request && format(' (request {0})', inputs.request) || '' }} +# The opt-in Nightly channel (docs/release-flow.md "Nightly"; Ludovic, 2026-10-27). Once a night, and when a trusted +# reviewer asks (`/nightly 2640 2642`, nightly-command.yml), it builds main plus the pull requests the reviewers +# picked, merged in order (tools/ci/nightly_set.py). With none picked, it builds the newest union branch on origin +# (union/-: main plus pull requests the contribution gate proved together), or main when no union is +# newer. It publishes the result as the `nightly` pre-release. Launchers install it only for players who turn Nightly +# on. The previous nightly stays a week as nightly-. +# +# Why the signing key never meets the pull requests' code: +# - `pick` merges the picked heads onto main with `git merge-tree --write-tree`: git objects only, no working tree, +# so none of their files reaches the disk and no hook, filter or script of theirs runs. It refuses any pull +# request that changes a path CODEOWNERS gives to Ludovic (this folder, tools/ci/, the signing and update code), +# pushes the merge as nightly/build-- and saves the set on the nightly-state branch. +# - This file, game-build.yml and every script below run from main's copy: a schedule runs the default branch, and +# `uses: ./…` takes the caller's commit. The union's own .github/ is never read. +# - `build` (game-build.yml, `trusted: false`) never reaches a release's tools: its macOS jobs run on the runner +# that already runs pull requests' parity jobs, never the release runner; its Rust cache has its own key and is +# never saved; and releases don't read the machine's shared sccache. +# - `build` (game-build.yml) checks out and compiles the merge (or the union) with no secrets: its token reads contents only and +# isn't kept in the checkout; the macOS programs are signed ad hoc (Developer ID needs the runner's keychain, +# which stays locked for nightlies). +# - `sign` is the only job with RELEASE_SIGNING_KEY. It checks out nothing but main's tools/ci/sign_release.sh, which +# runs the runner's sha256sum and OpenSSL over the archives: it hashes them, never runs them. The signed message +# names the channel ("horizon release nightly"), so a nightly's signature can't pass for a release's. +# - `publish` verifies the signature with main's horizon-release-sign, checks the smoke test, and only then moves +# the tag. Like sign, it never executes what build produced. +# gh workflow run "nightly build" # now (skips when the pick is the same commit as last night's) +# gh workflow run "nightly build" -f force=true # build and publish even if unchanged +# gh workflow run "nightly build" -f dry_run=true # build and sign with a throwaway key, publish nothing +on: + schedule: + - cron: '17 20 * * *' # 20:17 UTC: after the day's waves, before the 03:07 Paris parity audit takes the Mac mini + workflow_dispatch: + inputs: + force: + description: Build and publish even if tonight's pick is the commit already published + type: boolean + default: false + dry_run: + description: Build and sign with a throwaway key, publish nothing + type: boolean + default: false + issue: + description: The issue or pull request whose `/nightly` comment asked for this build (answered there) + type: string + default: '' + request: + description: The command's id, in the run's name so it can link the run + type: string + default: '' + prs: + description: A dry run's own set, `2640@ 2642@` (the saved set stays) + type: string + default: '' +permissions: + contents: read +concurrency: + # One build at a time. A newer request replaces one still waiting: it builds the set as it is by then, so no pick + # is lost. + group: nightly-build + cancel-in-progress: false +jobs: + pick: + runs-on: ubuntu-latest + timeout-minutes: 10 + permissions: + contents: write # nightly/build-- and the nightly-state branch (main is protected) + issues: write # says in the thread when the picked pull requests conflict + pull-requests: write + outputs: + build: ${{ steps.pick.outputs.build }} + sha: ${{ steps.pick.outputs.sha }} + short: ${{ steps.pick.outputs.short }} + source: ${{ steps.pick.outputs.source }} + date: ${{ steps.pick.outputs.date }} + version: ${{ steps.pick.outputs.version }} + nightly: ${{ steps.pick.outputs.nightly }} + dry_run: ${{ steps.mode.outputs.dry_run }} + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + persist-credentials: false + - id: mode + # A dry run never publishes; a hand-started run off main is always one. + run: echo "dry_run=${{ github.event_name == 'workflow_dispatch' && (inputs.dry_run || github.ref != 'refs/heads/main') }}" >> "$GITHUB_OUTPUT" + - id: pick + env: + GH_TOKEN: ${{ github.token }} + FORCE: ${{ (inputs.force || steps.mode.outputs.dry_run == 'true') && 'yes' || '' }} + DRY_RUN: ${{ steps.mode.outputs.dry_run }} + NIGHTLY_ISSUE: ${{ inputs.issue }} + NIGHTLY_PRS: ${{ inputs.prs }} + run: | + python3 tools/ci/nightly.py pick ${FORCE:+--force} | tee -a "$GITHUB_STEP_SUMMARY" + { echo; cat nightly-notes.md; } >> "$GITHUB_STEP_SUMMARY" + - uses: actions/upload-artifact@v4 + with: + name: nightly-notes + path: nightly-notes.md + retention-days: 3 + + build: + needs: pick + if: needs.pick.outputs.build == 'true' + uses: ./.github/workflows/game-build.yml + with: + ref: ${{ needs.pick.outputs.sha }} + version: ${{ needs.pick.outputs.version }} + nightly: ${{ needs.pick.outputs.nightly }} + developer_id: false + trusted: false # it can hold unreviewed pull requests: their own cache key, never saved, not the release runner + + sign: + needs: [pick, build] + runs-on: ubuntu-latest + timeout-minutes: 10 + # The key's only job: main's sign_release.sh hashes the archives and signs with the runner's OpenSSL. + environment: ${{ needs.pick.outputs.dry_run != 'true' && 'release' || '' }} + steps: + - uses: actions/checkout@v4 + with: + sparse-checkout: tools/ci/sign_release.sh + sparse-checkout-cone-mode: false + persist-credentials: false + - uses: actions/download-artifact@v4 + with: + path: dist + pattern: horizon-* + merge-multiple: true + - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig) for the nightly channel + env: + RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }} + RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }} + EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }} + run: | + bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \ + dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz + - uses: actions/upload-artifact@v4 + with: + name: signature + path: dist/SHA256SUMS* + if-no-files-found: error + retention-days: 3 + - uses: actions/upload-artifact@v4 + if: needs.pick.outputs.dry_run == 'true' + with: + name: ephemeral.pub + path: dist/ephemeral.pub + retention-days: 3 + + publish: + needs: [pick, build, sign] + runs-on: ubuntu-latest + timeout-minutes: 15 + permissions: + contents: write + steps: + - uses: actions/checkout@v4 + with: + persist-credentials: false + - uses: actions/download-artifact@v4 + with: + path: dist + merge-multiple: true + - name: The signature, checked as launchers check it + env: + EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }} + run: | + key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)") + cargo run --locked --quiet -p horizon-release-sign -- verify --tag nightly --publishing "${key[@]}" dist + - name: The smoke test drew a world + # No release-blocker check: a nightly is how blockers get tested. + run: python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json + - name: Publish as the `nightly` pre-release + if: needs.pick.outputs.dry_run != 'true' + env: + GH_TOKEN: ${{ github.token }} + SHA: ${{ needs.pick.outputs.sha }} + DATE: ${{ needs.pick.outputs.date }} + run: | + set -euo pipefail + python3 tools/ci/nightly.py rotate + signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig) + # A pre-release, never GitHub's latest: launchers on the release channel never see it. + gh release create nightly --prerelease --latest=false --target "$SHA" \ + --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \ + "dist/horizon-linux-x86_64.tar.gz#Nightly game files: Linux (horizon-linux-x86_64.tar.gz)" \ + "dist/horizon-windows-x64.zip#Nightly game files: Windows (horizon-windows-x64.zip)" \ + "dist/horizon-macos-arm64.zip#Nightly game files: macOS (horizon-macos-arm64.zip)" \ + "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \ + dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json + python3 tools/ci/nightly.py prune --days 7 + - name: Dry run, the nightly that would be published + if: needs.pick.outputs.dry_run == 'true' + run: | + echo "Would publish nightly at ${{ needs.pick.outputs.sha }} (${{ needs.pick.outputs.source }})" + ls -l dist + + answer: + # Tells the thread that asked for this build how it ended. A conflict `pick` already explained there. + needs: [pick, build, sign, publish] + if: always() && inputs.issue != '' && needs.pick.result == 'success' + runs-on: ubuntu-latest + timeout-minutes: 5 + permissions: + issues: write + pull-requests: write + steps: + - env: + GH_TOKEN: ${{ github.token }} + ISSUE: ${{ inputs.issue }} + BUILD: ${{ needs.pick.outputs.build }} + PUBLISHED: ${{ needs.publish.result }} + DRY_RUN: ${{ needs.pick.outputs.dry_run }} + NAME: Nightly ${{ needs.pick.outputs.date }} · ${{ needs.pick.outputs.short }} + RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} + run: | + if [[ "$BUILD" != true ]]; then + text="nothing new: the published Nightly is already this build." + elif [[ "$PUBLISHED" == success && "$DRY_RUN" == true ]]; then + text="the dry run built and signed $NAME; nothing was published. $RUN" + elif [[ "$PUBLISHED" == success ]]; then + text="published $NAME: https://github.com/$GITHUB_REPOSITORY/releases/tag/nightly. Launchers with Nightly on install it at their next start." + else + text="the build failed, nothing was published: $RUN" + fi + gh api "repos/$GITHUB_REPOSITORY/issues/$ISSUE/comments" -f body="🤖 Nightly: $text" diff --git a/.github/workflows/nightly-command.yml b/.github/workflows/nightly-command.yml new file mode 100644 index 000000000..340988d93 --- /dev/null +++ b/.github/workflows/nightly-command.yml @@ -0,0 +1,46 @@ +name: nightly command +# `/nightly …` comments: the trusted reviewers in .github/nightly-reviewers.txt (and Ludovic) pick the pull requests +# the Nightly holds (docs/release-flow.md "Nightly channel", tools/ci/nightly_set.py). This job only checks who asked, +# saves the set on the nightly-state branch, starts `nightly build` and answers in the thread. +# +# Why no pull request's code runs here, though the token can write: +# - `issue_comment` always runs this file from main, whoever comments and wherever; a pull request's own copy of it +# is never read. +# - It checks out main and runs main's nightly_set.py. The comment's text and author reach it as env vars, never in +# a shell line. +# - It never checks out, fetches or merges a pull request: it reads their file lists through the API. The merge +# happens in nightly-build.yml's `pick`, with git objects only; their code runs in its `build`, without secrets. +on: + issue_comment: + types: [created] +permissions: + contents: read +jobs: + command: + # Every other comment skips here, before a runner starts. + if: startsWith(github.event.comment.body, '/nightly') && github.event.comment.user.type != 'Bot' + runs-on: ubuntu-latest + timeout-minutes: 5 + permissions: + contents: write # the nightly-state branch (main is protected) + actions: write # starts `nightly build` + issues: write # answers in the thread + pull-requests: write + steps: + - uses: actions/checkout@v4 + with: + ref: main + persist-credentials: false + sparse-checkout: | + .github/CODEOWNERS + .github/nightly-reviewers.txt + tools/ci/nightly_set.py + sparse-checkout-cone-mode: false + - name: Run the command + env: + GH_TOKEN: ${{ github.token }} + BODY: ${{ github.event.comment.body }} + AUTHOR: ${{ github.event.comment.user.login }} + ISSUE: ${{ github.event.issue.number }} + COMMENT_URL: ${{ github.event.comment.html_url }} + run: python3 tools/ci/nightly_set.py command diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d879f0d61..0065a380a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -40,7 +40,10 @@ permissions: # The open release-blocker issues (decide). issues: read concurrency: - group: game-release + # One release at a time. A hand-started dry run publishes nothing, so it can't race a real release: it gets a + # group of its own. In the shared group, a release queued behind it replaced it as the pending run and GitHub + # cancelled it (#2779's dry run, 2026-10-27), which happens all day while releases go out in batches. + group: game-release${{ github.event_name == 'workflow_dispatch' && inputs.dry_run && '-dry-run' || '' }} cancel-in-progress: false jobs: decide: @@ -79,252 +82,15 @@ jobs: # A dry run builds whatever the decision, to test the builds. if [[ "${{ steps.mode.outputs.dry_run }}" == true ]]; then echo "release=true" >> "$GITHUB_OUTPUT"; fi - exporters: + build: needs: decide if: needs.decide.outputs.release == 'true' - # This runner holds the maintainer's own pinned Minecraft jars. Only our classes leave it. - runs-on: ${{ vars.MAC_RUNNER || 'ludovics-mac-mini' }} - # Three full preparations (two isolated, one batched) besides the compile. - timeout-minutes: 60 - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ needs.decide.outputs.head }} - persist-credentials: false - clean: true - - uses: dtolnay/rust-toolchain@stable - - run: bash tools/ci/runner-env.sh - - run: bash tools/ci/vanilla-data.sh - - name: Compile and validate original exporters against the pinned jars - shell: bash - run: | - set -euo pipefail - # target/ is gone after the clean checkout, and vanilla-data.sh builds the preparer only when it - # prepares afresh. - cargo build --release --locked -p horizon-prepare - # Compiled here, never taken from the runner's shared preparations: pull requests' parity jobs - # write those (vanilla-data.sh links .local/exporters to them). - rm -rf .local/exporters - bundle=$(target/release/horizon-prepare compile-exporters --root "$PWD" | tail -1) - mkdir -p exporters - cp -R "$bundle/server" "$bundle/client" "$bundle/manifest.json" exporters/ - # Only our classes and their manifest leave this runner. - stray=$(find exporters -type f ! -path exporters/manifest.json \ - ! \( -name '*.class' \( -path 'exporters/server/dev/horizonlab/parity/*' -o -path 'exporters/client/dev/horizonlab/parity/*' \) \)) - [ -z "$stray" ] || { echo "::error::not one of our classes: $stray"; exit 1; } - python3 tools/check_prepare_exporters.py --binary target/release/horizon-prepare - - uses: actions/upload-artifact@v4 - with: - name: original-exporters - path: exporters/ - if-no-files-found: error - retention-days: 3 - - build: - needs: [decide, exporters] - if: needs.decide.outputs.release == 'true' - name: build ${{ matrix.name }} - strategy: - fail-fast: false - matrix: - include: - - name: linux - os: ubuntu-22.04 - dir: horizon-linux-x86_64 - asset: horizon-linux-x86_64.tar.gz - # The server build too: packaging/server/install.sh installs it on Linux. - server_dir: horizon-server-linux-x86_64 - server_asset: horizon-server-linux-x86_64.tar.gz - - name: windows - os: windows-latest - dir: horizon-windows-x64 - asset: horizon-windows-x64.zip - exe: .exe - # The C runtime linked in, so the game runs without the Visual C++ redistributable. - rustflags: -C target-feature=+crt-static - - name: macos - mac: true - dir: horizon-macos-arm64 - asset: horizon-macos-arm64.zip - runs-on: ${{ matrix.mac && (vars.MAC_RUNNER || 'ludovics-mac-mini') || matrix.os }} - # Notarizing the zip can take a few minutes. - timeout-minutes: ${{ matrix.mac && 60 || 40 }} - env: - RUSTFLAGS: ${{ matrix.rustflags }} - # The release's version, built in (horizon_core::release): --version, user agents, crash reports and - # telemetry say it. No version-bump commits. - HORIZON_VERSION: ${{ needs.decide.outputs.version }} - defaults: - run: - shell: bash - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ needs.decide.outputs.head }} - persist-credentials: false - # Always from a clean checkout, the Mac mini's runner too: its work folder is shared with pull requests' - # parity jobs, and nothing they leave (target/, an untracked .cargo/config.toml, a build script's output) - # may end up in a release. target/ is rebuilt from scratch; .local/ is relinked by vanilla-data.sh, which - # keeps its preparations outside the checkout. - clean: true - - uses: dtolnay/rust-toolchain@stable - - uses: Swatinem/rust-cache@v2 - if: runner.environment == 'github-hosted' - with: - shared-key: release-${{ matrix.name }} - - name: ALSA and udev headers - if: runner.os == 'Linux' - run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev - - name: Build the client, horizon-ctl, horizon-prepare and horizon-server - # `horizon-client/mods`: every released game runs code mods (the feature is off in dev builds). - run: cargo build --release --locked --features horizon-client/mods -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server - - name: Every program the release folder takes was built - run: | - for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do - test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; } - done - - name: The signing keychain, unlocked - if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' - env: - MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }} - run: packaging/macos/keychain.sh unlock - - name: Signed with Developer ID and the hardened runtime - # Before the checks below, so they run the programs as players will. - if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' - env: - MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }} - run: | - for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do - codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \ - --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary" - codesign --verify --strict --verbose=2 "target/release/$binary" - done - - name: Only system libraries - # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard - # loader and libraries every desktop distribution has. macOS: only the system's own libraries. - run: | - for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do - file="target/release/$binary${{ matrix.exe }}" - if [[ "$RUNNER_OS" == macOS ]]; then - others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true) - [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; } - else - ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_imports.py "$file" - fi - done - - name: Every program starts - run: | - set -euo pipefail - bin=target/release - "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources' - "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null - "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir' - # The version is the release's. - for binary in horizon-prepare horizon-server; do - out=$("$bin/$binary${{ matrix.exe }}" --version | tr -d '\r') - echo "$out" - [[ "$out" == "$binary $HORIZON_VERSION" ]] || { echo "::error::expected $binary $HORIZON_VERSION"; exit 1; } - done - - name: Tools from the runner - if: runner.environment == 'self-hosted' - run: bash tools/ci/runner-env.sh - - name: Resources prepared from the runner's own Minecraft - if: runner.environment == 'self-hosted' - run: bash tools/ci/vanilla-data.sh - - name: The game runs (offscreen, a new world, 1500 frames) - if: runner.environment == 'self-hosted' - run: | - set -euo pipefail - # From a scratch folder: the game keeps its saves and options in the folder it starts in. - home="$RUNNER_TEMP/horizon-smoke" - rm -rf "$home" && mkdir -p "$home" - version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1) - client="$PWD/target/release/horizon-client" - resources="$PWD/.local/horizon-client/$version" - (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \ - --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \ - --smoke-report "$home/smoke.json" > "$home/client.log" 2>&1) || { tail -40 "$home/client.log"; exit 1; } - python3 - "$home/smoke.json" <<'EOF' - import json, sys - report = json.load(open(sys.argv[1])) - print(json.dumps(report)) - if report.get("error") is not None or report.get("frames", 0) < 1500 or not report.get("chunks") \ - or not report.get("meshed_sections") or not report.get("player"): - sys.exit("the smoke run did not draw a world") - EOF - # Published with the release; the publish job checks it again before it publishes anything. - cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json" - - uses: actions/upload-artifact@v4 - if: runner.environment == 'self-hosted' - with: - name: smoke-test.json - path: ${{ runner.temp }}/smoke-test.json - if-no-files-found: error - retention-days: 3 - - uses: actions/download-artifact@v4 - with: - name: original-exporters - path: exporters - - name: Package - run: | - set -euo pipefail - cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}" - cd dist - rm -f "${{ matrix.asset }}" - case "${{ matrix.asset }}" in - *.tar.gz) tar czf "${{ matrix.asset }}" "${{ matrix.dir }}" ;; - *) if [[ "$RUNNER_OS" == Windows ]]; then 7z a -tzip "${{ matrix.asset }}" "${{ matrix.dir }}" > /dev/null - else - # Without resource forks and extended attributes: plain ditto adds an - # AppleDouble `._` file beside every file that has any. - ditto -c -k --norsrc --noextattr --noqtn --keepParent "${{ matrix.dir }}" "${{ matrix.asset }}" - if unzip -Z1 "${{ matrix.asset }}" | grep -E '(^|/)(\._|__MACOSX/)'; then - echo "::error::macOS metadata files in ${{ matrix.asset }}"; exit 1 - fi - fi ;; - esac - ls -l "${{ matrix.asset }}" - - name: Notarized - # A zip of programs can't be stapled: Gatekeeper asks Apple the first time each one runs. - if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' - run: | - for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do - codesign --verify --strict "dist/${{ matrix.dir }}/$binary" - done - packaging/macos/notarize.sh "dist/${{ matrix.asset }}" - - uses: actions/upload-artifact@v4 - with: - name: ${{ matrix.asset }} - path: dist/${{ matrix.asset }} - if-no-files-found: error - retention-days: 3 - - name: The server build (the game without sound or controllers, as horizon-engine) - if: matrix.server_asset - run: | - set -euo pipefail - # After the client is packaged: target/release/horizon-client is rebuilt without the audio and - # controllers features, so it needs neither libasound nor libudev (minimal server images lack them), - # and with code mods like the client. - cargo build --release --locked -p horizon-client --no-default-features --features mods --bin horizon-client - cargo run --locked -p xtask -- package-server target/release/horizon-client "dist/${{ matrix.server_dir }}" - folder="dist/${{ matrix.server_dir }}" - python3 tools/check_imports.py --server "$folder/horizon-engine" "$folder/horizon-server" "$folder/horizon-prepare" - "$folder/horizon-engine" --help | grep -q -- '--resources' - [[ "$("$folder/horizon-server" --version)" == "horizon-server $HORIZON_VERSION" ]] - cd dist - rm -f "${{ matrix.server_asset }}" - tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}" - ls -l "${{ matrix.server_asset }}" - - uses: actions/upload-artifact@v4 - if: matrix.server_asset - with: - name: ${{ matrix.server_asset }} - path: dist/${{ matrix.server_asset }} - if-no-files-found: error - retention-days: 3 - - name: The signing keychain, locked again - if: always() && runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' - run: packaging/macos/keychain.sh lock + # Every platform's archive, and macOS's smoke test (game-build.yml). + uses: ./.github/workflows/game-build.yml + with: + ref: ${{ needs.decide.outputs.head }} + version: ${{ needs.decide.outputs.version }} + trusted: true # main: the release runner, the release cache, no shared sccache sign: needs: [decide, build] diff --git a/crates/horizon-client-core/src/component.rs b/crates/horizon-client-core/src/component.rs index afb68fa98..7437e4ea8 100644 --- a/crates/horizon-client-core/src/component.rs +++ b/crates/horizon-client-core/src/component.rs @@ -190,19 +190,31 @@ fn object_style(o: &serde_json::Map) -> Style { .filter(|p| *p >= 1) .map(crate::text::ClickEvent::ChangePage), Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand), + Some("run_command") => text("command").map(crate::text::ClickEvent::RunCommand), Some("copy_to_clipboard") => { text("value").map(crate::text::ClickEvent::CopyToClipboard) } _ => None, }; } - // HoverEvent.ShowText. - if let Some(e) = o.get("hover_event").and_then(Value::as_object) - && e.get("action").and_then(Value::as_str) == Some("show_text") - && let Some(value) = e.get("value") - { - style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s)))); + // HoverEvent.ShowText and ShowItem. + if let Some(e) = o.get("hover_event").and_then(Value::as_object) { + match e.get("action").and_then(Value::as_str) { + Some("show_text") => { + if let Some(value) = e.get("value") { + style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s)))); + } + } + Some("show_item") if e.get("id").is_some_and(Value::is_string) => { + style.hover_item = Some(Box::new(Value::Object(e.clone()))); + } + _ => {} + } } + style.insertion = o + .get("insertion") + .and_then(Value::as_str) + .map(str::to_owned); style } /// `ComponentSerialization.CODEC` decoding into text. `selector` components diff --git a/crates/horizon-client-core/src/text.rs b/crates/horizon-client-core/src/text.rs index 3a0bf301b..243a3ae3c 100644 --- a/crates/horizon-client-core/src/text.rs +++ b/crates/horizon-client-core/src/text.rs @@ -47,6 +47,8 @@ pub enum ClickEvent { /// `ClickEvent.ChangePage`: a book's page, counted from 1. ChangePage(i32), SuggestCommand(String), + /// `ClickEvent.RunCommand`: the command, with or without its `/`. + RunCommand(String), CopyToClipboard(String), /// A local file to open with the system handler. /// Only allow this in locally constructed messages, never server/LAN text. @@ -65,6 +67,10 @@ pub struct Style { pub click: Option, /// Hover text. pub hover: Option>, + /// `HoverEvent.ShowItem`: the event's `{id, count?, components?}` object. + pub hover_item: Option>, + /// `Style.insertion`: the text a Shift-click puts in the chat box. + pub insertion: Option, /// The font (`FontDescription.Resource`), a full id like /// `minecraft:alt`; the default font when unset. pub font: Option, @@ -94,6 +100,12 @@ impl Style { if self.hover.is_none() { self.hover.clone_from(&base.hover); } + if self.hover_item.is_none() { + self.hover_item.clone_from(&base.hover_item); + } + if self.insertion.is_none() { + self.insertion.clone_from(&base.insertion); + } if self.font.is_none() { self.font.clone_from(&base.font); } @@ -499,7 +511,7 @@ impl Text { } /// The style fields of a component's JSON. -const STYLE_KEYS: [&str; 9] = [ +const STYLE_KEYS: [&str; 10] = [ "color", "bold", "italic", @@ -508,6 +520,7 @@ const STYLE_KEYS: [&str; 9] = [ "obfuscated", "click_event", "hover_event", + "insertion", "font", ]; /// Style.Serializer: the fields a style sets. @@ -541,6 +554,9 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { ClickEvent::CopyToClipboard(value) => { json!({ "action": "copy_to_clipboard", "value": value }) } + ClickEvent::RunCommand(command) => { + json!({ "action": "run_command", "command": command }) + } ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }), }; out.push(("click_event".to_owned(), event)); @@ -550,6 +566,13 @@ fn style_json(style: &Style) -> Vec<(String, Value)> { "hover_event".to_owned(), json!({ "action": "show_text", "value": hover.component() }), )); + } else if let Some(Value::Object(item)) = style.hover_item.as_deref() { + let mut event = item.clone(); + event.insert("action".into(), "show_item".into()); + out.push(("hover_event".to_owned(), Value::Object(event))); + } + if let Some(insertion) = &style.insertion { + out.push(("insertion".to_owned(), insertion.clone().into())); } if let Some(font) = &style.font { out.push(("font".to_owned(), font.clone().into())); diff --git a/crates/horizon-client/examples/probe/emitter_particles_probe.rs b/crates/horizon-client/examples/probe/emitter_particles_probe.rs index 6349eb8dc..949b306ff 100644 --- a/crates/horizon-client/examples/probe/emitter_particles_probe.rs +++ b/crates/horizon-client/examples/probe/emitter_particles_probe.rs @@ -54,7 +54,7 @@ pub fn main() -> Result<()> { match c["axis"].as_i64() { Some(axis @ 0..=2) => { let line = record("electric_spark"); - particles::along_axis(&mut random, axis as usize, p, |p, v| { + particles::along_axis(&mut random, axis as usize, p, (10, 19), |p, v| { lines.push(line(p, v)) }); } diff --git a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs index 3f47ba787..f05bd8b83 100644 --- a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs +++ b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs @@ -24,6 +24,7 @@ fn stack(spec: &str) -> LootStack { exploration: None, ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), }; for e in parts { let (name, level) = e.rsplit_once(':').unwrap_or((e, "1")); diff --git a/crates/horizon-client/examples/probe/hud_fixture.rs b/crates/horizon-client/examples/probe/hud_fixture.rs index a6f27fcda..5fc77309b 100644 --- a/crates/horizon-client/examples/probe/hud_fixture.rs +++ b/crates/horizon-client/examples/probe/hud_fixture.rs @@ -223,6 +223,7 @@ fn decorations(c: &Value, atlas: &HudAtlas) -> Vec { display_health: int("displayHealth", 0), last_health_time: millis - i64::from(int("lastHealthAgo", 0)), health_blink_time: i64::from(int("healthBlinkTime", 0)), + ..HealthHud::default() }; let kind = if has("minecraft:poison") { HeartKind::Poisoned diff --git a/crates/horizon-client/examples/probe/hud_fixture/kinds.rs b/crates/horizon-client/examples/probe/hud_fixture/kinds.rs index 9ba66abe1..f45c122fa 100644 --- a/crates/horizon-client/examples/probe/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/probe/hud_fixture/kinds.rs @@ -101,7 +101,7 @@ fn title(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { } let partial = float(c, "partial", 0.0); let bg = background(c); - let mut out = t.overlay_message(w, h, partial, &atlas.font, bg); + let mut out = t.overlay_message(w, h, 39, partial, &atlas.font, bg); out.extend(t.title(w, h, partial, &atlas.font, bg)); out } @@ -129,7 +129,7 @@ fn selected(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { } let mode = c["gameMode"].as_str().unwrap_or("survival"); let can_hurt = mode == "survival" || mode == "adventure"; - highlight.draw(w, h, can_hurt, &atlas.font, background(c)) + highlight.draw(w, h, 39, can_hurt, &atlas.font, background(c)) } fn boss(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { diff --git a/crates/horizon-client/examples/probe/marker_particles_probe.rs b/crates/horizon-client/examples/probe/marker_particles_probe.rs index 72ebaff22..6025a563c 100644 --- a/crates/horizon-client/examples/probe/marker_particles_probe.rs +++ b/crates/horizon-client/examples/probe/marker_particles_probe.rs @@ -74,7 +74,14 @@ pub fn main() -> Result<()> { biomes: &biomes, registry: assets.registry, raining_at: &|_| false, + height_no_leaves: &|_| 0, + firefly_bush_sounds: false, + sky_darken: 0, marker: target.map(|name| (name, &options as &dyn Fn(_) -> _)), + model_offset: &|_, _, _| None, + gateway_particles: &|_, _| 0, + thundering: false, + ultrawarm: false, }; engine.seed_randoms(1057, 0, 0); engine.requested = Some(Vec::new()); diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs index 07f2bf22a..0e0813f4a 100644 --- a/crates/horizon-client/examples/probe/mob_ai_probe.rs +++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs @@ -567,7 +567,13 @@ fn print_heart( /// The damage of a mob's direct hit on the player (others count as none). fn player_damage(e: &MobEvent) -> f32 { match e { - MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount, + MobEvent::AttackPlayer(amount, _) + | MobEvent::AttackPlayerWithEffect { amount, .. } + | MobEvent::DamagePlayer { amount, .. } => *amount, + MobEvent::SonicBoom { + target: Who::Player, + .. + } => 10.0, _ => 0.0, } } @@ -578,7 +584,13 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool { return false; }; match e { - MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0, + MobEvent::AttackPlayer(amount, _) + | MobEvent::AttackPlayerWithEffect { amount, .. } + | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0, + MobEvent::SonicBoom { + target: Who::Player, + .. + } => true, // ServerExplosion.hurtEntities: within twice the radius every hit does damage. MobEvent::Explode(at, radius, _) => { let d = Vec3::new(at[0], at[1], at[2]) @@ -1045,6 +1057,7 @@ pub fn main() -> horizon_client::Result<()> { alive: true, creative: s.creative, sneaking: false, + swimming: false, look: [0.0, 0.0, 1.0], main_hand: s.hand.as_deref().map(Into::into), off_hand: None, @@ -1057,6 +1070,8 @@ pub fn main() -> horizon_client::Result<()> { last_hurt: None, velocity: Vec3::ZERO, yaw: 0.0, + sprinting: false, + riding: false, hero: false, effects: Vec::new(), uuid: PLAYER_UUID, diff --git a/crates/horizon-client/examples/probe/scene_motion_probe.rs b/crates/horizon-client/examples/probe/scene_motion_probe.rs index 0a7e4b594..66856858f 100644 --- a/crates/horizon-client/examples/probe/scene_motion_probe.rs +++ b/crates/horizon-client/examples/probe/scene_motion_probe.rs @@ -208,7 +208,7 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> { )), MotionEvent::Emission { state, - in_water: true, + muffled: true, .. } => Some(format!("muffled-step {}", state.0)), MotionEvent::BubbleColumnParticle { bubble, position } => Some(format!( diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 1ed11da4d..229510dd7 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -4,7 +4,7 @@ //! conditions advancements use). use serde_json::Value; use std::{ - collections::{BTreeMap, HashMap}, + collections::{BTreeMap, BTreeSet, HashMap}, path::Path, }; @@ -753,6 +753,41 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo } true } +/// `KilledByArrowTrigger.TriggerInstance.matches`: the weapon, each listed +/// victim condition matched by a distinct victim, and the count of entity types. +pub fn killed_by_arrow( + c: &Value, + me: &EntityView, + victims: &[EntityView], + weapon: Option<&ItemView>, + w: &dyn World, +) -> bool { + fn ctx<'a>(e: &'a EntityView, me: &EntityView) -> Entities<'a> { + Entities { + this: Some(e), + origin: me.position, + tool: None, + block_pos: None, + } + } + if !conditions(&c["player"], &ctx(me, me), w) { + return false; + } + if !c["fired_from_weapon"].is_null() + && !weapon.is_some_and(|it| item(&c["fired_from_weapon"], it, w)) + { + return false; + } + let mut left: Vec<&EntityView> = victims.iter().collect(); + for want in c["victims"].as_array().into_iter().flatten() { + let Some(i) = left.iter().position(|e| conditions(want, &ctx(e, me), w)) else { + return false; + }; + left.remove(i); + } + let kinds: BTreeSet<&str> = victims.iter().map(|e| e.kind.as_str()).collect(); + range_i(&c["unique_entity_types"], kinds.len() as i64) +} /// A damage event as `DamagePredicate` sees it. #[derive(Clone, Debug, Default)] pub struct DamageView { diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs index c2123e693..ac23d329e 100644 --- a/crates/horizon-client/src/animate_tick.rs +++ b/crates/horizon-client/src/animate_tick.rs @@ -8,7 +8,7 @@ use crate::{ blocks::{BlockFacts, Fluid}, command::args::GameMode, items::ItemStack, - particles::{ParticleEngine, ParticleOptions, ParticleType as T}, + particles::{ParticleEngine, ParticleOptions, ParticleType as T, along_axis}, world::World, }; use horizon_core::{ @@ -75,8 +75,32 @@ enum Animate { waterlogged: bool, }, EndPortal, + /// A powered lever: its facing and the direction it is attached toward. + Lever { + facing: [i32; 3], + connected: [i32; 3], + }, + /// A powered repeater. + Repeater { + facing: [i32; 3], + delay: i32, + }, + /// A free-hanging stalactite tip that is not waterlogged. + PointedDripstone, + WitherRose, + EndGateway, + /// A lightning rod, by the axis it points along (0, 1, 2 for X, Y, Z). + LightningRod(usize), /// `WetSpongeBlock.animateTick`. WetSponge, + FireflyBush, + /// An open eyeblossom (`Type.OPEN.emitSounds()`). + OpenEyeblossom, + PaleHangingMoss, + /// `DryVegetationBlock`: a dead bush. + DeadBush, + /// `ShortDryGrassBlock` and `TallDryGrassBlock`. + DryGrass, } fn step(facing: &str) -> [i32; 3] { match facing { @@ -91,6 +115,7 @@ fn step(facing: &str) -> [i32; 3] { fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { let name = name.strip_prefix("minecraft:").unwrap_or(name); let lit = prop("lit").as_deref() == Some("true"); + let powered = prop("powered").as_deref() == Some("true"); let facing = || step(&prop("facing").unwrap_or_default()); match name { "torch" => Animate::Torch(T::Flame), @@ -172,10 +197,47 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { waterlogged: prop("waterlogged").as_deref() == Some("true"), }, "end_portal" => Animate::EndPortal, + "lever" if powered => Animate::Lever { + facing: facing(), + // FaceAttachedHorizontalDirectionalBlock.getConnectedDirection. + connected: match prop("face").as_deref() { + Some("ceiling") => [0, -1, 0], + Some("floor") => [0, 1, 0], + _ => facing(), + }, + }, + "repeater" if powered => Animate::Repeater { + facing: facing(), + delay: prop("delay").and_then(|d| d.parse().ok()).unwrap_or(1), + }, + "pointed_dripstone" + if prop("vertical_direction").as_deref() == Some("down") + && prop("thickness").as_deref() == Some("tip") + && prop("waterlogged").as_deref() != Some("true") => + { + Animate::PointedDripstone + } + "wither_rose" => Animate::WitherRose, + "end_gateway" => Animate::EndGateway, + _ if name == "lightning_rod" || name.ends_with("_lightning_rod") => { + let [dx, dy, _] = facing(); + Animate::LightningRod(if dx != 0 { + 0 + } else if dy != 0 { + 1 + } else { + 2 + }) + } "wet_sponge" => Animate::WetSponge, // BrushableBlock has no dust colour of its own, so the dust is the map colour. "suspicious_sand" => Animate::Falling(0xF7E9A3, false), "suspicious_gravel" => Animate::Falling(0x707070, false), + "firefly_bush" => Animate::FireflyBush, + "open_eyeblossom" => Animate::OpenEyeblossom, + "pale_hanging_moss" => Animate::PaleHangingMoss, + "dead_bush" => Animate::DeadBush, + "short_dry_grass" | "tall_dry_grass" => Animate::DryGrass, "sculk_sensor" | "calibrated_sculk_sensor" if prop("sculk_sensor_phase").as_deref() == Some("active") => { @@ -246,10 +308,16 @@ pub struct AnimateTables { desert_sand_sounds: Vec, /// `#required_for_poplar_leaf_ambience` (overworld natural logs). poplar_leaf_logs: Vec, + /// `#triggers_ambient_desert_dry_vegetation_block_sounds`. + desert_dry_vegetation_sounds: Vec, + terracotta: Vec, + pale_oak_logs: Vec, /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged). burnable: Vec, /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`). ambient: Vec>, + /// Per state: 1 for a pointed dripstone, 2 for one whose tip points down. + dripstone: Vec, } impl AnimateTables { pub fn load(root: &Path, registry: &BlockRegistry, biomes: &Biomes) -> crate::Result { @@ -315,14 +383,36 @@ impl AnimateTables { } } } + let dripstone = (0..registry.len() as u32) + .map(|id| { + registry.state(BlockStateId(id)).map_or(0, |s| { + let name = s.name.strip_prefix("minecraft:").unwrap_or(&s.name); + if name != "pointed_dripstone" { + 0 + } else if s.properties.get("vertical_direction").map(String::as_str) + == Some("down") + { + 2 + } else { + 1 + } + }) + }) + .collect(); Ok(Self { kinds, + dripstone, impermeable: by_state("minecraft:impermeable"), 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"), desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"), poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"), + desert_dry_vegetation_sounds: by_state( + "minecraft:triggers_ambient_desert_dry_vegetation_block_sounds", + ), + terracotta: by_state("minecraft:terracotta"), + pale_oak_logs: by_state("minecraft:pale_oak_logs"), burnable, ambient, }) @@ -348,8 +438,22 @@ pub struct AnimateContext<'a> { pub registry: &'a BlockRegistry, /// `Level.isRainingAt`. pub raining_at: &'a dyn Fn([i32; 3]) -> bool, + /// `getHeight(MOTION_BLOCKING_NO_LEAVES, x, z)` at a position's column. + pub height_no_leaves: &'a dyn Fn([i32; 3]) -> i32, + /// `EnvironmentAttributes.FIREFLY_BUSH_SOUNDS` (overworld day timeline). + pub firefly_bush_sounds: bool, + /// `Level.getSkyDarken`, for `getMaxLocalRawBrightness`. + pub sky_darken: i32, /// Creative main-hand marker block and a resolver for each placed state's sprite. pub marker: Option<(&'a str, &'a dyn Fn(BlockStateId) -> Option)>, + /// `BlockState.getOffset` of a state at (x, z), for blocks with a random model offset. + pub model_offset: &'a dyn Fn(BlockStateId, i32, i32) -> Option<[f64; 3]>, + /// `TheEndGatewayBlockEntity.getParticleAmount` of the gateway state at a position. + pub gateway_particles: &'a dyn Fn(BlockStateId, [i32; 3]) -> usize, + /// `Level.isThundering`. + pub thundering: bool, + /// The dimension has `water_evaporates` and drips lava from dripstone (the Nether). + pub ultrawarm: bool, } /// `ClientLevel.getMarkerParticleTarget`: only the selected main-hand item counts. @@ -398,6 +502,15 @@ impl AnimateContext<'_> { ], )) } + /// `Level.getMaxLocalRawBrightness`: the brighter of block light and + /// sky light less the sky darkening. + fn max_local_raw_brightness(&self, p: [i32; 3]) -> i32 { + let light = self.world.light(p[0], p[1], p[2]); + i32::from(light & 15).max(i32::from(light >> 4) - self.sky_darken) + } + fn offset_of(&self, state: BlockStateId, p: [i32; 3]) -> [f64; 3] { + (self.model_offset)(state, p[0], p[2]).unwrap_or([0.0; 3]) + } fn foliage(&self, p: [i32; 3]) -> u32 { let biome = self .world @@ -453,7 +566,7 @@ fn do_animate_tick( return; } let state = ctx.state(pos); - block_animate_tick(tables, engine, ctx, state, pos); + block_animate_tick(tables, engine, ctx, state, pos, center); let facts = ctx.facts.get(state); if facts.fluid != Fluid::None { fluid_animate_tick( @@ -609,6 +722,22 @@ fn beehive_drip( ]; add(engine, T::DrippingHoney, p, [0.0; 3]); } +/// `AmbientDesertBlockSoundsPlayer.shouldPlayDesertDryVegetationBlockSounds`: +/// sand or terracotta two blocks deep. +fn desert_dry_vegetation_sounds( + tables: &AnimateTables, + ctx: &AnimateContext, + below: [i32; 3], +) -> bool { + let triggers = |p: [i32; 3]| { + tables + .desert_dry_vegetation_sounds + .get(ctx.state(p).0 as usize) + .copied() + .unwrap_or(false) + }; + triggers(below) && triggers([below[0], below[1] - 1, below[2]]) +} /// `WaterFluid.animateTick` / `LavaFluid.animateTick`. fn fluid_animate_tick( engine: &mut ParticleEngine, @@ -684,6 +813,7 @@ fn block_animate_tick( ctx: &AnimateContext, state: BlockStateId, pos: [i32; 3], + player: [i32; 3], ) { let (fx, fy, fz) = (f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])); match tables.kind(state) { @@ -1073,12 +1203,198 @@ fn block_animate_tick( } } } + Animate::FireflyBush => { + // FireflyBushBlock.animateTick: the idle sound on a quiet night + // under open sky, and fireflies in the dark within 5 blocks. + if next_int(engine.random(), 30) == 0 + && ctx.firefly_bush_sounds + && (ctx.height_no_leaves)(pos) <= pos[1] + { + let name = "minecraft:block.firefly_bush.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + if ctx.max_local_raw_brightness(pos) <= 13 { + let r = engine.random(); + if r.next_double() <= 0.7 { + let p = [ + fx + r.next_double() * 10.0 - 5.0, + fy + r.next_double() * 5.0, + fz + r.next_double() * 10.0 - 5.0, + ]; + add(engine, T::Firefly, p, [0.0; 3]); + } + } + } + Animate::OpenEyeblossom => { + // EyeblossomBlock.animateTick: pale moss below. + if next_int(engine.random(), 700) == 0 { + let below = ctx.state([pos[0], pos[1] - 1, pos[2]]); + if ctx + .registry + .state(below) + .is_some_and(|s| s.name == "minecraft:pale_moss_block") + { + let name = "minecraft:block.eyeblossom.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::PaleHangingMoss => { + // HangingMossBlock.animateTick: under pale oak logs or leaves. + if next_int(engine.random(), 500) == 0 { + let above = ctx.state([pos[0], pos[1] + 1, pos[2]]); + let pale_leaves = ctx + .registry + .state(above) + .is_some_and(|s| s.name == "minecraft:pale_oak_leaves"); + if pale_leaves + || tables + .pale_oak_logs + .get(above.0 as usize) + .copied() + .unwrap_or(false) + { + let name = "minecraft:block.pale_hanging_moss.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::DeadBush => { + // AmbientDesertBlockSoundsPlayer.playAmbientDeadBushSounds. + if next_int(engine.random(), 130) == 0 { + let below = [pos[0], pos[1] - 1, pos[2]]; + let state = ctx.state(below); + let red_sand = ctx + .registry + .state(state) + .is_some_and(|s| s.name == "minecraft:red_sand"); + let terracotta = tables + .terracotta + .get(state.0 as usize) + .copied() + .unwrap_or(false); + if (red_sand || terracotta) && next_int(engine.random(), 3) != 0 { + return; + } + if desert_dry_vegetation_sounds(tables, ctx, below) { + let name = "minecraft:block.deadbush.idle"; + sound(engine, name, [fx, fy, fz], 1.0, 1.0); + } + } + } + Animate::DryGrass => { + // AmbientDesertBlockSoundsPlayer.playAmbientDryGrassSounds: + // played at the player. + if next_int(engine.random(), 200) == 0 + && desert_dry_vegetation_sounds(tables, ctx, [pos[0], pos[1] - 1, pos[2]]) + { + let at = [ + f64::from(player[0]) + 0.5, + f64::from(player[1]), + f64::from(player[2]) + 0.5, + ]; + sound(engine, "minecraft:block.dry_grass.ambient", at, 1.0, 1.0); + } + } Animate::EndPortal => { // EndPortalBlock.animateTick: one smoke particle above the surface. let r = engine.random(); let p = [fx + r.next_double(), fy + 0.8, fz + r.next_double()]; add(engine, T::Smoke, p, [0.0; 3]); } + Animate::Lever { facing, connected } => { + // LeverBlock.animateTick: a powered lever puffs red dust a quarter of the time. + if engine.random().next_float() < 0.25 { + // LeverBlock.makeParticle with scale 0.5. + let at = |base: f64, i: usize| { + base + 0.5 + 0.1 * f64::from(-facing[i]) + 0.2 * f64::from(-connected[i]) + }; + let p = [at(fx, 0), at(fy, 1), at(fz, 2)]; + engine.add(&ParticleOptions::dust([1.0, 0.0, 0.0], 0.5), p, [0.0; 3]); + } + } + Animate::Repeater { facing, delay } => { + // RepeaterBlock.animateTick: dust at one of the torches. + let r = engine.random(); + let x = fx + 0.5 + (r.next_double() - 0.5) * 0.2; + let y = fy + 0.4 + (r.next_double() - 0.5) * 0.2; + let z = fz + 0.5 + (r.next_double() - 0.5) * 0.2; + let mut offset = -5.0f32; + if r.next_boolean() { + offset = (delay * 2 - 1) as f32; + } + offset /= 16.0; + let xo = f64::from(offset * facing[0] as f32); + let zo = f64::from(offset * facing[2] as f32); + redstone(engine, [x + xo, y, z + zo]); + } + Animate::PointedDripstone => dripstone_drip(tables, engine, ctx, state, pos), + Animate::WitherRose => { + // WitherRoseBlock.animateTick: smoke puffs at the centre of the shape. + let center = ctx.shape_y(pos).map_or([0.5; 2], |s| { + [(s.2[0] + s.2[1]) / 2.0, (s.2[2] + s.2[3]) / 2.0] + }); + let offset = ctx.offset_of(state, pos); + let x = fx + center[0] + offset[0]; + let z = fz + center[1] + offset[2]; + for _ in 0..3 { + let r = engine.random(); + if r.next_boolean() { + let p = [ + x + r.next_double() / 5.0, + fy + (0.5 - r.next_double()), + z + r.next_double() / 5.0, + ]; + add(engine, T::Smoke, p, [0.0; 3]); + } + } + } + Animate::EndGateway => { + // EndGatewayBlock.animateTick: portal particles, one for each visible face. + for _ in 0..(ctx.gateway_particles)(state, pos) { + let r = engine.random(); + let mut p = [ + fx + r.next_double(), + fy + r.next_double(), + fz + r.next_double(), + ]; + let mut v = [ + (r.next_double() - 0.5) * 0.5, + (r.next_double() - 0.5) * 0.5, + (r.next_double() - 0.5) * 0.5, + ]; + let flip = next_int(r, 2) * 2 - 1; + if r.next_boolean() { + p[2] = fz + 0.5 + 0.25 * f64::from(flip); + v[2] = f64::from(r.next_float() * 2.0 * flip as f32); + } else { + p[0] = fx + 0.5 + 0.25 * f64::from(flip); + v[0] = f64::from(r.next_float() * 2.0 * flip as f32); + } + add(engine, T::Portal, p, v); + } + } + Animate::LightningRod(axis) => { + // LightningRodBlock.animateTick: in a thunderstorm, sparks along the + // topmost rod, more often as the game time within 200 ticks grows. + if ctx.thundering + && i64::from(next_int(engine.level_random(), 200)) <= ctx.world.game_time % 200 + && pos[1] + == ctx + .world + .world_surface(pos[0], pos[2], |id| ctx.facts.is_air(id)) + - 1 + { + let mut sparks = Vec::new(); + along_axis(engine.level_random(), axis, pos, (1, 2), |p, v| { + sparks.push((p, v)); + }); + let options = ParticleOptions::simple(T::ElectricSpark); + for (p, v) in sparks { + engine.add(&options, p, v); + } + } + } Animate::EnderChest => { for _ in 0..3 { let r = engine.random(); @@ -1382,6 +1698,68 @@ fn leaves_ambient_sound( } } } +/// `PointedDripstoneBlock.animateTick`: a free-hanging stalactite tip drips the +/// fluid above the root of its stalactite. +fn dripstone_drip( + tables: &AnimateTables, + engine: &mut ParticleEngine, + ctx: &AnimateContext, + state: BlockStateId, + pos: [i32; 3], +) { + let roll = engine.random().next_float(); + if roll > 0.12 { + return; + } + // getFluidAboveStalactite: findRootBlock climbs at most ten blocks of + // stalactite and stops at the first block that is not pointed dripstone. + let mut root = None; + for step in 1..11 { + let p = [pos[0], pos[1] + step, pos[2]]; + match tables + .dripstone + .get(ctx.state(p).0 as usize) + .copied() + .unwrap_or(0) + { + 0 => { + root = Some(p); + break; + } + 2 => {} + _ => return, + } + } + let Some(root) = root else { + return; + }; + let above = ctx.facts.get(ctx.state([root[0], root[1] + 1, root[2]])); + // Mud above the root counts as a water source unless water evaporates here. + let (fluid, source) = if &*above.name == "minecraft:mud" && !ctx.ultrawarm { + (Fluid::Water, true) + } else { + (above.fluid, above.fluid_level >= 8 && !above.fluid_falling) + }; + // canFillCauldron: only a water or lava source passes below a 2% roll. + if roll >= 0.02 && !(fluid != Fluid::None && source) { + return; + } + // getDripParticle: no fluid drips what the dimension's default says. + let lava = fluid == Fluid::Lava || (fluid == Fluid::None && ctx.ultrawarm); + let ty = if lava { + T::DrippingDripstoneLava + } else { + T::DrippingDripstoneWater + }; + let offset = ctx.offset_of(state, pos); + // STALACTITE_DRIP_START_PIXEL is the tip's lowest point, 5/16. + let p = [ + f64::from(pos[0]) + 0.5 + offset[0], + f64::from(pos[1]) + 0.3125 - 0.0625, + f64::from(pos[2]) + 0.5 + offset[2], + ]; + add(engine, ty, p, [0.0; 3]); +} /// `AmbientDesertBlockSoundsPlayer.shouldPlayAmbientSandSound`: sand in the /// surface column eight blocks away on all four sides. fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]) -> bool { diff --git a/crates/horizon-client/src/arrows.rs b/crates/horizon-client/src/arrows.rs index 6d8dc528b..9b46269ad 100644 --- a/crates/horizon-client/src/arrows.rs +++ b/crates/horizon-client/src/arrows.rs @@ -159,6 +159,8 @@ pub struct ArrowState { pub pickup: Pickup, /// `pickupItemStack`: what picking the arrow up gives. pub pickup_item: crate::items::ItemStack, + /// `AbstractArrow.firedFromWeapon`: the crossbow or bow it was shot from. + pub fired_from_weapon: Option, pub no_physics: bool, /// `AbstractArrow.getPierceLevel`. pub pierce: u8, @@ -208,6 +210,7 @@ impl ArrowState { last_state: None, pickup: Pickup::Disallowed, pickup_item: crate::items::ItemStack::new("minecraft:arrow", 1), + fired_from_weapon: None, no_physics: false, pierce: 0, pierced: Vec::new(), diff --git a/crates/horizon-client/src/biome.rs b/crates/horizon-client/src/biome.rs index 46c1e16ca..291b719cc 100644 --- a/crates/horizon-client/src/biome.rs +++ b/crates/horizon-client/src/biome.rs @@ -66,6 +66,13 @@ impl BiomeInfo { } .height_adjusted(pos, sea_level) } + /// `Biome.getPrecipitationAt` in the Overworld (sea level 63): None + /// without precipitation, else whether it falls as snow + /// (`getHeightAdjustedTemperature` below 0.15). + pub fn snows_at(&self, x: i32, y: i32, z: i32) -> Option { + self.precipitation + .then(|| self.temperature_at(BlockPos::new(x, y, z), 63) < 0.15) + } } pub struct Biomes { pub list: Vec, diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 514326e66..ecad13fb1 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -5,7 +5,11 @@ //! (`entity-models.json`); transforms, animation and textures follow each //! vanilla renderer. Faces are lit like the `entity` shader: the lightmap at //! the block plus `minecraft_mix_light` with the level's two diffuse lights. -use crate::{hud::Rect, mesher::Vertex, world::World}; +use crate::{ + hud::Rect, + mesher::{CULL_BACK, Vertex}, + world::World, +}; use glam::{DVec3, Mat4, Quat, Vec3}; use horizon_core::geometry::{ Direction, @@ -938,6 +942,30 @@ impl BlockEntityRenderer { let lights = diffuse_lights(scene.nether); self.render_one(scene, pos, kind, base, packed, lights, false, false, out); } + /// `TheEndGatewayBlockEntity.shouldRenderFace` for each face of the gateway + /// at `pos`: the faces its portal is drawn on. + pub fn gateway_faces( + &self, + world: &World, + state: BlockStateId, + pos: [i32; 3], + ) -> Vec { + Direction::ALL + .into_iter() + .filter(|&d| { + let [dx, dy, dz] = d.normal(); + let neighbor = world.block(pos[0] + dx, pos[1] + dy, pos[2] + dz); + self.visibility.as_ref().is_none_or(|v| { + v.lock() + .map(|mut v| { + v.should_render_face(state, neighbor, d, true) + .unwrap_or(true) + }) + .unwrap_or(true) + }) + }) + .collect() + } /// Whether this block state has a block-entity renderer here. pub fn renders(&self, state: u32) -> bool { !matches!(self.kind(state), Kind::None) @@ -1392,6 +1420,7 @@ impl BlockEntityRenderer { m *= around(Mat4::from_rotation_y(turn * decay), pivot); } } + let first = out.len(); if let Some(paint) = paint("entity/decorated_pot/decorated_pot_base", 0xFFFFFF, packed) { @@ -1409,6 +1438,11 @@ impl BlockEntityRenderer { draw_part(part, side, m, &none, paint, out); } } + // `DecoratedPotRenderer` submits every part with `entitySolid`, which culls + // back faces: the flat `top` and `bottom` planes show one side each. + for vertex in &mut out[first..] { + vertex.normal = CULL_BACK; + } } Kind::EndPortal => { // TheEndPortalRenderer.TRANSFORMATION: y from 6/16 to 12/16; only the @@ -1439,22 +1473,8 @@ impl BlockEntityRenderer { out, ); } - // AbstractEndPortalRenderer.extractRenderState: TheEndGatewayBlockEntity.shouldRenderFace. - let faces: Vec = Direction::ALL - .into_iter() - .filter(|&d| { - let [dx, dy, dz] = d.normal(); - let neighbor = scene.world.block(pos[0] + dx, pos[1] + dy, pos[2] + dz); - self.visibility.as_ref().is_none_or(|v| { - v.lock() - .map(|mut v| { - v.should_render_face(BlockStateId(*state), neighbor, d, true) - .unwrap_or(true) - }) - .unwrap_or(true) - }) - }) - .collect(); + // AbstractEndPortalRenderer.extractRenderState. + let faces = self.gateway_faces(scene.world, BlockStateId(*state), pos); portal_cube(base, &faces, END_GATEWAY_LAYER, out); } Kind::Conduit => { @@ -2118,4 +2138,70 @@ mod tests { assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}"); assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab"); } + /// `DecoratedPotRenderer` submits every part with `RenderTypes.entitySolid`, + /// whose pipeline culls back faces. The pot's `top` and `bottom` are flat + /// boxes, so without that cull both sides of each plane are drawn and they + /// z-fight: the pot renders wrong. + #[test] + fn the_decorated_pot_culls_its_back_faces() { + let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("entity-models.json").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let registry = assets.registry; + let renderer = BlockEntityRenderer::load(&root, registry).unwrap(); + let state = registry.default_state("minecraft:decorated_pot").unwrap(); + let sprites: HashMap = [ + "entity/decorated_pot/decorated_pot_base", + "entity/decorated_pot/decorated_pot_side", + ] + .into_iter() + .map(|name| { + ( + name.to_owned(), + Rect { + u0: 0.25, + v0: 0.125, + u1: 0.375, + v1: 0.25, + w: 16, + h: 16, + }, + ) + }) + .collect(); + let world = World::new(BlockStateId(0), 1); + let scene = Scene { + camera: DVec3::ZERO, + orientation: Quat::IDENTITY, + anim: &|_| BlockAnim::default(), + texts: None, + partial: 0.5, + game_time: 0, + max_y: 320, + world: &world, + sprites: &sprites, + nether: false, + lid: &|_| 0.0, + sign: &|_| None, + banner: &|_| Vec::new(), + skull: &|_| None, + glyph: &|_| (None, 0.0), + }; + let mut verts = Vec::new(); + renderer.render_block(&scene, [0; 3], state.0, Mat4::IDENTITY, 0xff, &mut verts); + // Vanilla submits 28 quads for a plain pot, and the cull keeps them all. + assert_eq!( + verts.len() / 4, + 28, + "the pot submits all of vanilla's quads" + ); + assert!( + verts.iter().all(|v| v.normal == CULL_BACK), + "entitySolid culls the pot's back faces" + ); + } } diff --git a/crates/horizon-client/src/bundle.rs b/crates/horizon-client/src/bundle.rs index 948e2f4a9..49d29d5f9 100644 --- a/crates/horizon-client/src/bundle.rs +++ b/crates/horizon-client/src/bundle.rs @@ -211,6 +211,17 @@ impl Contents { self.weight.n >= self.weight.d } + /// `BundleItem.isBarVisible`, `getBarWidth` and `getBarColor`: the fullness bar + /// (width, RGB), blue until the bundle is full, then red. + pub fn bar(&self) -> Option<(i32, u32)> { + if self.weight.n <= 0 { + return None; + } + let width = (1 + self.weight.n * 12 / self.weight.d).min(13) as i32; + let color = if self.is_full() { 0xFF5454 } else { 0x7087FF }; + Some((width, color)) + } + /// `toImmutable`, written back into the bundle's component. pub fn store(self, bundle: &mut ItemStack) { let data = bundle.data_mut(); diff --git a/crates/horizon-client/src/chat.rs b/crates/horizon-client/src/chat.rs index 04b9d486c..63646bcc7 100644 --- a/crates/horizon-client/src/chat.rs +++ b/crates/horizon-client/src/chat.rs @@ -16,6 +16,9 @@ use crate::{ #[path = "chat_tests.rs"] mod tests; +/// `CommandHistory.PERSISTED_COMMANDS_FILE_NAME` and its size cap. +const COMMAND_HISTORY_FILE: &str = "command_history.txt"; +const MAX_PERSISTED_COMMAND_HISTORY: usize = 50; /// GuiMessageTag.systemSinglePlayer's indicator colour. pub const SYSTEM_INDICATOR: u32 = 0xD0D0D0; @@ -80,6 +83,10 @@ impl ChatAbilities { ChatSource::Client => true, } } + /// `ChatAbilities.hasAnyRestrictions`: the Chat option takes something. + pub fn any_restriction(&self) -> bool { + *self != Self::new(ChatVisibility::Full) + } /// Whether the chat screen may send `input` (`hasAllowedInput`). pub fn allows(&self, input: &str) -> bool { if input.starts_with('/') { @@ -185,6 +192,10 @@ pub struct Chat { lines: Vec, /// Sent messages and commands (ChatComponent.recentChat). pub recent: Vec, + /// `CommandHistory`: the last commands, kept in `command_history.txt` + /// in the game folder once `load_history` has set it. + commands: Vec, + history_file: Option, scroll: usize, new_since_scroll: bool, pub options: ChatOptions, @@ -310,6 +321,17 @@ impl Chat { self.lines.clear(); self.scroll = 0; } + /// `new CommandHistory(gameFolder)`: the commands kept from earlier runs + /// start the chat's history (`ChatComponent`'s constructor). + pub fn load_history(&mut self, game_folder: &std::path::Path) { + let file = game_folder.join(COMMAND_HISTORY_FILE); + if let Ok(text) = std::fs::read_to_string(&file) { + self.commands = text.lines().map(str::to_owned).collect(); + self.recent.extend(self.commands.iter().cloned()); + } + self.history_file = Some(file); + } + /// `ChatComponent.addRecentChat`: a command also goes to the saved history. pub fn add_recent(&mut self, message: &str) { if self.recent.last().map(String::as_str) != Some(message) { if self.recent.len() >= 100 { @@ -317,6 +339,21 @@ impl Chat { } self.recent.push(message.to_owned()); } + if message.starts_with('/') && self.commands.last().map(String::as_str) != Some(message) { + if self.commands.len() >= MAX_PERSISTED_COMMAND_HISTORY { + self.commands.remove(0); + } + self.commands.push(message.to_owned()); + if let Some(file) = &self.history_file { + let mut text = self.commands.join("\n"); + text.push('\n'); + if let Err(e) = std::fs::write(file, text) { + log::error!( + "Failed to write {COMMAND_HISTORY_FILE}, command history will be missing: {e}" + ); + } + } + } } pub fn reset_scroll(&mut self) { self.scroll = 0; @@ -438,10 +475,71 @@ impl Chat { out.push(GuiDraw::Pop); out } - /// Draws [`Chat::layout`] into the HUD batch. + /// Draws [`Chat::layout`] into the HUD batch, and with the chat screen + /// open the restricted prompt above the lines. pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: u64, focused: bool) { let draws = self.layout(batch.height as i32, ticks, focused); hud_layout::paint(batch, atlas, &draws); + if focused && self.abilities.any_restriction() { + let prompt = self.restricted_prompt(&atlas.font, batch.height as i32); + hud_layout::paint(batch, atlas, &prompt); + } + } + /// `ChatComponent.extractRenderState` for `FOREGROUND_RESTRICTED`: a + /// background row and the red, underlined "Chat is restricted" line in + /// the row above the messages, clipped to the chat's width. + fn restricted_prompt(&self, font: &crate::font::Font, height: i32) -> Vec { + let o = &self.options; + let scale = o.scale as f32; + let max_width = hud_layout::ceil(o.width_px() as f32 / scale); + let chat_bottom = hud_layout::floor((height - 40) as f32 / scale); + let entry_height = o.line_height(); + let bottom_to_text = + (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing + 0.5).floor() as i32; + let shown = self + .lines + .len() + .saturating_sub(self.scroll) + .min(self.lines_per_page(true)); + let top = chat_bottom - (shown as i32 + 1) * entry_height; + let mut prompt = Text::translate("chat_screen.restricted", &[]).with_style(&Style { + color: Some(text::RED), + underlined: Some(true), + ..Style::default() + }); + // ComponentRenderUtils.clipText. + let mut width = 0.0; + let fits = prompt + .chars() + .take_while(|(c, style)| { + width += font.advance(*c, style); + width <= max_width as f32 + }) + .count(); + if fits < prompt.chars().count() { + prompt = prompt.slice(0, fits); + } + vec![ + GuiDraw::Push(vec![ + PoseOp::Scale(scale, scale), + PoseOp::Translate(4.0, 0.0), + ]), + hud_layout::fill( + -2, + top, + max_width + 4 + 4, + top + entry_height, + hud_layout::as8(o.background_opacity as f32) << 24, + ), + GuiDraw::Text { + text: prompt, + x: 0, + y: top + entry_height - bottom_to_text - 1, + color: hud_layout::white(o.opacity as f32 * 0.9 + 0.1), + shadow: true, + }, + GuiDraw::Pop, + ] } /// The click action under a GUI-space cursor while chat is focused. pub fn click_at( @@ -458,26 +556,34 @@ impl Chat { pub fn hover_at(&self, font: &crate::font::Font, height: i32, x: f64, y: f64) -> Option { self.style_at(font, height, x, y)?.hover.map(|h| *h) } - /// ChatComponent.getClickedComponentStyleAt. - fn style_at( - &self, - font: &crate::font::Font, - height: i32, - x: f64, - y: f64, - ) -> Option { + /// The wrapped line under a GUI-space cursor while chat is focused, and + /// the cursor's x within it (the text starts at 0). + fn line_at(&self, height: i32, x: f64, y: f64) -> Option<(&Line, f64)> { let scale = self.options.scale as f32; - let mut x = x / f64::from(scale) - 4.0; + let x = x / f64::from(scale) - 4.0; let bottom = hud_layout::floor((height - 40) as f32 / scale); let from_bottom = f64::from(bottom) - y / f64::from(scale); - if x < 0.0 || x >= f64::from(self.max_width()) || from_bottom <= 0.0 { + if x >= f64::from(self.max_width()) || from_bottom <= 0.0 { return None; } let row = (from_bottom / f64::from(self.options.line_height())).ceil() as usize - 1; if row >= self.lines_per_page(true) { return None; } - let line = self.lines.get(self.scroll + row)?; + Some((self.lines.get(self.scroll + row)?, x)) + } + /// ChatComponent.getClickedComponentStyleAt. + pub fn style_at( + &self, + font: &crate::font::Font, + height: i32, + x: f64, + y: f64, + ) -> Option { + let (line, mut x) = self.line_at(height, x, y)?; + if x < 0.0 { + return None; + } let content = line.content.resolve_legacy(); for (c, style) in content.chars() { x -= f64::from(font.advance(c, style)); @@ -487,6 +593,13 @@ impl Chat { } None } + /// Whether the cursor is on a line's indicator bar while chat is focused + /// (`DrawingFocusedGraphicsAccess.handleTag`), whose tooltip is the + /// message tag's text. + pub fn indicator_at(&self, height: i32, x: f64, y: f64) -> bool { + self.line_at(height, x, y) + .is_some_and(|(line, x)| line.indicator.is_some() && (-4.0..-2.0).contains(&x)) + } /// Plain text of the newest messages (for tests and the control socket). pub fn recent_lines(&self, n: usize) -> Vec { self.messages diff --git a/crates/horizon-client/src/confirm_screen.rs b/crates/horizon-client/src/confirm_screen.rs index 3b4f7e7aa..c6fda8236 100644 --- a/crates/horizon-client/src/confirm_screen.rs +++ b/crates/horizon-client/src/confirm_screen.rs @@ -63,13 +63,24 @@ impl Confirm { atlas: &HudAtlas, cursor: (f32, f32), labels: [&Text; 2], + ) { + self.draw_active(batch, atlas, cursor, labels, true); + } + /// `draw` with the buttons greyed out while `setDelay` runs (`active` false). + pub fn draw_active( + &self, + batch: &mut HudBatch, + atlas: &HudAtlas, + cursor: (f32, f32), + labels: [&Text; 2], + active: bool, ) { for (line, x, y) in &self.lines { batch.text_styled(atlas, line, *x, *y, u32::MAX, true); } for ((bx, by), label) in self.buttons.into_iter().zip(labels) { - let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); - ui::button(batch, atlas, bx, by, 150.0, 20.0, label, true, hover); + let hover = active && ui::hovered(cursor, bx, by, 150.0, 20.0); + ui::button(batch, atlas, bx, by, 150.0, 20.0, label, active, hover); } } } diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index ed7d09a60..af867903f 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -103,6 +103,22 @@ pub enum BlockEntity { /// `DaylightDetectorBlockEntity`: no data, only the ticker /// (`DaylightDetectorBlock.tickEntity`). DaylightDetector, + /// `ChiseledBookShelfBlockEntity`: a `Container` of six one-book slots. + ChiseledBookshelf(Box), +} +/// `ChiseledBookShelfBlockEntity`: six slots and `lastInteractedSlot`. +#[derive(Clone, Debug, PartialEq)] +pub struct ChiseledBookshelf { + pub items: [Option; 6], + pub last_slot: i32, +} +impl Default for ChiseledBookshelf { + fn default() -> Self { + Self { + items: Default::default(), + last_slot: -1, + } + } } /// `TheEndGatewayBlockEntity`. #[derive(Clone, Debug, Default, PartialEq, Eq)] @@ -407,6 +423,9 @@ impl BlockEntity { if name == "minecraft:campfire" || name == "minecraft:soul_campfire" { return Some(Self::Campfire(Box::default())); } + if name == "minecraft:chiseled_bookshelf" { + return Some(Self::ChiseledBookshelf(Box::default())); + } let size = match name { "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => 27, n if n.ends_with("copper_chest") => 27, @@ -447,6 +466,7 @@ impl BlockEntity { Self::EndGateway(_) => "minecraft:end_gateway", Self::DaylightDetector => "minecraft:daylight_detector", Self::Campfire(_) => "minecraft:campfire", + Self::ChiseledBookshelf(_) => "minecraft:chiseled_bookshelf", } } pub fn contents(&self) -> Vec { @@ -471,6 +491,7 @@ impl BlockEntity { Self::Banner(_) => Vec::new(), Self::Crafter(c) => c.items.iter().flatten().cloned().collect(), Self::Campfire(c) => c.items.iter().flatten().cloned().collect(), + Self::ChiseledBookshelf(b) => b.items.iter().flatten().cloned().collect(), } } pub fn slots(&self) -> &[Option] { @@ -488,6 +509,7 @@ impl BlockEntity { | Self::Skull(_) | Self::DaylightDetector => &[], Self::Crafter(c) => &c.items, + Self::ChiseledBookshelf(b) => &b.items, Self::CreakingHeart(_) | Self::Spawner(_) | Self::TrialSpawner(_) @@ -513,6 +535,7 @@ impl BlockEntity { | Self::Skull(_) | Self::DaylightDetector => &mut [], Self::Crafter(c) => &mut c.items, + Self::ChiseledBookshelf(b) => &mut b.items, Self::CreakingHeart(_) | Self::Spawner(_) | Self::TrialSpawner(_) diff --git a/crates/horizon-client/src/crash.rs b/crates/horizon-client/src/crash.rs index e147bfb4c..5490808a1 100644 --- a/crates/horizon-client/src/crash.rs +++ b/crates/horizon-client/src/crash.rs @@ -105,9 +105,13 @@ impl Report { } } -/// The release this binary is (`v0.2.3`); for a release from before 0.2, its tag and the client's -/// crate version; for a build from source, that version alone. +/// The release this binary is (`v0.2.3`); a nightly's label (`Nightly 2026-10-28 · 0c02067`); for a +/// release from before 0.2, its tag and the client's crate version; for a build from source, that +/// version alone. pub fn version() -> String { + if let Some(label) = horizon_core::release::nightly_label() { + return label; + } let version = env!("CARGO_PKG_VERSION"); match (horizon_core::release::RELEASE, release_tag()) { (Some(_), Some(tag)) => tag, @@ -117,8 +121,12 @@ pub fn version() -> String { } /// The release this binary came with: the version release.yml built in (docs/versioning.md), else -/// the folder the launcher installed it in, named after the tag (releases from before 0.2). +/// the folder the launcher installed it in, named after the tag (releases from before 0.2). A +/// nightly is its version as the launcher installs it (`nightly-2026-10-28-0c02067`). pub fn release_tag() -> Option { + if let Some(nightly) = horizon_core::release::nightly_version() { + return Some(nightly); + } if let Some(version) = horizon_core::release::RELEASE { return Some(format!("v{version}")); } @@ -525,6 +533,11 @@ mod tests { #[test] fn a_release_reports_its_built_in_version() { // release.yml builds with HORIZON_VERSION (docs/versioning.md): `v0.2.3`, wherever it is installed. + if let Some(label) = horizon_core::release::nightly_label() { + assert_eq!(super::version(), label); + assert_eq!(release_tag(), horizon_core::release::nightly_version()); + return; + } match horizon_core::release::RELEASE { Some(version) => { assert_eq!(release_tag(), Some(format!("v{version}"))); diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs index 9511fd112..5365a9d5c 100644 --- a/crates/horizon-client/src/effects.rs +++ b/crates/horizon-client/src/effects.rs @@ -129,15 +129,16 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option { _ => None, } } -/// `InstantenousMobEffect.applyInstantenousEffect` (potions apply these directly). +/// `HealOrHarmMobEffect.applyInstantaneousEffect` (potions apply these directly; +/// the amount rounds to the nearest whole point). pub fn instant(id: &str, amp: i32, scale: f64) -> Option { match id { "instant_health" => Some(EffectAction::Heal( - (scale * f64::from(4 << amp.min(30))) as i32 as f32, + (scale * f64::from(4 << amp.min(30)) + 0.5) as i32 as f32, )), "instant_damage" => Some(EffectAction::Hurt( "minecraft:magic", - (scale * f64::from(6 << amp.min(30))) as i32 as f32, + (scale * f64::from(6 << amp.min(30)) + 0.5) as i32 as f32, )), "saturation" => Some(EffectAction::Eat(amp + 1, 1.0)), _ => None, diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index 14cd946c2..2c3488f5d 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -19,6 +19,8 @@ pub struct ItemEntity { pub id: u32, pub stack: ItemStack, pub thrower: Option<[i32; 4]>, + /// `ItemEntity.target`: the only player who may pick the item up. + pub target: Option<[i32; 4]>, pub position: Vec3, pub previous: Vec3, pub velocity: Vec3, @@ -355,7 +357,10 @@ pub fn merge_with_neighbours( } // ItemEntity.areMergable: both fit one stack of the same item and components. let (this, other) = (&items[i].stack, &items[j].stack); - if this.count + other.count > max_stack(other) || !this.same_item_same_components(other) { + if items[i].target != items[j].target + || this.count + other.count > max_stack(other) + || !this.same_item_same_components(other) + { continue; } let (to, from) = if other.count < this.count { @@ -771,9 +776,24 @@ pub struct ArmorStand { pub name_visible: bool, /// Game time of the last hit (the wobble and the second-hit window). pub last_hit: i64, + /// `DATA_HEAD_POSE` to `DATA_RIGHT_LEG_POSE`: head, body, left arm, right + /// arm, left leg, right leg, in degrees (`POSE_KEYS` order). + pub pose: [[f32; 3]; 6], } impl ArmorStand { pub const SLOTS: [&'static str; 6] = ["mainhand", "offhand", "feet", "legs", "chest", "head"]; + /// The `Pose` compound's keys. + pub const POSE_KEYS: [&'static str; 6] = + ["Head", "Body", "LeftArm", "RightArm", "LeftLeg", "RightLeg"]; + /// `ArmorStand.DEFAULT_*_POSE`. + pub const DEFAULT_POSE: [[f32; 3]; 6] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [-10.0, 0.0, -10.0], + [-15.0, 0.0, 10.0], + [-1.0, 0.0, -1.0], + [1.0, 0.0, 1.0], + ]; pub fn new(id: u32, position: Vec3, yaw: f32) -> Self { Self { fire_ticks: 0, @@ -792,6 +812,7 @@ impl ArmorStand { custom_name: None, name_visible: false, last_hit: i64::MIN / 2, + pose: Self::DEFAULT_POSE, } } pub fn environment_tick( @@ -935,6 +956,7 @@ mod fire_environment_tests { let make = |id: &str| ItemEntity { id: 1, thrower: None, + target: None, stack: ItemStack { item: std::sync::Arc::from(id), count: 1, @@ -1031,6 +1053,7 @@ mod merge_tests { ItemEntity { id: 0, thrower: None, + target: None, stack: ItemStack { item: std::sync::Arc::from(id), count, diff --git a/crates/horizon-client/src/entities/fluids.rs b/crates/horizon-client/src/entities/fluids.rs index fffa0ae2b..3b3dffa99 100644 --- a/crates/horizon-client/src/entities/fluids.rs +++ b/crates/horizon-client/src/entities/fluids.rs @@ -189,6 +189,7 @@ mod tests { extra: None, }, thrower: None, + target: None, position: at, previous: at, velocity: Vec3::ZERO, diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index e90b9dd66..919c5edbb 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -54,6 +54,8 @@ struct Out { // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour). @location(11) glint_uv: vec2, + // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type. + @location(12) @interpolate(flat) cull: u32, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -102,7 +104,10 @@ fn entity_vertex(position: vec3, uv: vec2, // minecraft_mix_light: the vertex colour times the cardinal light only. var c = color; var back = c; - if normal.w != 0.0 { + // Normal w: 0 keeps the baked colour, +-127 shades by the normal, and a small positive 1 + // keeps the baked colour but culls back faces (entitySolid models such as the decorated pot). + out.cull = select(0u, 1u, normal.w > 0.0 && normal.w < 0.5); + if abs(normal.w) >= 0.5 { c = vec4(c.rgb * entity_light(normal.xyz, globals.time.y != 0.0), c.a); back = select(c, vec4(back.rgb * entity_light(-normal.xyz, globals.time.y != 0.0), back.a), normal.w < 0.0); } @@ -234,7 +239,7 @@ fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, // clouds.fsh: alpha fades out towards the cloud fog end. return vec4(color.rgb, color.a * (1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y))); } - if color.a < 0.1 { discard; } + if color.a < 0.1 || (in.cull != 0u && !front) { discard; } // entity.fsh calculateFinalColor: the overlay (hurt red, TNT white) over the // lit texture, then the lightmap, then the glint and fog. color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a); diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs index 5c3d41ddc..a2d1bef82 100644 --- a/crates/horizon-client/src/entity_nbt.rs +++ b/crates/horizon-client/src/entity_nbt.rs @@ -339,6 +339,18 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting))); map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8)); } + "minecraft:panda" => { + use crate::mobs::panda::GENES; + for (key, gene) in [ + ("MainGene", m.extra.variant), + ("HiddenGene", m.extra.variant2), + ] { + map.insert( + key.into(), + string(GENES[usize::from(gene).min(GENES.len() - 1)]), + ); + } + } "minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => { // Only Piglin.addAdditionalSaveData writes CannotHunt. if id == "minecraft:piglin_brute" { @@ -503,6 +515,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { "Variant".into(), Tag::Int(i32::from(m.extra.variant.min(4))), ); + if let Some(owner) = m.extra.owner { + map.insert("Owner".into(), Tag::IntArray(owner.to_vec())); + } else { + map.remove(&"Owner".into()); + } + map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting))); } "minecraft:salmon" => { let size = SALMON_SIZES[usize::from(m.extra.variant).min(2)]; @@ -540,7 +558,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { "memories", Tag::compound([( "minecraft:liked_player", - Tag::compound([("value", Tag::IntArray(vec![0, 0, 0, 1]))]), + Tag::compound([( + "value", + Tag::IntArray(m.extra.owner.unwrap_or([0, 0, 0, 1]).to_vec()), + )]), )]), )]), ); @@ -594,6 +615,9 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { map.insert("life_ticks".into(), Tag::Int(m.extra.egg_time)); } } + "minecraft:endermite" => { + map.insert("Lifetime".into(), Tag::Int(m.extra.counter)); + } "minecraft:shulker" => { map.insert("AttachFace".into(), Tag::Byte(m.extra.variant3 as i8)); map.insert("Peek".into(), Tag::Byte(m.extra.counter as i8)); @@ -700,6 +724,17 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag { equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); continue; } + // A wolf's armor keeps the durability it lost. + if slot == "body" + && m.species() == crate::mobs::Species::Wolf + && let Some(id) = item + { + let mut stack = crate::items::ItemStack::new(id, 1); + stack.damage = m.extra.body_damage.max(0) as u32; + stack.extra = m.extra.body_extra.clone(); + equipment.insert(slot.into(), crate::save::item_to_nbt(&stack)); + continue; + } match item { Some(id) => { let keep = matches!( @@ -1094,6 +1129,16 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.color = number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15); } + if m.species() == crate::mobs::Species::Panda { + let gene = |key| text(tag.get(key)).map_or(0, |n| crate::mobs::panda::gene_from_name(&n)); + m.extra.variant = gene("MainGene"); + m.extra.variant2 = gene("HiddenGene"); + } + if m.species() == crate::mobs::Species::Parrot { + m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner")); + m.extra.tame = m.extra.owner.is_some(); + m.extra.sitting = flag(tag, "Sitting"); + } if m.species() == crate::mobs::Species::Wolf { let health = m.health; m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner")); @@ -1101,6 +1146,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - crate::mobs::tame::set_tame(&mut m, tame); m.health = health; m.extra.sitting = flag(tag, "Sitting"); + let armor = tag + .get("equipment") + .and_then(|e| e.get("body")) + .and_then(crate::save::item_from_nbt); + m.extra.body_damage = armor.as_ref().map_or(0, |s| s.damage as i32); + m.extra.body_extra = armor.and_then(|s| s.extra); m.extra.color = number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15); } @@ -1131,11 +1182,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.ints[1] = number(first.get("count")).unwrap_or(1) as i32; } m.extra.egg_time = number(tag.get("DuplicationCooldown")).unwrap_or(0) as i32; - m.extra.tame = tag + let liked = tag .get("Brain") .and_then(|b| b.get("memories")) - .and_then(|b| b.get("minecraft:liked_player")) - .is_some(); + .and_then(|b| b.get("minecraft:liked_player")); + m.extra.tame = liked.is_some(); + m.extra.owner = liked + .and_then(|l| l.get("value")) + .and_then(|v| crate::save::uuid_from_tag(Some(v))); } if crate::mobs::camel::is_camel(m.species()) { let sitting = matches!(tag.get("LastPoseTick"), Some(Tag::Long(v)) if *v < 0); @@ -1213,6 +1267,9 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) - m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32; m.extra.anim_ticks = number(tag.get("RoarTick")).unwrap_or(0) as i32; } + if m.species() == crate::mobs::Species::Endermite { + m.extra.counter = number(tag.get("Lifetime")).unwrap_or(0) as i32; + } if m.species() == crate::mobs::Species::Vex { if let Some(Tag::IntArray(v)) = tag.get("bound_pos") && v.len() == 3 @@ -1303,6 +1360,11 @@ pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) -> } else if let Tag::Compound(map) = &mut tag { map.remove(&"Thrower".into()); } + if let Some(target) = e.target { + put(&mut tag, "Owner", Tag::IntArray(target.to_vec())); + } else if let Tag::Compound(map) = &mut tag { + map.remove(&"Owner".into()); + } tag } pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option { @@ -1314,6 +1376,7 @@ pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option) -> } put(&mut tag, "Health", Tag::Float(a.health.to_bits())); put(&mut tag, "Fire", Tag::Short(a.fire_ticks as i16)); + // ArmorStand.addAdditionalSaveData: the `Pose` parts that are not default. + let pose: Vec<(&str, Tag)> = ArmorStand::POSE_KEYS + .into_iter() + .zip(a.pose) + .zip(ArmorStand::DEFAULT_POSE) + .filter(|((_, rotation), default)| rotation != default) + .map(|((key, rotation), _)| (key, floats(&rotation))) + .collect(); + put(&mut tag, "Pose", Tag::compound(pose)); // LivingEntity.addAdditionalSaveData and ArmorStand's own fields. if let Tag::Compound(map) = &mut tag { for (key, value) in [ @@ -1871,6 +1943,19 @@ pub fn armor_stand_from_nbt(tag: &Tag, id: u32) -> Option { a.invisible = flag(tag, "Invisible"); a.marker = flag(tag, "Marker"); a.on_ground = flag(tag, "OnGround"); + // ArmorStand.readAdditionalSaveData: each part of `Pose` that is a list of + // three numbers, the others staying at their defaults. + if let Some(pose) = tag.get("Pose") { + for (rotation, key) in a.pose.iter_mut().zip(ArmorStand::POSE_KEYS) { + if let Some(Tag::List(values)) = pose.get(key) + && values.len() == 3 + { + for (r, v) in rotation.iter_mut().zip(values) { + *r = float(Some(v)).unwrap_or(0.0) as f32; + } + } + } + } Some(a) } /// A boat entity (`minecraft:_boat`, `minecraft:bamboo_chest_raft`...): @@ -2201,6 +2286,7 @@ mod tests { health: 2, fire_ticks: 73, thrower: Some([5, 6, 7, 8]), + target: None, id: 7, stack: ItemStack { item: Arc::from("minecraft:diamond_pickaxe"), diff --git a/crates/horizon-client/src/first_person.rs b/crates/horizon-client/src/first_person.rs index 0735ce2ba..12c97dfa0 100644 --- a/crates/horizon-client/src/first_person.rs +++ b/crates/horizon-client/src/first_person.rs @@ -26,6 +26,13 @@ pub enum ItemPose { Bow { ticks_used: f32, }, + /// A spear being charged (`ItemUseAnimation.SPEAR`): the time held and + /// the ticks since its last hit's feedback. + Spear { + kinetic: crate::spear::Kinetic, + time_held: f32, + ticks_since_hit: f32, + }, Crossbow { ticks_used: Option, charge_duration: f32, @@ -69,6 +76,16 @@ pub fn item_pose(left: bool, inverse_height: f32, attack: f32, pose: ItemPose) - if matches!(pose, ItemPose::Using) { return m; } + // The spear's own place in the hand, without the equip height. + if let ItemPose::Spear { + kinetic, + time_held, + ticks_since_hit, + } = pose + { + return Mat4::from_translation(Vec3::new(invert * 0.56, -0.52, -0.72)) + * crate::spear::first_person_use(&kinetic, ticks_since_hit, time_held, !left); + } if matches!(pose, ItemPose::SpinAttack) { return m * Mat4::from_translation(Vec3::new(invert * -0.4, 0.8, 0.3)) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2c3eeed39..c84000fe5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -18,11 +18,14 @@ mod boats; mod books; mod bossbars; mod breezes; +mod brush; mod bundles; mod campfire; mod campfire_douse; mod cartography; +mod cat_spawner; mod chat; +mod chiseled_bookshelf; mod client_ambient; mod clipboard; mod combat; @@ -34,6 +37,7 @@ mod consume; mod control; mod copper_golems; mod creaking; +mod creative_hotbar; mod creatures; mod crossbow; pub(crate) mod cushions; @@ -128,9 +132,11 @@ mod packs; mod pad; mod pad_menu; mod paintings; +mod pandas; mod passengers; mod persist; mod perspective; +mod pick_entity; mod pickups; mod piglins; mod piston_push; @@ -144,6 +150,7 @@ mod recipe_book; mod remote; mod remote_chunks; mod remote_mob_data; +mod remote_mob_particles; mod remote_mob_use; mod remote_objects; mod remote_projectiles; @@ -164,9 +171,11 @@ mod server_packs; mod server_travel; mod shader_packs; mod shield; +mod shoulders; mod sign_edit; mod sniffers; mod spawner; +mod spear; mod spill; mod startup_menu; mod station_control; @@ -572,12 +581,19 @@ struct GameLevel<'w> { player_collision: Option, /// Minecart boxes (detector rails). cart_boxes: Vec<([f64; 3], [f64; 3])>, + /// The item frames a comparator reads through a conductor. + item_frames: &'w [horizon_client::entities::ItemFrame], /// Each minecart's kind and comparator signal, in `cart_boxes` order. cart_signals: Vec<(minecarts::CartKind, i32)>, /// Arrow and thrown trident boxes (wooden buttons). arrow_boxes: Vec<([f64; 3], [f64; 3])>, /// The other entities that keep blocks from being placed into them. blockers: Blockers<'w>, + /// Item entities, experience orbs and projectiles, which trigger plates and + /// tripwires but never keep a block from being placed. + dropped: &'w [ItemEntity], + orbs: &'w [ExperienceOrb], + projectiles: &'w [horizon_client::projectiles::Projectile], biomes: &'w Biomes, seed: i64, behaviours: &'w Behaviours, @@ -652,6 +668,53 @@ impl EntityObstructionWorld for BuildingObstruction { } } impl GameLevel<'_> { + /// The mobs that trigger plates and tripwires: living entities that don't + /// ignore block triggers (`Entity.isIgnoringBlockTriggers`: bats; armor + /// stands are not in `mobs`). + fn mob_trigger_boxes(&self) -> impl Iterator + '_ { + self.blockers + .mobs + .iter() + .filter(|m| !m.removed && m.species() != horizon_client::mobs::Species::Bat) + .map(Mob::bounds) + } + /// The non-living entities that trigger plates and tripwires (boats, + /// crystals, primed TNT, falling blocks, item entities, experience orbs and + /// projectiles). + fn other_trigger_boxes(&self) -> impl Iterator + '_ { + let b = self.blockers; + let square = |p: Vec3, size: f64| { + Aabb::new( + Vec3::new(p.x - size / 2.0, p.y, p.z - size / 2.0), + Vec3::new(p.x + size / 2.0, p.y + size, p.z + size / 2.0), + ) + }; + b.boats + .iter() + .map(boats::Boat::bounds) + .chain(b.crystals.iter().map(|c| { + // EntityType.END_CRYSTAL: 2 x 2. + let p = c.position; + Aabb::new( + Vec3::new(p.x - 1.0, p.y, p.z - 1.0), + Vec3::new(p.x + 1.0, p.y + 2.0, p.z + 1.0), + ) + })) + .chain(b.tnts.iter().map(tnt::PrimedTnt::bounds)) + .chain( + b.falling + .iter() + .map(|f| horizon_client::falling_block::bounds(f.position)), + ) + .chain(self.dropped.iter().map(ItemEntity::bounds)) + // EntityType.EXPERIENCE_ORB: 0.5 x 0.5. + .chain(self.orbs.iter().map(move |o| square(o.position, 0.5))) + .chain( + self.projectiles + .iter() + .map(move |p| square(p.position, p.kind.size())), + ) + } /// `DetectorRailBlock.getAnalogOutputSignal`: a powered rail reads the /// minecart on it, a command block cart first (its success count, which /// is 0 here), else the first container cart's fullness. @@ -741,7 +804,7 @@ impl LevelAccess for GameLevel<'_> { &self, pos: BlockPos, state: BlockStateId, - _direction: Direction, + direction: Direction, ) -> i32 { if let Some(s) = self.registry.state(state) && s.name == "minecraft:detector_rail" @@ -774,8 +837,27 @@ impl LevelAccess for GameLevel<'_> { if let Some(signal) = books::lectern_signal(self.world, pos) { return signal; } + if let Some(signal) = + machines::shelf_signal(self.world, self.registry, state, pos, direction) + { + return signal; + } machines::container_signal(self.world, self.behaviours, self.items, self.registry, pos) } + fn item_frame_analog_output(&self, pos: BlockPos, facing: Direction) -> Option { + let mut frames = self + .item_frames + .iter() + .filter(|f| f.pos == [pos.x, pos.y, pos.z] && f.facing == facing as u8); + let frame = frames.next().filter(|_| frames.next().is_none())?; + // ItemFrame.getAnalogOutput. + Some( + frame + .item + .as_ref() + .map_or(0, |_| i32::from(frame.rotation % 8) + 1), + ) + } fn block_entity_signal( &self, pos: BlockPos, @@ -947,8 +1029,9 @@ impl LevelAccess for GameLevel<'_> { self.tickets.block_ticking(chunk.x, chunk.z) && ticking_chunk(self.world, chunk.x, chunk.z) } /// Entities that trigger pressure plates, tripwires, detector rails and - /// wooden buttons: the players (the host and the LAN guests, mobs) and - /// the minecarts, and for `EntityQuery::Arrows` the arrows. + /// wooden buttons: the players (the host and the LAN guests), the mobs, + /// the minecarts and the other entities that don't ignore block triggers, + /// and for `EntityQuery::Arrows` the arrows. fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize { let hit = |(lo, hi): &([f64; 3], [f64; 3])| { area.intersects(Aabb::new( @@ -957,6 +1040,16 @@ impl LevelAccess for GameLevel<'_> { )) }; let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count(); + let mobs = || { + self.mob_trigger_boxes() + .filter(|b| area.intersects(*b)) + .count() + }; + let others = || { + self.other_trigger_boxes() + .filter(|b| area.intersects(*b)) + .count() + }; let arrows = || self.arrow_boxes.iter().filter(|b| hit(b)).count(); let players = || { self.player_box @@ -968,8 +1061,8 @@ impl LevelAccess for GameLevel<'_> { match query { EntityQuery::Minecart => carts(), EntityQuery::Arrows => arrows(), - EntityQuery::Mobs => players(), - EntityQuery::Everything => players() + carts(), + EntityQuery::Mobs => players() + mobs(), + EntityQuery::Everything => players() + carts() + mobs() + others(), } } fn emit(&mut self, event: LevelEvent) { @@ -1450,6 +1543,9 @@ struct Game<'a> { spawn_spiral: horizon_client::world_spawn::ChunkSpiral, /// A new player's spawn search, while its candidates' chunks load. player_spawn: Option, + /// Chunks a respawn search waits for this tick, kept loading beside the + /// player's own (taken by `update_world`). + spawn_wait: Vec<(i32, i32)>, mobs: Vec, creatures: creatures::Creatures, sculk: sculk::SculkState, @@ -1484,6 +1580,9 @@ struct Game<'a> { armor: [Option; 4], /// The off hand (Inventory slot 40, saved as slot 150; menu slot 504 here). offhand: Option, + /// `ItemStack.popTime` of the nine hotbar stacks, then the off hand: set to 5 + /// when a slot gains items, counted down each tick. + hotbar_pop: [u8; 10], /// The hand an item use acts with (`InteractionHand`): the off hand only /// for its turn in `use_item` and while its item is being used. hand: Hand, @@ -1536,8 +1635,12 @@ struct Game<'a> { /// The head of the bed while sleeping; the visual timer also survives waking. sleeping: Option<[i32; 3]>, sleep_timer: u32, + /// `SleepStatus`'s active and sleeping players at the last announcement. + sleep_seen: (i64, i64), dim: Dim, world_root: PathBuf, + /// The world is superflat (`ServerLevel.isFlat`, for every dimension). + world_flat: bool, /// A player carried through a portal, re-placed once the destination loads. travelling: Option<(PlayerMotion, Vec3)>, /// A server's players on their way to another level, each waiting for @@ -1739,6 +1842,9 @@ struct Game<'a> { guest_use: Option, /// Level events of this tick for the guests, and the guest acting now. lan_events: Vec<(i32, [i32; 3], i32, Option)>, + /// Jukebox level events 1010 (song name) and 1011 (`None`) for the guests; + /// the song's network id is only known once the hub is in hand. + lan_songs: Vec<([i32; 3], Option)>, lan_cushion_breaks: Vec<(horizon_world::registry::BlockStateId, [f64; 3])>, /// Block events (position, b0, b1, state) and entity events (id, event, /// position) for the guests. @@ -1746,6 +1852,18 @@ struct Game<'a> { lan_entity_events: Vec<(i32, i8, [f64; 3])>, /// Successful crits (attacking guest, hit entity), queued while the hub is taken. lan_critical_hits: Vec<(Option, i32, bool)>, + /// Spear stabs that landed (the stabbing guest), queued while the hub is + /// taken: `broadcastEntityEvent(player, 2)`. + lan_kinetic_hits: Vec>, + /// `LivingEntity.recentKineticEnemies`: when each player (a guest, or the + /// window's own) last stabbed each entity this use. + stabbed: HashMap<(Option, u32), i64>, + /// The movement a guest's client reported this tick + /// (`ServerPlayer.getKnownMovement`), for their turn. + known_movement: Vec3, + /// `LivingEntity.lastKineticHitFeedbackTime` of the entities that felt a + /// spear's hit (`spear::OWN` is this window's player), in game time. + kinetic_feedback: HashMap, /// Global level events for every guest (`ServerLevel.globalLevelEvent`). lan_global_events: Vec<(i32, [i32; 3], i32)>, /// `ContainerOpenersCounter`: how many players (the host and the guests) @@ -1789,6 +1907,8 @@ struct Game<'a> { boss_overlay: horizon_client::boss_overlay::BossOverlay, exec: commands::execute::ExecState, rand_sequences: horizon_client::random_sequences::RandomSequences, + /// `BrushableBlockEntity`'s brush counts of the blocks being brushed. + brushing: brush::Brushing, border: horizon_client::worldborder::WorldBorder, /// `WorldBorderRenderer` and its render state. border_renderer: horizon_client::border_render::BorderRenderer, @@ -2130,6 +2250,7 @@ impl Game<'_> { .as_ref() .is_some_and(|s| &*s.item == "minecraft:leather_boots"); let freeze_immune = self.wears_freeze_immune(); + let burn_immune = self.wears_burn_from_stepping_immunity(); let Some(player) = self.player.as_mut() else { return; }; @@ -2142,6 +2263,7 @@ impl Game<'_> { let _ = player.set_sleeping(sleeping); player.leather_boots = leather_boots; player.freeze_immune = freeze_immune; + player.burn_from_stepping_immune = burn_immune; player.fluids.fast_lava = self.dim == Dim::Nether; } fn held_slot(&self) -> usize { @@ -2385,6 +2507,7 @@ impl Game<'_> { health: 5, fire_ticks: 0, thrower: None, + target: None, id: self.next_entity, stack, position: p, @@ -2608,6 +2731,7 @@ impl Game<'_> { ], ); let feet = [p.position.x, p.position.y, p.position.z]; + let own = self.level.ensure_player_uuid(); let mut kept = Vec::with_capacity(items.len()); for mut item in items { let b = item.bounds(); @@ -2617,7 +2741,8 @@ impl Game<'_> { && b.max_position().y > min[1] && b.min_position().z < max[2] && b.max_position().z > min[2]; - if touching && item.pickup_delay == 0 { + // ItemEntity.playerTouch: no pickup delay, and the target (if any) is this player. + if touching && item.pickup_delay == 0 && item.target.is_none_or(|t| t == own) { let before = item.stack.count; let kind = item.stack.item.clone(); match self.give(item.stack.clone()) { @@ -2751,9 +2876,13 @@ impl Game<'_> { }; let mut level = GameLevel { cart_boxes, + item_frames: &self.item_frames, cart_signals, arrow_boxes, blockers, + dropped: &self.dropped, + orbs: &self.orbs, + projectiles: &self.creatures.projectiles, world: &mut self.world, facts: self.res.facts(), collision: self.collision, @@ -2897,7 +3026,8 @@ impl Game<'_> { .collect(); // Entity.checkInsideBlocks for the plates, tripwires, detector rails and // buttons under the players (the host and the LAN guests), the minecarts - // and the arrows. + // and the arrows (the mobs and other entities are added in `with_level` + // below). let mut inside = Vec::new(); let guests = self.lan_block_trigger_boxes(); let boxes = self @@ -2976,7 +3106,21 @@ impl Game<'_> { } } self.with_level(|b, level, ticks| { - for pos in inside { + // The mobs and the other entities (items, orbs, projectiles...) too. + let mut touched: Vec = Vec::new(); + for bounds in level.mob_trigger_boxes().chain(level.other_trigger_boxes()) { + let (lo, hi) = (bounds.min_position(), bounds.max_position()); + for x in (lo.x + 1e-7).floor() as i32..=(hi.x - 1e-7).floor() as i32 { + for y in (lo.y + 1e-7).floor() as i32..=(hi.y - 1e-7).floor() as i32 { + for z in (lo.z + 1e-7).floor() as i32..=(hi.z - 1e-7).floor() as i32 { + touched.push(BlockPos::new(x, y, z)); + } + } + } + } + touched.sort_unstable_by_key(|p| (p.x, p.y, p.z)); + touched.dedup(); + for pos in inside.into_iter().chain(touched) { b.entity_inside(level, ticks, pos); } for (pos, on_ground, feet_y) in standing { @@ -3093,6 +3237,12 @@ impl Game<'_> { data, } => self.sculk_charge_event(pos, data), LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos), + // LevelEventHandler 1010 and 1011: the parrots nearby dance or stop. + LevelEvent::LevelEvent { + id: id @ (1010 | 1011), + pos, + .. + } => self.notify_record_playing([pos.x, pos.y, pos.z], id == 1010), // LevelEventHandler 2019 and 2020: the crack on a face of the // block being mined, with its hit sound for 2020. LevelEvent::LevelEvent { @@ -3103,6 +3253,11 @@ impl Game<'_> { let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize]; self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020); } + LevelEvent::LevelEvent { + id: 3008, + pos, + data, + } => self.brush_complete_event([pos.x, pos.y, pos.z], data), LevelEvent::LevelEvent { id: 2004, pos, .. } => { self.spawner_burst([pos.x, pos.y, pos.z]) } @@ -3132,6 +3287,11 @@ impl Game<'_> { pos, data, } => self.consume_teleport_particles([pos.x, pos.y, pos.z], data), + LevelEvent::LevelEvent { + id: 2018, + pos, + data, + } => self.enderman_teleport_particles([pos.x, pos.y, pos.z], data), LevelEvent::LevelEvent { id: 2003, pos, .. } => { self.eye_break_particles([pos.x, pos.y, pos.z]); } @@ -3359,6 +3519,11 @@ impl Game<'_> { kind: "command_block", .. } => self.command_block_tick(pos), + LevelEvent::BlockEvent { + pos, + kind: "brushable", + .. + } => self.brushable_tick([pos.x, pos.y, pos.z]), LevelEvent::BlockEvent { pos, kind: "hatch", .. } => { @@ -3881,6 +4046,20 @@ impl Game<'_> { ); } } + // IceBlock.playerDestroy: the ice melts back into water (the + // #prevents_ice_melting tool tag holds only silk touch). + let prevents_melting = held + .as_ref() + .is_some_and(|h| h.enchantment_level("minecraft:silk_touch") > 0); + self.with_level(|b, level, ticks| { + b.ice_destroyed_by_player( + level, + ticks, + BlockPos::new(pos[0], pos[1], pos[2]), + broken, + prevents_melting, + ); + }); } self.pending.clear(pos); self.process_level_events()?; @@ -3989,10 +4168,20 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.use_golem_statue(hit.pos, held.as_ref()) { + self.swing_arm(); + return Ok(true); + } if self.use_jukebox(hit.pos, held.as_ref()) { self.swing_arm(); return Ok(true); } + if let Some(swings) = self.use_chiseled_bookshelf(hit, held.as_ref()) { + if swings { + self.swing_arm(); + } + return Ok(true); + } if self.use_composter(hit.pos, held.as_ref()) { self.swing_arm(); return Ok(true); @@ -4115,11 +4304,19 @@ impl Game<'_> { { return Ok(true); } + // BrushItem.useOn: brushing starts on the block aimed at (CONSUME). + if block_hit.is_some() && &*stack.item == "minecraft:brush" { + if self.using.is_none() { + self.using = Some((self.held_slot(), 0)); + } + return Ok(true); + } if !on_block && (self.raise_shield(self.held_slot()) || self.use_fishing_rod(&stack) || self.use_crossbow(&stack) || self.use_trident(&stack) + || self.use_spear(&stack) || self.boost_firework(&stack) || self.use_empty_map(&stack) || self.use_book(&stack) @@ -4155,6 +4352,7 @@ impl Game<'_> { || self.place_minecart(hit, &stack) || self.place_painting(hit, &stack) || self.place_item_frame(hit, &stack) + || self.use_lodestone_compass(hit, &stack) || self.place_armor_stand(hit, &stack) || self.place_cushion(hit, &stack) || self.place_end_crystal(hit, &stack)) @@ -4205,6 +4403,7 @@ impl Game<'_> { return Ok(true); }; let target = [pos.x, pos.y, pos.z]; + let state = self.apply_item_block_state(target, state, &stack)?; self.mod_block_event(target, state, true); if let Some(entity) = BlockEntity::for_block(&self.res.facts().get(state).name) { let key = (target[0], target[1], target[2]); @@ -4395,6 +4594,12 @@ impl Game<'_> { self.using = Some((slot, ticks + 1)); return; } + // ItemStack.onUseTick: a spear stabs what its speed allows, until released. + if horizon_client::spear::Kinetic::of(&stack.item).is_some() { + self.spear_tick(&stack, ticks); + self.using = Some((slot, ticks + 1)); + return; + } if &*stack.item == "minecraft:spyglass" { // SpyglassItem.USE_DURATION, then finishUsingItem. if ticks + 1 >= 1200 { @@ -4406,6 +4611,10 @@ impl Game<'_> { } return; } + if &*stack.item == "minecraft:brush" { + self.tick_brush(slot, ticks); + return; + } let Some(consumable) = info.consumable.as_ref() else { self.using = None; return; @@ -4661,11 +4870,22 @@ impl Game<'_> { if !(-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) { return Ok(()); } - // WorldSpawn: the stored column, lifted onto its current surface. - let y = self - .land_column(s.x.floor() as i32, s.z.floor() as i32) - .map_or(s.y, f64::from); - Vec3::new(s.x, y.max(s.y), s.z) + let column = [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]; + if self.level.world_spawn == Some(column) { + // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder + // around the world spawn, not its exact column; its candidates' + // chunks load first. + let Some(feet) = self.find_player_spawn(column)? else { + return Ok(()); + }; + feet + } else { + // A spawnpoint: the stored column, lifted onto its current surface. + let y = self + .land_column(column[0], column[2]) + .map_or(s.y, f64::from); + Vec3::new(s.x, y.max(s.y), s.z) + } }; let mut player = PlayerMotion::new(self.motion, feet)?; player.yaw = self.yaw; @@ -4689,6 +4909,7 @@ impl Game<'_> { self.screen = Screen::Dead; self.ui.died_at = Some(Instant::now()); self.ui.death_text = None; + self.ui.death_confirm = None; self.capture(false); } self.previous_position = feet; @@ -4889,15 +5110,13 @@ impl Game<'_> { for event in events { match event { MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet), - MotionEvent::Emission { - state, in_water, .. - } => { + MotionEvent::Emission { state, muffled, .. } => { let sounds = self.res.facts().get(state).sounds.clone(); // Entity.playStepSound: the block's step sound at 0.15 volume, // muffled under the swim sound in water. Whether it plays is // Player.getMovementEmission's call (shift on the ground), // not the pose: a forced crouch still steps. - let (volume, pitch) = if in_water { + let (volume, pitch) = if muffled { (sounds.volume * 0.05, sounds.pitch * 0.8) } else { (sounds.volume * 0.15, sounds.pitch) @@ -5030,7 +5249,13 @@ impl Game<'_> { } self.powder_snow_fire()?; self.rain_extinguish_in_frame(); + // LivingEntity.baseTick: a new block position runs the worn + // enchantments' location_changed effects (frost walker) on the server. + if self.remote.is_none() { + self.location_changed_effects(before.2, before.0); + } self.tick_totem(); + self.handle_shoulder_entities(); let Some(player) = self.player.as_mut() else { return Ok(()); }; @@ -5044,6 +5269,9 @@ impl Game<'_> { let feet = [player.position.x, player.position.y, player.position.z]; let at = [feet[0], feet[1] + 1.32, feet[2]]; let killer = self.combat_killer_kind(); + // Player.die: the dimension and block of the death. + self.level.last_death = + Some((self.dim.id().to_owned(), feet.map(|v| v.floor() as i32))); self.death_message(); // ServerPlayer.die: deaths, and the time-since counters restart. self.stats.custom("deaths", 1); @@ -5125,6 +5353,7 @@ impl Game<'_> { horizon_client::spans::time("tick_thunder", || self.tick_thunder()); horizon_client::spans::time("tick_lecterns", || self.tick_lecterns()); horizon_client::spans::time("tick_maps", || self.tick_maps()); + self.tick_lodestone_compasses(); horizon_client::spans::time("tick_bolts", || self.tick_bolts()); horizon_client::spans::time("tick_fishing", || self.tick_fishing()); horizon_client::spans::time("tick_tridents", || self.tick_tridents()); @@ -5152,6 +5381,7 @@ impl Game<'_> { self.tick_friends(); horizon_client::spans::time("tick_hand", || self.tick_hand()); horizon_client::spans::time("tick_sleep", || self.tick_sleep()); + self.announce_sleep_status(); horizon_client::spans::time("tick_portal", || self.tick_nether_portal())?; if running { horizon_client::spans::time("tick_end", || self.tick_end())?; @@ -5523,7 +5753,10 @@ impl Game<'_> { let decorations = hud_overlays::ItemDecorations { count: stack.count, count_text, - bar: hud_overlays::damage_bar(stack.damage as i32, max_damage), + // BundleItem overrides the bar with its fullness. + bar: horizon_client::bundle::Contents::of(self.res.items(), stack) + .map(|c| c.bar()) + .unwrap_or_else(|| hud_overlays::damage_bar(stack.damage as i32, max_damage)), cooldown: self.cooldowns.percent(&cooldown, partial), }; let mut draws = vec![hud_layout::GuiDraw::Push(vec![ @@ -5590,12 +5823,12 @@ impl Game<'_> { // The ToastManager draws over every screen: a server's packs // download while the connection screen shows. if self.remote_overlay(&mut batch) { - self.draw_pack_toasts(&mut batch); + self.draw_pack_toasts(&mut batch, false); return batch; } if let Some(reason) = self.loading_reason() { self.draw_level_loading(&mut batch, reason); - self.draw_pack_toasts(&mut batch); + self.draw_pack_toasts(&mut batch, false); return batch; } // Hud.extractRenderState: F1 (keyToggleGui) hides camera overlays, the @@ -5604,6 +5837,9 @@ impl Game<'_> { let spectator = self.spectator(); let (wi, hi) = (w as i32, h as i32); let show_hud = !self.ui.hide_gui; + // max(Hud.leftHeight, Hud.rightHeight) after the bars: the item name and + // the action bar sit above it. + let mut bar_height = 39; if show_hud { self.draw_spyglass(&mut batch); // Hud.extractCrosshair / extractItemHotbar / extractPlayerHealth / @@ -5625,12 +5861,17 @@ impl Game<'_> { hud_layout::paint(&mut batch, &self.gui.atlas, &draws); } if !spectator { + let partial = self.clock.fraction() as f32; let inputs = hud_layout::HotbarInputs { selected: self.selected as i32, right_handed: !self.settings.main_hand_left, offhand: self.offhand.is_some(), - slots: std::array::from_fn(|i| self.inventory[i].as_ref().map(|_| 0.0)), - offhand_pop: 0.0, + slots: std::array::from_fn(|i| { + self.inventory[i] + .as_ref() + .map(|_| (f32::from(self.hotbar_pop[i]) - partial).max(0.0)) + }), + offhand_pop: (f32::from(self.hotbar_pop[9]) - partial).max(0.0), attack: (indicator == 2).then_some(strength), }; let draws = hud_layout::hotbar(wi, hi, &inputs); @@ -5677,6 +5918,8 @@ impl Game<'_> { contextual == ContextualBar::JumpableVehicle, ) }; + // Without the survival bars only the mount's hearts raise it. + bar_height = 39 + 10 * ((vehicle_hearts + 9) / 10); if contextual == ContextualBar::Locator { let (sprite, [x, y, w, h]) = horizon_client::locator_bar::background(wi, hi); horizon_client::ui::nine_slice( @@ -5715,17 +5958,9 @@ impl Game<'_> { } else { hud_layout::HeartKind::Normal }; - let eye = p.position.y + f64::from(p.dimensions.eye_height); - let under_water = self - .res - .facts() - .get(self.world.block( - p.position.x.floor() as i32, - eye.floor() as i32, - p.position.z.floor() as i32, - )) - .fluid - == horizon_client::blocks::Fluid::Water; + // Hud.extractAirBubbles: `isEyeInFluidMatching`, so the eyes are below + // the surface, not merely in the water block. + let under_water = p.is_eye_in_fluid(horizon_client::motion::WATER); let inputs = hud_layout::HealthInputs { tick: self.ticks as i32, millis: self.started.elapsed().as_millis() as i64, @@ -5750,20 +5985,37 @@ impl Game<'_> { }; let draws = self.health_hud.layout(&inputs, wi, hi); hud_layout::paint(&mut batch, atlas, &draws); + bar_height = self + .health_hud + .left_height + .max(self.health_hud.right_height); + // Hud.playAirBubblePoppedSound: Player.playSound (PLAYERS), heard + // by this client only. + if let Some((volume, pitch)) = self.health_hud.bubble_pop_sound.take() { + let at = [p.position.x, p.position.y, p.position.z]; + let players = horizon_client::settings::SOUND_SOURCES + .iter() + .position(|s| *s == "player") + .unwrap_or(0); + let capture = self.audio.capture.take(); + self.audio + .play_on(players, "ui.hud.bubble_pop", Some(at), volume, pitch); + self.audio.capture = capture; + } } if contextual == ContextualBar::Locator { let draws = self.locator_bar_draws(wi, hi); hud_layout::paint(&mut batch, &self.gui.atlas, &draws); } if !spectator { - self.draw_selected_name(&mut batch, !self.creative); + self.draw_selected_name(&mut batch, bar_height, !self.creative); } } // Hud.extractSleepOverlay: over all health/food bars, under titles and chat. let draws = hud_overlays::sleep_overlay(wi, hi, self.sleep_timer as i32); hud_layout::paint(&mut batch, &self.gui.atlas, &draws); if show_hud { - self.draw_titles(&mut batch); + self.draw_titles(&mut batch, bar_height); self.draw_scoreboard(&mut batch); self.draw_subtitles(&mut batch); } @@ -5817,8 +6069,9 @@ impl Game<'_> { Screen::Playing | Screen::Options | Screen::Win => {} } self.draw_saving_indicator(&mut batch); - self.draw_toasts(&mut batch); - self.draw_pack_toasts(&mut batch); + // ToastManager.extractRenderState: F1 hides the toasts too. + self.draw_toasts(&mut batch, !show_hud); + self.draw_pack_toasts(&mut batch, !show_hud); self.remote_hud(&mut batch); self.draw_sign_editor(&mut batch); self.draw_book(&mut batch); @@ -5876,7 +6129,8 @@ impl Game<'_> { | BlockEntity::EndGateway(_) | BlockEntity::Skull(_) | BlockEntity::DaylightDetector - | BlockEntity::Campfire(_), + | BlockEntity::Campfire(_) + | BlockEntity::ChiseledBookshelf(_), ) => {} None => { v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i)); @@ -6149,7 +6403,8 @@ impl Game<'_> { | BlockEntity::EndGateway(_) | BlockEntity::Skull(_) | BlockEntity::DaylightDetector - | BlockEntity::Campfire(_), + | BlockEntity::Campfire(_) + | BlockEntity::ChiseledBookshelf(_), ) => {} None if self.mount_active() => self.draw_mount_background(batch, ox, oy), None => { @@ -8070,8 +8325,7 @@ impl Game<'_> { } /// `Player.getAttackStrengthScale(0.5)`. fn attack_strength_scale(&self) -> f32 { - let speed = self.attack_item_info().map_or(0.0, |i| i.attack_speed); - let delay = 20.0 / (4.0 + speed).max(0.1); + let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0) } /// `Player.isSweepAttack`: a charged, grounded sword hit below the movement limit. @@ -8108,18 +8362,9 @@ impl Game<'_> { self.audio .play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0); } - /// The damage and knockback part of `Player.doSweepAttack` after a sweep - /// hit on the mob at `target`: every other living mob in its box grown by - /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative - /// too), but the player's allies - /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the - /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4 - /// along the player's yaw. - pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) { - let Some(p) = self.player.as_ref() else { - return; - }; - let from = [p.position.x, p.position.y, p.position.z]; + /// What `Player.doSweepAttack` deals before the target's enchantment + /// bonus and the attack strength: `1 + sweeping_damage_ratio * baseDamage`. + pub(super) fn sweep_base_damage(&self, scale: f32) -> f32 { // `baseDamage` of `Player.attack` before a critical hit (a sweep has // none) and the enchantments: the attack damage attribute with the // strength and weakness effects, scaled by the attack strength. @@ -8135,7 +8380,21 @@ impl Game<'_> { "minecraft:sweeping_damage_ratio", ) .clamp(0.0, 1.0) as f32; - let sweep_damage = 1.0 + ratio * base_damage; + 1.0 + ratio * base_damage + } + /// The damage and knockback part of `Player.doSweepAttack` after a sweep + /// hit on the mob at `target`: every other living mob in its box grown by + /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative + /// too), but the player's allies + /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the + /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4 + /// along the player's yaw. + pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) { + let Some(p) = self.player.as_ref() else { + return; + }; + let from = [p.position.x, p.position.y, p.position.z]; + let sweep_damage = self.sweep_base_damage(scale); let hit_box = self.mobs[target] .bounds() .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0)); @@ -8170,6 +8429,10 @@ impl Game<'_> { .insert(self.mobs[i].id, self.lan_acting); } } + // `getEntitiesOfClass(LivingEntity.class)` takes the other players too. + let mut sweep = self.player_sweep(sweep_damage, scale); + sweep.hit_box = hit_box; + self.sweep_other_players(sweep); } /// `Player.attack`'s sounds when a vehicle takes the hit (it always does, /// and can't be hit critically): knockback when sprinting at full @@ -8453,24 +8716,34 @@ impl Game<'_> { } /// SkyRenderer.renderSunMoonAndStars: bodies on a frame rotated Y -90 then X by angle. /// Returns the sun and moon quads, and the stars' frame and brightness - /// (the renderer keeps their geometry, built once). + /// (the renderer keeps their geometry, built once). The bodies fade with + /// the rain (`rainBrightness = 1 - rainLevel`, their colour's alpha). fn celestial_geometry( &self, sky: &horizon_client::environment::Sky, + rain: f32, ) -> (Vec, Option<(glam::Mat4, f32)>) { + let body_color = + 0x00FF_FFFF | (((1.0 - rain).clamp(0.0, 1.0) * 255.0).round() as u32) << 24; let mut out = Vec::new(); let atlas = &self.gui.atlas; let frame = |angle: f32| { glam::Mat4::from_rotation_y((-90.0f32).to_radians()) * glam::Mat4::from_rotation_x(angle.to_radians()) }; - let mut body = |name: &str, angle: f32, size: f32, color: u32| { + let mut body = |name: &str, angle: f32, size: f32, moon: bool| { let Some(r) = atlas.sprites.get(name).copied() else { return; }; let m = frame(angle); let corners = [(-size, -size), (size, -size), (size, size), (-size, size)]; - let uv = [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]]; + // buildCelestialQuad (sun) vs buildMoonPhases: the moon's UVs run + // the other way round. + let uv = if moon { + [[r.u1, r.v1], [r.u0, r.v1], [r.u0, r.v0], [r.u1, r.v0]] + } else { + [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]] + }; for ((x, z), uv) in corners.iter().zip(uv) { let p = m.transform_point3(glam::Vec3::new(*x, 100.0, *z)); out.push(Vertex { @@ -8478,19 +8751,14 @@ impl Game<'_> { pos: p.to_array(), uv, layer: 2, - color, + color: body_color, light: 0, glint_uv: [0.0, 0.0], }); } }; - body( - "environment/celestial/sun", - sky.sun_angle, - 30.0, - 0xFFFF_FFFF, - ); + body("environment/celestial/sun", sky.sun_angle, 30.0, false); let phases = [ "full_moon", "waning_gibbous", @@ -8506,7 +8774,7 @@ impl Game<'_> { &format!("environment/celestial/moon/{phase}"), sky.moon_angle, 20.0, - 0xFFFF_FFFF, + true, ); // SkyRenderer.renderStars: the static star buffer on the same frame. let stars = @@ -8663,6 +8931,7 @@ impl Game<'_> { book.to_be_displayed.retain(|r| index.contains(r)); self.dim = dim; self.world_root = save_root.clone(); + self.world_flat = horizon_client::save::WorldGen::read(&save_root).is_some_and(|w| w.flat); self.block_ticks = Ticks::new(self.level.seed as i32); self.tick_chunks.clear(); self.clear_entities(); @@ -8681,6 +8950,7 @@ impl Game<'_> { self.spawn_spiral = Default::default(); self.player_spawn = None; self.creatures.reset_trader(); + self.creatures.cat_tick = 0; self.portals = Default::default(); self.experience = Experience { level: self.level.xp_level, @@ -10200,7 +10470,17 @@ impl Game<'_> { let ticks_used = owner.use_duration as f32 - (owner.use_item_remaining_ticks as f32 - a + 1.0); use horizon_client::first_person::ItemPose; + // ItemUseAnimation.SPEAR. + let spear = using + .then(|| horizon_client::spear::Kinetic::of(&stack.item)) + .flatten() + .map(|kinetic| ItemPose::Spear { + kinetic, + time_held: ticks_used, + ticks_since_hit: self.kinetic_hit_ticks(a), + }); let pose = match &*stack.item { + _ if let Some(pose) = spear => pose, "minecraft:bow" if using => ItemPose::Bow { ticks_used }, "minecraft:crossbow" => { let charged = stack.data().is_some_and(|d| !d.charged.is_empty()); @@ -10322,19 +10602,13 @@ impl Game<'_> { } } /// Whether precipitation at a column is snow (Biome.coldEnoughToSnow: - /// base temperature lowered above y 80) or none (no precipitation). + /// height adjusted temperature) or none (no precipitation). fn precipitation(&self, x: i32, y: i32, z: i32) -> Option { let chunk = self.world.chunks.get(&(x >> 4, z >> 4))?; - let b = self.res.biomes().get(chunk.biome(x, y, z)); - if !b.precipitation { - return None; - } - let t = if y > 80 { - b.temperature - (y - 80) as f32 * 0.05 / 40.0 - } else { - b.temperature - }; - Some(t < 0.15) + self.res + .biomes() + .get(chunk.biome(x, y, z)) + .snows_at(x, y, z) } /// `Level.isRainingAt`: it rains, the sky light is 15, nothing that stops /// motion is above, and the biome's precipitation there is rain. @@ -10439,11 +10713,29 @@ impl Game<'_> { rain.extend(snow_vertices); rain } + /// A translated message for the player the game acts for: `overlay` is + /// `sendOverlayMessage` (the action bar), else `sendSystemMessage` (chat). + /// A guest gets a packet, so its own client translates it. + fn tell_sleeper(&mut self, key: &str, fallback: &str, overlay: bool) { + if self.lan_acting.is_some() { + self.guest_packets + .push(horizon_protocol::packets::play::Clientbound::SystemChat( + horizon_protocol::packets::play::SystemChat { + content: horizon_protocol::text::translatable(key, &[]), + overlay, + }, + )); + } else if overlay { + self.message = Some((self.translate(key, fallback), Instant::now())); + } else { + self.system_message(horizon_client::text::Text::translate(key, &[])); + } + } /// ServerPlayer.startSleepInBed: in reach, not obstructed, night or thunder, /// and (outside creative) no monsters within 8 blocks; the bed becomes the /// respawn point either way. fn try_sleep(&mut self, pos: [i32; 3]) { - let Some(p) = self.player.as_ref() else { + let Some((position, yaw)) = self.player.as_ref().map(|p| (p.position, p.yaw)) else { return; }; let time = self.world.day_time.rem_euclid(24000); @@ -10466,15 +10758,16 @@ impl Game<'_> { // ServerPlayer.bedInRange / isReachableBedBlock: within 3 blocks // sideways and 2 vertically of the head or the foot. let reachable = |bed: [i32; 3]| { - (p.position.x - f64::from(bed[0]) - 0.5).abs() <= 3.0 - && (p.position.y - f64::from(bed[1])).abs() <= 2.0 - && (p.position.z - f64::from(bed[2]) - 0.5).abs() <= 3.0 + (position.x - f64::from(bed[0]) - 0.5).abs() <= 3.0 + && (position.y - f64::from(bed[1])).abs() <= 2.0 + && (position.z - f64::from(bed[2]) - 0.5).abs() <= 3.0 }; if !reachable(head) && !reachable(foot) { - self.message = Some(( - "You may not rest now; the bed is too far away".into(), - Instant::now(), - )); + self.tell_sleeper( + "block.minecraft.bed.too_far_away", + "You may not rest now; the bed is too far away", + true, + ); return; } // ServerPlayer.bedBlocked: Player.freeAt (not suffocating) for the @@ -10487,7 +10780,11 @@ impl Game<'_> { f.full_collision && f.solid_render }); if blocked { - self.message = Some(("This bed is obstructed".into(), Instant::now())); + self.tell_sleeper( + "block.minecraft.bed.obstructed", + "This bed is obstructed", + true, + ); return; } // In reach (bedInRange), day or night: setRespawnPosition( @@ -10496,9 +10793,16 @@ impl Game<'_> { // and finds where to stand up (findRespawnAndUseSpawnBlock). // Straw beds never set it (`straw_bed_rule`). if self.bed_sets_spawn(state) { - self.respawn_config = Some(respawn_anchor::RespawnConfig::wrapped( - self.dim, head, p.yaw, false, - )); + let config = respawn_anchor::RespawnConfig::wrapped(self.dim, head, yaw, false); + // ServerPlayer.setRespawnPosition: the chat message only when the + // point moved (`isSamePosition`). + let moved = self + .respawn_config + .is_none_or(|c| (c.dim, c.pos) != (config.dim, config.pos)); + self.respawn_config = Some(config); + if moved { + self.tell_sleeper("block.minecraft.set_spawn", "Respawn point set", false); + } // The fallback becomes the world spawn: a guest's is none of its // own, so it follows `setworldspawn`. self.spawn = if self.lan_acting.is_some() { @@ -10513,10 +10817,11 @@ impl Game<'_> { }; } if !night { - self.message = Some(( - "You can sleep only at night or during thunderstorms".into(), - Instant::now(), - )); + self.tell_sleeper( + "block.minecraft.bed.no_sleep", + "You can sleep only at night or during thunderstorms", + true, + ); return; } // Creative players skip the monster check (`!this.isCreative()`). @@ -10524,18 +10829,26 @@ impl Game<'_> { && self.mobs.iter().any(|m| { m.hostile() && m.alive() - && (m.position.x - p.position.x).abs() < 8.0 - && (m.position.y - p.position.y).abs() < 5.0 - && (m.position.z - p.position.z).abs() < 8.0 + && (m.position.x - position.x).abs() < 8.0 + && (m.position.y - position.y).abs() < 5.0 + && (m.position.z - position.z).abs() < 8.0 }); if monsters { - self.message = Some(( - "You may not rest now; there are monsters nearby".into(), - Instant::now(), - )); + self.tell_sleeper( + "block.minecraft.bed.not_safe", + "You may not rest now; there are monsters nearby", + true, + ); return; } - self.message = Some(("Respawn point set".into(), Instant::now())); + // ServerPlayer.startSleepInBed: a percentage above 100 cannot skip the night. + if self.ui.rules.int("players_sleeping_percentage") > 100 { + self.tell_sleeper( + "sleep.not_possible", + "No amount of rest can pass this night", + true, + ); + } self.stop_mining(); self.left = false; self.right = false; @@ -10558,7 +10871,9 @@ impl Game<'_> { fn tick_sleep(&mut self) { self.sleep_timer = tick_sleep_timer(self.sleep_timer, self.sleeping.is_some()); if let Some(head) = self.sleeping { - if self.keys.contains(&KeyCode::ShiftLeft) + // Vanilla has no Shift wake-up: the chat screen's capitals must + // not get the sleeper up. + if (self.screen != Screen::Chat && self.keys.contains(&KeyCode::ShiftLeft)) || self .player .as_ref() @@ -10595,6 +10910,8 @@ impl Game<'_> { self.wake_up(); } self.wake_guests(); + // SleepStatus.removeAllSleepers: waking everyone is not announced. + self.sleep_seen.1 = 0; } } fn creative_origin(batch: &HudBatch) -> (f32, f32) { @@ -11165,8 +11482,11 @@ impl Game<'_> { horizon_client::environment::apply_weather(&mut sky, rain, thunder); self.end_flash_sky(&mut sky, alpha); if self.flash > 0 && !self.settings.file.bool("hideLightningFlashes") { - // Lightning flash brightens the sky (LevelRenderer skyFlashTime). - sky.sky_color = [0.9, 0.9, 1.0]; + // ClientLevel's flash layer while skyFlashTime > 0: the sky colour + // moves 22% of the way to (0.8, 0.8, 1.0). + let flash = [0.8, 0.8, 1.0]; + sky.sky_color = + std::array::from_fn(|i| sky.sky_color[i] + (flash[i] - sky.sky_color[i]) * 0.22); sky.sky_light_factor = 1.0; } // FishingHookRenderer's line, then DebugRenderer: chunk borders and @@ -11305,7 +11625,7 @@ impl Game<'_> { && self.potions.effects.get("blindness").is_none() { // Camera.doesMobEffectBlockSky: no sun, moon or stars. - self.celestial_geometry(&sky) + self.celestial_geometry(&sky, rain) } else if self.dim == Dim::End && self.settings.horizon.sky { (self.end_flash_geometry(), None) } else { @@ -11731,7 +12051,7 @@ impl Game<'_> { | KeyCode::Digit9 if self.screen == Screen::Playing => { - self.selected = match key { + let slot = match key { KeyCode::Digit1 => 0, KeyCode::Digit2 => 1, KeyCode::Digit3 => 2, @@ -11742,6 +12062,15 @@ impl Game<'_> { KeyCode::Digit8 => 7, _ => 8, }; + // Minecraft.handleKeybinds: a creative player holding the load + // or save toolbar key loads or saves a toolbar instead (load + // first when both are held). + let load = self.mapped_key_down("key.loadToolbarActivator"); + if self.creative && (load || self.mapped_key_down("key.saveToolbarActivator")) { + self.hotbar_load_or_save(slot, load); + } else { + self.selected = slot; + } } _ => {} } @@ -11784,7 +12113,18 @@ impl Game<'_> { // Minecraft.pickBlockOrEntity -> the server's handlePickItemFromBlock: // the block's clone item, with its block entity's data on Ctrl in // creative, picked from the inventory (`pick_item`). - if let Some(hit) = self.pick() { + if let Some(entity) = self.pick_entity_hit() { + // handlePickItemFromEntity: the entity's pick result. + if let Some(stack) = entity.and_then(|id| self.entity_pick_result(id)) { + let infinite = self.creative; + horizon_client::pick_item::pick( + &mut self.inventory[..36], + &mut self.selected, + &stack, + infinite, + ); + } + } else if let Some(hit) = self.pick() { let include_data = self.creative && self.has_control_down(); if let Some(stack) = self.picked_stack(hit.pos, include_data) { let infinite = self.creative; @@ -11890,8 +12230,14 @@ impl Game<'_> { self.streaming.loading = self.options.execution_role.is_client() && self.loading_reason().is_some(); self.tick_pregen(); + let areas = self.streaming.extra.len(); + let waiting = std::mem::take(&mut self.spawn_wait); + self.streaming + .extra + .extend(waiting.into_iter().map(|chunk| (chunk, 0))); let (uploads, unloaded) = horizon_client::spans::time("streaming", || self.streaming.update(&mut self.world)); + self.streaming.extra.truncate(areas); if let Some(lod) = &mut self.lod { self.lod_observe .extend(uploads.iter().map(|(key, _)| (key.0, key.2))); @@ -12584,6 +12930,20 @@ impl ApplicationHandler for Game<'_> { _ => {} } } + // ConfirmScreen.keyPressed: Escape answers no, once its delay is over. + WindowEvent::KeyboardInput { event, .. } + if self.screen == Screen::Dead && self.ui.death_confirm.is_some() => + { + if event.state == ElementState::Pressed + && event.physical_key == PhysicalKey::Code(KeyCode::Escape) + && self + .ui + .death_confirm + .is_some_and(|t| t.elapsed().as_millis() >= 1000) + { + self.death_confirm_answer(false)?; + } + } // ConfirmScreen.keyPressed: Escape answers no. WindowEvent::KeyboardInput { event, .. } if self.link_prompt.is_some() => { if event.state == ElementState::Pressed @@ -13245,6 +13605,7 @@ impl<'a> Game<'a> { spawn_origin: None, spawn_spiral: Default::default(), player_spawn: None, + spawn_wait: Vec::new(), mobs: Vec::new(), creatures: Default::default(), sculk: Default::default(), @@ -13267,6 +13628,7 @@ impl<'a> Game<'a> { title: None, armor: [None, None, None, None], offhand: None, + hotbar_pop: [0; 10], hand: Hand::Main, shield_cooldown: 0, cooldowns: Default::default(), @@ -13297,8 +13659,10 @@ impl<'a> Game<'a> { lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, + sleep_seen: (0, 0), dim: Dim::Overworld, world_root: PathBuf::new(), + world_flat: false, travelling: None, server_trips: Vec::new(), level_teleports: Vec::new(), @@ -13423,10 +13787,15 @@ impl<'a> Game<'a> { forced_hit: None, guest_use: None, lan_events: Vec::new(), + lan_songs: Vec::new(), lan_cushion_breaks: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), lan_critical_hits: Vec::new(), + lan_kinetic_hits: Vec::new(), + stabbed: HashMap::new(), + known_movement: Vec3::ZERO, + kinetic_feedback: HashMap::new(), lan_global_events: Vec::new(), lid_openers: HashMap::new(), lan_acting: None, @@ -13439,7 +13808,7 @@ impl<'a> Game<'a> { admin_feedback: Vec::new(), console_broadcast: None, cmds: Default::default(), - ui: Default::default(), + ui: chat::UiState::new(), combat: Default::default(), guest_combat: Default::default(), mount: Default::default(), @@ -13450,6 +13819,7 @@ impl<'a> Game<'a> { boss_overlay: Default::default(), exec: Default::default(), rand_sequences: Default::default(), + brushing: Default::default(), border: Default::default(), border_renderer: Default::default(), border_state: Default::default(), @@ -14110,10 +14480,10 @@ fn build_renderer( previous, api, ))?; - renderer.hud.fire_animations = atlas - .fire_animations + renderer.hud.sprite_animations = atlas + .sprite_animations .iter() - .map(|(rect, animation)| (*rect, animation.clone(), usize::MAX)) + .map(|(rect, animation)| (*rect, animation.clone(), (usize::MAX, 0, 0))) .collect(); Ok(renderer) } @@ -14170,10 +14540,10 @@ fn loading_renderer( api, ))?; if let Some(atlas) = atlas { - renderer.hud.fire_animations = atlas - .fire_animations + renderer.hud.sprite_animations = atlas + .sprite_animations .iter() - .map(|(rect, animation)| (*rect, animation.clone(), usize::MAX)) + .map(|(rect, animation)| (*rect, animation.clone(), (usize::MAX, 0, 0))) .collect(); } Ok(renderer) diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 912bf7c33..79e836322 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -22,6 +22,9 @@ pub(super) struct Toast { frame: Frame, title: Text, slide: Slide, + /// `ToastInstance.firstSlotIndex`: the 32-pixel slot it stacks in once it + /// leaves the queue. + slot: Option, /// A `RecipeToast`: the crafting station and result of each display /// unlocked while it lasts (`recipeItems`); empty for an advancement. recipes: Vec<(String, ItemStack)>, @@ -37,6 +40,7 @@ impl Toast { frame: Frame::Task, title: Text::literal(""), slide: Slide::default(), + slot: None, recipes: items, changed: true, last_changed: 0, @@ -535,6 +539,7 @@ impl Game<'_> { frame: d.frame, title: text_of(&d.title), slide: Slide::default(), + slot: None, recipes: Vec::new(), changed: false, last_changed: 0, @@ -714,6 +719,19 @@ impl Game<'_> { adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w) }); } + /// `KilledByArrowTrigger`: what the arrow killed and the weapon it came from. + pub(super) fn trigger_killed_by_arrow( + &mut self, + victims: &[EntityView], + weapon: Option<&ItemStack>, + ) { + let me = self.player_entity(); + let victims = victims.to_vec(); + let weapon = weapon.map(item_view); + self.trigger("minecraft:killed_by_arrow", move |c, w| { + adv::killed_by_arrow(c, &me, &victims, weapon.as_ref(), w) + }); + } /// `LevitationTrigger`: how far the player rose from where it started /// levitating, and for how long. fn trigger_levitation(&mut self, start: [f64; 3], duration: i64) { @@ -858,6 +876,35 @@ impl Game<'_> { let it = item_view(stack); self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w)); } + /// `ConstructBeaconTrigger`: the pyramid levels of the new beacon. + pub(super) fn trigger_construct_beacon(&mut self, levels: i32) { + let me = self.player_entity(); + self.trigger("minecraft:construct_beacon", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) && adv::range_i(&c["level"], i64::from(levels)) + }); + } + /// `EnchantedItemTrigger`: the enchanted item and the levels it cost. + pub(super) fn trigger_enchanted_item(&mut self, stack: &ItemStack, levels: i32) { + let me = self.player_entity(); + let it = item_view(stack); + self.trigger("minecraft:enchanted_item", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && adv::item(&c["item"], &it, w) + && adv::range_i(&c["levels"], i64::from(levels)) + }); + } /// `BrewedPotionTrigger`: the potion contents of a stack taken from a /// brewing stand. pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) { @@ -1022,58 +1069,105 @@ impl Game<'_> { c["from"].as_str().is_none_or(|f| f == from) && c["to"].as_str().is_none_or(|t| t == to) }); } - /// `ToastManager` with the `AdvancementToast` and the `RecipeToast`, - /// one at a time. - pub(super) fn draw_toasts(&mut self, batch: &mut HudBatch) { + /// `ToastManager.SLOT_COUNT`. + pub(super) const TOAST_SLOTS: usize = 5; + /// `ToastManager.update` and `extractRenderState` for the `AdvancementToast`s and + /// `RecipeToast`s: up to five stack in 32-pixel slots, the rest queue. `hidden` (F1) + /// keeps them timing out without drawing them. + pub(super) fn draw_toasts(&mut self, batch: &mut HudBatch, hidden: bool) { let multiplier = f64::from(self.settings.notification_display_time); - let Some(t) = self.adv.toasts.front_mut() else { - return; - }; - let first = t.slide.origin.is_none(); - let origin = *t.slide.origin.get_or_insert_with(Instant::now); - let now = origin.elapsed().as_millis() as i64; - let mut slide = std::mem::take(&mut t.slide); - let (sound, finished) = slide.update(now, |fully| t.wants_show(fully, multiplier)); - t.slide = slide; - if finished { - self.adv.toasts.pop_front(); + let mut sound_played = false; + let mut i = 0; + while i < self.adv.toasts.len() { + let t = &mut self.adv.toasts[i]; + if t.slot.is_none() { + i += 1; + continue; + } + let origin = *t.slide.origin.get_or_insert_with(Instant::now); + let now = origin.elapsed().as_millis() as i64; + let mut slide = std::mem::take(&mut t.slide); + let (sound, finished) = slide.update(now, |fully| t.wants_show(fully, multiplier)); + t.slide = slide; + if finished { + self.adv.toasts.remove(i); + continue; + } + // Only the first visibility change of an update plays its sound. + if let Some(show) = sound + && !std::mem::replace(&mut sound_played, true) + { + let event = if show { "ui.toast.in" } else { "ui.toast.out" }; + self.audio + .play(&format!("minecraft:{event}"), None, 1.0, 1.0); + } + i += 1; + } + // The queued toasts take the free slots in order; a challenge's own sound + // plays once as it leaves the queue. + let mut used = self.toast_slots_used(); + let mut challenge_sound = false; + for t in &mut self.adv.toasts { + if t.slot.is_some() { + continue; + } + let Some(slot) = (0..Self::TOAST_SLOTS).find(|s| used & (1 << s) == 0) else { + break; + }; + used |= 1 << slot; + t.slot = Some(slot); + challenge_sound |= !t.is_recipe() && t.frame == Frame::Challenge; + } + if challenge_sound { + self.audio + .play("minecraft:ui.toast.challenge_complete", None, 1.0, 1.0); + } + if hidden { return; } + for i in 0..self.adv.toasts.len() { + if let Some(slot) = self.adv.toasts[i].slot { + self.draw_toast(batch, i, 32.0 * slot as f32, multiplier); + } + } + } + /// The slots held by shown advancement, recipe and pack toasts, as bits. + pub(super) fn toast_slots_used(&self) -> u32 { + let packs = self.server_packs.toast_slots(); + self.adv + .toasts + .iter() + .filter_map(|t| t.slot) + .chain(packs) + .fold(0, |used, slot| used | 1 << slot) + } + /// The `AdvancementToast` or `RecipeToast` at `index` in its slot at `y`. + fn draw_toast(&mut self, batch: &mut HudBatch, index: usize, y: f32, multiplier: f64) { + let t = &self.adv.toasts[index]; let x = batch.width - 160.0 * t.slide.portion; let fully_for = t.slide.fully_for; let (title, frame, icon) = (t.title.clone(), t.frame, t.icon.clone()); let recipe = t .is_recipe() .then(|| t.recipes[t.displayed_recipe(fully_for, multiplier)].clone()); - // ToastManager.update: the sound of the new visibility, and a - // challenge's own sound as it leaves the queue. - if let Some(show) = sound { - let event = if show { "ui.toast.in" } else { "ui.toast.out" }; - self.audio - .play(&format!("minecraft:{event}"), None, 1.0, 1.0); - } - if first && recipe.is_none() && frame == Frame::Challenge { - self.audio - .play("minecraft:ui.toast.challenge_complete", None, 1.0, 1.0); - } if let Some((station, item)) = recipe { // RecipeToast: black description under a purple title, the // station at 0.6 scale in the corner over the cycling result. let atlas = &self.gui.atlas; - batch.sprite(atlas, "gui/sprites/toast/recipe", x, 0.0); + batch.sprite(atlas, "gui/sprites/toast/recipe", x, y); let title = self.translate("recipe.toast.title", "New Recipe(s) Unlocked!"); let description = self.translate("recipe.toast.description", "Check your recipe book"); let atlas = &self.gui.atlas; - batch.text(atlas, &title, x + 30.0, 7.0, 0xFF50_0050, false); - batch.text(atlas, &description, x + 30.0, 18.0, 0xFF00_0000, false); + batch.text(atlas, &title, x + 30.0, y + 7.0, 0xFF50_0050, false); + batch.text(atlas, &description, x + 30.0, y + 18.0, 0xFF00_0000, false); let start = batch.vertices.len(); - self.draw_item_model(batch, &ItemStack::new(&station, 1), x + 3.0, 3.0); - batch.scale_since(start, x, 0.0, 0.6, 0.6); - self.draw_item_model(batch, &item, x + 8.0, 8.0); + self.draw_item_model(batch, &ItemStack::new(&station, 1), x + 3.0, y + 3.0); + batch.scale_since(start, x, y, 0.6, 0.6); + self.draw_item_model(batch, &item, x + 8.0, y + 8.0); return; } let atlas = &self.gui.atlas; - batch.sprite(atlas, "gui/sprites/toast/advancement", x, 0.0); + batch.sprite(atlas, "gui/sprites/toast/advancement", x, y); let (key, color) = match frame { Frame::Task => ("advancements.toast.task", 0xFF00_FFFF), Frame::Goal => ("advancements.toast.goal", 0xFF00_FFFF), @@ -1083,12 +1177,12 @@ impl Game<'_> { atlas, &Text::translate(key, &[]), x + 30.0, - 7.0, + y + 7.0, color, false, ); - batch.text_styled(atlas, &title, x + 30.0, 18.0, u32::MAX, false); - self.draw_item(batch, &ItemStack::new(&icon, 1), x + 8.0, 8.0); + batch.text_styled(atlas, &title, x + 30.0, y + 18.0, u32::MAX, false); + self.draw_item(batch, &ItemStack::new(&icon, 1), x + 8.0, y + 8.0); } } /// `Advancement.name`: the bracketed title in the frame's colour, with the @@ -1269,6 +1363,7 @@ impl Game<'_> { frame: d.frame, title: text_of(&d.title), slide: Slide::default(), + slot: None, recipes: Vec::new(), changed: false, last_changed: 0, diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs index ce9410ba5..27f40f980 100644 --- a/crates/horizon-client/src/game/allays.rs +++ b/crates/horizon-client/src/game/allays.rs @@ -8,7 +8,6 @@ use horizon_core::random::RandomSource; impl Game<'_> { pub(super) fn tick_allays(&mut self) { let griefing = self.ui.rules.bool("mob_griefing"); - let player = self.player.as_ref().map(|p| p.position); // The playing jukeboxes, found at the first allay: no allay starts // or stops one, and the block entities run into the thousands. let mut jukeboxes: Option> = None; @@ -58,7 +57,7 @@ impl Game<'_> { }; let Some((j, _)) = wanted else { self.mobs[i].extra.point = None; - self.allay_deliver(i, player); + self.allay_deliver(i); continue; }; let e = &self.dropped[j]; @@ -90,14 +89,46 @@ impl Game<'_> { } } } + /// `AllayAi.getLikedPlayer`: the player the allay was given an item by, + /// found by UUID among the host and the guests of the level (the window + /// is a guest on the server thread), when they are not a spectator and + /// within 64 blocks. + fn allay_liked_player(&self, i: usize) -> Option { + let m = &self.mobs[i]; + if !m.extra.tame { + return None; + } + // An allay saved before its player was kept belongs to the host. + let uuid = m + .extra + .owner + .filter(|u| *u != [0, 0, 0, 1]) + .or(self.level.player_uuid) + .unwrap_or([0, 0, 0, 1]); + let host = self + .player_view() + .filter(|p| !p.spectator && self.level.player_uuid.unwrap_or([0, 0, 0, 1]) == uuid) + .map(|p| p.position); + let found = host.or_else(|| { + self.lan_present() + .into_iter() + .find(|p| p.uuid == uuid && !p.spectator) + .map(|p| { + horizon_core::geometry::Vec3::new(p.position[0], p.position[1], p.position[2]) + }) + }); + found.filter(|p| p.distance_squared(m.position) < 64.0 * 64.0) + } /// `GoAndGiveItemsToTarget` / `AllayAi.throwItem`: within 3 blocks of /// the deposit, one item a tick, each restarting the three-second pause /// before it picks anything up again. - fn allay_deliver(&mut self, i: usize, player: Option) { + fn allay_deliver(&mut self, i: usize) { let m = &self.mobs[i]; if m.extra.ints[1] <= 0 { return; } + let player = self.allay_liked_player(i); + let m = &self.mobs[i]; let target = match m.extra.home.filter(|_| m.extra.ints[2] > 0) { Some(h) => horizon_core::geometry::Vec3::new( f64::from(h[0]) + 0.5, @@ -167,11 +198,14 @@ impl Game<'_> { self.consume_held(); return true; } + let acting = self.acting_uuid(); let holds = m.extra.main_hand.is_some(); if !holds && !item.is_empty() { let m = &mut self.mobs[index]; m.extra.main_hand = Some(item.into()); m.extra.tame = true; + // `Allay.mobInteract` remembers LIKED_PLAYER by UUID. + m.extra.owner = Some(acting); self.audio .play("minecraft:entity.allay.item_given", Some(at), 2.0, 1.0); self.consume_held(); @@ -186,6 +220,7 @@ impl Game<'_> { .unwrap_or_else(|| "minecraft:air".into()); let carried = std::mem::take(&mut m.extra.ints[1]); m.extra.tame = false; + m.extra.owner = None; self.audio .play("minecraft:entity.allay.item_taken", Some(at), 2.0, 1.0); if carried > 0 { diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 8cd8be53a..4c0bd32e3 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -627,21 +627,8 @@ impl Game<'_> { * glam::Mat4::from_scale(glam::Vec3::new(-1.0, -1.0, 1.0)) * glam::Mat4::from_translation(glam::Vec3::new(0.0, -1.501, 0.0)); let mut poses = Poses::new(model); - // ArmorStand.DEFAULT_*_POSE and ArmorStandModel part visibility. - let deg = |v: f32| v.to_radians(); - for (name, rot) in [ - ("left_arm", [-10.0, 0.0, -10.0]), - ("right_arm", [-15.0, 0.0, 10.0]), - ("left_leg", [-1.0, 0.0, -1.0]), - ("right_leg", [1.0, 0.0, 1.0]), - ] { - if poses.has(name) { - let pose = poses.get(name); - pose[3] = deg(rot[0]); - pose[4] = deg(rot[1]); - pose[5] = deg(rot[2]); - } - } + // ArmorStandModel.setupAnim: the stand's pose and part visibility. + apply_pose(&mut poses, &a.pose); // Item layers pose from the hidden arms too (`visible` only skips drawing). let posed = poses.clone(); let mut hide = |name: &str| { @@ -725,7 +712,9 @@ impl Game<'_> { } else { 0 }; - let layer_poses = Poses::new(part); + // ArmorStandArmorModel.setupAnim: the same pose as the stand. + let mut layer_poses = Poses::new(part); + apply_pose(&mut layer_poses, &a.pose); horizon_client::mobs::render::draw( part, base, @@ -757,6 +746,33 @@ impl Game<'_> { } } } +/// The `Pose` rotations on the parts of an armor stand model or its armor +/// (`ArmorStandArmorModel.setupAnim`); the body also turns the sticks. +fn apply_pose(poses: &mut Poses, pose: &[[f32; 3]; 6]) { + let parts: [&[&str]; 6] = [ + &["head"], + &[ + "body", + "right_body_stick", + "left_body_stick", + "shoulder_stick", + ], + &["left_arm"], + &["right_arm"], + &["left_leg"], + &["right_leg"], + ]; + for (names, rotation) in parts.into_iter().zip(pose) { + for name in names { + if poses.has(name) { + let part = poses.get(name); + part[3] = rotation[0].to_radians(); + part[4] = rotation[1].to_radians(); + part[5] = rotation[2].to_radians(); + } + } + } +} fn overlaps(a: Aabb, b: Aabb) -> bool { let (a0, a1, b0, b1) = ( a.min_position(), diff --git a/crates/horizon-client/src/game/beacon.rs b/crates/horizon-client/src/game/beacon.rs index 97177f2b9..6de017c33 100644 --- a/crates/horizon-client/src/game/beacon.rs +++ b/crates/horizon-client/src/game/beacon.rs @@ -164,11 +164,35 @@ impl Game<'_> { let (was, is) = (previous > 0, b.levels > 0); if !was && is { self.beacon_sound([x, y, z], "minecraft:block.beacon.activate"); + let levels = b.levels; + self.for_each_player(|g| g.beacon_constructed([x, y, z], levels)); } else if was && !is { self.beacon_sound([x, y, z], "minecraft:block.beacon.deactivate"); } } } + /// `BeaconBlockEntity.tick` after activating: `CONSTRUCT_BEACON` for a + /// player in the box `AABB(x, y, z, x, y - 4, z).inflate(10, 5, 10)`. + fn beacon_constructed(&mut self, p: [i32; 3], levels: i32) { + let Some(bb) = self + .player + .as_ref() + .map(|pl| pl.dimensions.bounds(pl.position)) + else { + return; + }; + let (lo, hi) = (bb.min_position(), bb.max_position()); + let [x, y, z] = p.map(f64::from); + if lo.x < x + 10.0 + && hi.x > x - 10.0 + && lo.y < y + 5.0 + && hi.y > y - 9.0 + && lo.z < z + 10.0 + && hi.z > z - 10.0 + { + self.trigger_construct_beacon(levels); + } + } pub(super) fn beacon_sound(&mut self, p: [i32; 3], sound: &str) { let at = [ f64::from(p[0]) + 0.5, diff --git a/crates/horizon-client/src/game/block_items.rs b/crates/horizon-client/src/game/block_items.rs index 199c39a78..d18715041 100644 --- a/crates/horizon-client/src/game/block_items.rs +++ b/crates/horizon-client/src/game/block_items.rs @@ -4,9 +4,13 @@ //! placed item gives its block entity. use super::Game; use horizon_client::{ - block_entity_item, block_entity_nbt, containers::BlockEntity, item_data, items::ItemStack, save, + Result, block_entity_item, block_entity_nbt, containers::BlockEntity, item_data, + items::ItemStack, save, +}; +use horizon_world::{ + nbt::{Compound, Tag}, + registry::BlockStateId, }; -use horizon_world::nbt::{Compound, Tag}; /// The component patch of `stack`. fn components(stack: &ItemStack) -> Compound { @@ -77,6 +81,42 @@ impl Game<'_> { Some(stack) } + /// `BlockItem.updateBlockStateFromTag`: the properties of the item's + /// `block_state` component (a hive's honey level, a statue's pose) set on + /// the block just placed at `pos`. Returns the state it has now. + pub(super) fn apply_item_block_state( + &mut self, + pos: [i32; 3], + state: BlockStateId, + stack: &ItemStack, + ) -> Result { + let Some(Tag::Compound(saved)) = + stack.data().and_then(|d| d.other("minecraft:block_state")) + else { + return Ok(state); + }; + let Some(current) = self.pack.assets.registry.state(state) else { + return Ok(state); + }; + // Only the properties the block has. + let props: Vec<(String, String)> = saved + .iter() + .filter_map(|(k, v)| match v { + Tag::String(v) => Some((k.to_string_lossy(), v.to_string_lossy())), + _ => None, + }) + .filter(|(k, v)| current.properties.get(k).is_some_and(|old| old != v)) + .collect(); + let props: Vec<(&str, &str)> = props.iter().map(|(k, v)| (&**k, &**v)).collect(); + match self.with_props(state, &props) { + Some(new) if !props.is_empty() && new != state => { + self.level_set(pos, new)?; + Ok(new) + } + _ => Ok(state), + } + } + /// `BlockItem.updateCustomBlockEntityTag` and `updateBlockEntityComponents` /// for the block entity just placed at `pos` from `stack`; `game_master`: /// the placer can use game master blocks (a dispenser can't). diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs index ddbe47481..07d65c5a4 100644 --- a/crates/horizon-client/src/game/books.rs +++ b/crates/horizon-client/src/game/books.rs @@ -1144,7 +1144,12 @@ impl Game<'_> { BLACK, ); } - let by = tr("book.byAuthor", "by %1$s").replace("%1$s", super::chat::PLAYER_NAME); + // BookSignScreen: `owner.getName()`, the account's name on a server. + let owner = self + .remote + .as_ref() + .map_or(super::chat::PLAYER_NAME, |r| r.profile_name.as_str()); + let by = tr("book.byAuthor", "by %1$s").replace("%1$s", owner); let tw = HudBatch::text_width(atlas, &by); batch.text( atlas, diff --git a/crates/horizon-client/src/game/brush.rs b/crates/horizon-client/src/game/brush.rs new file mode 100644 index 000000000..c064a3153 --- /dev/null +++ b/crates/horizon-client/src/game/brush.rs @@ -0,0 +1,246 @@ +//! Brushing suspicious sand and gravel: `BrushItem.onUseTick` and +//! `BrushableBlockEntity`. The block's loot table stays in its saved block +//! entity (like a decorated pot's) until the first counted stroke rolls it. +use super::{Game, Hit, decorated_pot, spill, view_vector}; +use horizon_client::{ + particles::{ParticleOptions, ParticleType}, + save, +}; +use horizon_core::random::RandomSource; +use std::collections::HashMap; + +/// `BrushItem.USE_DURATION`. +const USE_DURATION: u32 = 200; + +/// A brushable block's counters. Vanilla never saves them: the block's +/// `dusted` state is all that is left after a reload. +#[derive(Default)] +pub(super) struct BrushState { + count: i32, + resets_at: i64, + cooldown_ends_at: i64, + hit_face: Option<[i32; 3]>, +} + +/// `BrushableBlockEntity.getCompletionState`: the `dusted` property. +fn completion_state(count: i32) -> i32 { + match count { + 0 => 0, + 1..=2 => 1, + 3..=5 => 2, + _ => 3, + } +} + +pub(super) type Brushing = HashMap<[i32; 3], BrushState>; + +impl Game<'_> { + /// `BrushItem.onUseTick` for a brush used `ticks` ticks so far, the + /// hand of `slot` acting. + pub(super) fn tick_brush(&mut self, slot: usize, ticks: u32) { + // No block under the crosshair: releaseUsingItem. + let Some(hit) = self.pick() else { + self.using = None; + return; + }; + let elapsed = ticks + 1; + // The last tick before the backswing. + if elapsed % 10 == 5 { + self.brush_stroke(&hit, slot); + } + // The use ends after 200 ticks; the held button starts it again. + self.using = (elapsed < USE_DURATION).then_some((slot, elapsed)); + } + + /// One stroke on the block aimed at: dust (this window only), the brush + /// sound, and the block entity's count. The brush wears when the block + /// changed state. + fn brush_stroke(&mut self, hit: &Hit, slot: usize) { + let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]); + let name = self.res.facts().get(state).name.clone(); + let (sound, brushable) = match &*name { + "minecraft:suspicious_sand" => ("minecraft:item.brush.brushing.sand", true), + "minecraft:suspicious_gravel" => ("minecraft:item.brush.brushing.gravel", true), + _ => ("minecraft:item.brush.brushing.generic", false), + }; + if self.lan_acting.is_none() { + self.brush_dust(hit, slot == super::shield::OFFHAND_SLOT); + } + let at = hit.pos.map(|v| f64::from(v) + 0.5); + self.audio.play(sound, Some(at), 1.0, 1.0); + if brushable && self.brush_block(hit.pos, hit.face) { + self.damage_held(1); + } + } + + /// `BrushItem.spawnDustParticles`. + pub(super) fn brush_dust(&mut self, hit: &Hit, off_hand: bool) { + let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]); + let Some((sprite, tint)) = self.particle_sprite(state, hit.pos) else { + return; + }; + let options = ParticleOptions::block(ParticleType::Block, sprite, tint); + // The arm that brushes: the main arm, or the other one for the off hand. + let flip = if off_hand == self.settings.main_hand_left { + 1.0 + } else { + -1.0 + }; + let view = view_vector(self.yaw, self.pitch); + // DustParticlesDelta.fromDirection. + let (dx, dz) = match hit.face { + [0, _, 0] => (view[2], -view[0]), + [0, 0, -1] => (1.0, -0.1), + [0, 0, 1] => (-1.0, 0.1), + [-1, 0, 0] => (-0.1, -1.0), + _ => (0.1, 1.0), + }; + let count = 7 + self.particles.level_random().next_int_bound(5).unwrap_or(0); + let x = hit.point[0] - if hit.face == [-1, 0, 0] { 1.0e-6 } else { 0.0 }; + let z = hit.point[2] - if hit.face == [0, 0, -1] { 1.0e-6 } else { 0.0 }; + for _ in 0..count { + let random = self.particles.level_random(); + let v = [ + dx * flip * 3.0 * random.next_double(), + 0.0, + dz * flip * 3.0 * random.next_double(), + ]; + self.particles.add(&options, [x, hit.point[1], z], v); + } + } + + /// `BrushableBlockEntity.brush`: whether the block changed (the brush wears). + fn brush_block(&mut self, pos: [i32; 3], face: [i32; 3]) -> bool { + let time = self.world.game_time; + let mut brush = self.brushing.remove(&pos).unwrap_or_default(); + brush.hit_face.get_or_insert(face); + brush.resets_at = time + 40; + if time < brush.cooldown_ends_at { + self.brushing.insert(pos, brush); + return false; + } + brush.cooldown_ends_at = time + 10; + self.unpack_brush_loot(pos); + let before = completion_state(brush.count); + brush.count += 1; + if brush.count >= 10 { + self.brushing_completed(pos, brush.hit_face); + return true; + } + self.schedule_brushable_tick(pos); + let after = completion_state(brush.count); + self.brushing.insert(pos, brush); + if before != after { + self.set_dusted(pos, after); + } + false + } + + /// `BrushableBlockEntity.unpackLootTable`: the table's roll becomes the + /// block entity's item. + fn unpack_brush_loot(&mut self, pos: [i32; 3]) { + let Some(mut tag) = spill::saved_entity(&self.world, pos) else { + return; + }; + if tag.get("LootTable").is_none() { + return; + } + let loot = horizon_client::structure_blocks::loot_data(&self.options.resources); + decorated_pot::unpack_loot( + &mut tag, + loot.as_deref(), + &mut self.world.random, + &mut self.rand_sequences, + self.level.seed, + ); + spill::put_saved_entity(&mut self.world, pos, tag); + } + + /// `BrushableBlockEntity.brushingCompleted`: the item drops out of the + /// brushed face and the block turns into its sand or gravel. + fn brushing_completed(&mut self, pos: [i32; 3], face: Option<[i32; 3]>) { + let state = self.world.block(pos[0], pos[1], pos[2]); + let turns_into = match &*self.res.facts().get(state).name { + "minecraft:suspicious_sand" => "minecraft:sand", + "minecraft:suspicious_gravel" => "minecraft:gravel", + _ => "minecraft:air", + }; + // dropContent: the item at the middle of the block beside that face. + let item = spill::saved_entity(&self.world, pos) + .and_then(|tag| tag.get("item").and_then(save::item_from_nbt)); + if let Some(mut item) = item { + let face = face.unwrap_or([0, 1, 0]); + let take = 10 + self.world.random.next_int_bound(21).unwrap_or(0); + item.count = item.count.min(take as u32); + let at = [ + f64::from(pos[0] + face[0]) + 0.5, + f64::from(pos[1] + face[1]) + 0.625, + f64::from(pos[2] + face[2]) + 0.5, + ]; + self.spawn_item(item, at, [0.0; 3], 0); + } + // Level event 3008 for every player, then the block change. + self.level_event_at(3008, pos, state.0 as i32); + if let Some(base) = self.pack.assets.registry.default_state(turns_into) { + let _ = self.level_set(pos, base); + } + } + + fn set_dusted(&mut self, pos: [i32; 3], dusted: i32) { + let registry = self.pack.assets.registry; + let Some(mut state) = registry + .state(self.world.block(pos[0], pos[1], pos[2])) + .cloned() + else { + return; + }; + state.properties.insert("dusted".into(), dusted.to_string()); + if let Ok(state) = registry.resolve(&state) { + let _ = self.level_set(pos, state); + } + } + + fn schedule_brushable_tick(&mut self, pos: [i32; 3]) { + let at = horizon_core::position::BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| b.schedule_tick(level, ticks, at, 2)); + } + + /// `BrushableBlockEntity.checkReset`, from `BrushableBlock.tick`: a block + /// left alone loses two counts, again every four ticks. + pub(super) fn brushable_tick(&mut self, pos: [i32; 3]) { + let time = self.world.game_time; + let Some(mut brush) = self.brushing.remove(&pos) else { + return; + }; + let before = completion_state(brush.count); + if brush.count != 0 && time >= brush.resets_at { + brush.count = (brush.count - 2).max(0); + brush.resets_at = time + 4; + } + let after = completion_state(brush.count); + if brush.count != 0 { + self.brushing.insert(pos, brush); + self.schedule_brushable_tick(pos); + } + if before != after { + self.set_dusted(pos, after); + } + } + + /// Level event 3008 (`LevelEventHandler`): the finished block's sound + /// and break particles. + pub(super) fn brush_complete_event(&mut self, pos: [i32; 3], data: i32) { + let state = horizon_world::registry::BlockStateId(data as u32); + let sound = match &*self.res.facts().get(state).name { + "minecraft:suspicious_sand" => "minecraft:item.brush.brushing.sand.complete", + "minecraft:suspicious_gravel" => "minecraft:item.brush.brushing.gravel.complete", + _ => "", + }; + if !sound.is_empty() { + let at = pos.map(|v| f64::from(v) + 0.5); + // Each client plays it from the event itself. + self.audio.play_unshared(sound, Some(at), 1.0, 1.0); + } + self.destroy_particles(pos, state); + } +} diff --git a/crates/horizon-client/src/game/cat_spawner.rs b/crates/horizon-client/src/game/cat_spawner.rs new file mode 100644 index 000000000..539aae726 --- /dev/null +++ b/crates/horizon-client/src/game/cat_spawner.rs @@ -0,0 +1,138 @@ +//! `CatSpawner`: every 1200 ticks a cat may appear near a random player, +//! in a village with enough occupied beds or inside a swamp hut. +use super::{ + Dim, Game, + raids::{section, sections_to_village}, +}; +use horizon_client::mobs::{Species, spawn_rules}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +const TICK_DELAY: i32 = 1200; + +impl Game<'_> { + /// `CatSpawner.tick` (the overworld's custom spawner). + pub(super) fn tick_cat_spawner(&mut self) { + if self.dim != Dim::Overworld { + return; + } + self.creatures.cat_tick -= 1; + if self.creatures.cat_tick > 0 { + return; + } + self.creatures.cat_tick = TICK_DELAY; + // ServerLevel.getRandomPlayer: one of the living players. + let alive: Vec = self + .level_players() + .into_iter() + .filter(|p| p.alive) + .map(|p| p.position) + .collect(); + if alive.is_empty() { + return; + } + let pick = self + .world + .random + .next_int_bound(alive.len() as i32) + .unwrap_or(0); + let p = alive[pick as usize]; + let mut offset = || { + let n = 8 + self.world.random.next_int_bound(24).unwrap_or(0); + if self.world.random.next_boolean() { + -n + } else { + n + } + }; + let x = offset(); + let z = offset(); + let pos = [ + p.x.floor() as i32 + x, + p.y.floor() as i32, + p.z.floor() as i32 + z, + ]; + // hasChunksAt(pos +- 10) + let loaded = ((pos[0] - 10) >> 4..=(pos[0] + 10) >> 4).all(|cx| { + ((pos[2] - 10) >> 4..=(pos[2] + 10) >> 4) + .all(|cz| self.world.chunks.contains_key(&(cx, cz))) + }); + if !loaded { + return; + } + let ok = spawn_rules::is_spawn_position_ok( + Species::Cat, + &self.mob_world_base(&[]), + pos[0], + pos[1], + pos[2], + ); + if !ok { + return; + } + if sections_to_village(&self.village_centers(), section(pos)) <= 2 { + self.spawn_cat_in_village(pos); + } else { + let hut = self.structure_tag("minecraft:cats_spawn_in"); + if self.structures_at(pos).iter().any(|s| hut.contains(s)) { + self.spawn_cat_in_hut(pos); + } + } + } + /// `spawnInVillage`: more than four occupied beds within 48 blocks and + /// fewer than five cats around. + fn spawn_cat_in_village(&mut self, pos: [i32; 3]) { + // PoiManager.getCountInRange(HOME, IS_OCCUPIED): beds villagers have claimed. + let mut beds: Vec<[i32; 3]> = self + .mobs + .iter() + .filter(|m| m.species() == Species::Villager && m.alive()) + .filter_map(|m| m.extra.bed) + .filter(|b| { + let d = |i: usize| i64::from(b[i] - pos[i]); + d(0).abs() <= 48 + && d(2).abs() <= 48 + && d(0).pow(2) + d(1).pow(2) + d(2).pow(2) <= 48 * 48 + }) + .collect(); + beds.sort_unstable(); + beds.dedup(); + if beds.len() > 4 && self.cats_near(pos, 48.0) < 5 { + self.spawn_cat(pos, false); + } + } + /// `spawnInHut`: no cat within 16 blocks; the cat stays. + fn spawn_cat_in_hut(&mut self, pos: [i32; 3]) { + if self.cats_near(pos, 16.0) == 0 { + self.spawn_cat(pos, true); + } + } + /// Cats in `AABB(pos).inflate(radius, 8, radius)`. + fn cats_near(&self, pos: [i32; 3], radius: f64) -> usize { + let [x, y, z] = pos.map(f64::from); + let min = Vec3::new(x - radius, y - 8.0, z - radius); + let max = Vec3::new(x + 1.0 + radius, y + 9.0, z + 1.0 + radius); + self.mobs + .iter() + .filter(|m| { + m.species() == Species::Cat && m.alive() && m.bounds().intersects_corners(min, max) + }) + .count() + } + /// `spawnCat`: finalized for a natural spawn, black inside + /// `#cats_spawn_as_black` structures (`Cat.finalizeSpawn`). + fn spawn_cat(&mut self, pos: [i32; 3], persistent: bool) { + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + ]; + let Some(id) = self.spawn_mob("minecraft:cat", at, persistent) else { + return; + }; + let black = self.structure_tag("minecraft:cats_spawn_as_black"); + let in_black = self.structures_at(pos).iter().any(|s| black.contains(s)); + if in_black && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + m.extra.variant = 10; + } + } +} diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 7344c0e9d..49ad2be44 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -81,6 +81,8 @@ pub struct UiState { pub chat_screen: Option, /// When the chat screen opened (its input took the focus: the cursor blink). pub chat_opened: Option, + /// The chat screen is `InBedChatScreen`: the sleeper's, with a Leave Bed button. + pub in_bed_chat: bool, pub registries: Registries, pub rules: GameRules, pub clock: WorldClock, @@ -102,10 +104,25 @@ pub struct UiState { /// Death screen cause and when the player died (buttons wait 20 ticks). pub death_text: Option, pub died_at: Option, + /// `DeathScreen.TitleConfirmScreen` and when it opened (its buttons wait + /// 20 ticks, `setDelay`). + pub death_confirm: Option, /// `LivingEntity.deathTime` of the window's player: ticks since it died. pub death_time: u32, } +impl UiState { + /// The state a window starts with: the chat remembers the commands kept + /// in the game folder (`ChatComponent`'s constructor). + pub fn new() -> Self { + let mut ui = Self::default(); + if let Ok(dir) = std::env::current_dir() { + ui.chat.load_history(&dir); + } + ui + } +} + impl Game<'_> { /// `PlayerList.isOp` for the single-player owner: the world's Allow Commands. pub(super) fn allow_commands(&self) -> bool { @@ -440,6 +457,12 @@ impl Game<'_> { self.capture(false); } pub(super) fn close_chat(&mut self) { + // InBedChatScreen.onClose: leaving the screen means getting up; the + // screen goes once the player has woken (`tick_in_bed_chat`). + if self.ui.in_bed_chat && self.sleeping.is_some() { + self.wake_up(); + return; + } self.ui.chat_screen = None; self.ui.chat.reset_scroll(); if self.screen == Screen::Chat { @@ -447,6 +470,35 @@ impl Game<'_> { self.capture(true); } } + /// `Gui.tick`: a sleeper gets `InBedChatScreen`; when the player has + /// woken (`onPlayerWokeUp`) it closes, or turns into the plain chat + /// screen if something was typed. + pub(super) fn tick_in_bed_chat(&mut self) { + if self.screen != Screen::Chat { + self.ui.in_bed_chat = false; + } + if self.ui.in_bed_chat { + if self.sleeping.is_none() { + self.ui.in_bed_chat = false; + let text = self + .ui + .chat_screen + .as_ref() + .map_or_else(String::new, |s| s.value().to_owned()); + self.close_chat(); + if !text.is_empty() { + self.open_chat(&text); + } + } + } else if self.sleeping.is_some() && self.screen == Screen::Playing { + self.open_chat(""); + self.ui.in_bed_chat = self.screen == Screen::Chat; + } + } + /// The Leave Bed button of `InBedChatScreen`: its bounds. + fn leave_bed_button(width: f32, height: f32) -> (i32, i32, i32, i32) { + (width as i32 / 2 - 100, height as i32 - 40, 200, 20) + } /// `Minecraft.computeChatAbilities` from the Chat option. pub(super) fn chat_abilities(&self) -> ChatAbilities { ChatAbilities::new(ChatVisibility::from_option(self.settings.chat_visibility)) @@ -559,7 +611,15 @@ impl Game<'_> { match screen.key(&m, &c, &self.ui.chat.recent, key, shift, ctrl) { ChatAction::Close => self.close_chat(), ChatAction::Submit(message) => { - self.close_chat(); + // InBedChatScreen sends without closing (`closeOnSubmit` is + // false): the box empties and the screen stays. + if self.ui.in_bed_chat && self.sleeping.is_some() { + screen.suggest_command(&m, &c, ""); + self.ui.chat.reset_scroll(); + self.ui.chat_screen = Some(screen); + } else { + self.close_chat(); + } if !message.is_empty() { self.handle_chat_input(&message); } @@ -661,7 +721,8 @@ impl Game<'_> { { return; } - let shift = self.keys.contains(&KeyCode::ShiftLeft); + // ChatScreen.mouseScrolled: `hasShiftDown`, either Shift key. + let shift = self.has_shift_down(); let amount = amount.clamp(-1.0, 1.0) * if shift { 1.0 } else { 7.0 }; self.ui.chat.scroll_by(amount as i32, true); } @@ -675,6 +736,16 @@ impl Game<'_> { dispatcher: chat_tree(&self.remote, &self.mods), registries: &self.ui.registries, }; + if self.ui.in_bed_chat && self.sleeping.is_some() { + let width = self.renderer.as_ref().map_or(1280.0, |r| { + HudBatch::new([r.config.width, r.config.height]).width + }); + let (x, y, w, h) = Self::leave_bed_button(width, height); + if horizon_client::screen_draw::inside((cursor.0 as i32, cursor.1 as i32), x, y, w, h) { + self.wake_up(); + return; + } + } if let Some(screen) = self.ui.chat_screen.as_mut() { if screen.click(&m, &c, cursor.0 as f64, cursor.1 as f64) { return; @@ -682,12 +753,25 @@ impl Game<'_> { } else { return; } - match self.ui.chat.click_at( + let Some(style) = self.ui.chat.style_at( &self.gui.atlas.font, height as i32, cursor.0 as f64, cursor.1 as f64, - ) { + ) else { + return; + }; + // ChatScreen.handleComponentClicked: with Shift held only an + // insertion acts, else only the click event. + if self.has_shift_down() { + if let Some(insertion) = style.insertion + && let Some(screen) = self.ui.chat_screen.as_mut() + { + screen.type_text(&m, &c, &insertion); + } + return; + } + match style.click { Some(ClickEvent::CopyToClipboard(value)) => { use horizon_client::clipboard::Clipboard; self.clipboard.set(&value); @@ -701,6 +785,7 @@ impl Game<'_> { screen.suggest_command(&m, &c, &command); } } + Some(ClickEvent::RunCommand(command)) => self.click_command(&command), // Screen.defaultHandleClickEvent: a page link means nothing in chat. Some(ClickEvent::ChangePage(_)) | None => {} } @@ -769,6 +854,22 @@ impl Game<'_> { self.answer_link_prompt(yes); } } + /// `Screen.clickCommandAction`: run a clicked command as the player + /// without adding it to the chat history. A client mod's command goes + /// first, as `ClientPacketListener.sendUnattendedCommand` lets client + /// commands take it. (Vanilla asks first when the command fails to + /// parse; here the server answers it.) + fn click_command(&mut self, command: &str) { + let command = command.strip_prefix('/').unwrap_or(command); + if self.mod_command(command) { + return; + } + if self.remote.is_some() { + self.send_chat(&format!("/{command}")); + } else if !self.local_server_mod_command(command) { + self.run_command(command); + } + } /// Chat lines over the HUD (focused while the chat screen is open). pub(super) fn draw_chat(&mut self, batch: &mut HudBatch) { let focused = self.screen == Screen::Chat; @@ -803,17 +904,59 @@ impl Game<'_> { let draws = screen.draw(&m, mouse, blink, background); horizon_client::screen_draw::paint(batch, &self.gui.atlas, &draws); self.ui.chat_screen = Some(screen); - // The hovered message part's tooltip, one row per line of its text. - if let Some(hover) = self.ui.chat.hover_at( - &self.gui.atlas.font, - batch.height as i32, - f64::from(self.cursor.0), - f64::from(self.cursor.1), - ) { - let lines = hover_rows(&hover); + if self.ui.in_bed_chat && self.sleeping.is_some() { + let (x, y, w, h) = Self::leave_bed_button(batch.width, batch.height); + let label = Text::literal(horizon_client::lang::get_or( + "multiplayer.stopSleeping", + "Leave Bed", + )); + let mut button = Vec::new(); + horizon_client::screen_draw::button( + &mut button, + &m, + &label, + x, + y, + w, + h, + true, + horizon_client::screen_draw::inside(mouse, x, y, w, h), + ); + horizon_client::screen_draw::paint(batch, &self.gui.atlas, &button); + } + // The hovered message part's tooltip (`renderComponentHoverEffect`), + // or the text of the message tag under the cursor. + let height = batch.height as i32; + let (cx, cy) = (f64::from(self.cursor.0), f64::from(self.cursor.1)); + let wrap = (batch.width as i32 / 2).max(200); + if let Some(style) = self.ui.chat.style_at(&self.gui.atlas.font, height, cx, cy) { + if let Some(hover) = style.hover { + let lines = self.wrapped_rows(&hover, wrap); + self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); + } else if let Some(stack) = style + .hover_item + .as_deref() + .and_then(horizon_client::item_data::stack_from_hover) + .filter(|s| self.res.items().get(&s.item).is_some()) + { + self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1); + } + } else if self.ui.chat.indicator_at(height, cx, cy) { + // GuiMessageTag.systemSinglePlayer's text, split at 210. + let tag = Text::translate("chat.tag.system_single_player", &[]); + let lines = self.wrapped_rows(&tag, 210); self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1); } } + /// `Font.split`: a tooltip text wrapped at `width`, one white row per line. + fn wrapped_rows(&self, text: &Text, width: i32) -> Vec<(Text, u32)> { + let split = self + .gui + .atlas + .font + .split(&text.resolve_legacy(), width as f32); + split.into_iter().map(|row| (row, u32::MAX)).collect() + } /// Advance the overworld clock (ServerClockManager.tick) when /// `advance_time` allows it. pub(super) fn advance_clock(&mut self) { @@ -958,6 +1101,7 @@ impl Game<'_> { let cause = self.ui.death_cause.take(); self.ui.died_at = Some(std::time::Instant::now()); self.ui.death_text = None; + self.ui.death_confirm = None; if !self.ui.rules.bool("show_death_messages") { return; } @@ -1066,26 +1210,3 @@ pub fn screenshot_name(dir: &std::path::Path) -> String { fn owner_permission(allow_commands: bool) -> u8 { if allow_commands { 4 } else { 0 } } - -/// A hover text's rows for the tooltip: split at line breaks, each in the -/// colour of its first styled character (white without one). -fn hover_rows(hover: &horizon_client::text::Text) -> Vec<(String, u32)> { - let mut rows = vec![(String::new(), None)]; - for (c, style) in hover.resolve_legacy().chars() { - if c == '\n' { - rows.push((String::new(), None)); - continue; - } - let row = rows.last_mut().expect("one row"); - if row.0.is_empty() { - row.1 = style.color; - } - row.0.push(c); - } - rows.into_iter() - .map(|(text, color)| { - let [_, r, g, b] = color.unwrap_or(0xFF_FFFF).to_be_bytes(); - (text, horizon_client::hud::rgba(r, g, b, 255)) - }) - .collect() -} diff --git a/crates/horizon-client/src/game/chiseled_bookshelf.rs b/crates/horizon-client/src/game/chiseled_bookshelf.rs new file mode 100644 index 000000000..5d383b4ea --- /dev/null +++ b/crates/horizon-client/src/game/chiseled_bookshelf.rs @@ -0,0 +1,178 @@ +//! Chiseled bookshelves: `ChiseledBookShelfBlock.useItemOn` / `useWithoutItem` +//! (a book into the slot under the crosshair, or out of it) and +//! `ChiseledBookShelfBlockEntity.updateState`, which also follows the books a +//! hopper or dropper moved (`machines::container_changed`). The slots' books +//! show through the block state's `slot_N_occupied`, which reaches a server's +//! clients with the block update. +use super::{Game, Hit, machines::dir_from_name}; +use horizon_client::{containers::BlockEntity, items::ItemStack, mobs::Who}; +use horizon_core::{ + geometry::{Direction, Vec3}, + position::BlockPos, +}; +use horizon_world::level::{flags, hit_slot}; + +const BLOCK: &str = "minecraft:chiseled_bookshelf"; + +impl Game<'_> { + /// `useItemOn` with `held` in the acting hand, then `useWithoutItem` on + /// the main hand's turn: None when the block passes the click, else + /// whether the use succeeded and the arm swings (a click on an empty slot + /// without a book only consumes it). + pub(super) fn use_chiseled_bookshelf( + &mut self, + hit: &Hit, + held: Option<&ItemStack>, + ) -> Option { + let pos = hit.pos; + let state = self.world.block(pos[0], pos[1], pos[2]); + let info = self + .pack + .assets + .registry + .state(state) + .filter(|s| s.name == BLOCK)?; + let facing = info + .properties + .get("facing") + .and_then(|f| dir_from_name(f))?; + let face = Direction::ALL + .into_iter() + .find(|d| d.normal() == hit.face)?; + let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]); + let slot = hit_slot( + facing, + face, + BlockPos::new(pos[0], pos[1], pos[2]), + at, + 2, + 3, + )?; + let occupied = info + .properties + .get(&format!("slot_{slot}_occupied")) + .map(String::as_str) + == Some("true"); + let book = held.filter(|s| { + self.res + .items() + .item_tags + .get("minecraft:bookshelf_books") + .is_some_and(|m| m.contains(&*s.item)) + }); + let centre = pos.map(|v| f64::from(v) + 0.5); + if let Some(book) = book + && !occupied + { + // addBook: one book goes in (a creative player keeps theirs). + let book = book.clone(); + self.stats.add("used", &book.item, 1); + let sound = if &*book.item == "minecraft:enchanted_book" { + "minecraft:block.chiseled_bookshelf.insert.enchanted" + } else { + "minecraft:block.chiseled_bookshelf.insert" + }; + self.bookshelf_items(pos)?[slot] = Some(ItemStack { + count: 1, + ..book.clone() + }); + self.consume_held(); + self.chiseled_bookshelf_update_state(pos, slot); + self.audio.play(sound, Some(centre), 1.0, 1.0); + self.trigger_block("minecraft:item_used_on_block", pos, &book); + return Some(true); + } + // TRY_WITH_EMPTY_HAND: only the main hand goes on to useWithoutItem. + if self.hand != horizon_client::first_person::Hand::Main { + return None; + } + if !occupied { + return Some(false); + } + // removeBook: the book goes to the inventory, or is dropped. + let retrieved = self.bookshelf_items(pos)?[slot].take()?; + self.chiseled_bookshelf_update_state(pos, slot); + let sound = if &*retrieved.item == "minecraft:enchanted_book" { + "minecraft:block.chiseled_bookshelf.pickup.enchanted" + } else { + "minecraft:block.chiseled_bookshelf.pickup" + }; + self.audio.play(sound, Some(centre), 1.0, 1.0); + self.give_or_drop(retrieved); + self.post_block_game_event("minecraft:block_change", pos, Some(Who::Player), None); + Some(true) + } + + /// The bookshelf's six slots (made if the block has no block entity yet). + fn bookshelf_items(&mut self, pos: [i32; 3]) -> Option<&mut [Option; 6]> { + let entity = self + .world + .block_entities + .get_or_insert_with((pos[0], pos[1], pos[2]), || { + BlockEntity::ChiseledBookshelf(Box::default()) + }); + match entity { + BlockEntity::ChiseledBookshelf(b) => Some(&mut b.items), + _ => None, + } + } + + /// `ChiseledBookShelfBlockEntity.updateState`: `slot` becomes the last + /// one touched, the block state takes the slots' occupancy + /// (`setBlockAndUpdate`) and `BLOCK_CHANGE` goes out. + fn chiseled_bookshelf_update_state(&mut self, pos: [i32; 3], slot: usize) { + let key = (pos[0], pos[1], pos[2]); + let Some(BlockEntity::ChiseledBookshelf(b)) = self.world.block_entities.get_mut(&key) + else { + return; + }; + b.last_slot = slot as i32; + let occupied: Vec = b.items.iter().map(Option::is_some).collect(); + let registry = self.pack.assets.registry; + let Some(mut state) = registry + .state(self.world.block(pos[0], pos[1], pos[2])) + .cloned() + else { + return; + }; + for (i, occupied) in occupied.into_iter().enumerate() { + state + .properties + .insert(format!("slot_{i}_occupied"), occupied.to_string()); + } + let Some(new) = registry.id(&state) else { + return; + }; + let at = BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| b.set_block(level, ticks, at, new, flags::UPDATE_ALL)); + self.world.modified.insert((pos[0] >> 4, pos[2] >> 4)); + self.post_block_game_event("minecraft:block_change", pos, None, Some(new)); + } + + /// The books a hopper or dropper put in or took out: the slot whose + /// occupancy no longer matches the block state is the one `setItem` or + /// `removeItem` updated. + pub(super) fn chiseled_bookshelf_synced(&mut self, pos: (i32, i32, i32)) { + let Some(BlockEntity::ChiseledBookshelf(b)) = self.world.block_entities.get(&pos) else { + return; + }; + let Some(info) = self + .pack + .assets + .registry + .state(self.world.block(pos.0, pos.1, pos.2)) + else { + return; + }; + let moved = (0..6).rev().find(|i| { + let shown = info + .properties + .get(&format!("slot_{i}_occupied")) + .map(String::as_str); + b.items[*i].is_some() != (shown == Some("true")) + }); + if let Some(slot) = moved { + self.chiseled_bookshelf_update_state([pos.0, pos.1, pos.2], slot); + } + } +} diff --git a/crates/horizon-client/src/game/client_ambient.rs b/crates/horizon-client/src/game/client_ambient.rs index 1cf59733d..343390a1a 100644 --- a/crates/horizon-client/src/game/client_ambient.rs +++ b/crates/horizon-client/src/game/client_ambient.rs @@ -17,8 +17,10 @@ impl Game<'_> { return; } let mut events = Vec::new(); + let random = self.particles.level_random(); for m in self.mobs.iter_mut().filter(|m| !m.removed) { ambient::client_ai_step(m, &mut events); + ambient::client_particles(m, random, &mut events); } for event in events { match event { @@ -37,6 +39,7 @@ impl Game<'_> { } } self.eye_particles(); + self.panda_effects(); self.sprint_dust(); self.effect_swirls(); } diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs index f125899f3..808f489c7 100644 --- a/crates/horizon-client/src/game/combat.rs +++ b/crates/horizon-client/src/game/combat.rs @@ -42,6 +42,10 @@ pub(super) struct CombatTracker { /// The projectile hitting the player now is another player's that /// `ServerPlayer.canHarmPlayer` refuses (the `pvp` rule, an ally). pub(super) refuse_player_hit: bool, + /// The player whose melee hit is landing on the player now: where they + /// stand and the seconds their weapon disables a shield for + /// (`getSecondsToDisableBlocking`). + pub(super) player_attacker: Option<([f64; 3], f32)>, /// The mob exploding now (`ServerExplosion.source`): its team's friendly /// fire decides whom the blast may hurt. pub(super) explosion_source: Option, diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 43cdfa51c..ea628917e 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1162,6 +1162,17 @@ impl Game<'_> { // An air stack is empty: nothing is given (but the message still is). let empty = id == "minecraft:air"; for &t in targets.iter().filter(|_| !empty) { + // The player's UUID, which an item they could not hold is set to. + let conn = match t { + Target::Guest(conn) => Some(conn), + _ => self.lan_acting, + }; + let uuid = match conn { + Some(conn) => self + .command_guest(conn) + .map(|g| horizon_client::lan::playerdata::uuid_ints(g.uuid)), + None => Some(self.level.ensure_player_uuid()), + }; self.for_player(t, |g| { let mut remaining = count; while remaining > 0 { @@ -1178,8 +1189,19 @@ impl Game<'_> { .target_position(Target::Player) .unwrap_or(g.source_position()); if let Some(rest) = left { - // Inventory full: drop the rest at the player's feet without pickup delay. - g.spawn_item(rest, [p[0], p[1] + 1.32, p[2]], [0.0, 0.0, 0.0], 0); + // Inventory full: Player.createItemStackToDrop (thrown from + // the eyes), then setNoPickUpDelay and setTarget(player). + let eye = g.eye_position().unwrap_or([ + p[0], + p[1] + g.target_eye_height(Target::Player), + p[2], + ]); + g.throw_from_eyes(rest, eye, false); + if let Some(item) = g.dropped.last_mut() { + item.thrower = None; + item.pickup_delay = 0; + item.target = uuid; + } } else { let r = &mut g.world.random; let pitch = ((r.next_float() - r.next_float()) * 0.7 + 1.0) * 2.0; @@ -1447,7 +1469,7 @@ impl Game<'_> { { return Err(err("commands.teleport.invalidPosition", &[])); } - let mut rotation = match ctx.get("rotation") { + let rotation = match ctx.get("rotation") { Some(Arg::Coords(c)) => Some(c.rotation(self.source_rotation())), _ => None, }; @@ -1462,21 +1484,31 @@ impl Game<'_> { (Some(f), _) => Some(f), (None, Some(_)) => { let e = self.entities(ctx, "facingEntity", false)?[0]; + // EntityAnchorArgument.Anchor.apply: the feet, or the eyes. let eyes = matches!(ctx.get("facingAnchor"), Some(Arg::Anchor(true))); + let eye_height = if eyes { self.target_eye_height(e) } else { 0.0 }; self.target_position(e) - .map(|p| [p[0], p[1] + if eyes { 1.62 } else { 0.0 }, p[2]]) + .map(|p| [p[0], p[1] + eye_height, p[2]]) } _ => None, }; - if let Some(f) = facing { - let eye = pos[1] + 1.62; + // Entity.lookAt: from the source's anchor (the feet, unless `anchored + // eyes`) on the teleported entity, so the eyes depend on the target. + let anchored_eyes = self.command_source.is_some_and(|s| s.eyes); + let look_at = |this: &Self, t: Target| { + let f = facing?; + let eye = if anchored_eyes { + pos[1] + this.target_eye_height(t) + } else { + pos[1] + }; let (dx, dy, dz) = (f[0] - pos[0], f[1] - eye, f[2] - pos[2]); let horizontal = (dx * dx + dz * dz).sqrt(); - rotation = Some([ + Some([ ((dz.atan2(dx).to_degrees()) - 90.0) as f32, (-(dy.atan2(horizontal).to_degrees())) as f32, - ]); - } + ]) + }; // A server's player in another level than the source's (`execute // in`, the console's Overworld) moves there (ServerPlayer.teleport // into another level), after the command. @@ -1486,6 +1518,7 @@ impl Game<'_> { None => self.dim, }; for &t in &targets { + let rotation = look_at(self, t).or(rotation); if self.teleport_across(t, source_level, pos, rotation) { continue; } @@ -2210,7 +2243,8 @@ impl Game<'_> { let dmax = [dest[0] + size[0], dest[1] + size[1], dest[2] + size[2]]; let overlap = (0..3).all(|i| dest[i] <= max[i] && dmax[i] >= min[i]); let moving = ctx.has("move"); - if !ctx.has("force") && overlap { + // Mode.canOverlap: only the normal mode refuses overlapping regions. + if !ctx.has("force") && !moving && overlap { return Err(err("commands.clone.overlap", &[])); } let area = (0..3).map(|i| i64::from(size[i] + 1)).product::(); @@ -2419,26 +2453,54 @@ impl Game<'_> { let levels = ctx.has("levels"); let unit = if levels { "levels" } else { "points" }; if ctx.has("query") { - let _ = self.entities(ctx, "target", true)?; - let e = &self.experience; - let value = if levels { - e.level - } else { - (e.progress * horizon_client::entities::Experience::needed(e.level) as f32) as i32 - }; + let target = self.entities(ctx, "target", true)?[0]; + // ExperienceCommand.queryExperience: the target's own level or points. + let value = self + .for_player(target, |g| { + let e = &g.experience; + if levels { + e.level + } else { + (e.progress * horizon_client::entities::Experience::needed(e.level) as f32) + as i32 + } + }) + .unwrap_or(0); self.system_message(Text::translate( &format!("commands.experience.query.{unit}"), - &[ - Text::literal(self.acting_player_name()), - Text::literal(value.to_string()), - ], + &[self.target_name(target), Text::literal(value.to_string())], )); return Ok(value); } let targets = self.entities(ctx, "target", true)?; let amount = Self::int(ctx, "amount").unwrap_or(0); - let op = if ctx.has("add") { "add" } else { "set" }; - if op == "add" { + let add = ctx.has("add"); + let op = if add { "add" } else { "set" }; + // Every target changes (a set of points can be refused for some). + let changed: Vec = targets + .iter() + .copied() + .filter(|&t| { + self.for_player(t, |g| g.change_experience(add, levels, amount)) == Some(true) + }) + .collect(); + if changed.is_empty() { + return Err(err("commands.experience.set.points.invalid", &[])); + } + let (key, who) = match changed[..] { + [only] => ("single", self.target_name(only)), + _ => ("multiple", Text::literal(changed.len().to_string())), + }; + self.feedback(Text::translate( + &format!("commands.experience.{op}.{unit}.success.{key}"), + &[Text::literal(amount.to_string()), who], + )); + Ok(changed.len() as i32) + } + /// ExperienceCommand's add and set on the player in place: false when + /// the points to set do not fit the level. + fn change_experience(&mut self, add: bool, levels: bool, amount: i32) -> bool { + if add { if levels { self.experience.level = (self.experience.level + amount).max(0); if self.experience.level == 0 && amount < 0 { @@ -2452,26 +2514,11 @@ impl Game<'_> { } else { let needed = horizon_client::entities::Experience::needed(self.experience.level); if amount > needed - 1 { - return Err(err("commands.experience.set.points.invalid", &[])); + return false; } self.experience.progress = amount as f32 / needed as f32; } - let key = format!( - "commands.experience.{op}.{unit}.success.{}", - if targets.len() == 1 { - "single" - } else { - "multiple" - } - ); - self.feedback(Text::translate( - &key, - &[ - Text::literal(amount.to_string()), - Text::literal(self.acting_player_name()), - ], - )); - Ok(targets.len() as i32) + true } fn cmd_gamerule(&mut self, ctx: &Context) -> R { let Some(name) = ctx.literals.get(1).cloned() else { @@ -2556,21 +2603,26 @@ impl Game<'_> { }; let yaw = ((rot[0] + 180.0).rem_euclid(360.0)) - 180.0; let pitch = rot[1].clamp(-90.0, 90.0); - // SetSpawnCommand: a forced point in the source's level. - if self.dim == Dim::Overworld { - self.spawn = Some(Vec3::new( - f64::from(pos[0]) + 0.5, - f64::from(pos[1]), - f64::from(pos[2]) + 0.5, - )); - self.respawn_config = None; - } else { - self.spawn = None; - self.respawn_config = Some(super::respawn_anchor::RespawnConfig { - dim: self.dim, - pos, - yaw, - forced: true, + // SetSpawnCommand: a forced point in the source's level, for each target. + let level = self.dim; + for &t in &targets { + self.for_player(t, |g| { + if level == Dim::Overworld { + g.spawn = Some(Vec3::new( + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + )); + g.respawn_config = None; + } else { + g.spawn = None; + g.respawn_config = Some(super::respawn_anchor::RespawnConfig { + dim: level, + pos, + yaw, + forced: true, + }); + } }); } let dim = Text::literal(self.dim.id()); @@ -2750,6 +2802,44 @@ impl Game<'_> { }, }; let max = Self::int(ctx, "maxCount").unwrap_or(-1); + let counting = max == 0; + // ClearInventoryCommands.clearInventory: each player on their own. + let mut removed = 0i32; + let mut found = Vec::new(); + for &t in &targets { + let n = self + .for_player(t, |g| g.clear_matching(&predicate, max)) + .unwrap_or(0); + removed += n; + if n != 0 { + found.push(t); + } + } + if removed == 0 { + return Err(if targets.len() == 1 { + CommandError::new(Text::translate( + "clear.failed.single", + &[self.target_name(targets[0])], + )) + } else { + err("clear.failed.multiple", &[&targets.len()]) + }); + } + let kind = if counting { "test" } else { "success" }; + let (key, who) = match found[..] { + [only] => ("single", self.target_name(only)), + _ => ("multiple", Text::literal(found.len().to_string())), + }; + self.feedback(Text::translate( + &format!("commands.clear.{kind}.{key}"), + &[Text::literal(removed.to_string()), who], + )); + Ok(removed) + } + /// Inventory.clearOrCountMatchingItems for the player in place: `max` + /// of the matching items go (all when negative, none and only counted + /// when 0). Returns how many matched. + fn clear_matching(&mut self, predicate: &ItemInput, max: i32) -> i32 { let counting = max == 0; // Inventory slots 0..40: main, armor feet to head, off hand; // then clearOrCountMatchingItems visits the crafting grid and carried stack. @@ -2765,10 +2855,7 @@ impl Game<'_> { }; let matching: Vec = all(self) .iter() - .map(|s| { - s.as_ref() - .is_some_and(|s| self.stack_matches(&predicate, s)) - }) + .map(|s| s.as_ref().is_some_and(|s| self.stack_matches(predicate, s))) .collect(); let mut slots: Vec<&mut Option> = Vec::new(); slots.extend(self.inventory.iter_mut()); @@ -2798,25 +2885,7 @@ impl Game<'_> { } } } - if removed == 0 { - return Err(if targets.len() == 1 { - CommandError::new(Text::translate( - "clear.failed.single", - &[Text::literal(self.acting_player_name())], - )) - } else { - err("clear.failed.multiple", &[&targets.len()]) - }); - } - let kind = if counting { "test" } else { "success" }; - self.feedback(Text::translate( - &format!("commands.clear.{kind}.single"), - &[ - Text::literal(removed.to_string()), - Text::literal(self.acting_player_name()), - ], - )); - Ok(removed) + removed } /// `PoiTypes`: the point of interest type of a block state. fn poi_type(&self, state: horizon_world::registry::BlockStateId) -> Option<&'static str> { diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs index 39587fa00..952e7d806 100644 --- a/crates/horizon-client/src/game/commands/world_cmds.rs +++ b/crates/horizon-client/src/game/commands/world_cmds.rs @@ -105,6 +105,7 @@ impl Game<'_> { match ty.trim_start_matches("minecraft:") { "player_attack" => DamageKind::PlayerAttack, "mace_smash" => DamageKind::MaceSmash, + "spear" => DamageKind::Spear, "mob_attack" | "mob_attack_no_aggro" => DamageKind::MobAttack, "arrow" => DamageKind::Arrow, "thrown" | "trident" | "mob_projectile" => DamageKind::Thrown, @@ -118,7 +119,8 @@ impl Game<'_> { "dry_out" => DamageKind::DryOut, "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic, "sting" => DamageKind::Sting, - "cactus" | "sweet_berry_bush" => DamageKind::Cactus, + "cactus" => DamageKind::Cactus, + "sweet_berry_bush" => DamageKind::SweetBerryBush, "freeze" => DamageKind::Freeze, "in_wall" => DamageKind::InWall, "thorns" => DamageKind::Thorns, @@ -1219,7 +1221,7 @@ impl Game<'_> { /// LivingEntity.stopRiding for a mob: off its vehicle /// (Entity.removePassenger), then to where the vehicle lets it out /// (LivingEntity.dismountVehicle). - fn dismount_mob(&mut self, rider: u32) { + pub(in crate::game) fn dismount_mob(&mut self, rider: u32) { let Some(i) = self.mobs.iter().position(|m| m.id == rider) else { return; }; diff --git a/crates/horizon-client/src/game/copper_golems.rs b/crates/horizon-client/src/game/copper_golems.rs index db4e03b0b..1bb73d51d 100644 --- a/crates/horizon-client/src/game/copper_golems.rs +++ b/crates/horizon-client/src/game/copper_golems.rs @@ -204,6 +204,64 @@ impl Game<'_> { } } // ---- interactions ----------------------------------------------------- + /// `WeatheringCopperGolemStatueBlock.useItemOn`: an axe on an unoxidized + /// statue turns it back into a golem (`CopperGolemStatueBlockEntity.removeStatue`), + /// wearing the axe. Weathered statues are scraped by the axe's own + /// transform instead. + pub(super) fn use_golem_statue(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> bool { + if !held.is_some_and(|s| s.item.ends_with("_axe")) { + return false; + } + let registry = self.pack.assets.registry; + let Some(state) = registry.state(self.world.block(pos[0], pos[1], pos[2])) else { + return false; + }; + if state.name != "minecraft:copper_golem_statue" { + return false; + } + // `Direction.toYRot` of the statue's facing. + let yaw = match state.properties.get("facing").map(String::as_str) { + Some("west") => 90.0, + Some("north") => 180.0, + Some("east") => 270.0, + _ => 0.0, + }; + let waterlogged = state + .properties + .get("waterlogged") + .is_some_and(|w| w == "true"); + // initCopperGolem: at the block's feet, facing as the statue does. + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + ]; + let Some(id) = self.spawn_mob("minecraft:copper_golem", at, true) else { + return false; + }; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + m.yaw = yaw; + m.previous_yaw = yaw; + m.body_yaw = yaw; + m.previous_body_yaw = yaw; + m.head_yaw = yaw; + m.previous_head_yaw = yaw; + } + self.damage_held(1); + self.audio + .play("minecraft:entity.copper_golem.spawn", Some(at), 1.0, 1.0); + // Level.removeBlock(pos, false): air, or the water the statue stood in. + let replacement = registry.default_state(if waterlogged { + "minecraft:water" + } else { + "minecraft:air" + }); + if let Some(replacement) = replacement { + let _ = self.level_set(pos, replacement); + } + self.world.block_entities.remove(&(pos[0], pos[1], pos[2])); + true + } /// `CopperGolem.mobInteract`; true when handled. pub(super) fn interact_copper_golem(&mut self, index: usize, item: &str) -> bool { if self.mobs[index].species() != Species::CopperGolem || !self.mobs[index].alive() { diff --git a/crates/horizon-client/src/game/creative_hotbar.rs b/crates/horizon-client/src/game/creative_hotbar.rs new file mode 100644 index 000000000..81e5ad6c4 --- /dev/null +++ b/crates/horizon-client/src/game/creative_hotbar.rs @@ -0,0 +1,39 @@ +//! The creative toolbars, `hotbar.nbt` beside `options.txt`: hold the save or +//! load key and press a hotbar key (`Minecraft.handleKeybinds`). +use super::Game; +use horizon_client::{hotbar, keybinds, text::Text}; + +impl Game<'_> { + /// Whether the key bound to `mapping` is held. + pub(super) fn mapped_key_down(&self, mapping: &str) -> bool { + keybinds::key_code(self.settings.keys.get(mapping)) + .is_some_and(|k| self.physical_keys.contains(&k)) + } + + /// `CreativeModeInventoryScreen.handleHotbarLoadOrSave` for the hotbar key + /// `index`: load puts the saved row in the hotbar (the creative slot + /// packets follow from the inventory change), save stores the hotbar and + /// says so on the action bar. + pub(super) fn hotbar_load_or_save(&mut self, index: usize, load: bool) { + let path = Self::options_path().with_file_name("hotbar.nbt"); + let known = |id: &str| self.res.items().get(id).is_some(); + let mut rows = hotbar::load(&path, &known); + if load { + for (slot, stack) in rows[index].iter().enumerate() { + self.inventory[slot] = stack.clone(); + } + return; + } + rows[index] = self.inventory[..hotbar::SIZE].to_vec(); + let _ = hotbar::save(&path, &rows); + let key = |mapping: &str| keybinds::display_name(self.settings.keys.get(mapping)); + let message = Text::translate( + "inventory.hotbarSaved", + &[ + key("key.loadToolbarActivator"), + key(&format!("key.hotbar.{}", index + 1)), + ], + ); + self.titles.set_overlay(message, false); + } +} diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 34319d462..a9bf19c07 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -21,7 +21,7 @@ use horizon_client::{ text::Text, }; use horizon_core::{ - geometry::{Aabb, Vec3, traverse_blocks}, + geometry::{Aabb, Direction, Vec3, traverse_blocks}, position::BlockPos, random::RandomSource, }; @@ -46,6 +46,12 @@ pub(super) struct Creatures { pub projectiles: Vec, /// Wind bursts from a guest's turn, waiting for it to end (game/wind.rs). pub wind_bursts: Vec, + /// Mace smash knockback on the other players from a guest's turn, waiting + /// for it to end (game/mace.rs). + pub smash_pushes: Vec, + /// Sweep attacks from a guest's turn, waiting for it to end + /// (game/lan_pvp.rs). + pub sweeps: Vec, /// Explosion packets from a guest's turn, waiting for it to end /// (centre, small, radius, blocks hit; game/lan_particles.rs). pub lan_explosions: Vec<([f64; 3], bool, f32, usize)>, @@ -53,6 +59,10 @@ pub(super) struct Creatures { pub elder_apparition: i32, /// The wandering trader spawner's clock. pub trader: super::wandering_trader::Spawner, + /// When each player last put a parrot on a shoulder (`timeEntitySatOnShoulder`). + pub shoulder_time: std::collections::HashMap<[i32; 4], i64>, + /// The cat spawner's countdown (`CatSpawner.nextTick`). + pub cat_tick: i32, /// Particles from a guest's turn, waiting for it to end /// (`lan_send_particles`: options, centre, spread, speed, count). pub lan_particles: Vec<( @@ -196,6 +206,7 @@ impl Game<'_> { // EntitySelector.NO_CREATIVE_OR_SPECTATOR. creative: self.creative || self.spectator(), sneaking: self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft), + swimming: p.swimming, look: view_vector(self.yaw, self.pitch), main_hand: self.held().map(|s| s.item.clone()), off_hand: None, @@ -208,6 +219,8 @@ impl Game<'_> { last_hurt: self.combat.last_hurt_mob.map(|(id, at)| (Who::Mob(id), at)), velocity: p.velocity, yaw: self.yaw, + sprinting: p.sprinting, + riding: self.riding.is_some(), hero: self.potions.effects.get("hero_of_the_village").is_some(), effects: self.potions.effects.list.iter().map(|e| e.id).collect(), uuid: self.level.player_uuid.unwrap_or_default(), @@ -443,9 +456,10 @@ impl Game<'_> { teams: std::sync::Arc::new(self.mob_teams()), items: Some(self.res.items()), lid_openers: &self.lid_openers, + // The first player in the level: a server has no player of its own. difficulty: self.local_difficulty( - self.player - .as_ref() + self.level_players() + .first() .map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]), ), } @@ -499,6 +513,8 @@ impl Game<'_> { if self.ui.rules.bool("spawn_mobs") { self.tick_wandering_trader(); self.tick_patrol_spawner(); + self.tick_cat_spawner(); + self.tick_village_siege(); } self.tick_raids(); self.tick_creature_entities() @@ -581,6 +597,9 @@ impl Game<'_> { ..base.clone() }; let m = &mut mobs[i]; + // getCurrentDifficultyAt(blockPosition()): the mob's own chunk, + // not the local player's (a server thread has no player). + w.difficulty = self.local_difficulty([m.position.x, m.position.y, m.position.z]); w.nearest_player = super::natural_spawning::nearest_player( &players, m.position.x, @@ -726,6 +745,7 @@ impl Game<'_> { self.tick_projectiles()?; self.tick_fangs(); self.tick_allays(); + self.tick_pandas(); self.tick_breeze_effects(); self.tick_sniffer_effects(); self.piglin_pickups(); @@ -760,11 +780,12 @@ impl Game<'_> { let by_player = killer.is_some() || m.ai.last_hurt_by_player > 0; let mut dying = m.clone(); // LivingEntity.die: the death is heard, and a sculk catalyst nearby - // takes the experience (before the loot is dropped). + // takes the experience (before the loot is dropped). It takes what + // would drop, whoever killed the mob. self.sculk_mob_died(m); let consumed = self.catalyst_takes_experience([m.position.x, m.position.y, m.position.z], |_| { - if by_player { + if horizon_client::mobs::drops::drops_experience(&dying) { horizon_client::mobs::drops::base_experience(&mut dying).max(0) as u32 } else { 0 @@ -924,6 +945,55 @@ impl Game<'_> { } } } + /// Melee or ranged damage to another mob; whether the hit landed. + fn mob_hits_mob(&mut self, target: u32, amount: f32, source: Damage) -> bool { + let mut killed = false; + let mut hurt = false; + let mut infested = false; + if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) { + let hit = t.damage(amount, source); + hurt = hit; + if hit { + killed = !t.alive(); + // The hurt or death sound the mob raised. + let center = t.center(); + for event in std::mem::take(&mut t.outbox) { + match event { + MobEvent::Sound(s, _, volume, pitch) => { + self.audio + .play(&format!("minecraft:{s}"), Some(center), volume, pitch); + } + MobEvent::Infested { .. } => infested = true, + other => { + // Left for the end of the tick. + t.outbox.push(other); + } + } + } + } + } + if infested { + self.mob_infested(target); + } + if hurt + && let Some(Who::Mob(attacker)) = source.attacker + && let Some(m) = self + .mobs + .iter() + .find(|m| m.id == attacker && m.species() == Species::Axolotl) + { + self.audio.play( + "minecraft:entity.axolotl.attack", + Some([m.position.x, m.position.y, m.position.z]), + 1.0, + 1.0, + ); + } + if killed && let Some(Who::Mob(killer)) = source.attacker { + self.zombie_killed(killer, target); + } + hurt + } /// `InfestedMobEffect.onMobHurt` for a mob: silverfish from half its height up. pub(super) fn mob_infested(&mut self, mob: u32) { if let Some(m) = self.mobs.iter().find(|m| m.id == mob) { @@ -1003,6 +1073,20 @@ impl Game<'_> { MobEvent::EntityEvent { mob, event, at } => { self.lan_entity_event(mob as i32, event, at) } + MobEvent::LevelParticles { + kind, + at, + spread, + speed, + count, + } => { + if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) { + let options = horizon_client::particles::ParticleOptions::simple(ty); + self.particles + .send_particles(&options, at, spread, speed, count); + self.lan_level_particles(&options, at, spread, speed, count); + } + } MobEvent::Sound(name, at, volume, pitch) | MobEvent::LocalSound(name, at, volume, pitch) => { self.audio @@ -1031,6 +1115,18 @@ impl Game<'_> { MobEvent::AttackPlayer(amount, from) => { self.mob_hits_player(amount, from, "minecraft:mob_attack"); } + // doHurtTarget: the effect only when hurtServer took damage. + MobEvent::AttackPlayerWithEffect { + amount, + from, + effect, + ticks, + amplifier, + } => { + if self.mob_hits_player(amount, from, "minecraft:mob_attack") { + self.give_player_effect(effect, ticks, amplifier); + } + } MobEvent::DamagePlayer { amount, from, kind } => { self.mob_hits_player(amount, from, kind); } @@ -1050,6 +1146,19 @@ impl Game<'_> { } } } + MobEvent::Knockback { + target, + power, + x, + z, + } => match target { + Who::Player => self.knock_back_player(power, x, z), + Who::Mob(id) => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + m.knockback(power, x, z); + } + } + }, MobEvent::Shift { target, delta } => { let d = Vec3::new(delta[0], delta[1], delta[2]); match target { @@ -1116,54 +1225,48 @@ impl Game<'_> { amount, source, } => { - let mut killed = false; - let mut hurt = false; - let mut infested = false; - if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) { - let hit = t.damage(amount, source); - hurt = hit; - if hit { - killed = !t.alive(); - // The hurt or death sound the mob raised. - let center = t.center(); - for event in std::mem::take(&mut t.outbox) { - match event { - MobEvent::Sound(s, _, volume, pitch) => { - self.audio.play( - &format!("minecraft:{s}"), - Some(center), - volume, - pitch, - ); - } - MobEvent::Infested { .. } => infested = true, - other => { - // Left for the end of the tick. - t.outbox.push(other); - } - } - } + self.mob_hits_mob(target, amount, source); + } + MobEvent::SonicBoom { + target, + attacker, + from, + direction, + } => { + // SonicBoom: the push only follows a hit that landed, scaled + // by the target's KNOCKBACK_RESISTANCE. + let (hurt, resistance) = match target { + Who::Player => { + let hurt = self.mob_hits_player(10.0, from, "minecraft:sonic_boom"); + let resistance = self.player.as_mut().map_or(0.0, |p| { + p.attribute("minecraft:knockback_resistance").unwrap_or(0.0) + }); + (hurt, resistance) } - } - if infested { - self.mob_infested(target); - } - if hurt - && let Some(Who::Mob(attacker)) = source.attacker - && let Some(m) = self - .mobs - .iter() - .find(|m| m.id == attacker && m.species() == Species::Axolotl) - { - self.audio.play( - "minecraft:entity.axolotl.attack", - Some([m.position.x, m.position.y, m.position.z]), - 1.0, - 1.0, - ); - } - if killed && let Some(Who::Mob(killer)) = source.attacker { - self.zombie_killed(killer, target); + Who::Mob(id) => { + let source = Damage { + kind: DamageKind::SonicBoom, + attacker: Some(Who::Mob(attacker)), + from: Some(from), + }; + let hurt = self.mob_hits_mob(id, 10.0, source); + let resistance = self + .mobs + .iter() + .find(|m| m.id == id) + .map_or(0.0, |m| self.mob_knockback_resistance(m)); + (hurt, resistance) + } + }; + if hurt { + let horizontal = 2.5 * (1.0 - resistance); + let vertical = 0.5 * (1.0 - resistance); + let velocity = [ + direction[0] * horizontal, + direction[1] * vertical, + direction[2] * horizontal, + ]; + self.handle_mob_events(vec![MobEvent::Push { target, velocity }])?; } } MobEvent::FinishAdmiring { mob } => self.finish_admiring(mob), @@ -1193,6 +1296,7 @@ impl Game<'_> { } MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob), MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive), + MobEvent::ParrotToShoulder { mob } => self.parrot_to_shoulder(mob), MobEvent::Infested { mob } => self.mob_infested(mob), MobEvent::Gift { target, item } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target) @@ -1211,6 +1315,14 @@ impl Game<'_> { m.ai.target = Some(target); } } + MobEvent::HuntHoglin { mob, target, ticks } => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + m.extra.ints[0] = ticks; + if m.ai.target.is_none() { + m.ai.target = Some(Who::Mob(target)); + } + } + } MobEvent::Projectile(mut p) => { self.next_entity += 1; p.id = self.next_entity; @@ -1306,8 +1418,50 @@ impl Game<'_> { self.world.set(pos[0], pos[1], pos[2], state)?; } } + MobEvent::Infest { + pos, + infested, + poof, + } => { + let registry = &self.pack.assets.registry; + let old = self.world.block(pos[0], pos[1], pos[2]); + if let Some(mut state) = registry.state(old).cloned() { + let (from, to) = if infested { + ("minecraft:", "minecraft:infested_") + } else { + ("minecraft:infested_", "minecraft:") + }; + state.name = state.name.replacen(from, to, 1); + if let Ok(id) = registry.resolve(&state) { + self.world.set(pos[0], pos[1], pos[2], id)?; + } + } + if let Some(mob) = poof { + self.mob_poof(mob); + } + } MobEvent::BreakBlock { pos, drop } => { let old = self.world.block(pos[0], pos[1], pos[2]); + // InfestedBlock.spawnAfterBreak: its silverfish comes out + // when blocks drop. + if drop + && self + .res + .facts() + .get(old) + .name + .starts_with("minecraft:infested_") + && self.ui.rules.bool("block_drops") + { + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]), + f64::from(pos[2]) + 0.5, + ]; + if let Some(id) = self.spawn_mob("minecraft:silverfish", at, false) { + self.mob_poof(id); + } + } // Block.spawnDestroyParticles: fire breaks leave nothing. if !self.res.facts().get(old).has_class("BaseFireBlock") { self.destroy_particles(pos, old); @@ -1395,6 +1549,27 @@ impl Game<'_> { .list .retain(|e| e.id != "mining_fatigue"); } + MobEvent::DolphinTreasure { mob } => { + // ServerLevel.findNearestMapStructure(#dolphin_located, 50). + let Some(at) = self.mobs.iter().find(|m| m.id == mob).map(|m| { + [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ] + }) else { + continue; + }; + let names = self.structure_tag("minecraft:dolphin_located"); + let found = self + .end + .locator() + .filter(|_| !names.is_empty()) + .and_then(|t| t.locate(&names, at, 50)); + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + m.extra.home = found.map(|(_, p)| p); + } + } MobEvent::EffectPlayer { effect, ticks, @@ -1478,6 +1653,7 @@ impl Game<'_> { m.ai.aggressive |= aggressive; } } + MobEvent::PandaSneezed { mob } => self.panda_sneezed(mob), MobEvent::ShedScute { mob, at, pitch } => { // The mob already checked `shouldDropLoot` (a baby, `mob_drops`). let table = "minecraft:gameplay/armadillo_shed"; @@ -1495,8 +1671,12 @@ impl Game<'_> { self.post_game_event("minecraft:entity_place", at, ctx); } MobEvent::GiftLoot { mob, table, at } => { - // Turtle.ageBoundaryReached: only with mob loot on. - if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops") + // Turtle.ageBoundaryReached and Panda.afterSneeze: only + // with mob loot on. + if matches!( + table, + "minecraft:gameplay/turtle_grow" | "minecraft:gameplay/panda_sneeze" + ) && !self.ui.rules.bool("mob_drops") { continue; } @@ -1735,6 +1915,13 @@ impl Game<'_> { self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp); return; } + // Panda.getBreedOffspring: genes from both parents. + if p.species() == Species::Panda { + horizon_client::mobs::panda::inherit(child, &p, q.as_ref().unwrap_or(&p)); + let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32; + self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp); + return; + } // Nautilus.getBreedOffspring: a tame parent's baby is tame too. if p.species() == Species::Nautilus && p.extra.tame { child.extra.tame = true; @@ -1743,6 +1930,10 @@ impl Game<'_> { } // Offspring inherit a parent's variant (pigs/cows/chickens) or mixed wool. child.extra.variant = p.extra.variant; + // Fox.getBreedOffspring: either parent's variant. + if p.species() == Species::Fox && !coin { + child.extra.variant = q.as_ref().map_or(p.extra.variant, |q| q.extra.variant); + } if p.species() == Species::Sheep { child.extra.color = p.extra.color; } @@ -2303,6 +2494,22 @@ impl Game<'_> { 8.0, ) } + /// `BellBlock.onProjectileHit`: a projectile that strikes the bell proper + /// rings it, and a player's shot counts as the player's ring. + fn bell_projectile_hit(&mut self, p: &Projectile, pos: [i32; 3], at: Vec3, face: [i32; 3]) { + let Some(face) = Direction::ALL.into_iter().find(|d| d.normal() == face) else { + return; + }; + let block = BlockPos::new(pos[0], pos[1], pos[2]); + let rang = self + .with_level(|b, level, ticks| b.bell_projectile_hit(level, ticks, block, face, at.y)); + if rang { + let _ = self.process_level_events(); + if p.owner == Some(Who::Player) { + self.stats.custom("bell_ring", 1); + } + } + } /// What an arrow's tick asked for: its particles and sounds. fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) { use horizon_client::arrows::{ArrowEvent, ArrowParticle, ArrowSound, BlockReaction}; @@ -2445,6 +2652,13 @@ impl Game<'_> { } } pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> { + // Projectile.onHitBlock: BlockState.onProjectileHit, for every + // projectile (a wind charge out of the world's top has no face). + if let Hit::Block { pos, at, face } = hit + && face != [0; 3] + { + self.bell_projectile_hit(p, pos, at, face); + } self.combat.projectile_owner = match p.owner { Some(Who::Mob(id)) => Some(id), _ => None, @@ -2619,6 +2833,17 @@ impl Game<'_> { }; self.player_hit(&victim, "minecraft:arrow", Some(direct), amount); } + // AbstractArrow.onHitEntity: KILLED_BY_ARROW for a kill + // (piercing arrows are not modelled). + if hurt + && let Some(m) = self.mobs.iter().find(|m| m.id == id) + && !m.alive() + { + let victim = self.mob_entity(m); + let weapon = + p.arrow.as_ref().and_then(|a| a.fired_from_weapon.as_ref()); + self.trigger_killed_by_arrow(&[victim], weapon); + } } hurt } @@ -2922,7 +3147,7 @@ impl Game<'_> { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) && m.damage(4.0, source) { - m.extra.levitation = 200; + m.add_effect("minecraft:levitation", 200, 0); // Shulker.hurtServer: a shulker hit by a bullet. horizon_client::mobs::shulker::hit_by_bullet(m); } @@ -3047,6 +3272,14 @@ impl Game<'_> { let creative = self.creative; // The hand's slot (Player.interactOn passes the hand). let selected = self.held_slot(); + // Panda.mobInteract: bamboo, or a click on a panda lying on its back. + if self.mobs[index].species() == Species::Panda && self.mobs[index].alive() { + let taken = self.interact_panda(index, &item); + if taken { + self.swing_arm(); + } + return Ok(taken); + } if self.interact_zombie_villager(index, &item) { return Ok(true); } @@ -3078,6 +3311,10 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.interact_shear_mob(index, &item) { + self.swing_arm(); + return Ok(true); + } // AbstractHorse.mobInteract: feed, equip or ride. if self.interact_mount(index, &item) { self.swing_arm(); @@ -3102,18 +3339,36 @@ impl Game<'_> { .item_tags .get("minecraft:creeper_igniters") .is_some_and(|t| t.contains(&*item)); + let fish = self + .res + .items() + .item_tags + .get("minecraft:fishes") + .is_some_and(|t| t.contains(&*item)); let damageable = self .res .items() .get(&item) .is_some_and(|i| i.max_damage > 0); + let parrot_poisonous = self + .res + .items() + .item_tags + .get("minecraft:parrot_poisonous_food") + .is_some_and(|t| t.contains(&*item)); let acting = self.acting_player_uuid(); + let sneaking = self.keys.contains(&winit::keyboard::KeyCode::ShiftLeft) + || self.keys.contains(&winit::keyboard::KeyCode::ShiftRight); + let held_damage = held.as_ref().map_or(0, |h| h.damage as i32); + let held_extra = held.as_ref().and_then(|h| h.extra.clone()); let m = &mut self.mobs[index]; if !m.alive() { return Ok(false); } let species = m.species(); let center = m.center(); + // Wolf armor the owner takes off with shears or leaves a dropped stack of. + let mut armor_drop: Option = None; let mut consume = false; let mut give: Option<&str> = None; let mut sound: Option<&str> = None; @@ -3166,6 +3421,7 @@ impl Game<'_> { at: pos, setup, }])?; + self.damage_held_tool(); } Species::Sheep if item == "minecraft:shears" && !m.extra.sheared && !m.is_baby() => { m.extra.sheared = true; @@ -3197,6 +3453,23 @@ impl Game<'_> { handled = false; } } + // Entity.interact: shears take a tamed wolf's armor off for its owner. + Species::Wolf + if item == "minecraft:shears" + && m.extra.tame + && m.extra.owner == Some(acting) + && m.extra.head.is_some() + && !sneaking => + { + let mut stack = ItemStack::new("minecraft:wolf_armor", 1); + stack.damage = m.extra.body_damage.max(0) as u32; + stack.extra = m.extra.body_extra.take(); + armor_drop = Some(stack); + m.extra.head = None; + m.extra.body_damage = 0; + eat = Some(("item.armor.unequip_wolf", 1.0, 1.0)); + self.damage_held_tool(); + } // Wolf.mobInteract: heal, dye the collar or sit/stand when tame; // a bone tames a wild one a third of the time. Species::Wolf if m.extra.tame && is_food && m.health < m.attrs.max_health => { @@ -3205,11 +3478,42 @@ impl Game<'_> { .items() .get(&item) .and_then(|i| i.food.as_ref()) - .map_or(2.0, |f| f.0 as f32); - // TamableAnimal.feed: playEatingSound, which wolves leave empty. + .map_or(2.0, |f| f.0 as f32 * 2.0); + // TamableAnimal.feed(.., 2.0F, 2.0F): heals twice the nutrition, + // then playEatingSound, which wolves leave empty. m.health = (m.health + heal).min(m.attrs.max_health); consume = true; } + // Wolf.mobInteract: the owner puts wolf armor on a tamed adult. + Species::Wolf + if item == "minecraft:wolf_armor" + && m.extra.tame + && m.extra.owner == Some(acting) + && m.extra.head.is_none() + && !m.is_baby() => + { + m.extra.head = Some(item.as_str().into()); + m.extra.body_damage = held_damage; + m.extra.body_extra = held_extra; + consume = true; + eat = Some(("item.armor.equip_wolf", 1.0, 1.0)); + } + // Wolf.mobInteract: an armadillo scute repairs a sitting wolf's + // armor by an eighth of its durability. + Species::Wolf + if item == "minecraft:armadillo_scute" + && m.extra.tame + && m.extra.owner == Some(acting) + && m.extra.sitting + && m.extra.head.is_some() + && m.extra.body_damage > 0 => + { + m.extra.body_damage = (m.extra.body_damage + - (horizon_client::mobs::WOLF_ARMOR_DURABILITY as f32 * 0.125) as i32) + .max(0); + consume = true; + eat = Some(("item.wolf_armor.repair", 1.0, 1.0)); + } Species::Wolf if m.extra.tame && m.extra.owner == Some(acting) @@ -3329,6 +3633,15 @@ impl Game<'_> { m.position.z.floor() as i32 >> 4, )); } + // Parrot.mobInteract: the owner makes a tame parrot on the ground + // sit or stand (poisonous food is handled apart). + Species::Parrot if m.extra.tame && m.on_ground && !parrot_poisonous => { + m.extra.sitting = !m.extra.sitting; + self.world.modified.insert(( + m.position.x.floor() as i32 >> 4, + m.position.z.floor() as i32 >> 4, + )); + } Species::Cat if !m.extra.tame && is_food => { consume = true; m.persistent = true; @@ -3386,7 +3699,7 @@ impl Game<'_> { let tamed = m.random.next_int_bound(10).unwrap_or(1) == 0; if tamed { m.extra.tame = true; - m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1])); + m.extra.owner = Some(acting); } // TamableAnimal.spawnTamingParticles (entity event 7 or 6). self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 }); @@ -3395,6 +3708,18 @@ impl Game<'_> { self.trigger_entity("minecraft:tame_animal", "entity", &view); } } + // Dolphin.mobInteract: a fish makes a baby grow by a tenth and an + // adult remember it (`gotFish`), to swim to a treasure. + Species::Dolphin if fish => { + eat = Some(("entity.dolphin.eat", 1.0, 1.0)); + if m.extra.age < 0 { + let secs = ((-m.extra.age / 20) as f32 * 0.1) as i32; + horizon_client::mobs::ai::age_up(m, secs, true); + } else { + m.extra.flag = true; + } + consume = true; + } // Tadpole.feed: frog food ages it by a tenth of the time left to // grow into a frog (it grows on its next tick once past 24000). Species::Tadpole if is_food && !m.extra.age_locked => { @@ -3408,6 +3733,22 @@ impl Game<'_> { horizon_client::particles::Burst::HORSE_EATING, ); } + // Bee.mobInteract: a wither rose or an open eyeblossom is eaten for + // its `getBeeInteractionEffect` instead of breeding the bee. + Species::Bee + if is_food + && matches!( + &*item, + "minecraft:wither_rose" | "minecraft:open_eyeblossom" + ) => + { + if &*item == "minecraft:wither_rose" { + m.add_effect("minecraft:wither", 40, 0); + } else { + m.add_effect("minecraft:poison", 25, 0); + } + consume = true; + } // HappyGhast.canFallInLove: never, so only a ghastling takes food. _ if is_food && m.kind.flags.animal @@ -3478,6 +3819,9 @@ impl Game<'_> { self.spawn_item(rest, at, [0.0, 0.0, 0.0], 40); } } + if let Some(stack) = armor_drop { + self.spawn_item(stack, [center[0], center[1] + 0.5, center[2]], [0.0; 3], 10); + } for (item, count) in drops { for _ in 0..count { let v = [ @@ -3500,6 +3844,39 @@ impl Game<'_> { } Ok(true) } + /// `SnowGolem.mobInteract` and `Bogged.mobInteract` with shears: the + /// pumpkin or the mushrooms come off (the shearing loot table), the shear + /// game event is posted and the tool takes one damage. + fn interact_shear_mob(&mut self, index: usize, item: &str) -> bool { + let m = &self.mobs[index]; + if item != "minecraft:shears" || !m.alive() || m.extra.sheared { + return false; + } + let (sound, table, height) = match m.species() { + Species::SnowGolem => ( + "minecraft:entity.snow_golem.shear", + "minecraft:shearing/snow_golem", + m.eye_height(), + ), + Species::Bogged => ( + "minecraft:entity.bogged.shear", + "minecraft:shearing/bogged", + f64::from(m.height()), + ), + _ => return false, + }; + let at = m.position; + let tool = self.held().cloned(); + self.audio.play(sound, Some([at.x, at.y, at.z]), 1.0, 1.0); + self.mobs[index].extra.sheared = true; + for stack in self.sequence_loot(table, table, tool.as_ref()) { + self.spawn_at_location(at, height, stack); + } + let ctx = self.who_context(Some(horizon_client::mobs::Who::Player), None); + self.post_game_event("minecraft:shear", [at.x, at.y, at.z], ctx); + self.damage_held_tool(); + true + } /// `Armadillo.mobInteract`: a brush brushes a scute off an adult /// (`brushOffScute`) and loses 16 durability. fn interact_armadillo(&mut self, index: usize, item: &str) -> bool { @@ -3544,23 +3921,9 @@ impl Game<'_> { } true } + /// `ItemStack.hurtAndBreak(1, ...)` on the held tool: Unbreaking, break sound and stat. pub(super) fn damage_held_tool(&mut self) { - if self.creative { - return; - } - let slot = self.held_slot(); - let max_damage = self - .held() - .and_then(|s| self.res.items().get(&s.item)) - .map_or(0, |i| i.max_damage); - if max_damage > 0 - && let Some(stack) = self.stack_in_mut(slot).as_mut() - { - stack.damage += 1; - if stack.damage >= max_damage { - *self.stack_in_mut(slot) = None; - } - } + self.damage_held(1); } /// Throwables and spawn eggs (SnowballItem/EggItem/EnderpearlItem/SpawnEggItem.use). pub(super) fn throw_item(&mut self, stack: &ItemStack) -> Result { @@ -3862,6 +4225,18 @@ impl Game<'_> { &armor, out, ); + if &*mob.kind.id == "minecraft:player" { + // PlayerRenderer's WingsLayer and SpinAttackEffectLayer. + self.player_elytra_geometry( + mob, + mob.extra.chest.as_deref(), + camera, + alpha as f32, + packed, + out, + ); + self.spin_attack_geometry(mob, camera, alpha as f32, packed, out); + } self.mob_block_geometry(mob, camera, alpha, packed, out); if let Some(rgb) = outline { self.mark_outline(&out[entity_start..], rgb); @@ -4096,6 +4471,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) match kind { K::PlayerAttack => "minecraft:player_attack", K::MaceSmash => "minecraft:mace_smash", + K::Spear => "minecraft:spear", K::MobAttack => "minecraft:mob_attack", K::Arrow => "minecraft:arrow", K::Thrown => "minecraft:thrown", @@ -4112,6 +4488,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) K::Magic => "minecraft:magic", K::Sting => "minecraft:sting", K::Cactus => "minecraft:cactus", + K::SweetBerryBush => "minecraft:sweet_berry_bush", K::Generic => "minecraft:generic", K::InWall => "minecraft:in_wall", K::Thorns => "minecraft:thorns", @@ -4136,6 +4513,7 @@ fn to_loot(stack: &ItemStack) -> horizon_world::loot::LootStack { exploration: None, ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), } } /// A generated loot stack as a Horizon item stack. @@ -4155,6 +4533,9 @@ fn from_loot(stack: &horizon_world::loot::LootStack) -> ItemStack { if let Some(amplifier) = stack.ominous_amplifier.filter(|a| *a > 0) { item.data_mut().ominous_amplifier = Some(amplifier as u8); } + for (id, text) in &stack.names { + item.data_mut().set_loot_name(id, text); + } item } impl Game<'_> { @@ -4168,13 +4549,10 @@ impl Game<'_> { f64::from((pos[0] >> 4) * 16 + 8), f64::from((pos[2] >> 4) * 16 + 8), ]; - let spectator = self.spectator(); - let Some(close) = self.player.as_ref().filter(|_| !spectator).map(|p| { + let close = self.level_players().iter().any(|p| { let (dx, dz) = (p.position.x - centre[0], p.position.z - centre[1]); - dx * dx + dz * dz < 16384.0 - }) else { - return; - }; + !p.spectator && dx * dx + dz * dz < 16384.0 + }); if !close { return; } @@ -4198,6 +4576,9 @@ impl Game<'_> { f64::from(y + 1), f64::from(pos[2]) + 0.5, ]; - let _ = self.spawn_mob("minecraft:zombified_piglin", at, false); + // setPortalCooldown: the new piglin does not travel at once. + if let Some(id) = self.spawn_mob("minecraft:zombified_piglin", at, false) { + self.set_portal_cooldown(id); + } } } diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs index d66610183..0c58b69f9 100644 --- a/crates/horizon-client/src/game/crossbow.rs +++ b/crates/horizon-client/src/game/crossbow.rs @@ -219,6 +219,7 @@ impl Game<'_> { if let Some(a) = arrow.arrow.as_mut() { a.set_item(ammo); a.set_owner(Some(Who::Player)); + a.fired_from_weapon = Some(weapon.clone()); a.pierce = pierce; } arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0); @@ -235,6 +236,11 @@ impl Game<'_> { .play("minecraft:item.crossbow.shoot", Some(eye), 1.0, pitch); self.damage_held(if rocket { 3 } else { 1 }); } + // CrossbowItem.performShooting: SHOT_CROSSBOW with the crossbow, which + // is an empty stack (no match) when the shots broke it. + if let Some(stack) = self.held().cloned() { + self.trigger_item("minecraft:shot_crossbow", &stack); + } } } diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index dc79bf8c1..1b822430b 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -244,7 +244,8 @@ impl Game<'_> { if on { "visible" } else { "hidden" } ) }; - let remote = self.remote.is_some(); + // `DebugScreenOverlay`: the single-player variants for a local server. + let remote = !self.has_singleplayer_server(); let c = &self.debug_charts; [ format!( @@ -463,7 +464,7 @@ impl Game<'_> { height, self.settings.max_fps, 1000.0 / self.clock.rate(), - self.remote.is_some(), + !self.has_singleplayer_server(), ); draws.push(hud_layout::GuiDraw::Push(vec![hud_layout::PoseOp::Scale( scale, scale, diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs index 73c6fd4cc..07f3d6c21 100644 --- a/crates/horizon-client/src/game/dedicated.rs +++ b/crates/horizon-client/src/game/dedicated.rs @@ -412,6 +412,8 @@ struct ServerState { paused: bool, /// `broadcast-console-to-ops`. broadcast_console: bool, + /// `op-permission-level`: what `/op` grants (operatorUserPermissions). + op_level: i32, } /// The dedicated-only commands' replies vanilla sends with `broadcast` @@ -573,6 +575,14 @@ impl Game<'_> { // DedicatedServer.initServer: worldData.setGameType; forceDifficulty. self.set_default_game_mode(game_mode); self.ui.difficulty = props.difficulty as u8; + // DedicatedServer.initServer: a legacy `announce-player-achievements` + // sets the show_advancement_messages rule once, as the file is read. + if let Some(announce) = props.announce_player_achievements { + self.ui.rules.set( + "show_advancement_messages", + horizon_client::gamerules::Value::Bool(announce), + ); + } self.settings.render_distance = props.view_distance.clamp(2, 32); self.settings.simulation_distance = props.simulation_distance.clamp(2, 32); self.streaming.radius = self.settings.render_distance; @@ -663,6 +673,9 @@ impl Game<'_> { return Ok(()); } self.sync_ops(&lists); + if let Some(host) = self.lan.as_mut() { + host.hub.spawn_protection = props.spawn_protection; + } log( "INFO", &format!( @@ -685,6 +698,7 @@ impl Game<'_> { ticks: Default::default(), paused: false, broadcast_console: props.broadcast_console_to_ops, + op_level: props.op_permission_level, }; let pause_after = props.pause_when_empty_seconds * 20; let idle_timeout = props.player_idle_timeout; @@ -946,7 +960,7 @@ impl Game<'_> { let Some(user) = self.resolve(rest[0]) else { return; }; - let level = 4; + let level = state.op_level; let changed = { let mut l = state.lists.lock().unwrap(); if command == "op" { @@ -972,6 +986,10 @@ impl Game<'_> { self.console_reply(Text::translate(key, &[lit(&user.name)])); let lists = state.lists.clone(); self.sync_ops(&lists); + // DeOpCommands.deopPlayers. + if command == "deop" && changed { + self.kick_unlisted_players(&lists); + } } "whitelist" => self.console_whitelist(state, &rest), "ban" if !rest.is_empty() => { @@ -1183,6 +1201,7 @@ impl Game<'_> { ["on"] | ["off"] => { let on = rest[0] == "on"; let mut l = state.lists.lock().unwrap(); + let turned_on = on && !l.use_whitelist; let key = match (on, l.use_whitelist) { (true, true) => "commands.whitelist.alreadyOn", (true, false) => "commands.whitelist.enabled", @@ -1193,6 +1212,10 @@ impl Game<'_> { drop(l); self.store_property("white-list", on.to_string()); self.console_reply(Text::translate(key, &[])); + if turned_on { + let lists = state.lists.clone(); + self.kick_unlisted_players(&lists); + } } ["list"] => { let names: Vec = state @@ -1216,6 +1239,8 @@ impl Game<'_> { ["reload"] => { let _ = state.lists.lock().unwrap().white.load(); self.console_reply(Text::translate("commands.whitelist.reloaded", &[])); + let lists = state.lists.clone(); + self.kick_unlisted_players(&lists); } ["add", name] | ["remove", name] => { let Some(user) = self.resolve(name) else { @@ -1241,6 +1266,10 @@ impl Game<'_> { Vec::new() }; self.console_reply(Text::translate(key, &args)); + if ok && rest[0] == "remove" { + let lists = state.lists.clone(); + self.kick_unlisted_players(&lists); + } } _ => self.console_reply(Text::translate("command.unknown.argument", &[])), } @@ -1256,6 +1285,38 @@ impl Game<'_> { } } + /// MinecraftServer.kickUnlistedPlayers: with `enforce-whitelist` and the + /// whitelist on, whoever is online and not on the whitelist file is + /// disconnected (operators are not spared here). + fn kick_unlisted_players(&mut self, lists: &Arc>) { + let unlisted: Vec = { + let l = lists.lock().unwrap(); + let Some(host) = self.lan.as_ref() else { + return; + }; + if !(l.enforce_whitelist && l.use_whitelist) { + return; + } + host.hub + .guests + .iter() + .filter(|g| { + !l.white.contains(&NameAndId { + id: g.uuid, + name: g.name.clone(), + }) + }) + .map(|g| g.uuid) + .collect() + }; + for uuid in unlisted { + self.kick_uuid( + uuid, + translatable("multiplayer.disconnect.not_whitelisted", &[]), + ); + } + } + fn kick_uuid(&mut self, uuid: u128, reason: Tag) { if let Some(h) = self.lan.as_mut() { let conns: Vec = h diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs index 33da8b5ce..88e56819a 100644 --- a/crates/horizon-client/src/game/dispense_fixture.rs +++ b/crates/horizon-client/src/game/dispense_fixture.rs @@ -672,6 +672,7 @@ impl Game<'_> { } let source = match source.kind { horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash", + horizon_client::mobs::DamageKind::Spear => "minecraft:spear", _ => "minecraft:player_attack", }; out.push(format!( diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs index a0a9bfd93..a34433573 100644 --- a/crates/horizon-client/src/game/dispenser.rs +++ b/crates/horizon-client/src/game/dispenser.rs @@ -1548,6 +1548,7 @@ impl Game<'_> { return Ok((Some(stack), FAIL)); }; let target = (placed.x, placed.y, placed.z); + let state = self.apply_item_block_state([target.0, target.1, target.2], state, &stack)?; if let Some(entity) = BlockEntity::for_block(&self.res.facts().get(state).name) { self.world.block_entities.insert(target, entity); self.apply_placed_item([target.0, target.1, target.2], &stack, false); diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index 250887b30..aaf1dba39 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -1122,14 +1122,11 @@ impl Game<'_> { if !self.before_block(d) || self.mob_hit().is_some_and(|m| m.1 < d) { return false; } - let modifiers = self - .attack_item_info() - .map(|i| (i.attack_damage, i.attack_speed)) - .unwrap_or((0.0, 0.0)); - let speed = (4.0 + modifiers.1).max(0.1); - let scale = ((self.attack_ticks as f32 + 0.5) / (20.0 / speed)).clamp(0.0, 1.0); + let hand_damage = self.attack_item_info().map_or(0.0, |i| i.attack_damage); + let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed()); + let scale = ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0); let mut amount = - (1.0 + modifiers.0 + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8); + (1.0 + hand_damage + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8); let falling = self .player .as_ref() @@ -1465,7 +1462,16 @@ impl Game<'_> { } } let d2 = (pp.x - pos.x).powi(2) + (pp.y - pos.y).powi(2) + (pp.z - pos.z).powi(2); - if d2 < 4096.0 { + // Entity.hasLineOfSight: eye to eye (the dragon's eye is 0.85 of + // its 8 block height), blocks only. + let sees = d2 < 4096.0 && { + let eye = Vec3::new(pos.x, pos.y + 6.8, pos.z); + let target_eye = + tracked.map_or(pp.y + 1.62, |p| p.bounds.max_position().y - 0.18); + self.mob_world_base(&[]) + .line_of_sight(eye, Vec3::new(pp.x, target_eye, pp.z)) + }; + if sees { *charge += 1; let d = self.dragon.as_ref().expect("dragon"); let r = d.yaw.to_radians(); @@ -3020,14 +3026,11 @@ impl Game<'_> { let (a, b) = (room.min_position(), room.max_position()); lo.x < b.x && hi.x > a.x && lo.y < b.y && hi.y > a.y && lo.z < b.z && hi.z > a.z }; - let player = self.player.as_ref().is_some_and(|p| { - let w = f64::from(p.dimensions.width) / 2.0; - let h = f64::from(p.dimensions.height); - touches( - Vec3::new(p.position.x - w, p.position.y, p.position.z - w), - Vec3::new(p.position.x + w, p.position.y + h, p.position.z + w), - ) - }); + // Level.getEntities: the host's player and every guest in the level. + let player = self + .fight_players() + .iter() + .any(|p| !p.spectator && touches(p.bounds.min_position(), p.bounds.max_position())); player || self.crystals.iter().any(|c| { touches( diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs index 5688a3226..6986c5627 100644 --- a/crates/horizon-client/src/game/enchant_effects.rs +++ b/crates/horizon-client/src/game/enchant_effects.rs @@ -3,14 +3,18 @@ //! unbreaking (`minecraft:item_damage`), sharpness/smite/bane and power //! (`minecraft:damage`), knockback, fire aspect, infinity (`minecraft:ammo_use`), //! thorns (`minecraft:post_attack`), mending (`minecraft:repair_with_xp`) and -//! the armor attribute effects (respiration, depth strider, ...) and Soul -//! Speed's `location_changed` and `tick` effects. +//! the armor attribute effects (respiration, depth strider, ...), Soul +//! Speed's `location_changed` and `tick` effects and the +//! `minecraft:location_changed` disk effect (frost walker). use super::Game; use horizon_client::{ enchant::{EffectContext, Enchantments, level_value}, items::ItemStack, + mobs::Who, }; use horizon_core::{position::BlockPos, random::RandomSource}; +use horizon_world::{fluid::FluidKind, level::LevelAccess, registry::BlockStateId}; +use serde_json::Value; /// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`). #[derive(Clone, Copy)] @@ -69,7 +73,7 @@ impl Game<'_> { } /// `getEnchantedDamage - base`: damage bonus of the held weapon against a mob type. pub(super) fn enchant_damage_bonus(&mut self, target: &str) -> f32 { - let Some(held) = self.inventory[self.selected].clone() else { + let Some(held) = self.held().cloned() else { return 0.0; }; let ctx = EffectContext { @@ -102,7 +106,7 @@ impl Game<'_> { /// whether the hit is that knockback attack. pub(super) fn extra_knockback(&mut self, target_kind: &str, scale: f32) -> (f32, bool) { let knockback_attack = scale > 0.9 && self.player.as_ref().is_some_and(|p| p.sprinting); - let enchanted = match self.inventory[self.selected].clone() { + let enchanted = match self.held().cloned() { Some(held) => { let ctx = EffectContext { this: Some(target_kind), @@ -144,7 +148,7 @@ impl Game<'_> { } /// After a successful melee hit: fire aspect and wind burst. pub(super) fn post_attack(&mut self, mob: usize) { - let Some(held) = self.inventory[self.selected].clone() else { + let Some(held) = self.held().cloned() else { return; }; let Some(m) = self.mobs.get(mob) else { return }; @@ -636,6 +640,173 @@ impl Game<'_> { self.apply_equipment(); } } + /// `EnchantmentHelper.runLocationChangedEffects` for the worn armor of the + /// player, run on the server once the player has moved: `LivingEntity.baseTick` + /// runs it when the block position changed, `checkFallDamage` when it lands. + /// `from` and `was_on_ground` are where and how the tick began. + pub(super) fn location_changed_effects(&mut self, from: [f64; 3], was_on_ground: bool) { + let Some(p) = self.player.as_ref() else { + return; + }; + let at = [p.position.x, p.position.y, p.position.z]; + let on_ground = p.ground.on_ground; + let cell = |v: [f64; 3]| v.map(|c| c.floor() as i32); + if cell(from) == cell(at) && !(on_ground && !was_on_ground) { + return; + } + let riding = self.riding.is_some(); + let mut disks = Vec::new(); + for (stack, slot) in self.armor.iter().zip(["head", "chest", "legs", "feet"]) { + let Some(stack) = stack else { continue }; + for (id, level) in stack.enchantments() { + let Some(def) = self.res.stations().enchantments.get(id) else { + continue; + }; + if !def + .slots + .iter() + .any(|s| s == slot || s == "armor" || s == "any") + { + continue; + } + for effect in def.effects["minecraft:location_changed"] + .as_array() + .into_iter() + .flatten() + { + if effect["effect"]["type"] == "minecraft:replace_disk" + && location_requirements(&effect["requirements"], on_ground, riding) + { + disks.push((effect["effect"].clone(), *level)); + } + } + } + } + for (effect, level) in disks { + self.replace_disk(&effect, level, at); + } + } + /// `ReplaceDisk.apply`: the blocks of the disk around `at` that pass the + /// predicate become the effect's state, and each placement is a game event. + fn replace_disk(&mut self, effect: &Value, level: u32, at: [f64; 3]) { + let registry = self.pack.assets.registry; + let spec = &effect["block_state"]; + let Some(default) = spec["id"].as_str().and_then(|n| registry.default_state(n)) else { + return; + }; + let Some(mut state) = registry.state(default).cloned() else { + return; + }; + for (k, v) in spec["properties"].as_object().into_iter().flatten() { + state + .properties + .insert(k.clone(), v.as_str().unwrap_or("").to_owned()); + } + let new = registry.resolve(&state).unwrap_or(default); + let radius = level_value(&effect["radius"], level) as i32; + let height = level_value(&effect["height"], level) as i32; + let offset = cell_offset(effect); + let center = [0, 1, 2].map(|i| at[i].floor() as i32 + offset[i]); + let event = effect["trigger_game_event"].as_str() == Some("minecraft:block_place"); + for dy in (height - 1).min(0)..=0 { + for dz in -radius..=radius { + for dx in -radius..=radius { + let pos = [center[0] + dx, center[1] + dy, center[2] + dz]; + let (x, z) = ( + f64::from(pos[0]) + 0.5 - at[0], + f64::from(pos[2]) + 0.5 - at[2], + ); + if x * x + z * z >= f64::from(radius * radius) + || !self.disk_predicate(&effect["predicate"], pos, new) + || self.level_set(pos, new).is_err() + { + continue; + } + if event { + self.post_block_game_event( + "minecraft:block_place", + pos, + Some(Who::Player), + Some(new), + ); + } + } + } + } + } + /// The `BlockPredicate` subset the disk effect uses, tested at `pos`; no + /// predicate matches everything. + fn disk_predicate(&mut self, p: &Value, pos: [i32; 3], placed: BlockStateId) -> bool { + if p.is_null() { + return true; + } + let offset = cell_offset(p); + let at = [0, 1, 2].map(|i| pos[i] + offset[i]); + let state = self.world.block(at[0], at[1], at[2]); + let b = self.res.behaviours(); + let names = |v: &Value| -> Vec { + match v { + Value::String(s) => vec![s.clone()], + Value::Array(a) => a + .iter() + .filter_map(|n| n.as_str().map(String::from)) + .collect(), + _ => Vec::new(), + } + }; + match p["type"].as_str().unwrap_or("") { + "minecraft:all_of" => p["predicates"] + .as_array() + .into_iter() + .flatten() + .all(|q| self.disk_predicate(q, pos, placed)), + // `MatchingBlockTagPredicate` + "minecraft:matching_block_tag" => b + .tag(p["tag"].as_str().unwrap_or("").trim_start_matches('#')) + .is_some_and(|t| t.contains(b.block(state))), + // `MatchingBlocksPredicate` + "minecraft:matching_blocks" => { + names(&p["blocks"]).iter().any(|n| n == b.table.name(state)) + } + // `MatchingFluidsPredicate`: Fluids.WATER is the source. + "minecraft:matching_fluids" => { + let fluid = b.fluid(state); + names(&p["fluids"]).iter().any(|n| match n.as_str() { + "minecraft:water" => fluid.kind() == FluidKind::Water && fluid.is_source(), + "minecraft:flowing_water" => { + fluid.kind() == FluidKind::Water && !fluid.is_source() + } + _ => false, + }) + } + // `UnobstructedPredicate`: no building-blocking entity in the block. + "minecraft:unobstructed" => self.with_level(|_, level, _| { + level.is_unobstructed(BlockPos::new(pos[0], pos[1], pos[2]), placed) + }), + _ => false, + } + } + /// Whether a worn enchantment gives immunity to `#burn_from_stepping` + /// damage (frost walker's `minecraft:damage_immunity`). + pub(crate) fn wears_burn_from_stepping_immunity(&self) -> bool { + self.armor + .iter() + .zip(["head", "chest", "legs", "feet"]) + .any(|(stack, slot)| { + stack + .iter() + .flat_map(ItemStack::enchantments) + .any(|(id, _)| { + self.res.stations().enchantments.get(id).is_some_and(|def| { + def.effects.get("minecraft:damage_immunity").is_some() + && def + .slots + .iter() + .any(|s| s == slot || s == "armor" || s == "any") + }) + }) + }) + } /// Enchantment attribute modifiers of worn armor (respiration, depth strider...). /// Each piece's modifier id ends with its slot (`EnchantmentAttributeEffect.idForSlot`), /// so the same enchantment on two pieces stacks instead of replacing itself. @@ -684,3 +855,35 @@ fn soul_speed_modifiers( }) .collect() } + +/// An effect's or predicate's `offset` vector (zero when absent). +fn cell_offset(v: &Value) -> [i32; 3] { + let at = |i: usize| { + v["offset"] + .get(i) + .and_then(Value::as_i64) + .map_or(0, |n| n as i32) + }; + [at(0), at(1), at(2)] +} +/// The loot-condition subset a `location_changed` effect requires of the +/// wearer: standing on the ground and not riding (frost walker). +fn location_requirements(req: &Value, on_ground: bool, riding: bool) -> bool { + match req["type"].as_str().unwrap_or("") { + "" if req.is_null() => true, + "minecraft:all_of" => req["terms"] + .as_array() + .into_iter() + .flatten() + .all(|t| location_requirements(t, on_ground, riding)), + "minecraft:inverted" => !location_requirements(&req["term"], on_ground, riding), + "minecraft:entity_properties" => { + let p = &req["predicate"]; + p["minecraft:flags"]["is_on_ground"] + .as_bool() + .is_none_or(|v| v == on_ground) + && (p["minecraft:vehicle"].is_null() || riding) + } + _ => false, + } +} diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index 41c4e1628..3c5cce750 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -12,6 +12,7 @@ use horizon_client::{ motion::PlayerMotion, particles::{ParticleOptions, ParticleType}, vanillagen::VanillaTerrain, + world_spawn::PlayerSpawnFinder, }; use horizon_core::{ geometry::Vec3, @@ -581,7 +582,15 @@ impl Game<'_> { let position = if let Some(job) = self.end.job.take() { self.resolve_gateway(job, target)? } else { - let (position, yaw) = self.end_arrival(target)?; + let mut finder = self.player_spawn.take(); + let arrival = self.end_arrival(target, &mut finder); + self.player_spawn = finder; + let Some((position, yaw)) = arrival? else { + // A spawn candidate's chunk is loading: try again next tick. + self.travelling = Some((player, target)); + self.end_travel = true; + return Ok(()); + }; if let Some(yaw) = yaw { self.yaw = yaw; player.yaw = yaw; @@ -606,7 +615,13 @@ impl Game<'_> { /// Where an End portal's traveller lands once `target` has loaded, and /// the yaw it faces there: the platform below the End's spawn point, /// facing west, or the top of the Overworld's spawn column. - pub(super) fn end_arrival(&mut self, target: Vec3) -> Result<(Vec3, Option)> { + /// None while a candidate of the world spawn's search loads (`finder` + /// keeps it, see `search_spawn`). + pub(super) fn end_arrival( + &mut self, + target: Vec3, + finder: &mut Option, + ) -> Result)>> { if self.dim == Dim::End { // EndPlatformFeature.createEndPlatform below the spawn point. let origin = [END_SPAWN[0], END_SPAWN[1] - 1, END_SPAWN[2]]; @@ -626,22 +641,32 @@ impl Game<'_> { } } // Direction.WEST.toYRot(). - return Ok((target, Some(90.0))); + return Ok(Some((target, Some(90.0)))); } // ServerPlayer.findRespawnPositionAndUseSpawnBlock: where the bed or // anchor puts the player, facing it; else onto the spawn column. let mut target = target; if let Some(c) = self.respawn_config.filter(|c| c.dim == self.dim) { if let Some((at, yaw)) = self.find_respawn_and_use(c, false)? { - return Ok((at, Some(yaw))); + return Ok(Some((at, Some(yaw)))); } let s = self.level.spawn.unwrap_or([0.0, 64.0, 0.0]); target = Vec3::new(s[0].floor() + 0.5, s[1], s[2].floor() + 0.5); } - let y = self - .land_column(target.x.floor() as i32, target.z.floor() as i32) - .map_or(target.y, f64::from); - Ok((Vec3::new(target.x, y, target.z), None)) + let (x, z) = (target.x.floor() as i32, target.z.floor() as i32); + // TeleportTransition.missingRespawnBlock: PlayerSpawnFinder around + // the world spawn. + if let Some(world) = self.level.world_spawn.filter(|w| w[0] == x && w[2] == z) { + return Ok(match self.search_spawn(world, finder) { + Ok(at) => Some((at, None)), + Err(chunk) => { + self.spawn_wait.push(chunk); + None + } + }); + } + let y = self.land_column(x, z).map_or(target.y, f64::from); + Ok(Some((Vec3::new(target.x, y, target.z), None))) } /// Dying away from the Overworld respawns at the world spawn there. diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs index e3f4fd025..fa2627693 100644 --- a/crates/horizon-client/src/game/fishing.rs +++ b/crates/horizon-client/src/game/fishing.rs @@ -15,6 +15,7 @@ use horizon_client::{ }; use horizon_core::{ geometry::{Aabb, Vec3, trig}, + position::BlockPos, random::RandomSource, }; use horizon_protocol::entity_data::{Value, serializer}; @@ -248,7 +249,7 @@ impl Game<'_> { item, [hook.position.x, hook.position.y, hook.position.z], v, - 10, + 0, ); let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1; self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp); @@ -339,9 +340,12 @@ impl Game<'_> { let mut speed = 1; let above = [b[0], b[1] + 1, b[2]]; let sky = self.world.light(above[0], above[1], above[2]) >> 4 == 15; - let raining = self.world.weather.raining; - let r = &mut self.world.random; - if r.next_float() < 0.25 && raining && sky { + // Level.isRainingAt: rain (not snow) reaches the position. + if self.world.random.next_float() < 0.25 + && self.with_level(|b, level, _| { + b.is_raining_at(level, BlockPos::new(above[0], above[1], above[2])) + }) + { speed += 1; } let r = &mut self.world.random; diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs index f4721ae26..4b7465bd0 100644 --- a/crates/horizon-client/src/game/frames.rs +++ b/crates/horizon-client/src/game/frames.rs @@ -7,6 +7,7 @@ use horizon_assets::{bake::bake_model, model::CuboidModel, resolve::ModelLibrary use horizon_client::{entities::ItemFrame, items::ItemStack, mesher::Vertex}; use horizon_core::{ geometry::{Aabb, Vec3}, + position::BlockPos, random::RandomSource, }; use std::sync::Arc; @@ -223,6 +224,7 @@ impl Game<'_> { } let p = self.item_frames[i].pos; self.world.modified.insert((p[0] >> 4, p[2] >> 4)); + self.frame_output_changed(p); self.swing_arm(); true } @@ -255,8 +257,17 @@ impl Game<'_> { } self.drop_frame_items(&f, with_frame, true); self.world.modified.insert((f.pos[0] >> 4, f.pos[2] >> 4)); + if f.item.is_some() { + self.frame_output_changed(f.pos); + } true } + /// `ItemFrame.setItem` / `setRotation`: `updateNeighbourForOutputSignal`, so + /// the comparators reading the frame take its new signal. + fn frame_output_changed(&mut self, pos: [i32; 3]) { + let at = BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| b.update_neighbour_for_output_signal(level, ticks, at)); + } /// `ItemFrame.dropItem`: the frame (when breaking) and the held item. fn drop_frame_items(&mut self, f: &ItemFrame, with_frame: bool, by_player: bool) { if !self.ui.rules.bool("entity_drops") || (by_player && self.creative) { @@ -300,6 +311,9 @@ impl Game<'_> { self.audio .play(&sound(&f, "break"), Some(center(&f)), 1.0, 1.0); self.drop_frame_items(&f, true, false); + if f.item.is_some() { + self.frame_output_changed(f.pos); + } continue; } } diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs index 60869952f..e7bb1982f 100644 --- a/crates/horizon-client/src/game/hand.rs +++ b/crates/horizon-client/src/game/hand.rs @@ -144,6 +144,11 @@ impl Game<'_> { let harvest = !facts.requires_tool || self.res.items().correct_for_drops(held, &facts.name); speed / facts.hardness / if harvest { 30.0 } else { 100.0 } } + /// A key for the main-hand stack (`destroyingItem`): its item and components. + pub(super) fn main_hand_key(&self) -> String { + self.held() + .map_or(String::new(), |s| format!("{} {:?}", s.item, s.extra)) + } /// Whether an attack would hit an entity rather than the block behind /// it: the crosshair's `EntityHitResult`. pub(super) fn entity_targeted(&self) -> bool { @@ -347,12 +352,21 @@ impl Game<'_> { _ => name.ends_with("shulker_box"), } } - /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier. + /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier and the + /// Haste and Mining Fatigue modifiers (`ADD_MULTIPLIED_TOTAL`), clamped to + /// the attribute's range. pub(super) fn main_hand_attack_speed(&self) -> f64 { - horizon_client::attack_strength::BASE_ATTACK_SPEED + let value = horizon_client::attack_strength::BASE_ATTACK_SPEED + self .attack_item_info() - .map_or(0.0, |i| f64::from(i.attack_speed)) + .map_or(0.0, |i| f64::from(i.attack_speed)); + self.potions + .effects + .modifiers() + .into_iter() + .filter(|m| m.0 == "minecraft:attack_speed") + .fold(value, |v, m| v * (1.0 + m.2)) + .clamp(0.0, 1024.0) } /// The item whose attack damage and speed modifiers the player has (`attack_item`). pub(super) fn attack_item_info(&self) -> Option<&horizon_client::items::ItemInfo> { @@ -503,9 +517,7 @@ impl HandWorld for GameHands<'_, '_> { true } fn main_hand_key(&mut self) -> String { - self.game - .held() - .map_or(String::new(), |s| format!("{} {:?}", s.item, s.extra)) + self.game.main_hand_key() } fn destroy_stage(&mut self, _: [i32; 3], _: Option) {} fn swing(&mut self, hand: Hand, animation: SwingAnimation) { diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs index c1149b26a..ca727c5d0 100644 --- a/crates/horizon-client/src/game/initial_spawn.rs +++ b/crates/horizon-client/src/game/initial_spawn.rs @@ -212,39 +212,58 @@ impl Game<'_> { ) .is_ok_and(|shape| shape.is_empty()) } - /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a - /// player who has no position yet. None while a candidate's chunk loads. - pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result> { - let mut finder = match self.player_spawn { - Some(finder) => finder, - None => self.spawn_finder(suggestion), - }; - let found = loop { + /// PlayerSpawnFinder.findSpawn around the world spawn, as far as the loaded + /// chunks allow: the feet of the first free column within the respawn + /// radius, else the suggestion's own column. The finder waits in `state` + /// (None to begin); Err gives the chunk of the candidate being waited for, + /// which the caller must have loaded (the finder tries at most 1024 + /// columns). + pub(super) fn search_spawn( + &self, + suggestion: [i32; 3], + state: &mut Option, + ) -> std::result::Result { + let mut finder = state + .take() + .unwrap_or_else(|| self.spawn_finder(suggestion)); + let suggestion = finder.suggestion; + loop { let Some(candidate) = finder.next_candidate() else { - break Some(self.fixup_spawn_height(suggestion)); + return Ok(self.fixup_spawn_height(suggestion)); }; let (x, z) = match candidate { SpawnCandidate::Column(x, z) => (x, z), SpawnCandidate::Suggestion => (suggestion[0], suggestion[2]), }; if !self.streaming.is_lit(x >> 4, z >> 4) { - self.streaming.center = (x >> 4, z >> 4); finder.retry(); - break None; + *state = Some(finder); + return Err((x >> 4, z >> 4)); } match candidate { SpawnCandidate::Column(x, z) => { if let Some(pos) = level_respawn_pos(&self.spawn_columns(), x, z) && self.player_fits(pos) { - break Some(bottom_center(pos)); + return Ok(bottom_center(pos)); } } - SpawnCandidate::Suggestion => break Some(self.fixup_spawn_height(suggestion)), + SpawnCandidate::Suggestion => return Ok(self.fixup_spawn_height(suggestion)), } - }; - self.player_spawn = found.is_none().then_some(finder); - Ok(found) + } + } + /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a + /// player who has no position yet. None while a candidate's chunk loads. + pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result> { + let mut state = self.player_spawn.take(); + match self.search_spawn(suggestion, &mut state) { + Ok(feet) => Ok(Some(feet)), + Err(chunk) => { + self.streaming.center = chunk; + self.player_spawn = state; + Ok(None) + } + } } /// A new PlayerSpawnFinder around `suggestion`: the respawn radius, cut /// by the world border; the suggestion itself in adventure mode. diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs index efb83e5db..99d67493b 100644 --- a/crates/horizon-client/src/game/item_draw.rs +++ b/crates/horizon-client/src/game/item_draw.rs @@ -171,6 +171,9 @@ fn use_duration(components: &Components) -> i32 { let seconds = c["consume_seconds"].as_f64().unwrap_or(1.6); return (seconds * 20.0) as i32; } + if components.get("minecraft:kinetic_weapon").is_some() { + return 72_000; + } let item_model = components .get("minecraft:item_model") .and_then(Value::as_str) @@ -180,8 +183,9 @@ fn use_duration(components: &Components) -> i32 { | "minecraft:crossbow" | "minecraft:trident" | "minecraft:spyglass" - | "minecraft:goat_horn" - | "minecraft:brush" => 72_000, + | "minecraft:goat_horn" => 72_000, + // BrushItem.USE_DURATION. + "minecraft:brush" => 200, _ => 0, } } @@ -249,6 +253,11 @@ impl Game<'_> { owner.main_arm_left = self.settings.main_hand_left; owner.is_local_player = true; owner.is_view_entity = true; + owner.last_death_location = self + .level + .last_death + .clone() + .map(|(dimension, pos)| GlobalPos { dimension, pos }); if let (Some((slot, ticks)), Some(stack)) = (self.using, stack) && self.stack_in(slot) == Some(stack) { diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index 87f91895e..1af4a7d17 100644 --- a/crates/horizon-client/src/game/jukebox.rs +++ b/crates/horizon-client/src/game/jukebox.rs @@ -6,10 +6,15 @@ use super::Game; use horizon_client::{ containers::{BlockEntity, Jukebox}, items::ItemStack, + mobs::Species, particles::{ParticleOptions, ParticleType}, text::Text, }; -use horizon_core::{position::BlockPos, random::RandomSource}; +use horizon_core::{ + geometry::{Aabb, Vec3}, + position::BlockPos, + random::RandomSource, +}; use horizon_world::level::flags as level_flags; impl Game<'_> { @@ -97,7 +102,7 @@ impl Game<'_> { } /// Level event 1010: the song from the jukebox, and the "Now Playing" overlay. fn start_song(&mut self, pos: [i32; 3], song: &str) { - self.stop_song(pos); + self.stop_sound(pos); let Some(s) = self.res.items().songs.get(song).cloned() else { return; }; @@ -109,12 +114,38 @@ impl Game<'_> { self.titles .set_overlay(Text::translate("record.nowPlaying", &[description]), true); self.update_song_volumes(); + self.notify_record_playing(pos, true); + if self.audio.capture.is_some() { + self.lan_songs.push((pos, Some(song.to_owned()))); + } } - fn stop_song(&mut self, pos: [i32; 3]) { + fn stop_sound(&mut self, pos: [i32; 3]) { if let Some(id) = self.jukebox_sounds.remove(&(pos[0], pos[1], pos[2])) { self.audio.stop_and_release(id); } } + /// Level event 1011: the song ends, here and for the guests. + fn stop_song(&mut self, pos: [i32; 3]) { + self.stop_sound(pos); + self.notify_record_playing(pos, false); + if self.audio.capture.is_some() { + self.lan_songs.push((pos, None)); + } + } + /// `LevelEventHandler.notifyNearbyEntities` (level events 1010 and 1011): + /// parrots within three blocks of the jukebox start or stop dancing. + pub(super) fn notify_record_playing(&mut self, pos: [i32; 3], playing: bool) { + let min = Vec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])); + let area = Aabb::new(min, min.add_vector(Vec3::new(1.0, 1.0, 1.0))) + .inflate(Vec3::new(3.0, 3.0, 3.0)); + for m in self + .mobs + .iter_mut() + .filter(|m| m.species() == Species::Parrot && m.bounds().intersects(area)) + { + m.extra.party_jukebox = playing.then_some(pos); + } + } /// `popOutTheItem`: the disc above the jukebox, and the song stops. fn eject_record(&mut self, pos: [i32; 3]) { let key = (pos[0], pos[1], pos[2]); diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 506c6c419..ac5f8a13a 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -181,6 +181,136 @@ pub(super) fn baby_index(kind: &str) -> Option { } } +/// The variant and look entries of `mob_meta`'s mobs (registry holders, the +/// fish's, the bee's, the copper golem's weathering...), in a match of their +/// own: `mob_meta`'s arms hold these mobs' other entries. +fn mob_variant_meta( + m: &Mob, + hub: &Hub, + meta: &mut Vec<(u8, i32, Value)>, + defaults: &mut Vec<(u8, i32, Value)>, +) { + let (kind, e) = (m.kind.id.as_str(), &m.extra); + let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}")); + match kind { + // Axolotl.DATA_VARIANT (after AgeableMob's two). + "minecraft:axolotl" => { + if e.variant != 0 { + meta.push((18, serializer::INT, Value::Int(i32::from(e.variant)))); + } + } + // Frog.DATA_VARIANT_ID, Pig's, Cow's, Chicken's and ZombieNautilus's + // (after the entries of their parents): registry holders. + "minecraft:frog" + | "minecraft:pig" + | "minecraft:cow" + | "minecraft:chicken" + | "minecraft:zombie_nautilus" => { + let (index, serializer, registry) = match kind { + "minecraft:frog" => (18, serializer::FROG_VARIANT, "minecraft:frog_variant"), + "minecraft:pig" => (19, serializer::PIG_VARIANT, "minecraft:pig_variant"), + "minecraft:cow" => (18, serializer::COW_VARIANT, "minecraft:cow_variant"), + "minecraft:chicken" => { + (18, serializer::CHICKEN_VARIANT, "minecraft:chicken_variant") + } + _ => ( + 21, + serializer::ZOMBIE_NAUTILUS_VARIANT, + "minecraft:zombie_nautilus_variant", + ), + }; + // Each registry's default (`define(DATA_VARIANT_ID, ... TEMPERATE)`) + // stays out of the pairing data, as other default values do. + let name = horizon_client::mobs::finalize::variant_name(m.species(), e.variant); + let name = name.trim_start_matches("minecraft:"); + if let Some(v) = id(registry, name) + && name != "temperate" + { + meta.push((index, serializer, Value::Id(v))); + } + if let Some(v) = id(registry, "temperate") { + defaults.push((index, serializer, Value::Id(v))); + } + } + // Rabbit.DATA_TYPE_ID (after AgeableMob's two) and + // Parrot.DATA_VARIANT_ID (after TamableAnimal's two and its flags and + // owner). The fox's type goes with its flags (#2538). + "minecraft:rabbit" | "minecraft:parrot" => { + let index = if kind == "minecraft:parrot" { 20 } else { 18 }; + if e.variant != 0 { + meta.push((index, serializer::INT, Value::Int(i32::from(e.variant)))); + } + } + // Bee.DATA_FLAGS_ID (rolling 2, stung 4, nectar 8) and + // DATA_ANGER_END_TIME: the texture shows the nectar and the anger. + "minecraft:bee" => { + let bee = horizon_client::mobs::bee::get(m); + let flags = bee.map_or(0, |b| b.flags); + if flags != 0 { + meta.push((18, serializer::BYTE, Value::Byte(flags as i8))); + } + defaults.push((18, serializer::BYTE, Value::Byte(0))); + let anger_end = bee.map_or(-1, |b| b.anger_end); + if anger_end != -1 { + meta.push((19, serializer::LONG, Value::Long(anger_end))); + } + defaults.push((19, serializer::LONG, Value::Long(-1))); + } + // AbstractFish.FROM_BUCKET takes 16: Salmon.DATA_TYPE (small 0, + // medium 1, large 2; medium is the data's default, so always sent), + // Pufferfish.PUFF_STATE and TropicalFish.DATA_ID_TYPE_VARIANT: the + // pattern's packed id (size, then index << 8), base colour << 16 and + // pattern colour << 24. + "minecraft:salmon" => { + meta.push((17, serializer::INT, Value::Int(i32::from(e.variant.min(2))))); + } + "minecraft:pufferfish" => { + if e.size > 0 { + meta.push((17, serializer::INT, Value::Int(e.size))); + } + defaults.push((17, serializer::INT, Value::Int(0))); + } + "minecraft:tropical_fish" => { + let pattern = e.variant.min(11); + let packed = i32::from(pattern >= 6) + | i32::from(pattern % 6) << 8 + | i32::from(e.variant2 & 15) << 16 + | i32::from(e.variant3 & 15) << 24; + if packed != 0 { + meta.push((17, serializer::INT, Value::Int(packed))); + } + } + // CopperGolem.DATA_WEATHER_STATE: unaffected 0 to oxidized 3, and it + // goes back down when the golem is scraped. + "minecraft:copper_golem" => { + if e.variant != 0 { + meta.push(( + 16, + serializer::WEATHERING_COPPER_STATE, + Value::Id(i32::from(e.variant.min(3))), + )); + } + defaults.push((16, serializer::WEATHERING_COPPER_STATE, Value::Id(0))); + } + // Ghast.DATA_IS_CHARGING: the shooting texture. + "minecraft:ghast" => { + if e.flag { + meta.push((16, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((16, serializer::BOOLEAN, Value::Bool(false))); + } + // WitherBoss.DATA_ID_INV (after the three head targets): the + // invulnerable ticks, the blinking texture and the growing scale. + "minecraft:wither" => { + if e.counter > 0 { + meta.push((19, serializer::INT, Value::Int(e.counter))); + } + defaults.push((19, serializer::INT, Value::Int(0))); + } + _ => {} + } +} + /// A mob's synched data as ServerEntity sends it (only the values that differ /// from the defaults the client constructs), with vanilla's entry indices: /// Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses. @@ -258,6 +388,7 @@ fn mob_meta( } let e = &m.extra; let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}")); + mob_variant_meta(m, hub, meta, defaults); match kind { "minecraft:guardian" | "minecraft:elder_guardian" => { // Guardian.DATA_ID_MOVING and DATA_ID_ATTACK_TARGET. @@ -314,6 +445,25 @@ fn mob_meta( } defaults.push((18, serializer::BYTE, Value::Byte(0))); } + // Fox.DATA_TYPE_ID and DATA_FLAGS_ID (after AgeableMob's two; sleeping 32, ...). + "minecraft:fox" => { + if e.variant != 0 { + meta.push((18, serializer::INT, Value::Int(i32::from(e.variant)))); + } + defaults.push((18, serializer::INT, Value::Int(0))); + let flags = (e.ints[0] & 0xff) as u8 as i8; + if flags != 0 { + meta.push((19, serializer::BYTE, Value::Byte(flags))); + } + defaults.push((19, serializer::BYTE, Value::Byte(0))); + } + "minecraft:parrot" => { + // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. + let flags = i8::from(e.sitting) | if e.tame { 4 } else { 0 }; + if flags != 0 { + meta.push((18, serializer::BYTE, Value::Byte(flags))); + } + } "minecraft:cat" | "minecraft:wolf" => { // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4. let flags = i8::from(e.sitting) | if e.tame { 4 } else { 0 }; @@ -342,6 +492,14 @@ fn mob_meta( meta.push((collar, serializer::INT, Value::Int(i32::from(e.color & 15)))); } defaults.push((collar, serializer::INT, Value::Int(red))); + // Wolf.DATA_ANGER_END_TIME: the game time the anger ends, -1 when calm. + if kind == "minecraft:wolf" { + if e.anger > 0 { + let end = game_time + i64::from(e.anger); + meta.push((22, serializer::LONG, Value::Long(end))); + } + defaults.push((22, serializer::LONG, Value::Long(-1))); + } } "minecraft:horse" | "minecraft:donkey" @@ -376,6 +534,14 @@ fn mob_meta( meta.push((19, serializer::BOOLEAN, Value::Bool(true))); } } + // HappyGhast.STAYS_STILL (after AgeableMob's two and IS_LEASH_HOLDER), + // set while `serverStillTimeout > 0` (`syncStayStillFlag`). + "minecraft:happy_ghast" => { + if horizon_client::mobs::happy_ghast::on_still_timeout(m) { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + } // Villager.DATA_VILLAGER_DATA and ZombieVillager's (after Zombie's three). "minecraft:villager" | "minecraft:zombie_villager" => { use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; @@ -420,6 +586,29 @@ fn mob_meta( } defaults.push((17, serializer::BOOLEAN, Value::Bool(false))); } + // Panda: UNHAPPY_COUNTER, SNEEZE_COUNTER and EAT_COUNTER (after + // AgeableMob's two), MAIN_GENE_ID, HIDDEN_GENE_ID and DATA_ID_FLAGS; + // the client animates the states from them. + "minecraft:panda" => { + let (flags, counters) = horizon_client::mobs::panda::get(m) + .map_or((0, [0; 3]), |s| (s.flags, [s.unhappy, s.sneeze, s.eat])); + for (index, value) in (18..).zip(counters) { + if value != 0 { + meta.push((index, serializer::INT, Value::Int(value))); + } + defaults.push((index, serializer::INT, Value::Int(0))); + } + for (index, gene) in [(21, e.variant), (22, e.variant2)] { + if gene != 0 { + meta.push((index, serializer::BYTE, Value::Byte(gene as i8))); + } + defaults.push((index, serializer::BYTE, Value::Byte(0))); + } + if flags != 0 { + meta.push((23, serializer::BYTE, Value::Byte(flags as i8))); + } + defaults.push((23, serializer::BYTE, Value::Byte(0))); + } // PolarBear.DATA_STANDING_ID (after AgeableMob's two): the bear // rears up; the client animates it. "minecraft:polar_bear" => { @@ -470,7 +659,87 @@ fn mob_meta( } defaults.push((18, serializer::BYTE, Value::Byte(16))); } - // Enderman.DATA_CARRY_STATE. + // Vex.DATA_FLAGS_ID: charging in bit 0 (the arms and the glowing + // texture). + "minecraft:vex" => { + if e.flag { + meta.push((16, serializer::BYTE, Value::Byte(1))); + } + defaults.push((16, serializer::BYTE, Value::Byte(0))); + } + // Creaking.CAN_MOVE, IS_ACTIVE and IS_TEARING_DOWN. + "minecraft:creaking" => { + if e.flag2 { + meta.push((16, serializer::BOOLEAN, Value::Bool(false))); + } + defaults.push((16, serializer::BOOLEAN, Value::Bool(true))); + if e.flag { + meta.push((17, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((17, serializer::BOOLEAN, Value::Bool(false))); + if horizon_client::mobs::creaking::tearing_down(m) { + meta.push((18, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((18, serializer::BOOLEAN, Value::Bool(false))); + } + // Allay.DATA_DANCING and DATA_CAN_DUPLICATE (the held item is its + // main hand equipment). + "minecraft:allay" => { + if e.flag { + meta.push((16, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((16, serializer::BOOLEAN, Value::Bool(false))); + if e.egg_time > 0 { + meta.push((17, serializer::BOOLEAN, Value::Bool(false))); + } + defaults.push((17, serializer::BOOLEAN, Value::Bool(true))); + } + // Axolotl.DATA_PLAYING_DEAD (after DATA_VARIANT). + "minecraft:axolotl" => { + if horizon_client::mobs::axolotl::is_playing_dead(m) { + meta.push((19, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((19, serializer::BOOLEAN, Value::Bool(false))); + } + // CopperGolem.COPPER_GOLEM_STATE (after DATA_WEATHER_STATE). + "minecraft:copper_golem" => { + if e.variant3 != 0 { + meta.push(( + 17, + serializer::COPPER_GOLEM_STATE, + Value::Id(i32::from(e.variant3)), + )); + } + defaults.push((17, serializer::COPPER_GOLEM_STATE, Value::Id(0))); + } + // Armadillo.ARMADILLO_STATE (after AgeableMob's two). + "minecraft:armadillo" => { + let state = horizon_client::mobs::armadillo::state(m); + if state != 0 { + meta.push((18, serializer::ARMADILLO_STATE, Value::Id(i32::from(state)))); + } + defaults.push((18, serializer::ARMADILLO_STATE, Value::Id(0))); + } + // Frog.DATA_TONGUE_TARGET_ID (after the variant): the entity id plus + // one, 0 for none. + "minecraft:frog" => { + if let Some(target) = e.frog.tongue_target { + let id = i32::try_from(target).map_or(0, |t| t + 1); + meta.push((19, serializer::OPTIONAL_UNSIGNED_INT, Value::Id(id))); + } + defaults.push((19, serializer::OPTIONAL_UNSIGNED_INT, Value::Id(0))); + } + // Goat.DATA_HAS_LEFT_HORN and DATA_HAS_RIGHT_HORN (after + // DATA_IS_SCREAMING_GOAT): both true by default. + "minecraft:goat" => { + for (index, lost) in [(19, e.lost_horns[0]), (20, e.lost_horns[1])] { + if lost { + meta.push((index, serializer::BOOLEAN, Value::Bool(false))); + } + defaults.push((index, serializer::BOOLEAN, Value::Bool(true))); + } + } + // Enderman.DATA_CARRY_STATE and DATA_CREEPY (angry: the open mouth). "minecraft:enderman" => { if let Some(state) = e.carried { meta.push(( @@ -479,6 +748,10 @@ fn mob_meta( Value::Id(state.0 as i32), )); } + if e.flag { + meta.push((17, serializer::BOOLEAN, Value::Bool(true))); + } + defaults.push((17, serializer::BOOLEAN, Value::Bool(false))); } _ => {} } @@ -540,8 +813,17 @@ fn mob_equipment( let stack = ItemStack { item: item.clone(), count: 1, - damage: 0, - extra: None, + // A wolf's armor shows its cracks. + damage: if slot == 6 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_damage.max(0) as u32 + } else { + 0 + }, + extra: if slot == 6 && m.species() == horizon_client::mobs::Species::Wolf { + e.body_extra.clone() + } else { + None + }, }; out.push((slot, hub.stack(&Some(stack)))); } @@ -760,7 +1042,8 @@ impl Game<'_> { let host_uuid = host.unwrap_or(0); self.next_entity += 1; let host_entity = self.next_entity as i32; - let hub = Hub::new(lan, sync, encoder, config); + let mut hub = Hub::new(lan, sync, encoder, config); + hub.flat_world = self.world_flat; let port = hub.lan.port; self.world.block_log = Some(Vec::new()); self.world.light_log = Some(Default::default()); @@ -823,6 +1106,7 @@ impl Game<'_> { self.world.light_log = None; self.audio.capture = None; self.lan_events.clear(); + self.lan_songs.clear(); self.lan_critical_hits.clear(); self.lan_cushion_breaks.clear(); self.streaming.extra.clear(); @@ -1045,6 +1329,9 @@ impl Game<'_> { &mut e.meta, &mut e.defaults, ); + // HappyGhast.aiStep: requiresPrecisePosition while on a still timeout. + e.precise = m.species() == horizon_client::mobs::Species::HappyGhast + && horizon_client::mobs::happy_ghast::on_still_timeout(m); mob_freeze_meta(m, &mut e.meta, &mut e.defaults); mob_equipment(m, hub, &mut e.equipment); self.mob_attributes(m, &mut e.attributes); @@ -1223,6 +1510,16 @@ impl Game<'_> { "INFO", &format!("System chat: {} joined the game", g.name), ); + } else if self.player.is_some() + && let Some(g) = host.hub.guest(conn) + && g.placed + { + // The host's chat hears of the newcomer as the guests do. + let who = self.player_text(&g.name, g.uuid); + self.system_message( + Text::translate("multiplayer.player.joined", &[who]) + .with_color(horizon_client::text::YELLOW), + ); } } HostEvent::Left(mut guest) => { @@ -1257,6 +1554,13 @@ impl Game<'_> { "INFO", &format!("System chat: {} left the game", guest.name), ); + } else if self.player.is_some() && guest.placed { + // ServerGamePacketListenerImpl.removePlayerFromWorld. + let who = self.player_text(&guest.name, guest.uuid); + self.system_message( + Text::translate("multiplayer.player.left", &[who]) + .with_color(horizon_client::text::YELLOW), + ); } } HostEvent::Packet(conn, packet) => { @@ -1297,6 +1601,8 @@ impl Game<'_> { // A blast from a guest's attack, and a mace's wind burst. self.flush_lan_explosions(); let _ = self.flush_wind_bursts(); + // A sweep attack's reach to the other players from a guest's attack. + self.flush_sweeps(); // Particles a guest's turn sent (sweep attack, damage indicator, a hook's splashes). self.flush_lan_particles(); } @@ -1399,10 +1705,11 @@ impl Game<'_> { match e { horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => { // The acting guest does not predict the egg's teleport - // particles, bone meal's growth, or anvil result sounds - // (these levelEvent calls name no excluded player), nor - // the digger's own crack and hit sound (2019, 2020). - let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) { + // particles, bone meal's growth, anvil result sounds, or a + // finished brushing (these levelEvent calls name no + // excluded player), nor the digger's own crack and hit + // sound (2019, 2020). + let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020 | 3008) { None } else { self.lan_acting @@ -1464,6 +1771,7 @@ impl Game<'_> { /// Send the tick's level events, sounds and mob animations. fn lan_flush_effects(&mut self, host: &mut LanHost) { let critical_hits = std::mem::take(&mut self.lan_critical_hits); + let kinetic_hits = std::mem::take(&mut self.lan_kinetic_hits); for (state, at) in std::mem::take(&mut self.lan_cushion_breaks) { if let Some(id) = host .hub @@ -1498,6 +1806,16 @@ impl Game<'_> { } host.hub.level_event(kind, pos, data, acting); } + // Level events 1010 and 1011: the guests' parrots dance or stop. + for (pos, song) in std::mem::take(&mut self.lan_songs) { + match song { + Some(name) => { + let id = host.hub.registry_id("minecraft:jukebox_song", &name); + host.hub.level_event(1010, pos, id.unwrap_or(0), None); + } + None => host.hub.level_event(1011, pos, 0, None), + } + } for (pos, b0, b1, state) in std::mem::take(&mut self.lan_block_events) { host.hub.block_event(pos, b0, b1, state); } @@ -1542,7 +1860,12 @@ impl Game<'_> { // A projectile is the direct entity of its hit: not tracked here. let melee = matches!( source.kind, - K::PlayerAttack | K::MaceSmash | K::MobAttack | K::Sting | K::SonicBoom + K::PlayerAttack + | K::MaceSmash + | K::Spear + | K::MobAttack + | K::Sting + | K::SonicBoom ); let direct = cause.filter(|_| melee); host.hub.damage_event(m.id as i32, kind, cause, direct, at); @@ -1563,6 +1886,19 @@ impl Game<'_> { seen.insert(m.id, (m.hurt_time, dead, swing)); } host.mob_state.insert(self.dim, seen); + // Level.broadcastEntityEvent(player, 2) of a spear's stab. + for attacker in kinetic_hits { + let hit = match attacker { + None => self + .player + .as_ref() + .map(|p| (host.host_entity, [p.position.x, p.position.y, p.position.z])), + Some(conn) => host.hub.guest(conn).map(|g| (g.entity_id, g.position)), + }; + if let Some((id, at)) = hit { + host.hub.entity_event(id, 2, at); + } + } for (attacker, target, magic) in critical_hits { let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| { host.hub.guest(conn).map(|g| g.entity_id) @@ -1627,10 +1963,18 @@ impl Game<'_> { m.head_yaw = g.head_yaw; m.head_pitch = g.pitch; let mut target = m.body_yaw; - if dx * dx + dz * dz > 0.002_500_000_2 { - target = (dz.atan2(dx) as f32).to_degrees() - 90.0; - } let wrap = |a: f32| (a + 180.0).rem_euclid(360.0) - 180.0; + if dx * dx + dz * dz > 0.002_500_000_2 { + // LivingEntity.tick: walking backwards the body faces away + // from the walk direction, not along it. + let walk = (dz.atan2(dx) as f32).to_degrees() - 90.0; + let facing = (wrap(g.yaw) - walk).abs(); + target = if 95.0 < facing && facing < 265.0 { + walk - 180.0 + } else { + walk + }; + } m.body_yaw += wrap(target - m.body_yaw) * 0.3; let diff = wrap(g.yaw - m.body_yaw); if diff.abs() > 50.0 { @@ -1654,12 +1998,41 @@ impl Game<'_> { m.extra.crouching = g.sneaking; m.extra.avatar_pose = g.pose(); m.extra.sprinting = g.sprinting; + // Entity.DATA_POSE and the shared and living flags the others + // get (hub::guest_body): gliding, swimming, Riptide's spin. + let body = lan::hub::guest_body(g); + m.extra.fall_flying = body.gliding; + m.extra.synced_pose = if body.swimming || body.crawling { 3 } else { 0 }; + m.extra.auto_spin_attack = body.spin_attack; + m.velocity = g + .motion + .as_ref() + .map_or(Vec3::new(dx, dy, dz), |motion| motion.velocity); + m.tick_avatar_pose( + g.motion + .as_ref() + .is_some_and(|motion| motion.fluids.was_touching_water), + ); + // CrossbowItem.isCharged: the held crossbow's projectiles. + m.extra.charged = g + .inventory + .get(g.selected) + .and_then(|s| s.as_ref()) + .is_some_and(|s| s.data().is_some_and(|d| !d.charged.is_empty())); // LivingEntity.DATA_EFFECT_PARTICLES: the swirls of its visible effects. let visible = || g.effects.list.iter().filter(|e| e.visible); m.extra.effect_particles = visible() .filter_map(|e| super::client_ambient::effect_particle(e.id, e.ambient)) .collect(); m.extra.effect_ambient = visible().all(|e| e.ambient); + // Entity.isInvisible: the invisibility effect hides the body (the + // model pass, the name tag rules and `trader::is_invisible` read it). + m.extra.effects.retain(|e| e.0 != "minecraft:invisibility"); + if let Some(e) = g.effects.get("invisibility") { + m.extra + .effects + .push(("minecraft:invisibility", e.duration, e.amplifier)); + } // Lying in its bed (LivingEntity.getBedOrientation). m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b)); // LivingEntity.updateSwingTime: the arm swing lan_swings started. @@ -1720,6 +2093,15 @@ impl Game<'_> { ), out, ); + self.player_elytra_geometry( + m, + m.extra.chest.as_deref(), + camera, + alpha as f32, + packed, + out, + ); + self.spin_attack_geometry(m, camera, alpha as f32, packed, out); self.held_item_geometry(m, camera, alpha, packed, true, out); // LivingEntity.isCurrentlyGlowing: the guest's Glowing effect. let guest = host.hub.guest(*conn); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index dde9b590d..c18abba36 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -388,6 +388,7 @@ impl Game<'_> { std::mem::swap(&mut self.adv.changed, &mut g.advancements_changed); std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked); std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book); + std::mem::swap(&mut self.level.player_extra, &mut g.saved); std::mem::swap(&mut self.stats, &mut play.stats); std::mem::swap(&mut self.hook, &mut play.hook); let adv_loaded = std::mem::replace(&mut self.adv.loaded, true); @@ -643,6 +644,7 @@ impl Game<'_> { std::mem::swap(&mut self.adv.changed, &mut g.advancements_changed); std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked); std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book); + std::mem::swap(&mut self.level.player_extra, &mut g.saved); std::mem::swap(&mut self.stats, &mut play.stats); std::mem::swap(&mut self.hook, &mut play.hook); self.adv.loaded = adv_loaded; @@ -971,6 +973,45 @@ impl Game<'_> { d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < range * range } + /// DedicatedServer.isUnderSpawnProtection: no operators, an operator or a + /// radius of 0 or less is never under it; else a block within the radius + /// of the world spawn (square, in the Overworld) is. + fn under_spawn_protection(&self, host: &LanHost, gi: usize, pos: [i32; 3]) -> bool { + let g = &host.hub.guests[gi]; + let radius = host.hub.spawn_protection; + if self.options.dedicated.is_none() || radius <= 0 || g.dimension != "minecraft:overworld" { + return false; + } + let Some(spawn) = self.level.world_spawn else { + return false; + }; + if host.hub.ops.is_empty() || host.hub.ops.contains_key(&g.uuid) { + return false; + } + let dx = pos[0].abs_diff(spawn[0]); + let dz = pos[2].abs_diff(spawn[2]); + dx.max(dz) <= radius as u32 + } + + /// ServerPlayer.sendSpawnProtectionMessage. + fn spawn_protection_message(&self, host: &LanHost, conn: u32, pos: [i32; 3]) { + let message = horizon_client::text::Text::translate( + "build.spawn_protection", + &[horizon_client::text::Text::literal(format!( + "{}, {}, {}", + pos[0], pos[1], pos[2] + ))], + ) + .with_color(horizon_client::text::RED); + host.hub.send_to( + conn, + &C::SystemChat(play::SystemChat { + content: horizon_client::lan::data::component_nbt(&message.component()), + overlay: true, + }), + ); + } + /// A packet from a guest that the hub does not handle itself. pub(super) fn lan_guest_packet(&mut self, host: &mut LanHost, conn: u32, packet: S) { let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else { @@ -995,6 +1036,12 @@ impl Game<'_> { if spectator { return; } + // ServerPlayerGameMode.handleBlockBreakAction: no dig starts + // under spawn protection (the ack puts the block back). + if self.under_spawn_protection(host, gi, a.pos) { + self.spawn_protection_message(host, conn, a.pos); + return; + } let face = direction(i32::from(a.direction)); let play = host.play.entry(conn).or_default(); play.digging = Some((a.pos, face)); @@ -1122,19 +1169,25 @@ impl Game<'_> { ], }; let hand = if p.hand == 1 { Hand::Off } else { Hand::Main }; - let logged = self.world.block_log.as_ref().map_or(0, Vec::len); - let heard = self.audio.capture.as_ref().map_or(0, Vec::len); - let swung = self.as_guest(host, conn, |g| { - g.forced_hit = Some(hit); - g.guest_use = Some(GuestUse::OnBlock(hand)); - let swings = g.swings_started; - let _ = g.use_item(); - g.forced_hit = None; - g.guest_use = None; - g.swings_started != swings - }); - self.lan_swing_back(host, conn, swung); - self.guest_use_sounds(host, conn, logged, heard); + // handleUseItemOn: under spawn protection nothing is used or + // placed; the player is told and the blocks below go back. + if self.under_spawn_protection(host, gi, p.pos) { + self.spawn_protection_message(host, conn, p.pos); + } else { + let logged = self.world.block_log.as_ref().map_or(0, Vec::len); + let heard = self.audio.capture.as_ref().map_or(0, Vec::len); + let swung = self.as_guest(host, conn, |g| { + g.forced_hit = Some(hit); + g.guest_use = Some(GuestUse::OnBlock(hand)); + let swings = g.swings_started; + let _ = g.use_item(); + g.forced_hit = None; + g.guest_use = None; + g.swings_started != swings + }); + self.lan_swing_back(host, conn, swung); + self.guest_use_sounds(host, conn, logged, heard); + } // The client predicted a result: correct it with what really is. for pos in [ p.pos, @@ -1434,19 +1487,68 @@ impl Game<'_> { .unwrap_or_default(); host.hub.send_stats(conn, &stats); } + // handlePickItemFromBlock: a block within the block reach plus 1, its + // data only with infinite materials. S::PickItemFromBlock(p) => { - let state = self.world.block(p.pos[0], p.pos[1], p.pos[2]); - let item = self.res.facts().get(state).item.clone(); - let g = &mut host.hub.guests[gi]; - if g.creative() && &*item != "minecraft:air" { - let slot = g.selected; - g.inventory[slot] = Some(ItemStack::new(&item, 1)); - } + self.guest_pick_item(host, conn, |g| { + let eye = g.eye_position()?; + let d2: f64 = (0..3) + .map(|a| { + let lo = f64::from(p.pos[a]); + (eye[a] - eye[a].clamp(lo, lo + 1.0)).powi(2) + }) + .sum(); + let range = g.reach() + 1.0; + if d2 >= range * range { + return None; + } + g.picked_stack(p.pos, g.creative && p.include_data) + }); + } + // handlePickItemFromEntity. + S::PickItemFromEntity(p) => { + self.guest_pick_item(host, conn, |g| { + g.within_entity_range(p.id) + .then(|| g.entity_pick_result(p.id)) + .flatten() + }); } _ => {} } } + /// `ServerGamePacketListenerImpl.tryPickItem` for the guest: a matching stack + /// is selected, else a creative player gets the item; the held slot is sent + /// back and the changed slots follow with the tick's inventory changes. + fn guest_pick_item( + &mut self, + host: &mut LanHost, + conn: u32, + stack: impl FnOnce(&mut Self) -> Option, + ) { + let picked = self.as_guest(host, conn, |g| { + let stack = stack(g)?; + let infinite = g.creative; + horizon_client::pick_item::pick( + &mut g.inventory[..36], + &mut g.selected, + &stack, + infinite, + ); + Some(()) + }); + if picked.flatten().is_some() + && let Some(g) = host.hub.guests.iter().find(|g| g.conn == conn) + { + host.hub.send_to( + conn, + &C::SetHeldSlot(play::SetHeldSlot { + slot: g.selected as i32, + }), + ); + } + } + fn item_from_network( &self, host: &LanHost, @@ -1614,9 +1716,21 @@ impl Game<'_> { if self.look_at_entity(host, gi, id, None).is_none() { return; } - self.as_guest(host, conn, |g| { - g.attack(); - }); + // A mace's smash sets the attacker's velocity and sends it at once, before the + // Wind Burst's push (MaceItem.hurtEnemy, then the post-attack effects). + let sent = self + .as_guest(host, conn, |g| { + let marked = g + .player + .as_mut() + .is_some_and(|p| std::mem::take(&mut p.health.sync_velocity)); + g.attack(); + let p = g.player.as_mut()?; + let sent = std::mem::replace(&mut p.health.sync_velocity, marked); + sent.then_some(p.velocity) + }) + .flatten(); + self.send_guest_motion(host, conn, sent); // The mob now answers to this guest (game/lan_mobs.rs). if let Ok(id) = u32::try_from(id) { host.mob_players.insert(id, conn); @@ -1919,6 +2033,10 @@ impl Game<'_> { } if let Some(config) = elsewhere { self.respawn_trip(conn, config); + } else if in_frame_bed.is_none() && host.hub.guests[i].spawn.is_none() { + // TeleportTransition.createDefault: no point of its own, so the + // world spawn's free column once its chunks have loaded. + self.world_spawn_trip(conn); } if let Some(c) = in_frame_bed && self.dim == super::Dim::Overworld @@ -1937,6 +2055,10 @@ impl Game<'_> { host.hub.guests[i].yaw = yaw; [at.x, at.y, at.z] }); + if found.is_none() { + // TeleportTransition.missingRespawnBlock. + self.world_spawn_trip(conn); + } host.hub.teleport(i, Some(at)); } if away && let Err(e) = self.enter_level(Some(host), back) { @@ -1982,7 +2104,13 @@ impl Game<'_> { let using = play.using.is_some(); let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100; if digging.is_some() || using || delayed { + // ServerPlayer.getKnownMovement: the move their client just sent. + let movement = host.hub.guests[gi] + .moves + .last() + .map_or(Vec3::ZERO, |m| Vec3::new(m.0[0], m.0[1], m.0[2])); self.as_guest(host, conn, |g| { + g.known_movement = movement; g.attack_ticks = g.attack_ticks.saturating_add(1); if let Some((pos, face)) = digging { g.forced_hit = Some(Hit { @@ -2054,6 +2182,7 @@ impl Game<'_> { self.as_guest(host, conn, |g| { g.tick_fishing(); g.tick_maps(); + g.tick_lodestone_compasses(); g.count_tick_stats(sleeping); g.tick_advancements(); g.update_player_attributes(); @@ -2080,7 +2209,7 @@ impl Game<'_> { let g = &mut host.hub.guests[gi]; if g.health <= 0.0 && !g.dead { g.dead = true; - g.last_death = Some(g.position.map(|v| v.floor() as i32)); + g.last_death = Some((g.dimension.clone(), g.position.map(|v| v.floor() as i32))); let (id, at) = (g.entity_id, g.position); let reward = Experience { level: g.xp_level, @@ -2161,11 +2290,10 @@ impl Game<'_> { } } - /// `SleepStatus.areEnoughSleeping` and `areEnoughDeepSleeping` over the - /// host's player and the guests: of the players not in spectator mode, - /// players_sleeping_percentage of them (at least one) are in bed, and as - /// many have slept 100 ticks. - pub(super) fn enough_slept(&self) -> bool { + /// `SleepStatus.update`'s counts over the host's player and the guests: + /// the players not in spectator mode, how many are in bed, and how many + /// of those have slept 100 ticks. + fn sleep_counts(&self) -> (i64, i64, i64) { let (mut active, mut sleeping, mut deep) = (0i64, 0i64, 0i64); let mut count = |in_bed: bool, timer: u32| { active += 1; @@ -2189,11 +2317,64 @@ impl Game<'_> { count(g.bed.is_some(), g.sleep_timer); } } + (active, sleeping, deep) + } + + /// `SleepStatus.sleepersNeeded`. + fn sleepers_needed(&self, active: i64) -> i64 { let percent = i64::from(self.ui.rules.int("players_sleeping_percentage").max(0)); - let needed = ((active * percent + 99) / 100).max(1); + ((active * percent + 99) / 100).max(1) + } + + /// `SleepStatus.areEnoughSleeping` and `areEnoughDeepSleeping` over the + /// host's player and the guests: of the players not in spectator mode, + /// players_sleeping_percentage of them (at least one) are in bed, and as + /// many have slept 100 ticks. + pub(super) fn enough_slept(&self) -> bool { + let (active, sleeping, deep) = self.sleep_counts(); + let needed = self.sleepers_needed(active); sleeping >= needed && deep >= needed } + /// `ServerLevel.updateSleepingPlayerList` and `announceSleepStatus`: when + /// the players or the sleepers change, a published or dedicated world + /// shows everyone "n/m players sleeping", or "Sleeping through this + /// night" once enough are in bed, on the action bar. + pub(super) fn announce_sleep_status(&mut self) { + let (active, sleeping, _) = self.sleep_counts(); + let (old_active, old_sleeping) = self.sleep_seen; + self.sleep_seen = (active, sleeping); + let changed = (old_sleeping > 0 || sleeping > 0) + && (old_active != active || old_sleeping != sleeping); + let published = self.lan.is_some() || self.options.dedicated.is_some(); + if !changed || !published { + return; + } + // ServerLevel.canSleepThroughNights. + if self.ui.rules.int("players_sleeping_percentage") > 100 { + return; + } + let needed = self.sleepers_needed(active); + let text = if sleeping >= needed { + horizon_client::text::Text::translate("sleep.skipping_night", &[]) + } else { + horizon_client::text::Text::translate( + "sleep.players_sleeping", + &[ + horizon_client::text::Text::literal(sleeping.to_string()), + horizon_client::text::Text::literal(needed.to_string()), + ], + ) + }; + if let Some(host) = self.lan.as_ref() { + host.hub + .overlay_message(horizon_client::lan::data::component_nbt(&text.component())); + } + if self.options.dedicated.is_none() { + self.titles.set_overlay(text, false); + } + } + /// `ServerLevel.wakeUpAllPlayers` for the guests. pub(super) fn wake_guests(&mut self) { if let Some(host) = self.lan.as_mut() { @@ -2249,16 +2430,19 @@ impl Game<'_> { if !g.effects.list.is_empty() { self.as_guest(host, conn, |game| game.tick_mob_effects()); } + self.as_guest(host, conn, |game| game.handle_shoulder_entities()); return; } let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); let at = g.position; let (sneaking, sleeping) = (g.sneaking, g.sleeping); + let riding = g.vehicle.is_some(); let mut soul = None; let events = self.as_guest(host, conn, |game| { let (rules, motion) = (game.world.health_rules, game.motion); let health = &motion.health; let freeze_immune = game.wears_freeze_immune(); + let burn_immune = game.wears_burn_from_stepping_immunity(); let Some(player) = game.player.as_mut() else { return (Vec::new(), None); }; @@ -2273,6 +2457,12 @@ impl Game<'_> { w.player.health.advance_clock(); let _ = w.fluid_base_tick(); w.player.ground.on_ground = from_ground; + // Player.aiStep: a flying player that isn't riding starts every tick + // with no fall distance, so flying down in creative and switching to + // survival lands without the flight's distance. + if w.player.flying && !riding { + w.player.fall_distance = 0.0; + } let travelled: Vec<[f64; 3]> = moves.iter().map(|m| m.0).collect(); // Entity.move's movementThisTick: each move, from where the // tick's first one started. @@ -2324,6 +2514,7 @@ impl Game<'_> { w.player.shift_key_down = sneaking; let _ = w.player.set_sleeping(sleeping); w.player.freeze_immune = freeze_immune; + w.player.burn_from_stepping_immune = burn_immune; let _ = w.server_block_damage(start); let _ = w.update_soul_speed_block(); let _ = w.tick_environment_damage(); @@ -2352,12 +2543,16 @@ impl Game<'_> { for d in travelled { game.movement_stats(Vec3::new(d[0], d[1], d[2])); } + // LivingEntity.baseTick: a new block position runs the worn + // enchantments' location_changed effects (frost walker). + game.location_changed_effects([start.x, start.y, start.z], from_ground); // LivingEntity.baseTick: outside the world border, then tickEffects. game.border_damage(); game.tick_mob_effects(); // Soul Speed's effects (LivingEntity.baseTick's location_changed // and tick effects); its particle goes to the players around. soul = game.tick_soul_speed(); + game.handle_shoulder_entities(); let Some(player) = game.player.as_mut() else { return (Vec::new(), None); }; @@ -2396,7 +2591,10 @@ impl Game<'_> { if let Some((at, velocity)) = soul { super::lan_particles::send_soul_particle(host, at, velocity); } - self.as_guest(host, conn, |game| game.tick_player_sculk_events()); + self.as_guest(host, conn, |game| { + game.sculk_step_on_player(); + game.tick_player_sculk_events(); + }); for event in events { match event { MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at), @@ -2700,9 +2898,15 @@ impl Game<'_> { /// Dropped items touching a guest go into their inventory. fn guest_pickups(&mut self, host: &mut LanHost, gi: usize) { - let (conn, mode, position, id) = { + let (conn, mode, position, id, uuid) = { let g = &host.hub.guests[gi]; - (g.conn, g.game_mode, g.position, g.entity_id) + ( + g.conn, + g.game_mode, + g.position, + g.entity_id, + horizon_client::lan::playerdata::uuid_ints(g.uuid), + ) }; if mode == SPECTATOR || self.dropped.is_empty() { return; @@ -2713,6 +2917,7 @@ impl Game<'_> { .enumerate() .filter(|(_, d)| { d.pickup_delay == 0 + && d.target.is_none_or(|t| t == uuid) && (d.position.x - position[0]).abs() < 1.5 && (d.position.z - position[2]).abs() < 1.5 && d.position.y > position[1] - 0.6 diff --git a/crates/horizon-client/src/game/lan_attributes.rs b/crates/horizon-client/src/game/lan_attributes.rs index 73942e770..9909c88f6 100644 --- a/crates/horizon-client/src/game/lan_attributes.rs +++ b/crates/horizon-client/src/game/lan_attributes.rs @@ -24,6 +24,37 @@ fn slot_in_group(group: &str, slot: &str) -> bool { } impl Game<'_> { + /// `getAttributeValue(KNOCKBACK_RESISTANCE)` of a mob: its own value plus + /// the modifiers of the items it wears or holds in matching slots. + pub(super) fn mob_knockback_resistance(&self, m: &Mob) -> f64 { + let e = &m.extra; + let slots = [ + ("mainhand", &e.main_hand), + ("offhand", &e.off_hand), + ("feet", &e.feet), + ("legs", &e.legs), + ("chest", &e.chest), + ("head", &e.head), + ]; + let mut extra = Vec::new(); + for (slot, item) in slots { + let Some(info) = item.as_ref().and_then(|i| self.res.items().get(i)) else { + continue; + }; + for (attribute, _, amount, op, group) in &info.modifiers { + if attribute == "minecraft:knockback_resistance" && slot_in_group(group, slot) { + let op = match operation_named(op) { + 1 => Op::AddMultipliedBase, + 2 => Op::AddMultipliedTotal, + _ => Op::AddValue, + }; + extra.push((*amount, op)); + } + } + } + finalize::value_with(m, Attr::KnockbackResistance, &extra) + } + /// The registry id of a client-syncable attribute the entity type has /// (`AttributeMap.getInstance` is null for the others), by name. fn synced_attribute(&self, entity: &str, name: &str) -> Option { diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index ecfa0aea5..a3de0b9ad 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -11,18 +11,6 @@ use horizon_client::lan::{ use horizon_protocol::entity_data::{Value, serializer}; use horizon_world::nbt::Tag; -/// `ArmorStand`'s default poses (head, body, left arm, right arm, left leg, -/// right leg), DATA_HEAD_POSE to DATA_RIGHT_LEG_POSE (entries 16 to 21), -/// under their `Pose` keys. -const STAND_POSES: [(&str, [f32; 3]); 6] = [ - ("Head", [0.0, 0.0, 0.0]), - ("Body", [0.0, 0.0, 0.0]), - ("LeftArm", [-10.0, 0.0, -10.0]), - ("RightArm", [-15.0, 0.0, 10.0]), - ("LeftLeg", [-1.0, 0.0, -1.0]), - ("RightLeg", [1.0, 0.0, 1.0]), -]; - fn state(id: u32, kind: &str, position: [f64; 3], yaw: f32, on_ground: bool) -> EntityState { EntityState { id: id as i32, @@ -61,28 +49,21 @@ fn vehicle_meta(hurt_time: i32, hurt_dir: i32, damage: f32) -> Vec<(u8, i32, Val meta } -/// An armor stand's pose from its compound (`ArmorStandPose`), each part -/// that differs from the default. -fn stand_poses(raw: Option<&Tag>) -> Vec<(u8, i32, Value)> { - let Some(pose) = raw.and_then(|t| t.get("Pose")) else { - return Vec::new(); - }; +/// An armor stand's pose (`ArmorStandPose`), each part that differs from the +/// default, as DATA_HEAD_POSE to DATA_RIGHT_LEG_POSE (entries 16 to 21). +fn stand_poses(a: &horizon_client::entities::ArmorStand) -> Vec<(u8, i32, Value)> { let mut meta = Vec::new(); - for (i, (key, default)) in STAND_POSES.iter().enumerate() { - let Some(Tag::List(values)) = pose.get(key) else { - continue; - }; - let mut r = *default; - for (k, v) in values.iter().take(3).enumerate() { - if let Tag::Float(bits) = v { - r[k] = f32::from_bits(*bits); - } - } - if r != *default { + for (i, (rotation, default)) in a + .pose + .iter() + .zip(horizon_client::entities::ArmorStand::DEFAULT_POSE) + .enumerate() + { + if *rotation != default { meta.push(( 16 + i as u8, serializer::ROTATIONS, - Value::Floats(r.to_vec()), + Value::Floats(rotation.to_vec()), )); } } @@ -185,7 +166,19 @@ impl Game<'_> { if flags != 0 { e.meta.push((15, serializer::BYTE, Value::Byte(flags))); } - e.meta.extend(stand_poses(self.persist.raw.get(&a.id))); + e.meta.extend(stand_poses(a)); + // A pose put back to its default (`/data`) is sent as that default. + e.defaults.push((15, serializer::BYTE, Value::Byte(0))); + for (i, default) in horizon_client::entities::ArmorStand::DEFAULT_POSE + .iter() + .enumerate() + { + e.defaults.push(( + 16 + i as u8, + serializer::ROTATIONS, + Value::Floats(default.to_vec()), + )); + } // Stored main hand, off hand, feet, legs, chest, head: the wire's slots 0 to 5. for (slot, item) in a.equipment.iter().enumerate() { if item.is_some() { @@ -432,6 +425,9 @@ impl Game<'_> { let mut e = state(t.id, "minecraft:trident", at(t.position), t.yaw, false); e.pitch = t.pitch; e.velocity = at(t.velocity); + // Projectile.getAddEntityPacket: the owner's id; a trident here is + // always the host player's. + e.data = owner(Some(horizon_client::mobs::Who::Player)); e.meta = arrow_meta(false, t.no_physics, 0, t.in_ground); // ThrownTrident.ID_LOYALTY and ID_FOIL. if t.loyalty != 0 { @@ -498,7 +494,9 @@ impl Game<'_> { // The dragon's breath and lingering potion clouds (AreaEffectCloud's DATA_RADIUS, // DATA_WAITING for its 20-tick wait, and DATA_PARTICLE): the // client draws them from these (`tick_remote_clouds`). - let breath = self.network_particle( + // The hub is out of `self.lan` meanwhile, so it is passed in. + let breath = Self::hub_particle( + hub, &horizon_client::particles::ParticleOptions::simple( horizon_client::particles::ParticleType::DragonBreath, ), @@ -560,11 +558,9 @@ mod tests { #[test] fn armor_stand_poses_send_only_what_differs() { - let tag = - horizon_world::nbt::parse_snbt("{Pose:{Head:[10f,20f,0f],LeftArm:[-10f,0f,-10f]}}") - .unwrap() - .0; - let meta = stand_poses(Some(&tag)); + let mut stand = horizon_client::entities::ArmorStand::new(1, Default::default(), 0.0); + stand.pose[0] = [10.0, 20.0, 0.0]; + let meta = stand_poses(&stand); assert_eq!( meta, vec![( @@ -573,6 +569,7 @@ mod tests { Value::Floats(vec![10.0, 20.0, 0.0]) )] ); - assert!(stand_poses(None).is_empty()); + let plain = horizon_client::entities::ArmorStand::new(1, Default::default(), 0.0); + assert!(stand_poses(&plain).is_empty()); } } diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index 49eedbe55..8dd77dde7 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -81,11 +81,20 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { matches!( e, MobEvent::AttackPlayer(..) + | MobEvent::AttackPlayerWithEffect { .. } | MobEvent::DamagePlayer { .. } + | MobEvent::SonicBoom { + target: Who::Player, + .. + } | MobEvent::Push { target: Who::Player, .. } + | MobEvent::Knockback { + target: Who::Player, + .. + } | MobEvent::Ignite { target: Who::Player, .. @@ -96,6 +105,7 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool { } | MobEvent::EffectPlayer { .. } | MobEvent::AxolotlSupportPlayer + | MobEvent::ParrotToShoulder { .. } ) } @@ -369,6 +379,7 @@ mod tests { alive: true, creative, sneaking: false, + swimming: false, look: [0.0; 3], main_hand: None, off_hand: None, @@ -381,6 +392,8 @@ mod tests { last_hurt: None, velocity: Vec3::ZERO, yaw: 0.0, + sprinting: false, + riding: false, hero: false, effects: Vec::new(), uuid: [0; 4], diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs index aa5981e0b..fe1011804 100644 --- a/crates/horizon-client/src/game/lan_particles.rs +++ b/crates/horizon-client/src/game/lan_particles.rs @@ -82,6 +82,40 @@ impl Game<'_> { } } + /// `ServerLevel.sendParticles` of a mob's particles: a packet to each + /// player within 32 blocks. The window draws its own copy. + pub(super) fn lan_level_particles( + &self, + options: &ParticleOptions, + at: [f64; 3], + spread: [f64; 3], + speed: f64, + count: u32, + ) { + let (Some(host), Some(particle)) = (&self.lan, self.network_particle(options, None)) else { + return; + }; + let packet = C::LevelParticles(play::LevelParticles { + particle, + override_limiter: false, + always_show: false, + pos: at, + dist: spread.map(|d| d as f32), + max_speed: [speed as f32; 3], + count: count as i32, + randomization: 0, + }); + for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) { + // ServerLevel compares the player's block centre, strictly within 32. + let distance: f64 = (0..3) + .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2)) + .sum(); + if distance < 32.0 * 32.0 { + g.send(&packet); + } + } + } + /// `LivingEntity.checkFallDamage`'s `ServerLevel.sendParticles` of the /// landing block's crumbs: drawn in this window, when it has one, and /// sent to each player within 32 blocks. `host` is the hub of a guest's @@ -156,7 +190,7 @@ impl Game<'_> { /// `network_particle` for a hub that is out of `self.lan` meanwhile (a /// guest's turn). - fn hub_particle( + pub(super) fn hub_particle( hub: &Hub, options: &ParticleOptions, state: Option, diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 937fa28f4..ebf7b1ce3 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -12,6 +12,7 @@ use horizon_client::{ mobs::Who, projectiles::{Hit, Projectile, ProjectileKind}, }; +use horizon_core::geometry::{Aabb, Vec3}; /// The player projectiles that meet other players: arrows (their hurt), and /// snowballs and eggs, which break on them (`Player.hurtServer` takes no 0 @@ -24,7 +25,7 @@ pub(super) fn meets_players(kind: &ProjectileKind) -> bool { } /// Who a player's attack lands on. -#[derive(Clone, Copy)] +#[derive(Clone, Copy, PartialEq, Eq)] pub(super) enum Victim { Host, Guest(u32), @@ -40,6 +41,8 @@ pub(super) struct Strike { /// `Player.attack`'s `magicBoost > 0`: the enchantments added damage. magic: bool, from: [f64; 3], + /// `getSecondsToDisableBlocking` of the attacker's weapon. + disable_blocking: f32, sweep: Option<[f64; 3]>, /// `causeExtraKnockback`: its strength and direction (the attacker's /// yaw), and whether the hit is a sprinting knockback attack. @@ -47,6 +50,26 @@ pub(super) struct Strike { knockback_attack: bool, /// The attacker's team, for the victim's `Player.canHarmPlayer`. team: Option, + /// The sweep's damage to the players around the victim. + sweep_hit: Option, +} + +/// A sweep attack's reach to the other players (`Player.doSweepAttack`), +/// worked out as the attacker. +#[derive(Clone)] +pub(super) struct Sweep { + /// The attacking guest (none: the host). + attacker: Option, + from: [f64; 3], + /// The damage after the enchantments and the attack strength. + damage: f32, + /// The push along the attacker's yaw. + knockback: (f64, f64), + team: Option, + /// The target's box grown by (1, 0.25, 1). + pub(super) hit_box: Aabb, + /// The player the sweep started from, which it spares. + skip: Option, } impl Strike { @@ -125,10 +148,22 @@ impl Game<'_> { let from = [p.position.x, p.position.y, p.position.z]; let (amount, scale, crit, magic) = self.melee_damage("minecraft:player"); let sweep = self.sweep_attack_position(scale, crit); + let sweep_hit = sweep.map(|_| { + let base = self.sweep_base_damage(scale); + self.player_sweep(base, scale) + }); let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale); let (xd, zd) = self.extra_knockback_direction(); self.attack_ticks = 0; self.swing_arm(); + // LivingEntity.getSecondsToDisableBlocking: the held weapon's value, + // none while another item is in use. + let disable_blocking = if self.using.is_some() { + 0.0 + } else { + self.attack_item_info() + .map_or(0.0, |i| i.disable_blocking_seconds) + }; Some(Strike { attacker: self.lan_acting, amount, @@ -136,10 +171,12 @@ impl Game<'_> { crit, magic, from, + disable_blocking, sweep, knockback: (strength, xd, zd), knockback_attack, team: self.player_team().cloned(), + sweep_hit, }) } @@ -250,7 +287,9 @@ impl Game<'_> { // Player.attack: the hurt (with its knockback away from the // attacker), then causeExtraKnockback along the attacker's yaw. let land = |g: &mut Self| { + g.combat.player_attacker = Some((s.from, s.disable_blocking)); let hurt = g.mob_hits_player(s.amount, s.from, "minecraft:player_attack"); + g.combat.player_attacker = None; let (strength, xd, zd) = s.knockback; if hurt && strength > 0.0 { g.knock_back_player(f64::from(strength), xd, zd); @@ -331,9 +370,118 @@ impl Game<'_> { }; if let Some(at) = s.sweep.filter(|_| hurt) { self.sweep_attack(at, Some(s.from)); + // The other players next to the victim (Player.doSweepAttack). + let bounds = match victim { + Victim::Host => self.player.as_ref().map(|p| p.bounds()), + Victim::Guest(conn) => host.hub.guest(conn).map(guest_bounds), + }; + if let (Some(sweep), Some(bounds)) = (&s.sweep_hit, bounds) { + self.sweep_players( + host, + &Sweep { + hit_box: bounds.inflate(Vec3::new(1.0, 0.25, 1.0)), + skip: Some(victim), + ..sweep.clone() + }, + ); + } } else { self.audio.play(sound, Some(s.from), 1.0, 1.0); } hurt } + + /// The sweep of the player in place, for the players it reaches: the + /// damage (`1 + ratio * baseDamage`, plus the enchantments against a + /// player, scaled by the attack strength) and who hits. The box is set + /// by the caller. + pub(super) fn player_sweep(&mut self, base: f32, scale: f32) -> Sweep { + let from = self + .player + .as_ref() + .map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]); + let damage = (base + self.enchant_damage_bonus("minecraft:player")) * scale; + Sweep { + attacker: self.lan_acting, + from, + damage, + knockback: self.extra_knockback_direction(), + team: self.player_team().cloned(), + hit_box: Aabb::new(Vec3::ZERO, Vec3::ZERO), + skip: None, + } + } + + /// A sweep from a mob hit reaches the other players. Inside a guest's + /// turn the host holds the other players (`as_guest`), so it waits for + /// the turn to end. + pub(super) fn sweep_other_players(&mut self, sweep: Sweep) { + if self.lan_acting.is_some() { + self.creatures.sweeps.push(sweep); + } else if let Some(mut host) = self.lan.take() { + self.sweep_players(&mut host, &sweep); + self.lan = Some(host); + } + } + + /// The sweeps guests' turns put off. + pub(super) fn flush_sweeps(&mut self) { + for sweep in std::mem::take(&mut self.creatures.sweeps) { + self.sweep_other_players(sweep); + } + } + + /// `Player.doSweepAttack` on the players: each other player in the box, + /// closer than 3 blocks (`distanceToSqr < 9`) and not an ally + /// (`isAlliedTo`), is hurt (`ServerPlayer.canHarmPlayer`: the `pvp` rule) + /// and pushed 0.4 along the attacker's yaw. + pub(super) fn sweep_players(&mut self, host: &mut LanHost, sweep: &Sweep) { + let from = Vec3::new(sweep.from[0], sweep.from[1], sweep.from[2]); + let mut victims = Vec::new(); + if sweep.attacker.is_some() + && self.options.dedicated.is_none() + && !self.spectator() + && let Some(p) = self.player.as_ref() + && !p.health.dead_or_dying() + && p.bounds().intersects(sweep.hit_box) + && p.position.distance_squared(from) < 9.0 + { + victims.push((Victim::Host, self.player_team().cloned())); + } + for g in &host.hub.guests { + if host.hub.here(g) + && g.loaded + && !g.dead + && !g.spectator() + && sweep.attacker != Some(g.conn) + && guest_bounds(g).intersects(sweep.hit_box) + && Vec3::new(g.position[0], g.position[1], g.position[2]).distance_squared(from) + < 9.0 + { + let team = self.score.board.players_team(&g.name).cloned(); + victims.push((Victim::Guest(g.conn), team)); + } + } + let (xd, zd) = sweep.knockback; + let land = |g: &mut Self| { + let hurt = g.mob_hits_player(sweep.damage, sweep.from, "minecraft:player_attack"); + if hurt { + g.knock_back_player(0.4, xd, zd); + } + }; + for (victim, team) in victims { + if sweep.skip == Some(victim) + || horizon_client::scoreboard::teams_allied(team.as_ref(), sweep.team.as_ref()) + || !self.ui.rules.bool("pvp") + { + continue; + } + match victim { + Victim::Host => land(self), + Victim::Guest(conn) => { + self.guest_struck_by(host, conn, land); + } + } + } + } } diff --git a/crates/horizon-client/src/game/lan_stations.rs b/crates/horizon-client/src/game/lan_stations.rs index 418ed9c2a..cfd65403a 100644 --- a/crates/horizon-client/src/game/lan_stations.rs +++ b/crates/horizon-client/src/game/lan_stations.rs @@ -317,6 +317,8 @@ impl Game<'_> { self.as_guest(host, conn, |game| { game.give_levels(-need); game.stats.custom("enchant_item", 1); + // CriteriaTriggers.ENCHANTED_ITEM, with the levels it cost. + game.trigger_enchanted_item(&enchanted, need); }); host.hub.guests[gi].xp_seed = self.world.random.next_int(); let env = self.menu_env(); diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs index 7c6fb5598..c658743f0 100644 --- a/crates/horizon-client/src/game/level_particles.rs +++ b/crates/horizon-client/src/game/level_particles.rs @@ -1,8 +1,9 @@ //! Level events whose client handler (`LevelEventHandler`) spawns particles //! on a block: bone meal's growth (1505), dragon egg teleportation (2015), a -//! consumable's teleport (2017), electric sparks (3002), waxing (3003), wax -//! off (3004) and scraping (3005), plus the smoke, drips, egg and dragon -//! fireball particles of 1501, 1502, 1504, 2006, 2009, 2012 and 3009. +//! consumable's teleport (2017), an enderman's (2018), electric sparks (3002), +//! waxing (3003), wax off (3004) and scraping (3005), plus the smoke, drips, +//! egg and dragon fireball particles of 1501, 1502, 1504, 2006, 2009, 2012 +//! and 3009. use super::Game; use horizon_client::items::ItemStack; use horizon_client::particles::{self, ParticleOptions, ParticleType}; @@ -24,6 +25,11 @@ impl Game<'_> { self.particles .block_teleportation(pos, data, [127, 127, 127]); } + /// Event 2018: an enderman's portal trail. + pub(super) fn enderman_teleport_particles(&mut self, pos: [i32; 3], data: i32) { + self.particles + .enderman_teleportation(pos, data, self.settings.particles); + } /// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client /// level's random. pub(super) fn block_particle_event(&mut self, id: i32, pos: BlockPos, data: i32) { @@ -40,7 +46,7 @@ impl Game<'_> { // 3002 with an axis: a lightning rod; otherwise copper cleaned by lightning. match usize::try_from(data) { Ok(axis) if id == 3002 && axis < 3 => { - particles::along_axis(random, axis, p, |p, v| spawned.push((p, v))); + particles::along_axis(random, axis, p, (10, 19), |p, v| spawned.push((p, v))); } _ => particles::on_block_faces(random, p, |p, v| spawned.push((p, v))), } diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 921244e6d..6caf4458a 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -46,8 +46,12 @@ impl Game<'_> { if !self.with_level(|b, level, _| b.is_raining_at(level, p)) { continue; } - // Skeleton trap: effective difficulty / 100 (regional difficulty approximated). - let difficulty = f64::from(self.ui.difficulty) * 0.75; + // Skeleton trap: the local effective difficulty / 100 + // (`getCurrentDifficultyAt(pos)`). + let difficulty = f64::from( + self.local_difficulty([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]) + .effective, + ); let below = &self .res .facts() diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs index 34c968980..76b7f4d1c 100644 --- a/crates/horizon-client/src/game/mace.rs +++ b/crates/horizon-client/src/game/mace.rs @@ -6,6 +6,7 @@ use super::Game; use horizon_client::{ enchant::EffectContext, + items::ItemStack, mobs::{Damage, Mob, Species}, particles::{ParticleOptions, ParticleType}, }; @@ -37,6 +38,41 @@ pub(super) fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool { || m.species() == Species::Allay && m.extra.tame } +/// A smash's knockback on the players, put off while a guest's turn holds +/// the other players. +pub(super) struct SmashPush { + center: Vec3, + heavy: f64, + attacker: Option, + team: Option, +} +/// `MaceItem.getKnockbackPower` and the push of one entity at `at`, `heavy` +/// being 2 after a fall of more than five blocks. +fn smash_push(center: Vec3, heavy: f64, at: Vec3, velocity: &mut Vec3, resistance: f64) { + let d = [at.x - center.x, at.y - center.y, at.z - center.z]; + let distance_sqr = d[0] * d[0] + d[1] * d[1] + d[2] * d[2]; + if distance_sqr > KNOCKBACK_RADIUS.powi(2) { + return; + } + let length = distance_sqr.sqrt(); + let power = + (KNOCKBACK_RADIUS - length) * f64::from(KNOCKBACK_POWER) * heavy * (1.0 - resistance); + if power <= 0.0 { + return; + } + // Vec3.normalize: a vector shorter than 1e-5 has no direction. + let (x, z) = if length < f64::from(1.0e-5f32) { + (0.0, 0.0) + } else { + (d[0] / length * power, d[2] / length * power) + }; + *velocity = Vec3::new( + velocity.x + x, + velocity.y + f64::from(KNOCKBACK_POWER), + velocity.z + z, + ); +} + impl Game<'_> { fn holds_mace(&self) -> bool { self.inventory[self.selected] @@ -100,7 +136,7 @@ impl Game<'_> { /// `LivingEntity.hurtServer` of the mob at `index` by the player's hit: /// the weapon's `armor_effectiveness` enchantments (Breach) thin its armor. pub(super) fn hurt_by_player(&mut self, index: usize, amount: f32, source: Damage) -> bool { - let held = self.inventory[self.selected].clone(); + let held = self.held().cloned(); let kind = self.mobs[index].kind.id.clone(); let ctx = EffectContext { this: Some(&kind), @@ -109,6 +145,7 @@ impl Game<'_> { is_direct: true, damage_type: Some(match source.kind { horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash", + horizon_client::mobs::DamageKind::Spear => "minecraft:spear", _ => "minecraft:player_attack", }), items: Some(self.res.items()), @@ -138,7 +175,7 @@ impl Game<'_> { /// the post-attack enchantments, then `postHurtEnemy` with the weapon's /// wear. pub(super) fn weapon_hit(&mut self, index: usize) { - let Some(stack) = self.inventory[self.selected].clone() else { + let Some(stack) = self.held().cloned() else { return; }; let weapon = self @@ -158,16 +195,26 @@ impl Game<'_> { if smash && let Some(p) = self.player.as_mut() { p.fall_distance = 0.0; } - // ItemStack.postHurtEnemy: hurtAndBreak(weapon.itemDamagePerAttack). + self.weapon_wear(&stack); + } + /// `ItemStack.postHurtEnemy`: `hurtAndBreak(weapon.itemDamagePerAttack)` of + /// the weapon in the acting hand. + pub(super) fn weapon_wear(&mut self, stack: &ItemStack) { + let weapon = self + .res + .items() + .get(&stack.item) + .and_then(|i| i.weapon_damage.map(|d| (d, i.max_damage))); if let Some((per_attack, max)) = weapon && max > 0 && !self.creative { - let loss = self.durability_loss(&stack, per_attack); - if let Some(held) = self.inventory[self.selected].as_mut() { + let loss = self.durability_loss(stack, per_attack); + let cell = self.held_mut(); + if let Some(held) = cell.as_mut() { held.damage += loss; if held.damage >= max { - self.inventory[self.selected] = None; + *cell = None; } } } @@ -181,6 +228,9 @@ impl Game<'_> { return; }; p.velocity = Vec3::new(p.velocity.x, f64::from(0.01f32), p.velocity.z); + // A server player's client is told (ClientboundSetEntityMotionPacket): it moves by + // itself, so without it a Wind Burst's push would add to the speed of the fall. + p.health.sync_velocity = true; // calculateImpactPosition: an earlier impact below the player stays. let impact = match p.impulse.impact_position { Some(at) if at.y <= p.position.y => at, @@ -220,44 +270,75 @@ impl Game<'_> { ]; self.level_event_at(2013, on_pos, 750); let heavy = if fall > HEAVY_THRESHOLD { 2.0 } else { 1.0 }; - // getKnockbackPower and the push of one entity at `at`. - let push = |at: Vec3, velocity: &mut Vec3, resistance: f64| { - let d = [at.x - center.x, at.y - center.y, at.z - center.z]; - let distance_sqr = d[0] * d[0] + d[1] * d[1] + d[2] * d[2]; - if distance_sqr > KNOCKBACK_RADIUS.powi(2) { - return; - } - let length = distance_sqr.sqrt(); - let power = (KNOCKBACK_RADIUS - length) - * f64::from(KNOCKBACK_POWER) - * heavy - * (1.0 - resistance); - if power <= 0.0 { - return; - } - // Vec3.normalize: a vector shorter than 1e-5 has no direction. - let (x, z) = if length < f64::from(1.0e-5f32) { - (0.0, 0.0) - } else { - (d[0] / length * power, d[2] / length * power) - }; - *velocity = Vec3::new( - velocity.x + x, - velocity.y + f64::from(KNOCKBACK_POWER), - velocity.z + z, - ); - }; let player = self.level.player_uuid.or(Some([0, 0, 0, 1])); for m in self .mobs .iter_mut() .filter(|m| m.id != id && m.alive() && !m.removed && !ally_of_player(m, player)) { - push(m.position, &mut m.velocity, m.attrs.knockback_resistance); + smash_push( + center, + heavy, + m.position, + &mut m.velocity, + m.attrs.knockback_resistance, + ); } for s in self.armor_stands.iter_mut().filter(|s| !s.marker) { - push(s.position, &mut s.velocity, 0.0); + smash_push(center, heavy, s.position, &mut s.velocity, 0.0); } + // The host and the LAN guests are living entities too. A guest's turn + // holds the other players (`as_guest`): the push waits for it to end. + let push = SmashPush { + center, + heavy, + attacker: self.lan_acting, + team: self.player_team().cloned(), + }; + if self.lan_acting.is_some() { + self.creatures.smash_pushes.push(push); + } else { + self.smash_push_players(&push); + } + } + /// `MaceItem.knockback` on the players but the attacker: the host unless + /// it attacked, and every guest but the attacker. + fn smash_push_players(&mut self, push: &SmashPush) { + if push.attacker.is_some() { + self.smash_push_player(push); + } + self.each_guest_hit_except(push.attacker, |g| g.smash_push_player(push)); + } + /// The pushes guests' smashes put off. + pub(super) fn flush_smash_pushes(&mut self) { + for push in std::mem::take(&mut self.creatures.smash_pushes) { + self.smash_push_players(&push); + } + } + /// `MaceItem.knockback` on the player here (the host, or the guest swapped + /// in): not a spectator, an ally of the attacker (`isAlliedTo`: the same + /// team) or a creative player flying. + fn smash_push_player(&mut self, push: &SmashPush) { + if self.spectator() + || horizon_client::scoreboard::teams_allied(push.team.as_ref(), self.player_team()) + { + return; + } + let creative = self.creative; + let Some(p) = self.player.as_mut() else { + return; + }; + if creative && p.flying { + return; + } + let resistance = p.attribute("minecraft:knockback_resistance").unwrap_or(0.0); + smash_push( + push.center, + push.heavy, + p.position, + &mut p.velocity, + resistance, + ); } /// `ServerPlayer.checkFallDamage` after a smash on a grounded target: /// the landing block's particles, 50 for every block fallen (200 at most). diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs index 78dbfe66b..f9a208a7f 100644 --- a/crates/horizon-client/src/game/machines.rs +++ b/crates/horizon-client/src/game/machines.rs @@ -41,6 +41,8 @@ enum Kind { Crafter, /// `BrewingStandBlockEntity` (a `WorldlyContainer`). Brewing, + /// `ChiseledBookShelfBlockEntity`: books only, one to a slot. + Bookshelf, /// `ComposterBlock.getContainer` at this level (a `WorldlyContainerHolder` /// without a block entity): input below 7, empty at 7, bone meal at 8. Composter(i32), @@ -82,7 +84,7 @@ impl View { } } -fn dir_from_name(name: &str) -> Option { +pub(super) fn dir_from_name(name: &str) -> Option { Some(match name { "down" => Direction::Down, "up" => Direction::Up, @@ -169,6 +171,7 @@ impl Containers<'_> { (BlockEntity::Furnace(_), _) => Kind::Furnace, (BlockEntity::Crafter(_), _) => Kind::Crafter, (BlockEntity::Brewing(_), _) => Kind::Brewing, + (BlockEntity::ChiseledBookshelf(_), _) => Kind::Bookshelf, (_, "minecraft:hopper") => Kind::Hopper, _ => Kind::Generic, }; @@ -250,6 +253,16 @@ impl Containers<'_> { _ => false, }; } + if view.kind == Kind::Bookshelf { + // ListBackedContainer.canPlaceItem: `acceptsItemType` (the books) + // and a free slot, as `getMaxStackSize` is 1. + return self + .items + .item_tags + .get("minecraft:bookshelf_books") + .is_some_and(|m| m.contains(&*stack.item)) + && self.get(view, slot).is_none(); + } if view.kind == Kind::Brewing { // BrewingStandBlockEntity.canPlaceItem return match slot { @@ -399,6 +412,45 @@ pub(super) fn container_signal( .map_or(0, |v| c.signal(&v)) } +/// `ChiseledBookShelfBlock.getAnalogOutputSignal` and +/// `ShelfBlock.getAnalogOutputSignal`, from the block entity Horizon keeps as +/// it was loaded; `None` for any other block. `direction` points from the +/// block to the comparator. +pub(super) fn shelf_signal( + world: &World, + registry: &'static horizon_world::registry::BlockRegistry, + state: BlockStateId, + pos: BlockPos, + direction: Direction, +) -> Option { + let info = registry.state(state)?; + let chiseled = info.name == "minecraft:chiseled_bookshelf"; + if !chiseled && !info.name.ends_with("_shelf") { + return None; + } + if chiseled { + // The last slot touched, plus one (`lastInteractedSlot` starts at -1). + return Some(match world.block_entities.get(&(pos.x, pos.y, pos.z)) { + Some(BlockEntity::ChiseledBookshelf(b)) => b.last_slot + 1, + _ => 0, + }); + } + let tag = super::spill::saved_entity(world, [pos.x, pos.y, pos.z]); + // Only read from the back: a bit for each of the three slots in use. + let facing = info.properties.get("facing").and_then(|f| dir_from_name(f)); + if facing.map(Direction::opposite) != Some(direction) { + return Some(0); + } + let items = horizon_client::save::decode_items(tag.as_ref().and_then(|t| t.get("Items")), 3); + Some( + items + .iter() + .enumerate() + .map(|(slot, item)| i32::from(item.is_some()) << slot) + .sum(), + ) +} + impl Game<'_> { fn containers(&self) -> Containers<'_> { Containers { @@ -433,6 +485,7 @@ impl Game<'_> { if pos.1 == super::minecarts::CART_KEY_Y { return; } + self.chiseled_bookshelf_synced(pos); // A double chest's other half changes with it. let halves: Vec = std::iter::once(pos) .chain(self.chest_other_half(pos)) @@ -595,27 +648,41 @@ impl Game<'_> { self.container_changed(pos); } } - /// `HopperBlockEntity.ejectItems`. + /// `HopperBlockEntity.ejectItems`: into the block container in front, else + /// a container entity there (`getContainerAt`). fn hopper_eject(&mut self, pos: Pos, hopper: &View) -> bool { let state = self.world.block(pos.0, pos.1, pos.2); let c = self.containers(); let Some(facing) = c.prop(state, "facing").and_then(dir_from_name) else { return false; }; - let Some(target) = c.view(offset(pos, facing), false) else { + let front = offset(pos, facing); + let face = facing.opposite(); + if let Some(target) = c.view(front, false) { + return self.eject_into(pos, hopper, &target, face); + } + let Some(id) = self.entity_container_at([ + f64::from(front.0) + 0.5, + f64::from(front.1) + 0.5, + f64::from(front.2) + 0.5, + ]) else { return false; }; - let face = facing.opposite(); - if c.is_full(&target, face) { + self.with_entity_container(id, |g, target| g.eject_into(pos, hopper, target, face)) + .unwrap_or(false) + } + /// The rest of `HopperBlockEntity.ejectItems`: one item into `target`. + fn eject_into(&mut self, pos: Pos, hopper: &View, target: &View, face: Direction) -> bool { + if self.containers().is_full(target, face) { return false; } for slot in 0..hopper.len() { let Some(one) = self.take_one(hopper, slot) else { continue; }; - match self.add_item(Some(pos), &target, one, Some(face)) { + match self.add_item(Some(pos), target, one, Some(face)) { None => { - self.view_changed(&target); + self.view_changed(target); return true; } Some(rest) => self.put_back(hopper, slot, rest), @@ -626,7 +693,12 @@ impl Game<'_> { /// `HopperBlockEntity.suckInItems`: from the container above, or item entities. fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool { let above = (pos.0, pos.1 + 1, pos.2); - if let Some(took) = self.suck_from_container(above, hopper) { + let at = [ + f64::from(pos.0) + 0.5, + f64::from(pos.1) + 1.5, + f64::from(pos.2) + 0.5, + ]; + if let Some(took) = self.suck_from_container(above, at, hopper) { return took; } let above_state = self.world.block(above.0, above.1, above.2); @@ -660,11 +732,16 @@ impl Game<'_> { self.suck_item_entities(hopper, min, max) } /// The container half of `HopperBlockEntity.suckInItems`: one item from the - /// container at `above`, through its bottom face. `None` when there is no - /// container there. - fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option { + /// container at `above`, through its bottom face; with no block container + /// there, from a container entity whose box meets the one around `at` + /// (`getSourceContainerOrHandler`). `None` when there is no container. + fn suck_from_container(&mut self, above: Pos, at: [f64; 3], hopper: &View) -> Option { let c = self.containers(); - let source = c.view(above, false)?; + let Some(source) = c.view(above, false) else { + let id = self.entity_container_at(at)?; + return self + .with_entity_container(id, |g, source| g.suck_from_slots(None, source, hopper)); + }; if let Kind::Composter(level) = source.kind { if level != 8 { return Some(false); @@ -683,26 +760,133 @@ impl Game<'_> { return Some(moved); } let source_hopper = (source.kind == Kind::Hopper).then_some(above); + Some(self.suck_from_slots(source_hopper, &source, hopper)) + } + /// `HopperBlockEntity.tryTakeInItemFromSlot` over the `DOWN` face of `source`. + fn suck_from_slots( + &mut self, + source_hopper: Option, + source: &View, + hopper: &View, + ) -> bool { for slot in source.slots_for_face(Some(Direction::Down)) { let c = self.containers(); - let Some(stack) = c.get(&source, slot) else { + let Some(stack) = c.get(source, slot) else { continue; }; - if !c.can_take(&source, slot, stack, Direction::Down) { + if !c.can_take(source, slot, stack, Direction::Down) { continue; } - let Some(one) = self.take_one(&source, slot) else { + let Some(one) = self.take_one(source, slot) else { continue; }; match self.add_item(source_hopper, hopper, one, None) { None => { - self.view_changed(&source); - return Some(true); + self.view_changed(source); + return true; } - Some(rest) => self.put_back(&source, slot, rest), + Some(rest) => self.put_back(source, slot, rest), } } - Some(false) + false + } + /// `HopperBlockEntity.getEntityContainer`: one of the alive container + /// entities (`EntitySelector.CONTAINER_ENTITY_SELECTOR`: chest and hopper + /// minecarts, chest boats) whose box meets the 1x1x1 box around `at`, + /// picked at random. + fn entity_container_at(&mut self, at: [f64; 3]) -> Option { + let meets = |b: horizon_core::geometry::Aabb| { + let (lo, hi) = (b.min_position(), b.max_position()); + lo.x < at[0] + 0.5 + && hi.x > at[0] - 0.5 + && lo.y < at[1] + 0.5 + && hi.y > at[1] - 0.5 + && lo.z < at[2] + 0.5 + && hi.z > at[2] - 0.5 + }; + let mut found: Vec = self + .carts + .iter() + .filter(|c| { + matches!( + c.kind, + super::minecarts::CartKind::Chest | super::minecarts::CartKind::Hopper + ) && meets(c.bounds()) + }) + .map(|c| c.id) + .collect(); + found.extend( + self.boats + .iter() + .filter(|b| b.chest && meets(b.bounds())) + .map(|b| b.id), + ); + if found.is_empty() { + return None; + } + let pick = self + .world + .random + .next_int_bound(found.len() as i32) + .unwrap_or(0); + found.get(pick as usize).copied() + } + /// Runs `f` on a container entity's items as a container, under the + /// placeholder key its menu uses (the open menu's copy when it is open), + /// then hands the items back to the entity. + fn with_entity_container( + &mut self, + id: u32, + f: impl FnOnce(&mut Self, &View) -> R, + ) -> Option { + let mut items = if let Some(c) = self.carts.iter_mut().find(|c| c.id == id) { + std::mem::take(&mut c.items) + } else { + std::mem::take(&mut self.boats.iter_mut().find(|b| b.id == id)?.items) + }; + let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, id as i32); + let (view, open) = self.lend_items(key, &mut items); + let result = f(self, &view); + self.reclaim_items(key, open, &mut items); + if let Some(c) = self.carts.iter_mut().find(|c| c.id == id) { + c.items = items; + } else if let Some(b) = self.boats.iter_mut().find(|b| b.id == id) { + b.items = items; + } + Some(result) + } + /// A vehicle's slots as a container under its placeholder `key`. When its + /// menu is open the placeholder is the live copy and stays as it is. + /// Returns the view and whether the menu was open. + fn lend_items(&mut self, key: Pos, items: &mut Vec>) -> (View, bool) { + let open = self.world.block_entities.contains_key(&key); + if !open { + let slots = BlockEntity::Chest(std::mem::take(items)); + self.world.block_entities.insert(key, slots); + } + let size = self + .world + .block_entities + .get(&key) + .map_or(0, |e| e.slots().len()); + let view = View { + parts: vec![(key, size)], + kind: Kind::Generic, + }; + (view, open) + } + /// Gives `lend_items`' slots back to the vehicle, so its own items stay + /// the one source of truth: a menu copy that is still around (open, or + /// left by a guest's close) gets the changed items copied to `items`. + fn reclaim_items(&mut self, key: Pos, open: bool, items: &mut Vec>) { + let slots = if open { + self.world.block_entities.get(&key).cloned() + } else { + self.world.block_entities.remove(&key) + }; + if let Some(BlockEntity::Chest(slots)) = slots { + *items = slots; + } } /// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`): /// adds the item entities that meet the box, until one is taken whole. @@ -738,20 +922,7 @@ impl Game<'_> { // The cart's slots are edited as a container under the placeholder key // its menu uses; when that menu is open the placeholder is the live copy. let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32); - let open = self.world.block_entities.contains_key(&key); - if !open { - let items = BlockEntity::Chest(std::mem::take(&mut cart.items)); - self.world.block_entities.insert(key, items); - } - let size = self - .world - .block_entities - .get(&key) - .map_or(0, |e| e.slots().len()); - let view = View { - parts: vec![(key, size)], - kind: Kind::Generic, - }; + let (view, open) = self.lend_items(key, &mut cart.items); let p = cart.position; // getLevelY is the cart's y + 0.5, so the container is the block at // y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16 @@ -761,7 +932,8 @@ impl Game<'_> { (p.y + 1.5).floor() as i32, p.z.floor() as i32, ); - let took = match self.suck_from_container(above, &view) { + let at = [p.x, p.y + 1.5, p.z]; + let took = match self.suck_from_container(above, at, &view) { Some(took) => took, None => self.suck_item_entities( &view, @@ -779,17 +951,7 @@ impl Game<'_> { [hi.x + 0.25, hi.y, hi.z + 0.25], ); } - // The cart's own items stay the one source of truth: a menu copy that - // is still around (open, or left by a guest's close) gets the pulled - // items back into `cart.items`, so reopening never restores a stale copy. - let slots = if open { - self.world.block_entities.get(&key).cloned() - } else { - self.world.block_entities.remove(&key) - }; - if let Some(BlockEntity::Chest(items)) = slots { - cart.items = items; - } + self.reclaim_items(key, open, &mut cart.items); } // ---- dispensers and droppers ---- @@ -1027,6 +1189,7 @@ mod item_column_tests { id, stack: ItemStack::new("minecraft:stone", 1), thrower: None, + target: None, position: at, previous: at, velocity: Vec3::ZERO, diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs index 1617eab56..e2680ec84 100644 --- a/crates/horizon-client/src/game/maps.rs +++ b/crates/horizon-client/src/game/maps.rs @@ -721,6 +721,93 @@ impl Game<'_> { self.swing_arm(); true } + /// `CompassItem.useOn`: a compass used on a lodestone locks onto it (a + /// single one in survival changes in place, else one is split off). + pub(super) fn use_lodestone_compass(&mut self, hit: &super::Hit, stack: &ItemStack) -> bool { + if &*stack.item != "minecraft:compass" { + return false; + } + let [x, y, z] = hit.pos; + if self + .res + .facts() + .get(self.world.block(x, y, z)) + .name + .as_ref() + != "minecraft:lodestone" + { + return false; + } + let at = [x, y, z].map(|v| f64::from(v) + 0.5); + self.audio + .play("minecraft:item.lodestone_compass.lock", Some(at), 1.0, 1.0); + let target = Tag::compound([( + "target", + Tag::compound([ + ("dimension", Tag::String(self.dimension_id().into())), + ("pos", Tag::IntArray(vec![x, y, z])), + ]), + )]); + if !self.creative && stack.count == 1 { + if let Some(held) = self.held_mut() { + held.data_mut() + .set_other("minecraft:lodestone_tracker", Some(target)); + } + } else { + let mut locked = stack.clone(); + locked.count = 1; + locked + .data_mut() + .set_other("minecraft:lodestone_tracker", Some(target)); + self.consume_held(); + self.give_or_drop_stack(locked); + } + self.stats.add("used", &stack.item, 1); + self.swing_arm(); + true + } + /// `CompassItem.inventoryTick` / `LodestoneTracker.tick`: a compass whose + /// lodestone is gone loses its target. A target in an unloaded chunk waits. + pub(super) fn tick_lodestone_compasses(&mut self) { + let dim = self.dimension_id(); + let gone = |game: &Self, stack: &ItemStack| -> bool { + let Some(tracker) = stack + .data() + .and_then(|d| d.other("minecraft:lodestone_tracker")) + else { + return false; + }; + let (Some(target), true) = ( + tracker.get("target"), + horizon_client::save::number(tracker.get("tracked")).is_none_or(|v| v != 0), + ) else { + return false; + }; + let Some(Tag::IntArray(pos)) = target.get("pos") else { + return false; + }; + let [x, y, z] = [pos[0], pos[1], pos[2]]; + horizon_client::save::text(target.get("dimension")).as_deref() == Some(dim) + && game.world.chunks.contains_key(&(x >> 4, z >> 4)) + && game + .res + .facts() + .get(game.world.block(x, y, z)) + .name + .as_ref() + != "minecraft:lodestone" + }; + for slot in (0..self.inventory.len()).chain([super::shield::OFFHAND_SLOT]) { + if self.stack_in(slot).is_some_and(|s| gone(self, s)) + && let Some(s) = self.stack_in_mut(slot) + { + s.data_mut().set_other( + "minecraft:lodestone_tracker", + Some(Tag::Compound(Default::default())), + ); + } + } + } fn give_or_drop_stack(&mut self, stack: ItemStack) { if let Some(rest) = self.give(stack) && let Some(eye) = self.eye_position() @@ -781,9 +868,8 @@ impl Game<'_> { (d * 2.0 + 0.5) as i8 } }; - let y = f64::from(yaw); - let adjusted = if y < 0.0 { y - 8.0 } else { y + 8.0 }; - let rot = ((adjusted * 16.0 / 360.0) as i32 & 15) as u8; + // calculateRotation: the arrow spins in the Nether. + let rot = decoration_rotation(nether, game_time, f64::from(yaw)); let sprite = if inside { Some("map/decorations/player") } else if dx.abs() < 320.0 && dz.abs() < 320.0 { diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs index a57accfaa..118b3cc8d 100644 --- a/crates/horizon-client/src/game/mob_blocks.rs +++ b/crates/horizon-client/src/game/mob_blocks.rs @@ -386,13 +386,15 @@ impl Game<'_> { owner.use_item_remaining_ticks = 72_000 - mob.extra.using_item; owner.crossbow_charge_duration = 25; } - let context = if left { - horizon_assets::item_model::DisplayContext::ThirdPersonLeftHand - } else { - horizon_assets::item_model::DisplayContext::ThirdPersonRightHand + use horizon_assets::item_model::DisplayContext as Context; + // PandaHoldsItemLayer shows the item as it lies on the ground. + let (context, ordinal) = match (mob.species(), left) { + (Species::Panda, _) => (Context::Ground, 7), + (_, true) => (Context::ThirdPersonLeftHand, 1), + (_, false) => (Context::ThirdPersonRightHand, 2), }; // `updateForLiving`: seeded by the entity id plus the context ordinal. - let seed = mob.id as i32 + if left { 1 } else { 2 }; + let seed = mob.id as i32 + ordinal; let state = self.resolve_item(&stack, context, Some(&owner), seed); if lit { self.submit_item_world(&state, t, light, out); diff --git a/crates/horizon-client/src/game/mob_gear.rs b/crates/horizon-client/src/game/mob_gear.rs index 809b250dc..7dc529f17 100644 --- a/crates/horizon-client/src/game/mob_gear.rs +++ b/crates/horizon-client/src/game/mob_gear.rs @@ -5,11 +5,15 @@ use super::Game; use horizon_client::{ mobs::{ Species, + drops::{self, SLOTS}, + finalize::equip_stack, gear::{self, ARMOR, MAIN}, + spawner::equipment_table, }, raid::{self, RaiderType}, }; use horizon_core::random::RandomSource; +use horizon_world::{loot::EntityLootParams, nbt::Tag}; /// `EnchantmentsByCostWithDifficulty` of `mob_spawn_equipment`. const MIN_COST: i32 = 5; @@ -47,6 +51,58 @@ fn slot_item(m: &horizon_client::mobs::Mob, slot: usize) -> Option { + /// `Mob.equip(EquipmentTable)` for a spawner's `equipment`: the loot table + /// (the mob as `this`, its random sequence) is rolled and each stack goes + /// in the slot `EquipmentUser.resolveSlot` picks, with the table's drop + /// chance for that slot. + pub(super) fn equip_from_table(&mut self, id: u32, table: &Tag) { + let Some((name, chances)) = equipment_table(table) else { + return; + }; + let Some(loot) = horizon_client::structure_blocks::loot_data(&self.options.resources) + else { + return; + }; + let Some(m) = self.mobs.iter().find(|m| m.id == id) else { + return; + }; + if !loot.has_table(&name) { + return; + } + let params = EntityLootParams { + this: drops::loot_entity(m, None), + ..EntityLootParams::default() + }; + let seed = self.level.seed; + let stacks = match loot.random_sequence(&name) { + Some(sequence) => { + let random = self.rand_sequences.get(sequence, seed); + loot.roll_entity(&name, random, ¶ms) + } + None => loot.roll_entity(&name, &mut self.world.random, ¶ms), + }; + let mut inserted: Vec = Vec::new(); + for stack in stacks.iter().filter(|s| !s.is_empty()) { + // `resolveSlot`: an `equippable` item goes in its own slot, any + // other in the main hand, each slot once. + let slot = match self + .res + .items() + .get(&stack.item) + .and_then(|i| i.equip_slot.as_deref()) + { + Some(name) => SLOTS.iter().position(|s| *s == name), + None => Some(0), + }; + let Some(slot) = slot.filter(|s| !inserted.contains(s)) else { + continue; + }; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + equip_stack(m, slot, stack, chances[slot]); + } + inserted.push(slot); + } + } /// `Mob.populateDefaultEquipmentEnchantments`: the weapon one time in /// four and each piece of armour one time in two, scaled by the local /// difficulty, enchanted as if at an enchanting table of cost 5 to 22. diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index 617d86aaa..0084bfa2f 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -273,10 +273,7 @@ impl Game<'_> { /// `LocalPlayer.aiStep`'s riding jump: the bar charges while jump is /// held; on release, the jump's strength (0 when there is none). pub(super) fn charge_mount_jump(&mut self, i: usize, keys: Keys) -> f32 { - // PlayerRideableJumping: horses, camels and nautili (the dash). - let saddled = self.mobs[i].extra.saddled - && (equine::is_equine(self.mobs[i].species()) - || horizon_client::mobs::nautilus::is_nautilus(self.mobs[i].species())); + let saddled = self.mobs[i].extra.saddled && Self::jumps(self.mobs[i].species()); let mut jump = 0.0; if saddled { let st = &mut self.mount; @@ -485,10 +482,15 @@ impl Game<'_> { _ => {} } } - /// `Player.jumpableVehicle`: a saddled mount that jumps. + /// `PlayerRideableJumping`: horses, camels and nautili (the dash). + fn jumps(species: Species) -> bool { + equine::is_equine(species) || horizon_client::mobs::nautilus::is_nautilus(species) + } + /// `Player.jumpableVehicle`: a saddled mount that jumps (not a pig or a + /// strider, which a saddle only steers). pub(super) fn jumpable_mount(&self) -> bool { self.mount_index() - .is_some_and(|i| self.mobs[i].extra.saddled) + .is_some_and(|i| self.mobs[i].extra.saddled && Self::jumps(self.mobs[i].species())) } /// `willPrioritizeJumpInfo`: charging a jump or recharging. pub(super) fn mount_jumping(&self) -> bool { @@ -513,8 +515,13 @@ impl Game<'_> { let draws = horizon_client::hud_layout::vehicle_health(w, h, hearts, m.health); horizon_client::hud_layout::paint(batch, atlas, &draws); if jump_bar { - // JumpableVehicleBar: the cooldown shows while the jump recharges. - let cooldown = i32::from(self.mount.jump_ticks < 0); + // JumpableVehicleBar: `getJumpCooldown`, which only the camel's and + // the nautilus' dash have; a horse always shows the progress. + let cooldown = i32::from( + self.mount.jump_ticks < 0 + && (matches!(m.species(), Species::Camel | Species::CamelHusk) + || horizon_client::mobs::nautilus::is_nautilus(m.species())), + ); let draws = horizon_client::hud_overlays::jump_bar(w, h, cooldown, self.mount.jump_scale); horizon_client::hud_layout::paint(batch, atlas, &draws); diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs index c8142284a..d8c76231d 100644 --- a/crates/horizon-client/src/game/nether_portal.rs +++ b/crates/horizon-client/src/game/nether_portal.rs @@ -297,7 +297,8 @@ impl Game<'_> { let p = plan.approximate; let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5); if plan.dim == Dim::End { - if let Err(e) = self.end_arrival(centre) { + // In the End the arrival only builds the platform: no spawn search. + if let Err(e) = self.end_arrival(centre, &mut None) { log::error!("End platform: {e}"); } return centre; @@ -662,6 +663,17 @@ impl Game<'_> { ); } } + /// `Entity.setPortalCooldown` on an entity that has just spawned in a + /// portal: it stands in the portal for 300 ticks without going through. + pub(super) fn set_portal_cooldown(&mut self, id: u32) { + self.portals.entities.insert( + id, + PortalState { + cooldown: ENTITY_DELAY, + process: None, + }, + ); + } /// `canUsePortal(false)` of a mob: alive, riding nothing, not asleep, /// not carrying the player, and not a boss that never travels. fn mob_can_use_portal(&self, m: &horizon_client::mobs::Mob) -> bool { diff --git a/crates/horizon-client/src/game/pandas.rs b/crates/horizon-client/src/game/pandas.rs new file mode 100644 index 000000000..f89feca05 --- /dev/null +++ b/crates/horizon-client/src/game/pandas.rs @@ -0,0 +1,165 @@ +//! Pandas on the game side: the food they find on the ground and pick up +//! (`Mob.aiStep`, `Panda.pickUpItem`), the bamboo a player gives them +//! (`Panda.mobInteract`), the start a sneeze gives the grown pandas about, +//! and the crumbs and the sneeze a window draws. +use super::{ + Game, + pickups::{Collector, Taken}, +}; +use horizon_client::{ + items::ItemStack, + mobs::{Species, panda}, + particles::{ParticleOptions, ParticleType}, +}; +use horizon_core::geometry::Vec3; + +impl Game<'_> { + /// `Panda.canPickUpAndEat`'s tag. + fn panda_eats_from_ground(&self, item: &str) -> bool { + self.res + .items() + .item_tags + .get("minecraft:panda_eats_from_ground") + .is_some_and(|tag| tag.contains(item)) + } + /// A panda takes what lies at its feet when its mouth is free, and + /// looks for food within 6 and 8 blocks for `PandaSitGoal`. + pub(super) fn tick_pandas(&mut self) { + let griefing = self.ui.rules.bool("mob_griefing"); + for i in 0..self.mobs.len() { + let m = &self.mobs[i]; + if m.species() != Species::Panda || !m.alive() { + continue; + } + let id = m.id; + let wants = |g: &Self, e: &horizon_client::entities::ItemEntity| { + e.pickup_delay == 0 && g.panda_eats_from_ground(&e.stack.item) + }; + // Mob.aiStep: the items within the box grown by (1, 0, 1). + if griefing && m.can_pick_up_loot() && m.extra.main_hand.is_none() { + let reach = m.bounds().inflate(Vec3::new(1.0, 0.0, 1.0)); + let taken = self + .dropped + .iter() + .position(|e| wants(self, e) && reach.intersects(e.bounds())); + if let Some(j) = taken { + let e = self.dropped.remove(j); + self.add_pickup(Taken::Item(Box::new(e.clone())), Collector::Mob(id)); + panda::hold(&mut self.mobs[i], &e.stack.item, e.stack.count, true); + } + } + let m = &self.mobs[i]; + let area = |r: f64| m.bounds().inflate(Vec3::new(r, r, r)); + let (near, wide) = (area(6.0), area(8.0)); + let food_near = self + .dropped + .iter() + .any(|e| wants(self, e) && near.intersects(e.bounds())); + let food_at = self + .dropped + .iter() + .find(|e| wants(self, e) && wide.intersects(e.bounds())) + .map(|e| [e.position.x, e.position.y, e.position.z]); + panda::set_food(&mut self.mobs[i], food_near, food_at); + } + } + /// `Panda.mobInteract` for a click with `item`; whether the click is taken. + pub(super) fn interact_panda(&mut self, index: usize, item: &str) -> bool { + let creative = self.creative; + let m = &mut self.mobs[index]; + if panda::scared(m) { + return false; + } + if panda::get_up(m) { + return true; + } + if !m.kind.food.iter().any(|f| f == item) { + return false; + } + if m.ai.target.is_some() { + panda::got_bamboo(m); + } + let at = [m.position.x, m.position.y, m.position.z]; + let mut dropped = None; + if m.is_baby() { + // ageUp((int) (-getAge() / 20 * 0.1F), true). + let seconds = ((-m.extra.age / 20) as f32 * 0.1) as i32; + horizon_client::mobs::ai::age_up(m, seconds, true); + } else if m.extra.age == 0 && m.extra.in_love <= 0 { + m.extra.in_love = 600; + m.extra.love_player = true; + } else { + if panda::is_sitting(m) || m.fluids.in_water { + return false; + } + panda::try_to_sit(m); + panda::start_eating(m); + // What it held falls, unless the player has infinite materials. + if let Some(held) = m.extra.main_hand.clone() + && !creative + { + dropped = Some(ItemStack::new(&held, panda::held_count(m))); + } + panda::hold(m, item, 1, false); + } + self.consume_held(); + if let Some(stack) = dropped { + self.spawn_item(stack, at, [0.0, 0.2, 0.0], 10); + } + true + } + /// `Panda.afterSneeze`: the grown pandas within 10 blocks of a cub jump. + pub(super) fn panda_sneezed(&mut self, id: u32) { + let Some(area) = self + .mobs + .iter() + .find(|m| m.id == id) + .map(|m| m.bounds().inflate(Vec3::new(10.0, 10.0, 10.0))) + else { + return; + }; + for m in &mut self.mobs { + if m.species() == Species::Panda + && !m.is_baby() + && m.on_ground + && !m.fluids.in_water + && panda::can_perform_action(m, panda::scared(m)) + && area.intersects(m.bounds()) + { + // LivingEntity.jumpFromGround. + m.needs_sync = true; + let power = f64::from(m.jump_power()); + if power > 1.0e-5 { + m.velocity.y = power.max(m.velocity.y); + } + } + } + } + /// What a window draws of its pandas: the crumbs of a bite + /// (`addEatingParticles`) and the sneeze's particle. + pub(super) fn panda_effects(&mut self) { + let mut bites = Vec::new(); + let mut sneezes = Vec::new(); + for m in self + .mobs + .iter_mut() + .filter(|m| m.species() == Species::Panda) + { + let (crumbs, sneeze) = panda::effects(m); + if let (Some(crumbs), Some(item)) = (crumbs, m.extra.main_hand.clone()) { + bites.push((item, crumbs)); + } + sneezes.extend(sneeze); + } + for (item, crumbs) in bites { + let options = self.item_particle(&ItemStack::new(&item, 1)); + for (at, velocity) in crumbs { + self.particles.add(&options, at, velocity); + } + } + let options = ParticleOptions::simple(ParticleType::Sneeze); + for (at, velocity) in sneezes { + self.particles.add(&options, at, velocity); + } + } +} diff --git a/crates/horizon-client/src/game/passengers.rs b/crates/horizon-client/src/game/passengers.rs index 8f205c484..c39a6d1af 100644 --- a/crates/horizon-client/src/game/passengers.rs +++ b/crates/horizon-client/src/game/passengers.rs @@ -279,11 +279,13 @@ impl Game<'_> { /// horse is a trap for fifteen minutes; a player within ten blocks springs /// it. pub(super) fn tick_skeleton_traps(&mut self) { - let player = self - .player - .as_ref() - .filter(|p| !p.health.dead_or_dying()) - .map(|p| p.position); + // `Level.hasNearbyAlivePlayer`: alive, not a spectator, in the level. + let players: Vec<_> = self + .level_players() + .into_iter() + .filter(|p| p.alive && !p.spectator) + .map(|p| p.position) + .collect(); let mut sprung = Vec::new(); for m in &mut self.mobs { if m.species() != Species::SkeletonHorse || !m.extra.trap || !m.alive() { @@ -296,7 +298,10 @@ impl Game<'_> { continue; } } - if player.is_some_and(|p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) { + if players + .iter() + .any(|&p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) + { sprung.push(m.id); } } diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index 2c4cd1571..ceb4507de 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -381,7 +381,15 @@ impl Game<'_> { m.head_pitch = pitch; let mut target = m.body_yaw; if dx * dx + dz * dz > 0.002_500_000_2 { - target = (dz.atan2(dx) as f32).to_degrees() - 90.0; + // LivingEntity.tick: walking backwards the body faces away from + // the walk direction, not along it. + let walk = (dz.atan2(dx) as f32).to_degrees() - 90.0; + let facing = (wrap(yaw) - walk).abs(); + target = if 95.0 < facing && facing < 265.0 { + walk - 180.0 + } else { + walk + }; } if swinging { target = yaw; @@ -463,7 +471,14 @@ impl Game<'_> { &self.player_armor_layers(), out, ); - self.player_elytra_geometry(m, camera, alpha as f32, packed, out); + self.player_elytra_geometry( + m, + self.armor[1].as_ref().map(|s| &*s.item), + camera, + alpha as f32, + packed, + out, + ); self.spin_attack_geometry(m, camera, alpha as f32, packed, out); self.held_item_geometry(m, camera, alpha, packed, true, out); // LivingEntity.isCurrentlyGlowing: the Glowing effect. A server's client is @@ -528,7 +543,14 @@ impl Game<'_> { &self.player_armor_layers(), &mut verts, ); - self.player_elytra_geometry(&m, camera, 1.0, 240 | 240 << 8, &mut verts); + self.player_elytra_geometry( + &m, + self.armor[1].as_ref().map(|s| &*s.item), + camera, + 1.0, + 240 | 240 << 8, + &mut verts, + ); self.held_item_geometry(&m, camera, 1.0, 240 | 240 << 8, false, &mut verts); let height = if m.extra.crouching { 1.5 } else { 1.8 }; // PictureInPictureRenderer: the box centre, (size, size, -size); @@ -567,17 +589,18 @@ impl Game<'_> { } impl Game<'_> { - fn player_elytra_geometry( + /// `WingsLayer` for a player wearing `chest`. + pub(super) fn player_elytra_geometry( &self, m: &Mob, + chest: Option<&str>, camera: glam::DVec3, partial: f32, light: u32, out: &mut Vec, ) { - let Some(asset) = self.armor[1] - .as_ref() - .and_then(|s| self.res.items().get(&s.item)) + let Some(asset) = chest + .and_then(|item| self.res.items().get(item)) .and_then(|i| i.equip_asset.as_ref()) else { return; @@ -617,7 +640,7 @@ impl Game<'_> { } /// `SpinAttackEffectLayer`: Riptide's two boxes turning around a spinning /// player (`SpinAttackEffectModel.setupAnim`). - fn spin_attack_geometry( + pub(super) fn spin_attack_geometry( &self, m: &Mob, camera: glam::DVec3, diff --git a/crates/horizon-client/src/game/pick_entity.rs b/crates/horizon-client/src/game/pick_entity.rs new file mode 100644 index 000000000..5efc54d44 --- /dev/null +++ b/crates/horizon-client/src/game/pick_entity.rs @@ -0,0 +1,98 @@ +//! Pick Block on an entity (`Minecraft.pickBlockOrEntity`'s entity case and +//! `ServerGamePacketListenerImpl.handlePickItemFromEntity`): the client aims, +//! the server answers with `Entity.getPickResult`. +use super::Game; +use horizon_client::items::ItemStack; + +impl Game<'_> { + /// The entity the crosshair hits before any block, as `Entity.getId`; an + /// entity with nothing to pick (a projectile, a player, the dragon) is + /// `Some(None)`. `None` when the view hits a block or nothing. + pub(super) fn pick_entity_hit(&self) -> Option> { + let mut best: Option<(f64, Option)> = None; + let mut offer = |distance: f64, id: Option| { + if self.before_block(distance) && best.is_none_or(|b| distance < b.0) { + best = Some((distance, id)); + } + }; + if let Some(hit) = self.remote_object_hit(true) { + offer(hit.distance, Some(hit.id)); + } + if let Some((i, d)) = self.mob_hit() { + offer(d, Some(self.mobs[i].id as i32)); + } + if let Some((_, d)) = self.guest_hit() { + offer(d, None); + } + if let Some((_, d)) = self.redirectable_hit() { + offer(d, None); + } + if let Some((_, d)) = self.dragon_hit() { + offer(d, None); + } + best.map(|b| b.1) + } + + /// `Entity.getPickResult` of the entity `id`: a mob's spawn egg, the item + /// of a boat, minecart, armor stand, cushion, painting, item frame (the + /// framed item when it holds one) or end crystal. + pub(super) fn entity_pick_result(&self, id: i32) -> Option { + let id = u32::try_from(id).ok()?; + let item = if let Some(m) = self.mobs.iter().find(|m| m.id == id) { + // Mob.getPickResult: SpawnEggItem.byId. + let egg = format!("{}_spawn_egg", m.kind.id); + return self.res.items().get(&egg).map(|_| ItemStack::new(&egg, 1)); + } else if let Some(b) = self.boats.iter().find(|b| b.id == id) { + b.entity_type() + } else if let Some(c) = self.carts.iter().find(|c| c.id == id) { + c.kind.id().to_owned() + } else if self.armor_stands.iter().any(|a| a.id == id) { + "minecraft:armor_stand".to_owned() + } else if let Some(c) = self.cushions.iter().find(|c| c.id == id) { + c.item() + } else if let Some(f) = self.item_frames.iter().find(|f| f.id == id) { + // ItemFrame.getPickResult: what it frames, else the frame itself. + return Some( + f.item + .clone() + .unwrap_or_else(|| ItemStack::new(f.kind(), 1)), + ); + } else if self.paintings.iter().any(|p| p.id == id) { + "minecraft:painting".to_owned() + } else if self.crystals.iter().any(|c| c.id == id) { + "minecraft:end_crystal".to_owned() + } else { + return None; + }; + Some(ItemStack::new(&item, 1)) + } + + /// `Player.isWithinEntityInteractionRange(entity, 3.0)`: the entity's box + /// within the interaction range plus 3 of the eyes. + pub(super) fn within_entity_range(&self, id: i32) -> bool { + let Some(eye) = self.eye_position() else { + return false; + }; + let mob = u32::try_from(id) + .ok() + .and_then(|id| self.mobs.iter().find(|m| m.id == id)) + .map(|m| m.bounds()); + let Some(b) = self + .object_target(id) + .map(|(lo, hi, _)| (lo, hi)) + .or_else(|| { + mob.or_else(|| self.tracked_special_box(id)).map(|b| { + let (lo, hi) = (b.min_position(), b.max_position()); + ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z]) + }) + }) + else { + return false; + }; + let d2: f64 = (0..3) + .map(|a| (eye[a] - eye[a].clamp(b.0[a], b.1[a])).powi(2)) + .sum(); + let range = if self.creative { 5.0 } else { 3.0 } + 3.0; + d2 < range * range + } +} diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index c0d7f1e3c..affd68782 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -119,6 +119,22 @@ fn mob_can_be_affected( || (effect != "regeneration" && effect != "poison") } } +/// `ThrownSplashPotion.onHitAsPotion`: the squared distance from the potion's +/// box at the hit point to an entity's box grown by the hit margin +/// (`ProjectileUtil.computeMargin`), for entities that meet the potion's box +/// grown by (4, 2, 4); none when it is 16 or more. +fn splash_distance_sqr(at: Vec3, age: u32, bounds: Aabb) -> Option { + let potion = Aabb::new( + Vec3::new(at.x - 0.125, at.y, at.z - 0.125), + Vec3::new(at.x + 0.125, at.y + 0.25, at.z + 0.125), + ); + if !potion.inflate(Vec3::new(4.0, 2.0, 4.0)).intersects(bounds) { + return None; + } + let margin = ((f64::from(age) - 2.0) / 20.0).clamp(0.0, 0.3); + let d2 = potion.distance_squared_to_box(bounds.inflate(Vec3::new(margin, margin, margin))); + (d2 < 16.0).then_some(d2) +} impl Game<'_> { /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer @@ -804,15 +820,15 @@ impl Game<'_> { } } if let Some((p, mob)) = hit { - landed.push((t.stack.clone(), p, mob, t.owner.clone())); + landed.push((t.stack.clone(), p, mob, t.age, t.owner.clone())); return false; } t.position = next; t.age < 1200 && t.position.y > -128.0 }); self.potions.thrown = thrown; - for (stack, at, mob, owner) in landed { - self.splash(&stack, at, mob, owner); + for (stack, at, mob, age, owner) in landed { + self.splash(&stack, at, mob, age, owner); } } /// `AreaEffectCloud.tick` for the lingering potions' clouds: the client @@ -1079,17 +1095,20 @@ impl Game<'_> { &mut self, effects: &'static [(&'static str, i32, i32)], at: Vec3, + age: u32, source: &Text, ) { if let Some(p) = self.player.as_ref() { - let center = Vec3::new( - p.position.x, - p.position.y + f64::from(p.dimensions.height) / 2.0, - p.position.z, + let w = f64::from(p.dimensions.width) / 2.0; + let bounds = Aabb::new( + Vec3::new(p.position.x - w, p.position.y, p.position.z - w), + Vec3::new( + p.position.x + w, + p.position.y + f64::from(p.dimensions.height), + p.position.z + w, + ), ); - let d2 = - (center.x - at.x).powi(2) + (center.y - at.y).powi(2) + (center.z - at.z).powi(2); - if d2 < 16.0 && (center.y - at.y).abs() <= 2.0 + f64::from(p.dimensions.height) { + if let Some(d2) = splash_distance_sqr(at, age, bounds) { let intensity = 1.0 - d2.sqrt() / 4.0; for (id, duration, amp) in effects { let instant = brewing::effect(id).is_some_and(|e| e.instant); @@ -1110,8 +1129,15 @@ impl Game<'_> { } } /// `ThrownSplashPotion.onHitAsPotion`, or `ThrownLingeringPotion.onHitAsPotion` - /// for a lingering potion; `mob` is where it hit a mob. - fn splash(&mut self, stack: &ItemStack, at: Vec3, mob: Option, owner: Option) { + /// for a lingering potion; `mob` is where it hit a mob, `age` its age. + fn splash( + &mut self, + stack: &ItemStack, + at: Vec3, + mob: Option, + age: u32, + owner: Option, + ) { let block = [at.x, at.y, at.z].map(|v| v.floor() as i32); if &*stack.item == "minecraft:experience_bottle" { // ThrownExperienceBottle.onHit: the water-coloured splash (level @@ -1169,15 +1195,14 @@ impl Game<'_> { // message names by the owner, else by the potion. let source = owner.unwrap_or_else(|| Text::translate("entity.minecraft.splash_potion", &[])); - self.for_each_player(|g| g.splash_on_player(def.effects, at, &source)); + self.for_each_player(|g| g.splash_on_player(def.effects, at, age, &source)); // Mobs take the instant effects (undead invert healing and harming). let undead = &self.res.stations().enchantments.entity_tags; let mut hits = Vec::new(); for (i, m) in self.mobs.iter().enumerate() { - let d2 = (m.position.x - at.x).powi(2) - + (m.position.y + m.kind.height / 2.0 - at.y).powi(2) - + (m.position.z - at.z).powi(2); - if m.alive() && d2 < 16.0 { + if m.alive() + && let Some(d2) = splash_distance_sqr(at, age, m.bounds()) + { let inverted = undead .get("minecraft:inverted_healing_and_harm") .is_some_and(|t| t.contains(&m.kind.id)); @@ -1204,20 +1229,39 @@ impl Game<'_> { let m = &mut self.mobs[i]; if harm { m.hurt( - (intensity * f64::from(6 << amp)) as i32 as f32, + (intensity * f64::from(6 << amp) + 0.5) as i32 as f32, Some([at.x, at.y, at.z]), &mut self.world.random, ); } else { - m.health = (m.health + (intensity * f64::from(4 << amp)) as i32 as f32) + m.health = (m.health + (intensity * f64::from(4 << amp) + 0.5) as i32 as f32) .min(m.kind.max_health); } } } } - /// `Hud.extractEffects`: icons top-right, beneficial row then harmful row. + /// `Screen.showsActiveEffects`: the survival and creative inventories + /// draw their own effect list when `EffectsInInventory.canSeeEffects` + /// (32 or more pixels right of the screen). + fn screen_shows_active_effects(&self, batch: &HudBatch) -> bool { + let (ox, image_width) = match self.screen { + Screen::Inventory + if self.container.is_none() && self.craft_size == 2 && !self.mount_active() => + { + (self.inventory_origin(batch).0, 176) + } + Screen::Creative => ( + Self::creative_origin(batch).0, + horizon_client::creative::Creative::WIDTH as i32, + ), + _ => return false, + }; + batch.width as i32 - (ox as i32 + image_width + 2) >= 32 + } + /// `Hud.extractEffects`: icons top-right, beneficial row then harmful row; + /// every screen but the inventories keeps them. pub(super) fn draw_effect_icons(&self, batch: &mut HudBatch) { - if self.screen != Screen::Playing || self.potions.effects.list.is_empty() { + if self.potions.effects.list.is_empty() || self.screen_shows_active_effects(batch) { return; } let icons: Vec = self diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index 8fbcfc6dd..d5f47cc1f 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -23,6 +23,7 @@ use std::collections::{HashMap, HashSet}; #[derive(Default)] pub(super) struct Raiding { patrol: PatrolSpawner, + siege: Siege, /// The raids of the dimension the player is in, and that dimension. raids: Raids, loaded: Option, @@ -38,6 +39,17 @@ pub(super) struct Raiding { homes: HashMap>)>, } +/// `VillageSiege`: whether tonight is a siege, whether the spot is chosen, +/// and the zombies still to spawn there. +#[derive(Default)] +struct Siege { + tonight: bool, + set_up: bool, + zombies_to_spawn: i32, + next_spawn_time: i32, + spot: [i32; 3], +} + impl Raiding { /// Exchange the level-held parts (`ServerLevel.getRaids`) with another /// level's (game/levels.rs). @@ -102,11 +114,12 @@ impl RaidLevel for Lvl<'_, '_> { && g.res.facts().is_air(g.world.block(x, y, z)) } fn player(&self) -> Option { - let p = self.game.player.as_ref()?; + // The first player in the level: a server has no player of its own. + let p = self.game.level_players().into_iter().next()?; Some(RaidPlayer { position: [p.position.x, p.position.y, p.position.z], block: block_of(p.position), - alive: !p.health.dead_or_dying(), + alive: p.alive, }) } } @@ -174,12 +187,13 @@ impl PatrolLevel for PatrolCx<'_, '_, '_> { fn bright_outside(&self) -> bool { self.level.game.dim == Dim::Overworld && self.level.game.sky_darken() < 4 } + /// `PatrolSpawner.tick` picks from `level.players()`: the local player + /// and every guest in the level. fn patrol_players(&self) -> Vec<([i32; 3], bool)> { - let g = self.level.game; - g.player - .as_ref() - .map(|p| (block_of(p.position), g.spectator())) - .into_iter() + self.level + .players + .iter() + .map(|p| (block_of(p.position), p.spectator)) .collect() } fn sections_to_village(&self, pos: [i32; 3]) -> i32 { @@ -633,7 +647,7 @@ impl Game<'_> { /// `Raid.playSound`: the horn, 13 blocks away from the player toward the /// wave, for players within 64 blocks or in the raid. fn raid_horn(&mut self, id: i32, pos: [i32; 3]) { - let Some(p) = self.player.as_ref().map(|p| p.position) else { + let Some(p) = self.level_players().first().map(|p| p.position) else { return; }; let in_raid = self.raiding.raids.get(id).is_some_and(|r| r.bar.player); @@ -791,7 +805,7 @@ impl Game<'_> { let has_rider = ridden.contains(&m.id); let target_golem = matches!(m.ai.target, Some(horizon_client::mobs::Who::Mob(t)) if golems.contains(&t)); let target_player = m.ai.target == Some(horizon_client::mobs::Who::Player); - let (health, age, range) = (m.health, m.age, m.attrs.follow_range); + let (health, range) = (m.health, m.attrs.follow_range); let raids = &mut self.raiding.raids; let s = m.extra.raider.get_or_insert_with(Box::default); s.rider = has_rider; @@ -821,14 +835,11 @@ impl Game<'_> { if !alive { continue; } - // Raider.updateNoActionTime adds two per tick, and a raider - // fighting a player or golem in a raid is never idle. - if s.raid_id.is_some() { - m.ai.no_action_time = if target_player || target_golem { - 0 - } else { - m.ai.no_action_time + 1 - }; + // Raider.aiStep: a raider fighting a player or golem in a raid is + // never idle. The per-tick growth (+1 serverAiStep, +2 + // Raider.updateNoActionTime) is added by the mob's own step. + if s.raid_id.is_some() && (target_player || target_golem) { + m.ai.no_action_time = 0; } // Raider.aiStep: join the raid the raider stands in. if s.raid_id.is_none() @@ -839,11 +850,9 @@ impl Game<'_> { { joins.push((m.id, id, health)); } - // PathfindToRaidGoal.recruitNearby. - if s.active_raid - && !s.raid_over - && !s.in_village - && age % 20 == 0 + // PathfindToRaidGoal.tick: recruitNearby, only while the goal runs. + if std::mem::take(&mut s.recruit_due) + && s.active_raid && let Some(id) = s.raid_id { recruit.push((id, position)); @@ -1221,6 +1230,140 @@ impl Game<'_> { self.spawn_event_mob("minecraft:pillager", at, m.leader, raider::Reason::Patrol); } } + /// `VillageSiege.tick`: at midnight one night in ten, 20 zombies spawn + /// two ticks apart near a village 32 blocks from a player standing in it. + pub(super) fn tick_village_siege(&mut self) { + if self.dim != Dim::Overworld { + return; + } + let enemies = self.ui.rules.bool("spawn_mobs") && self.ui.rules.bool("spawn_monsters"); + if self.sky_darken() < 4 || !enemies { + self.raiding.siege.tonight = false; + self.raiding.siege.set_up = false; + return; + } + // ClockTimeMarkers.ROLL_VILLAGE_SIEGE: tick 18000 of the 24000 tick day. + if self.world.day_time.rem_euclid(24000) == 18000 { + self.raiding.siege.tonight = self.world.random.next_int_bound(10).unwrap_or(1) == 0; + } + if !self.raiding.siege.tonight { + return; + } + if !self.raiding.siege.set_up { + if !self.try_to_setup_siege() { + return; + } + self.raiding.siege.set_up = true; + } + if self.raiding.siege.next_spawn_time > 0 { + self.raiding.siege.next_spawn_time -= 1; + return; + } + self.raiding.siege.next_spawn_time = 2; + if self.raiding.siege.zombies_to_spawn > 0 { + self.try_spawn_siege_zombie(); + self.raiding.siege.zombies_to_spawn -= 1; + } else { + self.raiding.siege.tonight = false; + } + } + /// `ServerLevel.isVillage`: within one section of a village. + fn is_village(centers: &HashSet<(i32, i32, i32)>, pos: [i32; 3]) -> bool { + sections_to_village(centers, section(pos)) <= 1 + } + /// `VillageSiege.tryToSetupSiege`: the first player standing in a village + /// picks a spot 32 blocks away (ten tries); true when one stood in a + /// village, even if no spot was found. + fn try_to_setup_siege(&mut self) -> bool { + let centers = self.village_centers(); + for player in self.level_players() { + if player.spectator { + continue; + } + let center = block_of(player.position); + if !Self::is_village(¢ers, center) + || self.natural_level().biome_tag( + "minecraft:without_zombie_sieges", + center[0], + center[1], + center[2], + ) + { + continue; + } + for _ in 0..10 { + let angle = self.world.random.next_float() * std::f32::consts::TAU; + let spot = [ + center[0] + (angle.cos() * 32.0).floor() as i32, + center[1], + center[2] + (angle.sin() * 32.0).floor() as i32, + ]; + if self.find_siege_spawn_pos(¢ers, spot).is_some() { + self.raiding.siege.spot = spot; + self.raiding.siege.next_spawn_time = 0; + self.raiding.siege.zombies_to_spawn = 20; + break; + } + } + return true; + } + false + } + /// `VillageSiege.trySpawn`: one zombie, in a random yaw. + fn try_spawn_siege_zombie(&mut self) { + let centers = self.village_centers(); + let spot = self.raiding.siege.spot; + let Some(at) = self.find_siege_spawn_pos(¢ers, spot) else { + return; + }; + let Some(id) = self.spawn_event_mob("minecraft:zombie", at, false, raider::Reason::Event) + else { + return; + }; + let yaw = self.world.random.next_float() * 360.0; + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + (m.yaw, m.previous_yaw, m.body_yaw, m.previous_body_yaw) = (yaw, yaw, yaw, yaw); + (m.head_yaw, m.previous_head_yaw) = (yaw, yaw); + } + self.spawn_jockeys(id, false); + } + /// `VillageSiege.findRandomSpawnPos`: ten tries within 8 blocks of the + /// spot for a village column where a zombie may spawn. + fn find_siege_spawn_pos( + &mut self, + centers: &HashSet<(i32, i32, i32)>, + spot: [i32; 3], + ) -> Option<[f64; 3]> { + let mut random = std::mem::replace( + &mut self.world.random, + horizon_core::random::LegacyRandom::new(0), + ); + let mut found = None; + for _ in 0..10 { + let x = spot[0] + random.next_int_bound(16).unwrap_or(0) - 8; + let z = spot[2] + random.next_int_bound(16).unwrap_or(0) - 8; + if !self.world.chunks.contains_key(&(x >> 4, z >> 4)) { + continue; + } + let y = self.surface_height(x, z); + if Self::is_village(centers, [x, y, z]) + && spawn_rules::check_spawn_rules( + Species::Zombie, + &self.natural_level(), + spawn_rules::Reason::Event, + &mut random, + x, + y, + z, + ) + { + found = Some([f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5]); + break; + } + } + self.world.random = random; + found + } /// A raider's ominous banner (drop chance 2.0: always dropped) and a /// patrol captain's ominous bottle (`entities/pillager`). /// `OminousBottleAmplifier.onConsume`: Bad Omen for 100 minutes at the diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 55c678307..b69798e88 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -119,7 +119,7 @@ pub(super) struct Remote { pub(super) entity_id: i32, /// The item the player's use began with (`LivingEntity.useItem`). pub(super) use_item: Option>, - dimension: DimensionType, + pub(super) dimension: DimensionType, /// What chunk packets decode with (the dimension's height and sky, the /// biome registry); replaced whenever one of them changes. pub(super) chunk_format: Arc, @@ -160,6 +160,9 @@ pub(super) struct Remote { stepped: HashMap, /// `LivingEntity.lerpHeadTo`: the head yaw and the ticks left to reach it. head_lerps: HashMap, + /// The happy ghast the player just got off, until the server's teleport + /// puts the player on top of it (`place_ghast_under`). + pub(super) ghast_dismount: Option, /// Item entities waiting for their item data: where they are and their /// motion. pending_items: HashMap, @@ -194,6 +197,8 @@ pub(super) struct Remote { /// The local player's profile name: its score holder and team member. pub(super) profile_name: String, destroying: Option<([i32; 3], u8, f32)>, + /// `MultiPlayerGameMode.destroyingItem`: the held item key the break began with. + destroying_item: String, destroy_delay: u32, input: horizon_client::interaction_input::InteractionInput, /// Keys whose presses send a packet (swap hands, drop, a mount's @@ -202,7 +207,9 @@ pub(super) struct Remote { pub(super) pending_keys: Vec, stop_mining: bool, placing: Option<([i32; 3], u64)>, - death_message: Option, + /// `CommonPlayerSpawnInfo.isFlat`: the level is a superflat one. + pub(super) flat: bool, + death_message: Option, /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`. show_death_screen: bool, player_type: Option>, @@ -474,6 +481,7 @@ impl Game<'_> { lerps: HashMap::new(), stepped: HashMap::new(), head_lerps: HashMap::new(), + ghast_dismount: None, pending_items: HashMap::new(), health: (20.0, 20, 5.0), flash_on_set_health: false, @@ -492,11 +500,13 @@ impl Game<'_> { profile: 0, profile_name: String::new(), destroying: None, + destroying_item: String::new(), destroy_delay: 0, input: Default::default(), pending_keys: Vec::new(), stop_mining: false, placing: None, + flat: false, death_message: None, show_death_screen: true, player_type, @@ -690,10 +700,14 @@ impl Game<'_> { } let text = content.plain(); log::info!("[chat] {text}"); + // addServerSystemMessage and addClientSystemMessage both carry + // GuiMessageTag.systemSinglePlayer: the grey bar at the line's left. + let indicator = (source != horizon_client::chat::ChatSource::Player) + .then_some(horizon_client::chat::SYSTEM_INDICATOR); self.ui.chat.add( &self.gui.atlas, content, - None, + indicator, source, self.ticks, self.screen == Screen::Chat, @@ -1018,12 +1032,19 @@ impl Game<'_> { r.chunk_format = Arc::new(r.chunk_format.with_dimension(&dimension)); r.dimension = dimension; r.game_mode = spawn.game_type; + r.flat = spawn.flat; r.loaded_sent = false; // A replacement LocalPlayer has a fresh sendPosition baseline. r.position_sender = Default::default(); r.predictions.clear(); self.set_mode_id(spawn.game_type); self.dim = Dim::from_id(&spawn.dimension); + // ClientPacketListener.handleLogin / handleRespawn: the server's + // Player.getLastDeathLocation, for the recovery compass. + self.level.last_death = spawn + .last_death + .as_ref() + .map(|d| (d.dimension.clone(), d.pos)); if !same { let mut streaming = Streaming::new( Arc::new(NoTerrain), @@ -1437,6 +1458,17 @@ impl Game<'_> { { return; } + // A thrown trident is an arrow: placed at once, flown on by its tick. + if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id as u32) { + if path.is_some() { + t.position = Vec3::new(position[0], position[1], position[2]); + } + if let Some((yaw, pitch)) = rotation { + t.yaw = yaw; + t.pitch = pitch; + } + return; + } // So does a firework rocket: its own tick flies it on. if path.is_some() && let Some(f) = self.rockets.iter_mut().find(|f| f.id == id as u32) @@ -1647,6 +1679,41 @@ impl Game<'_> { } } + /// `ClientPacketListener.handleUpdateAttributes` for a mob: its maximum + /// health (the hearts drawn over its mount) takes the server's value, from + /// `AttributeInstance.calculateValue`. + fn remote_mob_attributes(&mut self, id: i32, values: &[play::AttributeSnapshot]) { + let catalog = &self.motion.attributes; + let Some(max_health) = catalog.id("minecraft:max_health") else { + return; + }; + let Some(s) = values + .iter() + .find(|s| s.attribute == max_health.registry_id()) + else { + return; + }; + let amounts = |op: i32| { + s.modifiers + .iter() + .filter(move |m| m.operation == op) + .map(|m| m.amount) + }; + let base = s.base + amounts(0).sum::(); + let mut value = base + amounts(1).map(|a| base * a).sum::(); + for amount in amounts(2) { + value *= 1.0 + amount; + } + let value = catalog.attribute(max_health).definition.sanitize(value); + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) { + horizon_client::mobs::finalize::set_base( + m, + horizon_client::mobs::finalize::Attr::MaxHealth, + value, + ); + } + } + fn handle_packet(&mut self, packet: C) -> Result<()> { match packet { // ClientCommonPacketListenerImpl.handlePing runs on the game @@ -2119,7 +2186,23 @@ impl Game<'_> { ) }) .collect(); + // CrossbowItem.isCharged: the main hand's `charged_projectiles` + // (AvatarRenderer.getArmPose holds a loaded crossbow up). + let charged = p.slots.iter().find(|(slot, _)| *slot == 0).map(|(_, s)| { + s.as_ref().is_some_and(|s| { + matches!( + s.component(horizon_protocol::item::component::CHARGED_PROJECTILES), + Some(horizon_protocol::item::Component::Stacks(list)) + if !list.is_empty() + ) + }) + }); if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + if let Some(charged) = charged + && &*m.kind.id == "minecraft:player" + { + m.extra.charged = charged; + } // The body slot (6: horse armour, llama carpet, harness) // is kept in `head`, as Horizon's own mobs do. let body = horizon_client::mobs::drops::head_is_body(m.species()); @@ -2132,7 +2215,11 @@ impl Game<'_> { 3 => e.legs = item, 4 => e.chest = item, 5 if !body => e.head = item, - 6 if body => e.head = item, + 6 if body => { + // A wolf's armor shows its cracks. + e.body_damage = stack.as_ref().map_or(0, |s| s.damage as i32); + e.head = item; + } 7 => m.set_saddle(stack), _ => {} } @@ -2219,6 +2306,10 @@ impl Game<'_> { self.remote_firework_explosion(p.id); } self.remote_fangs_event(p.id as u32, p.event); + // LivingEntity.handleEntityEvent 2: a spear's hit felt. + if p.event == 2 { + self.remote_kinetic_hit(p.id); + } // LocalPlayer.setPermissions also refreshes an open World Options screen. if (24..=28).contains(&p.event) && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) @@ -2226,6 +2317,10 @@ impl Game<'_> { self.ui.registries.permission = (p.event - 24) as u8; self.remote_world_options_permission(p.event >= 26); } + // Ravager.handleEntityEvent 69: the roar's puff and push. + if p.event == 69 { + self.remote_ravager_roar(p.id); + } if p.event == 1 && let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) && m.species() == horizon_client::mobs::Species::Rabbit @@ -2338,6 +2433,7 @@ impl Game<'_> { } self.apply_remote_health(); } + C::UpdateAttributes(p) => self.remote_mob_attributes(p.id, &p.values), C::UpdateMobEffect(p) => self.remote_effect(&p), C::RemoveMobEffect(p) => { if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) @@ -2369,6 +2465,7 @@ impl Game<'_> { { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } } @@ -2376,7 +2473,7 @@ impl Game<'_> { // The component resolves in the client's current language, as // the chat line does, not in the language the session joined // with (`Remote.lang` is the vanilla server-language table). - let message = remote_text(&p.message).plain(); + let message = remote_text(&p.message); let me = self.remote.as_ref().is_some_and(|r| r.entity_id == p.id); if let Some(r) = self.remote.as_mut() { r.death_message = Some(message); @@ -2388,6 +2485,7 @@ impl Game<'_> { if self.remote.as_ref().is_none_or(|r| r.show_death_screen) { self.screen = Screen::Dead; self.ui.death_time = 0; + self.ui.death_confirm = None; self.capture(false); } else { self.respawn_player()?; @@ -2513,6 +2611,20 @@ impl Game<'_> { r.state_id = p.state; } let stack = self.to_stack(&p.item); + // ClientPacketListener.handleContainerSetSlot: a hotbar slot that + // gains items squeezes for 5 ticks. + if p.container == 0 + && (36..=45).contains(&p.slot) + && let Some(new) = &stack + { + let (pop, old) = match p.slot { + 45 => (9, self.offhand.as_ref()), + s => (s as usize - 36, self.inventory[s as usize - 36].as_ref()), + }; + if old.is_none_or(|old| old.count < new.count) { + self.hotbar_pop[pop] = 5; + } + } self.set_menu_slot(p.container, i32::from(p.slot), stack); self.remote_synced(); } @@ -3201,6 +3313,7 @@ impl Game<'_> { health: 5, fire_ticks: 0, thrower: None, + target: None, id: id as u32, stack, position: at, @@ -3237,6 +3350,8 @@ impl Game<'_> { p.velocity = v; } else if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) { b.velocity = v; + } else if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id as u32) { + t.velocity = v; } else if let Some(r) = self.rockets.iter_mut().find(|r| r.id == id as u32) { r.velocity = v; } else if let Some(p) = self @@ -3261,6 +3376,37 @@ impl Game<'_> { p.health.food.saturation = saturation; } } + /// `ServerPlayer.dismountTo` lands a rider at the ghast's own (x, maxY, z) + /// (`HappyGhast.getDismountLocationForPassenger`). A vanilla client + /// simulates the ghast it rides, so its copy is where the server has it; + /// this window's copy trails the server's by the stepped interpolation and + /// would rise into the rider's feet, which lets the rider fall through. + /// Put the copy under the landing spot. + fn place_ghast_under(&mut self, id: u32, spot: Vec3) { + let Some(m) = self + .mobs + .iter_mut() + .find(|m| m.id == id && m.species() == horizon_client::mobs::Species::HappyGhast) + else { + return; + }; + let at = Vec3::new(spot.x, spot.y - f64::from(m.height()), spot.z); + // Only a teleport that is that dismount: right above the ghast. + if (at.x - m.position.x).powi(2) + (at.z - m.position.z).powi(2) > 25.0 + || (at.y - m.position.y).abs() > 5.0 + { + return; + } + m.position = at; + m.previous = at; + if let Some(handler) = self + .remote + .as_mut() + .and_then(|r| r.stepped.get_mut(&(id as i32))) + { + handler.cancel(); + } + } /// ClientPacketListener.handleMovePlayer. fn remote_teleport(&mut self, p: &play::PlayerPosition) -> Result<()> { use play::relative as rel; @@ -3320,6 +3466,9 @@ impl Game<'_> { self.previous_position = position; self.yaw = yaw; self.pitch = pitch; + if let Some(id) = self.remote.as_mut().and_then(|r| r.ghast_dismount.take()) { + self.place_ghast_under(id, position); + } if let Some(r) = self.remote.as_mut() { // handleMovePlayer does not change LocalPlayer.sendPosition's // baseline: the next tick must still report the corrected state. @@ -3405,10 +3554,15 @@ impl Game<'_> { // a client. Ticking it after the keybinds keeps a held use from // trying again a tick before the server's entry ends. self.cooldowns.tick(); + // Inventory.tick's ItemStack.inventoryTick: the pop time runs down. + for pop in &mut self.hotbar_pop { + *pop = pop.saturating_sub(1); + } // ClientLevel.tick: the border's size change. self.border.tick(); self.player_border(); self.tick_remote_entities(running); + self.tick_remote_guardian_eyes(running); // ClientLevel.tickBlockEntities: chest lids, shulker boxes, bells, // and the moving pistons a block event's client-side moveBlocks made // (their progress advances between the server's block updates). @@ -3546,12 +3700,10 @@ impl Game<'_> { let feet = [player.position.x, player.position.y, player.position.z]; for event in events { match event { - horizon_client::motion::MotionEvent::Emission { - state, in_water, .. - } => { + horizon_client::motion::MotionEvent::Emission { state, muffled, .. } => { let sounds = self.res.facts().get(state).sounds.clone(); // Player.playStepSound: muffled under the swim sound in water. - let (volume, pitch) = if in_water { + let (volume, pitch) = if muffled { (sounds.volume * 0.05, sounds.pitch * 0.8) } else { (sounds.volume * 0.15, sounds.pitch) @@ -3712,6 +3864,43 @@ impl Game<'_> { } /// ClientLevel.tickEntities; a frozen level only ticks the players /// (`TickRateManager.isEntityFrozen`). + /// `GuardianRenderer.getEntityToLookAt`: a guardian's eye follows its + /// synched attack target, else the camera. + fn tick_remote_guardian_eyes(&mut self, running: bool) { + use horizon_client::mobs::{Species, Who, guardian}; + if !running { + return; + } + let camera = self.player.as_ref().map(|p| { + [ + p.position.x, + p.position.y + f64::from(p.dimensions.eye_height), + p.position.z, + ] + }); + let looks: Vec<_> = self + .mobs + .iter() + .enumerate() + .filter(|(_, m)| { + matches!(m.species(), Species::Guardian | Species::ElderGuardian) && m.alive() + }) + .filter_map(|(i, m)| { + let look = match m.ai.target.filter(|_| m.extra.flag) { + Some(Who::Mob(id)) => self + .mobs + .iter() + .find(|t| t.id == id) + .map(|t| [t.position.x, t.eye_y(), t.position.z]), + _ => camera, + }; + look.map(|look| (i, look)) + }) + .collect(); + for (i, look) in looks { + guardian::look_at(&mut self.mobs[i], look); + } + } fn tick_remote_entities(&mut self, running: bool) { if running { self.tick_text_displays(); @@ -3720,16 +3909,18 @@ impl Game<'_> { // server never sends the fluid contact, and the renderers read it (cod, salmon and // tropical fish lie on their side without `in_water`, #1591). // A frozen level ticks only the players, as below. - let fluids: Vec<_> = { + let (fluids, thundering): (Vec<_>, bool) = { let w = self.mob_world_base(&[]); let players = self.remote.as_ref().map(|r| &r.level_players); - self.mobs + let fluids = self + .mobs .iter() .map(|m| { (running || players.is_some_and(|p| p.contains_key(&(m.id as i32)))) .then(|| w.fluids(m.bounds(), m.eye_y())) }) - .collect() + .collect(); + (fluids, w.thundering) }; for (m, fluids) in self.mobs.iter_mut().zip(fluids) { if let Some(fluids) = fluids { @@ -3745,15 +3936,12 @@ impl Game<'_> { let head_lerps = &mut r.head_lerps; let players = &r.level_players; let mut using = Vec::new(); - let mut wither_heads = Vec::new(); + let mut mob_fx = Vec::new(); for m in &mut self.mobs { let player = players.contains_key(&(m.id as i32)); if !running && !player { continue; } - if m.species() == horizon_client::mobs::Species::Wither { - wither_heads.extend((0..3).map(|i| horizon_client::mobs::wither::head_pos(m, i))); - } m.previous = m.position; m.previous_yaw = m.yaw; m.previous_body_yaw = m.body_yaw; @@ -3788,6 +3976,17 @@ impl Game<'_> { if m.species() == horizon_client::mobs::Species::PolarBear { horizon_client::mobs::polar_bear::client_tick(m); } + // The particles these mobs' own ticks draw on the client side. + { + use horizon_client::mobs::{Species as S, cube, illusioner, nautilus, wither}; + match m.species() { + S::Slime | S::MagmaCube | S::SulfurCube => cube::client_tick(m, &mut mob_fx), + S::Nautilus | S::ZombieNautilus => nautilus::client_tick(m, &mut mob_fx), + S::Illusioner => illusioner::client_tick(m, &mut mob_fx), + S::Wither => wither::client_smoke(m, &mut mob_fx), + _ => {} + } + } if m.hurt_time > 0 { m.hurt_time -= 1; } @@ -3811,6 +4010,10 @@ impl Game<'_> { m.head_yaw += wrap_degrees(*yaw - m.head_yaw) / *steps as f32; *steps -= 1; } + // Fox.tick: the head tilt and crouch follow the synched flags. + if m.species() == horizon_client::mobs::Species::Fox { + horizon_client::mobs::fox::client_tick(m); + } // Chicken.aiStep: the wings follow the server's on-ground flag. if m.species() == horizon_client::mobs::Species::Chicken { horizon_client::mobs::farm::chicken_flap(m); @@ -3844,6 +4047,8 @@ impl Game<'_> { // a player's body following its walk and look. if player { remote_player_head_turn(m); + // LivingEntity.tick: the glide count, wings and swim amount. + m.tick_avatar_pose(m.fluids.in_water); } else if m.alive() { m.body_rotation_tick(); } @@ -3862,6 +4067,9 @@ impl Game<'_> { } // The animation states a server computes in its own `ai_step`. horizon_client::mobs::sync::client_tick(m, game_time); + if m.species() == horizon_client::mobs::Species::Panda { + horizon_client::mobs::panda::client_tick(m, thundering); + } } for o in self.orbs.iter_mut().filter(|_| running) { o.previous = o.position; @@ -3886,19 +4094,7 @@ impl Game<'_> { d.tick(world, facts, collision, false, &self.res.motion().fluids); } head_lerps.retain(|_, (_, steps)| *steps > 0); - // WitherBoss.aiStep runs on a client too: smoke around each head. - let smoke = horizon_client::particles::ParticleOptions::simple( - horizon_client::particles::ParticleType::Smoke, - ); - for h in wither_heads { - let r = self.particles.random(); - let at = [ - h[0] + r.next_gaussian() * 0.3, - h[1] + r.next_gaussian() * 0.3, - h[2] + r.next_gaussian() * 0.3, - ]; - self.particles.add(&smoke, at, [0.0; 3]); - } + let _ = self.handle_mob_events(mob_fx); for (item, ticks, at, eye, pitch, yaw) in using { self.remote_player_eating(&item, ticks, at, eye, pitch, yaw); } @@ -4065,6 +4261,8 @@ impl Game<'_> { } } + /// `MultiPlayerGameMode.stopDestroyBlock`: aborts the break and starts + /// the attack strength again. pub(super) fn stop_remote_mining(&mut self) { if let Some((pos, _, _)) = self.remote.as_mut().and_then(|r| r.destroying.take()) { self.send(S::PlayerAction(play::PlayerAction { @@ -4073,6 +4271,7 @@ impl Game<'_> { direction: 0, sequence: 0, })); + self.reset_attack_strength(); } } @@ -4126,11 +4325,11 @@ impl Game<'_> { } else { self.destroy_progress(hit.pos) }; - let same = self - .remote - .as_ref() - .and_then(|r| r.destroying) - .is_some_and(|(p, _, _)| p == hit.pos); + // sameDestroyTarget: the same block and still the item the break began with. + let held = self.main_hand_key(); + let same = self.remote.as_ref().is_some_and(|r| { + r.destroying.is_some_and(|(p, _, _)| p == hit.pos) && r.destroying_item == held + }); if start && same { return; } @@ -4157,6 +4356,7 @@ impl Game<'_> { } if let Some(r) = self.remote.as_mut() { r.destroying = Some((hit.pos, face, 0.0)); + r.destroying_item = held; } // startDestroyBlock plays the first hit and crack itself; the // server's level events 2019 and 2020 do the rest. @@ -4346,6 +4546,15 @@ impl Game<'_> { // click ends, so a shield in the other hand is not raised. self.with_hand(hand, Game::swing_arm); return true; + } else if held.as_ref().is_some_and(|s| &*s.item == "minecraft:brush") { + // BrushItem.useOn: brushing starts here (CONSUME, no swing); the + // server brushes and the dust is this client's own. + self.with_hand(hand, |g| { + if g.using.is_none() { + g.using = Some((g.held_slot(), 0)); + } + }); + return true; } else if let Some(stack) = held.as_ref() && self.predict_item_on_block(stack, &hit) { @@ -4641,6 +4850,8 @@ impl Game<'_> { } // SpyglassItem.use (its sound is the server's). "minecraft:spyglass" => true, + // Item.use: a kinetic weapon starts being used. + id if horizon_client::spear::Kinetic::of(id).is_some() => true, // ShieldItem.use: anything that blocks attacks, off cooldown. _ => { self.raise_shield(self.held_slot()); @@ -4657,7 +4868,8 @@ impl Game<'_> { matches!( &*stack.item, "minecraft:bow" | "minecraft:crossbow" | "minecraft:trident" | "minecraft:spyglass" - ) || self.blocks_attacks(stack).is_some() + ) || horizon_client::spear::Kinetic::of(&stack.item).is_some() + || self.blocks_attacks(stack).is_some() } /// The rest of Minecraft.startUseItem once the main hand's target passed: @@ -4701,6 +4913,30 @@ impl Game<'_> { // Another hotbar slot picked: LivingEntity.updatingUsingItem sees a // different stack in the hand. The off hand keeps its item. let in_hand = slot == self.selected || slot == super::shield::OFFHAND_SLOT; + // BrushItem.onUseTick: with no block aimed the use ends (the server + // ends it too); a stroke shows its dust. Its sounds are the server's. + if stack + .as_ref() + .is_some_and(|s| &*s.item == "minecraft:brush") + { + let elapsed = ticks + 1; + let hit = self.pick().filter(|_| in_hand); + if let Some(hit) = &hit + && elapsed % 10 == 5 + { + self.brush_dust(hit, slot == super::shield::OFFHAND_SLOT); + } + if hit.is_none() && in_hand { + self.send(S::PlayerAction(play::PlayerAction { + action: 6, + pos: [0; 3], + direction: 0, + sequence: 0, + })); + } + self.using = hit.and(Some((slot, elapsed))).filter(|_| elapsed < 200); + return; + } // A drawn bow, a charging crossbow, a raised shield...: held until // the button lets go. if stack.as_ref().is_some_and(|s| self.held_until_released(s)) { @@ -4842,7 +5078,9 @@ impl Game<'_> { match key { KeyCode::KeyF if !self.spectator() => self.remote_swap_hands(), KeyCode::KeyQ if !self.spectator() => { - let all = self.keys.contains(&KeyCode::ControlLeft); + // Minecraft.hasControlDown: the physical keys, so a toggled + // sprint on Left Control does not make Q drop the stack. + let all = self.has_control_down(); self.remote_drop(all); } KeyCode::KeyE if self.riding_mount_with_menu() => { @@ -5537,8 +5775,16 @@ impl Game<'_> { if self.screen == Screen::Dead && let Some(message) = &r.death_message { - let tw = HudBatch::text_width(atlas, message); - batch.text(atlas, message, (w - tw) / 2.0, 85.0, u32::MAX, true); + // DeathScreen draws the styled cause component. + let tw = atlas.font.width_text(message); + batch.text_styled( + atlas, + message, + ((w - tw) / 2.0).floor(), + 85.0, + u32::MAX, + true, + ); } } /// Shared flag 6 of an entity on a server's client (`None` without a server). @@ -5833,7 +6079,8 @@ fn hand_id(hand: Hand) -> i32 { /// server decides; this is the client's guess of whether to go on. fn item_has_use(info: &horizon_client::items::ItemInfo) -> bool { let id = info.id.trim_start_matches("minecraft:"); - info.consumable.is_some() + id.ends_with("_spear") + || info.consumable.is_some() || info.equip_slot.is_some() || info.blocks_attacks.is_some() || horizon_client::items::bucket_contents(&info.id).is_some() @@ -5903,7 +6150,18 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ direction: 0, sequence: 0, })); - self.0.using = None; + // MultiPlayerGameMode.releaseUsingItem also runs `Item.releaseUsing` here: the + // player moves by itself, so a Riptide launch happens on the client. + let hand = self.0.used_hand(); + if let Some((slot, ticks)) = self.0.using.take() + && let Some(hand) = hand + && self + .0 + .stack_in(slot) + .is_some_and(|s| &*s.item == "minecraft:trident") + { + self.0.with_hand(hand, |g| g.release_trident(ticks)); + } } fn start_attack(&mut self) -> bool { self.0.remote_start_attack() @@ -5912,7 +6170,16 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ self.0.remote_use(); } fn pick(&mut self) { - if let Some(hit) = self.0.pick() { + // Minecraft.pickBlockOrEntity: an entity before the block is asked + // for (`handlePickItemFromEntity`), else the block. + if let Some(entity) = self.0.pick_entity_hit() { + if let Some(id) = entity { + self.0.send(S::PickItemFromEntity(play::PickItemFromEntity { + id, + include_data: self.0.has_control_down(), + })); + } + } else if let Some(hit) = self.0.pick() { self.0.send(S::PickItemFromBlock(play::PickItemFromBlock { pos: hit.pos, include_data: self.0.has_control_down(), diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs index f85a96119..a4080ac16 100644 --- a/crates/horizon-client/src/game/remote_mob_data.rs +++ b/crates/horizon-client/src/game/remote_mob_data.rs @@ -4,10 +4,12 @@ //! own simulation, which a client of a server doesn't run. use super::Game; use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES}; -use horizon_client::mobs::{Mob, Species, Who, bat, camel, sniffer, sync, tame}; +use horizon_client::mobs::{ + Mob, Species, Who, armadillo, bat, bee, camel, creaking, finalize, panda, sniffer, sync, tame, +}; use horizon_client::particles::{ParticleOptions, ParticleType}; use horizon_protocol::entity_data::{Particle, ParticleData, Value}; -use horizon_protocol::registry::Builtin; +use horizon_protocol::registry::{Builtin, Dynamic}; /// The values `apply` takes from one SetEntityData packet, by vanilla's entry /// indices (Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses). @@ -15,6 +17,9 @@ use horizon_protocol::registry::Builtin; fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_entity: i32) { let species = m.species(); let baby = super::lan::baby_index(&m.kind.id); + if &*m.kind.id == "minecraft:player" { + player_poses(m, values); + } for (index, _, value) in values { match (*index, value) { // Entity.DATA_POSE: a player's or mannequin's box follows it. @@ -72,10 +77,23 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti Who::Mob(*target as u32) }); } + // Panda: the counters, the two genes and DATA_ID_FLAGS (after + // AgeableMob's two entries). + (Species::Panda, 18, Value::Int(n)) => panda::set_unhappy(m, *n), + (Species::Panda, 19, Value::Int(n)) => panda::set_sneeze(m, *n), + (Species::Panda, 20, Value::Int(n)) => panda::set_eat(m, *n), + (Species::Panda, 21, Value::Byte(gene)) => m.extra.variant = (*gene).clamp(0, 6) as u8, + (Species::Panda, 22, Value::Byte(gene)) => m.extra.variant2 = (*gene).clamp(0, 6) as u8, + (Species::Panda, 23, Value::Byte(flags)) => panda::set_flags(m, *flags as u8), // PolarBear.DATA_STANDING_ID: the client animates the rearing. (Species::PolarBear, 18, Value::Bool(standing)) => m.extra.flag = *standing, // Bat.DATA_ID_FLAGS: resting in bit 0. (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0), + // Fox.DATA_TYPE_ID and DATA_FLAGS_ID. + (Species::Fox, 18, Value::Int(variant)) => { + m.extra.variant = (*variant).clamp(0, 1) as u8 + } + (Species::Fox, 19, Value::Byte(flags)) => m.extra.ints[0] = i32::from(*flags as u8), // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared. (Species::Sheep, 18, Value::Byte(wool)) => { m.extra.color = (*wool & 15) as u8; @@ -102,6 +120,9 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti (Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => { m.extra.size = (*size).clamp(1, 127); } + // Enderman.DATA_CREEPY (after DATA_CARRY_STATE): the open mouth + // and raised head of an angry enderman. + (Species::Enderman, 17, Value::Bool(creepy)) => m.extra.flag = *creepy, // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace. (Species::Warden, 16, Value::Int(anger)) => { if let Some(st) = m.extra.warden.as_mut() { @@ -113,6 +134,15 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti (Species::Sniffer, 18, Value::Id(state)) => { sniffer::set_state(m, (*state).clamp(0, 6) as u8); } + // Armadillo.ARMADILLO_STATE (after AgeableMob's two): the shell and + // its animations follow it in `sync::client_tick`. + (Species::Armadillo, 18, Value::Id(state)) => { + armadillo::set_state(m, (*state).clamp(0, 3) as u8); + } + // Goat.DATA_HAS_LEFT_HORN and DATA_HAS_RIGHT_HORN: the model hides + // a horn the goat lost. + (Species::Goat, 19, Value::Bool(has)) => m.extra.lost_horns[0] = !*has, + (Species::Goat, 20, Value::Bool(has)) => m.extra.lost_horns[1] = !*has, // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID. (Species::Shulker, 16, Value::Id(face)) => m.extra.variant3 = (*face).clamp(0, 5) as u8, (Species::Shulker, 17, Value::Byte(peek)) => m.extra.counter = i32::from(*peek), @@ -125,9 +155,73 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti (Species::Camel | Species::CamelHusk, 20, Value::Long(tick)) => { camel::set_synced_pose_tick(m, *tick); } + // Vex.DATA_FLAGS_ID: charging in bit 0. + (Species::Vex, 16, Value::Byte(flags)) => m.extra.flag = flags & 1 != 0, + // Creaking.CAN_MOVE, IS_ACTIVE and IS_TEARING_DOWN. + (Species::Creaking, 16, Value::Bool(can_move)) => m.extra.flag2 = !*can_move, + (Species::Creaking, 17, Value::Bool(active)) => m.extra.flag = *active, + (Species::Creaking, 18, Value::Bool(true)) => creaking::set_tearing_down(m), + // Allay.DATA_DANCING and DATA_CAN_DUPLICATE (a cooldown running + // is any non-zero `egg_time`). + (Species::Allay, 16, Value::Bool(dancing)) => m.extra.flag = *dancing, + (Species::Allay, 17, Value::Bool(can)) => m.extra.egg_time = i32::from(!*can), + // Axolotl.DATA_PLAYING_DEAD (after DATA_VARIANT): the factors + // ease in `sync::client_tick`. + (Species::Axolotl, 19, Value::Bool(dead)) => m.extra.axolotl.playing_dead = *dead, + // CopperGolem.COPPER_GOLEM_STATE (after DATA_WEATHER_STATE). + (Species::CopperGolem, 17, Value::Id(state)) => { + m.extra.variant3 = (*state).clamp(0, 4) as u8; + } + // AbstractHorse's flags take 18. Horse.DATA_ID_TYPE_VARIANT: the + // colour in the low byte, the markings in the next. + (Species::Horse, 19, Value::Int(v)) => { + m.extra.variant = (v & 0xFF).clamp(0, 6) as u8; + m.extra.variant2 = ((v >> 8) & 0xFF).clamp(0, 4) as u8; + } + // AbstractChestedHorse.DATA_ID_CHEST, then Llama.DATA_STRENGTH_ID + // and DATA_VARIANT_ID. + ( + Species::Donkey | Species::Mule | Species::Llama | Species::TraderLlama, + 19, + Value::Bool(chested), + ) => m.extra.chested = *chested, + (Species::Llama | Species::TraderLlama, 20, Value::Int(strength)) => { + m.extra.variant2 = (*strength).clamp(1, 5) as u8; + } + (Species::Llama | Species::TraderLlama, 21, Value::Int(variant)) => { + m.extra.variant = (*variant).clamp(0, 3) as u8; + } + // Axolotl.DATA_VARIANT (lucy 0 to blue 4) and Parrot.DATA_VARIANT_ID + // (after TamableAnimal's flags and owner). + (Species::Axolotl, 18, Value::Int(v)) => m.extra.variant = (*v).clamp(0, 4) as u8, + (Species::Parrot, 20, Value::Int(v)) => m.extra.variant = (*v).clamp(0, 4) as u8, + // Rabbit.DATA_TYPE_ID: the killer bunny's 99 has no model here. + (Species::Rabbit, 18, Value::Int(t)) if (0..=5).contains(t) => { + m.extra.variant = *t as u8; + } + // Bee.DATA_FLAGS_ID and DATA_ANGER_END_TIME (after Animal's). + (Species::Bee, 18, Value::Byte(flags)) => bee::set_synced(m, Some(*flags as u8), None), + (Species::Bee, 19, Value::Long(end)) => bee::set_synced(m, None, Some(*end)), + // AbstractFish.FROM_BUCKET takes 16: Salmon.DATA_TYPE (small 0 + // to large 2), Pufferfish.PUFF_STATE and + // TropicalFish.DATA_ID_TYPE_VARIANT. + (Species::Salmon, 17, Value::Int(v)) => m.extra.variant = (*v).clamp(0, 2) as u8, + (Species::Pufferfish, 17, Value::Int(state)) => m.extra.size = (*state).clamp(0, 2), + (Species::TropicalFish, 17, Value::Int(v)) => tropical_fish(m, *v), + // Ghast.DATA_IS_CHARGING and WitherBoss.DATA_ID_INV. + (Species::Ghast, 16, Value::Bool(charging)) => m.extra.flag = *charging, + (Species::Wither, 19, Value::Int(ticks)) => m.extra.counter = (*ticks).max(0), + // CopperGolem.DATA_WEATHER_STATE: the oxidation the texture shows. + (Species::CopperGolem, 16, Value::Id(state)) => { + m.extra.variant = (*state).clamp(0, 3) as u8; + } // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's // IS_CELEBRATING takes 16). (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging, + // HappyGhast.STAYS_STILL (after AgeableMob's two and IS_LEASH_HOLDER): + // `isOnStillTimeout` on a client, which keeps the ghast solid to + // the player (`canBeCollidedWith`). + (Species::HappyGhast, 19, Value::Bool(still)) => m.extra.counter = i32::from(*still), // SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose. (Species::Evoker | Species::Illusioner, 17, Value::Byte(spell)) => { m.extra.variant2 = (*spell).max(0) as u8; @@ -146,6 +240,71 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti } } +/// A tropical fish's packed variant: the pattern's id (the size, then the +/// index << 8), the base colour << 16 and the pattern colour << 24. Here the +/// pattern is 0 to 5 for the small ones and 6 to 11 for the large ones. +fn tropical_fish(m: &mut Mob, packed: i32) { + let (size, index) = (packed & 0xFF, (packed >> 8) & 0xFF); + // TropicalFish.Pattern.byId: an unknown id is a kob. + m.extra.variant = if size <= 1 && index < 6 { + (size * 6 + index) as u8 + } else { + 0 + }; + m.extra.variant2 = ((packed >> 16) & 0xFF) as u8 & 15; + m.extra.variant3 = ((packed >> 24) & 0xFF) as u8 & 15; +} + +/// The values of one SetEntityData packet that name an entry of a +/// synchronized registry (the variants of the cat, wolf, frog, pig, cow, +/// chicken and zombie nautilus) or count game time (a wolf's anger). +/// `game_time` is the client level's. +fn apply_registry_data( + m: &mut Mob, + values: &[(u8, i32, Value)], + registries: &Dynamic, + game_time: i64, +) { + let species = m.species(); + for (index, _, value) in values { + let registry = match (species, *index, value) { + (Species::Cat, 20, Value::Id(_)) => "minecraft:cat_variant", + (Species::Wolf, 23, Value::Id(_)) => "minecraft:wolf_variant", + (Species::Frog, 18, Value::Id(_)) => "minecraft:frog_variant", + (Species::Pig, 19, Value::Id(_)) => "minecraft:pig_variant", + (Species::Cow, 18, Value::Id(_)) => "minecraft:cow_variant", + (Species::Chicken, 18, Value::Id(_)) => "minecraft:chicken_variant", + (Species::ZombieNautilus, 21, Value::Id(_)) => "minecraft:zombie_nautilus_variant", + // Wolf.DATA_ANGER_END_TIME: the angry texture while it lies ahead. + (Species::Wolf, 22, Value::Long(end)) => { + m.extra.anger = (end - game_time).clamp(0, i64::from(i32::MAX)) as i32; + continue; + } + _ => continue, + }; + if let Value::Id(id) = value + && let Some(name) = registries.name(registry, *id) + { + m.extra.variant = finalize::variant_index(species, name); + } + } +} + +/// What another player's pose draws from: gliding (Entity.isFallFlying, flag +/// 0x80 of the shared flags), the pose (swimming), Riptide's spin +/// (LivingEntity.isAutoSpinAttack, flag 4) and a loaded crossbow in the +/// hand (the held stack comes with SetEquipment). +fn player_poses(m: &mut Mob, values: &[(u8, i32, Value)]) { + for (index, _, value) in values { + match (*index, value) { + (0, Value::Byte(flags)) => m.extra.fall_flying = flags & -128 != 0, + (6, Value::Id(pose)) => m.extra.synced_pose = (*pose).clamp(0, 17) as u8, + (8, Value::Byte(flags)) => m.extra.auto_spin_attack = flags & 4 != 0, + _ => {} + } + } +} + /// The options of a synched particle list: an entity effect carries its ARGB /// colour, the omens none. fn swirls(list: &[Particle], builtin: &Builtin) -> Vec { @@ -200,6 +359,7 @@ impl Game<'_> { }; if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) { apply(m, values, &r.builtin, r.entity_id); + apply_registry_data(m, values, &r.registries, self.world.game_time); } } } diff --git a/crates/horizon-client/src/game/remote_mob_particles.rs b/crates/horizon-client/src/game/remote_mob_particles.rs new file mode 100644 index 000000000..e3daf284d --- /dev/null +++ b/crates/horizon-client/src/game/remote_mob_particles.rs @@ -0,0 +1,50 @@ +//! Particles a client of a server draws for a mob's entity event, which the +//! server does not send as a particle packet. +use super::Game; +use horizon_client::{ + mobs::Species, + particles::{ParticleOptions, ParticleType}, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +impl Game<'_> { + /// `Ravager.handleEntityEvent(69)`: forty puffs of smoke from the middle + /// of its box, then `applyRoarKnockbackClient`: this client's own player + /// within 4 blocks is thrown away from it. + pub(super) fn remote_ravager_roar(&mut self, id: i32) { + let Some(m) = self + .mobs + .iter() + .find(|m| m.id == id as u32 && m.species() == Species::Ravager) + else { + return; + }; + let (center, at, area) = ( + m.center(), + m.position, + m.bounds().inflate(Vec3::new(4.0, 4.0, 4.0)), + ); + let options = ParticleOptions::simple(ParticleType::Poof); + for _ in 0..40 { + let r = self.particles.random(); + let v = [ + r.next_gaussian() * 0.2, + r.next_gaussian() * 0.2, + r.next_gaussian() * 0.2, + ]; + self.particles.add(&options, center, v); + } + if let Some(view) = self.player_view() + && view.alive + && view.bounds.intersects(area) + && let Some(p) = self.player.as_mut() + { + // strongKnockback. + let (xd, zd) = (p.position.x - at.x, p.position.z - at.z); + let dd = (xd * xd + zd * zd).max(0.001); + p.velocity = p + .velocity + .add_vector(Vec3::new(xd / dd * 4.0, 0.2, zd / dd * 4.0)); + } + } +} diff --git a/crates/horizon-client/src/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs index bd38c7301..728d22094 100644 --- a/crates/horizon-client/src/game/remote_mob_use.rs +++ b/crates/horizon-client/src/game/remote_mob_use.rs @@ -61,6 +61,8 @@ impl Game<'_> { ) && !baby } Species::Sheep => item == "minecraft:shears" || item.ends_with("_dye"), + // SnowGolem.mobInteract: shears take the pumpkin off. + Species::SnowGolem => item == "minecraft:shears" && !m.extra.sheared, // Bucketable.bucketMobPickup. Species::Cod | Species::Salmon diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 7f484c35f..d70ab795d 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -164,6 +164,10 @@ impl Game<'_> { } (3, Value::Bool(visible)) => a.name_visible = *visible, (9, Value::Float(health)) => a.health = *health, + // ArmorStand.DATA_HEAD_POSE to DATA_RIGHT_LEG_POSE. + (16..=21, Value::Floats(r)) if r.len() == 3 => { + a.pose[usize::from(index - 16)] = [r[0], r[1], r[2]]; + } // ArmorStand.DATA_CLIENT_FLAGS. (15, Value::Byte(flags)) => { a.small = flags & 1 != 0; diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 00d4abaed..409c28c88 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -207,6 +207,8 @@ impl Game<'_> { "minecraft:trident" => { let mut t = super::trident::ThrownTrident::remote(id, at, yaw, pitch); t.velocity = velocity; + // Projectile.getAddEntityPacket: the owner's id is the data. + t.owner = data as u32; self.tridents.push(t); } "minecraft:firework_rocket" => { @@ -350,6 +352,15 @@ impl Game<'_> { (9, Value::Bool(show)) => c.show_bottom = *show, _ => {} } + } else if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id) { + // AbstractArrow.ID_FLAGS (no physics) and IN_GROUND, and + // ThrownTrident.ID_LOYALTY. + match (index, value) { + (8, Value::Byte(flags)) => t.no_physics = flags & 2 != 0, + (10, Value::Bool(in_ground)) => t.in_ground = *in_ground, + (11, Value::Byte(loyalty)) => t.loyalty = u32::from(*loyalty as u8), + _ => {} + } } else if let Some(p) = self.creatures.projectiles.iter_mut().find(|p| p.id == id) { match (&mut p.kind, index, value) { // AbstractArrow.ID_FLAGS (critical) and IN_GROUND. @@ -383,6 +394,25 @@ impl Game<'_> { } } + /// `Entity.getEyePosition` of a projectile's owner: this game's player or + /// another player the server sent. + fn remote_eye(&self, id: u32) -> Option { + let me = self + .remote + .as_ref() + .and_then(|r| u32::try_from(r.entity_id).ok()); + if me == Some(id) { + let eye = self.eye_position()?; + return Some(Vec3::new(eye[0], eye[1], eye[2])); + } + let m = self.mobs.iter().find(|m| m.id == id)?; + Some(Vec3::new( + m.position.x, + m.position.y + m.eye_height(), + m.position.z, + )) + } + /// One tick of interpolation, as `tick_remote_objects`. pub(super) fn tick_remote_projectiles(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) { self.tick_remote_fangs(); @@ -416,6 +446,7 @@ impl Game<'_> { // updates (10 to 20 ticks apart); a block stops them there, and only // the server decides what they hit. let mut projectiles = std::mem::take(&mut self.creatures.projectiles); + let mut tridents = std::mem::take(&mut self.tridents); { let w = self.mob_world_base(&[]); let world = super::creatures::ProjWorld { @@ -434,8 +465,12 @@ impl Game<'_> { _ => remote_projectile_tick(p, &world), } } + for t in &mut tridents { + t.remote_tick(&world, self.remote_eye(t.owner)); + } } self.creatures.projectiles = projectiles; + self.tridents = tridents; let trails: Vec = self .creatures .projectiles @@ -444,10 +479,6 @@ impl Game<'_> { .map(|p| p.position) .collect(); self.smoke_trails(trails); - for t in &mut self.tridents { - let id = t.id; - t.remote_step(|at| step(id, at)); - } // FireworkRocketEntity.tick: a rocket attached to an entity follows it // and boosts it client-side too (attachedToEntity.isFallFlying), and // every rocket leaves its spark trail on a client. diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs index 877ed66e6..c9cbf1159 100644 --- a/crates/horizon-client/src/game/remote_vehicles.rs +++ b/crates/horizon-client/src/game/remote_vehicles.rs @@ -128,6 +128,17 @@ impl Game<'_> { } else if self.riding == Some(vehicle_id) { // The server takes the player out, then teleports it. self.riding = None; + // HappyGhast.removePassenger: a still timeout of 10 (the server's + // STAYS_STILL confirms it), and the rider lands on top of the ghast + // (`place_ghast_under`). + if let Some(m) = self.mobs.iter_mut().find(|m| { + m.id == vehicle_id && m.species() == horizon_client::mobs::Species::HappyGhast + }) { + m.extra.counter = 10; + if let Some(r) = self.remote.as_mut() { + r.ghast_dismount = Some(vehicle_id); + } + } } } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index fecb58615..26a5a81cd 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -19,10 +19,29 @@ use horizon_core::random::{LegacyRandom, RandomSource}; /// The first motion-blocking block at or below `from` (Heightmap MOTION_BLOCKING), plus one. fn motion_blocking(world: &World, facts: &BlockFacts, x: i32, z: i32, from: i32) -> i32 { + motion_blocking_leaves(world, facts, x, z, from, true) +} +/// `motion_blocking` where leaves count only for MOTION_BLOCKING, not for +/// MOTION_BLOCKING_NO_LEAVES. +fn motion_blocking_leaves( + world: &World, + facts: &BlockFacts, + x: i32, + z: i32, + from: i32, + leaves: bool, +) -> i32 { let mut y = from.min(MIN_Y + HEIGHT - 1); while y > MIN_Y { let f = facts.get(world.block(x, y, z)); - if f.full_collision || f.fluid != Fluid::None || f.name.contains("leaves") { + // #minecraft:leaves block motion, but MOTION_BLOCKING_NO_LEAVES skips them + // (their water still counts). + let blocks = if f.name.ends_with("_leaves") { + leaves + } else { + f.full_collision + }; + if blocks || f.fluid != Fluid::None { return y + 1; } y -= 1; @@ -34,16 +53,7 @@ fn rains_at(world: &World, biomes: &Biomes, x: i32, y: i32, z: i32) -> bool { let Some(chunk) = world.chunks.get(&(x >> 4, z >> 4)) else { return false; }; - let b = biomes.get(chunk.biome(x, y, z)); - if !b.precipitation { - return false; - } - let t = if y > 80 { - b.temperature - (y - 80) as f32 * 0.05 / 40.0 - } else { - b.temperature - }; - t >= 0.15 + biomes.get(chunk.biome(x, y, z)).snows_at(x, y, z) == Some(false) } impl Game<'_> { @@ -92,9 +102,8 @@ impl Game<'_> { distant_terrain: self.lod.is_some(), cloud_range_chunks: self.settings.cloud_range, camera_y: camera.y, - // level.getMinY(): the Nether and the End start at y 0. - min_y: if self.dim == Dim::Overworld { MIN_Y } else { 0 }, - flat: false, + min_y: self.level_min_y(), + flat: self.level_flat(), forward: forward.map(|c| c as f32), rain, thunder, @@ -108,9 +117,30 @@ impl Game<'_> { }, ) } - /// `SkyRenderer.shouldRenderDarkDisc`: eye below the horizon (y 63) and not under water. + /// `ClientLevelData.isFlat`: on the server thread, the world-wide flag. + fn level_flat(&self) -> bool { + match self.remote.as_ref() { + Some(r) => r.flat, + None => self.world_flat, + } + } + /// `Level.getMinY`: the current dimension type's minimum y. + fn level_min_y(&self) -> i32 { + match self.remote.as_ref() { + Some(r) => r.dimension.min_y, + None => self.dim.min_y(), + } + } + /// `SkyRenderer.shouldRenderDarkDisc`: eye below the horizon and not under + /// water. `ClientLevelData.getHorizonHeight`: the bottom of a flat world, + /// otherwise y 63. pub(super) fn dark_disc(&self, camera: glam::DVec3) -> bool { - camera.y < 63.0 + let horizon = if self.level_flat() { + f64::from(self.level_min_y()) + } else { + 63.0 + }; + camera.y < horizon && fog_type( &self.world, self.res.facts(), @@ -273,6 +303,21 @@ impl Game<'_> { && motion_blocking(world, facts, p[0], p[2], p[1] + 64) <= p[1] && rains_at(world, biomes, p[0], p[1], p[2]) }; + let height_no_leaves = + |p: [i32; 3]| motion_blocking_leaves(world, facts, p[0], p[2], i32::MAX, false); + // The day timeline: firefly bush sounds from 12600 to 23400. + let firefly_bush_sounds = self.dim == Dim::Overworld + && (12600..23401).contains(&self.world.day_time.rem_euclid(24000)); + let tables = &self.pack.context.tables; + let model_offset = |state, x, z| tables.offset(state, x, z); + let gateway_particles = |state, p| { + self.res + .block_entity_render() + .gateway_faces(world, state, p) + .len() + }; + // Level.isThundering: a thunder level above 0.9 where the sky is open. + let thundering = self.dim == Dim::Overworld && world.weather.levels(1.0).1 > 0.9; let ctx = AnimateContext { world, facts, @@ -280,7 +325,14 @@ impl Game<'_> { biomes, registry: self.pack.assets.registry, raining_at: &raining_at, + height_no_leaves: &height_no_leaves, + firefly_bush_sounds, + sky_darken: self.sky_darken(), marker: marker.map(|name| (name, &marker_options as &dyn Fn(_) -> _)), + model_offset: &model_offset, + gateway_particles: &gateway_particles, + thundering, + ultrawarm: self.dim == Dim::Nether, }; if let Some(e) = eye { let block = [ diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs index 53323fdbb..443cb2c03 100644 --- a/crates/horizon-client/src/game/scoreboard.rs +++ b/crates/horizon-client/src/game/scoreboard.rs @@ -683,7 +683,7 @@ impl Game<'_> { let objective = board.display_objective(sb::SLOT_LIST); let shown = tab_list::visible( key, - self.remote.is_none(), + self.has_singleplayer_server(), players.len(), objective.is_some(), ); diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index 4b5c4c333..200a0e6fe 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -3,6 +3,7 @@ use super::{Game, Screen}; use horizon_client::{ Result, command::args::GameMode, + confirm_screen::Confirm, hud::{HudBatch, rgba}, text::{self, Text}, ui, @@ -103,6 +104,14 @@ fn pause_icons(w: f32, h: f32, links: bool) -> [(f32, f32, &'static str); 4] { ] } /// DeathScreen.init: a hardcore player can only spectate. +/// `DeathScreen.TitleConfirmScreen`: its title and the yes and no labels. +fn death_confirm_texts() -> (Text, [Text; 2]) { + let t = |key: &str| Text::translate(key, &[]); + ( + t("deathScreen.quit.confirm"), + [t("deathScreen.titleScreen"), t("deathScreen.respawn")], + ) +} fn death_buttons(w: f32, h: f32, hardcore: bool) -> [(f32, f32, &'static str, u8); 2] { let respawn = if hardcore { "deathScreen.spectate" @@ -267,6 +276,20 @@ impl Game<'_> { ), ); } + // DeathScreen.handleExitToTitleScreen: the TitleConfirmScreen takes the + // screen over, on the same background. + if let Some(opened) = self.ui.death_confirm { + let (title, labels) = death_confirm_texts(); + let size = self.gui_size(); + Confirm::new(&atlas.font, size, &title, &Text::literal("")).draw_active( + batch, + atlas, + self.cursor, + [&labels[0], &labels[1]], + opened.elapsed().as_millis() >= 1000, + ); + return; + } let title = if self.level.hardcore { "deathScreen.title.hardcore" } else { @@ -382,6 +405,23 @@ impl Game<'_> { { return Ok(()); } + if let Some(opened) = self.ui.death_confirm { + // ConfirmScreen.setDelay: both buttons wait 20 ticks. + if opened.elapsed().as_millis() < 1000 { + return Ok(()); + } + let (title, _) = death_confirm_texts(); + let confirm = Confirm::new( + &self.gui.atlas.font, + self.gui_size(), + &title, + &Text::literal(""), + ); + if let Some(yes) = confirm.answer_at(self.cursor) { + self.death_confirm_answer(yes)?; + } + return Ok(()); + } let size = self .renderer .as_ref() @@ -391,6 +431,27 @@ impl Game<'_> { .into_iter() .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0)) .map(|d| d.3); + // handleExitToTitleScreen: outside hardcore, Title Screen asks first. + if hit == Some(1) && !self.level.hardcore { + self.ui.death_confirm = Some(std::time::Instant::now()); + self.audio.play_button_click(); + return Ok(()); + } + self.death_action(hit) + } + /// The confirm screen's answer: yes leaves the world, no respawns + /// (`DeathScreen.handleExitToTitleScreen`'s callback). + pub(super) fn death_confirm_answer(&mut self, yes: bool) -> Result<()> { + self.ui.death_confirm = None; + if yes { + self.audio.play_button_click(); + self.close_world() + } else { + self.death_action(Some(0)) + } + } + /// A death screen button: 0 respawns (or spectates in hardcore), 1 leaves. + fn death_action(&mut self, hit: Option) -> Result<()> { match hit { Some(0) => self.respawn_player()?, Some(1) => self.close_world()?, diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs index 65dfede1a..abcecf841 100644 --- a/crates/horizon-client/src/game/sculk.rs +++ b/crates/horizon-client/src/game/sculk.rs @@ -876,17 +876,26 @@ impl Game<'_> { /// `SculkSensorBlock.stepOn` and `SculkShriekerBlock.stepOn`: standing on /// them is heard (or seen) every tick. fn sculk_step_on(&mut self) { + self.sculk_step_on_player(); let mut standing: Vec<(Who, [f64; 3])> = Vec::new(); - if let Some(p) = self.player.as_ref() - && p.ground.on_ground - { - standing.push((Who::Player, [p.position.x, p.position.y, p.position.z])); - } for m in &self.mobs { if m.alive() && m.on_ground { standing.push((Who::Mob(m.id), [m.position.x, m.position.y, m.position.z])); } } + self.sculk_stand_on(standing); + } + /// `stepOn` for the player in place: the host, or a guest swapped in + /// (`guest_server_tick`), as a server has no player of its own. + pub(super) fn sculk_step_on_player(&mut self) { + if let Some(p) = self.player.as_ref() + && p.ground.on_ground + { + let at = [p.position.x, p.position.y, p.position.z]; + self.sculk_stand_on(vec![(Who::Player, at)]); + } + } + fn sculk_stand_on(&mut self, standing: Vec<(Who, [f64; 3])>) { for (who, at) in standing { // getOnPosLegacy: 0.2 below the feet. let key = ( @@ -1108,23 +1117,10 @@ impl Game<'_> { /// in the way (`isUnobstructed`), and no block collision. fn warden_fits(&self, mob: &Mob) -> bool { let bounds = mob.bounds(); - let player_blocks = !self.spectator() - && self.player.as_ref().is_some_and(|p| { - let w = f64::from(p.dimensions.width) / 2.0; - let b = horizon_core::geometry::Aabb::new( - horizon_core::geometry::Vec3::new( - p.position.x - w, - p.position.y, - p.position.z - w, - ), - horizon_core::geometry::Vec3::new( - p.position.x + w, - p.position.y + f64::from(p.dimensions.height), - p.position.z + w, - ), - ); - !p.health.dead_or_dying() && b.intersects(bounds) - }); + let player_blocks = self + .level_players() + .iter() + .any(|p| p.alive && !p.spectator && p.bounds.intersects(bounds)); if player_blocks || self .mobs diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs index d0769b894..a616be199 100644 --- a/crates/horizon-client/src/game/server_packs.rs +++ b/crates/horizon-client/src/game/server_packs.rs @@ -67,6 +67,13 @@ impl PackPrompt { } } +impl ServerPackState { + /// The `ToastManager` slots the download toasts hold. + pub(super) fn toast_slots(&self) -> impl Iterator + '_ { + self.notifiers.iter().filter_map(|n| n.toast.as_ref()?.slot) + } +} + /// The game's `DownloadedPackSource`. #[derive(Default)] pub(super) struct ServerPackState { @@ -503,15 +510,22 @@ impl Game<'_> { .layout(atlas, (w, h)) .draw(batch, atlas, self.cursor, [&yes, &no]); } - /// The download notifiers' toasts, each in the next 32-pixel slot - /// below an advancement or recipe toast (`ToastManager`). - pub(super) fn draw_pack_toasts(&mut self, batch: &mut HudBatch) { + /// The download notifiers' toasts, each in a free 32-pixel slot of the + /// `ToastManager` (`hidden`, F1, keeps them timing out undrawn). + pub(super) fn draw_pack_toasts(&mut self, batch: &mut HudBatch, hidden: bool) { let multiplier = f64::from(self.settings.notification_display_time); - let mut slot = usize::from(!self.adv.toasts.is_empty()); + let mut used = self.toast_slots_used(); for notifier in &mut self.server_packs.notifiers { let Some(toast) = &mut notifier.toast else { continue; }; + if toast.slot.is_none() { + let Some(slot) = (0..Self::TOAST_SLOTS).find(|s| used & (1 << s) == 0) else { + continue; + }; + used |= 1 << slot; + toast.slot = Some(slot); + } let (sound, finished) = toast.update(multiplier); if let Some(show) = sound { let event = if show { "ui.toast.in" } else { "ui.toast.out" }; @@ -522,8 +536,9 @@ impl Game<'_> { notifier.toast = None; continue; } - toast.draw(&self.gui.atlas, batch, 32.0 * slot as f32); - slot += 1; + if let (false, Some(slot)) = (hidden, toast.slot) { + toast.draw(&self.gui.atlas, batch, 32.0 * slot as f32); + } } } /// A left click on the prompt: its answer when it hit a button. diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs index bcaf37a76..e516d3f67 100644 --- a/crates/horizon-client/src/game/server_travel.rs +++ b/crates/horizon-client/src/game/server_travel.rs @@ -11,7 +11,7 @@ use super::end::GatewayJob; use super::nether_portal::{PLAYER_DELAY, Plan}; use super::respawn_anchor::RespawnConfig; use super::{Dim, Game, lan::LanHost}; -use horizon_client::{lan::hub::TickCtx, text::Text}; +use horizon_client::{lan::hub::TickCtx, text::Text, world_spawn::PlayerSpawnFinder}; use horizon_core::{geometry::Vec3, position::BlockPos}; use horizon_protocol::packets::play::{self, Clientbound as C}; @@ -31,6 +31,11 @@ pub(super) struct Trip { /// A respawn at this point outside the Overworld, resolved through its /// block on arrival. respawn: Option, + /// A respawn at the world spawn, moved onto a free column within the + /// respawn radius once the chunks around it have loaded. + world_spawn: bool, + /// The search for that column while a candidate's chunk loads. + finder: Option, /// Sent by a command: the player is already where it goes. placed: bool, } @@ -66,10 +71,11 @@ impl Game<'_> { /// in it (Nether portals count up their transition time, End portals /// take them at once). pub(super) fn tick_server_travel(&mut self, host: &mut LanHost) { + // Outside a server only the respawns at the world spawn wait for chunks. + self.arrive_server_trips(host); if self.options.dedicated.is_none() { return; } - self.arrive_server_trips(host); let conns: Vec = host .hub .guests @@ -253,6 +259,8 @@ impl Game<'_> { plan, gateway: None, respawn: None, + world_spawn: false, + finder: None, placed: false, }); if let Err(e) = self.enter_level(Some(host), source) { @@ -272,6 +280,8 @@ impl Game<'_> { plan: None, gateway: None, respawn: Some(config), + world_spawn: false, + finder: None, placed: false, }); } @@ -304,6 +314,28 @@ impl Game<'_> { } } + /// TeleportTransition.createDefault and missingRespawnBlock: the player + /// waits at the world spawn for its chunks, then PlayerSpawnFinder puts + /// it on a free column within the respawn radius. + pub(super) fn world_spawn_trip(&mut self, conn: u32) { + let Some([x, y, z]) = self.level.world_spawn else { + return; + }; + self.server_trips.retain(|t| !t.is(conn)); + self.server_trips.push(Trip { + conn, + dim: Dim::Overworld, + target: Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5), + end: false, + plan: None, + gateway: None, + respawn: None, + world_spawn: true, + finder: None, + placed: false, + }); + } + /// TeleportTransition.missingRespawnBlock: the world spawn, in the /// Overworld. fn respawn_at_world_spawn(&mut self, host: &mut LanHost, conn: u32) { @@ -318,6 +350,7 @@ impl Game<'_> { rotation: None, }); self.run_level_teleports(host); + self.world_spawn_trip(conn); } /// `TheEndGatewayBlockEntity.getPortalPosition` and the teleport within @@ -343,6 +376,8 @@ impl Game<'_> { plan: None, gateway: Some(job), respawn: None, + world_spawn: false, + finder: None, placed: false, }); } @@ -369,7 +404,7 @@ impl Game<'_> { k += 1; continue; } - let trip = self.server_trips.remove(k); + let mut trip = self.server_trips.remove(k); if trip.placed { continue; } @@ -383,6 +418,22 @@ impl Game<'_> { continue; } } + } else if trip.world_spawn { + // PlayerSpawnFinder.findSpawn around the world spawn. + let suggestion = + [trip.target.x, trip.target.y, trip.target.z].map(|v| v.floor() as i32); + match self.search_spawn(suggestion, &mut trip.finder) { + // The respawn already put the player on this column: + // vanilla teleports once, so no second move. + Ok(at) if host.hub.guests[i].position == [at.x, at.y, at.z] => continue, + Ok(at) => (at, yaw), + Err(chunk) => { + self.spawn_wait.push(chunk); + self.server_trips.insert(k, trip); + k += 1; + continue; + } + } } else if let Some(job) = trip.gateway { match self.resolve_gateway(job, trip.target) { Ok(at) => (at, yaw), @@ -392,12 +443,19 @@ impl Game<'_> { } } } else if trip.end { - let arrival = match self.as_guest(host, trip.conn, |g| g.end_arrival(trip.target)) { + let arrival = match self.as_guest(host, trip.conn, |g| { + g.end_arrival(trip.target, &mut trip.finder) + }) { Some(arrival) => arrival, - None => self.end_arrival(trip.target), + None => self.end_arrival(trip.target, &mut trip.finder), }; match arrival { - Ok((at, turned)) => (at, turned.unwrap_or(yaw)), + Ok(Some((at, turned))) => (at, turned.unwrap_or(yaw)), + Ok(None) => { + self.server_trips.insert(k, trip); + k += 1; + continue; + } Err(e) => { log::error!("End arrival: {e}"); (trip.target, yaw) @@ -458,6 +516,8 @@ impl Game<'_> { plan: None, gateway: None, respawn: None, + world_spawn: false, + finder: None, placed: true, }); if let Err(e) = self.enter_level(Some(host), source) { diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index a26bc5d75..228b7c206 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -176,7 +176,14 @@ impl Game<'_> { if projectile { return; } - let Some(id) = attacker else { return }; + let Some(id) = attacker else { + // Another player's melee hit has no mob behind it. + if let Some((from, disable)) = self.combat.player_attacker { + let fully = outcome.blocked >= damage; + self.blocked_by_attacker(&component, [from[0], from[2]], fully, disable, at); + } + return; + }; let fully = outcome.blocked >= damage; let Some(m) = self.mobs.iter().find(|m| m.id == id) else { return; @@ -219,6 +226,21 @@ impl Game<'_> { let _ = self.handle_mob_events(events); return; } + self.blocked_by_attacker(&component, [mx, mz], fully, disable, at); + } + + /// What a blocked melee hit does to the defender once the shield took + /// it: `LivingEntity.blockedByItem` knocks them back unless fully + /// blocked, then `Player.blockUsingItem` disables the shield. + fn blocked_by_attacker( + &mut self, + component: &horizon_client::items::BlocksAttacks, + attacker: [f64; 2], + fully: bool, + disable: f32, + at: Option<[f64; 3]>, + ) { + let [mx, mz] = attacker; // LivingEntity.blockedByItem: defender.knockback(0.5, defender - attacker), // which moves the defender along -(xd, zd). if !fully && let Some(p) = self.player.as_mut() { diff --git a/crates/horizon-client/src/game/shoulders.rs b/crates/horizon-client/src/game/shoulders.rs new file mode 100644 index 000000000..7dfc2f355 --- /dev/null +++ b/crates/horizon-client/src/game/shoulders.rs @@ -0,0 +1,124 @@ +//! Parrots on a player's shoulder: a tame parrot lands on its owner +//! (`LandOnOwnersShoulderGoal`), is kept as the player's `ShoulderEntityLeft` +//! or `ShoulderEntityRight`, and flies off again when the player is hurt, +//! falls, swims, flies or sleeps (`ServerPlayer.handleShoulderEntities`). +use super::Game; +use horizon_client::mobs::Species; +use horizon_world::nbt::Tag; + +const KEYS: [&str; 2] = ["ShoulderEntityLeft", "ShoulderEntityRight"]; + +/// A shoulder slot holds a parrot when its compound is not empty. +fn occupied(extra: &Tag, key: &str) -> bool { + matches!(extra.get(key), Some(Tag::Compound(c)) if !c.is_empty()) +} + +impl Game<'_> { + /// `ServerPlayer.setEntityOnShoulder` for a parrot that touched its + /// owner: stored in the first free slot, the parrot gone from the world. + pub(super) fn parrot_to_shoulder(&mut self, mob: u32) { + let Some(i) = self + .mobs + .iter() + .position(|m| m.id == mob && m.alive() && !m.removed && m.species() == Species::Parrot) + else { + return; + }; + let Some(p) = self.player.as_ref() else { + return; + }; + // The acting player must be the saved owner (`getOwner`). + if !horizon_client::mobs::tame::owned_by(self.mobs[i].extra.owner, self.acting_uuid()) { + return; + } + if self.riding.is_some() + || !p.ground.on_ground + || p.fluids.was_touching_water + || p.in_powder_snow + || p.flying + { + return; + } + let extra = self + .level + .player_extra + .get_or_insert_with(|| Tag::Compound(Default::default())); + let Some(key) = KEYS.into_iter().find(|k| !occupied(extra, k)) else { + return; + }; + let tag = self.mob_tree_nbt(i); + if let Some(Tag::Compound(map)) = self.level.player_extra.as_mut() { + map.insert(key.into(), tag); + } + let (uuid, now) = (self.acting_uuid(), self.world.game_time); + self.creatures.shoulder_time.insert(uuid, now); + self.mobs[i].removed = true; + } + + /// `ServerPlayer.handleShoulderEntities`: the parrots leave the shoulder + /// of a player who falls, swims, flies, sleeps, is hurt, dying, a + /// spectator or spinning with a riptide. + pub(super) fn handle_shoulder_entities(&mut self) { + let Some(p) = self.player.as_ref() else { + return; + }; + let any = self + .level + .player_extra + .as_ref() + .is_some_and(|e| KEYS.iter().any(|k| occupied(e, k))); + if any + && (p.fall_distance > 0.5 + || p.fluids.was_touching_water + || p.flying + || p.spectator + || p.in_powder_snow + || p.auto_spin_attack_ticks > 0 + || p.health.hurt.hurt_time > 0 + || p.health.dead_or_dying() + || self.sleeping.is_some()) + { + self.remove_entities_on_shoulder(); + } + } + + /// `ServerPlayer.removeEntitiesOnShoulder` (not within a second of the + /// landing) and `respawnEntityOnShoulder`: the parrots come back at the + /// player, still owned by them. + fn remove_entities_on_shoulder(&mut self) { + let (uuid, now) = (self.acting_uuid(), self.world.game_time); + if self + .creatures + .shoulder_time + .get(&uuid) + .is_some_and(|t| t + 20 >= now) + { + return; + } + let Some(p) = self.player.as_ref().map(|p| p.position) else { + return; + }; + let Some(Tag::Compound(map)) = self.level.player_extra.as_mut() else { + return; + }; + let tags: Vec = KEYS + .iter() + .filter_map(|k| map.remove(&(*k).into())) + .collect(); + let pos = [p.x, p.y + f64::from(0.7_f32), p.z]; + for mut tag in tags { + let Tag::Compound(c) = &mut tag else { + continue; + }; + if c.is_empty() { + continue; + } + c.insert( + "Pos".into(), + Tag::List(pos.iter().map(|v| Tag::Double(v.to_bits())).collect()), + ); + c.insert("Owner".into(), Tag::IntArray(uuid.to_vec())); + self.load_mob(tag, None); + } + } +} diff --git a/crates/horizon-client/src/game/sniffers.rs b/crates/horizon-client/src/game/sniffers.rs index 8e851d028..5027f5c2b 100644 --- a/crates/horizon-client/src/game/sniffers.rs +++ b/crates/horizon-client/src/game/sniffers.rs @@ -5,9 +5,8 @@ use super::Game; use horizon_client::{ items::ItemStack, mobs::{Mob, Species, sniffer}, - particles::Particle, }; -use horizon_core::random::RandomSource; +use horizon_core::{geometry::Vec3, random::RandomSource}; impl Game<'_> { /// The egg item at the parent (`Sniffer.spawnChildFromBreeding`; the @@ -46,15 +45,20 @@ impl Game<'_> { /// block's hit sound between the 1.7th and the 6th second of the /// digging animation) and `playSearchingSound`. pub(super) fn tick_sniffer_effects(&mut self) { - let Some(camera) = self.player.as_ref().map(|p| p.position) else { + // Vanilla runs these on each client: a sniffer within 32 blocks of + // any player in the level (the host and the guests) shows them. + let players = self.level_players(); + if players.is_empty() { return; - }; + } for i in 0..self.mobs.len() { let m = &self.mobs[i]; if m.species() != Species::Sniffer || !m.alive() || m.silent - || m.position.distance_squared(camera) > 32.0 * 32.0 + || !players + .iter() + .any(|p| m.position.distance_squared(p.position) <= 32.0 * 32.0) { continue; } @@ -79,20 +83,20 @@ impl Game<'_> { } let head = sniffer::head_block(m); let below = self.world.block(head[0], head[1] - 1, head[2]); - let Some((sprite, tint)) = self.particle_sprite(below, [head[0], head[1] - 1, head[2]]) - else { + if self + .particle_sprite(below, [head[0], head[1] - 1, head[2]]) + .is_none() + { continue; - }; + } let dust = [ f64::from(head[0]) + 0.5, f64::from(head[1]) + 0.5 - f64::from(0.65_f32), f64::from(head[2]) + 0.5, ]; - for _ in 0..30 { - let particle = - Particle::terrain(&mut self.world.random, dust, [0.0; 3], sprite.clone(), tint); - self.particles.push(particle); - } + // Drawn in this window when it has one, and sent to the players + // within 32 blocks (the server thread's window is one of them). + self.landing_dust(None, below, Vec3::new(dust[0], dust[1], dust[2]), 30, 0.0); if self.mobs[i].age.is_multiple_of(10) { let hit = self.res.facts().get(below).sounds.hit.clone(); self.audio.play(&hit, Some(at), 0.5, 0.5); diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs index a3761cf7a..40085b7fa 100644 --- a/crates/horizon-client/src/game/spawner.rs +++ b/crates/horizon-client/src/game/spawner.rs @@ -21,10 +21,11 @@ type Pos = (i32, i32, i32); /// What a spawner tick decided to add, created once the level is free. pub(super) enum Planned { - /// `finalizeSpawn` ran on a fresh mob. - Finalized(Mob), - /// A mob loaded from the spawn data (with its passengers). - Loaded(Tag), + /// `finalizeSpawn` ran on a fresh mob; the spawn data's `equipment`. + Finalized(Mob, Option), + /// A mob loaded from the spawn data (with its passengers) and its + /// `equipment`. + Loaded(Tag, Option), } /// What the spawner code keeps between ticks. @@ -120,18 +121,24 @@ impl Game<'_> { for (i, plan) in planned.into_iter().enumerate() { let provisional = u32::MAX - i as u32; let id = match plan { - Planned::Finalized(mut mob) => { + Planned::Finalized(mut mob, equipment) => { self.next_entity += 1; mob.id = self.next_entity; let id = mob.id; self.mobs.push(mob); self.enchant_spawn_equipment(id); self.spawn_jockeys(id, true); - Some(id) + Some((id, equipment)) + } + Planned::Loaded(tag, equipment) => { + self.load_mob(tag, None).map(|id| (id, equipment)) } - Planned::Loaded(tag) => self.load_mob(tag, None), }; - if let Some(id) = id { + if let Some((id, equipment)) = id { + // `nextSpawnData.getEquipment().ifPresent(mob::equip)`. + if let Some(table) = equipment { + self.equip_from_table(id, &table); + } ids.insert(provisional, id); } } @@ -169,7 +176,7 @@ impl Game<'_> { mob.previous_head_yaw = 0.0; } let bounds = mob.bounds(); - planned.push(Planned::Finalized(mob)); + planned.push(Planned::Finalized(mob, r.equipment.cloned())); bounds } else { // A UUID already in the level is refused. @@ -197,7 +204,7 @@ impl Game<'_> { let tag = Tag::Compound(tag); let mob = horizon_client::entity_nbt::mob_from_nbt(&tag, self.res.mob_types(), 0)?; let bounds = mob.bounds(); - planned.push(Planned::Loaded(tag)); + planned.push(Planned::Loaded(tag, r.equipment.cloned())); bounds }; l.pending.borrow_mut().push(bounds); diff --git a/crates/horizon-client/src/game/spear.rs b/crates/horizon-client/src/game/spear.rs new file mode 100644 index 000000000..13df3aed9 --- /dev/null +++ b/crates/horizon-client/src/game/spear.rs @@ -0,0 +1,330 @@ +//! Spears (`KineticWeapon`): holding the use button charges the spear, and +//! from `delay_ticks` on every living entity along the view that the +//! player's speed allows is stabbed: the damage grows with the speed +//! relative to the target, the knockback and the dismount need the +//! attacker's own speed, and each condition runs out after its time +//! (`Item.use`, `ItemStack.onUseTick`, `KineticWeapon.damageEntities`, +//! `Player.stabAttack`). The hit's feedback (`onKineticHit`) reaches the +//! players around as entity event 2. +use super::{Game, view_vector}; +use horizon_client::{ + collisions::SceneCollisions, + items::ItemStack, + mobs::Damage, + spear::{HIT_FEEDBACK_TICKS, Kinetic, REACH}, +}; +use horizon_core::{ + geometry::{Aabb, Vec3, traverse_blocks}, + position::BlockPos, +}; + +/// The key of this window's own player in `Game::kinetic_feedback`. +pub(super) const OWN: i32 = i32::MIN; + +impl Game<'_> { + /// `Item.use` of a kinetic weapon: `startUsingItem` with a new + /// `recentKineticEnemies`, and `KineticWeapon.makeSound` at the user. + pub(super) fn use_spear(&mut self, stack: &ItemStack) -> bool { + let Some(kinetic) = Kinetic::of(&stack.item) else { + return false; + }; + if self.using.is_none() { + self.using = Some((self.held_slot(), 0)); + let actor = self.lan_acting; + self.stabbed.retain(|(who, _), _| *who != actor); + if let Some(p) = &self.player { + let at = [p.position.x, p.position.y, p.position.z]; + self.audio.play(kinetic.sound, Some(at), 1.0, 1.0); + } + } + true + } + + /// `ServerPlayer.getKnownMovement` of the acting player: what they moved + /// in the last tick. A guest's comes with their moves. + fn known_player_movement(&self) -> Vec3 { + if self.lan_acting.is_some() { + return self.known_movement; + } + self.player + .as_ref() + .map_or(Vec3::ZERO, |p| p.position.subtract(self.previous_position)) + } + + /// `Entity.getKnownSpeed` of the mob at `index`, per second: its root + /// vehicle's (`KineticWeapon.getMotion`). + fn mob_speed(&self, index: usize) -> Vec3 { + let mut mob = &self.mobs[index]; + while let Some(vehicle) = mob + .extra + .mount + .and_then(|v| self.mobs.iter().find(|m| m.id == v)) + { + mob = vehicle; + } + mob.position.subtract(mob.previous).scale(20.0) + } + + /// `Level.clip` with COLLIDER shapes and no fluids: where the segment + /// first meets a block, if it does (tall grass lets a stab through). + fn clip_collider(&self, from: Vec3, to: Vec3) -> Option { + let mut scene = SceneCollisions { + world: &self.world, + binding: self.collision, + subject: None, + }; + traverse_blocks(from, to, 512, |p: BlockPos| { + let state = self.world.block(p.x, p.y, p.z); + if self.res.facts().is_air(state) { + return None; + } + let shape = self + .collision + .collision_shape(&mut scene, state, [p.x, p.y, p.z]) + .ok()?; + shape.clip(from, to, p).map(|hit| hit.location) + }) + .ok() + .flatten() + } + + /// `ProjectileUtil.getHitEntitiesAlong` for the mobs: those whose box the + /// segment `from`..`to` meets, or comes within the margin of with no + /// block between. + fn mobs_along(&self, from: Vec3, to: Vec3, margin: f64) -> Vec { + let grow = Vec3::new(margin, margin, margin); + let mut hits = Vec::new(); + for (i, m) in self.mobs.iter().enumerate() { + // PiercingWeapon.canHitEntity: alive, and not the vehicle ridden. + if !m.alive() || m.removed || self.riding == Some(m.id) { + continue; + } + let bounds: Aabb = m.bounds(); + let hit = bounds.contains(from) + || bounds.clip(from, to).is_some() + || (margin > 0.0 + && bounds.inflate(grow).clip(from, to).is_some_and(|outside| { + let centre = bounds.center(); + let toward = self.clip_collider(outside, centre).unwrap_or(centre); + bounds.clip(outside, toward).is_some() + })); + if hit { + hits.push(i); + } + } + hits + } + + /// `KineticWeapon.damageEntities`: one tick of the spear in use, `ticks` + /// ticks into the use. + pub(super) fn spear_tick(&mut self, stack: &ItemStack, ticks: u32) { + let Some(kinetic) = Kinetic::of(&stack.item) else { + return; + }; + let used = ticks as i32 - kinetic.delay_ticks; + let (Some(eye), Some(feet)) = ( + self.eye_position(), + self.player.as_ref().map(|p| p.position), + ) else { + return; + }; + if used < 0 || self.spectator() { + return; + } + let eye = Vec3::new(eye[0], eye[1], eye[2]); + let look = view_vector(self.yaw, self.pitch); + let look = Vec3::new(look[0], look[1], look[2]); + let movement = self.known_player_movement(); + let attacker_speed = look.dot(movement.scale(20.0)); + // AttackRange.effectiveMinRange and effectiveMaxRange for a player. + let (min, max) = if self.creative { + (REACH.min_creative, REACH.max_creative) + } else { + (REACH.min, REACH.max) + }; + let from = eye.add_vector(look.scale(f64::from(min))); + let mut to = eye.add_vector(look.scale(f64::from(max) + movement.dot(look).max(0.0))); + // A block closer than the minimum reach takes the whole stab. + if let Some(block) = self.clip_collider(eye, to) { + to = block; + if eye.distance_squared(to) < eye.distance_squared(from) { + return; + } + } + let now = self.world.game_time; + let actor = self.lan_acting; + let mut affected = false; + for i in self.mobs_along(from, to, f64::from(REACH.hitbox_margin)) { + let key = (actor, self.mobs[i].id); + let recent = self + .stabbed + .get(&key) + .is_some_and(|&t| now - t < i64::from(kinetic.contact_cooldown_ticks)); + if recent { + continue; + } + self.stabbed.insert(key, now); + let target_speed = look.dot(self.mob_speed(i)); + let relative = (attacker_speed - target_speed).max(0.0); + // An entity factor of 1 for a player. + let dismounts = kinetic.dismount.test(used, attacker_speed, relative, 1.0); + let pushes = kinetic.knockback.test(used, attacker_speed, relative, 1.0); + let damages = kinetic.damage.test(used, attacker_speed, relative, 1.0); + if dismounts || pushes || damages { + // The attack damage attribute's base value (1) and the speed. + let amount = 1.0 + (relative * f64::from(kinetic.damage_multiplier)).floor() as f32; + affected |= self.stab_mob(i, amount, damages, pushes, dismounts); + } + } + if affected { + // Level.broadcastEntityEvent(player, 2), felt by the player too. + if self.audio.capture.is_some() { + self.lan_kinetic_hits.push(actor); + } + let who = actor.map_or(OWN, |conn| conn as i32); + self.kinetic_hit_feedback(who, &kinetic, [feet.x, feet.y, feet.z]); + } + } + + /// `Player.stabAttack` on the mob at `index`: whether it was affected. + fn stab_mob( + &mut self, + index: usize, + base_damage: f32, + deals_damage: bool, + deals_knockback: bool, + dismounts: bool, + ) -> bool { + let kind = format!( + "minecraft:{}", + self.mobs[index].kind.id.trim_start_matches("minecraft:") + ); + let id = self.mobs[index].id; + let Some(p) = self.player.as_ref() else { + return false; + }; + let from = [p.position.x, p.position.y, p.position.z]; + // The enchantments' share, with no attack strength scaling for a + // weapon in use. + let magic_boost = self.enchant_damage_bonus(&kind); + let total = if deals_damage { + base_damage + magic_boost + } else { + 0.0 + }; + let old_health = self.mobs[index].health; + let hurt = deals_damage && self.hurt_by_player(index, total, Damage::spear(from)); + // causeExtraKnockback: a push of 0.4, then the weapon's Knockback. + if deals_knockback { + let (xd, zd) = self.extra_knockback_direction(); + self.mobs[index].knockback(0.4, xd, zd); + let (strength, _) = self.extra_knockback(&kind, 0.0); + self.mobs[index].knockback(f64::from(strength), xd, zd); + } + let dismounted = dismounts && self.mobs[index].extra.mount.is_some(); + if dismounted { + self.dismount_mob(id); + } + if !hurt && !deals_knockback && !dismounted { + return false; + } + let mob = &self.mobs[index]; + let (feet, width, height) = ( + [mob.position.x, mob.position.y, mob.position.z], + mob.kind.width, + mob.kind.height, + ); + // attackVisualEffects: no attack sound, the enchantments' magic crit. + if magic_boost > 0.0 { + self.critical_hit(self.lan_acting, id as i32, feet, width, height, true); + } + self.combat.last_hurt_mob = Some((id, self.world.game_time)); + // itemAttackInteraction: hurtEnemy (statistic, wear), and the + // post-attack enchantments when the target was hurt. + if let Some(stack) = self.held().cloned() { + self.stats.add("used", &stack.item, 1); + if hurt { + self.post_attack(index); + } + self.weapon_wear(&stack); + } + // damageStatsAndHearts. + let actual = old_health - self.mobs[index].health; + self.stats + .custom("damage_dealt", (actual * 10.0).round() as i32); + if actual > 2.0 { + let indicator = horizon_client::particles::ParticleOptions::simple( + horizon_client::particles::ParticleType::DamageIndicator, + ); + self.particles.send_particles( + &indicator, + [feet[0], feet[1] + height * 0.5, feet[2]], + [0.1, 0.0, 0.1], + 0.2, + (actual * 0.5) as u32, + ); + } + if hurt { + self.last_hurt_by_player.insert(id, self.lan_acting); + } + if let Some(p) = self.player.as_mut() + && !self.creative + { + p.cause_food_exhaustion(0.1); + } + true + } + + /// `LivingEntity.onKineticHit` for `entity`: the hit feels (the spear + /// moves back, `kinetic_hit_ticks`) and sounds, at most once every ten + /// ticks. + pub(super) fn kinetic_hit_feedback(&mut self, entity: i32, kinetic: &Kinetic, at: [f64; 3]) { + let now = self.world.game_time; + if self + .kinetic_feedback + .get(&entity) + .is_none_or(|&t| now - t > HIT_FEEDBACK_TICKS) + { + self.kinetic_feedback.insert(entity, now); + self.audio + .play_unshared(kinetic.hit_sound, Some(at), 1.0, 1.0); + } + } + + /// `getTicksSinceLastKineticHitFeedback` of this window's player. + pub(super) fn kinetic_hit_ticks(&self, partial: f32) -> f32 { + self.kinetic_feedback + .get(&OWN) + .map_or(0.0, |&t| (self.world.game_time - t) as f32 + partial) + } + + /// `LivingEntity.handleEntityEvent(2)` on a server's client: the + /// player `id` (this one, or another) was hit by the spear it uses. + pub(super) fn remote_kinetic_hit(&mut self, id: i32) { + let own = self.remote.as_ref().is_some_and(|r| r.entity_id == id); + let (item, at) = if own { + let item = self + .using + .and_then(|(slot, _)| self.stack_in(slot)) + .map(|s| s.item.clone()); + let at = self.player.as_ref().map(|p| p.position); + (item, at) + } else { + let mob = self + .mobs + .iter() + .find(|m| m.id == id as u32 && m.extra.using_item > 0); + let item = mob.and_then(|m| { + if m.extra.using_off_hand { + m.extra.off_hand.clone() + } else { + m.extra.main_hand.clone() + } + }); + (item, mob.map(|m| m.position)) + }; + if let (Some(kinetic), Some(at)) = (item.as_deref().and_then(Kinetic::of), at) { + self.kinetic_hit_feedback(if own { OWN } else { id }, &kinetic, [at.x, at.y, at.z]); + } + } +} diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs index b1953596b..d8f15daa1 100644 --- a/crates/horizon-client/src/game/spill.rs +++ b/crates/horizon-client/src/game/spill.rs @@ -5,9 +5,11 @@ //! world as soon as the behaviour returns, within the same tick. use super::{Game, GameLevel, Screen, dispenser::new_item_motion, storage::is_shulker_box}; use horizon_client::{ + block_entity_item, block_entity_nbt, containers::{Banner, BlockEntity}, item_data, items::ItemStack, + save, }; use horizon_core::position::BlockPos; use horizon_core::random::RandomSource; @@ -16,7 +18,7 @@ use horizon_world::{ LevelEvent, removal::{self, PreRemove}, }, - nbt::{JavaString, Tag}, + nbt::{Compound, JavaString, Tag}, registry::BlockStateId, }; use std::collections::HashMap; @@ -32,6 +34,9 @@ pub(super) struct Pending { pub(super) names: HashMap<[i32; 3], (String, String)>, /// A decorated pot's sherds (back, left, right, front). pub(super) pot: HashMap<[i32; 3], [Option; 4]>, + /// A head's profile, note block sound and name, or a hive's bees: the + /// dropped item and the component patch it takes. + pub(super) copied: HashMap<[i32; 3], (String, Compound)>, } impl Pending { /// Remember what the block entity at `pos` copies into the drops of `block`. @@ -49,6 +54,31 @@ impl Pending { if let Some(name) = name { self.names.insert(pos, (block.to_owned(), name)); } + // `copy_components` from the block entity: the head tables copy the + // profile (player heads), note block sound and name, the hive tables + // the bees. + let include: &[&str] = match entity { + BlockEntity::Skull(_) if block.starts_with("minecraft:player_") => &[ + "minecraft:profile", + "minecraft:note_block_sound", + "minecraft:custom_name", + ], + BlockEntity::Skull(_) => &["minecraft:custom_name"], + BlockEntity::Beehive(_) => &["minecraft:bees"], + _ => &[], + }; + if !include.is_empty() { + let saved = save::encode_block_entity((pos[0], pos[1], pos[2]), entity, block); + let mut patch = block_entity_nbt::canonical(&saved) + .map(|saved| block_entity_item::pick(&saved)) + .unwrap_or_default(); + patch.retain(|k, _| include.contains(&k.to_string_lossy().as_str())); + if !patch.is_empty() { + // `Blocks.wallVariant`: a wall head drops the standing item. + let item = block.replacen("_wall_", "_", 1); + self.copied.insert(pos, (item, patch)); + } + } if is_shulker_box(block) && let BlockEntity::Chest(items) = entity { @@ -76,6 +106,19 @@ impl Pending { { stack.data_mut().custom_name = Some(name); } + if self + .copied + .get(&pos) + .is_some_and(|(item, _)| **item == *stack.item) + && let Some((_, copied)) = self.copied.remove(&pos) + { + let mut patch = match item_data::encode_components(stack) { + Some(Tag::Compound(c)) => c, + _ => Default::default(), + }; + patch.extend(copied); + (stack.damage, stack.extra) = item_data::decode_components(Some(&Tag::Compound(patch))); + } if &*stack.item == "minecraft:decorated_pot" { // The pot's block entity always copies its decorations, empty or not. let sides = self.pot.remove(&pos).unwrap_or_default(); @@ -155,6 +198,7 @@ impl Pending { self.shulker.remove(&pos); self.banner.remove(&pos); self.names.remove(&pos); + self.copied.remove(&pos); } } diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs index 361879d2e..1734cb3ee 100644 --- a/crates/horizon-client/src/game/stations.rs +++ b/crates/horizon-client/src/game/stations.rs @@ -779,6 +779,7 @@ impl Game<'_> { return; }; let pos = s.pos; + let enchanted_item = enchanted.clone(); // Player.onEnchantmentPerformed self.give_levels(-(lapis_needed as i32)); self.level.xp_seed = self.world.random.next_int(); @@ -795,6 +796,7 @@ impl Game<'_> { } let pitch = self.world.random.next_float() * 0.1 + 0.9; self.stats.custom("enchant_item", 1); + self.trigger_enchanted_item(&enchanted_item, lapis_needed as i32); self.play_at("minecraft:block.enchantment_table.use", pos, 1.0, pitch); self.station_changed(); } @@ -1768,6 +1770,11 @@ impl Game<'_> { }; let gray = rgba(170, 170, 170, 255); let item_info = self.res.items().get(&stack.item); + // SmithingTemplateItem.appendHoverText: `Item.appendHoverText` comes + // before the components. + for (text, c) in horizon_client::item_tooltip::smithing_template_lines(stack, &translate) { + push(&mut lines, text, c); + } // InstrumentComponent.addToTooltip. if let Some(text) = horizon_client::item_tooltip::instrument_line(stack, &display, &translate) @@ -2023,15 +2030,19 @@ impl Game<'_> { && stack.damage > 0 && advanced { - push( - &mut lines, - format!( - "Durability: {} / {}", - info.max_damage - stack.damage, - info.max_damage + // `item.durability`, in the selected language. + lines.push(( + horizon_client::text::Text::translate( + "item.durability", + &[ + horizon_client::text::Text::literal( + (info.max_damage - stack.damage).to_string(), + ), + horizon_client::text::Text::literal(info.max_damage.to_string()), + ], ), u32::MAX, - ); + )); } // ItemStack.addDetailsToTooltipTail: with advanced tooltips the item id // and how many components the stack has. diff --git a/crates/horizon-client/src/game/stats.rs b/crates/horizon-client/src/game/stats.rs index 68a574eb1..94814320c 100644 --- a/crates/horizon-client/src/game/stats.rs +++ b/crates/horizon-client/src/game/stats.rs @@ -378,9 +378,10 @@ impl Game<'_> { if pos[1] < 63 || !self.can_see_sky(pos) { return; } - // DifficultyInstance.isHarderThan(random * 3) at normal difficulty. + // `getCurrentDifficultyAt(playerPos).isHarderThan(random * 3)`. + let difficulty = self.local_difficulty([position.x, position.y, position.z]); let r = &mut self.world.random; - if r.next_float() * 3.0 >= 2.0 { + if difficulty.effective <= r.next_float() * 3.0 { return; } if r.next_int_bound(since_rest.max(1)).unwrap_or(0) < 72000 { diff --git a/crates/horizon-client/src/game/titles.rs b/crates/horizon-client/src/game/titles.rs index 9bb000314..217702e51 100644 --- a/crates/horizon-client/src/game/titles.rs +++ b/crates/horizon-client/src/game/titles.rs @@ -12,12 +12,14 @@ use horizon_client::{ impl Game<'_> { /// `Hud.extractOverlayMessage` and `extractTitle`. - pub(super) fn draw_titles(&self, batch: &mut HudBatch) { + pub(super) fn draw_titles(&self, batch: &mut HudBatch, bar_height: i32) { let (w, h) = (batch.width as i32, batch.height as i32); let partial = self.clock.fraction() as f32; let background = self.settings.text_background(0.0); let font = &self.gui.atlas.font; - let mut draws = self.titles.overlay_message(w, h, partial, font, background); + let mut draws = self + .titles + .overlay_message(w, h, bar_height, partial, font, background); draws.extend(self.titles.title(w, h, partial, font, background)); hud_layout::paint(batch, &self.gui.atlas, &draws); } @@ -60,6 +62,7 @@ impl Game<'_> { /// The title, action bar and selected-item parts of `Hud.tick`. pub(super) fn tick_hud(&mut self) { self.titles.tick(); + self.tick_in_bed_chat(); // `MinecraftServer.isCurrentlySaving` of single player's server. let saving = self .integrated @@ -71,10 +74,11 @@ impl Game<'_> { .tick(held, f64::from(self.settings.notification_display_time)); } /// `Hud.extractSelectedItemName`. - pub(super) fn draw_selected_name(&self, batch: &mut HudBatch, can_hurt: bool) { + pub(super) fn draw_selected_name(&self, batch: &mut HudBatch, bar_height: i32, can_hurt: bool) { let draws = self.tool_highlight.draw( batch.width as i32, batch.height as i32, + bar_height, can_hurt, &self.gui.atlas.font, self.settings.text_background(0.0), diff --git a/crates/horizon-client/src/game/trial_spawner.rs b/crates/horizon-client/src/game/trial_spawner.rs index 42a26c6e4..d076671ea 100644 --- a/crates/horizon-client/src/game/trial_spawner.rs +++ b/crates/horizon-client/src/game/trial_spawner.rs @@ -163,7 +163,7 @@ impl Game<'_> { let mut spawn = |l: &GameLevel, r: &SpawnerSpawn| { let added = l.game.plan_spawner_mob(l, r, &mut planned)?; let uuid = match planned.last_mut() { - Some(Planned::Loaded(Tag::Compound(tag))) => { + Some(Planned::Loaded(Tag::Compound(tag), _)) => { let tag_uuid = horizon_client::entity_nbt::uuid(&Tag::Compound(tag.clone())); tag_uuid.unwrap_or_else(|| { diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index bca582d1a..b333156e1 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -10,6 +10,7 @@ use horizon_client::{ items::ItemStack, mesher::Vertex, mobs::{Damage, DamageKind, Who, anim::Poses}, + projectiles::ProjectileWorld, }; use horizon_core::{ geometry::{Aabb, Vec3, traverse_blocks}, @@ -33,6 +34,8 @@ pub(super) struct ThrownTrident { pub(super) no_physics: bool, returning: u32, creative_only: bool, + /// The entity id a server sent as its owner (the one Loyalty returns it to). + pub(super) owner: u32, /// The guest that threw it (`Projectile.getOwner`); `None` for the host. guest: Option, } @@ -54,13 +57,72 @@ impl ThrownTrident { no_physics: false, returning: 0, creative_only: false, + owner: 0, guest: None, } } - /// One tick of a server's client: the previous position, then `step`. - pub(super) fn remote_step(&mut self, step: impl FnOnce(Vec3) -> Vec3) { + /// `ThrownTrident.tick`'s Loyalty return: pulled up and towards the + /// owner's eye. + fn loyalty_pull(&mut self, owner_eye: Vec3) { + let v = Vec3::new( + owner_eye.x - self.position.x, + owner_eye.y - self.position.y, + owner_eye.z - self.position.z, + ); + self.position.y += v.y * 0.015 * f64::from(self.loyalty); + let len = (v.x * v.x + v.y * v.y + v.z * v.z).sqrt().max(1e-9); + let accel = 0.05 * f64::from(self.loyalty); + self.velocity = Vec3::new( + self.velocity.x * 0.95 + v.x / len * accel, + self.velocity.y * 0.95 + v.y / len * accel, + self.velocity.z * 0.95 + v.z / len * accel, + ); + } + /// `ThrownTrident.tick` on a server's client: it flies on by itself + /// between the server's updates (`AbstractArrow.tick`: gravity and drag, + /// a block holds it), and Loyalty pulls it back to its owner; only the + /// server decides what it hits. + pub(super) fn remote_tick(&mut self, w: &impl ProjectileWorld, owner_eye: Option) { self.previous = self.position; - self.position = step(self.position); + if self.in_ground_time > 4 { + self.dealt_damage = true; + } + if self.loyalty > 0 + && (self.dealt_damage || self.no_physics) + && let Some(eye) = owner_eye + { + self.no_physics = true; + self.in_ground = false; + self.loyalty_pull(eye); + } + if self.in_ground && !self.no_physics { + self.in_ground_time += 1; + return; + } + self.in_ground_time = 0; + let m = self.velocity; + let (x, z) = if self.no_physics { + (-m.x, -m.z) + } else { + (m.x, m.z) + }; + self.yaw = x.atan2(z).to_degrees() as f32; + self.pitch = m.y.atan2(m.x.hypot(m.z)).to_degrees() as f32; + let to = self.position.add_vector(m); + if !self.no_physics + && let Some((at, _, _)) = w.clip(self.position, to) + { + self.position = at; + self.velocity = Vec3::ZERO; + self.in_ground = true; + return; + } + self.position = to; + // A trident's water inertia (0.99) equals the air drag. + self.velocity = self.velocity.scale(0.99); + if !self.no_physics { + self.velocity.y -= 0.05; + } } } const HALF: f64 = 0.25; @@ -244,7 +306,12 @@ impl Game<'_> { if !self.in_water_or_rain() || self.riding.is_some() { return; } - self.hurt_held_without_breaking(1); + // `hurtWithoutBreaking` and the sound belong to the server; a server's + // client only launches. + let server_client = self.remote.is_some(); + if !server_client { + self.hurt_held_without_breaking(1); + } // trident_spin_attack_strength: 1.5 + 0.75 per level above the first. let strength = 1.5 + 0.75 * (riptide as f32 - 1.0); let d = view_vector(self.yaw, self.pitch); @@ -257,12 +324,34 @@ impl Game<'_> { // Player.startAutoSpinAttack(20, 8, stack). p.auto_spin_attack_ticks = 20; p.auto_spin_attack_dmg = 8.0; - if p.ground.on_ground { - p.position.y += 1.2; + } + // `player.move(SELF, (0, 1.1999999, 0))` when on the ground: the lift + // stops at a ceiling. + let lift = self + .player + .as_ref() + .filter(|p| p.ground.on_ground) + .map(|p| p.bounds()); + if let Some(bounds) = lift { + let mut scene = SceneCollisions { + world: &self.world, + binding: self.collision, + subject: None, + }; + let up = Vec3::new(0.0, f64::from(1.1999999f32), 0.0); + let moved = scene.resolve(bounds, up, 0.0, true).unwrap_or(Vec3::ZERO); + if let Some(p) = self.player.as_mut() { + p.position.y += moved.y; } } - let sound = format!("minecraft:item.trident.riptide_{}", riptide.min(3)); - self.audio.play(&sound, at, 1.0, 1.0); + if !server_client { + let sound = format!("minecraft:item.trident.riptide_{}", riptide.min(3)); + self.audio.play(&sound, at, 1.0, 1.0); + } + return; + } + // The server throws the trident. + if self.remote.is_some() { return; } // hurtWithoutBreaking (Unbreaking applies), then the thrown copy. @@ -306,6 +395,7 @@ impl Game<'_> { no_physics: false, returning: 0, creative_only: self.creative, + owner: 0, guest: self.lan_acting, }); self.player_projectile_shot(); @@ -349,19 +439,7 @@ impl Game<'_> { if t.loyalty > 0 && (t.dealt_damage || t.no_physics) { t.no_physics = true; t.in_ground = false; - let v = Vec3::new( - owner_eye.x - t.position.x, - owner_eye.y - t.position.y, - owner_eye.z - t.position.z, - ); - t.position.y += v.y * 0.015 * f64::from(t.loyalty); - let len = (v.x * v.x + v.y * v.y + v.z * v.z).sqrt().max(1e-9); - let accel = 0.05 * f64::from(t.loyalty); - t.velocity = Vec3::new( - t.velocity.x * 0.95 + v.x / len * accel, - t.velocity.y * 0.95 + v.y / len * accel, - t.velocity.z * 0.95 + v.z / len * accel, - ); + t.loyalty_pull(owner_eye); if t.returning == 0 { self.audio.play( "minecraft:item.trident.return", diff --git a/crates/horizon-client/src/game/wind.rs b/crates/horizon-client/src/game/wind.rs index 63ac2641d..b00cea116 100644 --- a/crates/horizon-client/src/game/wind.rs +++ b/crates/horizon-client/src/game/wind.rs @@ -470,6 +470,7 @@ impl Game<'_> { } /// The bursts guests' turns put off. pub(super) fn flush_wind_bursts(&mut self) -> Result<()> { + self.flush_smash_pushes(); for b in std::mem::take(&mut self.creatures.wind_bursts) { self.wind_burst(b.center, b.radius, b.multiplier, b.breeze, b.wind_charge)?; } diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 5f01633b0..aa56409b1 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -71,7 +71,8 @@ impl Game<'_> { /// After a wither skeleton skull is placed: the T of soul sand (or soul /// soil) under three skulls, upright along X or Z, becomes a wither. pub(super) fn check_wither_spawn(&mut self, placed: [i32; 3]) -> horizon_client::Result<()> { - if !self.is_wither_skull(placed) { + // Nothing is built in Peaceful (`level.getDifficulty() != PEACEFUL`). + if self.ui.difficulty == 0 || !self.is_wither_skull(placed) { return Ok(()); } // Pattern rows top to bottom: "^^^", "###", "~#~" ('~' air). diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 801dedde9..ad1fd0561 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3587,7 +3587,7 @@ impl Renderer { if self.animated_textures { self.animate(&mut encoder, frame.ticks); self.hud - .animate_fire(&mut self.uploads, &mut encoder, frame.ticks); + .animate_sprites(&mut self.uploads, &mut encoder, frame.ticks); } self.update_lightmap( &mut encoder, diff --git a/crates/horizon-client/src/hotbar.rs b/crates/horizon-client/src/hotbar.rs index a60f28287..dccae7560 100644 --- a/crates/horizon-client/src/hotbar.rs +++ b/crates/horizon-client/src/hotbar.rs @@ -119,3 +119,23 @@ pub fn load(path: &Path, known: &dyn Fn(&str) -> bool) -> Vec { _ => (0..GROUPS).map(|_| empty()).collect(), } } + +/// `HotbarManager.save`: the nine rows with the current data version, each +/// stack as `ItemStack.OPTIONAL_CODEC` writes it (an empty one is `{}`). +pub fn save(path: &Path, rows: &[Hotbar]) -> crate::Result<()> { + let mut entries = vec![( + JavaString::from("DataVersion"), + Tag::Int(horizon_world::DATA_VERSION), + )]; + for (i, row) in rows.iter().enumerate() { + let stacks = row.iter().map(|s| match s { + Some(s) => save::item_to_nbt(s), + None => Tag::compound(Vec::<(&str, Tag)>::new()), + }); + entries.push(( + JavaString::from(i.to_string().as_str()), + Tag::List(stacks.collect()), + )); + } + save::write_dat(path, Tag::compound(entries)) +} diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 2b9bae9b5..fda0094d8 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -2,6 +2,7 @@ //! textures, and a batch of textured quads in GUI pixels (vanilla's automatic //! GUI scale is applied when drawing). use crate::Result; +use horizon_assets::animation::AnimationMetadata; use std::{ collections::{HashMap, HashSet}, fs, @@ -64,7 +65,10 @@ pub struct HudAtlas { /// Sprites whose `.png.mcmeta` sets `blur` or `clamp`; the others /// sample as vanilla's defaults (nearest, repeat). pub flags: HashMap, - pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, + /// Every animated block or item sprite the atlas packs: its atlas rect + /// and the mcmeta-driven frame list, re-uploaded into the rect as the + /// frames turn (vanilla's stitched atlas animates all of these). + pub sprite_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>, /// The default font (bitmap sheets in this atlas, unifont rasterized on demand). pub font: crate::font::Font, /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler` @@ -147,6 +151,21 @@ fn walk(dir: &Path, out: &mut Vec) { } /// A packed atlas image: sprite name, size and RGBA pixels. type PackedImage = (String, u32, u32, Vec); +/// A frame of an animated strip at `x, y`, nearest-resampled to the longer +/// side of the frame: array layers are square, as `Sprites::load` keeps them +/// for the world's sprite arrays. +fn strip_frame(pixels: &[u8], stride: u32, x: u32, y: u32, w: u32, h: u32) -> Vec { + let side = w.max(h); + let mut out = Vec::with_capacity((side * side * 4) as usize); + for row in 0..side { + let source_row = y + row * h / side; + for column in 0..side { + let at = ((source_row * stride + x + column * w / side) * 4) as usize; + out.extend_from_slice(&pixels[at..at + 4]); + } + } + out +} /// `image` inside a one-texel border copied from its opposite edges, the /// texels repeat addressing reads past each edge. fn wrap_border((name, w, h, data): &PackedImage) -> PackedImage { @@ -378,7 +397,7 @@ impl HudAtlas { let s = p.to_string_lossy(); !s.contains("title/background") && !s.contains("realms") && !s.contains("presets") }); - type Decoded = (PackedImage, Option, Option<(u32, u32)>); + type Decoded = (PackedImage, Option, Option<(u32, u32)>, bool); let decode_one = |path: &PathBuf| -> Option { let name = path .strip_prefix(&textures) @@ -386,12 +405,35 @@ impl HudAtlas { .with_extension("") .to_string_lossy() .replace('\\', "/"); - let (w, mut h, pixels) = decode(path).ok()?; - // Animated strips keep their first frame. + let (mut w, mut h, pixels) = decode(path).ok()?; + let mcmeta = fs::read_to_string(path.with_extension("png.mcmeta")).ok(); + let animation = mcmeta + .as_deref() + .and_then(|json| serde_json::from_str::(json).ok()) + .and_then(|meta| { + meta.get("animation") + .and_then(|section| AnimationMetadata::from_json(§ion.to_string()).ok()) + }); + // An animated strip keeps its first frame: the region the mcmeta's + // frame size picks (`AnimationMetadataSection.frameSize`), which is + // the top-left square unless it names other dimensions or the + // frames run along a row. let frames = name.starts_with("block/") || name.starts_with("item/"); - let pixels = if frames && h > w { - h = w; - pixels[..(w * w * 4) as usize].to_vec() + let pixels = if frames { + let stride = w; + let [fw, fh] = animation.as_ref().map_or([w.min(h) as i32; 2], |meta| { + meta.frame_size(w as i32, h as i32) + }); + match (u32::try_from(fw), u32::try_from(fh)) { + (Ok(fw), Ok(fh)) + if fw > 0 && fh > 0 && w % fw == 0 && h % fh == 0 && (fw, fh) != (w, h) => + { + let side = fw.max(fh); + (w, h) = (side, side); + strip_frame(&pixels, stride, 0, 0, fw, fh) + } + _ => pixels, + } } else { pixels }; @@ -399,16 +441,19 @@ impl HudAtlas { let gui_size = default_textures .as_ref() .and_then(|d| png_size(&d.join(format!("{name}.png")))) - .map(|(dw, dh)| (dw, if frames { dh.min(dw) } else { dh })) + .map(|(dw, dh)| { + let side = dw.min(dh); + if frames { (side, side) } else { (dw, dh) } + }) .filter(|&size| size != (w, h)); - let flags = fs::read_to_string(path.with_extension("png.mcmeta")) - .ok() - .and_then(|json| TextureFlags::from_mcmeta(&json)); + let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta); + let animated = frames && animation.is_some(); let (gw, gh) = gui_size.unwrap_or((w, h)); (gw <= 1024 && (gh <= 512 || name.starts_with("font/"))).then_some(( (name, w, h, pixels), flags, gui_size, + animated, )) }; let threads = std::thread::available_parallelism().map_or(2, |n| n.get()); @@ -427,14 +472,18 @@ impl HudAtlas { }); let mut flags = HashMap::new(); let mut gui_sizes = HashMap::new(); + let mut animated: Vec = Vec::new(); let mut images: Vec = Vec::with_capacity(decoded.len()); - for (image, image_flags, gui_size) in decoded { + for (image, image_flags, gui_size, is_animated) in decoded { if let Some(f) = image_flags { flags.insert(image.0.clone(), f); } if let Some(size) = gui_size { gui_sizes.insert(image.0.clone(), size); } + if is_animated { + animated.push(image.0.clone()); + } images.push(image); } if full { @@ -500,35 +549,32 @@ impl HudAtlas { }, ); } - let mut fire_sprites = crate::sprites::Sprites::default(); - let mut fire_animations = Vec::new(); - for name in [ - "block/fire_0", - "block/fire_1", - "block/soul_fire_0", - "block/soul_fire_1", - ] { - if let Some(rect) = sprites.get(name).copied() { - let layer = fire_sprites.insert(root, &format!("minecraft:{name}"))?; - if let Some(animation) = fire_sprites - .animations - .iter() - .find(|a| a.layer == layer) - .cloned() - { - let (tw, th) = rect.texels((width, height)); - let image = animation.resized_pixels(animation.frame(0), tw, th); - let x = (rect.u0 * width as f32).round() as usize; - let y = (rect.v0 * height as f32).round() as usize; - let row_bytes = tw as usize * 4; - for row in 0..th as usize { - let dst = ((y + row) * width as usize + x) * 4; - let src = row * row_bytes; - pixels[dst..dst + row_bytes].copy_from_slice(&image[src..src + row_bytes]); - } - fire_animations.push((rect, animation)); - } + // Every animated sprite animates: the packed strip is the raw first + // frame, while the mcmeta's frame list may start anywhere, so each + // animation's frame(0) overwrites its atlas rect before drawing. + let mut loaded = crate::sprites::Sprites::default(); + let mut sprite_animations = Vec::new(); + animated.sort(); + for name in animated { + let Some(rect) = sprites.get(&name).copied() else { + continue; + }; + let layer = loaded.insert(root, &format!("minecraft:{name}"))?; + let Some(animation) = loaded.animations.iter().find(|a| a.layer == layer).cloned() + else { + continue; + }; + let (tw, th) = rect.texels((width, height)); + let image = animation.resized_pixels(animation.frame(0), tw, th); + let x = (rect.u0 * width as f32).round() as usize; + let y = (rect.v0 * height as f32).round() as usize; + let row_bytes = tw as usize * 4; + for row in 0..th as usize { + let dst = ((y + row) * width as usize + x) * 4; + let src = row * row_bytes; + pixels[dst..dst + row_bytes].copy_from_slice(&image[src..src + row_bytes]); } + sprite_animations.push((rect, animation)); } let white = sprites["horizon/white"]; let glint = Self::glint_texture(root, defaults, "enchanted_glint_item"); @@ -548,7 +594,7 @@ impl HudAtlas { sprites, translucent, flags, - fire_animations, + sprite_animations, glint, glint_armor, font, @@ -1082,7 +1128,7 @@ impl HudUniform { } } pub struct HudRenderer { - pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation, usize)>, + pub sprite_animations: Vec<(Rect, crate::sprites::SpriteAnimation, (usize, usize, u32))>, /// The shared atlas texture, for run-time glyph uploads. pub atlas_texture: Option, pipeline: wgpu::RenderPipeline, @@ -1311,7 +1357,7 @@ impl HudRenderer { }); Ok(Self { atlas_texture: None, - fire_animations: Vec::new(), + sprite_animations: Vec::new(), pipeline, invert_pipeline, additive_pipeline, @@ -1324,7 +1370,7 @@ impl HudRenderer { capacity, }) } - pub fn animate_fire( + pub fn animate_sprites( &mut self, uploads: &mut crate::gfx::upload::Uploads, encoder: &mut wgpu::CommandEncoder, @@ -1333,13 +1379,31 @@ impl HudRenderer { let Some(texture) = &self.atlas_texture else { return; }; - for (rect, animation, previous) in &mut self.fire_animations { - let frame = animation.frame(tick); - if frame == *previous { + for (rect, animation, previous) in &mut self.sprite_animations { + // `SpriteContents.AnimationState`: the frame from the mcmeta's + // list, blended into the next one by the sub-frame's thousandths + // when the sprite interpolates. + let blend = animation.blend(tick); + let state = (blend.frame, blend.next, blend.millis); + if state == *previous { continue; } let (w, h) = rect.texels((texture.width(), texture.height())); - let pixels = animation.resized_pixels(frame, w, h); + let pixels = if blend.millis == 0 { + animation.resized_pixels(blend.frame, w, h) + } else { + let current = animation.resized_pixels(blend.frame, w, h); + let next = animation.resized_pixels(blend.next, w, h); + let millis = blend.millis; + current + .iter() + .zip(next) + .map(|(&a, b)| { + ((u32::from(a) * (1000 - millis) + u32::from(b) * millis + 500) / 1000) + as u8 + }) + .collect() + }; uploads.texture( encoder, wgpu::TexelCopyTextureInfo { @@ -1356,7 +1420,7 @@ impl HudRenderer { h, &pixels, ); - *previous = frame; + *previous = state; } } /// Stage the batch's atlas patches, vertices and uniform: before the @@ -1522,6 +1586,80 @@ impl HudRenderer { mod tests { use super::*; + /// Write a PNG `width x height` whose `frames` stacked rows are solid + /// colours, then its mcmeta beside it. + fn write_strip(path: &Path, width: u32, height: u32, frames: &[[u8; 4]], mcmeta: Option<&str>) { + let file = std::io::BufWriter::new(fs::File::create(path).unwrap()); + let mut encoder = png::Encoder::new(file, width, height); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + let mut writer = encoder.write_header().unwrap(); + let mut pixels = Vec::with_capacity((width * height * 4) as usize); + for frame in frames { + let rows = height / frames.len() as u32; + pixels.extend((0..width * rows).flat_map(|_| *frame)); + } + writer.write_image_data(&pixels).unwrap(); + writer.finish().unwrap(); + if let Some(mcmeta) = mcmeta { + let meta = path.with_extension("png.mcmeta"); + fs::write(meta, mcmeta).unwrap(); + } + } + /// A resource root holding one animated block texture: a strip of two + /// 16x16 frames, red then blue, whose mcmeta starts on the blue one. + fn animated_root() -> PathBuf { + let root = std::env::temp_dir().join(format!("horizon-atlas-anim-{}", std::process::id())); + let block = root.join("assets/minecraft/textures/block"); + fs::create_dir_all(&block).unwrap(); + write_strip( + &block.join("test_anim.png"), + 16, + 32, + &[[255, 0, 0, 255], [0, 0, 255, 255]], + Some(r#"{"animation": {"frames": [1, 0]}}"#), + ); + root + } + fn texel_at(atlas: &HudAtlas, rect: Rect, x: u32, y: u32) -> [u8; 4] { + let px = (rect.u0 * atlas.width as f32).round() as u32 + x; + let py = (rect.v0 * atlas.height as f32).round() as u32 + y; + let at = ((py * atlas.width + px) * 4) as usize; + atlas.pixels[at..at + 4].try_into().unwrap() + } + #[test] + fn animated_block_sprites_register_and_pack_their_first_mcmeta_frame() { + let root = animated_root(); + let atlas = HudAtlas::build(&root).unwrap(); + let (rect, animation) = atlas + .sprite_animations + .iter() + .find(|(_, animation)| animation.frame_count() == 2) + .expect("the animated block sprite"); + // The mcmeta's list starts on the strip's second (blue) frame. + assert_eq!(animation.frame(0), 1); + assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16)); + assert_eq!(texel_at(&atlas, *rect, 0, 0), [0, 0, 255, 255]); + assert_eq!(texel_at(&atlas, *rect, 15, 15), [0, 0, 255, 255]); + } + #[test] + fn a_strip_frames_size_comes_from_its_mcmeta() { + let root = animated_root(); + let block = root.join("assets/minecraft/textures/block"); + // A row of two frames with the animation's own frame size. + write_strip( + &block.join("test_row.png"), + 32, + 16, + &[[0, 255, 0, 255], [255, 255, 0, 255]], + Some(r#"{"animation": {"width": 16, "height": 16}}"#), + ); + let atlas = HudAtlas::build(&root).unwrap(); + let rect = atlas.sprites["block/test_row"]; + // The first frame is the left 16x16, not the whole row. + assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16)); + assert_eq!(texel_at(&atlas, rect, 0, 0), [0, 255, 0, 255]); + } /// `count` images of `w x h`; layout reads only their sizes. fn sized(count: usize, w: u32, h: u32) -> Vec { (0..count) diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 4b0f2fa82..efdb2747b 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -485,6 +485,16 @@ pub struct HealthHud { /// `Util.getMillis()` of the last health change. pub last_health_time: i64, pub health_blink_time: i64, + /// `Hud.leftHeight` and `rightHeight` once the health, armor, food, mount + /// and air layers have run; the selected item name and the action bar sit + /// above them. + pub left_height: i32, + pub right_height: i32, + /// `Hud.lastBubblePopSoundPlayed`. + pub last_bubble_pop_sound: i32, + /// The `ui.hud.bubble_pop` volume and pitch `playAirBubblePoppedSound` + /// asked for this frame; the caller plays it and clears it. + pub bubble_pop_sound: Option<(f32, f32)>, } pub struct HealthInputs { @@ -645,6 +655,9 @@ impl HealthHud { let rows = ceil((max_health + absorption as f32) / 2.0 / 10.0); let row_height = (10 - (rows - 2)).max(3); let mut y_air = y_base - 10; + self.left_height = 39 + (rows - 1) * row_height + 10 + if i.armor > 0 { 10 } else { 0 }; + // The mount's heart rows (`extractVehicleHealth`); food adds its row below. + self.right_height = 39 + 10 * ((i.vehicle_hearts + 9) / 10); let offset_index = if i.regeneration { i.tick % ceil(max_health + 5.0) } else { @@ -739,11 +752,13 @@ impl HealthHud { } } y_air -= 10; + self.right_height += 10; } // Hud.extractAirBubbles. let max_air = i.max_air.max(1); let air = i.air.clamp(0, max_air); if i.under_water || air < max_air { + self.right_height += 10; let rows = (f64::from(i.vehicle_hearts) / 10.0).ceil() as i32; let y = y_air - (rows - 1) * 10; let bubble = |offset: i32| ceil(((air + offset) * 10) as f32 / max_air as f32); @@ -751,12 +766,22 @@ impl HealthHud { let popping = bubble(0); let delay = i32::from(air != 0 && i.under_water); let empty = 10 - bubble(delay); + if !i.under_water { + self.last_bubble_pop_sound = 0; + } for b in 1..=10 { let x = x_right - (b - 1) * 8 - 9; if b <= full { out.push(sprite("hud/air", x, y, 9, 9)); } else if full != popping && b == popping && i.under_water { out.push(sprite("hud/air_bursting", x, y, 9, 9)); + // Hud.playAirBubblePoppedSound. + if self.last_bubble_pop_sound != b { + let volume = 0.5 + 0.1 * (empty - 3 + 1).max(0) as f32; + let pitch = 1.0 + 0.1 * (empty - 5 + 1).max(0) as f32; + self.bubble_pop_sound = Some((volume, pitch)); + self.last_bubble_pop_sound = b; + } } else if b > 10 - empty { let wobble = if empty == 10 && i.tick % 2 == 0 { next(2) diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index 8af2c2a0d..a5373cbf4 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -323,11 +323,13 @@ impl Titles { } } } - /// `Hud.extractOverlayMessage`. + /// `Hud.extractOverlayMessage`; `bar_height` is + /// `max(leftHeight, rightHeight)`. pub fn overlay_message( &self, w: i32, h: i32, + bar_height: i32, partial: f32, font: &Font, background: u32, @@ -343,9 +345,12 @@ impl Titles { let alpha = ((t * 255.0 / 20.0) as i32).min(255); if alpha > 0 { let message = message.resolve_legacy(); + // The bars' height plus the gap between the item name (59) and the + // overlay (68), at least the default level. + let y_shift = bar_height + (68 - 59); out.push(GuiDraw::Push(vec![PoseOp::Translate( (w / 2) as f32, - (h - 68) as f32, + (h - y_shift.max(68)) as f32, )])); let color = if self.overlay_animated { hsv_to_argb(t / 50.0, 0.7, 0.6, alpha as u32) @@ -463,11 +468,13 @@ impl ToolHighlight { self.last = selected; } /// `Hud.extractSelectedItemName`; `can_hurt` is - /// `gameMode.canHurtPlayer()` (survival and adventure). + /// `gameMode.canHurtPlayer()` (survival and adventure) and `bar_height` + /// is `max(leftHeight, rightHeight)`. pub fn draw( &self, w: i32, h: i32, + bar_height: i32, can_hurt: bool, font: &Font, background: u32, @@ -488,7 +495,7 @@ impl ToolHighlight { } let str_width = width(font, &name); let x = (w - str_width) / 2; - let mut y = h - 59; + let mut y = h - bar_height.max(59); if !can_hurt { y += 14; } diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs index 1bd80437f..f5ff99939 100644 --- a/crates/horizon-client/src/item_data.rs +++ b/crates/horizon-client/src/item_data.rs @@ -106,6 +106,16 @@ impl StackData { pub fn other(&self, id: &str) -> Option<&Tag> { self.other.iter().find(|(k, _)| k == id).map(|(_, v)| v) } + /// `SetNameFunction.run`: a loot text component stored as `custom_name` + /// (plain text, as modelled) or as the unmodelled `item_name`. + pub fn set_loot_name(&mut self, id: &str, text: &serde_json::Value) { + let tag = crate::scoreboard::json_to_tag(text); + if id == "minecraft:custom_name" { + self.custom_name = read_text(&tag); + } else { + self.set_other(id, Some(tag)); + } + } /// Set (or with None remove) an unmodelled component. pub fn set_other(&mut self, id: &str, value: Option) { self.other.retain(|(k, _)| k != id); @@ -429,6 +439,11 @@ fn template_from(tag: &Tag) -> Option { } } } +/// The stack a `show_item` hover event holds (`HoverEvent.ShowItem`): its +/// `{id, count?, components?}` object. +pub fn stack_from_hover(event: &serde_json::Value) -> Option { + template_from(&crate::scoreboard::json_to_tag(event)) +} /// Sorted-key, type-annotated text of a tag (the differential harnesses /// print the same form from the vanilla side). pub fn canon_tag(tag: &Tag) -> String { diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs index 107da9208..f8fb3af8c 100644 --- a/crates/horizon-client/src/item_render.rs +++ b/crates/horizon-client/src/item_render.rs @@ -12,7 +12,7 @@ mod special; use crate::{ block_entity_render::{ModelPart, diffuse}, hud::Rect, - mesher::Vertex, + mesher::{CULL_BACK, Vertex}, }; use glam::{Mat3, Mat4, Vec3}; use horizon_assets::{ @@ -49,6 +49,8 @@ pub struct ItemQuad { pub foil: Foil, /// `MaterialInfo.lightEmission` (block light floor). pub light_emission: u8, + /// The render type culls back faces (`entitySolid`): world drawing discards them. + pub cull_back: bool, /// The quad's sprite has translucent pixels (`MaterialInfo.itemRenderType` /// is a translucent sheet): drawn with the translucent entities. pub translucent: bool, @@ -307,6 +309,7 @@ fn submit_quads( color: argb(color), foil, light_emission: q.light_emission, + cull_back: false, translucent: translucent || q.material.force_translucent, }); } @@ -787,7 +790,7 @@ impl ItemSink for WorldSink<'_> { for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() { let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.uv(q.foil_uv[i])); self.out.push(Vertex { - normal: [0; 4], + normal: if q.cull_back { CULL_BACK } else { [0; 4] }, pos: p.to_array(), uv, layer: overlay, diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs index a99969679..1ae908db6 100644 --- a/crates/horizon-client/src/item_render/gui.rs +++ b/crates/horizon-client/src/item_render/gui.rs @@ -377,6 +377,7 @@ mod tests { color, foil: Foil::None, light_emission: 0, + cull_back: false, translucent: false, } } diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs index 6a1d049af..1bc7cb12e 100644 --- a/crates/horizon-client/src/item_render/special.rs +++ b/crates/horizon-client/src/item_render/special.rs @@ -65,6 +65,17 @@ pub(super) fn load_parts(root: &Path) -> HashMap { .collect() } +/// Marks every quad passed on as drawn with a back-face-culling render type (`entitySolid`). +struct CullBack<'a>(&'a mut dyn ItemSink); +impl ItemSink for CullBack<'_> { + fn quad(&mut self, quad: ItemQuad) { + self.0.quad(ItemQuad { + cull_back: true, + ..quad + }); + } +} + /// A pose override for a named part (`setupAnim`). type Adjust<'a> = &'a dyn Fn(&str, &mut [f32; 9]); fn none(_: &str, _: &mut [f32; 9]) {} @@ -120,6 +131,7 @@ fn draw( color, foil, light_emission: 0, + cull_back: false, translucent: false, }); } @@ -571,6 +583,8 @@ pub(super) fn submit( } SpecialKind::DecoratedPot => { let sides = pot_sides(argument); + // `DecoratedPotRenderer` draws every part with `entitySolid`. + let sink = &mut CullBack(sink); if let Some(base) = renderer.part("decorated_pot_base") && let Some(r) = sprites .get("entity/decorated_pot/decorated_pot_base") @@ -674,4 +688,51 @@ mod tests { ); } } + /// `DecoratedPotRenderer` draws every part with `RenderTypes.entitySolid`, + /// whose pipeline culls back faces: the pot's flat `top` and `bottom` + /// planes would otherwise show both sides and z-fight in the hand too. + #[test] + fn the_decorated_pot_item_culls_its_back_faces() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("entity-models.json").exists() { + return; + } + let renderer = ItemRenderer::load(&root).unwrap(); + let sprite = Rect { + u0: 0.25, + v0: 0.125, + u1: 0.375, + v1: 0.25, + w: 16, + h: 16, + }; + let sprites: HashMap = [ + "entity/decorated_pot/decorated_pot_base", + "entity/decorated_pot/decorated_pot_side", + ] + .into_iter() + .map(|name| (name.to_owned(), sprite)) + .collect(); + let model = SpecialModel { + kind: SpecialKind::DecoratedPot, + }; + let mut quads: Vec = Vec::new(); + submit( + &renderer, + &model, + &Value::Null, + false, + Mat4::IDENTITY, + &sprites, + &super::super::NoHost, + &mut quads, + ); + assert!(!quads.is_empty(), "the pot item draws its parts"); + assert!( + quads.iter().all(|q| q.cull_back), + "entitySolid culls the pot's back faces" + ); + } } diff --git a/crates/horizon-client/src/item_sync.rs b/crates/horizon-client/src/item_sync.rs index 01d90246f..bc2b54e26 100644 --- a/crates/horizon-client/src/item_sync.rs +++ b/crates/horizon-client/src/item_sync.rs @@ -95,6 +95,22 @@ fn components_tag(s: &Stack, builtin: &Builtin, synced: &Dynamic) -> Option ), ]), Component::FireworkExplosion(e) => fireworks_tag(e), + Component::LodestoneTracker { target, tracked } => { + let mut entries = Vec::new(); + if let Some((dimension, pos)) = target { + entries.push(( + "target", + Tag::compound([ + ("dimension", Tag::String(dimension.as_str().into())), + ("pos", Tag::IntArray(pos.to_vec())), + ]), + )); + } + if !tracked { + entries.push(("tracked", Tag::Byte(0))); + } + Tag::compound(entries) + } Component::Enchantments(list) => { // Enchantments are a synced (data-driven) registry: the // ids index the server's RegistryData, not the builtin diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 63a19b114..ce4fc352d 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -484,6 +484,37 @@ pub fn component_count(stack: &ItemStack, info: Option<&ItemInfo>) -> usize { keys.len() } +/// `SmithingTemplateItem.appendHoverText`: the template's kind, what it applies to +/// and its ingredients (gray titles over blue descriptions); none for other items. +pub fn smithing_template_lines( + stack: &ItemStack, + translate: &dyn Fn(&str) -> Option, +) -> Vec<(String, u32)> { + let path = stack.item.trim_start_matches("minecraft:"); + if !path.ends_with("_smithing_template") { + return Vec::new(); + } + let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); + let kind = if path == "netherite_upgrade_smithing_template" { + "netherite_upgrade" + } else { + "armor_trim" + }; + let (title, description) = (rgba(170, 170, 170, 255), rgba(85, 85, 255, 255)); + let described = |what: &str| { + let key = format!("item.minecraft.smithing_template.{kind}.{what}"); + (format!(" {}", text(&key)), description) + }; + vec![ + (text("item.minecraft.smithing_template"), title), + (String::new(), u32::MAX), + (text("item.minecraft.smithing_template.applies_to"), title), + described("applies_to"), + (text("item.minecraft.smithing_template.ingredients"), title), + described("ingredients"), + ] +} + /// The lines of `stack` below its name that its components give, in /// `ItemStack.addDetailsToTooltip` order. pub fn detail_lines( @@ -494,30 +525,11 @@ pub fn detail_lines( let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let path = stack.item.trim_start_matches("minecraft:"); let mut lines = Vec::new(); - // SmithingTemplateItem.appendHoverText. - if path.ends_with("_smithing_template") { - let kind = if path == "netherite_upgrade_smithing_template" { - "netherite_upgrade" - } else { - "armor_trim" - }; - lines.push(text("item.minecraft.smithing_template")); - lines.push(String::new()); - lines.push(text("item.minecraft.smithing_template.applies_to")); - lines.push(format!( - " {}", - text(&format!( - "item.minecraft.smithing_template.{kind}.applies_to" - )) - )); - lines.push(text("item.minecraft.smithing_template.ingredients")); - lines.push(format!( - " {}", - text(&format!( - "item.minecraft.smithing_template.{kind}.ingredients" - )) - )); - } + lines.extend( + smithing_template_lines(stack, translate) + .into_iter() + .map(|l| l.0), + ); let display = TooltipDisplay::for_stack(stack); lines.extend(bees_line(stack, &display, translate)); lines.extend(honey_line(stack, &display, translate)); diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs index 10f1c72ad..bd818bd76 100644 --- a/crates/horizon-client/src/items.rs +++ b/crates/horizon-client/src/items.rs @@ -1154,6 +1154,8 @@ impl Items { ctx.evaluate(table, random) } } +/// `DataComponents.BLOCK_STATE`. +const BLOCK_STATE: &str = "minecraft:block_state"; impl LootContext<'_> { fn evaluate(&self, table: &Value, random: &mut R) -> Vec { let ctx = self; @@ -1561,6 +1563,30 @@ impl LootContext<'_> { } } } + // CopyBlockState: the listed properties of the broken block + // become the item's `block_state` component. + "minecraft:copy_state" => { + use horizon_world::nbt::Tag; + let mut copied = match stack.data().and_then(|d| d.other(BLOCK_STATE)) { + Some(Tag::Compound(c)) => c.clone(), + _ => Default::default(), + }; + for name in f["properties"] + .as_array() + .into_iter() + .flatten() + .filter_map(Value::as_str) + { + if let Some(value) = self.properties.get(name) { + copied.insert(name.into(), Tag::String(value.as_str().into())); + } + } + if !copied.is_empty() { + stack + .data_mut() + .set_other(BLOCK_STATE, Some(Tag::Compound(copied))); + } + } // ApplyExplosionDecay: each item survives with 1 / radius. "minecraft:explosion_decay" => { if let Some(radius) = self.explosion_radius { diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs index 920052b5a..19eda20a9 100644 --- a/crates/horizon-client/src/lan/entity.rs +++ b/crates/horizon-client/src/lan/entity.rs @@ -742,6 +742,24 @@ impl Entities { chunk, }); } + // TrackedEntity.getEffectiveRange: a vehicle is tracked as far as its + // widest indirect passenger, so a rider never leaves before its mount. + for (&vehicle, passengers) in &riding.passengers { + let Some(own) = self.states.get(&vehicle).filter(|s| s.seen == now) else { + continue; + }; + let (index, mut range) = (own.index, own.range); + let mut pending = passengers.clone(); + while let Some(id) = pending.pop() { + if let Some(s) = self.states.get(&id).filter(|s| s.seen == now) { + range = range.max(s.range); + } + pending.extend_from_slice(riding.passengers(id)); + } + self.probes[index].range = self + .range_percent + .map_or(range * 16, |p| p * (range * 16) / 100); + } self.flags.resize_with(viewers.len(), Vec::new); self.pairs.clear(); self.pairs.resize(entities.len(), false); diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 9f83e1457..cc53eeaed 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -215,7 +215,7 @@ pub struct Guest { /// last sent about itself. pub sent_shared: i8, /// Where the player last died (Player.lastDeathLocation), sent with the respawn. - pub last_death: Option<[i32; 3]>, + pub last_death: Option<(String, [i32; 3])>, /// The last action sequence to acknowledge at the next tick (-1: none). pub ack_up_to: std::cell::Cell, pub sent_selected: usize, @@ -614,6 +614,21 @@ fn network_stack( )); } stack.added.extend(firework_components(d)); + // The compass's lodestone target. + if let Some(t) = d.other("minecraft:lodestone_tracker") { + let target = t.get("target").and_then(|g| { + let Some(horizon_world::nbt::Tag::IntArray(pos)) = g.get("pos") else { + return None; + }; + let dimension = crate::save::text(g.get("dimension"))?; + Some((dimension, [*pos.first()?, *pos.get(1)?, *pos.get(2)?])) + }); + let tracked = crate::save::number(t.get("tracked")).is_none_or(|v| v != 0); + stack.added.push(( + horizon_protocol::item::component::LODESTONE_TRACKER, + horizon_protocol::item::Component::LodestoneTracker { target, tracked }, + )); + } // PotionContents: the potion by its `minecraft:potion` id. if let Some(id) = (d.potion.as_deref()).and_then(|potion| { synced_id( diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 12967d778..8f1845de1 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -178,6 +178,9 @@ pub struct Hub { /// An integrated server's owner (`MinecraftServer.isSingleplayerOwner`), /// whose moves are never checked. pub singleplayer_owner: Option, + /// The world is superflat (`ServerLevel.isFlat`, a world-wide flag, sent as + /// `CommonPlayerSpawnInfo.isFlat` in every dimension). + pub flat_world: bool, /// Who rides what, set by the game before each tick. pub riding: super::entity::Riding, /// The scoreboard's teams, set by the game each tick, for players' @@ -196,6 +199,9 @@ pub struct Hub { pub ops: std::collections::HashMap, /// `entity-broadcast-range-percentage` (dedicated servers). pub entity_range_percent: i32, + /// `spawn-protection` (dedicated servers): the radius around the world + /// spawn that only operators may change. + pub spawn_protection: i32, chat_type: i32, dimension_type: i32, clock_ids: Vec, @@ -358,6 +364,7 @@ impl Hub { immediate_respawn: false, movement_checks: (true, true), singleplayer_owner: None, + flat_world: false, riding: Default::default(), last_clock: i64::MIN, last_rate: 0.0, @@ -365,6 +372,7 @@ impl Hub { stepping: 0, ops: Default::default(), entity_range_percent: 100, + spawn_protection: 0, weather: (false, 0.0, 0.0), level_sync: Default::default(), chat_type, @@ -485,6 +493,13 @@ impl Hub { overlay: false, })); } + /// `ServerPlayer.sendOverlayMessage` to every guest (the action bar). + pub fn overlay_message(&self, content: Tag) { + self.broadcast(&C::SystemChat(play::SystemChat { + content, + overlay: true, + })); + } /// A chat message from the host (a disguised chat: the host has no /// connection to sign with). pub fn chat(&self, sender: &str, text: &str) { @@ -602,16 +617,24 @@ impl Hub { // ---- joining ------------------------------------------------------- - fn spawn_info(&self, game_mode: i32) -> play::SpawnInfo { + fn spawn_info(&self, i: usize) -> play::SpawnInfo { + let g = &self.guests[i]; play::SpawnInfo { dimension_type: self.dimension_type, dimension: self.config.dimension.clone(), seed: horizon_core::biome::obfuscate_seed(self.config.seed), - game_type: game_mode, + game_type: g.game_mode, previous_game_type: None, debug: false, - flat: false, - last_death: None, + flat: self.flat_world, + // Player.getLastDeathLocation. + last_death: g + .last_death + .as_ref() + .map(|(dimension, pos)| play::GlobalPos { + dimension: dimension.clone(), + pos: *pos, + }), portal_cooldown: 0, sea_level: 63, } @@ -680,7 +703,7 @@ impl Hub { reduced_debug_info: false, show_death_screen: !self.immediate_respawn, limited_crafting: false, - spawn: self.spawn_info(mode), + spawn: self.spawn_info(i), // MinecraftServer.usesAuthentication, enforceSecureProfile. online_mode: self.lan.shared.config.online.is_some(), enforces_secure_chat: self.enforces_secure_chat(), @@ -2516,14 +2539,7 @@ impl Hub { /// level loading screen from the Respawn packet until the level info's "level chunks load /// start" event and the chunk under the player, so the packets follow vanilla's order. pub fn respawn(&mut self, i: usize, at: [f64; 3], ctx: &TickCtx) { - let mode = self.guests[i].game_mode; - let mut info = self.spawn_info(mode); - // Player.getLastDeathLocation, set where the player died. - // The level they died in: theirs until now. - info.last_death = self.guests[i].last_death.map(|pos| play::GlobalPos { - dimension: self.guests[i].dimension.clone(), - pos, - }); + let info = self.spawn_info(i); self.close_container_for(i); let g = &mut self.guests[i]; // PlayerList.respawn: into the level in place (the respawn level). @@ -2636,8 +2652,7 @@ impl Hub { portal_sound: bool, ctx: &TickCtx, ) { - let mode = self.guests[i].game_mode; - let info = self.spawn_info(mode); + let info = self.spawn_info(i); self.close_container_for(i); let g = &mut self.guests[i]; g.dimension = self.config.dimension.clone(); @@ -2734,7 +2749,7 @@ fn ticking_state(rate: f32, frozen: bool) -> C { } /// What the others see of a guest's body, from its server-side state. -fn guest_body(g: &Guest) -> BodyFlags { +pub fn guest_body(g: &Guest) -> BodyFlags { let m = g.motion.as_deref(); BodyFlags { gliding: g.fall_flying, diff --git a/crates/horizon-client/src/lan/playerdata.rs b/crates/horizon-client/src/lan/playerdata.rs index f5eb935c9..af8f15bb4 100644 --- a/crates/horizon-client/src/lan/playerdata.rs +++ b/crates/horizon-client/src/lan/playerdata.rs @@ -86,6 +86,7 @@ pub fn apply(guest: &mut Guest, level: &Level) { guest.respawn_elsewhere = level.respawn_elsewhere.clone(); guest.saved = level.player_extra.clone(); guest.seen_credits = level.seen_credits; + guest.last_death = level.last_death.clone(); let extra = level.player_extra.as_ref(); let short = |key: &str, default: i64| { extra @@ -168,6 +169,7 @@ pub fn store(guest: &Guest, level: &mut Level) { level.respawn_elsewhere = guest.respawn_elsewhere.clone(); level.on_ground = guest.on_ground; level.seen_credits = guest.seen_credits; + level.last_death = guest.last_death.clone(); level.player_extra = guest.saved.clone(); // The live body's fire, air and fall distance (Entity.saveWithoutId), // or what the file had while the player has no body yet. diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 4082c0b0c..5ff582455 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -169,6 +169,7 @@ pub mod skins; pub mod sound_engine; pub mod sound_events; pub mod spans; +pub mod spear; pub mod sprint; pub mod sprites; pub mod stations; diff --git a/crates/horizon-client/src/main.rs b/crates/horizon-client/src/main.rs index 7144a1670..8d03455af 100644 --- a/crates/horizon-client/src/main.rs +++ b/crates/horizon-client/src/main.rs @@ -23,6 +23,8 @@ fn main() { }; if !help { logging::init(&home, thread); + // The log's first line names the build, so a bug report that carries the log says which one it was. + log::info!("Horizon {}", crash::version()); crash::install(home.clone(), side); } if let Err(error) = game::run() { diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 7594e7e31..491e70366 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -36,11 +36,15 @@ pub struct Vertex { pub color: u32, /// Smooth light, 16x fixed point: sky in bits 0..8, block in bits 8..16. pub light: u32, - /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour. + /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour, + /// [`CULL_BACK`] to keep it and also drop back-facing pixels. pub normal: [i8; 4], /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere. pub glint_uv: [f32; 2], } +/// `Vertex::normal` of a baked-colour quad of an `entitySolid` model: the render type culls +/// back faces, which the entity pipelines here do not, so `entity.wgsl` discards them. +pub const CULL_BACK: [i8; 4] = [0, 0, 0, 1]; /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour, /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes /// rather than vanilla's 28: the UV is fixed point, which holds model UVs @@ -57,7 +61,7 @@ pub struct TerrainVertex { /// UV within the sprite, `UV_STEPS` per unit (`TerrainVertex::new`, /// `terrain.wgsl`'s `terrain_uv`). pub(crate) uv: [u16; 2], - /// Sprite array layer, with `OPAQUE_LAYER` for opaque leaves. + /// Sprite array layer, with `OPAQUE_LAYER` for opaque leaves and quads over opaque texels. pub layer: u16, /// Smooth light, 16x fixed point: sky in the low byte, block in the high one. pub light: u16, @@ -892,8 +896,9 @@ impl Mesher<'_> { target.push(TerrainVertex::new( [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]], q.uv[i], - // Opaque leaves (forceOpaque) draw in the solid layer: no alpha cutout. - if !self.cutout_leaves && state.leaves { + // Opaque leaves (forceOpaque) and quads over opaque texels draw in the + // solid layer: no alpha cutout (a dirt path's side skips its clear top row). + if face.opaque && !face.translucent || !self.cutout_leaves && state.leaves { face.layer as u16 | OPAQUE_LAYER } else { face.layer as u16 diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index f4ab3f834..29e9313f1 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -11,6 +11,7 @@ pub mod ambient; pub mod anim; pub mod animal_brain; pub mod aquatic; +pub mod armadillo; pub mod axolotl; pub mod bat; pub mod bee; @@ -25,14 +26,18 @@ pub mod creaking; pub mod creaking_heart; pub mod cube; pub mod data; +pub mod dolphin; pub mod doors; pub mod drops; pub mod enderman; pub mod equine; pub mod farm; pub mod finalize; +pub mod fox; +pub mod frog; pub mod gear; pub mod goals; +pub mod goat; pub mod golem; pub mod guardian; pub mod happy_ghast; @@ -47,6 +52,8 @@ pub mod monster_brain; pub mod nautilus; pub mod nav; pub mod nether; +pub mod panda; +pub mod parrot; pub mod path; pub mod phantom; pub mod piglin; @@ -508,6 +515,8 @@ pub enum DamageKind { PlayerAttack, /// `mace_smash`: a mace hit after a fall (the player attack tags too). MaceSmash, + /// `spear`: a stab of a spear (the player attack tags too). + Spear, MobAttack, Arrow, Thrown, @@ -524,6 +533,8 @@ pub enum DamageKind { Magic, Sting, Cactus, + /// `sweet_berry_bush`. + SweetBerryBush, Generic, InWall, Thorns, @@ -570,6 +581,14 @@ impl Damage { from: Some(from), } } + /// `DamageSources.spear`: a player's stab with a spear. + pub fn spear(from: [f64; 3]) -> Self { + Self { + kind: DamageKind::Spear, + attacker: Some(Who::Player), + from: Some(from), + } + } pub fn mob(id: u32, from: [f64; 3]) -> Self { Self { kind: DamageKind::MobAttack, @@ -586,6 +605,7 @@ impl Damage { | DamageKind::DryOut | DamageKind::Generic | DamageKind::InWall + | DamageKind::SweetBerryBush ) } /// DamageTypeTags.BYPASSES_ARMOR @@ -622,6 +642,7 @@ impl Damage { | DamageKind::DryOut | DamageKind::Magic | DamageKind::Cactus + | DamageKind::SweetBerryBush | DamageKind::Generic | DamageKind::InWall | DamageKind::Freeze @@ -646,6 +667,8 @@ pub struct Attrs { pub spawn_reinforcements: f64, pub jump_strength: f64, } +/// `minecraft:wolf_armor`'s maximum damage. +pub const WOLF_ARMOR_DURABILITY: i32 = 64; /// Species-specific persistent state (variants, colours, taming, ageing...). #[derive(Clone, Debug, Default)] pub struct Extra { @@ -679,6 +702,10 @@ pub struct Extra { /// `Mob.canPickUpLoot` (also lets dispensers equip it). pub pick_up_loot: bool, pub saddled: bool, + /// The durability a wolf's body armor (`extra.head`) has lost. + pub body_damage: i32, + /// The components (dye, name...) of that armor stack. + pub body_extra: Option>, /// The saddle's components (name, enchantments...) when it is not a bare /// one; `saddled` stays the gameplay flag. pub saddle_stack: Option, @@ -689,6 +716,8 @@ pub struct Extra { pub inventory: Vec, pub tame: bool, pub sitting: bool, + /// `Parrot.partyParrot` and `jukebox`: the playing jukebox it dances to. + pub party_jukebox: Option<[i32; 3]>, /// The owner's UUID (tamed animals). pub owner: Option<[i32; 4]>, /// Slime/magma cube size (0 = not sized). @@ -699,7 +728,6 @@ pub struct Extra { pub anger: i32, pub carried: Option, pub charged: bool, - pub levitation: i32, /// Held item ids (main hand, off hand) and head item. pub main_hand: Option>, pub off_hand: Option>, @@ -713,6 +741,8 @@ pub struct Extra { pub blocking: bool, pub fall_flying: bool, pub fall_fly_ticks: i32, + /// `Entity.DATA_POSE` of another player, as the server sent it. + pub synced_pose: u8, /// `LivingEntity.isAutoSpinAttack` (Riptide). pub auto_spin_attack: bool, pub main_hand_left: bool, @@ -797,6 +827,8 @@ pub struct Extra { /// A goat's `IsScreamingGoat` and the horns it lost (left, right). pub screaming: bool, pub lost_horns: [bool; 2], + /// A goat's lowered head and ram behaviours. + pub goat: goat::State, /// Attribute bases and permanent modifiers set by `finalizeSpawn`. pub attributes: Option>, /// Brain memories `finalizeSpawn` sets: (memory, value, ticks to expiry). @@ -812,6 +844,12 @@ pub struct Extra { pub brain: Option>, /// A bee's nectar, anger, flower and hive state. pub bee: Option>, + /// An armadillo's state and scare brain. + pub armadillo: armadillo::State, + /// A frog's brain memories and tongue target. + pub frog: frog::State, + /// A panda's flags, counters and amounts. + pub panda: Option>, } #[derive(Clone, Debug)] pub struct Mob { @@ -848,6 +886,8 @@ pub struct Mob { pub previous_swell: i32, pub ambient_timer: i32, pub fall_distance: f64, + /// `Entity.stuckSpeedMultiplier`: the next move is scaled by it. + pub stuck_multiplier: Vec3, /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving /// block has pushed this mob this tick (0.51 at most on any axis). pub piston: horizon_world::piston_movement::PistonMovement, @@ -929,6 +969,16 @@ pub enum MobEvent { event: i8, at: [f64; 3], }, + /// `ServerLevel.sendParticles`: drawn here and sent to the players within + /// 32 blocks, which spread and speed the way the client does for a count + /// (a count of 0 is one particle moving by speed times spread). + LevelParticles { + kind: &'static str, + at: [f64; 3], + spread: [f64; 3], + speed: f64, + count: u32, + }, Sound(&'static str, [f64; 3], f32, f32), /// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the /// chest's opener count goes up or down (interaction range 3). @@ -942,6 +992,11 @@ pub enum MobEvent { mob: u32, hive: [i32; 3], }, + /// `LandOnOwnersShoulderGoal`: a tame parrot touched its owner and sits + /// on their shoulder (the host stores its tag and discards it). + ParrotToShoulder { + mob: u32, + }, /// `CopperGolem.turnToStatue`. BecomeStatue { mob: u32, @@ -998,6 +1053,16 @@ pub enum MobEvent { state: horizon_world::registry::BlockStateId, }, AttackPlayer(f32, [f64; 3]), + /// A melee hit whose effect comes only if the hit lands (husk hunger, + /// cave spider poison, wither skeleton wither, bee and pufferfish + /// poison): a shield-blocked hit gives nothing. + AttackPlayerWithEffect { + amount: f32, + from: [f64; 3], + effect: &'static str, + ticks: i32, + amplifier: i32, + }, /// Damage of a given type to the player (guardian lasers, thorns). DamagePlayer { amount: f32, @@ -1013,6 +1078,15 @@ pub enum MobEvent { target: Who, velocity: [f64; 3], }, + /// `SonicBoom`: 10 damage to the target, then a push along `direction` + /// (the unit vector from the warden's chest to the target's eyes) only + /// if the hit landed, less the target's knockback resistance. + SonicBoom { + target: Who, + attacker: u32, + from: [f64; 3], + direction: [f64; 3], + }, /// `Entity.move(MoverType.SHULKER, delta)`: shift a target's position /// (an opening shulker lifts what stands on its shell). Shift { @@ -1048,11 +1122,25 @@ pub enum MobEvent { amount: f32, source: Damage, }, + /// `LivingEntity.knockback(power, x, z)`: pushed away from the direction. + Knockback { + target: Who, + power: f64, + x: f64, + z: f64, + }, /// Set another mob's attack target (HurtByTargetGoal alerts). SetTarget { mob: u32, target: Who, }, + /// `StartHuntingHoglin` for a nearby adult piglin: it takes the hoglin as + /// its anger target (when it has none) and starts its `HUNTED_RECENTLY` wait. + HuntHoglin { + mob: u32, + target: u32, + ticks: i32, + }, Projectile(crate::projectiles::Projectile), /// Spawn a new mob (breeding, slime splitting, chicken eggs...). Spawn(Box), @@ -1095,6 +1183,14 @@ pub enum MobEvent { pos: [i32; 3], data: i32, }, + /// `InfestedBlock.infestedStateByHost` (`infested`) or `hostStateByInfested` + /// for the block there, keeping its axis; `poof` is the silverfish that + /// hid in it (`spawnAnim`). + Infest { + pos: [i32; 3], + infested: bool, + poof: Option, + }, /// Destroy a block, dropping nothing (sheep eating grass becomes dirt via SetBlock). BreakBlock { pos: [i32; 3], @@ -1128,6 +1224,12 @@ pub enum MobEvent { }, /// Regeneration support after an axolotl-assisted kill. AxolotlSupportPlayer, + /// A dolphin that was given a fish asks the game for the nearest + /// shipwreck or ocean ruin (`DolphinSwimToTreasureGoal.start`): the game + /// sets the dolphin's `extra.home` to it, or leaves it empty. + DolphinTreasure { + mob: u32, + }, /// Apply an effect to the player (witch potions, bee stings, cave spider poison). EffectPlayer { effect: &'static str, @@ -1291,6 +1393,10 @@ pub enum MobEvent { center: [f64; 3], spread: [f64; 3], }, + /// `Panda.afterSneeze`: the grown pandas within 10 blocks start. + PandaSneezed { + mob: u32, + }, } /// How a spawned-by-kind mob should be set up. #[derive(Clone, Debug, Default)] @@ -1324,10 +1430,14 @@ pub struct Seen { pub baby: bool, pub in_love: bool, pub tame: bool, + /// A tamed animal's owner (`getOwner`). + pub owner: Option<[i32; 4]>, pub hostile: bool, pub target: Option, pub health: f32, pub variant: u8, + /// A slime's or magma cube's size. + pub size: i32, /// Dye colour (sheep). pub color: u8, /// A villager's claimed job site and bed. @@ -1371,10 +1481,16 @@ pub struct Seen { pub stats: [f64; 3], /// `Wolf.isInSittingPose`. pub sitting: bool, + /// `Entity.isSilent`. + pub silent: bool, /// `Entity.isVehicle` or `isPassenger`. pub ridden: bool, + /// `Attributes.KNOCKBACK_RESISTANCE`. + pub knockback_resistance: f64, /// The active effects, without namespace (`slowness`, `poison`...). pub effects: Vec<&'static str>, + /// A piglin's `HUNTED_RECENTLY` memory. + pub hunted_recently: bool, } impl Seen { /// `LivingEntity.hasEffect`, by id without namespace. @@ -1425,10 +1541,12 @@ impl Mob { m.extra.in_love > 0 }, tame: m.extra.tame, + owner: m.extra.owner, hostile: m.hostile(), target: m.ai.target, health: m.health, variant: m.extra.variant, + size: m.extra.size, color: m.extra.color, job: villager.then_some(m.extra.home).flatten(), bed: villager.then_some(m.extra.bed).flatten(), @@ -1459,13 +1577,16 @@ impl Mob { m.attrs.speed, ], sitting: m.extra.sitting, + silent: m.silent, ridden: m.rider.is_some() || m.extra.rider.is_some() || m.extra.mount.is_some(), + knockback_resistance: m.attrs.knockback_resistance, effects: m .extra .effects .iter() .map(|e| e.0.trim_start_matches("minecraft:")) .collect(), + hunted_recently: m.species() == Species::Piglin && m.extra.ints[0] > 0, } } /// `EntityType.getCategory`'s name. @@ -1594,6 +1715,8 @@ pub struct PlayerView { pub alive: bool, pub creative: bool, pub sneaking: bool, + /// `Entity.isSwimming`. + pub swimming: bool, pub look: [f64; 3], pub main_hand: Option>, pub off_hand: Option>, @@ -1610,6 +1733,9 @@ pub struct PlayerView { pub last_hurt: Option<(Who, i64)>, pub velocity: Vec3, pub yaw: f32, + /// `Player.isSprinting` and `isPassenger` (what scares an armadillo). + pub sprinting: bool, + pub riding: bool, /// The Hero of the Village effect. pub hero: bool, /// The active effects, without namespace (`slowness`, `poison`...). @@ -1673,7 +1799,8 @@ pub struct MobWorld<'a> { pub mob_griefing: bool, /// The `mob_drops` game rule (`shouldDropLoot`). pub mob_drops: bool, - /// `getCurrentDifficultyAt` near the player. + /// `getCurrentDifficultyAt` at the mob being ticked (near the player + /// outside the mob tick). pub difficulty: spawning::LocalDifficulty, /// The End (its dimension type's monster spawn light rules). pub end: bool, @@ -1741,6 +1868,7 @@ impl Mob { // Mob.ambientSoundTime starts at 0. ambient_timer: 0, fall_distance: 0.0, + stuck_multiplier: Vec3::ZERO, piston: Default::default(), persistent: false, random, @@ -1813,13 +1941,17 @@ impl Mob { } } pub fn bounds(&self) -> Aabb { + self.bounds_at(self.position) + } + /// `Entity.makeBoundingBox(position)`. + pub fn bounds_at(&self, position: Vec3) -> Aabb { let w = f64::from(self.width()) / 2.0; Aabb::new( - Vec3::new(self.position.x - w, self.position.y, self.position.z - w), + Vec3::new(position.x - w, position.y, position.z - w), Vec3::new( - self.position.x + w, - self.position.y + f64::from(self.height()), - self.position.z + w, + position.x + w, + position.y + f64::from(self.height()), + position.z + w, ), ) } @@ -1854,8 +1986,14 @@ impl Mob { /// the last-hurt-by bookkeeping goals read. /// The `armor` and `armor_toughness` modifiers of worn humanoid armour. pub fn worn_armor(&self) -> (f32, f32) { + // An equine keeps its horse armor in `extra.head`: the item's `armor` + // and `armor_toughness` modifiers of the body slot. if equine::is_equine(self.species()) { - return (0.0, 0.0); + return self + .extra + .head + .as_deref() + .map_or((0.0, 0.0), spawning::horse_armor_stats); } [ &self.extra.head, @@ -1896,6 +2034,9 @@ impl Mob { return false; } let mut amount = if reflected { 1000.0 } else { amount }; + if self.species() == Species::Armadillo { + amount = armadillo::reduce_damage(self, amount); + } if source.kind == DamageKind::FallingBlock && !species::body_slot(self.species()) && self.extra.head.is_some() @@ -1912,9 +2053,15 @@ impl Mob { amount *= 5.0; } let (worn, worn_toughness) = self.worn_armor(); - if !source.bypasses_armor() && self.kind.armor + worn > 0.0 { + // Shulker.setRawPeekAmount: a closed shell adds the covered armor modifier. + let covered = if self.species() == Species::Shulker && self.extra.counter == 0 { + 20.0 + } else { + 0.0 + }; + if !source.bypasses_armor() && self.kind.armor + worn + covered > 0.0 { // CombatRules.getDamageAfterAbsorb - let armor = self.kind.armor + worn; + let armor = self.kind.armor + worn + covered; let toughness = 2.0 + (self.kind.armor_toughness + worn_toughness) / 4.0; let effective = (armor - amount / toughness).clamp(armor * 0.2, 20.0); let mut fraction = effective / 25.0; @@ -1928,18 +2075,29 @@ impl Mob { if epf > 0.0 { amount *= 1.0 - epf / 25.0; } + // Wolf.actuallyHurt: wolf armor takes the damage instead of the wolf. + let absorbed = self.wolf_armor_absorbs(&source); let mut knock = true; if self.invulnerable as f32 > 10.0 { if amount <= self.last_hurt { return false; } - self.health -= amount - self.last_hurt; + let dealt = amount - self.last_hurt; + if absorbed { + self.hurt_wolf_armor(dealt); + } else { + self.health -= dealt; + } self.last_hurt = amount; knock = false; } else { self.last_hurt = amount; self.invulnerable = 20; - self.health -= amount; + if absorbed { + self.hurt_wolf_armor(amount); + } else { + self.health -= amount; + } self.hurt_time = 10; } // Animal.actuallyHurt: damage taken ends love mode (`resetLove`). @@ -1970,7 +2128,12 @@ impl Mob { // playHurtSound (Mob: also resets the ambient sound clock) or the // death sound: makeSound draws the voice pitch whenever there is a sound. let dead = !self.alive(); - let sound = ai::voice_sounds(self)[if dead { 2 } else { 1 }]; + // Wolf.getHurtSound: the armor's own sound when it takes the hit. + let sound = if absorbed { + "item.wolf_armor.damage" + } else { + ai::voice_sounds(self)[if dead { 2 } else { 1 }] + }; if !dead { self.ambient_timer = -self.ambient_interval(); } @@ -1994,6 +2157,46 @@ impl Mob { } true } + /// `Wolf.canArmorAbsorb`: it wears wolf armor and the damage type is not + /// in `#bypasses_wolf_armor` (drowning, magic, thorns, in a wall, out of + /// the world and the untyped kills). + fn wolf_armor_absorbs(&self, source: &Damage) -> bool { + self.species() == Species::Wolf + && self.extra.head.as_deref() == Some("minecraft:wolf_armor") + && !matches!( + source.kind, + DamageKind::Drown + | DamageKind::Magic + | DamageKind::InWall + | DamageKind::Thorns + | DamageKind::OutOfWorld + | DamageKind::Generic + ) + } + /// `Wolf.actuallyHurt`: the armor loses `ceil(damage)` durability, cracks + /// at `Crackiness.WOLF_ARMOR` steps and breaks at its maximum. + fn hurt_wolf_armor(&mut self, damage: f32) { + let crack = |lost: i32| { + let left = (WOLF_ARMOR_DURABILITY - lost) as f32 / WOLF_ARMOR_DURABILITY as f32; + [0.95_f32, 0.69, 0.32].iter().filter(|t| left < **t).count() + }; + let before = self.extra.body_damage; + let after = before + damage.ceil() as i32; + let at = [self.position.x, self.position.y, self.position.z]; + if after >= WOLF_ARMOR_DURABILITY { + self.extra.head = None; + self.extra.body_damage = 0; + self.extra.body_extra = None; + self.outbox + .push(MobEvent::Sound("item.wolf_armor.break", at, 1.0, 1.0)); + } else { + self.extra.body_damage = after; + if crack(before) != crack(after) { + self.outbox + .push(MobEvent::Sound("item.wolf_armor.crack", at, 1.0, 1.0)); + } + } + } /// LivingEntity.knockback(power, xd, zd) towards the negative direction. pub fn knockback(&mut self, power: f64, mut xd: f64, mut zd: f64) { let power = power * (1.0 - self.attrs.knockback_resistance); @@ -2042,8 +2245,10 @@ impl Mob { /// Movement speed attribute bonus (baby zombies, sprinting modifiers). /// MOVEMENT_SPEED including effects (speed +20%/level, slowness -15%/level). pub fn movement_speed(&self) -> f64 { - let mut v = strider::movement_speed(self, witch::speed(self, self.attrs.speed)) - * self.speed_bonus(); + let mut v = strider::movement_speed( + self, + witch::speed(self, self.attrs.speed) + enderman::attacking_speed(self), + ) * self.speed_bonus(); for (e, _, amp) in &self.extra.effects { match *e { "minecraft:speed" => v *= 1.0 + 0.2 * f64::from(amp + 1), @@ -2435,6 +2640,25 @@ impl SwimAnimation { } } +impl Mob { + /// The part of `LivingEntity.tick` and `aiStep` that animates another + /// player from its synched pose and flags: the glide count, the wings + /// (`elytraAnimationState`) and the swim amount (`updateSwimAmount`). + pub fn tick_avatar_pose(&mut self, in_water: bool) { + let e = &mut self.extra; + e.fall_fly_ticks = if e.fall_flying { + e.fall_fly_ticks + 1 + } else { + 0 + }; + // LivingEntity.isVisuallySwimming: the swimming pose, or the gliding + // pose after the glide ended. + let visually = e.synced_pose == 3 || (!e.fall_flying && e.synced_pose == 1); + e.elytra.tick(e.fall_flying, e.crouching, self.velocity); + e.swim.tick(visually, in_water); + } +} + #[cfg(test)] mod elytra_tests { use super::*; diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs index ad130ea68..7d596f5ca 100644 --- a/crates/horizon-client/src/mobs/ai.rs +++ b/crates/horizon-client/src/mobs/ai.rs @@ -106,6 +106,7 @@ pub enum Family { Strider, Bat, Bee, + Panda, PolarBear, } pub fn family(s: Species) -> Family { @@ -122,7 +123,7 @@ pub fn family(s: Species) -> Family { | S::Parched | S::WitherSkeleton | S::ZombifiedPiglin => Family::Undead, - S::Creeper | S::Spider | S::CaveSpider => Family::Hostile, + S::Creeper | S::Spider | S::CaveSpider | S::Silverfish => Family::Hostile, S::Squid | S::GlowSquid | S::Cod @@ -168,6 +169,7 @@ pub fn family(s: Species) -> Family { S::Strider => Family::Strider, S::Bat => Family::Bat, S::Bee => Family::Bee, + S::Panda => Family::Panda, S::PolarBear => Family::PolarBear, _ => Family::Generic, } @@ -180,6 +182,12 @@ pub fn register(m: &mut Mob) { Family::Undead => undead::register(m), Family::Hostile => hostile::register(m), Family::Aquatic => aquatic::register(m), + // Turtle.registerGoals has its own list, none of the generic goals. + Family::Generic if m.species() == Species::Turtle => super::turtle::register(m), + Family::Generic if m.species() == Species::Armadillo => super::armadillo::register(m), + Family::Generic if m.species() == Species::Frog => super::frog::register(m), + Family::Generic if m.species() == Species::Fox => super::fox::register(m), + Family::Generic if m.species() == Species::Parrot => super::tame::register_parrot(m), Family::Generic => { generic(m); if m.species() == Species::Rabbit { @@ -197,22 +205,8 @@ pub fn register(m: &mut Mob) { gravity: true, }; } - if m.species() == Species::Turtle { - super::turtle::register(m); - } - if m.species() == Species::Frog { - // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true). - // The frog's movement speed is 1.0, so the controller's 0.1 - // outside-water speed is what keeps a walking frog at - // vanilla's pace; the plain ground controller walks ten - // times too fast (#2213). - m.ai.mov.kind = super::control::MoveKind::SmoothSwimming { - max_turn_x: 85.0, - max_turn_y: 10.0, - in_water: 0.02, - outside: 0.1, - gravity: true, - }; + if m.species() == Species::Goat { + super::goat::register(m); } } Family::Inert => {} @@ -255,6 +249,7 @@ pub fn register(m: &mut Mob) { Family::Strider => super::strider::register(m), Family::Bat => super::bat::register(m), Family::Bee => super::bee::register(m), + Family::Panda => super::panda::register(m), Family::PolarBear => super::polar_bear::register(m), } // FloatGoal's constructor lets the navigation float, as do the @@ -447,15 +442,25 @@ pub fn tick( } return false; } - if !m.no_ai { + if m.no_ai { + // Mob.aiStep still runs without AI (only serverAiStep is skipped), + // so the endermite's life keeps counting. + if m.species() == Species::Endermite { + endermite_lifetime(m); + } + } else { ai_step(m, w, level_random, events); } + effects_from_blocks(m, w); if m.species() == Species::Rabbit { super::rabbit::post_tick(m); } // Mob.tickHeadTurn -> BodyRotationControl.clientTick (a frozen // creaking's waits). - if m.alive() && (!super::creaking::is_creaking(m) || super::creaking::can_move(m)) { + if m.alive() + && (!super::creaking::is_creaking(m) || super::creaking::can_move(m)) + && !super::armadillo::scared(m) + { m.body_rotation_tick(); } events.append(&mut m.outbox); @@ -477,8 +482,64 @@ pub fn tick( if m.species() == Species::Bee { super::bee::tick(m, level_random); } + if m.species() == Species::Panda { + super::panda::tick(m, w, events); + } true } +/// `LivingEntity.aiStep` -> `Entity.applyEffectsFromBlocks` for the blocks +/// that hurt or hold a mob: the cactus (`CactusBlock.entityInside`, 1) and the +/// sweet berry bush (`SweetBerryBushBlock.entityInside`: stuck at 0.8, 0.75, +/// 0.8, and a grown bush pricks for 1 when the mob moved at least 0.003 on X +/// or Z this tick). The blocks are those the mob's box touches anywhere along +/// its move this tick, from where it started to where it ended. +fn effects_from_blocks(m: &mut Mob, w: &MobWorld) { + let mut visited: Vec<[i32; 3]> = Vec::new(); + let travel = m.position.subtract(m.previous); + let longest = travel.x.abs().max(travel.y.abs()).max(travel.z.abs()); + let steps = ((longest / 0.2).ceil() as i32).clamp(1, 100); + for step in 0..=steps { + if !m.alive() { + return; + } + let at = m + .previous + .add_vector(travel.scale(f64::from(step) / f64::from(steps))); + let b = m.bounds_at(at).deflate(Vec3::new(1e-5, 1e-5, 1e-5)); + for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 { + for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 { + for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 { + let p = [x, y, z]; + if visited.contains(&p) { + continue; + } + match w.block_name(x, y, z) { + "minecraft:cactus" => { + m.damage(1.0, Damage::of(DamageKind::Cactus)); + } + "minecraft:sweet_berry_bush" + if !matches!(m.species(), Species::Fox | Species::Bee) => + { + m.fall_distance = 0.0; + m.stuck_multiplier = + Vec3::new(f64::from(0.8_f32), 0.75, f64::from(0.8_f32)); + let moved = m.previous.subtract(m.position); + if w.prop(x, y, z, "age") != Some("0") + && moved.horizontal_distance_squared() > 0.0 + && (moved.x.abs() >= f64::from(0.003_f32) + || moved.z.abs() >= f64::from(0.003_f32)) + { + m.damage(1.0, Damage::of(DamageKind::SweetBerryBush)); + } + } + _ => continue, + } + visited.push(p); + } + } + } + } +} /// LivingEntity.updateSwingTime (6-tick swing duration). pub fn tick_swing(m: &mut Mob) { if m.ai.swinging { @@ -724,6 +785,7 @@ fn play_ambient(m: &mut Mob, w: &MobWorld, events: &mut Vec) { "entity.wolf.pant" } } + Species::Parrot => super::parrot::ambient(m, w), Species::Cat if m.extra.tame && m.extra.in_love > 0 => "entity.cat.purr", Species::Cat if !m.extra.tame => "entity.cat.stray_ambient", Species::PolarBear if m.is_baby() => "entity.polar_bear.ambient_baby", @@ -775,6 +837,9 @@ fn play_ambient(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } /// LivingEntity.aiStep (and Mob/AgeableMob/Animal additions). fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &mut Vec) { + if m.species() == Species::Parrot { + super::parrot::ai_step(m, w, level_random, events); + } // Witch.aiStep runs before super.aiStep(). if m.species() == Species::Witch { let far = m @@ -782,6 +847,9 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: & .is_some_and(|t| t.position.distance_squared(m.position) > 121.0); super::witch::ai_step(m, events, far); } + if m.species() == Species::Fox { + super::fox::pre_ai_step(m); + } // AbstractHorse.aiStep: the tail swishes now and then (moveTail). if super::equine::is_equine(m.species()) { super::equine::tail_tick(m); @@ -833,8 +901,8 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: & if m.kind.flags.climber { m.climbing = m.horizontal_collision; } - // AgeableMob.aiStep: a forced age-up's particles (positions drawn on the - // server too), then the age. + // AgeableMob.aiStep: a forced age-up's particles (`sendParticles`, so the + // players are sent them), then the age. if m.extra.forced_age_timer > 0 { if m.extra.forced_age_timer % 4 == 0 { let (w, h) = (f64::from(m.width()), f64::from(m.height())); @@ -843,10 +911,12 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: & let y = m.position.y + h * r.next_double() + 0.5; let z = m.position.z + w * (2.0 * r.next_double() - 1.0); // sendParticles(HAPPY_VILLAGER, x, y, z, 1, 0, 0, 0, 0): exactly there, at rest. - events.push(MobEvent::Particles { + events.push(MobEvent::LevelParticles { kind: "happy_villager", at: [x, y, z], - count: 0, + spread: [0.0; 3], + speed: 0.0, + count: 1, }); } m.extra.forced_age_timer -= 1; @@ -1108,7 +1178,11 @@ fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec super::rabbit::server_ai_step(m), - Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events), + // Armadillo.customServerAiStep: the brain and its activity, then the scute. + Species::Armadillo => { + super::armadillo::server_ai_step(m, cx); + armadillo_server_ai_step(m, cx.w.mob_drops, cx.events); + } Species::Sheep => {} Species::Zombie | Species::Husk @@ -1129,9 +1203,20 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { Species::Evoker if m.extra.counter > 0 => m.extra.counter -= 1, Species::Bat => super::bat::server_ai_step(m, cx.w, cx.events), Species::Bee => super::bee::server_ai_step(m, cx), + Species::Frog => super::frog::server_ai_step(m, cx.w), _ => {} } } +/// Endermite.aiStep: `counter` is the life; an endermite not required to +/// persist is discarded at 2400. +fn endermite_lifetime(m: &mut Mob) { + if !m.persistent { + m.extra.counter += 1; + } + if m.extra.counter >= 2400 { + m.removed = true; + } +} fn species_ai_step( m: &mut Mob, w: &MobWorld, @@ -1143,6 +1228,9 @@ fn species_ai_step( } match m.species() { Species::Enderman => super::enderman::ai_step(m, w, events), + // Endermite.aiStep: `counter` is the life; an endermite not required + // to persist is discarded at 2400. + Species::Endermite => endermite_lifetime(m), Species::Wolf => super::tame::ai_step(m, w, events), Species::Cat => super::tame::cat_ai_step(m, events), Species::Blaze => super::nether::blaze_ai_step(m, events), @@ -1182,6 +1270,10 @@ fn species_ai_step( } Species::Nautilus | Species::ZombieNautilus => super::nautilus::ai_step(m, w, events), Species::Chicken => farm::chicken_ai_step(m, w, events), + Species::Armadillo => super::armadillo::tick(m), + Species::Frog => super::frog::tick(m), + Species::Goat => super::goat::tick(m), + Species::Fox => super::fox::ai_step(m, w, events), Species::Turtle => super::turtle::ai_step(m, w, events), Species::Sheep if m.extra.anim_ticks > 0 => { m.extra.anim_ticks -= 1; @@ -1300,6 +1392,18 @@ pub fn voice_sounds(m: &Mob) -> [&'static str; 3] { match m.species() { Species::Nautilus | Species::ZombieNautilus => super::nautilus::sounds(m), Species::SulfurCube => super::sulfur_cube::sounds(m), + Species::Armadillo => super::armadillo::sounds(m), + // Panda.getAmbientSound. + Species::Panda => { + let ambient = if super::panda::is_aggressive(m) { + "entity.panda.aggressive_ambient" + } else if super::panda::is_worried(m) { + "entity.panda.worried_ambient" + } else { + m.kind.sounds[0] + }; + [ambient, m.kind.sounds[1], m.kind.sounds[2]] + } // The sound variant's baby_sounds (classic sets, like the rest here). Species::Pig if m.is_baby() => [ "entity.baby_pig.ambient", @@ -1322,6 +1426,10 @@ pub fn feed_animal( m: &mut Mob, level: &mut impl RandomSource, ) -> Option> { + // Armadillo.mobInteract: a ball takes no food. + if super::armadillo::scared(m) { + return None; + } if m.extra.age == 0 && m.extra.in_love <= 0 { m.extra.in_love = 600; m.extra.love_player = true; @@ -1434,6 +1542,9 @@ pub fn walk_target_value(m: &Mob, w: &MobWorld, p: [i32; 3]) -> f32 { if m.species() == Species::Strider { return super::strider::walk_target_value(m, w, p); } + if m.species() == Species::Turtle { + return super::turtle::walk_target_value(m, w, p, light()); + } // Hoglin.getWalkTargetValue: nowhere near a repellent, crimson nylium best. if m.species() == Species::Hoglin { let near = m.extra.repellent.is_some_and(|r| { @@ -1498,6 +1609,15 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, _amount: f32) -> bool { super::bee::hurt(m); true } + // Panda.hurtServer: up first, whatever the damage. + Species::Panda => { + super::panda::hurt(m); + true + } + Species::Silverfish => { + super::hostile::silverfish_hurt(m, source); + true + } Species::Enderman => super::enderman::on_damage(m, source), Species::WitherSkeleton | Species::Blaze | Species::MagmaCube | Species::Strider if source.is_fire() => @@ -1512,6 +1632,7 @@ pub fn after_hurt(m: &mut Mob, source: &Damage) { m.ai.no_action_time = 0; match m.species() { Species::Enderman => super::enderman::after_hurt(m, source), + Species::Armadillo => super::armadillo::after_hurt(m, source), Species::Shulker => super::shulker::after_hurt(m), Species::Warden => super::warden::hurt(m, source), Species::Wolf => super::tame::after_hurt(m, source), @@ -1525,7 +1646,16 @@ pub fn after_hurt(m: &mut Mob, source: &Damage) { // PiglinAi.wasHurtBy: drop what is being admired, no admiring for // a while after a player's hit, and anger. Species::Piglin if source.attacker == Some(Who::Player) => { - m.extra.using_item = 0; + // stopHoldingOffHandItem(.., false): a gold ingot is not bartered + // and is gone; anything else ends its admiring next tick, as if + // the time ran out, and the game side puts it away. + if m.extra.off_hand.as_deref() == Some("minecraft:gold_ingot") { + m.extra.off_hand = None; + m.extra.using_item = 0; + } else { + m.extra.using_item = + i32::from(m.extra.off_hand.is_some() && m.extra.using_item > 0); + } m.extra.egg_time = 400; m.extra.anger = 600; } @@ -1549,24 +1679,37 @@ pub fn do_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { if m.species() == Species::Ravager { super::ravager::on_attack(m, cx.events); } + if m.species() == Species::Panda { + super::panda::bit(m); + } if super::creaking::is_creaking(m) { super::creaking::on_attack(m, cx.events); } let mut amount = m.attrs.attack_damage; let from = [m.position.x, m.position.y, m.position.z]; let source = Damage::mob(m.id, from); + let first_event = cx.events.len(); match m.species() { - // Difficulty NORMAL: cave spiders poison for 7 seconds. - Species::CaveSpider if who == Who::Player => cx.events.push(MobEvent::EffectPlayer { - effect: "minecraft:poison", - ticks: 7 * 20, - amplifier: 0, - }), - Species::Husk if who == Who::Player => cx.events.push(MobEvent::EffectPlayer { - effect: "minecraft:hunger", - ticks: 140, - amplifier: 0, - }), + // CaveSpider.doHurtTarget: poison for 7 s on normal, 15 s on hard. + Species::CaveSpider if who == Who::Player && cx.w.difficulty.base >= 2 => { + cx.events.push(MobEvent::EffectPlayer { + effect: "minecraft:poison", + ticks: if cx.w.difficulty.base == 2 { 7 } else { 15 } * 20, + amplifier: 0, + }) + } + // Husk.doHurtTarget: hunger for 140 ticks per whole point of the + // local difficulty, only with an empty main hand. + Species::Husk if who == Who::Player && m.extra.main_hand.is_none() => { + let ticks = 140 * cx.w.difficulty.effective as i32; + if ticks > 0 { + cx.events.push(MobEvent::EffectPlayer { + effect: "minecraft:hunger", + ticks, + amplifier: 0, + }) + } + } Species::WitherSkeleton if who == Who::Player => cx.events.push(MobEvent::EffectPlayer { effect: "minecraft:wither", ticks: 200, @@ -1616,7 +1759,28 @@ pub fn do_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { }); } match who { - Who::Player => cx.events.push(MobEvent::AttackPlayer(amount, from)), + // The effect picked above goes with the hit: it applies only when + // the player takes damage (a shield-blocked hit gives none). + Who::Player => { + let effect = cx.events[first_event..] + .iter() + .position(|e| matches!(e, MobEvent::EffectPlayer { .. })) + .map(|k| cx.events.remove(first_event + k)); + cx.events.push(match effect { + Some(MobEvent::EffectPlayer { + effect, + ticks, + amplifier, + }) => MobEvent::AttackPlayerWithEffect { + amount, + from, + effect, + ticks, + amplifier, + }, + _ => MobEvent::AttackPlayer(amount, from), + }); + } Who::Mob(id) => cx.events.push(MobEvent::AttackMob { target: id, amount, @@ -1627,6 +1791,12 @@ pub fn do_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { if super::creaking::is_creaking(m) { m.voice("entity.creaking.attack", cx.events); } + // Panda.playAttackSound: playSound(PANDA_BITE, 1.0, 1.0). + if m.species() == Species::Panda && !m.silent { + let at = [m.position.x, m.position.y, m.position.z]; + cx.events + .push(MobEvent::Sound("entity.panda.bite", at, 1.0, 1.0)); + } // Axolotl.playAttackSound: playSound(AXOLOTL_ATTACK, 1.0, 1.0). if m.species() == Species::Axolotl { let at = [m.position.x, m.position.y, m.position.z]; diff --git a/crates/horizon-client/src/mobs/allay.rs b/crates/horizon-client/src/mobs/allay.rs index 029ddb6e5..22461945d 100644 --- a/crates/horizon-client/src/mobs/allay.rs +++ b/crates/horizon-client/src/mobs/allay.rs @@ -133,6 +133,11 @@ pub fn ai_step(m: &mut Mob) { if m.extra.egg_time > 0 { m.extra.egg_time -= 1; } + animate(m); +} +/// `Allay.tick`'s client half: the hold and spin clocks (the server's and a +/// client's). +pub fn animate(m: &mut Mob) { let holding = m.extra.main_hand.is_some(); let v = &mut m.anim.v; v[HOLD] = (v[HOLD] + if holding { 1.0 } else { -1.0 }).clamp(0.0, 5.0); diff --git a/crates/horizon-client/src/mobs/ambient.rs b/crates/horizon-client/src/mobs/ambient.rs index cb4146e08..94589ffab 100644 --- a/crates/horizon-client/src/mobs/ambient.rs +++ b/crates/horizon-client/src/mobs/ambient.rs @@ -2,8 +2,10 @@ //! `level().isClientSide()` branches of `aiStep`: nothing of it reaches the //! server or goes over the network, so the window's game runs it, whether it //! simulates the world (in-frame) or follows a server. -use super::{Mob, MobEvent, Species}; +use super::{Mob, MobEvent, Species, bee}; +use horizon_core::geometry::trig::Mth; use horizon_core::random::RandomSource; +use std::f32::consts::PI; /// `Enderman.aiStep`, `Endermite.aiStep` and `Blaze.aiStep` on a client: /// two portal particles a tick around endermen and endermites; two large @@ -53,3 +55,67 @@ pub fn client_ai_step(m: &mut Mob, out: &mut Vec) { out.push(MobEvent::ParticleAt { kind, at, velocity }); } } + +/// `Phantom.tick` and `Bee.tick` on a client, which draw from the client +/// level's random (`random`) and never from the mob's own, so a window that +/// simulates the world keeps the mob's draws as the server has them: a +/// phantom's wings leave mycelium dust, a bee carrying nectar now and then +/// drips it. +pub fn client_particles(m: &Mob, random: &mut impl RandomSource, out: &mut Vec) { + match m.species() { + Species::Phantom => { + // The wings flap every phantom in a different phase + // (`getUniqueFlapTickOffset`). + let flap = ((m.id.wrapping_mul(3).wrapping_add(m.age)) as i32 as f32 + * 7.448451 + * (PI / 180.0) + + PI) + .mcos(); + let width = m.width() * 1.48; + let yaw = m.yaw * (PI / 180.0); + let (c, s) = (yaw.mcos() * width, yaw.msin() * width); + let h = (0.3 + flap * 0.45) * m.height() * 2.5; + let p = m.position; + for (dx, dz) in [(c, s), (-c, -s)] { + out.push(MobEvent::ParticleAt { + kind: "mycelium", + at: [p.x + f64::from(dx), p.y + f64::from(h), p.z + f64::from(dz)], + velocity: [0.0; 3], + }); + } + } + Species::Bee => { + if !bee::has_nectar(m) + || !bee::get(m).is_some_and(|b| b.crops_grown < 10) + || random.next_float() >= 0.05 + { + return; + } + // `for (i = 0; i < nextInt(2) + 1; i++)` rolls the bound each time. + let mut i = 0; + while i < random.next_int_bound(2).unwrap_or(0) + 1 { + // Mth.lerp(level.random.nextDouble(), x - 0.3F, x + 0.3F). + let spread = f64::from(0.3_f32); + let lerp = |delta: f64, from: f64, to: f64| from + delta * (to - from); + let x = lerp( + random.next_double(), + m.position.x - spread, + m.position.x + spread, + ); + let z = lerp( + random.next_double(), + m.position.z - spread, + m.position.z + spread, + ); + out.push(MobEvent::ParticleAt { + kind: "falling_nectar", + // getY(0.5). + at: [x, m.position.y + f64::from(m.height()) * 0.5, z], + velocity: [0.0; 3], + }); + i += 1; + } + } + _ => {} + } +} diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index a4c27960e..2eccd31f0 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -244,6 +244,8 @@ pub enum ArmPose { CrossbowCharge, /// Raising a trident to throw it (or to launch with Riptide). ThrowTrident, + /// A spear held out (`HumanoidModel.ArmPose.SPEAR`), at rest or charging. + Spear, } /// HumanoidModel.setupAnim with empty hands (endermen). pub fn humanoid_pub(p: &mut Poses, s: &State, _m: &Mob) { @@ -295,6 +297,10 @@ pub struct Hum { pub swing_right_arm: Option, /// `mainArm` is the left one (`Mob.isLeftHanded`): a mob's swing uses it. pub left_main: bool, + /// The spear each arm (right, left) holds, and how long that arm has + /// been using it (`ticksUsingItem(arm)`, 0 when it is not). + pub spear: [Option; 2], + pub spear_ticks: [f32; 2], } impl Hum { pub fn new(right: ArmPose, left: ArmPose) -> Self { @@ -313,6 +319,8 @@ impl Hum { using_item: false, swing_right_arm: None, left_main: false, + spear: [None; 2], + spear_ticks: [0.0; 2], } } } @@ -388,6 +396,23 @@ fn pose_arm(p: &mut Poses, pose: ArmPose, right: bool, h: &Hum) { } ArmPose::CrossbowHold => crossbow_hold(p, hx, hy, right), ArmPose::CrossbowCharge => crossbow_charge(p, h.charge.0, h.charge.1, right), + // SpearAnimations.thirdPersonHandUse. + ArmPose::Spear => { + let side = usize::from(!right); + let Some(kinetic) = h.spear[side] else { + return; + }; + let (x, y, z) = crate::spear::third_person_arm( + &kinetic, + h.spear_ticks[side], + right, + (hx, hy), + h.fall_flying || h.swim > 0.0, + ); + p.xrot(arm, x); + p.yrot(arm, y); + p.get(arm)[5] += z; + } } } /// `HumanoidModel.setupAnim` (and `ZombieModel.setupAttackAnimation`). @@ -687,6 +712,14 @@ pub fn setup( ArmPose::Empty }; let using_main = m.extra.using_item > 0 && !m.extra.using_off_hand; + // AvatarRenderer.getArmPose: an arm holding a spear (at rest too). + let spear_in = |hand: &Option>| { + hand.as_deref() + .filter(|_| player) + .and_then(crate::spear::Kinetic::of) + }; + let (main_spear, off_spear) = + (spear_in(&m.extra.main_hand), spear_in(&m.extra.off_hand)); let pose = if player { match m.extra.main_hand.as_deref() { Some(_) if using_main && m.extra.blocking => ArmPose::Block, @@ -698,6 +731,7 @@ pub fn setup( Some("minecraft:crossbow") if m.extra.charged && s.swing == 0.0 => { ArmPose::CrossbowHold } + Some(_) if main_spear.is_some() => ArmPose::Spear, Some(_) => ArmPose::Item, None => ArmPose::Empty, } @@ -705,7 +739,9 @@ pub fn setup( right }; let off = if player && m.extra.off_hand.is_some() && !pose.affects_offhand() { - if m.extra.using_item > 0 && m.extra.using_off_hand && m.extra.blocking { + if off_spear.is_some() { + ArmPose::Spear + } else if m.extra.using_item > 0 && m.extra.using_off_hand && m.extra.blocking { ArmPose::Block } else { ArmPose::Item @@ -731,6 +767,17 @@ pub fn setup( h.using_item = m.extra.using_item > 0; h.swing_right_arm = m.extra.swing_right_arm; h.left_main = m.main_arm_left(); + let main_side = usize::from(m.main_arm_left()); + h.spear[main_side] = main_spear; + h.spear[1 - main_side] = off_spear; + if m.extra.using_item > 0 { + let using_side = if m.extra.using_off_hand { + 1 - main_side + } else { + main_side + }; + h.spear_ticks[using_side] = m.extra.using_item as f32 + s.partial; + } humanoid(p, s, &h); if m.ai.aggressive && !bow { // SkeletonModel melee pose. diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs index 59a73c605..fdc543e08 100644 --- a/crates/horizon-client/src/mobs/aquatic.rs +++ b/crates/horizon-client/src/mobs/aquatic.rs @@ -128,9 +128,12 @@ pub fn register(m: &mut Mob) { let g = &mut m.ai.goals; g.add(0, BreathAir); g.add(0, TryFindWater::default()); + g.add(1, super::dolphin::SwimToTreasure::default()); + g.add(2, super::dolphin::SwimWithPlayer::new(4.0)); g.add(4, Stroll::swimming(1.0, 10)); g.add(4, RandomLookAround::default()); g.add(5, LookAtPlayer::new(6.0)); + g.add(5, super::dolphin::Jump::new(10)); g.add(6, MeleeAttack::new(1.2, true)); m.ai.targets.add(1, HurtByTarget::new().alert()); m.ai.mov.kind = MoveKind::SmoothSwimming { @@ -244,11 +247,10 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { && m.ai.no_action_time % 10 == 0 { let amount = 1.0 + m.extra.size as f32; - events.push(MobEvent::AttackPlayer( + // Only when the sting hurt the player. + events.push(MobEvent::AttackPlayerWithEffect { amount, - [m.position.x, m.position.y, m.position.z], - )); - events.push(MobEvent::EffectPlayer { + from: [m.position.x, m.position.y, m.position.z], effect: "minecraft:poison", ticks: 60 * m.extra.size, amplifier: 0, diff --git a/crates/horizon-client/src/mobs/armadillo.rs b/crates/horizon-client/src/mobs/armadillo.rs new file mode 100644 index 000000000..8837d8cf8 --- /dev/null +++ b/crates/horizon-client/src/mobs/armadillo.rs @@ -0,0 +1,407 @@ +//! Armadillos (`Armadillo`, `ArmadilloAi`): a player who sprints or rides +//! nearby, an undead mob or the last attacker scares one into a ball (IDLE, +//! ROLLING, SCARED, UNROLLING); it peeks out now and then, and a ball takes +//! less damage. The brain's `ARMADILLO_SCARE_DETECTED` sensor, its +//! `DANGER_DETECTED_RECENTLY` memory and the `ArmadilloBallUp` behaviour are +//! kept in `State`; the walking behaviours are the goals of `register`. +//! AnimState states: roll out, roll up, peek. +use super::{ + Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who, + goals::{ + Cx, Float, Goal, LOOK, LookAtPlayer, MOVE, Panic, RandomLookAround, Stroll, goal_clone, + }, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +pub const IDLE: u8 = 0; +pub const ROLLING: u8 = 1; +pub const SCARED: u8 = 2; +pub const UNROLLING: u8 = 3; + +const ROLL_OUT: usize = 0; +const ROLL_UP: usize = 1; +const PEEK: usize = 2; + +/// `ArmadilloState.animationDuration`. +fn animation_duration(state: u8) -> i32 { + match state { + ROLLING => 10, + SCARED => 50, + UNROLLING => 30, + _ => 0, + } +} + +/// `Armadillo.ARMADILLO_STATE` and the brain's memory and behaviour. +#[derive(Clone, Debug, Default)] +pub struct State { + pub state: u8, + /// `inStateTicks`. + pub in_state_ticks: i32, + /// `DANGER_DETECTED_RECENTLY`: ticks to live, 0 when absent. + danger: i32, + /// Ticks to the sensor's next scan. + sensor: i32, + /// `ArmadilloBallUp`: running, its peek timer and whether it saw the + /// danger around last tick. + ball_up: bool, + next_peek: i32, + danger_was_around: bool, + /// Whether the PANIC activity was the active one after the last tick. + panic_activity: bool, + /// `peekReceivedClient`. + peek_received: bool, +} + +pub fn register(m: &mut Mob) { + let mut panic = Panic::new(2.0); + panic.environmental = true; + let g = &mut m.ai.goals; + g.add(0, Float); + g.add(1, ArmadilloPanic(panic)); + g.add(2, Rolled); + g.add(5, Stroll::avoiding_water(1.0)); + g.add(6, LookAtPlayer::new(6.0)); + g.add(7, RandomLookAround::default()); +} + +/// `Armadillo.isScared`. +pub fn scared(m: &Mob) -> bool { + m.extra.armadillo.state != IDLE +} +/// `ArmadilloState.shouldHideInShell`: the model shows its shell. +pub fn hiding_in_shell(m: &Mob) -> bool { + let a = &m.extra.armadillo; + match a.state { + ROLLING => a.in_state_ticks > 5, + SCARED => true, + UNROLLING => a.in_state_ticks < 26, + _ => false, + } +} +/// `Armadillo.getState`, as it is synched. +pub fn state(m: &Mob) -> u8 { + m.extra.armadillo.state +} +/// `Armadillo.switchToState` and `onSyncedDataUpdated(ARMADILLO_STATE)`. +pub fn set_state(m: &mut Mob, state: u8) { + let a = &mut m.extra.armadillo; + if a.state != state { + a.state = state; + a.in_state_ticks = 0; + } +} +/// `Armadillo.canStayRolledUp`. +fn can_stay_rolled_up(m: &Mob) -> bool { + !m.ai.panicking + && !m.fluids.in_water + && !m.fluids.in_lava + && m.extra.leash.is_none() + && m.extra.mount.is_none() + && m.extra.rider.is_none() +} +/// `Entity.playSound(sound)`. +fn play(m: &Mob, events: &mut Vec, sound: &'static str) { + if !m.silent { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound(sound, at, 1.0, 1.0)); + } +} +/// `Armadillo.rollUp`. +fn roll_up(m: &mut Mob, events: &mut Vec) { + if !scared(m) { + super::creaking::stop_in_place(m); + m.extra.in_love = 0; + if !m.silent { + m.voice("entity.armadillo.roll", events); + } + set_state(m, ROLLING); + } +} +/// `Armadillo.rollOut`. +fn roll_out(m: &mut Mob, events: &mut Vec) { + if scared(m) { + if !m.silent { + m.voice("entity.armadillo.unroll_finish", events); + } + set_state(m, IDLE); + } +} + +/// `Armadillo.hurtServer`: a ball takes half of the damage past the first +/// point. +pub fn reduce_damage(m: &Mob, amount: f32) -> f32 { + if scared(m) { + ((amount - 1.0) / 2.0).max(0.0) + } else { + amount + } +} +/// `Armadillo.actuallyHurt`: a hit by a living thing curls it up (and keeps +/// the danger in mind for 80 ticks), a hit by fire and the like unrolls it. +pub fn after_hurt(m: &mut Mob, source: &Damage) { + if m.no_ai || m.health <= 0.0 { + return; + } + let mut events = Vec::new(); + if source.attacker.is_some() { + m.extra.armadillo.danger = 80; + if can_stay_rolled_up(m) { + roll_up(m, &mut events); + } + } else if environmental(source.kind) { + roll_out(m, &mut events); + } + m.outbox.append(&mut events); +} +/// `DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES`. +pub fn environmental(kind: DamageKind) -> bool { + matches!( + kind, + DamageKind::Cactus | DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava + ) +} +/// The hurt sound: a ball's is muffled, and it has no ambient sound +/// (`getAmbientSound`, `getHurtSound`); empty is none. +pub fn sounds(m: &Mob) -> [&'static str; 3] { + let [ambient, hurt, death] = m.kind.sounds; + if scared(m) { + ["", "entity.armadillo.hurt_reduced", death] + } else { + [ambient, hurt, death] + } +} + +/// `EntityTypeTags.UNDEAD`. +fn undead(s: Species) -> bool { + matches!( + s, + Species::Skeleton + | Species::Stray + | Species::WitherSkeleton + | Species::SkeletonHorse + | Species::Bogged + | Species::Parched + | Species::ZombieHorse + | Species::CamelHusk + | Species::Zombie + | Species::ZombieVillager + | Species::ZombifiedPiglin + | Species::Zoglin + | Species::Drowned + | Species::Husk + | Species::ZombieNautilus + | Species::Wither + | Species::Phantom + ) +} +/// `Armadillo.isScaredBy` for the nearby living entities: within 7 blocks +/// sideways and 2 up and down, an undead mob, the last attacker, or a +/// player who sprints or rides. +fn scared_by_someone(m: &Mob, w: &MobWorld) -> bool { + let area = m.bounds().inflate(Vec3::new(7.0, 2.0, 7.0)); + let attacker = + m.ai.last_hurt_by + .filter(|_| m.age as i32 - m.ai.last_hurt_by_time <= 100); + if let Some(p) = &w.player + && p.alive + && !p.spectator + && p.bounds.intersects(area) + && (attacker == Some(Who::Player) || p.sprinting || p.riding) + { + return true; + } + w.others_near(area).any(|s| { + s.id != m.id + && s.alive + && s.bounds.intersects(area) + && (undead(s.species) || attacker == Some(Who::Mob(s.id))) + }) +} + +/// `Armadillo.customServerAiStep`'s brain: memories expire, the scare +/// sensor scans every fifth tick, the core's rolling out, then the +/// `ArmadilloBallUp` behaviour of the PANIC activity. +pub fn server_ai_step(m: &mut Mob, cx: &mut Cx) { + let events = &mut *cx.events; + let a = &mut m.extra.armadillo; + if a.danger > 0 { + a.danger -= 1; + } + a.sensor -= 1; + if a.sensor <= 0 { + a.sensor = 5; + if !can_stay_rolled_up(m) { + m.extra.armadillo.danger = 0; + } else if scared_by_someone(m, cx.w) { + m.extra.armadillo.danger = 80; + } + } + // ARMADILLO_ROLLING_OUT: no danger left in mind. + if m.extra.armadillo.danger == 0 && scared(m) { + roll_out(m, events); + } + if m.extra.armadillo.panic_activity && !m.extra.armadillo.ball_up && m.on_ground && !liquid(m) { + // ArmadilloBallUp.start. + m.extra.armadillo.ball_up = true; + roll_up(m, events); + } + if m.extra.armadillo.ball_up { + ball_up_tick(m, events); + } + let a = &mut m.extra.armadillo; + a.panic_activity = a.danger > 0 && !m.ai.panicking; +} +fn liquid(m: &Mob) -> bool { + m.fluids.in_water || m.fluids.in_lava +} +/// `ArmadilloBallUp.tickOrStop`. +fn ball_up_tick(m: &mut Mob, events: &mut Vec) { + if !scared(m) { + // canStillUse is false: stop. + m.extra.armadillo.ball_up = false; + if !can_stay_rolled_up(m) { + roll_out(m, events); + } + return; + } + let a = &mut m.extra.armadillo; + if a.next_peek > 0 { + a.next_peek -= 1; + } + if a.state == ROLLING && a.in_state_ticks > animation_duration(ROLLING) { + set_state(m, SCARED); + if m.on_ground { + play(m, events, "entity.armadillo.land"); + } + return; + } + let danger = m.extra.armadillo.danger; + let around = danger > 75; + if around != m.extra.armadillo.danger_was_around { + m.extra.armadillo.next_peek = next_peek_timer(m); + } + m.extra.armadillo.danger_was_around = around; + let state = m.extra.armadillo.state; + if state == SCARED { + if m.extra.armadillo.next_peek == 0 && m.on_ground && around { + peek(m, events); + m.extra.armadillo.next_peek = next_peek_timer(m); + } + if danger < animation_duration(UNROLLING) { + play(m, events, "entity.armadillo.unroll_start"); + set_state(m, UNROLLING); + } + } else if state == UNROLLING && danger > animation_duration(UNROLLING) { + set_state(m, SCARED); + } +} +/// `ArmadilloBallUp.pickNextPeekTimer`. +fn next_peek_timer(m: &mut Mob) -> i32 { + animation_duration(SCARED) + m.random.next_int_between_inclusive(100, 400).unwrap_or(100) +} +/// `level.broadcastEntityEvent(body, 64)`; the sound is the client's +/// `playLocalSound`, which the server plays for everyone here. +fn peek(m: &mut Mob, events: &mut Vec) { + entity_event(m, 64); + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 64, + at, + }); + events.push(MobEvent::Sound("entity.armadillo.peek", at, 1.0, 1.0)); +} +/// `Armadillo.handleEntityEvent`: 64 is a peek. +pub fn entity_event(m: &mut Mob, event: u8) { + if event == 64 { + m.extra.armadillo.peek_received = true; + } +} + +/// `Armadillo.tick`: the animation states on a client, the ball's head held +/// to its body, and `inStateTicks`. Server and client both run it. +pub fn tick(m: &mut Mob) { + animate(m); + if scared(m) { + // clampHeadRotationToBody with getMaxHeadYRot 0. + m.head_yaw += super::living::wrap(m.body_yaw - m.head_yaw); + } + m.extra.armadillo.in_state_ticks += 1; +} +/// `Armadillo.setupAnimationStates`. +fn animate(m: &mut Mob) { + let age = m.age as f32; + let a = &mut m.extra.armadillo; + let s = &mut m.anim.states; + match a.state { + ROLLING => { + s[ROLL_OUT].stop(); + s[ROLL_UP].start_if_stopped(age); + s[PEEK].stop(); + } + SCARED => { + s[ROLL_OUT].stop(); + s[ROLL_UP].stop(); + if a.peek_received { + s[PEEK].stop(); + a.peek_received = false; + } + if a.in_state_ticks == 0 { + s[PEEK].start(age); + s[PEEK].fast_forward(animation_duration(SCARED)); + } else { + s[PEEK].start_if_stopped(age); + } + } + UNROLLING => { + s[ROLL_OUT].start_if_stopped(age); + s[ROLL_UP].stop(); + s[PEEK].stop(); + } + _ => { + s[ROLL_OUT].stop(); + s[ROLL_UP].stop(); + s[PEEK].stop(); + } + } +} + +/// `ArmadilloAi.ArmadilloPanic`: it unrolls, then runs. +#[derive(Clone, Debug)] +struct ArmadilloPanic(Panic); +impl Goal for ArmadilloPanic { + goal_clone!(); + fn flags(&self) -> u8 { + self.0.flags() + } + fn name(&self) -> &'static str { + "Panic" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.0.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.0.can_continue(m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + roll_out(m, cx.events); + self.0.start(m, cx); + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.stop(m, cx); + } +} +/// The behaviours that do not run while the armadillo is a ball: its +/// `MoveToTargetSink` and the idle activity's walking and looking. +#[derive(Clone, Debug)] +struct Rolled; +impl Goal for Rolled { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + scared(m) + } +} diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs index cecaff589..e8e3ae0ae 100644 --- a/crates/horizon-client/src/mobs/bee.rs +++ b/crates/horizon-client/src/mobs/bee.rs @@ -103,6 +103,17 @@ pub fn has_stung(m: &Mob) -> bool { pub fn rolling(m: &Mob) -> bool { flag(m, FLAG_ROLL) } +/// A client's bee from the server's `DATA_FLAGS_ID` and `DATA_ANGER_END_TIME` +/// (the texture and the roll read them). +pub fn set_synced(m: &mut Mob, flags: Option, anger_end: Option) { + let b = st(m); + if let Some(flags) = flags { + b.flags = flags; + } + if let Some(anger_end) = anger_end { + b.anger_end = anger_end; + } +} /// `Bee.setHasNectar`: nectar resets the time without it. pub fn set_has_nectar(m: &mut Mob, value: bool) { if value { @@ -322,19 +333,23 @@ pub fn sting(m: &mut Mob, who: Who, cx: &mut Cx) { let amount = (m.attrs.attack_damage as i32) as f32; match who { Who::Player => { - cx.events.push(MobEvent::AttackPlayer(amount, from)); - // Poison only on normal (10 s) and hard (18 s). + // Bee.doHurtTarget: the poison only when the sting hurt, and + // only on normal (10 s) and hard (18 s). let seconds = match cx.w.difficulty.id { 2 => 10, 3 => 18, _ => 0, }; if seconds > 0 { - cx.events.push(MobEvent::EffectPlayer { + cx.events.push(MobEvent::AttackPlayerWithEffect { + amount, + from, effect: "minecraft:poison", ticks: seconds * 20, amplifier: 0, }); + } else { + cx.events.push(MobEvent::AttackPlayer(amount, from)); } } Who::Mob(id) => cx.events.push(MobEvent::AttackMob { diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs index 360e1447f..d31603156 100644 --- a/crates/horizon-client/src/mobs/body_anim.rs +++ b/crates/horizon-client/src/mobs/body_anim.rs @@ -59,11 +59,11 @@ pub struct Goat { pub ramming_x_head_rot: f32, } impl Goat { - pub fn from_mob(_m: &Mob) -> Self { + pub fn from_mob(m: &Mob) -> Self { Self { - left_horn: true, - right_horn: true, - ramming_x_head_rot: 0.0, + left_horn: !m.extra.lost_horns[0], + right_horn: !m.extra.lost_horns[1], + ramming_x_head_rot: super::goat::ramming_x_head_rot(m), } } } @@ -960,7 +960,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { match m.species() { Species::Goat => goat(p, s, &Goat::from_mob(m)), Species::PolarBear => polar_bear(p, s, super::polar_bear::standing_scale(m, s.partial)), - Species::Panda => panda(p, s, &Panda::default()), + Species::Panda => panda(p, s, &super::panda::pose(m, s.partial)), Species::Llama | Species::TraderLlama => { llama(p, s, m.extra.chested && !s.baby); } @@ -981,7 +981,9 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { let flap = m.anim.flap_o + (m.anim.flap - m.anim.flap_o) * s.partial; let speed = m.anim.flap_speed_o + (m.anim.flap_speed - m.anim.flap_speed_o) * s.partial; // `Parrot.isFlying` is `!onGround`, in water too. - let pose = if m.extra.sitting { + let pose = if m.extra.party_jukebox.is_some() { + ParrotPose::Party + } else if m.extra.sitting { ParrotPose::Sitting } else if !m.on_ground { ParrotPose::Flying @@ -1008,7 +1010,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { p, s, &Armadillo { - hiding_in_shell: false, + hiding_in_shell: super::armadillo::hiding_in_shell(m), roll_out: st[0], roll_up: st[1], peek: st[2], @@ -1029,7 +1031,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool { a, ), Species::Rabbit => rabbit(p, s, &st[0], &st[1], a), - Species::Fox => fox(p, s, &Fox::default(), a), + Species::Fox => fox(p, s, &super::fox::pose(m, s.partial), a), _ => return false, } true diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs index e6874ea0b..b142188da 100644 --- a/crates/horizon-client/src/mobs/control.rs +++ b/crates/horizon-client/src/mobs/control.rs @@ -146,6 +146,16 @@ impl Mob { if self.species() == super::Species::Rabbit { return super::rabbit::move_control(self, w); } + // Fox.FoxMoveControl.tick: still while asleep, sitting or faceplanted. + if self.species() == super::Species::Fox && !super::fox::can_move(self) { + return; + } + // Panda.PandaMoveControl: only while it can act. + if self.species() == super::Species::Panda + && !super::panda::can_perform_action(self, w.thundering) + { + return; + } if self.species() == super::Species::Turtle { return super::turtle::move_control(self); } @@ -328,6 +338,11 @@ impl Mob { /// LookControl.tick (and SmoothSwimmingLookControl). pub fn look_control_tick(&mut self) { let look = self.ai.look.clone(); + let fox = self.species() == super::Species::Fox; + // Fox.FoxLookControl: no turning in sleep. + if fox && super::fox::flag(self, super::fox::SLEEPING) { + return; + } if look.kind == LookKind::HappyGhast { return super::happy_ghast::look_control(self); } @@ -374,7 +389,8 @@ impl Mob { // clampHeadRotationToBody does nothing for a shulker. } LookKind::Default | LookKind::Fixed => { - if look.kind == LookKind::Default { + // FoxLookControl.resetXRotOnTick keeps a stalking or pouncing pitch. + if look.kind == LookKind::Default && (!fox || super::fox::resets_x_rot(self)) { self.head_pitch = 0.0; } if look.cooldown > 0 { diff --git a/crates/horizon-client/src/mobs/copper_golem.rs b/crates/horizon-client/src/mobs/copper_golem.rs index 5f4ffba13..c5e0dbece 100644 --- a/crates/horizon-client/src/mobs/copper_golem.rs +++ b/crates/horizon-client/src/mobs/copper_golem.rs @@ -70,6 +70,16 @@ pub fn sound(m: &Mob, what: &str) -> &'static str { } /// `CopperGolem.setupAnimationStates` (client) and the sound of the head spin. pub fn ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec) { + if animate(m) { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::LocalSound(sound(m, "spin"), at, 1.0, 1.0)); + } +} +/// `CopperGolem.setupAnimationStates`, for the server and a client alike; +/// returns whether the head spin sound plays now (a client's sound is the +/// server's `LocalSound`). +pub fn animate(m: &mut Mob) -> bool { + let mut spin = false; let age = m.age as f32; let state = m.extra.variant3; let st = &mut m.anim.states; @@ -93,8 +103,7 @@ pub fn ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec) { m.extra.ints[0] = tick + 200 + r.next_int_bound(40).unwrap_or(0); } if tick == m.extra.ints[0] + 10 { - let at = [m.position.x, m.position.y, m.position.z]; - events.push(MobEvent::LocalSound(sound(m, "spin"), at, 1.0, 1.0)); + spin = true; m.extra.ints[0] = 0; } } @@ -106,6 +115,7 @@ pub fn ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec) { } _ => {} } + spin } /// `CopperGolem.updateWeathering` on the level random: the first tick sets /// the next weathering tick, which advances the weather state; once diff --git a/crates/horizon-client/src/mobs/creaking.rs b/crates/horizon-client/src/mobs/creaking.rs index fd6248d2b..0bfccc7a6 100644 --- a/crates/horizon-client/src/mobs/creaking.rs +++ b/crates/horizon-client/src/mobs/creaking.rs @@ -118,6 +118,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage) -> bool { source.kind, DamageKind::PlayerAttack | DamageKind::MaceSmash + | DamageKind::Spear | DamageKind::MobAttack | DamageKind::Arrow | DamageKind::Thrown @@ -152,8 +153,26 @@ pub fn sway(m: &mut Mob, events: &mut Vec) { } /// `Creaking.doHurtTarget`: the attack animation (the sound is the /// `playAttackSound` that ends `Mob.doHurtTarget`). -pub fn on_attack(m: &mut Mob, _events: &mut Vec) { +pub fn on_attack(m: &mut Mob, events: &mut Vec) { m.extra.ints[ATTACKING] = ATTACK_TICKS; + broadcast(m, 4, events); +} +/// `Level.broadcastEntityEvent` for a creaking (guests run `entity_event`). +fn broadcast(m: &Mob, event: i8, events: &mut Vec) { + events.push(MobEvent::EntityEvent { + mob: m.id, + event, + at: [m.position.x, m.position.y, m.position.z], + }); +} +/// `Creaking.handleEntityEvent` on a client: 66 the invulnerability flash, +/// 4 the attack swing (the sounds are the server's). +pub fn entity_event(m: &mut Mob, event: u8) { + match event { + 66 => m.extra.ints[INVULNERABLE] = INVULNERABILITY_TICKS, + 4 => m.extra.ints[ATTACKING] = ATTACK_TICKS, + _ => {} + } } /// The heart this creaking is bound to protects it (`isProtector`); a link /// read from a save is trusted until the heart resolves it. @@ -176,15 +195,12 @@ pub fn update(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if heart_bound(m) && m.alive() && !protected(m, w) { m.health = 0.0; } - for slot in [INVULNERABLE, ATTACKING] { - if m.extra.ints[slot] > 0 { - m.extra.ints[slot] -= 1; - } + // hurtServer set the invulnerability clock since the last tick: entity + // event 66. + if m.extra.ints[INVULNERABLE] == INVULNERABILITY_TICKS { + broadcast(m, 66, events); } - let age = m.age as f32; - m.anim.states[0].animate_when(m.extra.ints[ATTACKING] > 0, age); - m.anim.states[1].animate_when(m.extra.ints[INVULNERABLE] > 0, age); - m.anim.states[2].animate_when(tearing_down(m), age); + animate(m); if m.extra.counter & HURT != 0 { // hurtServer: sway, and the heart reacts to a player's hit. if protected(m, w) { @@ -200,18 +216,6 @@ pub fn update(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } m.extra.counter &= !(HURT | HURT_BY_PLAYER); } - // checkEyeBlink: the eyes of a creaking falling apart flicker. - if m.death_time > m.extra.ints[NEXT_FLICKER] { - let glowing = m.extra.ints[EYES] != 0; - let (lo, hi) = if glowing { - (2, 8) - } else { - (m.death_time / 4, m.death_time / 2) - }; - let span = (hi - lo + 1).max(1); - m.extra.ints[NEXT_FLICKER] = m.death_time + lo + m.random.next_int_bound(span).unwrap_or(0); - m.extra.ints[EYES] = i32::from(!glowing); - } if !m.alive() { return; } @@ -226,6 +230,31 @@ pub fn update(m: &mut Mob, w: &MobWorld, events: &mut Vec) { m.extra.flag2 = !now; } } +/// The clocks and keyframe states `Creaking.aiStep`, `setupAnimationStates` +/// and `checkEyeBlink` run (the server's and a client's). +pub fn animate(m: &mut Mob) { + for slot in [INVULNERABLE, ATTACKING] { + if m.extra.ints[slot] > 0 { + m.extra.ints[slot] -= 1; + } + } + let age = m.age as f32; + m.anim.states[0].animate_when(m.extra.ints[ATTACKING] > 0, age); + m.anim.states[1].animate_when(m.extra.ints[INVULNERABLE] > 0, age); + m.anim.states[2].animate_when(tearing_down(m), age); + // checkEyeBlink: the eyes of a creaking falling apart flicker. + if m.death_time > m.extra.ints[NEXT_FLICKER] { + let glowing = m.extra.ints[EYES] != 0; + let (lo, hi) = if glowing { + (2, 8) + } else { + (m.death_time / 4, m.death_time / 2) + }; + let span = (hi - lo + 1).max(1); + m.extra.ints[NEXT_FLICKER] = m.death_time + lo + m.random.next_int_bound(span).unwrap_or(0); + m.extra.ints[EYES] = i32::from(!glowing); + } +} /// `Mob.stopInPlace`. pub fn stop_in_place(m: &mut Mob) { m.nav_stop(); diff --git a/crates/horizon-client/src/mobs/cube.rs b/crates/horizon-client/src/mobs/cube.rs index ea8a05392..3cc16463c 100644 --- a/crates/horizon-client/src/mobs/cube.rs +++ b/crates/horizon-client/src/mobs/cube.rs @@ -151,37 +151,49 @@ pub fn jump(m: &mut Mob) { }; m.velocity.y = f64::from(m.jump_power() + boost); } +/// `AbstractCubeMob.tick`'s landing splash: crumbs of goo (or flames) around +/// the cube's feet, drawn by the side that ticks the mob. +fn landing_splash(m: &mut Mob, events: &mut Vec) { + let size = m.width() * 2.0; + let radius = size / 2.0; + let kind = match m.species() { + Species::MagmaCube => "flame", + Species::SulfurCube => "sulfur_cube_goo", + _ => "item_slime", + }; + let mut i = 0; + while (i as f32) < size * 16.0 { + let dir = m.random.next_float() * std::f64::consts::TAU as f32; + let d = m.random.next_float() * 0.5 + 0.5; + let xd = trig::sin(f64::from(dir)) * radius * d; + let zd = trig::cos(f64::from(dir)) * radius * d; + events.push(MobEvent::Particles { + kind, + at: [ + m.position.x + f64::from(xd), + m.position.y, + m.position.z + f64::from(zd), + ], + count: 0, + }); + i += 1; + } +} +/// `AbstractCubeMob.tick` on a client of a server: the landing splash follows +/// the on-ground flag the server sends. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if m.on_ground && !m.extra.flag2 { + landing_splash(m, events); + } + m.extra.flag2 = m.on_ground; +} /// AbstractCubeMob.tick squish and landing sounds, plus contact damage. pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { let v = &mut m.anim.v; v[SQUISH] += (v[TARGET_SQUISH] - v[SQUISH]) * 0.5; let was = m.extra.flag2; if m.on_ground && !was { - // The landing splash: drawn on the server too, where it spawns nothing. - let size = m.width() * 2.0; - let radius = size / 2.0; - let kind = match m.species() { - Species::MagmaCube => "flame", - Species::SulfurCube => "sulfur_cube_goo", - _ => "item_slime", - }; - let mut i = 0; - while (i as f32) < size * 16.0 { - let dir = m.random.next_float() * std::f64::consts::TAU as f32; - let d = m.random.next_float() * 0.5 + 0.5; - let xd = trig::sin(f64::from(dir)) * radius * d; - let zd = trig::cos(f64::from(dir)) * radius * d; - events.push(MobEvent::Particles { - kind, - at: [ - m.position.x + f64::from(xd), - m.position.y, - m.position.z + f64::from(zd), - ], - count: 0, - }); - i += 1; - } + landing_splash(m, events); let squish = match (m.species(), tiny(m)) { (Species::SulfurCube, _) => super::sulfur_cube::squish_sound(m), (Species::MagmaCube, true) => "entity.magma_cube.squish_small", diff --git a/crates/horizon-client/src/mobs/dolphin.rs b/crates/horizon-client/src/mobs/dolphin.rs new file mode 100644 index 000000000..c9948f6fb --- /dev/null +++ b/crates/horizon-client/src/mobs/dolphin.rs @@ -0,0 +1,265 @@ +//! Dolphin goals: `DolphinSwimToTreasureGoal`, `DolphinSwimWithPlayerGoal` +//! and `DolphinJumpGoal`. `extra.flag` is `gotFish` and `extra.home` the +//! `treasurePos` the game found for it (`MobEvent::DolphinTreasure`). +use super::{ + Mob, MobEvent, Who, + goals::{Cx, Goal, JUMP, LOOK, MOVE, goal_clone, reduced}, +}; +use crate::blocks::Fluid; +use horizon_core::random::RandomSource; + +/// `Entity.getMotionDirection`: the horizontal step of the yaw +/// (`Direction.fromYRot`: south, west, north, east). +fn motion_step(yaw: f32) -> [i32; 2] { + match (yaw / 90.0 + 0.5).floor() as i32 & 3 { + 0 => [0, 1], + 1 => [-1, 0], + 2 => [0, -1], + _ => [1, 0], + } +} + +/// `DolphinSwimToTreasureGoal`: a dolphin that was fed a fish leads the way to +/// a shipwreck or an ocean ruin within 50 sectors. +#[derive(Clone, Debug, Default)] +pub struct SwimToTreasure { + stuck: bool, +} +impl SwimToTreasure { + /// `BlockPos.containing(x, dolphin.getY(), z).closerToCenterThan(position, 4)`. + fn arrived(m: &Mob) -> bool { + let Some(t) = m.extra.home else { return false }; + let d = [ + f64::from(t[0]) + 0.5 - m.position.x, + m.position.y.floor() + 0.5 - m.position.y, + f64::from(t[2]) + 0.5 - m.position.z, + ]; + d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < 16.0 + } +} +impl Goal for SwimToTreasure { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn interruptable(&self) -> bool { + false + } + fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + m.extra.flag && m.air >= 100 + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + m.extra.home.is_some() && !Self::arrived(m) && !self.stuck && m.air >= 100 + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.stuck = false; + m.nav_stop(); + // The game looks for the structure and sets the position, or none. + m.extra.home = None; + cx.events.push(MobEvent::DolphinTreasure { mob: m.id }); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + if m.extra.home.is_none() || Self::arrived(m) || self.stuck { + m.extra.flag = false; + } + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(t) = m.extra.home else { return }; + let close = m.ai.nav.target_pos.is_some_and(|p| { + let d = [ + f64::from(p[0]) + 0.5 - m.position.x, + f64::from(p[1]) + 0.5 - m.position.y, + f64::from(p[2]) + 0.5 - m.position.z, + ]; + d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < 144.0 + }); + if !close && !m.ai.nav.is_done() { + return; + } + let treasure = [ + f64::from(t[0]) + 0.5, + f64::from(t[1]) + 0.5, + f64::from(t[2]) + 0.5, + ]; + let eighth = f64::from(std::f32::consts::FRAC_PI_8); + let half = f64::from(std::f32::consts::FRAC_PI_2); + let mut next = m.default_random_pos_towards(cx.w, 16, 1, treasure, eighth); + if next.is_none() { + next = m.default_random_pos_towards(cx.w, 8, 4, treasure, half); + } + // isPathfindable(WATER) is a water fluid state. + if let Some(n) = next + && cx.w.fluid( + n[0].floor() as i32, + n[1].floor() as i32, + n[2].floor() as i32, + ) != Fluid::Water + { + next = m.default_random_pos_towards(cx.w, 8, 5, treasure, half); + } + let Some(next) = next else { + self.stuck = true; + return; + }; + let (y, x) = (m.kind.max_head_y_rot + 20.0, m.kind.max_head_x_rot); + m.look_at_speed(next, y, x); + m.nav_move_to(cx.w, next, 1.3); + if m.random.next_int_bound(80).unwrap_or(1) == 0 { + // Entity event 38: happy villager particles about the dolphin. + cx.events.push(MobEvent::AroundSelf { + mob: m.id, + event: 38, + kind: "happy_villager", + feet: [m.position.x, m.position.y, m.position.z], + width: f64::from(m.width()), + height: f64::from(m.height()), + burst: crate::particles::Burst::DOLPHIN, + }); + } + } +} + +/// `DolphinSwimWithPlayerGoal`: swim up to a swimming player and give them +/// Dolphin's Grace. +#[derive(Clone, Debug)] +pub struct SwimWithPlayer { + speed: f64, +} +impl SwimWithPlayer { + pub fn new(speed: f64) -> Self { + Self { speed } + } +} +impl Goal for SwimWithPlayer { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + // getNearestPlayer(forNonCombat().range(10).ignoreLineOfSight()). + m.can_see_player_through_walls(cx.w, 10.0) + && cx.w.player.as_ref().is_some_and(|p| p.swimming) + && m.ai.target != Some(Who::Player) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + cx.w.player + .as_ref() + .is_some_and(|p| p.swimming && m.distance_sqr(p.position) < 256.0) + } + fn start(&mut self, _: &mut Mob, cx: &mut Cx) { + cx.events.push(grace()); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + m.nav_stop(); + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(p) = cx.w.player.clone() else { return }; + let (y, x) = (m.kind.max_head_y_rot + 20.0, m.kind.max_head_x_rot); + m.look_at_speed(p.eye, y, x); + if m.distance_sqr(p.position) < 6.25 { + m.nav_stop(); + } else { + m.nav_move_to_entity( + cx.w, + [p.position.x, p.position.y, p.position.z], + 1, + self.speed, + ); + } + if p.swimming && m.random.next_int_bound(6).unwrap_or(1) == 0 { + cx.events.push(grace()); + } + } +} +/// `MobEffectInstance(DOLPHINS_GRACE, 100)`. +fn grace() -> MobEvent { + MobEvent::EffectPlayer { + effect: "minecraft:dolphins_grace", + ticks: 100, + amplifier: 0, + } +} + +/// `DolphinJumpGoal`: leap out of clear water and arc back in. +#[derive(Clone, Debug)] +pub struct Jump { + interval: i32, + breached: bool, +} +impl Jump { + pub fn new(interval: i32) -> Self { + Self { + interval: reduced(interval), + breached: false, + } + } +} +impl Goal for Jump { + goal_clone!(); + fn flags(&self) -> u8 { + JUMP | MOVE + } + fn interruptable(&self) -> bool { + false + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.random.next_int_bound(self.interval).unwrap_or(1) != 0 { + return false; + } + let [sx, sz] = motion_step(m.yaw); + let (bx, by, bz) = ( + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ); + let w = cx.w; + [0, 1, 4, 5, 6, 7].into_iter().all(|i| { + let (x, z) = (bx + sx * i, bz + sz * i); + // waterIsClear, then surfaceIsClear. + w.fluid(x, by, z) == Fluid::Water + && !w.has_tag("minecraft:blocks_dolphin_jump", w.block_name(x, by, z)) + && w.facts.is_air(w.world.block(x, by + 1, z)) + && w.facts.is_air(w.world.block(x, by + 2, z)) + }) + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + let yd = m.velocity.y; + (yd * yd >= f64::from(0.03f32) + || m.head_pitch == 0.0 + || m.head_pitch.abs() >= 10.0 + || !m.fluids.in_water) + && !m.on_ground + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + let [sx, sz] = motion_step(m.yaw); + m.velocity.x += f64::from(sx) * 0.6; + m.velocity.y += 0.7; + m.velocity.z += f64::from(sz) * 0.6; + m.nav_stop(); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + m.head_pitch = 0.0; + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let already = self.breached; + if !already { + self.breached = cx.w.fluid( + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ) == Fluid::Water; + } + if self.breached && !already { + m.sound("entity.dolphin.jump", cx.events); + } + let v = m.velocity; + if v.y * v.y < f64::from(0.03f32) && m.head_pitch != 0.0 { + // Mth.rotLerp(0.2, xRot, 0). + m.head_pitch += 0.2 * super::living::wrap(0.0 - m.head_pitch); + } else if v.length() > f64::from(1.0e-5f32) { + let horizontal = v.x.hypot(v.z); + m.head_pitch = ((-v.y).atan2(horizontal) * f64::from(180.0f32) + / f64::from(std::f32::consts::PI)) as f32; + } + } +} diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs index 3168d8f1e..d0159a619 100644 --- a/crates/horizon-client/src/mobs/drops.rs +++ b/crates/horizon-client/src/mobs/drops.rs @@ -244,7 +244,16 @@ pub fn slot_item(m: &Mob, slot: &str) -> Option { } _ => (None, None), }; - let mut stack = loot_stack(item?, 1); + // A panda keeps the whole stack it picked up in its mouth. + let count = if slot == "mainhand" && m.species() == Species::Panda { + super::panda::held_count(m) + } else { + 1 + }; + let mut stack = loot_stack(item?, count as i32); + if slot == "body" && m.species() == Species::Wolf { + stack.damage = m.extra.body_damage; + } if let (Some(index), Some(g)) = (index, gear::gear(m)) { for (e, l) in &g.slots[index] { stack.enchantments.push((e.to_string(), *l as i32)); @@ -282,6 +291,8 @@ pub fn clear_slot(m: &mut Mob, slot: &str) { } "body" if body => { m.extra.head = None; + m.extra.body_damage = 0; + m.extra.body_extra = None; return; } "saddle" => { @@ -305,6 +316,7 @@ fn loot_stack(item: &str, count: i32) -> LootStack { exploration: None, ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), } } /// `Mob.dropChances.byEquipment(slot)`: the recorded chance, or the one the @@ -504,13 +516,7 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec false, - Species::Hoglin => true, - s if is_monster(s) => true, - _ => !m.is_baby(), - }; - if killed_by_player && drops_experience && d.mob_drops { + if killed_by_player && drops_experience(m) && d.mob_drops { let mut amount = base_experience(m); while amount > 0 { let value = orb_value(amount); @@ -534,6 +540,16 @@ fn roll( None => Vec::new(), } } +/// `LivingEntity.shouldDropExperience`: babies drop none, except monsters and +/// hoglins; tadpoles never do. +pub fn drops_experience(m: &Mob) -> bool { + match m.species() { + Species::Tadpole => false, + Species::Hoglin => true, + s if is_monster(s) => true, + _ => !m.is_baby(), + } +} /// `getBaseExperienceReward` (no vanilla enchantment changes mob experience). pub fn base_experience(m: &mut Mob) -> i32 { use Species as S; diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs index 17566fb65..72c6a7ccd 100644 --- a/crates/horizon-client/src/mobs/enderman.rs +++ b/crates/horizon-client/src/mobs/enderman.rs @@ -97,10 +97,26 @@ pub fn teleport_to( return false; } let old = m.center(); + let old_block = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; m.position = Vec3::new(x, ny, z); m.previous = m.position; m.velocity = Vec3::ZERO; m.ai.nav.stop(); + if !m.silent { + // Level event 2018: the portal trail, from the old block to the new + // one, packed as `BlockUtil.clampedPackDifferenceInPosition` does. + let new_block = [x.floor() as i32, ny.floor() as i32, z.floor() as i32]; + let packed = |k: usize| ((new_block[k] - old_block[k]).clamp(-127, 127) + 127) & 255; + events.push(MobEvent::LevelEvent { + id: 2018, + pos: old_block, + data: packed(0) << 16 | packed(1) << 8 | packed(2), + }); + } events.push(MobEvent::Sound("entity.enderman.teleport", old, 1.0, 1.0)); events.push(MobEvent::Sound( "entity.enderman.teleport", @@ -138,6 +154,15 @@ fn teleport_towards( let z = m.position.z + (m.random.next_double() - 0.5) * 8.0 - d[2] * 16.0; teleport_to(m, w, x, y, z, events) } +/// `Enderman.SPEED_MODIFIER_ATTACKING`, an ADD_VALUE modifier `setTarget` +/// adds while the enderman has a target. +pub fn attacking_speed(m: &Mob) -> f64 { + if m.species() == Species::Enderman && m.ai.target.is_some() { + f64::from(0.15f32) + } else { + 0.0 + } +} /// Enderman.customServerAiStep: in daylight, flee by teleporting. The End has a /// fixed time, so `Level.isBrightOutside` is never true there. pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs index ccf4564ca..52f3d575f 100644 --- a/crates/horizon-client/src/mobs/finalize.rs +++ b/crates/horizon-client/src/mobs/finalize.rs @@ -516,9 +516,13 @@ fn effect_modifiers(m: &Mob, a: Attr) -> impl Iterator + '_ { } /// `AttributeInstance.getValue`: the base, then the modifiers by operation. pub fn value(m: &Mob, a: Attr) -> f64 { - compute(m, a, true) + compute(m, a, true, &[]) } -fn compute(m: &Mob, a: Attr, with_transient: bool) -> f64 { +/// `value` with more modifiers, such as the ones worn equipment grants. +pub fn value_with(m: &Mob, a: Attr, extra: &[(f64, Op)]) -> f64 { + compute(m, a, true, extra) +} +fn compute(m: &Mob, a: Attr, with_transient: bool, extra: &[(f64, Op)]) -> f64 { let mut base = base_value(m, a); let empty = Vec::new(); let mods = m.extra.attributes.as_ref().map_or(&empty, |s| &s.modifiers); @@ -531,6 +535,7 @@ fn compute(m: &Mob, a: Attr, with_transient: bool) -> f64 { ops.extend(transient(m, a)); ops.extend(effect_modifiers(m, a)); } + ops.extend(extra.iter().copied()); for (amount, op) in &ops { if *op == Op::AddValue { base += amount; @@ -573,7 +578,7 @@ fn refresh(m: &mut Mob, a: Attr) { /// The value without the transient baby modifier (`speed_bonus` applies /// that one to movement speed). fn base_with_modifiers(m: &Mob, a: Attr) -> f64 { - compute(m, a, false) + compute(m, a, false, &[]) } /// `AttributeInstance.setBaseValue`. pub fn set_base(m: &mut Mob, a: Attr, v: f64) { @@ -898,6 +903,28 @@ pub fn slot_enchantments(m: &Mob, slot: usize) -> gear::Levels { pub fn set_slot_enchantments(m: &mut Mob, slot: usize, levels: gear::Levels) { gear::set(m, gear_slot(slot), levels); } +/// `EquipmentUser.equip` for one rolled stack: `setItemSlot` puts the item in +/// `slot` with its own enchantments, then the slot's drop chance is stored +/// when the table names one. +pub fn equip_stack( + m: &mut Mob, + slot: usize, + stack: &horizon_world::loot::LootStack, + drop_chance: Option, +) { + set_item(m, slot, &stack.item); + if slot <= HEAD { + let levels = stack + .enchantments + .iter() + .map(|(id, level)| (Arc::from(id.as_str()), (*level).max(0) as u32)) + .collect(); + gear::set(m, gear_slot(slot), levels); + } + if let Some(chance) = drop_chance { + set_drop_chance(m, slot, chance); + } +} /// `Mob.setDropChance`. pub fn set_drop_chance(m: &mut Mob, slot: usize, chance: f32) { let c = m @@ -1691,13 +1718,7 @@ impl Ctx<'_, L, R> { let hidden = panda_gene(self.int(16)); m.extra.variant = main; m.extra.variant2 = hidden; - let shown = panda_variant(main, hidden); - if shown == 5 { - set_base(m, Attr::MaxHealth, 10.0); - } - if shown == 1 { - set_base(m, Attr::MovementSpeed, f64::from(0.07f32)); - } + super::panda::set_attributes(m); self.ageable(m, g.or(Some(Group::Ageable(Ageable::chance(0.2))))) } S::PolarBear | S::Ocelot => { @@ -1950,7 +1971,7 @@ fn set_memory(m: &mut Mob, name: &'static str, value: i64, ttl: i64) { } /// `Panda.Gene.getRandom` (enum order: normal, lazy, worried, playful, /// brown, weak, aggressive). -fn panda_gene(roll: i32) -> u8 { +pub fn panda_gene(roll: i32) -> u8 { match roll { 0 => 1, 1 => 2, diff --git a/crates/horizon-client/src/mobs/fox.rs b/crates/horizon-client/src/mobs/fox.rs new file mode 100644 index 000000000..833002b46 --- /dev/null +++ b/crates/horizon-client/src/mobs/fox.rs @@ -0,0 +1,845 @@ +//! Foxes (`net.minecraft.world.entity.animal.fox.Fox`): the goal list, the +//! flags byte (sleeping, sitting, crouching, interested, pouncing, +//! faceplanted), stalking and pouncing, napping in the shade by day, seeking +//! shelter, perching, eating berries and the food held in the mouth. +//! Picking up items, strolling through villages and trusting players (with +//! defending them) are not ported yet. +use super::{ + Mob, MobEvent, MobWorld, Seen, Species, + goals::{ + Avoid, AvoidEntity, Breed, Cx, Float, FollowParent, Goal, JUMP, LOOK, LeapAtTarget, + LookAtPlayer, MOVE, MeleeAttack, MoveToBlock, NearestTarget, Panic, Prey, Stroll, + goal_clone, hide_pos, reduced, + }, + living::wrap, +}; +use horizon_core::{ + geometry::{Axis, Vec3}, + jmath, + random::RandomSource, +}; +use horizon_world::registry::BlockStateId; + +// Fox.DATA_FLAGS_ID, kept in `extra.ints[0]` (and sent to clients as is). +pub const SITTING: i32 = 1; +pub const CROUCHING: i32 = 4; +pub const INTERESTED: i32 = 8; +pub const POUNCING: i32 = 16; +pub const SLEEPING: i32 = 32; +pub const FACEPLANTED: i32 = 64; +pub const DEFENDING: i32 = 128; +/// `Fox.ticksSinceEaten`. +const TICKS_SINCE_EATEN: usize = 1; +/// `Fox.interestedAngle` and `crouchAmount` in `anim.v`, the previous tick's +/// values in `anim.vo`. +const INTERESTED_ANGLE: usize = 0; +const CROUCH_AMOUNT: usize = 1; +/// `Fox.MAX_CROUCH_AMOUNT`. +const MAX_CROUCH_AMOUNT: f32 = 5.0; + +pub fn flag(m: &Mob, f: i32) -> bool { + m.extra.ints[0] & f != 0 +} +fn set_flag(m: &mut Mob, f: i32, on: bool) { + if on { + m.extra.ints[0] |= f; + } else { + m.extra.ints[0] &= !f; + } +} +/// `Fox.clearStates`. +fn clear_states(m: &mut Mob) { + m.extra.ints[0] = 0; +} +/// `Fox.canMove`, which `FoxMoveControl` waits for. +pub fn can_move(m: &Mob) -> bool { + !flag(m, SLEEPING | SITTING | FACEPLANTED) +} +/// `FoxLookControl.resetXRotOnTick`: stalking and pouncing keep their pitch. +pub fn resets_x_rot(m: &Mob) -> bool { + !flag(m, POUNCING | CROUCHING | INTERESTED | FACEPLANTED) +} + +/// `Fox.registerGoals` and `setTargetGoals` (the targets wait for the variant: +/// red foxes prefer chickens and rabbits, snow foxes fish). +pub fn register(m: &mut Mob) { + let countdown = m.random.next_int_bound(reduced(140)).unwrap_or(0); + let g = &mut m.ai.goals; + g.add(0, Wrap::new(Float).on_start(clear_states)); + g.add(1, Faceplant { countdown: 0 }); + g.add(2, Panic::new(2.2)); + g.add(3, Wrap::new(Breed::new(1.0)).on_start(clear_states)); + // AVOID_PLAYERS: not a sneaking player. + g.add( + 4, + AvoidEntity::new(Avoid::Player, 16.0, 1.6, 1.4) + .player_when(|p| !p.sneaking && !p.spectator), + ); + g.add( + 4, + AvoidEntity::new(Avoid::Species(vec![Species::Wolf]), 8.0, 1.6, 1.4).seen_when(|s| !s.tame), + ); + g.add( + 4, + AvoidEntity::new(Avoid::Species(vec![Species::PolarBear]), 8.0, 1.6, 1.4), + ); + g.add(5, StalkPrey); + g.add(6, Pounce); + g.add(6, SeekShelter::new(1.25)); + g.add( + 7, + Wrap::new(MeleeAttack::new(1.2, true)) + .when( + |m| !flag(m, SITTING | SLEEPING | CROUCHING | FACEPLANTED), + false, + ) + .on_start(|m| set_flag(m, INTERESTED, false)), + ); + g.add(7, Sleep { countdown }); + g.add(8, Wrap::new(FollowParent::new(1.25)).on_start(clear_states)); + g.add(10, EatBerries::new()); + g.add(10, LeapAtTarget::new(0.4)); + g.add(11, Stroll::avoiding_water(1.0)); + // FoxLookAtPlayerGoal: not with the nose in the snow or while stalking. + g.add( + 12, + Wrap::new(LookAtPlayer::new(24.0)).when(|m| !flag(m, FACEPLANTED | INTERESTED), true), + ); + g.add(13, Perch::default()); + let red = |m: &Mob, _: &MobWorld| m.extra.variant == 0; + let snow = |m: &Mob, _: &MobWorld| m.extra.variant != 0; + let land = || NearestTarget::new(Prey::Filter(chicken_or_rabbit), false).interval(10); + let turtle = || NearestTarget::new(Prey::Filter(baby_turtle_on_land), false).interval(10); + let fish = || NearestTarget::new(Prey::Filter(schooling_fish), false).interval(20); + let t = &mut m.ai.targets; + t.add(4, land().gate(red)); + t.add(4, turtle().gate(red)); + t.add(6, fish().gate(red)); + t.add(4, fish().gate(snow)); + t.add(6, land().gate(snow)); + t.add(6, turtle().gate(snow)); +} + +fn chicken_or_rabbit(s: &Seen) -> bool { + matches!(s.species, Species::Chicken | Species::Rabbit) +} +fn baby_turtle_on_land(s: &Seen) -> bool { + s.species == Species::Turtle && s.baby && !s.in_water +} +fn schooling_fish(s: &Seen) -> bool { + matches!( + s.species, + Species::Cod | Species::Salmon | Species::TropicalFish + ) +} + +/// The part of `Fox.tick` a client runs too: the head tilt eases toward the +/// interested flag and the crouch builds up to 5 while crouching. +pub fn client_tick(m: &mut Mob) { + let (interested, crouching) = (flag(m, INTERESTED), flag(m, CROUCHING)); + let v = &mut m.anim.v; + m.anim.vo[INTERESTED_ANGLE] = v[INTERESTED_ANGLE]; + v[INTERESTED_ANGLE] += (if interested { 1.0 } else { 0.0 } - v[INTERESTED_ANGLE]) * 0.4; + m.anim.vo[CROUCH_AMOUNT] = v[CROUCH_AMOUNT]; + v[CROUCH_AMOUNT] = if crouching { + (v[CROUCH_AMOUNT] + 0.2).min(MAX_CROUCH_AMOUNT) + } else { + 0.0 + }; +} +/// `Fox.isFullyCrouched`. +fn fully_crouched(m: &Mob) -> bool { + m.anim.v[CROUCH_AMOUNT] == MAX_CROUCH_AMOUNT +} + +/// `Fox.tick` and the eating part of `Fox.aiStep`. +pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { + client_tick(m); + if !m.alive() { + return; + } + m.extra.ints[TICKS_SINCE_EATEN] += 1; + if let Some(item) = m.extra.main_hand.clone() + && eats(w, &item) + && m.ai.target.is_none() + && m.on_ground + && !flag(m, SLEEPING) + { + let eaten = m.extra.ints[TICKS_SINCE_EATEN]; + if eaten > 600 { + // ItemStack.finishUsingItem: the food is gone, a use remainder stays. + m.extra.main_hand = w + .items + .and_then(|i| i.items.get(&item)) + .and_then(|i| i.use_remainder.as_deref()) + .map(Into::into); + m.extra.ints[TICKS_SINCE_EATEN] = 0; + } else if eaten > 560 && m.random.next_float() < 0.1 { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound("entity.fox.eat", at, 1.0, 1.0)); + } + } + if !m.target_info(w).is_some_and(|t| t.alive) { + set_flag(m, CROUCHING | INTERESTED, false); + } + let in_water = m.fluids.in_water; + if in_water || m.ai.target.is_some() || w.thundering { + set_flag(m, SLEEPING, false); + } + if in_water || flag(m, SLEEPING) { + set_flag(m, SITTING, false); + } + // Faceplanted: crumbs of the snow now and then (level event 2001). + if flag(m, FACEPLANTED) && m.random.next_float() < 0.2 { + let at = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + events.push(MobEvent::LevelEvent { + id: 2001, + pos: at, + data: w.world.block(at[0], at[1], at[2]).0 as i32, + }); + } +} +/// `Fox.aiStep` before the living step: a sleeping fox takes no input. +pub fn pre_ai_step(m: &mut Mob) { + if flag(m, SLEEPING) { + m.ai.jumping = false; + m.ai.xxa = 0.0; + m.ai.zza = 0.0; + } +} +/// `Fox.isConsumableFood`: the item has food and consumable components. +fn eats(w: &MobWorld, item: &str) -> bool { + w.items + .and_then(|i| i.items.get(item)) + .is_some_and(|i| i.food.is_some() && i.consumable.is_some()) +} + +/// `Fox.FoxBehaviorGoal.hasShelter`: out of the sky's sight and not a bad spot. +fn has_shelter(m: &Mob, w: &MobWorld) -> bool { + let at = [ + m.position.x.floor() as i32, + m.bounds().max(Axis::Y).floor() as i32, + m.position.z.floor() as i32, + ]; + !w.can_see_sky(at[0], at[1], at[2]) && m.walk_target_value(w, at) >= 0.0 +} +/// `Fox.FoxBehaviorGoal.alertable`: someone within 12 blocks the fox would +/// keep watch over (`FoxAlertableEntitiesSelector`). +fn alertable(m: &Mob, w: &MobWorld) -> bool { + let (from, id, y) = (m.position, m.id, m.position.y); + let mob = w + .nearby(from, 12.0, |s: &Seen| { + s.id != id + && (s.position.y - y).abs() <= 6.0 + && m.distance_sqr(s.position) <= 144.0 + && match s.species { + Species::Fox => false, + Species::Chicken | Species::Rabbit => true, + Species::Wolf | Species::Cat | Species::Parrot | Species::Nautilus => !s.tame, + _ => true, + } + }) + .next() + .is_some(); + mob || w.player.as_ref().is_some_and(|p| { + p.alive + && !p.creative + && !p.spectator + && !p.sneaking + && (p.position.y - y).abs() <= 6.0 + && m.distance_sqr(p.position) <= 144.0 + }) +} + +/// `Fox.SleepGoal`: nap in the shade by day when nothing is around. +#[derive(Clone, Debug)] +struct Sleep { + countdown: i32, +} +impl Sleep { + fn can_sleep(&mut self, m: &Mob, w: &MobWorld) -> bool { + if self.countdown > 0 { + self.countdown -= 1; + return false; + } + let (x, y, z) = ( + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ); + w.daylight + && has_shelter(m, w) + && !alertable(m, w) + && w.block_name(x, y, z) != "minecraft:powder_snow" + } +} +impl Goal for Sleep { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK | JUMP + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + m.ai.nav.is_done() && (self.can_sleep(m, cx.w) || flag(m, SLEEPING)) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.can_sleep(m, cx.w) + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, SITTING | CROUCHING | INTERESTED, false); + m.ai.jumping = false; + set_flag(m, SLEEPING, true); + m.nav_stop(); + let p = m.position; + m.ai.mov.set_wanted(p.x, p.y, p.z, 0.0); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + self.countdown = m.random.next_int_bound(reduced(140)).unwrap_or(0); + clear_states(m); + } +} + +/// A shared goal under the fox's own conditions and start-up: the extra +/// `canUse` of `FoxMeleeAttackGoal` and `FoxLookAtPlayerGoal` and the +/// `clearStates` or `setIsInterested(false)` its subclasses do in `start`. +#[derive(Clone, Debug)] +struct Wrap { + goal: G, + when: Option bool>, + /// The condition also applies to `canContinueToUse`. + both: bool, + on_start: Option, +} +impl Wrap { + fn new(goal: G) -> Self { + Self { + goal, + when: None, + both: false, + on_start: None, + } + } + fn when(mut self, f: fn(&Mob) -> bool, both: bool) -> Self { + (self.when, self.both) = (Some(f), both); + self + } + fn on_start(mut self, f: fn(&mut Mob)) -> Self { + self.on_start = Some(f); + self + } +} +impl Goal for Wrap { + goal_clone!(); + fn flags(&self) -> u8 { + self.goal.flags() + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.when.is_none_or(|f| f(m)) && self.goal.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + (!self.both || self.when.is_none_or(|f| f(m))) && self.goal.can_continue(m, cx) + } + fn interruptable(&self) -> bool { + self.goal.interruptable() + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + if let Some(f) = self.on_start { + f(m); + } + self.goal.start(m, cx); + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.goal.stop(m, cx); + } + fn every_tick(&self) -> bool { + self.goal.every_tick() + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + self.goal.tick(m, cx); + } + fn name(&self) -> &'static str { + self.goal.name() + } +} + +/// `Fox.isPathClear`: six points along the way to the target, each with +/// nothing but replaceable blocks in the three above it. +fn path_clear(m: &Mob, w: &MobWorld, to: Vec3) -> bool { + let (zdiff, xdiff) = (to.z - m.position.z, to.x - m.position.x); + let slope = zdiff / xdiff; + for i in 0..6 { + let step = f64::from(i as f32 / 6.0); + let z = if slope == 0.0 { 0.0 } else { zdiff * step }; + let x = if slope == 0.0 { + xdiff * step + } else { + z / slope + }; + for j in 1..4 { + let at = [ + (m.position.x + x).floor() as i32, + (m.position.y + f64::from(j)).floor() as i32, + (m.position.z + z).floor() as i32, + ]; + if !w.facts.get(w.world.block(at[0], at[1], at[2])).replaceable { + return false; + } + } + } + true +} +fn signum(x: f64) -> f64 { + if x > 0.0 { + 1.0 + } else if x < 0.0 { + -1.0 + } else { + 0.0 + } +} + +/// `Fox.FaceplantGoal`: stay put for 40 ticks with the nose in the snow. +#[derive(Clone, Debug)] +struct Faceplant { + countdown: i32, +} +impl Goal for Faceplant { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK | JUMP + } + fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + flag(m, FACEPLANTED) + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + flag(m, FACEPLANTED) && self.countdown > 0 + } + fn start(&mut self, _: &mut Mob, _: &mut Cx) { + self.countdown = reduced(40); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, FACEPLANTED, false); + } + fn tick(&mut self, _: &mut Mob, _: &mut Cx) { + self.countdown -= 1; + } +} + +/// `Fox.StalkPreyGoal`: creep up on a chicken or rabbit more than 6 blocks +/// away, then crouch and keep still once it is within 6. +#[derive(Clone, Debug)] +struct StalkPrey; +impl StalkPrey { + fn look(m: &mut Mob, eye: [f64; 3]) { + let (y, x) = (m.kind.max_head_y_rot, m.kind.max_head_x_rot); + m.look_at_speed(eye, y, x); + } +} +impl Goal for StalkPrey { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if flag(m, SLEEPING) { + return false; + } + let Some(t) = m.target_info(cx.w) else { + return false; + }; + let stalkable = match m.ai.target { + Some(super::Who::Mob(id)) => { + cx.w.seen(id) + .is_some_and(|s| matches!(s.species, Species::Chicken | Species::Rabbit)) + } + _ => false, + }; + t.alive + && stalkable + && m.distance_sqr(t.position) > 36.0 + && !flag(m, CROUCHING | INTERESTED) + && !m.ai.jumping + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, SITTING | FACEPLANTED, false); + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + match m.target_info(cx.w) { + Some(t) if path_clear(m, cx.w, t.position) => { + set_flag(m, INTERESTED | CROUCHING, true); + m.nav_stop(); + Self::look(m, [t.position.x, t.eye_y, t.position.z]); + } + _ => set_flag(m, INTERESTED | CROUCHING, false), + } + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(t) = m.target_info(cx.w) else { return }; + Self::look(m, [t.position.x, t.eye_y, t.position.z]); + if m.distance_sqr(t.position) <= 36.0 { + set_flag(m, INTERESTED | CROUCHING, true); + m.nav_stop(); + } else { + let at = [t.position.x, t.position.y, t.position.z]; + m.nav_move_to_entity(cx.w, at, 0, 1.5); + } + } +} + +/// `Fox.FoxPounceGoal`: once fully crouched with a clear path, leap at the +/// target, tilt with the flight and bite when within 2 blocks, or end up with +/// the nose in snow. +#[derive(Clone, Debug)] +struct Pounce; +impl Goal for Pounce { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | JUMP + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if !fully_crouched(m) { + return false; + } + let Some(t) = m.target_info(cx.w).filter(|t| t.alive) else { + return false; + }; + let clear = path_clear(m, cx.w, t.position); + if !clear { + set_flag(m, CROUCHING | INTERESTED, false); + } + clear + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if !m.target_info(cx.w).is_some_and(|t| t.alive) { + return false; + } + let yd = m.velocity.y; + (yd * yd >= f64::from(0.05f32) || m.head_pitch.abs() >= 15.0 || !m.on_ground) + && !flag(m, FACEPLANTED) + } + fn interruptable(&self) -> bool { + false + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + m.ai.jumping = true; + set_flag(m, POUNCING, true); + set_flag(m, INTERESTED, false); + if let Some(t) = m.target_info(cx.w) { + m.look_at_speed([t.position.x, t.eye_y, t.position.z], 60.0, 30.0); + let u = m.position.vector_to(t.position).normalize(); + m.velocity = m.velocity.add_vector(Vec3::new(u.x * 0.8, 0.9, u.z * 0.8)); + } + m.nav_stop(); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, CROUCHING | INTERESTED | POUNCING, false); + m.anim.v[CROUCH_AMOUNT] = 0.0; + m.anim.vo[CROUCH_AMOUNT] = 0.0; + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let target = m.target_info(cx.w); + if let Some(t) = &target { + m.look_at_speed([t.position.x, t.eye_y, t.position.z], 60.0, 30.0); + } + if !flag(m, FACEPLANTED) { + let v = m.velocity; + if v.y * v.y < f64::from(0.03f32) && m.head_pitch != 0.0 { + m.head_pitch += 0.2 * wrap(-m.head_pitch); + } else { + let horizontal = v.horizontal_distance(); + let bias = if m.ai.jumping && v.y > 0.0 { 6.5 } else { 1.0 }; + let y = v.y * bias; + let len = (horizontal * horizontal + y * y).sqrt(); + if len > f64::from(1.0e-5f32) { + let pitch = signum(-y) * jmath::acos(horizontal / len) * 180.0 + / f64::from(std::f32::consts::PI); + m.head_pitch = (pitch as f32 % 360.0).clamp(-90.0, 90.0); + } + } + } + if let (Some(t), Some(who)) = (&target, m.ai.target) + && m.distance_sqr(t.position) <= 4.0 + { + super::ai::do_hurt_target(m, who, cx); + } else if m.head_pitch > 0.0 + && m.on_ground + && m.velocity.y as f32 != 0.0 + && cx.w.block_name( + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ) == "minecraft:snow" + { + m.head_pitch = 60.0; + m.ai.target = None; + set_flag(m, FACEPLANTED, true); + } + } +} + +/// `Fox.SeekShelterGoal`: by day, or in a thunderstorm, leave open sky for +/// somewhere the sky does not see. Villages are not told apart yet (vanilla +/// stays put in one). +#[derive(Clone, Debug)] +struct SeekShelter { + speed: f64, + interval: i32, + wanted: [f64; 3], +} +impl SeekShelter { + fn new(speed: f64) -> Self { + Self { + speed, + interval: reduced(100), + wanted: [0.0; 3], + } + } + fn set_wanted_pos(&mut self, m: &mut Mob, w: &MobWorld) -> bool { + hide_pos(m, w).is_some_and(|at| { + self.wanted = at; + true + }) + } +} +impl Goal for SeekShelter { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if flag(m, SLEEPING) || m.ai.target.is_some() { + return false; + } + let at = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + let sees_sky = cx.w.can_see_sky(at[0], at[1], at[2]); + if cx.w.thundering && sees_sky { + self.set_wanted_pos(m, cx.w) + } else if self.interval > 0 { + self.interval -= 1; + false + } else { + self.interval = 100; + cx.w.daylight && sees_sky && self.set_wanted_pos(m, cx.w) + } + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + !m.ai.nav.is_done() + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + clear_states(m); + m.nav_move_to(cx.w, self.wanted, self.speed); + } +} + +/// `Fox.PerchAndSearchGoal`: now and then sit down and look around two to +/// four times when nothing is going on. +#[derive(Clone, Debug, Default)] +struct Perch { + rel: [f64; 2], + look_time: i32, + looks_remaining: i32, +} +impl Perch { + fn reset_look(&mut self, m: &mut Mob) { + let angle = std::f64::consts::TAU * m.random.next_double(); + self.rel = [angle.cos(), angle.sin()]; + self.look_time = reduced(80 + m.random.next_int_bound(20).unwrap_or(0)); + } +} +impl Goal for Perch { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + m.ai.last_hurt_by.is_none() + && m.random.next_float() < 0.02 + && !flag(m, SLEEPING) + && m.ai.target.is_none() + && m.ai.nav.is_done() + && !alertable(m, cx.w) + && !flag(m, POUNCING | CROUCHING) + } + fn can_continue(&mut self, _: &mut Mob, _: &mut Cx) -> bool { + self.looks_remaining > 0 + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + self.reset_look(m); + self.looks_remaining = 2 + m.random.next_int_bound(3).unwrap_or(0); + set_flag(m, SITTING, true); + m.nav_stop(); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, SITTING, false); + } + fn tick(&mut self, m: &mut Mob, _: &mut Cx) { + self.look_time -= 1; + if self.look_time <= 0 { + self.looks_remaining -= 1; + self.reset_look(m); + } + let at = [ + m.position.x + self.rel[0], + m.eye_y(), + m.position.z + self.rel[1], + ]; + let (y, x) = (m.kind.max_head_y_rot, m.kind.max_head_x_rot); + m.look_at_speed(at, y, x); + } +} + +/// `BlockState` with one property changed. +fn with_prop(w: &MobWorld, p: [i32; 3], key: &str, value: &str) -> Option { + let mut s = w.registry.state(w.world.block(p[0], p[1], p[2]))?.clone(); + s.properties.insert(key.into(), value.into()); + w.registry.id(&s) +} +/// `FoxEatBerriesGoal.isValidTarget`: a ripe sweet berry bush or glow berries. +fn has_berries(w: &MobWorld, p: [i32; 3]) -> bool { + match w.block_name(p[0], p[1], p[2]) { + "minecraft:sweet_berry_bush" => w + .prop(p[0], p[1], p[2], "age") + .and_then(|a| a.parse::().ok()) + .is_some_and(|a| a >= 2), + "minecraft:cave_vines" | "minecraft:cave_vines_plant" => { + w.prop(p[0], p[1], p[2], "berries") == Some("true") + } + _ => false, + } +} + +/// `Fox.FoxEatBerriesGoal`: walk to a ripe berry bush and pick it after 40 ticks. +#[derive(Clone, Debug)] +struct EatBerries { + block: MoveToBlock, + waited: i32, +} +impl EatBerries { + fn new() -> Self { + Self { + block: MoveToBlock::new(1.2, 12, 1), + waited: 0, + } + } + fn pick(&mut self, m: &mut Mob, cx: &mut Cx) { + let p = self.block.block; + let at = [ + f64::from(p[0]) + 0.5, + f64::from(p[1]) + 0.5, + f64::from(p[2]) + 0.5, + ]; + if cx.w.block_name(p[0], p[1], p[2]) == "minecraft:sweet_berry_bush" { + let age: i32 = + cx.w.prop(p[0], p[1], p[2], "age") + .and_then(|a| a.parse().ok()) + .unwrap_or(0); + let mut count = 1 + m.random.next_int_bound(2).unwrap_or(0) + i32::from(age == 3); + if m.extra.main_hand.is_none() { + m.extra.main_hand = Some("minecraft:sweet_berries".into()); + count -= 1; + } + if count > 0 { + cx.events.push(MobEvent::DropItem { + item: "minecraft:sweet_berries".into(), + count: count as u32, + at, + }); + } + if let Some(state) = with_prop(cx.w, p, "age", "1") { + cx.events.push(MobEvent::SetBlock { pos: p, state }); + } + cx.events.push(MobEvent::Sound( + "block.sweet_berry_bush.pick_berries", + at, + 1.0, + 1.0, + )); + } else { + // CaveVines.use: one glow berry, the vine goes back to bare. + cx.events.push(MobEvent::DropItem { + item: "minecraft:glow_berries".into(), + count: 1, + at, + }); + if let Some(state) = with_prop(cx.w, p, "berries", "false") { + cx.events.push(MobEvent::SetBlock { pos: p, state }); + } + let pitch = 0.8 + m.random.next_float() * 0.4; + cx.events.push(MobEvent::Sound( + "block.cave_vines.pick_berries", + at, + 1.0, + pitch, + )); + } + } +} +impl Goal for EatBerries { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | JUMP + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if flag(m, SLEEPING) { + return false; + } + // MoveToBlockGoal.canUse draws the next delay only once the last one + // has run out. + if self.block.next_start > 0 { + self.block.next_start -= 1; + return false; + } + let next = reduced(200 + m.random.next_int_bound(200).unwrap_or(0)); + self.block.can_use(m, cx.w, next, has_berries) + } + fn can_continue(&mut self, _: &mut Mob, cx: &mut Cx) -> bool { + self.block.can_continue(cx.w, has_berries) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.waited = 0; + set_flag(m, SITTING, false); + self.block.start(m, cx.w); + } + fn every_tick(&self) -> bool { + true + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + if self.block.reached { + if self.waited >= 40 { + if cx.w.mob_griefing { + self.pick(m, cx); + } + } else { + self.waited += 1; + } + } else if m.random.next_float() < 0.05 { + let at = [m.position.x, m.position.y, m.position.z]; + cx.events + .push(MobEvent::Sound("entity.fox.sniff", at, 1.0, 1.0)); + } + self.block.tick_within(m, cx.w, 2.0); + } +} + +/// `FoxRenderState` as the renderer reads it: the flags, `getHeadRollAngle` +/// and `getCrouchAmount` at the partial tick. `FoxModel.legMotionPos` gains +/// 0.67 a frame; this takes 60 frames a second. +pub fn pose(m: &Mob, partial: f32) -> super::body_anim::Fox { + super::body_anim::Fox { + crouching: flag(m, CROUCHING), + sleeping: flag(m, SLEEPING), + sitting: flag(m, SITTING), + pouncing: flag(m, POUNCING), + faceplanted: flag(m, FACEPLANTED), + head_roll_angle: m.anim.lerp(INTERESTED_ANGLE, partial) * 0.11 * std::f32::consts::PI, + crouch_amount: m.anim.lerp(CROUCH_AMOUNT, partial), + leg_motion_pos: (m.age as f32 + partial) * 0.67 * 3.0, + } +} diff --git a/crates/horizon-client/src/mobs/frog.rs b/crates/horizon-client/src/mobs/frog.rs new file mode 100644 index 000000000..4fbb6a849 --- /dev/null +++ b/crates/horizon-client/src/mobs/frog.rs @@ -0,0 +1,312 @@ +//! Frogs (`Frog`, `FrogAi`): the `Croak` and `ShootTongue` behaviours as +//! goals, the poses they set and the client's animation states. +//! AnimState states: jump, croak, tongue, swim idle. +//! +//! The brain's idle `RunOne` picks a croak three times as often as a stroll +//! (weights 3 and 1; it also holds a do-nothing option that only repeats +//! the pick), so a frog that is not walking croaks in three of four idle +//! picks: `Croak` takes those, and the frog's stroll then follows at once. +use super::{ + Mob, MobEvent, MobWorld, Species, Who, + goals::{ + Cx, Float, Goal, LOOK, LookAtPlayer, MOVE, Panic, RandomLookAround, Stroll, goal_clone, + }, + sync, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +const JUMP: usize = 0; +const CROAK: usize = 1; +const TONGUE: usize = 2; +const SWIM_IDLE: usize = 3; + +/// `Croak.CROAK_TICKS`. +const CROAK_TICKS: i32 = 60; +/// `ShootTongue`'s duration and eating distance. +const TONGUE_TIME_OUT: i32 = 100; +const EATING_DISTANCE: f64 = 1.75; +/// `FrogAttackablesSensor.TARGET_DETECTION_DISTANCE` and the sensor's scan +/// rate. +const DETECTION_DISTANCE: f64 = 10.0; +const SCAN_RATE: i32 = 20; + +/// `ShootTongue.State`. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +enum Phase { + MoveToTarget, + CatchAnimation, + EatAnimation, + #[default] + Done, +} + +/// The frog's brain memories and `DATA_TONGUE_TARGET_ID`. +#[derive(Clone, Debug, Default)] +pub struct State { + croak: i32, + /// Ticks to the attackables sensor's next scan, and `NEAREST_ATTACKABLE`. + scan: i32, + nearest: Option, + /// `UNREACHABLE_TONGUE_TARGETS`: the mob and the ticks it stays in mind. + unreachable: Vec<(u32, i32)>, + /// `ATTACK_TARGET` while `ShootTongue` runs, and the synched tongue target. + target: Option, + pub tongue_target: Option, + phase: Phase, + eat_timer: i32, + path_counter: i32, + time: i32, +} + +pub fn register(m: &mut Mob) { + // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true). The + // frog's movement speed is 1.0, so the controller's 0.1 outside-water + // speed is what keeps a walking frog at vanilla's pace; the plain ground + // controller walks ten times too fast (#2213). + m.ai.mov.kind = super::control::MoveKind::SmoothSwimming { + max_turn_x: 85.0, + max_turn_y: 10.0, + in_water: 0.02, + outside: 0.1, + gravity: true, + }; + let g = &mut m.ai.goals; + g.add(0, Float); + g.add(1, Panic::new(1.25)); + g.add(2, ShootTongue); + g.add(4, Croak); + g.add(5, Stroll::avoiding_water(1.0).interval(1)); + g.add(6, LookAtPlayer::new(6.0)); + g.add(7, RandomLookAround::default()); +} + +/// `Entity.setPose` and `Frog.onSyncedDataUpdated(DATA_POSE)`. +pub fn set_pose(m: &mut Mob, id: u8) { + let old = std::mem::replace(&mut m.extra.pose, id); + if old != id { + pose_changed(m); + } +} +/// The animation states of the pose the frog has taken. +pub fn pose_changed(m: &mut Mob) { + let age = m.age as f32; + let pose = m.extra.pose; + let states = &mut m.anim.states; + for (state, on) in [ + (JUMP, pose == sync::LONG_JUMPING), + (CROAK, pose == sync::CROAKING), + (TONGUE, pose == sync::USING_TONGUE), + ] { + if on { + states[state].start(age); + } else { + states[state].stop(); + } + } +} +/// `Frog.tick` on a client: the idle swim while it floats still. The server +/// runs it too, for a window that shows its own mobs. +pub fn tick(m: &mut Mob) { + let age = m.age as f32; + let still = m.fluids.in_water && m.limb_speed <= 1.0e-5; + m.anim.states[SWIM_IDLE].animate_when(still, age); +} + +/// `Frog.canEat`: a slime or magma cube of size 1. +fn can_eat(species: Species, size: i32) -> bool { + matches!(species, Species::Slime | Species::MagmaCube) && size == 1 +} + +/// `FrogAttackablesSensor` (every 20 ticks) and the memory timers. +pub fn server_ai_step(m: &mut Mob, w: &MobWorld) { + let f = &mut m.extra.frog; + f.unreachable.retain_mut(|(_, ttl)| { + *ttl -= 1; + *ttl > 0 + }); + f.scan -= 1; + if f.scan > 0 { + return; + } + f.scan = SCAN_RATE; + let unreachable: Vec = f.unreachable.iter().map(|u| u.0).collect(); + let eye = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let nearest = w + .nearby(m.position, DETECTION_DISTANCE, |s| { + can_eat(s.species, s.size) + && !unreachable.contains(&s.id) + && w.line_of_sight(eye, Vec3::new(s.position.x, s.eye_y, s.position.z)) + }) + .find(|s| s.position.distance_squared(m.position) < DETECTION_DISTANCE * DETECTION_DISTANCE) + .map(|s| s.id); + m.extra.frog.nearest = nearest; +} + +/// `Croak`: the pose sync::CROAKING for 60 ticks (the croak is the frog's ambient +/// sound). +#[derive(Clone, Debug)] +struct Croak; +impl Goal for Croak { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + // checkExtraStartConditions (standing), no walk target, and not in + // a liquid (start does nothing there). + m.extra.pose == sync::STANDING + && m.on_ground + && !m.fluids.in_water + && !m.fluids.in_lava + && m.ai.nav.is_done() + && m.random.next_int_bound(4).unwrap_or(0) != 0 + } + fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + m.extra.frog.croak < CROAK_TICKS + } + fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.extra.frog.croak = 0; + set_pose(m, sync::CROAKING); + } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + set_pose(m, sync::STANDING); + } + fn tick(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.extra.frog.croak += 1; + } + fn every_tick(&self) -> bool { + true + } +} + +/// `ShootTongue` with the tongue activity's `StartAttacking` and +/// `StopAttackingIfTargetInvalid`: walk up to a small slime or magma cube, +/// shoot the tongue, pull it in and eat it. +#[derive(Clone, Debug)] +struct ShootTongue; +impl Goal for ShootTongue { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let Some(id) = m.extra.frog.nearest else { + return false; + }; + // The start conditions: no walk target, no panic, not croaking. + if m.ai.panicking || m.extra.pose == sync::CROAKING || !m.ai.nav.is_done() { + return false; + } + let Some(t) = cx.w.seen(id).filter(|t| t.alive) else { + m.extra.frog.nearest = None; + return false; + }; + // canPathfindToTarget: a path that ends at the target. + let at = [t.position.x, t.position.y, t.position.z]; + let ends = m + .create_path_to_entity(cx.w, at, 0) + .is_some_and(|p| f64::from(p.dist_to_target) < EATING_DISTANCE); + if !ends { + // The target is forgotten and not taken for 100 ticks. + let f = &mut m.extra.frog; + f.nearest = None; + if !f.unreachable.iter().any(|u| u.0 == id) { + if f.unreachable.len() == 5 { + f.unreachable.remove(0); + } + f.unreachable.push((id, 100)); + } + return false; + } + m.extra.frog.target = Some(id); + true + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let f = &m.extra.frog; + f.phase != Phase::Done + && f.time <= TONGUE_TIME_OUT + && !m.ai.panicking + && f.target + .is_some_and(|id| cx.w.seen(id).is_some_and(|t| t.alive)) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(t) = m.extra.frog.target.and_then(|id| cx.w.seen(id)) else { + return; + }; + let at = [t.position.x, t.position.y, t.position.z]; + let eye = [t.position.x, t.eye_y, t.position.z]; + m.look_at(eye); + m.extra.frog.tongue_target = m.extra.frog.target; + m.nav_move_to_entity(cx.w, at, 0, 2.0); + let f = &mut m.extra.frog; + f.path_counter = 10; + f.time = 0; + f.phase = Phase::MoveToTarget; + } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + let f = &mut m.extra.frog; + f.target = None; + f.tongue_target = None; + f.phase = Phase::Done; + set_pose(m, sync::STANDING); + } + fn every_tick(&self) -> bool { + true + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(id) = m.extra.frog.target else { + return; + }; + let Some(t) = cx.w.seen(id) else { + return; + }; + let (at, pos) = ([t.position.x, t.position.y, t.position.z], t.position); + m.look_at([t.position.x, t.eye_y, t.position.z]); + m.extra.frog.tongue_target = Some(id); + m.extra.frog.time += 1; + let here = [m.position.x, m.position.y, m.position.z]; + match m.extra.frog.phase { + Phase::MoveToTarget => { + if pos.distance_squared(m.position) < EATING_DISTANCE * EATING_DISTANCE { + cx.events + .push(MobEvent::Sound("entity.frog.tongue", here, 2.0, 1.0)); + set_pose(m, sync::USING_TONGUE); + // The target is drawn in at 0.75 a tick. + let pull = m.position.subtract(pos).normalize().scale(0.75); + cx.events.push(MobEvent::Push { + target: Who::Mob(id), + velocity: [pull.x, pull.y, pull.z], + }); + let f = &mut m.extra.frog; + f.eat_timer = 0; + f.phase = Phase::CatchAnimation; + } else if m.extra.frog.path_counter <= 0 { + m.nav_move_to_entity(cx.w, at, 0, 2.0); + m.extra.frog.path_counter = 10; + } else { + m.extra.frog.path_counter -= 1; + } + } + Phase::CatchAnimation => { + let f = &mut m.extra.frog; + f.eat_timer += 1; + if f.eat_timer > 6 { + f.phase = Phase::EatAnimation; + // eatEntity. + cx.events + .push(MobEvent::Sound("entity.frog.eat", here, 2.0, 1.0)); + super::ai::do_hurt_target(m, Who::Mob(id), cx); + } + } + Phase::EatAnimation => { + let f = &mut m.extra.frog; + if f.eat_timer >= 10 { + f.phase = Phase::Done; + } else { + f.eat_timer += 1; + } + } + Phase::Done => {} + } + } +} diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs index 6704246de..e4682b0de 100644 --- a/crates/horizon-client/src/mobs/goals.rs +++ b/crates/horizon-client/src/mobs/goals.rs @@ -604,6 +604,11 @@ impl Mob { pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool { self.player_in_range(w, range, true, true) } + /// `TargetingConditions.forNonCombat().range(range).ignoreLineOfSight()` + /// for the player (still scaled by visibility). + pub fn can_see_player_through_walls(&mut self, w: &MobWorld, range: f64) -> bool { + self.player_in_range(w, range, false, true) + } /// `scale` is `TargetingConditions.testInvisible`: scale the range by /// the player's visibility. fn player_in_range( @@ -668,15 +673,27 @@ impl Goal for Float { #[derive(Clone, Debug)] pub struct Panic { pub speed: f64, + /// Only the damage of `#panic_environmental_causes` (an armadillo). + pub environmental: bool, + /// `TurtlePanicGoal`: always look for water this far away, not only + /// when on fire. + pub water_range: Option, pos: [f64; 3], } impl Panic { pub fn new(speed: f64) -> Self { Self { speed, + environmental: false, + water_range: None, pos: [0.0; 3], } } + /// `TurtlePanicGoal`. + pub fn looking_for_water(mut self, range: i32) -> Self { + self.water_range = Some(range); + self + } } pub fn should_panic(m: &Mob) -> bool { m.last_damage @@ -689,21 +706,29 @@ impl Goal for Panic { MOVE } fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { - if !should_panic(m) { + let wanted = if self.environmental { + m.last_damage.is_some_and(|(d, t)| { + super::armadillo::environmental(d.kind) && i64::from(m.age) - t <= 40 + }) || m.fire_ticks > 0 && !m.kind.flags.fire_immune + } else { + should_panic(m) + }; + if !wanted { return false; } - if m.fire_ticks > 0 { + let range = self.water_range.or((m.fire_ticks > 0).then_some(5)); + if let Some(range) = range { let (bx, by, bz) = ( m.position.x.floor() as i32, m.position.y.floor() as i32, m.position.z.floor() as i32, ); if cx.w.data.state(cx.w.world.block(bx, by, bz)).top == 0.0 { - // findBlocksInBoxByManhattanDistance(pos, 5, 1) for water. + // findBlocksInBoxByManhattanDistance(pos, range, 1) for water. let mut best: Option<([i32; 3], i32)> = None; for dy in -1i32..=1 { - for dx in -5i32..=5 { - for dz in -5i32..=5 { + for dx in -range..=range { + for dz in -range..=range { let d = dx.abs() + dy.abs() + dz.abs(); if cx.w.fluid(bx + dx, by + dy, bz + dz) == crate::blocks::Fluid::Water && best.is_none_or(|b| d < b.1) @@ -1456,6 +1481,9 @@ pub struct HurtByTarget { /// `Bee.BeeHurtByOtherGoal`: kept only while angry, and alerting others /// only when the attacker is in sight. pub bee: bool, + /// Whom `alertOther` calls: a filter on the mob (`PandaHurtByTargetGoal` + /// calls aggressive pandas only). + pub alert_if: Option bool>, /// `PolarBear.PolarBearHurtByTargetGoal`: a hurt cub only calls the /// adult bears and drops the target itself. pub polar_bear: bool, @@ -1469,6 +1497,7 @@ impl HurtByTarget { alert_except: vec![], ignore: vec![], bee: false, + alert_if: None, polar_bear: false, timestamp: 0, st: TargetState { @@ -1489,6 +1518,10 @@ impl HurtByTarget { self.bee = true; self } + pub fn alert_if(mut self, f: fn(&Seen) -> bool) -> Self { + self.alert_if = Some(f); + self + } pub fn polar_bear(mut self) -> Self { self.polar_bear = true; self @@ -1566,6 +1599,7 @@ impl Goal for HurtByTarget { && (s.position.z - pos.z).abs() <= range + 1.0 }) .filter(|s| !self.alert_except.contains(&s.species)) + .filter(|s| self.alert_if.is_none_or(|f| f(s))) // PolarBearHurtByTargetGoal.alertOther: adults only. .filter(|s| !(self.polar_bear && s.baby)) .filter(|s| Who::Mob(s.id) != by) @@ -1605,6 +1639,10 @@ pub struct AvoidEntity { pub sprint: f64, /// Extra condition on the avoider (e.g. untamed cats only). pub when: Option bool>, + /// Extra condition on the player or mob avoided (`AvoidEntityGoal`'s + /// predicate: a sneaking player, a tame wolf). + pub player_when: Option bool>, + pub seen_when: Option bool>, from: Vec3, /// The mob being avoided (`toAvoid`), when it is one. pub found: Option, @@ -1617,6 +1655,8 @@ impl AvoidEntity { walk, sprint, when: None, + player_when: None, + seen_when: None, from: Vec3::ZERO, found: None, } @@ -1625,6 +1665,14 @@ impl AvoidEntity { self.when = Some(f); self } + pub fn player_when(mut self, f: fn(&super::PlayerView) -> bool) -> Self { + self.player_when = Some(f); + self + } + pub fn seen_when(mut self, f: fn(&Seen) -> bool) -> Self { + self.seen_when = Some(f); + self + } } impl Goal for AvoidEntity { goal_clone!(); @@ -1645,6 +1693,7 @@ impl Goal for AvoidEntity { .filter(|p| { p.alive && !p.creative + && self.player_when.is_none_or(|f| f(p)) && m.distance_sqr(p.position) <= max * max && (p.position.y - m.position.y).abs() <= max + 3.0 }) @@ -1653,10 +1702,12 @@ impl Goal for AvoidEntity { Avoid::Species(list) => { let id = m.id; let y = m.position.y; + let seen_when = self.seen_when; let hit = cx.w.nearby(m.position, max, move |s| { s.id != id && list.contains(&s.species) + && seen_when.is_none_or(|f| f(s)) && (s.position.y - y).abs() <= 3.0 + max }) .map(|s| (s.id, s.position)) @@ -2035,6 +2086,30 @@ impl Goal for RestrictSun { m.ai.nav.avoid_sun = false; } } +/// `FleeSunGoal.getHidePos`: a spot within 10 blocks that the sky does not +/// see and the mob likes. +pub fn hide_pos(m: &mut Mob, w: &MobWorld) -> Option<[f64; 3]> { + let (bx, by, bz) = ( + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ); + for _ in 0..10 { + let p = [ + bx + m.random.next_int_bound(20).unwrap_or(0) - 10, + by + m.random.next_int_bound(6).unwrap_or(0) - 3, + bz + m.random.next_int_bound(20).unwrap_or(0) - 10, + ]; + if !w.can_see_sky(p[0], p[1], p[2]) && m.walk_target_value(w, p) < 0.0 { + return Some([ + f64::from(p[0]) + 0.5, + f64::from(p[1]), + f64::from(p[2]) + 0.5, + ]); + } + } + None +} /// FleeSunGoal: find shade while burning. #[derive(Clone, Debug)] pub struct FleeSun { @@ -2066,22 +2141,13 @@ impl Goal for FleeSun { if !cx.w.can_see_sky(bx, by, bz) { return false; } - for _ in 0..10 { - let p = [ - bx + m.random.next_int_bound(20).unwrap_or(0) - 10, - by + m.random.next_int_bound(6).unwrap_or(0) - 3, - bz + m.random.next_int_bound(20).unwrap_or(0) - 10, - ]; - if !cx.w.can_see_sky(p[0], p[1], p[2]) && m.walk_target_value(cx.w, p) < 0.0 { - self.wanted = [ - f64::from(p[0]) + 0.5, - f64::from(p[1]), - f64::from(p[2]) + 0.5, - ]; - return true; + match hide_pos(m, cx.w) { + Some(at) => { + self.wanted = at; + true } + None => false, } - false } fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { !m.ai.nav.is_done() diff --git a/crates/horizon-client/src/mobs/goat.rs b/crates/horizon-client/src/mobs/goat.rs new file mode 100644 index 000000000..058f0e697 --- /dev/null +++ b/crates/horizon-client/src/mobs/goat.rs @@ -0,0 +1,467 @@ +//! Goats (`Goat`, `GoatAi`): the lowered head (`lowerHeadTick`, entity +//! events 58 and 59) and the ram activity: `PrepareRamNearestTarget` picks +//! the nearest living thing it can see, walks to a spot four to seven +//! blocks away in a straight line and waits there 20 ticks with its head +//! down; `RamTarget` then charges at it, knocks it back, or breaks a horn +//! on a log, stone or ore. Both are one goal here. +use super::{ + Damage, Mob, MobEvent, MobWorld, Who, + goals::{Cx, Goal, LOOK, MOVE, goal_clone}, +}; +use horizon_core::{geometry::Vec3, random::RandomSource}; + +/// `GoatAi.TIME_BETWEEN_RAMS` and `TIME_BETWEEN_RAMS_SCREAMER`. +const RAMS: (i32, i32) = (600, 6000); +const RAMS_SCREAMER: (i32, i32) = (100, 300); +const RAM_PREPARE_TIME: i64 = 20; +const MIN_RAM_DISTANCE: i32 = 4; +const MAX_RAM_DISTANCE: i32 = 7; +/// `PrepareRamNearestTarget.TIME_OUT_DURATION` and `RamTarget`'s. +const PREPARE_TIME_OUT: i32 = 160; +const RAM_TIME_OUT: i32 = 200; +/// `NEAREST_VISIBLE_LIVING_ENTITIES` reaches 16 blocks. +const SENSE_RANGE: f64 = 16.0; + +#[derive(Clone, Copy, Debug, Default, PartialEq)] +enum Phase { + #[default] + Done, + Prepare, + /// `RAM_TARGET` is set; `RamTarget` starts on the next tick. + RamStart, + Ram, +} +#[derive(Clone, Copy, Debug)] +struct Candidate { + start: [i32; 3], + target_pos: [i32; 3], + target: Who, +} + +/// The lowered head and the ram behaviours' state. `RAM_COOLDOWN_TICKS` is a +/// brain memory (`ram_cooldown`), saved with the others. +#[derive(Clone, Debug, Default)] +pub struct State { + lower_head_tick: i32, + lowering_head: bool, + phase: Phase, + candidate: Option, + reached_at: Option, + /// `RAM_TARGET`, and the direction of the charge. + ram_target: Option, + ram_direction: Vec3, + time: i32, +} + +pub fn register(m: &mut Mob) { + m.ai.goals.add(2, Ram); +} + +/// `Goat.handleEntityEvent`: 58 lowers the head, 59 raises it. +pub fn entity_event(m: &mut Mob, event: u8) { + match event { + 58 => m.extra.goat.lowering_head = true, + 59 => m.extra.goat.lowering_head = false, + _ => {} + } +} +/// `Goat.aiStep`'s `lowerHeadTick`; a client runs it too. +pub fn tick(m: &mut Mob) { + let g = &mut m.extra.goat; + g.lower_head_tick += if g.lowering_head { 1 } else { -2 }; + g.lower_head_tick = g.lower_head_tick.clamp(0, 20); + // `CountDownCooldownTicks(RAM_COOLDOWN_TICKS)`: one less each tick, erased + // once it runs out. + let cooldown = ram_cooldown(m); + if cooldown > 0 { + set_ram_cooldown(m, cooldown - 1); + } +} +/// `RAM_COOLDOWN_TICKS`: 0 when absent. +pub fn ram_cooldown(m: &Mob) -> i32 { + m.extra + .memories + .iter() + .find(|x| x.0 == RAM_COOLDOWN) + .map_or(0, |x| x.1 as i32) +} +fn set_ram_cooldown(m: &mut Mob, ticks: i32) { + let memories = &mut m.extra.memories; + match memories.iter().position(|x| x.0 == RAM_COOLDOWN) { + Some(i) if ticks > 0 => memories[i].1 = i64::from(ticks), + Some(i) => { + memories.remove(i); + } + None if ticks > 0 => memories.push((RAM_COOLDOWN, i64::from(ticks), i64::MAX)), + None => {} + } +} +const RAM_COOLDOWN: &str = "ram_cooldown"; +/// `Goat.getRammingXHeadRot`. +pub fn ramming_x_head_rot(m: &Mob) -> f32 { + let max = if m.is_baby() { 52.5_f32 } else { 30.0 }; + m.extra.goat.lower_head_tick as f32 / 20.0 * max * (std::f32::consts::PI / 180.0) +} +/// A server's `level.broadcastEntityEvent(goat, 58 or 59)`, sent when it +/// changes what the goat does. +fn lower_head(m: &mut Mob, events: &mut Vec, lower: bool) { + if m.extra.goat.lowering_head != lower { + let event: i8 = if lower { 58 } else { 59 }; + entity_event(m, event as u8); + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::EntityEvent { + mob: m.id, + event, + at, + }); + } +} +fn between(m: &mut Mob, (min, max): (i32, i32)) -> i32 { + m.random.next_int_between_inclusive(min, max).unwrap_or(min) +} +fn rams(m: &Mob) -> (i32, i32) { + if m.extra.screaming { + RAMS_SCREAMER + } else { + RAMS + } +} +fn block_of(p: Vec3) -> [i32; 3] { + [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32] +} +fn play(m: &Mob, events: &mut Vec, sound: &'static str, pitch: f32) { + if !m.silent { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound(sound, at, 1.0, pitch)); + } +} + +/// `PrepareRamNearestTarget.isWalkableBlock`. +fn walkable(m: &Mob, w: &MobWorld, p: [i32; 3]) -> bool { + m.stable_destination(w, p) && m.malus(w.path_type_static(p[0], p[1], p[2])) == 0.0 +} +/// `PrepareRamNearestTarget.calculateRammingStartPosition`. +fn ramming_start(m: &mut Mob, w: &MobWorld, target: [i32; 3]) -> Option<[i32; 3]> { + if !walkable(m, w, target) { + return None; + } + // Direction.Plane.HORIZONTAL: north, east, south, west. + let mut starts = Vec::new(); + for (dx, dz) in [(0, -1), (1, 0), (0, 1), (-1, 0)] { + let mut p = target; + for _ in 0..MAX_RAM_DISTANCE { + p = [p[0] + dx, p[1], p[2] + dz]; + if !walkable(m, w, p) { + p = [p[0] - dx, p[1], p[2] - dz]; + break; + } + } + let manhattan = + (p[0] - target[0]).abs() + (p[1] - target[1]).abs() + (p[2] - target[2]).abs(); + if manhattan >= MIN_RAM_DISTANCE { + starts.push(p); + } + } + let here = block_of(m.position); + let sqr = |p: &[i32; 3]| { + (0..3) + .map(|i| i64::from(p[i] - here[i]).pow(2)) + .sum::() + }; + starts.sort_by_key(sqr); + starts + .into_iter() + .find(|&p| m.create_path_to(w, p, 0).is_some_and(|path| path.reached)) +} +/// `PrepareRamNearestTarget.chooseRamPosition`. +fn choose(m: &mut Mob, w: &MobWorld, target: Who) { + let g = &mut m.extra.goat; + g.reached_at = None; + let Some(t) = w.target_info(target) else { + g.candidate = None; + return; + }; + let target_pos = block_of(t.position); + m.extra.goat.candidate = ramming_start(m, w, target_pos).map(|start| Candidate { + start, + target_pos, + target, + }); +} +/// The nearest living thing the goat sees that `RAM_TARGET_CONDITIONS` +/// allow: not a goat, a player who is not creative or a spectator. +fn nearest_target(m: &mut Mob, w: &MobWorld) -> Option { + let mut best: Option<(Who, f64)> = None; + if let Some(p) = &w.player + && p.alive + && !p.creative + && !p.spectator + && !p.allies.contains(&m.id) + && m.distance_sqr(p.position) <= SENSE_RANGE * SENSE_RANGE + && m.sees(w, Who::Player) + { + best = Some((Who::Player, m.distance_sqr(p.position))); + } + let id = m.id; + let mobs: Vec<(u32, f64)> = w + .nearby(m.position, SENSE_RANGE, |s| { + s.id != id && s.species != super::Species::Goat && !s.playing_dead + }) + .map(|s| (s.id, m.distance_sqr(s.position))) + .collect(); + for (mob, d) in mobs { + if best.is_none_or(|b| d < b.1) && m.sees(w, Who::Mob(mob)) { + best = Some((Who::Mob(mob), d)); + } + } + best.map(|b| b.0) +} + +/// `PrepareRamNearestTarget` and `RamTarget` of the ram activity. +#[derive(Clone, Debug)] +struct Ram; +impl Goal for Ram { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + // The ram activity needs the cooldown to be over (it also waits for + // no tempting player and no breed target, which goats lack here). + ram_cooldown(m) <= 0 + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let g = &m.extra.goat; + match g.phase { + Phase::Done => false, + Phase::Prepare => { + g.time <= PREPARE_TIME_OUT + && g.candidate + .is_some_and(|c| cx.w.target_info(c.target).is_some_and(|t| t.alive)) + } + Phase::RamStart | Phase::Ram => g.ram_target.is_some() && g.time <= RAM_TIME_OUT, + } + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + m.extra.goat.phase = Phase::Prepare; + m.extra.goat.time = 0; + m.extra.goat.reached_at = None; + m.extra.goat.candidate = None; + if let Some(target) = nearest_target(m, cx.w) { + choose(m, cx.w, target); + } + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + match m.extra.goat.phase { + // PrepareRamNearestTarget.stop: no ram target, so the head comes + // up and the cooldown starts. + Phase::Prepare => { + lower_head(m, cx.events, false); + let wait = rams(m).0; + set_ram_cooldown(m, wait); + } + // RamTarget.finishRam (also what its timeout leaves undone). + Phase::RamStart | Phase::Ram => finish_ram(m, cx.events), + Phase::Done => {} + } + m.extra.goat.phase = Phase::Done; + m.extra.goat.candidate = None; + } + fn every_tick(&self) -> bool { + true + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + m.extra.goat.time += 1; + match m.extra.goat.phase { + Phase::Prepare => prepare_tick(m, cx), + Phase::RamStart => { + // RamTarget.start: charge from here at the ram target. + let (Some(target), here) = (m.extra.goat.ram_target, block_of(m.position)) else { + return; + }; + let d = Vec3::new( + f64::from(here[0]) - target.x, + 0.0, + f64::from(here[2]) - target.z, + ); + m.extra.goat.ram_direction = d.normalize(); + m.extra.goat.phase = Phase::Ram; + m.extra.goat.time = 0; + m.nav_move_to_entity(cx.w, [target.x, target.y, target.z], 0, 3.0); + ram_tick(m, cx); + } + Phase::Ram => ram_tick(m, cx), + Phase::Done => {} + } + } +} +/// `PrepareRamNearestTarget.tick`. +fn prepare_tick(m: &mut Mob, cx: &mut Cx) { + let Some(c) = m.extra.goat.candidate else { + return; + }; + let Some(t) = cx.w.target_info(c.target) else { + return; + }; + m.look_at([t.position.x, t.eye_y, t.position.z]); + let now = m.age as i32; + let at = [ + f64::from(c.start[0]) + 0.5, + f64::from(c.start[1]), + f64::from(c.start[2]) + 0.5, + ]; + if m.ai.nav.is_done() && block_of(m.position) != c.start { + m.nav_move_to_entity(cx.w, at, 0, 1.25); + } + if block_of(t.position) != c.target_pos { + // The target moved: the head comes up and a new spot is chosen. + lower_head(m, cx.events, false); + m.nav_stop(); + choose(m, cx.w, c.target); + } else if block_of(m.position) == c.start { + lower_head(m, cx.events, true); + let since = *m.extra.goat.reached_at.get_or_insert(now); + if i64::from(now - since) >= RAM_PREPARE_TIME { + // getEdgeOfBlock. + let (x, z) = ( + f64::from(c.target_pos[0]) + + 0.5 + + 0.5 * f64::from(sign(c.target_pos[0] - c.start[0])), + f64::from(c.target_pos[2]) + + 0.5 + + 0.5 * f64::from(sign(c.target_pos[2] - c.start[2])), + ); + m.extra.goat.ram_target = Some(Vec3::new(x, f64::from(c.target_pos[1]), z)); + let sound = if m.extra.screaming { + "entity.goat.screaming.prepare_ram" + } else { + "entity.goat.prepare_ram" + }; + let pitch = m.voice_pitch(); + play(m, cx.events, sound, pitch); + m.extra.goat.candidate = None; + m.extra.goat.phase = Phase::RamStart; + } + } +} +fn sign(v: i32) -> i32 { + v.signum() +} +/// `RamTarget.tick`. +fn ram_tick(m: &mut Mob, cx: &mut Cx) { + let impact = if m.extra.screaming { + "entity.goat.screaming.ram_impact" + } else { + "entity.goat.ram_impact" + }; + let from = [m.position.x, m.position.y, m.position.z]; + if let Some(target) = rammed(m, cx.w) { + // hurtServer by `noAggroMobAttack`, then the knockback. + let amount = m.attrs.attack_damage; + match target { + Who::Player => cx.events.push(MobEvent::DamagePlayer { + amount, + from, + kind: "minecraft:mob_attack_no_aggro", + }), + Who::Mob(id) => cx.events.push(MobEvent::AttackMob { + target: id, + amount, + source: Damage::mob(m.id, from), + }), + } + let level = |effect: &str| { + m.extra + .effects + .iter() + .find(|e| e.0 == effect) + .map_or(0, |e| e.2 + 1) + }; + let boost = 0.25 * (level("minecraft:speed") - level("minecraft:slowness")) as f32; + let factor = (m.ai.speed * 1.65).clamp(0.2, 3.0) + boost; + let force = if m.is_baby() { 1.0 } else { 2.5 }; + let d = m.extra.goat.ram_direction; + cx.events.push(MobEvent::Knockback { + target, + power: f64::from(factor * force), + x: d.x, + z: d.z, + }); + finish_ram(m, cx.events); + play(m, cx.events, impact, 1.0); + } else if rammed_horn_block(m, cx.w) { + play(m, cx.events, impact, 1.0); + if drop_horn(m, cx.events) { + play(m, cx.events, "entity.goat.horn_break", 1.0); + } + finish_ram(m, cx.events); + } else if m.ai.nav.is_done() || m.extra.goat.ram_target.is_none() { + // The walk target is gone: the charge ended where it could. + finish_ram(m, cx.events); + } +} +/// The first living thing in the goat's box that `RAM_TARGET_CONDITIONS` +/// allow. +fn rammed(m: &Mob, w: &MobWorld) -> Option { + let bounds = m.bounds(); + if let Some(p) = &w.player + && p.alive + && !p.creative + && !p.spectator + && !p.allies.contains(&m.id) + && p.bounds.intersects(bounds) + { + return Some(Who::Player); + } + w.others_near(bounds) + .find(|s| { + s.id != m.id + && s.alive + && s.species != super::Species::Goat + && !s.playing_dead + && s.bounds.intersects(bounds) + }) + .map(|s| Who::Mob(s.id)) +} +/// `RamTarget.hasRammedHornBreakingBlock`: the block one step ahead, or the +/// one above it, snaps a horn. +fn rammed_horn_block(m: &Mob, w: &MobWorld) -> bool { + let ahead = Vec3::new(m.velocity.x, 0.0, m.velocity.z).normalize(); + let at = block_of(m.position.add_vector(ahead)); + let snaps = + |p: [i32; 3]| w.has_tag("minecraft:snaps_goat_horn", w.block_name(p[0], p[1], p[2])); + snaps(at) || snaps([at[0], at[1] + 1, at[2]]) +} +/// `Goat.dropHorn`: one of the horns it still has comes off and drops. +fn drop_horn(m: &mut Mob, events: &mut Vec) -> bool { + if m.is_baby() { + return false; + } + let [left_lost, right_lost] = m.extra.lost_horns; + if left_lost && right_lost { + return false; + } + let lose_left = if left_lost { + false + } else if right_lost { + true + } else { + m.random.next_boolean() + }; + m.extra.lost_horns[usize::from(!lose_left)] = true; + events.push(MobEvent::DropItem { + item: "minecraft:goat_horn".into(), + count: 1, + at: [m.position.x, m.position.y, m.position.z], + }); + true +} +/// `RamTarget.finishRam`. +fn finish_ram(m: &mut Mob, events: &mut Vec) { + lower_head(m, events, false); + let wait = rams(m); + let cooldown = between(m, wait); + set_ram_cooldown(m, cooldown); + m.extra.goat.ram_target = None; + m.extra.goat.phase = Phase::Done; +} diff --git a/crates/horizon-client/src/mobs/golem.rs b/crates/horizon-client/src/mobs/golem.rs index c41c34f11..2fe37331b 100644 --- a/crates/horizon-client/src/mobs/golem.rs +++ b/crates/horizon-client/src/mobs/golem.rs @@ -157,12 +157,16 @@ impl Goal for OfferFlower { fn can_continue(&mut self, _: &mut Mob, _: &mut Cx) -> bool { self.ticks > 0 } - fn start(&mut self, m: &mut Mob, _: &mut Cx) { + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { self.ticks = 400; m.extra.counter = 400; + // IronGolem.offerFlower(true): entity event 11. + entity_event(m, 11, cx); } fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { m.extra.counter = 0; + // IronGolem.offerFlower(false): entity event 34. + entity_event(m, 34, cx); // A copper golem the offer ran out beside takes the poppy on its // antenna (#accepts_iron_golem_gift) when it has none. if self.ticks == 0 @@ -198,6 +202,7 @@ impl Goal for OfferFlower { /// the target is thrown upward. pub fn iron_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { m.extra.anim_ticks = 10; + entity_event(m, 4, cx); let attack = m.attrs.attack_damage; let amount = if attack as i32 > 0 { attack / 2.0 + m.random.next_int_bound(attack as i32).unwrap_or(0) as f32 @@ -224,6 +229,33 @@ pub fn iron_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { 1.0, )); } +/// `Level.broadcastEntityEvent` for an iron golem (guests run `client_event`). +fn entity_event(m: &Mob, event: i8, cx: &mut Cx) { + cx.events.push(MobEvent::EntityEvent { + mob: m.id, + event, + at: [m.position.x, m.position.y, m.position.z], + }); +} +/// `IronGolem.handleEntityEvent` on a client: 4 the swing, 11 and 34 the +/// poppy offer starting and stopping. +pub fn client_event(m: &mut Mob, event: u8) { + match event { + 4 => m.extra.anim_ticks = 10, + 11 => m.extra.counter = 400, + 34 => m.extra.counter = 0, + _ => {} + } +} +/// The swing and offer clocks of `IronGolem.aiStep` on a client. +pub fn client_tick(m: &mut Mob) { + if m.extra.anim_ticks > 0 { + m.extra.anim_ticks -= 1; + } + if m.extra.counter > 0 { + m.extra.counter -= 1; + } +} /// `IronGolem.aiStep` timers and anger. pub fn iron_ai_step(m: &mut Mob) { if m.extra.anim_ticks > 0 { @@ -309,12 +341,12 @@ fn snowball_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) { let zd = t.position.z - m.position.z; let yo = (xd * xd + zd * zd).sqrt() * 0.2; let mut p = Projectile::new(ProjectileKind::Snowball, start, Some(Who::Mob(m.id))); - // rangedAttackUncertainty: 14 - 4 * difficulty (normal: 6). + // SnowGolem.rangedAttackUncertainty: 12 on every difficulty. p.shoot( &mut crate::projectiles::own_random(m), [xd, yd + yo - start.y, zd], 1.6, - 6.0, + 12.0, ); cx.events.push(MobEvent::Projectile(p)); let pitch = 0.4 / (m.random.next_float() * 0.4 + 0.8); diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs index b630aeadd..4bdd1831b 100644 --- a/crates/horizon-client/src/mobs/guardian.rs +++ b/crates/horizon-client/src/mobs/guardian.rs @@ -214,12 +214,9 @@ pub fn travel(m: &mut Mob, w: &MobWorld, input: Vec3, events: &mut Vec } true } -/// `Guardian.aiStep`: the client animations, air, flopping on land, the -/// beam's clock, and the spikes' thorns. -pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { - if !m.alive() { - return; - } +/// `Guardian.aiStep`'s `clientSideTailAnimation` and +/// `clientSideSpikesAnimation` (the server's and a client's). +pub fn tail_and_spikes(m: &mut Mob) { let moving = m.extra.flag2; let in_water = m.fluids.in_water; // Tail and spikes (clientSideTailAnimation / clientSideSpikesAnimation). @@ -244,6 +241,16 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } else { a.v[SPIKES] += (1.0 - a.v[SPIKES]) * 0.06; } +} +/// `Guardian.aiStep`: the client animations, air, flopping on land, the +/// beam's clock, and the spikes' thorns. +pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { + if !m.alive() { + return; + } + let moving = m.extra.flag2; + let in_water = m.fluids.in_water; + tail_and_spikes(m); client_tick(m); if in_water { m.air = 300; @@ -276,17 +283,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { None => w.player.as_ref().map(|p| p.eye), }; if let Some(look) = look { - m.anim.v[EYE_Y] = if look[1] - m.eye_y() > 0.0 { 0.0 } else { 1.0 }; - let yaw = m.head_yaw.to_radians(); - let pitch = m.head_pitch.to_radians(); - let view = [-yaw.msin() * pitch.mcos(), yaw.mcos() * pitch.mcos()]; - let d = [m.position.x - look[0], m.position.z - look[2]]; - let len = (d[0] * d[0] + d[1] * d[1]).sqrt().max(1e-9); - let (dx, dz) = ((d[0] / len) as f32, (d[1] / len) as f32); - // Vec3.yRot(pi / 2) of the direction from the target. - let side = [dz, -dx]; - let dot = view[0] * side[0] + view[1] * side[1]; - m.anim.v[EYE_X] = dot.abs().sqrt() * 2.0 * dot.signum(); + look_at(m, look); } // Guardian.hurtServer: a still guardian's spikes hurt a melee attacker. if m.hurt_time == 10 @@ -294,7 +291,10 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { && let Some((d, _)) = m.last_damage && matches!( d.kind, - DamageKind::PlayerAttack | DamageKind::MaceSmash | DamageKind::MobAttack + DamageKind::PlayerAttack + | DamageKind::MaceSmash + | DamageKind::Spear + | DamageKind::MobAttack ) { let from = [m.position.x, m.position.y, m.position.z]; @@ -317,6 +317,21 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } } } +/// `GuardianModel.setupAnim`'s eye: it follows `look` (the attack target's +/// eye, else the camera's), from where the guardian faces. +pub fn look_at(m: &mut Mob, look: [f64; 3]) { + m.anim.v[EYE_Y] = if look[1] - m.eye_y() > 0.0 { 0.0 } else { 1.0 }; + let yaw = m.head_yaw.to_radians(); + let pitch = m.head_pitch.to_radians(); + let view = [-yaw.msin() * pitch.mcos(), yaw.mcos() * pitch.mcos()]; + let d = [m.position.x - look[0], m.position.z - look[2]]; + let len = (d[0] * d[0] + d[1] * d[1]).sqrt().max(1e-9); + let (dx, dz) = ((d[0] / len) as f32, (d[1] / len) as f32); + // Vec3.yRot(pi / 2) of the direction from the target. + let side = [dz, -dx]; + let dot = view[0] * side[0] + view[1] * side[1]; + m.anim.v[EYE_X] = dot.abs().sqrt() * 2.0 * dot.signum(); +} /// `ElderGuardian.customServerAiStep`: every minute, mining fatigue III for /// players within 50 blocks; a home within 16 blocks. pub fn elder_server_ai_step(m: &mut Mob, cx: &mut Cx) { diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs index 34dc256f9..e5c7b6a93 100644 --- a/crates/horizon-client/src/mobs/hostile.rs +++ b/crates/horizon-client/src/mobs/hostile.rs @@ -1,7 +1,7 @@ //! Creepers (swelling, explosions) and spiders (wall climbing, daylight //! neutrality, leaping). use super::{ - Mob, MobEvent, MobWorld, Species, Who, + Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who, goals::{ Avoid, AvoidEntity, Cx, Float, Goal, HurtByTarget, LeapAtTarget, LookAtPlayer, MOVE, MeleeAttack, NearestTarget, RandomLookAround, Stroll, goal_clone, @@ -54,9 +54,157 @@ pub fn register(m: &mut Mob) { ); m.ai.nav.kind = super::nav::NavKind::WallClimber; } + S::Silverfish => { + let g = &mut m.ai.goals; + g.add(1, Float); + g.add(3, SilverfishWakeUpFriends); + g.add(4, MeleeAttack::new(1.0, false)); + g.add(5, SilverfishMergeWithStone::default()); + m.ai.targets.add(1, HurtByTarget::new().alert()); + m.ai.targets.add(2, NearestTarget::player(true)); + } _ => {} } } +/// `Silverfish.hurtServer`: a hit by an entity (or magic damage) starts the +/// countdown of its wake-up goal, kept in `extra.counter`. +pub fn silverfish_hurt(m: &mut Mob, source: &Damage) { + if (source.attacker.is_some() || source.kind == DamageKind::Magic) && m.extra.counter == 0 { + m.extra.counter = super::goals::reduced(20); + } +} +/// `Silverfish.SilverfishWakeUpFriendsGoal`: 20 ticks after being hurt, the +/// infested blocks within 10 blocks sideways and 5 up or down break (or turn +/// back into stone with mob griefing off), until a coin flip stops it. +#[derive(Clone, Debug)] +struct SilverfishWakeUpFriends; +impl Goal for SilverfishWakeUpFriends { + goal_clone!(); + fn name(&self) -> &'static str { + "SilverfishWakeUpFriendsGoal" + } + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + m.extra.counter > 0 + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + m.extra.counter -= 1; + if m.extra.counter > 0 { + return; + } + let base = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + // The loops' offsets go 0, 1, -1, 2, -2 and so on. + let offsets = |limit: i32| std::iter::once(0).chain((1..=limit).flat_map(|i| [i, -i])); + for y in offsets(5) { + for x in offsets(10) { + for z in offsets(10) { + let pos = [base[0] + x, base[1] + y, base[2] + z]; + if !cx + .w + .block_name(pos[0], pos[1], pos[2]) + .starts_with("minecraft:infested_") + { + continue; + } + if cx.w.mob_griefing { + cx.events.push(MobEvent::BreakBlock { pos, drop: true }); + } else { + cx.events.push(MobEvent::Infest { + pos, + infested: false, + poof: None, + }); + } + if m.random.next_boolean() { + return; + } + } + } + } + } +} +/// `Silverfish.SilverfishMergeWithStoneGoal`: a stroll that, now and then +/// with mob griefing on, hides in a stone block next to the silverfish. +#[derive(Clone, Debug)] +struct SilverfishMergeWithStone { + stroll: Stroll, + merge: Option<[i32; 3]>, +} +impl Default for SilverfishMergeWithStone { + fn default() -> Self { + Self { + stroll: Stroll::new(1.0).interval(10), + merge: None, + } + } +} +impl Goal for SilverfishMergeWithStone { + goal_clone!(); + fn name(&self) -> &'static str { + "SilverfishMergeWithStoneGoal" + } + fn flags(&self) -> u8 { + MOVE + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.ai.target.is_some() || !m.ai.nav.is_done() { + return false; + } + if cx.w.mob_griefing + && m.random + .next_int_bound(super::goals::reduced(10)) + .unwrap_or(1) + == 0 + { + // Direction.getRandom: down, up, north, south, west, east. + const DIRECTIONS: [[i32; 3]; 6] = [ + [0, -1, 0], + [0, 1, 0], + [0, 0, -1], + [0, 0, 1], + [-1, 0, 0], + [1, 0, 0], + ]; + let d = DIRECTIONS[m.random.next_int_bound(6).unwrap_or(0) as usize]; + let pos = [ + m.position.x.floor() as i32 + d[0], + (m.position.y + 0.5).floor() as i32 + d[1], + m.position.z.floor() as i32 + d[2], + ]; + if super::spawn_selection::infested_host(cx.w.block_name(pos[0], pos[1], pos[2])) { + self.merge = Some(pos); + return true; + } + } + self.merge = None; + self.stroll.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.merge.is_none() && self.stroll.can_continue(m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(pos) = self.merge else { + return self.stroll.start(m, cx); + }; + if super::spawn_selection::infested_host(cx.w.block_name(pos[0], pos[1], pos[2])) { + cx.events.push(MobEvent::Infest { + pos, + infested: true, + poof: Some(m.id), + }); + m.removed = true; + } + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.stroll.stop(m, cx); + } +} /// Entity.getLightLevelDependentMagicValue at the eye. pub fn mob_brightness(m: &Mob, w: &MobWorld) -> f32 { w.brightness( @@ -77,7 +225,8 @@ impl Goal for SpiderAttack { self.0.flags() } fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { - self.0.can_use(m, cx) + // SpiderAttackGoal.canUse: not while it carries a rider. + self.0.can_use(m, cx) && m.extra.rider.is_none() } fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { if mob_brightness(m, cx.w) >= 0.5 && m.random.next_int_bound(100).unwrap_or(1) == 0 { diff --git a/crates/horizon-client/src/mobs/illager.rs b/crates/horizon-client/src/mobs/illager.rs index 00581d6d3..f4cb18af8 100644 --- a/crates/horizon-client/src/mobs/illager.rs +++ b/crates/horizon-client/src/mobs/illager.rs @@ -13,18 +13,6 @@ use horizon_core::geometry::trig::Mth; use horizon_core::{geometry::Vec3, random::RandomSource}; use std::f32::consts::PI; -/// The species raiders do not fight (`Raider`'s allies). -fn raider(s: Species) -> bool { - matches!( - s, - Species::Pillager - | Species::Vindicator - | Species::Witch - | Species::Evoker - | Species::Illusioner - | Species::Ravager - ) -} fn targets(m: &mut Mob, villagers_seen: bool) { let mut hurt = HurtByTarget::new().alert(); hurt.ignore = vec![ @@ -80,10 +68,11 @@ pub fn register_vindicator(m: &mut Mob) { g.add(9, LookAtPlayer::new(3.0).probability(1.0)); g.add(10, LookAtPlayer::mobs(8.0)); targets(m, true); - // VindicatorJohnnyAttackGoal: a vindicator named Johnny attacks anything. + // VindicatorJohnnyAttackGoal: a vindicator named Johnny attacks any + // living entity, other raiders included. m.ai.targets.add( 4, - NearestTarget::new(Prey::Filter(|s| !raider(s.species)), true) + NearestTarget::new(Prey::Filter(|_| true), true) .interval(0) .when(|m, _| m.custom_name.as_deref() == Some("Johnny")), ); diff --git a/crates/horizon-client/src/mobs/illusioner.rs b/crates/horizon-client/src/mobs/illusioner.rs index ec17abad7..b98e56920 100644 --- a/crates/horizon-client/src/mobs/illusioner.rs +++ b/crates/horizon-client/src/mobs/illusioner.rs @@ -152,20 +152,7 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { if !m.has_effect(INVISIBILITY) { return; } - let hurt = m.hurt_time; - let age = m.age; - let mut il = m.extra.illusions.take().unwrap_or_default(); - il.ticks = (il.ticks - 1).max(0); - if hurt == 1 || age.is_multiple_of(1200) { - il.ticks = 3; - for i in 0..COPIES { - il.offsets[0][i] = il.offsets[1][i]; - let r = &mut m.random; - let x = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; - let y = (r.next_int_bound(6).unwrap_or(0) - 4).max(0) as f64; - let z = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; - il.offsets[1][i] = [x, y, z]; - } + if step(m) { events.push(MobEvent::Particles { kind: "minecraft:cloud", at: [m.position.x, m.position.y + 0.9, m.position.z], @@ -177,6 +164,47 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { 1.0, 1.0, )); + } +} + +/// `Illusioner.aiStep` on a client of a server: invisible is the synched +/// shared flag. The puff is drawn here exactly (sixteen `addParticle`s); the +/// sound comes from the server. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if !m.invisible || !step(m) { + return; + } + let (w, h) = (f64::from(m.width()), f64::from(m.height())); + for _ in 0..16 { + // getRandomX(0.5), getRandomY() and getZ(0.5), which is not random. + let x = m.position.x + w * (2.0 * m.random.next_double() - 1.0) * 0.5; + let y = m.position.y + h * m.random.next_double(); + events.push(MobEvent::ParticleAt { + kind: "cloud", + at: [x, y, m.position.z + w * 0.5], + velocity: [0.0; 3], + }); + } +} + +/// The image offsets' clock of an invisible illusioner. True when the images +/// jumped to new offsets (hurt, or once a minute), which the puff goes with. +fn step(m: &mut Mob) -> bool { + let hurt = m.hurt_time; + let age = m.age; + let mut il = m.extra.illusions.take().unwrap_or_default(); + il.ticks = (il.ticks - 1).max(0); + let jumped = hurt == 1 || age.is_multiple_of(1200); + if jumped { + il.ticks = 3; + for i in 0..COPIES { + il.offsets[0][i] = il.offsets[1][i]; + let r = &mut m.random; + let x = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; + let y = (r.next_int_bound(6).unwrap_or(0) - 4).max(0) as f64; + let z = (-6 + r.next_int_bound(13).unwrap_or(0)) as f64 * 0.5; + il.offsets[1][i] = [x, y, z]; + } } else if hurt == 9 { il.ticks = 3; for i in 0..COPIES { @@ -185,6 +213,7 @@ pub fn tick(m: &mut Mob, events: &mut Vec) { } } m.extra.illusions = Some(il); + jumped } /// `Illusioner.getIllusionOffsets`. diff --git a/crates/horizon-client/src/mobs/keyframes.rs b/crates/horizon-client/src/mobs/keyframes.rs index e070210ec..edcee8835 100644 --- a/crates/horizon-client/src/mobs/keyframes.rs +++ b/crates/horizon-client/src/mobs/keyframes.rs @@ -165,6 +165,12 @@ impl AnimationState { pub fn stop(&mut self) { self.started = None; } + /// `AnimationState.fastForward`: the animation is `ticks` further on. + pub fn fast_forward(&mut self, ticks: i32) { + if let Some(s) = &mut self.started { + *s -= ticks as f32; + } + } pub fn animate_when(&mut self, condition: bool, age: f32) { if condition { self.start_if_stopped(age) diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index 10388d0c0..2de7297ef 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -505,7 +505,14 @@ impl Mob { /// Entity.move with block collisions and step-up; updates collision flags /// and fall distance (Entity.checkFallDamage). pub fn do_move(&mut self, w: &MobWorld, events: &mut Vec) { - let wanted = self.velocity; + let mut wanted = self.velocity; + // Entity.move: a block the mob is stuck in (sweet berry bush) scales + // this move once and stops it. + if self.stuck_multiplier.length_squared() > 1.0e-7 { + wanted = wanted.multiply(self.stuck_multiplier); + self.stuck_multiplier = Vec3::ZERO; + self.velocity = Vec3::ZERO; + } let step = self.kind.step_height as f32; let mut scene = SceneCollisions { world: w.world, @@ -546,19 +553,45 @@ impl Mob { } else if !matches!(self.kind.species, super::Species::Bat | super::Species::Bee) { self.check_fall_damage(w, moved, events); } - // restituteMovementAfterCollisions with no bounciness: the colliding - // components become (signed) zero. + // Entity.restituteMovementAfterCollisions: the colliding components + // bounce back by the entity's bounciness (zero for most mobs, so they + // become signed zero). Block bounciness is not modelled for mobs. if moved_vertically && vertical || self.horizontal_collision { let v = self.velocity; + let restitution = self.entity_bounciness(); + let mut after = v; if x_hit { - self.velocity.x = -v.x * 0.0; + after.x = -v.x * restitution; } if z_hit { - self.velocity.z = -v.z * 0.0; + after.z = -v.z * restitution; } if vertical { - self.velocity.y = (0.0 - v.y) * 1.0 * 0.0; + let mut restitution = restitution; + if self.vertical_collision_below { + // Only a hard enough landing bounces, and never on honey. + let on = ( + self.position.x.floor() as i32, + (self.position.y - f64::from(0.2_f32)).floor() as i32, + self.position.z.floor() as i32, + ); + if -v.y <= self.gravity() + || restitution > 0.0 + && w.block_name(on.0, on.1, on.2) == "minecraft:honey_block" + { + restitution = 0.0; + } + } + let (compensation, drag) = if restitution > 0.0 { + let portion = moved.y / v.y; + let air_drag = f64::from(self.air_drag()); + (portion * self.gravity(), 1.0 + portion * (air_drag - 1.0)) + } else { + (0.0, 1.0) + }; + after.y = (compensation - v.y) * drag * restitution; } + self.velocity = after; } // Entity.checkSupportingBlock self.supporting = self.supporting_block(w, moved); @@ -814,6 +847,11 @@ impl Mob { let at = [self.position.x, self.position.y, self.position.z]; events.push(MobEvent::Sound("entity.breeze.land", at, 1.0, 1.0)); } + // Creeper.causeFallDamage: the fall swells the fuse, up to five ticks + // short of exploding. + if self.species() == super::Species::Creeper { + self.swell = (self.swell + (self.fall_distance * 1.5) as i32).min(30 - 5); + } if self.kind.flags.fall_immune { return; } @@ -909,9 +947,33 @@ impl Mob { let y = (self.position.y - 0.500_001).floor() as i32; w.facts.get(w.world.block(x, y, z)).friction } + /// `getAttributeValue(BOUNCINESS)`. + fn entity_bounciness(&self) -> f64 { + super::sulfur_cube::physics(self).map_or(0.0, |a| f64::from(a.bounciness.clamp(0.0, 1.0))) + } + /// `LivingEntity.computeModifiedFriction`. + fn modified_friction(friction: f32, modifier: f32) -> f32 { + (1.0 - (1.0 - friction) * modifier).clamp(0.0, 1.0) + } + /// `LivingEntity.getAirDrag`: what vertical air drag a bounce applies. + fn air_drag(&self) -> f32 { + let base = if self.kind.flags.omnidirectional { + 0.91 + } else { + 0.98 + }; + Self::modified_friction(base, self.air_drag_modifier()) + } + /// `getAttributeValue(AIR_DRAG_MODIFIER)`. + fn air_drag_modifier(&self) -> f32 { + super::sulfur_cube::physics(self).map_or(1.0, |a| a.air_drag_modifier.clamp(0.0, 2048.0)) + } fn travel_in_air(&mut self, w: &MobWorld, input: Vec3, events: &mut Vec) { let friction = if self.on_ground { - self.block_friction(w) + // FRICTION_MODIFIER scales the block's slipperiness. + let modifier = super::sulfur_cube::physics(self) + .map_or(1.0, |a| a.friction_modifier.clamp(0.0, 2048.0)); + Self::modified_friction(self.block_friction(w), modifier) } else { 1.0 }; @@ -935,8 +997,14 @@ impl Mob { movement.y = 0.2; } let mut y = movement.y; - if self.extra.levitation > 0 { - y += (0.05 * 1.0 - movement.y) * 0.2; + // LivingEntity.travelInAir: levitation lifts by its amplifier. + if let Some(&(_, _, amp)) = self + .extra + .effects + .iter() + .find(|e| e.0 == "minecraft:levitation") + { + y += (0.05 * f64::from(amp + 1) - movement.y) * 0.2; } else { y -= self.gravity(); } @@ -945,12 +1013,13 @@ impl Mob { self.velocity = Vec3::new(movement.x, y, movement.z); return; } - let drag = 0.91f32; + let air_drag_modifier = self.air_drag_modifier(); + let drag = Self::modified_friction(0.91, air_drag_modifier); let f = friction * drag; let vertical = if self.kind.flags.omnidirectional { drag } else { - 0.98 + Self::modified_friction(0.98, air_drag_modifier) }; self.velocity = Vec3::new( movement.x * f64::from(f), diff --git a/crates/horizon-client/src/mobs/nautilus.rs b/crates/horizon-client/src/mobs/nautilus.rs index 2fcf7eb46..864865846 100644 --- a/crates/horizon-client/src/mobs/nautilus.rs +++ b/crates/horizon-client/src/mobs/nautilus.rs @@ -293,19 +293,28 @@ fn bubbles(m: &mut Mob, events: &mut Vec) { f64::from(yaw.cos() * pitch.cos()), ]; let spread = m.random.next_double() * 0.8 * (1.0 + speed); - for _ in 0..3 { - let _ = (f64::from(m.random.next_float()) - 0.5) * spread; - } - events.push(MobEvent::Particles { + let velocity = [ + (f64::from(m.random.next_float()) - 0.5) * spread, + (f64::from(m.random.next_float()) - 0.5) * spread, + (f64::from(m.random.next_float()) - 0.5) * spread, + ]; + events.push(MobEvent::ParticleAt { kind: "bubble", at: [ m.position.x - dir[0] * 1.1, m.position.y - dir[1] + 0.25, m.position.z - dir[2] * 1.1, ], - count: 1, + velocity, }); } +/// `AbstractNautilus.tick` on a client of a server: the bubbles of a nautilus +/// in the water, from the motion the server sent. +pub fn client_tick(m: &mut Mob, events: &mut Vec) { + if m.fluids.in_water { + bubbles(m, events); + } +} fn in_water_at(w: &MobWorld, p: Vec3) -> bool { w.fluid(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32) == Fluid::Water } diff --git a/crates/horizon-client/src/mobs/nav.rs b/crates/horizon-client/src/mobs/nav.rs index 178751ff6..d63035a61 100644 --- a/crates/horizon-client/src/mobs/nav.rs +++ b/crates/horizon-client/src/mobs/nav.rs @@ -580,6 +580,11 @@ impl Mob { if self.species() == super::Species::Bee { return super::bee::stable_destination(w, p); } + if self.species() == super::Species::Turtle + && let Some(stable) = super::turtle::stable_destination(self, w, p) + { + return stable; + } // StriderPathNavigation: lava too. if self.kind.flags.lava_walker && w.block_name(p[0], p[1], p[2]) == "minecraft:lava" { return true; diff --git a/crates/horizon-client/src/mobs/panda.rs b/crates/horizon-client/src/mobs/panda.rs new file mode 100644 index 000000000..a5b8e2944 --- /dev/null +++ b/crates/horizon-client/src/mobs/panda.rs @@ -0,0 +1,1090 @@ +//! Pandas (`Panda`): the genes and what they show, the sit, lie-on-back, roll +//! and sneeze states with their goals, the unhappy and eat counters, and the +//! client side of the three amounts `PandaModel.setupAnim` reads. +//! +//! `extra.variant` and `extra.variant2` are the main and the hidden gene +//! (`MAIN_GENE_ID`, `HIDDEN_GENE_ID`); the rest is [`State`], whose `flags`, +//! `unhappy`, `sneeze` and `eat` are the synched data a server sends. +use super::{ + DamageKind, Mob, MobEvent, MobWorld, Species, Who, + body_anim::Panda as Pose, + finalize::{self, Attr}, + goals::{ + Avoid, AvoidEntity, Breed, Cx, Float, FollowParent, Goal, HurtByTarget, JUMP, LOOK, MOVE, + MeleeAttack, Panic, RandomLookAround, Stroll, Tempt, goal_clone, reduced, + }, +}; +use horizon_core::{ + geometry::{ + Vec3, + trig::{DEG_TO_RAD, Mth}, + }, + jmath, + random::{LegacyRandom, RandomSource}, +}; + +/// `Panda.Gene` ids (the order of `Gene.values()`). +pub const LAZY: u8 = 1; +pub const WORRIED: u8 = 2; +pub const PLAYFUL: u8 = 3; +pub const WEAK: u8 = 5; +pub const AGGRESSIVE: u8 = 6; +/// `Gene.getSerializedName`, by id. +pub const GENES: [&str; 7] = [ + "normal", + "lazy", + "worried", + "playful", + "brown", + "weak", + "aggressive", +]; + +/// `DATA_ID_FLAGS`. +pub const FLAG_SNEEZE: u8 = 2; +pub const FLAG_ROLL: u8 = 4; +pub const FLAG_SIT: u8 = 8; +pub const FLAG_ON_BACK: u8 = 16; + +/// The crumbs of one bite: where and how fast each one flies. +pub type Crumbs = Vec<([f64; 3], [f64; 3])>; + +#[derive(Clone, Debug, Default)] +pub struct State { + /// `DATA_ID_FLAGS` (sneezing, rolling, sitting, on its back). + pub flags: u8, + /// `UNHAPPY_COUNTER`, `SNEEZE_COUNTER` and `EAT_COUNTER`. + pub unhappy: i32, + pub sneeze: i32, + pub eat: i32, + got_bamboo: bool, + did_bite: bool, + /// `rollCounter`, which a client counts for itself. + pub roll_counter: i32, + roll_delta: [f64; 2], + /// `sitAmount`, `onBackAmount` and `rollAmount` with the tick before. + sit_amount: [f32; 2], + on_back_amount: [f32; 2], + roll_amount: [f32; 2], + /// `isScared` as of the last tick (the model and the item layer read it). + scared: bool, + /// `PandaLookAtPlayerGoal.lookAt`, which the breed goal can set. + look_at: Option, + /// What the game saw on the ground: any food within 6 blocks, and the + /// first within 8. + pub food_near: bool, + pub food_at: Option<[f64; 3]>, + /// The size of the stack in its mouth (the mob holds one item id). + pub held_count: u32, + /// What a window draws of the last bite and sneeze, taken by `effects`. + crumbs: Option, + sneezed: Option<([f64; 3], [f64; 3])>, +} + +fn st(m: &mut Mob) -> &mut State { + m.extra.panda.get_or_insert_with(Default::default) +} +pub fn get(m: &Mob) -> Option<&State> { + m.extra.panda.as_deref() +} +fn flag(m: &Mob, f: u8) -> bool { + get(m).is_some_and(|s| s.flags & f != 0) +} +fn set_flag(m: &mut Mob, f: u8, on: bool) { + let s = st(m); + if on { + s.flags |= f; + } else { + s.flags &= !f; + } +} + +// ---- genes ---------------------------------------------------------------- + +/// `Panda.getVariant`: the gene a panda shows. +pub fn variant(m: &Mob) -> u8 { + finalize::panda_variant(m.extra.variant, m.extra.variant2) +} +pub fn is_lazy(m: &Mob) -> bool { + variant(m) == LAZY +} +pub fn is_worried(m: &Mob) -> bool { + variant(m) == WORRIED +} +pub fn is_playful(m: &Mob) -> bool { + variant(m) == PLAYFUL +} +pub fn is_weak(m: &Mob) -> bool { + variant(m) == WEAK +} +/// `Panda.isAggressive`: the gene, not the mob flag. +pub fn is_aggressive(m: &Mob) -> bool { + variant(m) == AGGRESSIVE +} +/// `Panda.Gene.getRandom`. +fn random_gene(random: &mut impl RandomSource) -> u8 { + finalize::panda_gene(random.next_int_bound(16).unwrap_or(0)) +} +/// `Panda.setAttributes`: a weak panda has 10 health, a lazy one is slow. +pub fn set_attributes(m: &mut Mob) { + if is_weak(m) { + finalize::set_base(m, Attr::MaxHealth, 10.0); + } + if is_lazy(m) { + finalize::set_base(m, Attr::MovementSpeed, f64::from(0.07_f32)); + } +} +/// `Panda.getBreedOffspring`: `setGeneFromParents`, then `setAttributes`, on +/// a baby the game made (its attributes go back to the type's first). +pub fn inherit(child: &mut Mob, parent: &Mob, partner: &Mob) { + let r = &mut child.random; + let one_of = |p: &Mob, r: &mut LegacyRandom| { + if r.next_boolean() { + p.extra.variant + } else { + p.extra.variant2 + } + }; + let (mut main, mut hidden) = if r.next_boolean() { + let main = one_of(parent, r); + (main, one_of(partner, r)) + } else { + let main = one_of(partner, r); + (main, one_of(parent, r)) + }; + if r.next_int_bound(32).unwrap_or(1) == 0 { + main = random_gene(r); + } + if r.next_int_bound(32).unwrap_or(1) == 0 { + hidden = random_gene(r); + } + child.extra.variant = main; + child.extra.variant2 = hidden; + for a in [Attr::MaxHealth, Attr::MovementSpeed] { + if let Some(value) = finalize::default_value(child, a) { + finalize::set_base(child, a, value); + } + } + set_attributes(child); + child.health = finalize::max_health(child); +} +/// `Panda.Gene.CODEC` for `MainGene` and `HiddenGene`. +pub fn gene_from_name(name: &str) -> u8 { + let name = name.strip_prefix("minecraft:").unwrap_or(name); + GENES.iter().position(|g| *g == name).unwrap_or(0) as u8 +} + +// ---- state ---------------------------------------------------------------- + +pub fn is_sitting(m: &Mob) -> bool { + flag(m, FLAG_SIT) +} +fn is_rolling(m: &Mob) -> bool { + flag(m, FLAG_ROLL) +} +fn is_on_back(m: &Mob) -> bool { + flag(m, FLAG_ON_BACK) +} +fn is_eating(m: &Mob) -> bool { + get(m).is_some_and(|s| s.eat > 0) +} +/// `Panda.isScared`: a worried panda in a thunderstorm. +fn is_scared(m: &Mob, thundering: bool) -> bool { + is_worried(m) && thundering +} +/// `Panda.canPerformAction`. +pub fn can_perform_action(m: &Mob, thundering: bool) -> bool { + !is_on_back(m) && !is_scared(m, thundering) && !is_eating(m) && !is_rolling(m) && !is_sitting(m) +} +fn sit(m: &mut Mob, on: bool) { + set_flag(m, FLAG_SIT, on); +} +fn eat(m: &mut Mob, on: bool) { + st(m).eat = i32::from(on); +} +/// `Panda.sneeze`: ending it resets the counter. +fn sneeze(m: &mut Mob, on: bool) { + set_flag(m, FLAG_SNEEZE, on); + if !on { + st(m).sneeze = 0; + } +} +/// `Panda.tryToSit`. +pub fn try_to_sit(m: &mut Mob) { + if !m.fluids.in_water { + m.ai.zza = 0.0; + m.nav_stop(); + sit(m, true); + } +} +/// `Panda.mobInteract` with bamboo in hand while it has a target. +pub fn got_bamboo(m: &mut Mob) { + st(m).got_bamboo = true; +} +/// `Panda.hurtServer`: any hurt gets it up. +pub fn hurt(m: &mut Mob) { + sit(m, false); +} +/// `Panda.doHurtTarget`: a bite that is not an aggressive panda's. +pub fn bit(m: &mut Mob) { + if !is_aggressive(m) { + st(m).did_bite = true; + } +} +/// `Panda.setOnBack(false)` from a click on a panda on its back. +pub fn get_up(m: &mut Mob) -> bool { + let was = is_on_back(m); + if was { + set_flag(m, FLAG_ON_BACK, false); + } + was +} +/// `Panda.eat(true)` at the first bite of what a player gave it. +pub fn start_eating(m: &mut Mob) { + eat(m, true); +} +/// `isScared` as of its last tick, for a click or a sneeze. +pub fn scared(m: &Mob) -> bool { + get(m).is_some_and(|s| s.scared) +} +/// `setItemSlot(MAINHAND, stack)` and `setGuaranteedDrop`, or just the size +/// of a stack it was given. +pub fn hold(m: &mut Mob, item: &str, count: u32, guaranteed: bool) { + finalize::set_item(m, super::gear::MAIN, item); + if guaranteed { + finalize::set_drop_chance(m, super::gear::MAIN, 2.0); + } + st(m).held_count = count; +} +/// What its goals look for on the ground, found by the game each tick. +pub fn set_food(m: &mut Mob, near: bool, at: Option<[f64; 3]>) { + let s = st(m); + s.food_near = near; + s.food_at = at; +} +/// The size of the stack in its mouth, for what it drops. +pub fn held_count(m: &Mob) -> u32 { + get(m).map_or(1, |s| s.held_count.max(1)) +} + +// ---- synched data --------------------------------------------------------- + +/// `DATA_ID_FLAGS` from a server: a sneeze that ends is a sneeze that was +/// done (`afterSneeze`'s particle). +pub fn set_flags(m: &mut Mob, flags: u8) { + if flag(m, FLAG_SNEEZE) && flags & FLAG_SNEEZE == 0 { + let at = [m.position.x, m.position.y, m.position.z]; + let particle = sneeze_particle(at, m.width(), m.body_yaw, m.eye_y(), m.velocity); + st(m).sneezed = Some(particle); + } + st(m).flags = flags; +} +/// `UNHAPPY_COUNTER` and `SNEEZE_COUNTER` from a server. +pub fn set_unhappy(m: &mut Mob, unhappy: i32) { + st(m).unhappy = unhappy; +} +pub fn set_sneeze(m: &mut Mob, sneeze: i32) { + st(m).sneeze = sneeze; +} +/// `EAT_COUNTER` from a server: a bite every five. +pub fn set_eat(m: &mut Mob, eat: i32) { + let bite = eat > 0 && eat % 5 == 0 && st(m).eat != eat && m.extra.main_hand.is_some(); + st(m).eat = eat; + if bite { + let crumbs = crumbs(m); + st(m).crumbs = Some(crumbs); + } +} +/// What the window draws since the last call: the crumbs of a bite and the +/// sneeze's particle (position, velocity). +pub fn effects(m: &mut Mob) -> (Option, Option<([f64; 3], [f64; 3])>) { + match m.extra.panda.as_deref_mut() { + Some(s) => (s.crumbs.take(), s.sneezed.take()), + None => (None, None), + } +} + +// ---- the tick -------------------------------------------------------------- + +/// `Entity.playSound`: at the feet, never from a silent mob. +fn play(m: &Mob, sound: &'static str, volume: f32, pitch: f32, events: &mut Vec) { + if !m.silent { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound(sound, at, volume, pitch)); + } +} +fn lerp(a: f32, o: f32, n: f32) -> f32 { + o + a * (n - o) +} +/// `updateSitAmount`, `updateOnBackAnimation` and `updateRollAmount`. +fn step_amount(amount: &mut [f32; 2], on: bool) { + amount[0] = amount[1]; + amount[1] = if on { + (amount[1] + 0.15).min(1.0) + } else { + (amount[1] - 0.19).max(0.0) + }; +} +fn update_amounts(m: &mut Mob) { + let (sit, back, roll) = (is_sitting(m), is_on_back(m), is_rolling(m)); + let s = st(m); + step_amount(&mut s.sit_amount, sit); + step_amount(&mut s.on_back_amount, back); + step_amount(&mut s.roll_amount, roll); +} +/// `Panda.handleRoll`; a client counts the roll and leaves the motion to the +/// server. +fn handle_roll(m: &mut Mob, server: bool) { + let counter = { + let s = st(m); + s.roll_counter += 1; + s.roll_counter + }; + if counter > 32 { + set_flag(m, FLAG_ROLL, false); + } else if server { + let movement = m.velocity; + if counter == 1 { + let angle = m.yaw * DEG_TO_RAD; + let multiplier = if m.is_baby() { 0.1_f32 } else { 0.2_f32 }; + let delta = [ + movement.x + f64::from(-angle.msin() * multiplier), + movement.z + f64::from(angle.mcos() * multiplier), + ]; + st(m).roll_delta = delta; + m.velocity = Vec3::new(delta[0], 0.27, delta[1]); + } else if counter != 7 && counter != 15 && counter != 23 { + let [x, z] = st(m).roll_delta; + m.velocity = Vec3::new(x, movement.y, z); + } else { + let y = if m.on_ground { 0.27 } else { movement.y }; + m.velocity = Vec3::new(0.0, y, 0.0); + } + } +} +fn rnd(m: &mut Mob, bound: i32) -> i32 { + m.random.next_int_bound(bound).unwrap_or(0) +} +/// `Panda.handleEating`: the bite's sound and crumbs, and the end of a meal. +fn handle_eating(m: &mut Mob, w: &MobWorld, events: &mut Vec) { + let holds = m.extra.main_hand.is_some(); + if !is_eating(m) && is_sitting(m) && !is_scared(m, w.thundering) && holds && rnd(m, 80) == 1 { + eat(m, true); + } else if !holds || !is_sitting(m) { + eat(m, false); + } + if !is_eating(m) { + return; + } + // addEatingParticles + if st(m).eat % 5 == 0 { + let volume = 0.5 + 0.5 * rnd(m, 2) as f32; + let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; + play(m, "entity.panda.eat", volume, pitch, events); + if holds { + let crumbs = crumbs(m); + st(m).crumbs = Some(crumbs); + } + } + let count = st(m).eat; + if count > 80 && rnd(m, 20) == 1 { + let eats_from_ground = m.extra.main_hand.as_deref().is_some_and(|item| { + w.items + .and_then(|i| i.item_tags.get("minecraft:panda_eats_from_ground")) + .is_some_and(|tag| tag.contains(item)) + }); + if count > 100 && eats_from_ground { + super::drops::clear_slot(m, "mainhand"); + sit(m, false); + } + eat(m, false); + return; + } + st(m).eat += 1; +} +/// The six crumbs of `addEatingParticles`, drawn as the server draws them. +fn crumbs(m: &mut Mob) -> Crumbs { + let (x_rot, y_rot) = (-m.head_pitch * DEG_TO_RAD, -m.yaw * DEG_TO_RAD); + let body = -m.body_yaw * DEG_TO_RAD; + let (x, y, z) = (m.position.x, m.eye_y() + 1.0, m.position.z); + (0..6) + .map(|_| { + let r = &mut m.random; + let mut f = || f64::from(r.next_float()); + let v = Vec3::new((f() - 0.5) * 0.1, f() * 0.1 + 0.1, (f() - 0.5) * 0.1) + .rotate_x(x_rot) + .rotate_y(y_rot); + let p = Vec3::new((f() - 0.5) * 0.8, -f() * 0.6 - 0.3, 1.0 + (f() - 0.5) * 0.4) + .rotate_y(body); + ([p.x + x, p.y + y, p.z + z], [v.x, v.y + 0.05, v.z]) + }) + .collect() +} +/// `afterSneeze`'s particle, from the nose. +fn sneeze_particle( + at: [f64; 3], + width: f32, + body_yaw: f32, + eye: f64, + movement: Vec3, +) -> ([f64; 3], [f64; 3]) { + let reach = f64::from(width + 1.0) * 0.5; + let angle = body_yaw * DEG_TO_RAD; + ( + [ + at[0] - reach * f64::from(angle.msin()), + eye - f64::from(0.1_f32), + at[2] + reach * f64::from(angle.mcos()), + ], + [movement.x, 0.0, movement.z], + ) +} +/// `Panda.afterSneeze`: the particle, the sound, a start for the grown pandas +/// about, and a slime ball one sneeze in 700. +fn after_sneeze(m: &mut Mob, events: &mut Vec) { + let at = [m.position.x, m.position.y, m.position.z]; + let particle = sneeze_particle(at, m.width(), m.body_yaw, m.eye_y(), m.velocity); + st(m).sneezed = Some(particle); + play(m, "entity.panda.sneeze", 1.0, 1.0, events); + events.push(MobEvent::PandaSneezed { mob: m.id }); + events.push(MobEvent::GiftLoot { + mob: m.id, + table: "minecraft:gameplay/panda_sneeze", + at, + }); +} +/// `Panda.tick` after `super.tick()`. +pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { + let thundering = w.thundering; + if is_worried(m) { + if thundering && !m.fluids.in_water { + sit(m, true); + eat(m, false); + } else if !is_eating(m) { + sit(m, false); + } + } + if m.ai.target.is_none() { + let s = st(m); + s.got_bamboo = false; + s.did_bite = false; + } + let unhappy = st(m).unhappy; + if unhappy > 0 { + if let Some(t) = m.target_info(w) { + m.turn_to([t.position.x, t.eye_y, t.position.z], 90.0, 90.0); + } + if unhappy == 29 || unhappy == 14 { + play(m, "entity.panda.cant_breed", 1.0, 1.0, events); + } + st(m).unhappy -= 1; + } + if flag(m, FLAG_SNEEZE) { + let count = { + let s = st(m); + s.sneeze += 1; + s.sneeze + }; + if count > 20 { + sneeze(m, false); + after_sneeze(m, events); + } else if count == 1 { + play(m, "entity.panda.pre_sneeze", 1.0, 1.0, events); + } + } + if is_rolling(m) { + handle_roll(m, true); + } else { + st(m).roll_counter = 0; + } + if is_sitting(m) { + m.head_pitch = 0.0; + } + st(m).scared = is_scared(m, thundering); + update_amounts(m); + handle_eating(m, w, events); + // updateOnBackAnimation and updateRollAmount ran with the others. +} +/// `Panda.tick` for a panda a client only displays: the flags and counters +/// are the server's; the amounts and the roll count are the client's own. +pub fn client_tick(m: &mut Mob, thundering: bool) { + if is_rolling(m) { + handle_roll(m, false); + } else { + st(m).roll_counter = 0; + } + if is_sitting(m) { + m.head_pitch = 0.0; + } + st(m).scared = is_scared(m, thundering); + update_amounts(m); +} + +// ---- drawing --------------------------------------------------------------- + +/// `PandaRenderer.getTextureLocation`. +pub fn texture(m: &Mob) -> String { + let v = usize::from(variant(m)).min(GENES.len() - 1); + let gene = GENES[v]; + match (m.is_baby(), gene) { + (false, "normal") => "entity/panda/panda".into(), + (false, g) => format!("entity/panda/panda_{g}"), + (true, "normal") => "entity/panda/panda_baby".into(), + (true, g) => format!("entity/panda/{g}_panda_baby"), + } +} +/// What `PandaRenderState` gives `PandaModel.setupAnim`. +pub fn pose(m: &Mob, partial: f32) -> Pose { + let Some(s) = get(m) else { + return Pose::default(); + }; + let amount = |a: &[f32; 2]| lerp(partial, a[0], a[1]); + Pose { + unhappy: s.unhappy > 0, + sneezing: s.flags & FLAG_SNEEZE != 0, + sneeze_time: s.sneeze, + eating: s.eat > 0, + scared: s.scared, + sit_amount: amount(&s.sit_amount), + lie_on_back_amount: amount(&s.on_back_amount), + roll_amount: if m.is_baby() { + 0.0 + } else { + amount(&s.roll_amount) + }, + } +} +/// `PandaRenderer.setupRotations` after the common ones: the roll over, the +/// sit up and the lie on its back, and a scared panda's shiver. +pub fn rotations(m: &Mob, partial: f32) -> glam::Mat4 { + use glam::{Mat4, Vec3}; + let Some(s) = get(m) else { + return Mat4::IDENTITY; + }; + let baby = m.is_baby(); + let x_rot = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * partial; + let mut t = Mat4::IDENTITY; + let translate = |y: f32| Mat4::from_translation(Vec3::new(0.0, y, 0.0)); + let tilt = |degrees: f32| Mat4::from_rotation_x(degrees.to_radians()); + if s.roll_counter > 0 { + let time = s.roll_counter as f32 + partial; + let (pos, frac) = (time.floor() as i32, time.fract()); + let next = pos + 1; + let y = if baby { 0.3 } else { 0.8 }; + // getAngle: the angle between this step and the next, except in the + // last step of a quarter. + let angle = |this: f32, next_angle: f32, threshold: i32| { + if next < threshold { + lerp(frac, this, next_angle) + } else { + this + } + }; + let quarter = pos / 8; + if (0..4).contains(&quarter) { + let base = 90.0 * quarter as f32; + let step = |p: i32| base + 90.0 * (p - quarter * 8) as f32 / 7.0; + let a = angle(step(pos), step(next), (quarter + 1) * 8); + let lift = match quarter { + 0 => (y + 0.2) * (a / 90.0), + 1 => y + 0.2 + (y - 0.2) * (a - 90.0) / 90.0, + 2 => y + y * (270.0 - a) / 90.0, + _ => y * ((360.0 - a) / 90.0), + }; + t = t * translate(lift) * tilt(-a); + } + } + let sit = s.sit_amount; + let sit = lerp(partial, sit[0], sit[1]); + if sit > 0.0 { + t = t * translate(0.8 * sit) * tilt(lerp(sit, x_rot, x_rot + 90.0)) * translate(-sit); + if s.scared { + let age = m.age as f32 + partial; + let shake = (jmath::cos(f64::from(age * 1.25)) + * std::f64::consts::PI + * f64::from(0.05_f32)) as f32; + t *= Mat4::from_rotation_y(shake.to_radians()); + if baby { + t *= Mat4::from_translation(Vec3::new(0.0, 0.8, 0.55)); + } + } + } + let back = lerp(partial, s.on_back_amount[0], s.on_back_amount[1]); + if back > 0.0 { + let y = if baby { 0.5 } else { 1.3 }; + t = t * translate(y * back) * tilt(lerp(back, x_rot, x_rot + 180.0)); + } + t +} +/// `PandaHoldsItemLayer`: where the item in its mouth sits, in the model's +/// space, while it sits and eats. +pub fn item_offset(m: &Mob, partial: f32) -> Option { + let s = get(m)?; + if m.extra.main_hand.is_none() || s.flags & FLAG_SIT == 0 || s.scared { + return None; + } + let (mut y, mut z) = (1.4_f32, -0.6_f32); + if s.eat > 0 { + let bite = ((m.age as f32 + partial) * 0.6).msin(); + z -= 0.2 * bite + 0.2; + y -= 0.09 * bite; + } + Some(glam::Mat4::from_translation(glam::Vec3::new(0.1, y, z))) +} + +// ---- goals ----------------------------------------------------------------- + +/// A goal that starts only when `when` allows it (`PandaAttackGoal`, +/// `PandaAvoidGoal`). +#[derive(Clone, Debug)] +struct When { + goal: G, + when: fn(&Mob, &MobWorld) -> bool, +} +impl Goal for When { + goal_clone!(); + fn flags(&self) -> u8 { + self.goal.flags() + } + fn name(&self) -> &'static str { + self.goal.name() + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + (self.when)(m, cx.w) && self.goal.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.goal.can_continue(m, cx) + } + fn interruptable(&self) -> bool { + self.goal.interruptable() + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.goal.start(m, cx) + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.goal.stop(m, cx) + } + fn every_tick(&self) -> bool { + self.goal.every_tick() + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + self.goal.tick(m, cx) + } +} +fn acts(m: &Mob, w: &MobWorld) -> bool { + can_perform_action(m, w.thundering) +} +fn avoids(m: &Mob, w: &MobWorld) -> bool { + is_worried(m) && acts(m, w) +} + +/// `PandaPanicGoal`: panics at the environment only, and not while sitting. +#[derive(Clone, Debug)] +struct PandaPanic(Panic); +impl Goal for PandaPanic { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE + } + fn name(&self) -> &'static str { + "Panic" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + environmental(m) && self.0.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if is_sitting(m) { + m.nav_stop(); + false + } else { + self.0.can_continue(m, cx) + } + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx) + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.stop(m, cx) + } +} +/// `DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES`, or burning. +fn environmental(m: &Mob) -> bool { + m.fire_ticks > 0 && !m.kind.flags.fire_immune + || m.last_damage.is_some_and(|(d, t)| { + matches!( + d.kind, + DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava | DamageKind::Cactus + ) && i64::from(m.age) - t <= 40 + }) +} + +/// `PandaBreedGoal`: a panda in love finds no mate happy unless there is +/// bamboo about. +#[derive(Clone, Debug)] +struct PandaBreed { + breed: Breed, + unhappy_cooldown: i64, +} +impl PandaBreed { + /// `canFindBamboo`: any bamboo within 7 blocks and 2 up. + fn can_find_bamboo(m: &Mob, w: &MobWorld) -> bool { + let at = [ + m.position.x.floor() as i32, + m.position.y.floor() as i32, + m.position.z.floor() as i32, + ]; + (0..3).any(|y| { + (-7..=7).any(|x| { + (-7..=7) + .any(|z| w.block_name(at[0] + x, at[1] + y, at[2] + z) == "minecraft:bamboo") + }) + }) + } +} +impl Goal for PandaBreed { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK + } + fn name(&self) -> &'static str { + "Breed" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if !self.breed.can_use(m, cx) || st(m).unhappy != 0 { + return false; + } + if Self::can_find_bamboo(m, cx.w) { + return true; + } + if self.unhappy_cooldown <= i64::from(m.age) { + st(m).unhappy = 32; + self.unhappy_cooldown = i64::from(m.age) + 600; + // The nearest player it looks at while it sulks. + let seen = m.can_see_player(cx.w, 8.0); + st(m).look_at = seen.then_some(Who::Player); + } + false + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.breed.can_continue(m, cx) + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.breed.stop(m, cx) + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + self.breed.tick(m, cx) + } +} + +/// `PandaHurtByTargetGoal`: a panda that was fed bamboo or bit lets go. +#[derive(Clone, Debug)] +struct PandaHurtBy(HurtByTarget); +impl Goal for PandaHurtBy { + goal_clone!(); + fn flags(&self) -> u8 { + self.0.flags() + } + fn name(&self) -> &'static str { + self.0.name() + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.0.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let s = st(m); + if s.got_bamboo || s.did_bite { + m.ai.target = None; + false + } else { + self.0.can_continue(m, cx) + } + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx) + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.stop(m, cx) + } +} + +/// What `PandaSitGoal` and `PandaLieOnBackGoal` ask each tick of their run. +fn rest_goes_on(m: &mut Mob) -> bool { + if !m.fluids.in_water && (is_lazy(m) || rnd(m, reduced(600)) != 1) { + rnd(m, reduced(2000)) != 1 + } else { + false + } +} + +/// `PandaSitGoal`: sit down with bamboo or cake in the mouth, or go to get +/// some from the ground. +#[derive(Clone, Debug, Default)] +struct PandaSit { + cooldown: i64, +} +impl Goal for PandaSit { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if self.cooldown > i64::from(m.age) + || m.is_baby() + || m.fluids.in_water + || !acts(m, cx.w) + || st(m).unhappy > 0 + { + return false; + } + m.extra.main_hand.is_some() || st(m).food_near + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + rest_goes_on(m) + } + fn tick(&mut self, m: &mut Mob, _: &mut Cx) { + if !is_sitting(m) && m.extra.main_hand.is_some() { + try_to_sit(m); + } + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + if m.extra.main_hand.is_none() { + if let Some(at) = st(m).food_at { + m.nav_move_to_entity(cx.w, at, 0, f64::from(1.2_f32)); + } + } else { + try_to_sit(m); + } + self.cooldown = 0; + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + if let Some(item) = m.extra.main_hand.clone() { + let count = held_count(m); + cx.events.push(MobEvent::DropItem { + item, + count, + at: [m.position.x, m.position.y, m.position.z], + }); + super::drops::clear_slot(m, "mainhand"); + let wait = if is_lazy(m) { + rnd(m, 50) + 10 + } else { + rnd(m, 150) + 10 + }; + self.cooldown = i64::from(m.age) + i64::from(wait) * 20; + } + sit(m, false); + } +} + +/// `PandaLieOnBackGoal`: a lazy panda now and then lies down. +#[derive(Clone, Debug, Default)] +struct PandaLieOnBack { + cooldown: i64, +} +impl Goal for PandaLieOnBack { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.cooldown < i64::from(m.age) && is_lazy(m) && acts(m, cx.w) && rnd(m, reduced(400)) == 1 + } + fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool { + rest_goes_on(m) + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, FLAG_ON_BACK, true); + self.cooldown = 0; + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, FLAG_ON_BACK, false); + self.cooldown = i64::from(m.age) + 200; + } +} + +/// `PandaSneezeGoal`: a cub sneezes now and then, a weak one more. +#[derive(Clone, Debug)] +struct PandaSneeze; +impl Goal for PandaSneeze { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if !(m.is_baby() && acts(m, cx.w)) { + return false; + } + if is_weak(m) && rnd(m, reduced(500)) == 1 { + true + } else { + rnd(m, reduced(6000)) == 1 + } + } + fn can_continue(&mut self, _: &mut Mob, _: &mut Cx) -> bool { + false + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + sneeze(m, true); + } +} + +/// `PandaLookAtPlayerGoal`: looks at the nearest player, or at the one the +/// breed goal sulks at. +#[derive(Clone, Debug, Default)] +struct PandaLook { + look_time: i32, +} +impl PandaLook { + fn target(m: &Mob, cx: &Cx) -> Option<(Vec3, f64)> { + match get(m)?.look_at? { + Who::Player => { + cx.w.player + .as_ref() + .filter(|p| p.alive) + .map(|p| (p.position, p.eye[1])) + } + Who::Mob(id) => { + cx.w.seen(id) + .filter(|s| s.alive) + .map(|s| (s.position, s.eye_y)) + } + } + } +} +impl Goal for PandaLook { + goal_clone!(); + fn flags(&self) -> u8 { + LOOK + } + fn name(&self) -> &'static str { + "LookAtPlayer" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.random.next_float() >= 0.02 { + return false; + } + if st(m).look_at.is_none() { + let seen = m.can_see_player(cx.w, 6.0); + st(m).look_at = seen.then_some(Who::Player); + } + acts(m, cx.w) && st(m).look_at.is_some() + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let Some((at, _)) = Self::target(m, cx) else { + return false; + }; + m.distance_sqr(at) <= 36.0 && self.look_time > 0 + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + self.look_time = reduced(40 + rnd(m, 40)); + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + st(m).look_at = None; + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + if let Some((at, eye)) = Self::target(m, cx) { + m.look_at([at.x, eye, at.z]); + self.look_time -= 1; + } + } +} + +/// `PandaRollGoal`: a cub, or a playful panda, rolls over when it faces a +/// drop and now and then at random. +#[derive(Clone, Debug)] +struct PandaRoll; +impl Goal for PandaRoll { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | LOOK | JUMP + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if !((m.is_baby() || is_playful(m)) && m.on_ground) || !acts(m, cx.w) { + return false; + } + let angle = m.yaw * DEG_TO_RAD; + let (x_dir, z_dir) = (-angle.msin(), angle.mcos()); + let step = |d: f32| if d.abs() > 0.5 { d.signum() as i32 } else { 0 }; + let (x, z) = ( + m.position.x.floor() as i32 + step(x_dir), + m.position.z.floor() as i32 + step(z_dir), + ); + let below = m.position.y.floor() as i32 - 1; + if cx.w.facts.is_air(cx.w.world.block(x, below, z)) { + return true; + } + if is_playful(m) && rnd(m, reduced(60)) == 1 { + true + } else { + rnd(m, reduced(500)) == 1 + } + } + fn can_continue(&mut self, _: &mut Mob, _: &mut Cx) -> bool { + false + } + fn start(&mut self, m: &mut Mob, _: &mut Cx) { + set_flag(m, FLAG_ROLL, true); + } + fn interruptable(&self) -> bool { + false + } +} + +/// `Panda.registerGoals`. +pub fn register(m: &mut Mob) { + let food = m.kind.food.clone(); + let monsters = super::species::ALL + .iter() + .map(|d| d.species) + .filter(|s| super::ai::is_monster(*s)) + .collect::>(); + let g = &mut m.ai.goals; + g.add(0, Float); + g.add(2, PandaPanic(Panic::new(2.0))); + g.add( + 2, + PandaBreed { + breed: Breed::new(1.0), + unhappy_cooldown: 0, + }, + ); + g.add( + 3, + When { + goal: MeleeAttack::new(f64::from(1.2_f32), true), + when: acts, + }, + ); + g.add(4, Tempt::new(1.0, food, false)); + g.add( + 6, + When { + goal: AvoidEntity::new(Avoid::Player, 8.0, 2.0, 2.0), + when: avoids, + }, + ); + g.add( + 6, + When { + goal: AvoidEntity::new(Avoid::Species(monsters), 4.0, 2.0, 2.0), + when: avoids, + }, + ); + g.add(7, PandaSit::default()); + g.add(8, PandaLieOnBack::default()); + g.add(8, PandaSneeze); + g.add(9, PandaLook::default()); + g.add(10, RandomLookAround::default()); + g.add(12, PandaRoll); + g.add(13, FollowParent::new(1.25)); + g.add(14, Stroll::avoiding_water(1.0)); + // alertOther: only an aggressive panda joins in. + m.ai.targets.add( + 1, + PandaHurtBy( + HurtByTarget::new() + .alert() + .alert_if(|s| s.species == Species::Panda && s.variant == AGGRESSIVE), + ), + ); +} diff --git a/crates/horizon-client/src/mobs/parrot.rs b/crates/horizon-client/src/mobs/parrot.rs new file mode 100644 index 000000000..c50176f7b --- /dev/null +++ b/crates/horizon-client/src/mobs/parrot.rs @@ -0,0 +1,138 @@ +//! What `Parrot.aiStep` adds: imitating the mobs around it (`imitateNearbyMobs`, +//! the ambient sound of `getAmbient`) and dancing near a playing jukebox. +use super::{Mob, MobEvent, MobWorld, Species}; +use horizon_core::{ + geometry::Vec3, + random::{LegacyRandom, RandomSource}, +}; + +/// `Parrot.MOB_SOUND_MAP` (the happy ghast's is `SoundEvents.EMPTY`: ""). +const IMITATIONS: [(Species, &str); 41] = [ + (Species::Blaze, "entity.parrot.imitate.blaze"), + (Species::Bogged, "entity.parrot.imitate.bogged"), + (Species::Breeze, "entity.parrot.imitate.breeze"), + (Species::CamelHusk, "entity.parrot.imitate.camel_husk"), + (Species::CaveSpider, "entity.parrot.imitate.spider"), + (Species::Creaking, "entity.parrot.imitate.creaking"), + (Species::Creeper, "entity.parrot.imitate.creeper"), + (Species::Drowned, "entity.parrot.imitate.drowned"), + ( + Species::ElderGuardian, + "entity.parrot.imitate.elder_guardian", + ), + (Species::Endermite, "entity.parrot.imitate.endermite"), + (Species::Evoker, "entity.parrot.imitate.evoker"), + (Species::Ghast, "entity.parrot.imitate.ghast"), + (Species::HappyGhast, ""), + (Species::Guardian, "entity.parrot.imitate.guardian"), + (Species::Hoglin, "entity.parrot.imitate.hoglin"), + (Species::Husk, "entity.parrot.imitate.husk"), + (Species::Illusioner, "entity.parrot.imitate.illusioner"), + (Species::MagmaCube, "entity.parrot.imitate.magma_cube"), + (Species::Parched, "entity.parrot.imitate.parched"), + (Species::Phantom, "entity.parrot.imitate.phantom"), + (Species::Piglin, "entity.parrot.imitate.piglin"), + (Species::PiglinBrute, "entity.parrot.imitate.piglin_brute"), + (Species::Pillager, "entity.parrot.imitate.pillager"), + (Species::Ravager, "entity.parrot.imitate.ravager"), + (Species::Shulker, "entity.parrot.imitate.shulker"), + (Species::Silverfish, "entity.parrot.imitate.silverfish"), + (Species::Skeleton, "entity.parrot.imitate.skeleton"), + (Species::Slime, "entity.parrot.imitate.slime"), + (Species::Spider, "entity.parrot.imitate.spider"), + (Species::Stray, "entity.parrot.imitate.stray"), + (Species::Vex, "entity.parrot.imitate.vex"), + (Species::Vindicator, "entity.parrot.imitate.vindicator"), + (Species::Warden, "entity.parrot.imitate.warden"), + (Species::Witch, "entity.parrot.imitate.witch"), + (Species::Wither, "entity.parrot.imitate.wither"), + ( + Species::WitherSkeleton, + "entity.parrot.imitate.wither_skeleton", + ), + (Species::Zoglin, "entity.parrot.imitate.zoglin"), + (Species::Zombie, "entity.parrot.imitate.zombie"), + (Species::ZombieHorse, "entity.parrot.imitate.zombie_horse"), + ( + Species::ZombieNautilus, + "entity.parrot.imitate.zombie_nautilus", + ), + ( + Species::ZombieVillager, + "entity.parrot.imitate.zombie_villager", + ), +]; + +fn imitation(species: Species) -> Option<&'static str> { + IMITATIONS.iter().find(|i| i.0 == species).map(|i| i.1) +} + +/// `Parrot.getPitch`. +fn pitch(random: &mut LegacyRandom) -> f32 { + (random.next_float() - random.next_float()) * 0.2 + 1.0 +} + +/// The start of `Parrot.aiStep`: a jukebox that is gone or farther than +/// 3.46 blocks stops the dance, and one tick in 400 the parrot imitates a +/// mob nearby. +pub fn ai_step( + m: &mut Mob, + w: &MobWorld, + level_random: &mut LegacyRandom, + events: &mut Vec, +) { + if let Some(at) = m.extra.party_jukebox { + let d = |i: usize, v: f64| f64::from(at[i]) + 0.5 - v; + let (x, y, z) = (d(0, m.position.x), d(1, m.position.y), d(2, m.position.z)); + let jukebox = &*w.facts.get(w.world.block(at[0], at[1], at[2])).name == "minecraft:jukebox"; + if x * x + y * y + z * z >= 3.46 * 3.46 || !jukebox { + m.extra.party_jukebox = None; + } + } + if level_random.next_int_bound(400).unwrap_or(1) == 0 { + imitate_nearby_mobs(m, w, level_random, events); + } +} + +/// `Parrot.imitateNearbyMobs`: half the time, a random imitable mob within 20 +/// blocks is heard through the parrot's own mouth. +fn imitate_nearby_mobs( + m: &Mob, + w: &MobWorld, + random: &mut LegacyRandom, + events: &mut Vec, +) { + if !m.alive() || m.silent || random.next_int_bound(2).unwrap_or(1) != 0 { + return; + } + let area = m.bounds().inflate(Vec3::new(20.0, 20.0, 20.0)); + let mobs: Vec<_> = w + .others + .iter() + .filter(|s| s.alive && imitation(s.species).is_some() && s.bounds.intersects(area)) + .collect(); + if mobs.is_empty() { + return; + } + let mob = mobs[random.next_int_bound(mobs.len() as i32).unwrap_or(0) as usize]; + if mob.silent { + return; + } + if let Some(sound) = imitation(mob.species).filter(|s| !s.is_empty()) { + let at = [m.position.x, m.position.y, m.position.z]; + events.push(MobEvent::Sound(sound, at, 0.7, pitch(random))); + } +} + +/// `Parrot.getAmbient`: now and then (outside peaceful) the voice of a random +/// imitable mob instead of the parrot's own. +pub fn ambient(m: &mut Mob, w: &MobWorld) -> &'static str { + if w.difficulty.effective > 0.0 && m.random.next_int_bound(1000).unwrap_or(1) == 0 { + let i = m + .random + .next_int_bound(IMITATIONS.len() as i32) + .unwrap_or(0); + return IMITATIONS[i as usize].1; + } + "entity.parrot.ambient" +} diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs index b62262bb0..ed219d312 100644 --- a/crates/horizon-client/src/mobs/piglin.rs +++ b/crates/horizon-client/src/mobs/piglin.rs @@ -6,7 +6,8 @@ use super::{ anim::{Poses, State}, goals::{ Avoid, AvoidEntity, Cx, Float, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, MeleeAttack, - NearestTarget, Prey, RandomLookAround, Stroll, goal_clone, + NearestTarget, Prey, RandomLookAround, Stroll, TARGET, TargetState, goal_clone, + target_continue, }, }; use horizon_core::geometry::{Vec3, trig::Mth}; @@ -62,15 +63,94 @@ pub fn register_piglin(m: &mut Mob) { m.ai.targets.add(1, hurt); m.ai.targets .add(2, NearestTarget::player(true).when(hostile_to_player)); - m.ai.targets.add( - 3, - NearestTarget::new( - Prey::Filter(|s| s.species == Species::Hoglin && s.baby), - true, - ) - .interval(10) - .when(|m, _| !m.is_baby()), - ); + m.ai.targets.add(3, HuntHoglin::default()); + // `PiglinAi.initMemories`: the first hunt waits too. + m.extra.ints[0] = time_between_hunts(m); +} +/// `PiglinAi.TIME_BETWEEN_HUNTS`: 30 to 120 seconds. +fn time_between_hunts(m: &mut Mob) -> i32 { + m.random + .next_int_between_inclusive(600, 2400) + .unwrap_or(600) +} +/// `StartHuntingHoglin`: an adult piglin that is not angry, has not hunted +/// recently and sees no adult piglin that has, goes for the nearest adult +/// hoglin it sees; then it and the adult piglins near it wait before the next +/// hunt, and the others join in (`broadcastAngerTarget`). +#[derive(Clone, Debug)] +struct HuntHoglin { + found: Option, + st: TargetState, +} +impl Default for HuntHoglin { + fn default() -> Self { + let mut st = TargetState::default(); + st.unseen_memory = 60; + Self { found: None, st } + } +} +impl Goal for HuntHoglin { + goal_clone!(); + fn flags(&self) -> u8 { + TARGET + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + if m.is_baby() || m.extra.ints[0] > 0 || m.extra.anger > 0 || m.ai.target.is_some() { + return false; + } + let range = m.attrs.follow_range; + let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let id = m.id; + if cx + .w + .nearby(pos, range, |s| { + s.id != id && s.species == Species::Piglin && !s.baby && s.hunted_recently + }) + .next() + .is_some() + { + return false; + } + let hoglins: Vec<(u32, Vec3)> = + cx.w.nearby(pos, range, |s| s.species == Species::Hoglin && !s.baby) + .map(|s| (s.id, s.position)) + .collect(); + self.found = hoglins + .into_iter() + .find(|&(hoglin, at)| { + m.distance_sqr(at) <= range * range && m.sees(cx.w, Who::Mob(hoglin)) + }) + .map(|(hoglin, _)| hoglin); + self.found.is_some() + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + target_continue(&mut self.st, true, m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(hoglin) = self.found else { return }; + m.ai.target = Some(Who::Mob(hoglin)); + m.extra.ints[0] = time_between_hunts(m); + let range = m.attrs.follow_range; + let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z); + let id = m.id; + let others: Vec = + cx.w.nearby(pos, range, |s| { + s.id != id && s.species == Species::Piglin && !s.baby + }) + .map(|s| s.id) + .collect(); + for mob in others { + let ticks = time_between_hunts(m); + cx.events.push(MobEvent::HuntHoglin { + mob, + target: hoglin, + ticks, + }); + } + } + fn stop(&mut self, m: &mut Mob, _: &mut Cx) { + m.ai.target = None; + } } pub fn register_brute(m: &mut Mob) { let g = &mut m.ai.goals; @@ -394,6 +474,19 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { if m.species() == Species::Hoglin && m.alive() { hoglin_repellent(m, w); } + if m.species() == Species::Piglin { + if m.extra.ints[0] > 0 { + m.extra.ints[0] -= 1; + } + // `StopAttackingIfTargetInvalid`: a hoglin handed over by a hunt + // broadcast has no target goal of its own to drop it when it dies. + if let Some(who @ Who::Mob(_)) = m.ai.target + && w.target_info(who) + .is_none_or(|t| !t.alive || !t.can_be_seen_as_enemy) + { + m.ai.target = None; + } + } if m.extra.anger > 0 { m.extra.anger -= 1; if m.extra.anger == 0 && m.ai.target == Some(Who::Player) && !hostile_to_player(m, w) { @@ -466,9 +559,44 @@ fn find_piglin_repellent(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> { || w.prop(p[0], p[1], p[2], "lit") == Some("true")) }) } +/// `HoglinBase.throwTarget`: a shove away and up of the attack knockback less +/// the target's knockback resistance (none at all when that is used up). +fn throw_target(m: &mut Mob, who: Who, cx: &mut Cx) { + let resistance = match who { + Who::Mob(id) => cx.w.seen(id).map_or(0.0, |s| s.knockback_resistance), + Who::Player => 0.0, + }; + let power = m.kind.attack_knockback - resistance; + let Some(t) = cx.w.target_info(who) else { + return; + }; + if power <= 0.0 { + return; + } + let away = Vec3::new( + t.position.x - m.position.x, + 0.0, + t.position.z - m.position.z, + ); + // `yRot` takes the random whole number of degrees as radians, as vanilla does. + let angle = (m.random.next_int_bound(21).unwrap_or(10) - 10) as f32; + let scale = power * f64::from(m.random.next_float() * 0.5 + 0.2); + let push = away.normalize().scale(scale).rotate_y(angle); + let up = power * f64::from(m.random.next_float()) * 0.5; + cx.events.push(MobEvent::Push { + target: who, + velocity: [push.x, up, push.z], + }); +} /// `HoglinBase.hurtAndThrowTarget`. pub fn hoglin_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { m.extra.anim_ticks = 10; + // Entity event 4: clients start the headbutt. + cx.events.push(MobEvent::EntityEvent { + mob: m.id, + event: 4, + at: [m.position.x, m.position.y, m.position.z], + }); let attack = m.attrs.attack_damage; let amount = if !m.is_baby() && attack as i32 > 0 { attack / 2.0 + m.random.next_int_bound(attack as i32).unwrap_or(0) as f32 @@ -485,11 +613,7 @@ pub fn hoglin_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) { }), } if !m.is_baby() { - // throwTarget: a strong shove up and away. - cx.events.push(MobEvent::Launch { - target: who, - up: 0.5 * f64::from(m.random.next_float()) + 0.3, - }); + throw_target(m, who, cx); } let sound = if m.species() == Species::Zoglin { "entity.zoglin.attack" @@ -603,6 +727,19 @@ pub fn piglin_pose( _ => {} } } +/// `Hoglin.handleEntityEvent` and `Zoglin`'s event 4 on a client: the +/// headbutt, which `aiStep` then counts down. +pub fn client_event(m: &mut Mob, event: u8) { + if event == 4 { + m.extra.anim_ticks = 10; + } +} +/// The headbutt's countdown (`Hoglin.aiStep`, `Zoglin.aiStep`) on a client. +pub fn client_tick(m: &mut Mob) { + if m.extra.anim_ticks > 0 { + m.extra.anim_ticks -= 1; + } +} /// `HoglinModel.setupAnim`. pub fn hoglin_anim(m: &Mob, s: &State, p: &mut Poses) { let (pos, sp) = (s.pos, s.speed); diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs index 9b1d17eed..04ebdff1e 100644 --- a/crates/horizon-client/src/mobs/raider.rs +++ b/crates/horizon-client/src/mobs/raider.rs @@ -46,6 +46,9 @@ pub struct State { /// Banners with no path to them, and until when (game time): /// `unreachableBannerCache`. pub unreachable_banners: Vec<(u32, i64)>, + /// `PathfindToRaidGoal.tick` ran its 20 tick recruitment: the game + /// recruits the raiders around this one. + pub recruit_due: bool, /// Beds around the raid's centre. pub homes: Option>>, /// A ravager carrying a raider, set every tick from `Extra::rider`. @@ -105,6 +108,10 @@ pub fn state(m: &Mob) -> Option<&State> { pub fn state_mut(m: &mut Mob) -> &mut State { m.extra.raider.get_or_insert_with(Box::default) } +/// `Raider.getCurrentRaid() != null`. +pub fn in_raid(m: &Mob) -> bool { + state(m).is_some_and(|s| s.raid_id.is_some()) +} pub fn has_active_raid(m: &Mob) -> bool { state(m).is_some_and(|s| s.active_raid) } @@ -122,7 +129,7 @@ pub fn register(m: &mut Mob) { m.extra.raider = Some(Box::default()); m.ai.goals.add(4, LongDistancePatrol::new(0.7, 0.595)); m.ai.goals.add(1, ObtainBanner::default()); - m.ai.goals.add(3, PathfindToRaid); + m.ai.goals.add(3, PathfindToRaid::default()); m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0)); m.ai.goals.add(5, Celebration); } @@ -379,9 +386,11 @@ impl Goal for ObtainBanner { } /// `PathfindToRaidGoal`: outside the village, head for the raid's centre in -/// hops of up to 15 blocks. -#[derive(Clone, Debug)] -pub struct PathfindToRaid; +/// hops of up to 15 blocks, recruiting nearby raiders every 20 ticks. +#[derive(Clone, Debug, Default)] +pub struct PathfindToRaid { + recruitment_tick: i32, +} impl PathfindToRaid { fn valid(s: &State) -> bool { s.active_raid && !s.raid_over && !s.in_village @@ -402,6 +411,12 @@ impl Goal for PathfindToRaid { let Some(c) = state(m).map(|s| s.raid_center) else { return; }; + if m.age as i32 > self.recruitment_tick { + self.recruitment_tick = m.age as i32 + 20; + if let Some(s) = m.extra.raider.as_deref_mut() { + s.recruit_due = true; + } + } if m.ai.nav.is_done() { let to = [ f64::from(c[0]) + 0.5, diff --git a/crates/horizon-client/src/mobs/ravager.rs b/crates/horizon-client/src/mobs/ravager.rs index 49bac4d9f..daa707a07 100644 --- a/crates/horizon-client/src/mobs/ravager.rs +++ b/crates/horizon-client/src/mobs/ravager.rs @@ -49,9 +49,14 @@ pub fn register(m: &mut Mob) { pub fn immobile(m: &Mob) -> bool { m.extra.counter > 0 || m.extra.counter2 > 0 || m.extra.anim_ticks > 0 } -/// `Ravager.doHurtTarget`: the bite animation. +/// `Ravager.doHurtTarget`: the bite animation (entity event 4 for clients). pub fn on_attack(m: &mut Mob, events: &mut Vec) { m.extra.counter = 10; + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 4, + at: [m.position.x, m.position.y, m.position.z], + }); events.push(MobEvent::Sound( "entity.ravager.attack", [m.position.x, m.position.y, m.position.z], @@ -67,6 +72,12 @@ pub fn blocked(m: &mut Mob, events: &mut Vec) -> bool { } if m.random.next_double() < 0.5 { m.extra.counter2 = 40; + // Entity event 39: the stun starts on clients. + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 39, + at: [m.position.x, m.position.y, m.position.z], + }); events.push(MobEvent::Sound( "entity.ravager.stunned", [m.position.x, m.position.y, m.position.z], @@ -155,6 +166,34 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { } } } +/// `Ravager.handleEntityEvent` 4 and 39 on a client. +pub fn entity_event(m: &mut Mob, event: u8) { + match event { + 4 => m.extra.counter = 10, + 39 => m.extra.counter2 = 40, + _ => {} + } +} +/// `Ravager.aiStep`'s clocks on a client: the bite and roar run down, and +/// the end of the stun starts the roar (the sounds, particles and the roar's +/// damage are the server's). +pub fn client_tick(m: &mut Mob) { + if !m.alive() { + return; + } + if m.extra.anim_ticks > 0 { + m.extra.anim_ticks -= 1; + } + if m.extra.counter > 0 { + m.extra.counter -= 1; + } + if m.extra.counter2 > 0 { + m.extra.counter2 -= 1; + if m.extra.counter2 == 0 { + m.extra.anim_ticks = 20; + } + } +} /// `Ravager.roar`: 6 damage to everything but illagers within 4 blocks, /// and a strong knockback (players too, through the client). fn roar(m: &mut Mob, w: &MobWorld, events: &mut Vec) { @@ -197,7 +236,14 @@ fn roar(m: &mut Mob, w: &MobWorld, events: &mut Vec) { velocity: fling(s.position), }); } - // Entity event 69: a puff of smoke. + // Entity event 69: a puff of smoke, and the client's own push. A client + // of this server (the window of the server thread) gets the event; + // this window draws the puff itself. + events.push(MobEvent::EntityEvent { + mob: m.id, + event: 69, + at: from, + }); events.push(MobEvent::Particles { kind: "poof", at: [ diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index bbed917a4..d02c3a172 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -143,6 +143,10 @@ pub fn body(m: &Mob) -> (String, String) { baby_or(m, "wolf#main", "wolf_baby#main"), super::tame::texture(m), ), + S::Panda => ( + baby_or(m, "panda#main", "panda_baby#main"), + super::panda::texture(m), + ), S::HappyGhast => ( baby_or(m, "happy_ghast#main", "happy_ghast_baby#main"), if baby { @@ -250,6 +254,20 @@ pub fn body(m: &Mob) -> (String, String) { baby_or(m, "armadillo#main", "armadillo_baby#main"), b(&m.kind.texture), ), + // FoxRenderer.getTextureLocation: snow variant, sleeping, baby. + S::Fox => ( + baby_or(m, "fox#main", "fox_baby#main"), + format!( + "entity/fox/fox{}{}{}", + if m.extra.variant == 0 { "" } else { "_snow" }, + if super::fox::flag(m, super::fox::SLEEPING) { + "_sleep" + } else { + "" + }, + if baby { "_baby" } else { "" }, + ), + ), S::Pig => { let model = if baby { "pig_baby#main".into() @@ -421,13 +439,37 @@ pub fn layers(m: &Mob) -> Vec { }) }; match m.species() { - // WolfCollarLayer. + // WolfArmorLayer, then WolfCollarLayer. S::Wolf if m.extra.tame => { let (model, texture) = if m.is_baby() { ("wolf_baby#main", "entity/wolf/wolf_collar_baby") } else { ("wolf#main", "entity/wolf/wolf_collar") }; + // The armor, then the cracks of its damage (`Crackiness.WOLF_ARMOR`). + if !m.is_baby() && m.extra.head.as_deref() == Some("minecraft:wolf_armor") { + let left = (super::WOLF_ARMOR_DURABILITY - m.extra.body_damage) as f32 + / super::WOLF_ARMOR_DURABILITY as f32; + push( + &mut v, + "wolf_armor#main", + "entity/equipment/wolf_body/armadillo_scute", + white, + false, + ); + let crack = [(0.32, "high"), (0.69, "medium"), (0.95, "low")] + .iter() + .find(|(t, _)| left < *t); + if let Some((_, level)) = crack { + push( + &mut v, + "wolf_armor#main", + &format!("entity/wolf/wolf_armor_crackiness_{level}"), + white, + false, + ); + } + } push( &mut v, model, @@ -927,7 +969,13 @@ fn flip_degrees(m: &Mob) -> f32 { fn species_rotations(m: &Mob, alpha: f32) -> glam::Mat4 { match m.species() { Species::Cat => super::tame::cat_rotations(m, alpha), + Species::Panda => super::panda::rotations(m, alpha), Species::Shulker => super::shulker::rotations(m), + // FoxRenderer.setupRotations: the body follows a pounce's pitch. + Species::Fox if super::fox::flag(m, super::fox::POUNCING | super::fox::FACEPLANTED) => { + let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * alpha; + glam::Mat4::from_rotation_x((-pitch).to_radians()) + } _ => glam::Mat4::IDENTITY, } } @@ -1409,6 +1457,12 @@ pub fn held_item_transform( data: &MobData, left: bool, ) -> Option { + // PandaHoldsItemLayer: the main hand's item in its mouth. + if m.species() == Species::Panda { + return super::panda::item_offset(m, alpha) + .filter(|_| !left) + .map(|offset| base_transform(m, alpha, camera) * offset); + } if !super::illager::shows_item(m) { return None; } @@ -1422,7 +1476,23 @@ pub fn held_item_transform( .unwrap_or_else(|| m.kind.model.clone()); let mut poses = Poses::new(&model); anim::setup(m, &s, &mut poses, &data.animations); - hand_base(m, &model, base, &poses, left) + let mut t = hand_base(m, &model, base, &poses, left)?; + // ItemInHandLayer: a spear in use (ArmPose.SPEAR's animateUseItem). + let off_hand = left != m.main_arm_left(); + if m.extra.using_item > 0 + && m.extra.using_off_hand == off_hand + && let Some(kinetic) = (if off_hand { + &m.extra.off_hand + } else { + &m.extra.main_hand + }) + .as_deref() + .and_then(crate::spear::Kinetic::of) + { + let time_held = m.extra.using_item as f32 + s.partial; + t *= crate::spear::third_person_use_item(&kinetic, time_held, s.swing, 0.0, !left); + } + Some(t) } #[cfg(test)] diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs index c510409d9..3a962241c 100644 --- a/crates/horizon-client/src/mobs/shulker.rs +++ b/crates/horizon-client/src/mobs/shulker.rs @@ -49,7 +49,7 @@ pub fn register(m: &mut Mob) { // attach axis. m.ai.targets.add( 2, - NearestTarget::player(true).when(|m, w| { + NearestTarget::player(true).gate(peaceful_off).when(|m, w| { let Some(p) = &w.player else { return false }; let d = p.position.subtract(m.position); let axis = match m.extra.variant3 { @@ -426,6 +426,11 @@ impl ProjectileWorld for Probe<'_, '_> { .full_collision } } +/// `level().getDifficulty() != Difficulty.PEACEFUL`, which the shulker's +/// attack goal and target goal check. +fn peaceful_off(_m: &Mob, w: &MobWorld) -> bool { + w.difficulty.effective != 0.0 +} /// `ShulkerAttackGoal`: open up and fire a bullet every one to five and a /// half seconds at a target within 20 blocks. #[derive(Clone, Debug)] @@ -441,7 +446,7 @@ impl Goal for ShulkerAttack { true } fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { - m.target_info(cx.w).is_some_and(|t| t.alive) + m.target_info(cx.w).is_some_and(|t| t.alive) && peaceful_off(m, cx.w) } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { self.attack_time = 20; @@ -451,6 +456,9 @@ impl Goal for ShulkerAttack { set_peek(m, 0, cx.events); } fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + if !peaceful_off(m, cx.w) { + return; + } self.attack_time -= 1; let (Some(who), Some(t)) = (m.ai.target, m.target_info(cx.w)) else { return; diff --git a/crates/horizon-client/src/mobs/spawn_selection.rs b/crates/horizon-client/src/mobs/spawn_selection.rs index 4e51722f1..dc6a2fc72 100644 --- a/crates/horizon-client/src/mobs/spawn_selection.rs +++ b/crates/horizon-client/src/mobs/spawn_selection.rs @@ -535,7 +535,7 @@ pub(crate) fn mob_spawn_rules(s: Species, l: &L, x: i32, y: i32 value >= 0.0 } /// `InfestedBlock.isCompatibleHostBlock`. -fn infested_host(block: &str) -> bool { +pub fn infested_host(block: &str) -> bool { matches!( block, "minecraft:stone" diff --git a/crates/horizon-client/src/mobs/spawner.rs b/crates/horizon-client/src/mobs/spawner.rs index 78b091b7b..f5e633226 100644 --- a/crates/horizon-client/src/mobs/spawner.rs +++ b/crates/horizon-client/src/mobs/spawner.rs @@ -152,6 +152,34 @@ pub(crate) fn cube_scale(id: &str, entity: &Compound) -> f32 { .map_or(1, |size| (size as i32).saturating_add(1).clamp(1, 127)) as f32 } +/// `EquipmentTable.CODEC`: the loot table and the drop chance of each +/// `EquipmentSlot` (`drops::SLOTS` order) the table names, `slot_drop_chances` +/// being one number for every slot or a map by slot name. +pub fn equipment_table(tag: &Tag) -> Option<(String, [Option; 8])> { + let chance = |t: &Tag| match t { + Tag::Float(v) => Some(f32::from_bits(*v)), + Tag::Double(v) => Some(f64::from_bits(*v) as f32), + Tag::Byte(v) => Some(f32::from(*v)), + Tag::Short(v) => Some(f32::from(*v)), + Tag::Int(v) => Some(*v as f32), + Tag::Long(v) => Some(*v as f32), + _ => None, + }; + let Some(Tag::String(table)) = tag.get("loot_table") else { + return None; + }; + let mut chances = [None; 8]; + match tag.get("slot_drop_chances") { + Some(Tag::Compound(map)) => { + for (i, slot) in super::drops::SLOTS.iter().enumerate() { + chances[i] = map.get(&JavaString::from(*slot)).and_then(chance); + } + } + Some(all) => chances = [Some(chance(all)?); 8], + None => {} + } + Some((table.to_string_lossy(), chances)) +} /// A whole number from any numeric tag (`NumericTag.intValue`: floats floor). pub(crate) fn number(tag: Option<&Tag>) -> Option { Some(match tag? { diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs index 3cce491ef..867869070 100644 --- a/crates/horizon-client/src/mobs/spawning.rs +++ b/crates/horizon-client/src/mobs/spawning.rs @@ -34,6 +34,8 @@ pub fn placement_ok(species: Species, w: &MobWorld, x: i32, y: i32, z: i32) -> b /// `DifficultyInstance`: the local difficulty at a position. #[derive(Clone, Copy, Debug)] pub struct LocalDifficulty { + /// The world difficulty id, 0 peaceful to 3 hard. + pub base: u8, pub effective: f32, /// The world difficulty is normal. pub normal: bool, @@ -52,6 +54,7 @@ impl LocalDifficulty { let normal = base == 2; if base == 0 { return Self { + base, effective: 0.0, normal, hard, @@ -66,6 +69,7 @@ impl LocalDifficulty { local *= 0.5; } Self { + base, effective: f32::from(base) * (0.75 + global + local), normal, hard, @@ -105,6 +109,19 @@ pub fn armor_stats(item: &str) -> (f32, f32) { }; (points[slot], toughness) } +/// The armour and toughness a horse armor item adds in the body slot +/// (`ArmorMaterial.createAttributes(ArmorType.BODY)`). +pub fn horse_armor_stats(item: &str) -> (f32, f32) { + match item.strip_prefix("minecraft:") { + Some("leather_horse_armor") => (3.0, 0.0), + Some("copper_horse_armor") => (4.0, 0.0), + Some("iron_horse_armor") => (5.0, 0.0), + Some("golden_horse_armor") => (7.0, 0.0), + Some("diamond_horse_armor") => (11.0, 2.0), + Some("netherite_horse_armor") => (19.0, 3.0), + _ => (0.0, 0.0), + } +} /// `Mob.populateDefaultEquipmentSlots`: sometimes a set of armour, from the /// head down, of one random material. fn populate_armor(m: &mut Mob, d: &LocalDifficulty) { diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs index 64106574b..201632706 100644 --- a/crates/horizon-client/src/mobs/species.rs +++ b/crates/horizon-client/src/mobs/species.rs @@ -1699,10 +1699,15 @@ impl Def { } } /// Mobs whose `body` equipment slot Horizon keeps in `Extra::head` (a -/// happy ghast's harness, nautilus armour, a sulfur cube's swallowed block). +/// happy ghast's harness, nautilus armour, a sulfur cube's swallowed block, +/// a wolf's armor). pub fn body_slot(s: Species) -> bool { matches!( s, - Species::HappyGhast | Species::Nautilus | Species::ZombieNautilus | Species::SulfurCube + Species::HappyGhast + | Species::Nautilus + | Species::ZombieNautilus + | Species::SulfurCube + | Species::Wolf ) } diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs index 91c303467..f0d4611a5 100644 --- a/crates/horizon-client/src/mobs/sulfur_cube.rs +++ b/crates/horizon-client/src/mobs/sulfur_cube.rs @@ -32,6 +32,12 @@ pub struct Archetype { pub contact_damage: Option, /// The knockback resistance modifier (the attribute clamps to 0..1). pub knockback_resistance: f64, + /// `Attributes.BOUNCINESS` (the modifier added to a base of 0). + pub bounciness: f32, + /// `Attributes.FRICTION_MODIFIER` and `AIR_DRAG_MODIFIER` (base 1 times + /// the archetype's factor). + pub friction_modifier: f32, + pub air_drag_modifier: f32, pub horizontal_power: f32, pub vertical_power: f32, pub hit_sound: &'static str, @@ -40,13 +46,16 @@ pub struct Archetype { pub push_threshold: f32, } macro_rules! arch { - ($n:literal, $b:expr, $e:expr, $c:expr, $k:expr, $h:expr, $v:expr, $cd:expr, $t:expr) => { + ($n:literal, $b:expr, $e:expr, $c:expr, $k:expr, $phys:expr, $h:expr, $v:expr, $cd:expr, $t:expr) => { Archetype { name: $n, buoyant: $b, explosion: $e, contact_damage: $c, knockback_resistance: $k, + bounciness: $phys.0, + friction_modifier: $phys.1, + air_drag_modifier: $phys.2, horizontal_power: $h, vertical_power: $v, hit_sound: concat!("entity.sulfur_cube.", $n, ".hit"), @@ -58,13 +67,25 @@ macro_rules! arch { } /// `data/minecraft/sulfur_cube_archetype/*.json`. pub const ARCHETYPES: [Archetype; 12] = [ - arch!("bouncy", true, None, None, -2.0, 0.4125, 0.105, 0.7, 0.3), + arch!( + "bouncy", + true, + None, + None, + -2.0, + (0.9, 0.3, 0.01), + 0.4125, + 0.105, + 0.7, + 0.3 + ), arch!( "explosive", true, Some((120, 3.0, false)), None, -1.0, + (0.5, 0.3, 0.3), 0.4125, 0.09, 0.7, @@ -76,6 +97,7 @@ pub const ARCHETYPES: [Archetype; 12] = [ None, None, -1.0, + (0.5, 0.2, 0.01), 0.9125, 0.09, 0.9, @@ -87,6 +109,7 @@ pub const ARCHETYPES: [Archetype; 12] = [ None, None, 0.5, + (0.1, 0.05, 0.01), 0.6625, 0.09, 1.0, @@ -98,20 +121,55 @@ pub const ARCHETYPES: [Archetype; 12] = [ None, None, 0.7, + (0.2, 1.0, 0.01), 0.4125, 0.09, 0.7, 0.03 ), - arch!("hot", true, None, Some(1.0), -1.0, 0.4125, 0.09, 0.7, 0.2), - arch!("light", true, None, None, -1.0, 0.4125, 0.18, 0.7, 0.2), - arch!("regular", true, None, None, -1.0, 0.4125, 0.09, 0.5, 0.2), + arch!( + "hot", + true, + None, + Some(1.0), + -1.0, + (0.5, 0.3, 0.1), + 0.4125, + 0.09, + 0.7, + 0.2 + ), + arch!( + "light", + true, + None, + None, + -1.0, + (1.0, 0.3, 1.8), + 0.4125, + 0.18, + 0.7, + 0.2 + ), + arch!( + "regular", + true, + None, + None, + -1.0, + (0.5, 0.3, 0.1), + 0.4125, + 0.09, + 0.5, + 0.2 + ), arch!( "slow_bouncy", false, None, None, 0.4, + (0.6, 0.3, 0.05), 0.4125, 0.24, 0.5, @@ -123,6 +181,7 @@ pub const ARCHETYPES: [Archetype; 12] = [ None, None, 0.5, + (0.4, 0.4, 0.1), 0.4125, 0.105, 0.9, @@ -134,12 +193,24 @@ pub const ARCHETYPES: [Archetype; 12] = [ None, None, 0.8, + (0.1, 0.05, 0.01), 0.4125, 0.09, 1.0, 0.02 ), - arch!("sticky", false, None, None, -2.0, 0.4125, 0.09, 0.5, 0.05), + arch!( + "sticky", + false, + None, + None, + -2.0, + (0.0, 2.0, 0.01), + 0.4125, + 0.09, + 0.5, + 0.05 + ), ]; /// `SulfurCubeArchetype.DEFAULT_*`: no block swallowed. const DEFAULT_PUSH: (&str, f32, f32) = ("entity.sulfur_cube.regular.push", 0.5, 0.2); @@ -178,6 +249,15 @@ pub fn has_body(m: &Mob) -> bool { pub fn archetype(m: &Mob) -> Option<&'static Archetype> { m.extra.head.as_deref().and_then(archetype_of) } +/// The archetype whose bounciness, friction and air drag attributes a +/// sulfur cube's physics use (no other mob has those modifiers). +pub fn physics(m: &Mob) -> Option<&'static Archetype> { + if m.species() == super::Species::SulfurCube { + archetype(m) + } else { + None + } +} pub fn fuse(m: &Mob) -> i32 { m.extra.counter2 - 1 } @@ -290,6 +370,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { source.kind, DamageKind::PlayerAttack | DamageKind::MaceSmash + | DamageKind::Spear | DamageKind::MobAttack | DamageKind::Arrow | DamageKind::Thrown @@ -298,6 +379,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool { | DamageKind::Sting | DamageKind::Cactus | DamageKind::Freeze + | DamageKind::SweetBerryBush ); if immune { if let Some(from) = source.from { diff --git a/crates/horizon-client/src/mobs/sync.rs b/crates/horizon-client/src/mobs/sync.rs index d1c5b6609..16cd2b30c 100644 --- a/crates/horizon-client/src/mobs/sync.rs +++ b/crates/horizon-client/src/mobs/sync.rs @@ -15,11 +15,16 @@ //! them in `entity_event`; //! - run its client side animation in `client_tick`, sharing the function //! with the server's `ai_step` where the server computes the same. -use super::{Mob, Species, breeze, camel, shulker, sniffer, warden}; +use super::{ + Mob, Species, allay, armadillo, axolotl, breeze, camel, copper_golem, creaking, frog, goat, + golem, guardian, piglin, ravager, shulker, sniffer, warden, +}; // `Pose.id` of the poses mobs take. pub const STANDING: u8 = 0; pub const LONG_JUMPING: u8 = 6; +pub const CROAKING: u8 = 8; +pub const USING_TONGUE: u8 = 9; pub const SITTING: u8 = 10; pub const ROARING: u8 = 11; pub const SNIFFING: u8 = 12; @@ -36,14 +41,16 @@ pub fn pose_id(m: &Mob) -> u8 { Species::Warden => warden::pose_id(m), Species::Breeze => breeze::pose_id(m), Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING, + Species::Frog => m.extra.pose, _ => STANDING, } } /// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client. pub fn set_pose(m: &mut Mob, id: u8) { - m.extra.pose = id; + let old = std::mem::replace(&mut m.extra.pose, id); match m.species() { + Species::Frog if old != id => frog::pose_changed(m), Species::Warden => warden::set_pose_id(m, id), Species::Breeze => breeze::set_pose_id(m, id), _ => {} @@ -60,6 +67,26 @@ pub fn client_tick(m: &mut Mob, game_time: i64) { Species::Breeze => breeze::ai_step(m), Species::Camel | Species::CamelHusk => camel::client_tick(m, game_time), Species::Shulker => shulker::client_tick(m), + Species::Ravager => ravager::client_tick(m), + Species::Hoglin | Species::Zoglin => piglin::client_tick(m), + Species::IronGolem => golem::client_tick(m), + Species::Creaking => creaking::animate(m), + Species::Allay => { + m.anim.vo = m.anim.v; + allay::animate(m); + } + Species::Axolotl => axolotl::tick_animation(m), + Species::Guardian | Species::ElderGuardian => { + m.anim.vo = m.anim.v; + guardian::tail_and_spikes(m); + } + // The head spin's sound is the server's. + Species::CopperGolem if !m.no_ai => { + copper_golem::animate(m); + } + Species::Armadillo => armadillo::tick(m), + Species::Frog => frog::tick(m), + Species::Goat => goat::tick(m), _ => {} } } @@ -67,9 +94,15 @@ pub fn client_tick(m: &mut Mob, game_time: i64) { /// `handleEntityEvent` of the mob types that start animations by an event /// (`ClientboundEntityEventPacket` for a mob of a client). pub fn entity_event(m: &mut Mob, event: u8) { + if m.species() == Species::Armadillo { + armadillo::entity_event(m, event); + } + if m.species() == Species::Goat { + goat::entity_event(m, event); + } let age = m.age as f32; - if m.species() == Species::Warden { - match event { + match m.species() { + Species::Warden => match event { // Attack: the roar ends, the swing starts. 4 => { m.anim.states[warden::ROAR].stop(); @@ -80,6 +113,11 @@ pub fn entity_event(m: &mut Mob, event: u8) { // The sonic boom. 62 => m.anim.states[warden::SONIC_BOOM].start(age), _ => {} - } + }, + Species::Ravager => ravager::entity_event(m, event), + Species::Hoglin | Species::Zoglin => piglin::client_event(m, event), + Species::IronGolem => golem::client_event(m, event), + Species::Creaking => creaking::entity_event(m, event), + _ => {} } } diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs index f38296d4b..faee3c4de 100644 --- a/crates/horizon-client/src/mobs/tame.rs +++ b/crates/horizon-client/src/mobs/tame.rs @@ -100,6 +100,48 @@ pub fn register(m: &mut Mob) { ), ); } +/// `Parrot.registerGoals`: a tamed parrot sits when told to and follows its +/// owner from five blocks away (the wander and the shoulder come as they are). +pub fn register_parrot(m: &mut Mob) { + let g = &mut m.ai.goals; + g.add(0, TamePanic(Panic::new(1.25))); + g.add(0, Float); + g.add(1, LookAtPlayer::new(8.0)); + g.add(2, SitWhenOrdered); + g.add(2, FollowOwner::new(1.0, 5.0, 1.0)); + g.add(2, Stroll::avoiding_water(1.0)); + g.add(3, LandOnOwnersShoulder); +} +/// `LandOnOwnersShoulderGoal`: a standing parrot, 100 ticks old, lands on +/// the shoulder of the owner it touches; the host does the landing. +#[derive(Clone, Debug)] +struct LandOnOwnersShoulder; +impl Goal for LandOnOwnersShoulder { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + // ShoulderRidingEntity.canSitOnShoulder: rideCooldownCounter > 100. + is_owner(m, cx.w) + && owner(m, cx.w).is_some_and(|(_, _, spectator)| !spectator) + && !m.extra.sitting + && m.age > 100 + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + if !m.extra.sitting + && m.extra.leash.is_none() + && is_owner(m, cx.w) + && cx + .w + .player + .as_ref() + .is_some_and(|p| m.bounds().intersects(p.bounds)) + { + cx.events.push(MobEvent::ParrotToShoulder { mob: m.id }); + } + } +} /// `Wolf.PREY_SELECTOR`: sheep, rabbits and foxes. fn wolf_prey(s: &super::Seen) -> bool { matches!(s.species, Species::Sheep | Species::Rabbit | Species::Fox) @@ -138,6 +180,18 @@ fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> { let p = owner_view(m, w)?; Some((p.position, p.eye[1], p.spectator)) } +/// Whether the player the mob sees is the one saved as its owner (with +/// guests on, that player is whoever stands nearest). +fn is_owner(m: &Mob, w: &MobWorld) -> bool { + w.player + .as_ref() + .is_some_and(|p| owned_by(m.extra.owner, p.uuid)) +} +/// Whether `uuid` is the saved owner. A host with no UUID yet owns what it +/// tamed under the placeholder `[0, 0, 0, 1]`. +pub fn owned_by(owner: Option<[i32; 4]>, uuid: [i32; 4]) -> bool { + owner.is_some_and(|o| o == uuid || (o == [0, 0, 0, 1] && uuid == [0; 4])) +} /// `TamableAnimal.unableToMoveToOwner`. fn unable_to_move_to_owner(m: &Mob, w: &MobWorld) -> bool { m.extra.sitting || owner_view(m, w).is_some_and(|p| p.spectator) @@ -448,7 +502,8 @@ impl Goal for OwnerHurt { m.ai.target = None; } } -/// `Wolf.wantsToAttack`: never creepers, ghasts or tame wolves and cats. +/// `Wolf.wantsToAttack`: never creepers, ghasts, tame cats and parrots, or a +/// tame wolf of the same owner. fn wants_to_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { let Who::Mob(id) = who else { return false; @@ -461,7 +516,8 @@ fn wants_to_attack(m: &Mob, w: &MobWorld, who: Who) -> bool { }; match s.species { Species::Creeper | Species::Ghast => false, - Species::Wolf | Species::Cat | Species::Parrot => !s.tame, + Species::Wolf => !s.tame || s.owner != m.extra.owner, + Species::Cat | Species::Parrot => !s.tame, Species::Horse | Species::Donkey | Species::Mule | Species::Llama => !s.tame, _ => true, } diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs index e56973384..58417052e 100644 --- a/crates/horizon-client/src/mobs/turtle.rs +++ b/crates/horizon-client/src/mobs/turtle.rs @@ -1,23 +1,77 @@ //! Turtles (`Turtle`): the egg a bred mother carries (`TurtleBreedGoal`), her //! walk home (`TurtleGoHomeGoal`) and the egg she digs into the sand //! (`TurtleLayEggGoal`). `extra.flag` is `hasEgg`, `extra.flag2` `isLayingEgg`, -//! `extra.counter` `layEggCounter` and `extra.home` `homePos`. Its own -//! `TurtleMoveControl` sets the speed it walks and swims at. Not ported yet: -//! `Turtle.travelInWater` (swimming still uses the generic fluid travel), -//! `TurtlePathNavigation` and the rest of the turtle goal set, so movement in -//! water still differs from vanilla. +//! `extra.counter` `layEggCounter`, `extra.home` `homePos`, `extra.counter2` +//! `goingHome` and `extra.point` `travelPos`. Its own `TurtleMoveControl` +//! sets the speed it walks and swims at. Not ported yet: `Turtle.travelInWater` +//! (swimming still uses the generic fluid travel), so movement in water still +//! differs from vanilla. use super::{ Mob, MobEvent, MobWorld, control::{EPSILON, Operation, rotlerp}, - goals::{Breed, Cx, Goal, JUMP, MOVE, MoveToBlock, goal_clone, reduced}, + goals::{ + Breed, Cx, Goal, JUMP, LookAtPlayer, MOVE, MoveToBlock, Panic, Stroll, Tempt, goal_clone, + reduced, + }, + nav::NavKind, + path::PathType, }; +use crate::blocks::Fluid; use horizon_core::{geometry::trig, random::RandomSource}; +/// `Turtle.registerGoals`, and the path maluses and navigation `Turtle` and +/// `TurtlePathNavigation` give it. pub fn register(m: &mut Mob) { + m.set_malus(PathType::Water, 0.0); + for t in [ + PathType::DoorIronClosed, + PathType::DoorWoodClosed, + PathType::DoorOpen, + ] { + m.set_malus(t, -1.0); + } + m.ai.nav.kind = NavKind::Amphibious; + let food = m.kind.food.clone(); let g = &mut m.ai.goals; + g.add(0, Panic::new(1.2).looking_for_water(7)); g.add(1, Breed::new(1.0)); g.add(1, LayEgg(MoveToBlock::new(1.0, 16, 1))); + g.add(2, Tempt::new(1.1, food, false)); + g.add( + 3, + GoToWater(MoveToBlock { + vertical_start: -1, + ..MoveToBlock::new(1.0, 24, 1) + }), + ); g.add(4, GoHome::default()); + g.add(7, Travel::default()); + g.add(8, LookAtPlayer::new(8.0)); + g.add(9, RandomStroll(Stroll::new(1.0).interval(100))); +} +/// `Turtle.goingHome`. +fn going_home(m: &Mob) -> bool { + m.extra.counter2 != 0 +} +fn set_going_home(m: &mut Mob, on: bool) { + m.extra.counter2 = i32::from(on); +} +/// `Turtle.getWalkTargetValue`; `light` is `getPathfindingCostFromLightLevels`. +pub fn walk_target_value(m: &Mob, w: &MobWorld, p: [i32; 3], light: f32) -> f32 { + if !going_home(m) && w.fluid(p[0], p[1], p[2]) == Fluid::Water + || is_sand(w, [p[0], p[1] - 1, p[2]]) + { + 10.0 + } else { + light + } +} +/// `TurtlePathNavigation.isStableDestination` while travelling: water only. +/// `None` without a `travelPos`, the amphibious rule then. +pub fn stable_destination(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option { + m.extra + .point + .map(|_| w.block_name(p[0], p[1], p[2]) == "minecraft:water") } /// `Turtle.hasEgg`. pub fn has_egg(m: &Mob) -> bool { @@ -209,10 +263,14 @@ impl Goal for GoHome { m.random.next_int_bound(reduced(700)).unwrap_or(1) == 0 && !close_to_home(m, 64.0) } } - fn start(&mut self, _m: &mut Mob, _cx: &mut Cx) { + fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { + set_going_home(m, true); self.stuck = false; self.close_to_home_try_ticks = 0; } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + set_going_home(m, false); + } fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { !close_to_home(m, 7.0) && !self.stuck && self.close_to_home_try_ticks <= reduced(600) } @@ -252,6 +310,173 @@ impl Goal for GoHome { } } +/// `Turtle.TurtleGoToWaterGoal`: a turtle on land walks to water within 24 +/// blocks, unless it is going home or carries an egg. +#[derive(Clone, Debug)] +struct GoToWater(MoveToBlock); +impl GoToWater { + fn valid(w: &MobWorld, p: [i32; 3]) -> bool { + w.block_name(p[0], p[1], p[2]) == "minecraft:water" + } +} +impl Goal for GoToWater { + goal_clone!(); + fn flags(&self) -> u8 { + MOVE | JUMP + } + fn name(&self) -> &'static str { + "TurtleGoToWaterGoal" + } + fn every_tick(&self) -> bool { + true + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + let wanted = if m.is_baby() && !m.fluids.in_water { + true + } else { + !going_home(m) && !m.fluids.in_water && !has_egg(m) + }; + if !wanted { + return false; + } + // MoveToBlockGoal.canUse. + if self.0.next_start > 0 { + self.0.next_start -= 1; + return false; + } + self.0.next_start = reduced(200 + m.random.next_int_bound(200).unwrap_or(0)); + self.0.find_nearest(m, cx.w, Self::valid) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + !m.fluids.in_water && self.0.try_ticks <= 1200 && Self::valid(cx.w, self.0.block) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx.w); + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + // MoveToBlockGoal.tick, with shouldRecalculatePath every 160 ticks. + let b = self.0.block; + let d = [ + f64::from(b[0]) + 0.5 - m.position.x, + f64::from(b[1] + 1) + 0.5 - m.position.y, + f64::from(b[2]) + 0.5 - m.position.z, + ]; + if d[0] * d[0] + d[1] * d[1] + d[2] * d[2] >= 1.0 { + self.0.reached = false; + self.0.try_ticks += 1; + if self.0.try_ticks % 160 == 0 { + let at = [ + f64::from(b[0]) + 0.5, + f64::from(b[1] + 1), + f64::from(b[2]) + 0.5, + ]; + m.nav_move_to(cx.w, at, self.0.speed); + } + } else { + self.0.reached = true; + self.0.try_ticks -= 1; + } + } +} + +/// `Turtle.TurtleTravelGoal`: a turtle in water swims towards a spot up to +/// 512 blocks away, a leg at a time. +#[derive(Clone, Debug, Default)] +struct Travel { + stuck: bool, +} +impl Goal for Travel { + goal_clone!(); + fn flags(&self) -> u8 { + 0 + } + fn name(&self) -> &'static str { + "TurtleTravelGoal" + } + fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + !going_home(m) && !has_egg(m) && m.fluids.in_water + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + let xt = m.random.next_int_bound(1025).unwrap_or(0) - 512; + let mut yt = m.random.next_int_bound(9).unwrap_or(0) - 4; + let zt = m.random.next_int_bound(1025).unwrap_or(0) - 512; + if f64::from(yt) + m.position.y > f64::from(cx.w.sea_level - 1) { + yt = 0; + } + m.extra.point = Some([ + (f64::from(xt) + m.position.x).floor(), + (f64::from(yt) + m.position.y).floor(), + (f64::from(zt) + m.position.z).floor(), + ]); + self.stuck = false; + } + fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { + !m.ai.nav.is_done() && !self.stuck && !going_home(m) && m.extra.in_love <= 0 && !has_egg(m) + } + fn stop(&mut self, m: &mut Mob, _cx: &mut Cx) { + m.extra.point = None; + } + fn tick(&mut self, m: &mut Mob, cx: &mut Cx) { + let Some(travel) = m.extra.point else { + self.stuck = true; + return; + }; + if !m.ai.nav.is_done() { + return; + } + // Vec3.atBottomCenterOf(travelPos). + let to = [travel[0] + 0.5, travel[1], travel[2] + 0.5]; + let tenth = f64::from((std::f64::consts::PI / 10.0) as f32); + let half = f64::from(std::f32::consts::FRAC_PI_2); + let mut next = m + .default_random_pos_towards(cx.w, 16, 3, to, tenth) + .or_else(|| m.default_random_pos_towards(cx.w, 8, 7, to, half)); + if let Some(n) = next { + let (xc, zc) = (n[0].floor() as i32, n[2].floor() as i32); + // Level.hasChunksAt(xc - 34, zc - 34, xc + 34, zc + 34). + let loaded = ((xc - 34) >> 4..=(xc + 34) >> 4).all(|chunk_x| { + ((zc - 34) >> 4..=(zc + 34) >> 4) + .all(|chunk_z| cx.w.world.chunks.contains_key(&(chunk_x, chunk_z))) + }); + if !loaded { + next = None; + } + } + match next { + Some(at) => { + m.nav_move_to(cx.w, at, 1.0); + } + None => self.stuck = true, + } + } +} + +/// `Turtle.TurtleRandomStrollGoal`: no stroll in water, going home or with an +/// egg. +#[derive(Clone, Debug)] +struct RandomStroll(Stroll); +impl Goal for RandomStroll { + goal_clone!(); + fn flags(&self) -> u8 { + self.0.flags() + } + fn name(&self) -> &'static str { + "TurtleRandomStrollGoal" + } + fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + !m.fluids.in_water && !going_home(m) && !has_egg(m) && self.0.can_use(m, cx) + } + fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { + self.0.can_continue(m, cx) + } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.start(m, cx); + } + fn stop(&mut self, m: &mut Mob, cx: &mut Cx) { + self.0.stop(m, cx); + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs index 3707f4bbe..0f446c87a 100644 --- a/crates/horizon-client/src/mobs/undead.rs +++ b/crates/horizon-client/src/mobs/undead.rs @@ -498,15 +498,77 @@ fn zombified_piglin_step(m: &mut Mob, cx: &mut Cx) { } } } +/// `Entity.isInPowderSnow`: the mob's box, shrunk by `1.0E-5` as in +/// `checkInsideBlocks`, touches powder snow. +fn in_powder_snow(m: &Mob, w: &super::MobWorld) -> bool { + let b = m.bounds().deflate(Vec3::new(1e-5, 1e-5, 1e-5)); + let (min, max) = (b.min_position(), b.max_position()); + for x in min.x.floor() as i32..=max.x.floor() as i32 { + for y in min.y.floor() as i32..=max.y.floor() as i32 { + for z in min.z.floor() as i32..=max.z.floor() as i32 { + if &*w.facts.get(w.world.block(x, y, z)).name == "minecraft:powder_snow" { + return true; + } + } + } + } + false +} +/// `Skeleton.freezingTracker` (`ConversionTracker.tick`): 140 ticks in +/// powder snow start a conversion into a stray that takes 300 more; leaving +/// the snow stops it. `counter` is the affliction time (-1 outside the snow) +/// and `counter2` the conversion time plus one while converting, so that +/// reaching 0 is vanilla's `conversionTime < 0`. +fn skeleton_freezing(m: &mut Mob, cx: &mut Cx) { + if !in_powder_snow(m, cx.w) { + m.extra.counter = -1; + m.extra.counter2 = 0; + } else if m.extra.counter2 > 0 { + m.extra.counter2 -= 1; + if m.extra.counter2 == 0 { + // levelEvent 1048: the conversion sound at the stray. + let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0; + cx.events.push(MobEvent::Sound( + "entity.skeleton.converted_to_stray", + m.center(), + 2.0, + pitch, + )); + cx.events.push(MobEvent::SpawnKind { + kind: "minecraft:stray".into(), + at: [m.position.x, m.position.y, m.position.z], + setup: super::SpawnSetup { + yaw: m.yaw, + persistent: m.persistent, + ..Default::default() + }, + }); + m.removed = true; + } + } else { + m.extra.counter += 1; + if m.extra.counter >= 140 { + m.extra.counter2 = 301; + } + } +} pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) { if m.species() == Species::ZombieVillager { super::zombie_villager::step(m, cx); } + if m.species() == Species::Skeleton && m.alive() && !m.no_ai { + skeleton_freezing(m, cx); + } if m.species() == Species::ZombifiedPiglin { return zombified_piglin_step(m, cx); } if matches!(m.species(), Species::Zombie | Species::Husk) && m.alive() { - if m.extra.counter2 > 0 { + if m.extra.counter2 > 0 && !m.fluids.eye_in_water { + // ConversionTracker.tick: leaving the water ends a started + // conversion too. + m.extra.counter = -1; + m.extra.counter2 = 0; + } else if m.extra.counter2 > 0 { m.extra.counter2 -= 1; if m.extra.counter2 == 0 { let (kind, sound) = if m.species() == Species::Husk { @@ -782,8 +844,9 @@ pub fn perform_ranged_attack(m: &mut Mob, who: Who, cx: &mut Cx, power: f32) { let zd = t.position.z - m.position.z; let dist = (xd * xd + zd * zd).sqrt(); // AbstractArrow.setBaseDamageFromMob: power * 2 + triangle(difficulty * 0.11, 0.57425). + let id = i32::from(cx.w.difficulty.id); let mut arrow_random = crate::projectiles::own_random(m); - let base = f64::from(power) * 2.0 + arrow_random.triangle(2.0 * 0.11, 0.574_25); + let base = f64::from(power) * 2.0 + arrow_random.triangle(f64::from(id) * 0.11, 0.574_25); let effect = match m.species() { Species::Stray => Some(("minecraft:slowness", 600)), Species::Bogged => Some(("minecraft:poison", 100)), @@ -804,7 +867,7 @@ pub fn perform_ranged_attack(m: &mut Mob, who: Who, cx: &mut Cx, power: f32) { &mut arrow_random, [xd, yd + dist * 0.2, zd], 1.6, - (14 - 2 * 4) as f32, + (14 - id * 4) as f32, ); cx.events.push(MobEvent::Projectile(p)); let pitch = 1.0 / (m.random.next_float() * 0.4 + 0.8); @@ -978,16 +1041,21 @@ impl Goal for AttackTurtleEgg { pos: eat, drop: false, }); + // `sendParticles(POOF, ..., 1, xa, ya, za, 0.15)`, twenty times. for _ in 0..20 { - m.random.next_gaussian(); - m.random.next_gaussian(); - m.random.next_gaussian(); + let spread = [ + m.random.next_gaussian() * 0.02, + m.random.next_gaussian() * 0.02, + m.random.next_gaussian() * 0.02, + ]; + cx.events.push(MobEvent::LevelParticles { + kind: "poof", + at: [center[0], f64::from(eat[1]), center[2]], + spread, + speed: 0.15, + count: 1, + }); } - cx.events.push(MobEvent::Particles { - kind: "poof", - at: [center[0], f64::from(eat[1]), center[2]], - count: 20, - }); // The break sound's pitch draws from the level random. cx.events.push(MobEvent::Sound( "block.turtle_egg.break", diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs index 20280b190..632ba8c81 100644 --- a/crates/horizon-client/src/mobs/villager.rs +++ b/crates/horizon-client/src/mobs/villager.rs @@ -353,18 +353,14 @@ pub fn food_points(item: &str) -> i32 { _ => 0, } } -/// The farmer's `requestedItems`. +/// The farmer's `requestedItems` (`VillagerProfession.FARMER`). Food is picked +/// up and traded separately, through its villager food value. pub fn farmer_items() -> &'static [&'static str] { &[ - "minecraft:bread", - "minecraft:potato", - "minecraft:carrot", "minecraft:wheat", "minecraft:wheat_seeds", - "minecraft:beetroot", "minecraft:beetroot_seeds", - "minecraft:torchflower_seeds", - "minecraft:pitcher_pod", + "minecraft:bone_meal", ] } /// A villager's `requestedItems` by profession. diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs index 747443577..0714bfc64 100644 --- a/crates/horizon-client/src/mobs/warden.rs +++ b/crates/horizon-client/src/mobs/warden.rs @@ -730,34 +730,11 @@ pub(super) fn tick_sonic_boom(m: &mut Mob, w: &MobWorld, events: &mut Vec events.push(MobEvent::DamagePlayer { - amount: 10.0, - from, - kind: "minecraft:sonic_boom", - }), - Who::Mob(id) => events.push(MobEvent::AttackMob { - target: id, - amount: 10.0, - source: Damage { - kind: DamageKind::SonicBoom, - attacker: Some(Who::Mob(m.id)), - from: Some(from), - }, - }), - } - let horizontal = 2.5 * (1.0 - resistance); - let vertical = 0.5 * (1.0 - resistance); - events.push(MobEvent::Push { + events.push(MobEvent::SonicBoom { target, - velocity: [ - normal[0] * horizontal, - normal[1] * vertical, - normal[2] * horizontal, - ], + attacker: m.id, + from: at(m), + direction: normal, }); } /// `Warden.tick` on the client: the heartbeat (pitched by the client's copy diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs index 2fdd16372..0a429b135 100644 --- a/crates/horizon-client/src/mobs/wither.rs +++ b/crates/horizon-client/src/mobs/wither.rs @@ -169,6 +169,26 @@ fn target_pos(w: &MobWorld, id: i32) -> Option<([f64; 3], f64, bool)> { .map(|s| ([s.position.x, s.position.y, s.position.z], s.eye_y, false)), } } +/// `WitherBoss.aiStep` on a client of a server: the smoke about each head +/// (`radius` 0.3 of the wither's scale, which is 1 here). The heads' turning +/// and the coloured particles need the server's targets and invulnerable +/// ticks, which a client is not sent. +pub fn client_smoke(m: &mut Mob, events: &mut Vec) { + for i in 0..3 { + let h = head_pos(m, i); + let r = &mut m.random; + let at = [ + h[0] + r.next_gaussian() * 0.3, + h[1] + r.next_gaussian() * 0.3, + h[2] + r.next_gaussian() * 0.3, + ]; + events.push(MobEvent::ParticleAt { + kind: "smoke", + at, + velocity: [0.0; 3], + }); + } +} /// `WitherBoss.aiStep` after `super.aiStep()`: the side heads turn, smoke /// rises from the heads (the particle offsets are drawn on the server too). pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec) { diff --git a/crates/horizon-client/src/models/catalog.rs b/crates/horizon-client/src/models/catalog.rs index 2e6326c40..c02e97240 100644 --- a/crates/horizon-client/src/models/catalog.rs +++ b/crates/horizon-client/src/models/catalog.rs @@ -28,6 +28,8 @@ use std::{ pub struct BakedFace { pub quad: ModelQuad, pub layer: u32, + /// The texels under the quad's UVs are all opaque (`SpriteContents.computeTransparency`): + /// drawn in the solid layer without an alpha test. pub opaque: bool, /// Fractional alpha: drawn in the sorted translucent pass. pub translucent: bool, @@ -230,9 +232,9 @@ impl StateModels { Ok(BakedFace { translucent: quad.material.force_translucent || sprites.translucent[layer as usize], + opaque: sprites.region_opaque(layer, &quad.uv), quad, layer, - opaque: sprites.opaque[layer as usize], }) }) .collect::>()?; diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 0ff3b13c5..e9899ad40 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -13,6 +13,7 @@ use horizon_world::{ attributes::{Modifier, Operation, entity::Catalog, live::LiveAttributes}, block_collision::BlockCollisionRegistry, block_landing::BlockLandingRegistry, + climbing::{self, ClimbingRegistry, ClimbingWorld}, collision_context::{CollisionContext, CollisionEntity, CollisionItem}, edge_backoff::{self, EdgeBackoffInput, EdgeBackoffWorld}, entity_move::{self, CollisionFlags, EntityMoveWorld, MovementHistory, MoverType}, @@ -50,11 +51,15 @@ pub struct MotionResources { pub attributes: Arc, pub blocks: BoundMovementProperties, pub climbable: BTreeSet, - /// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes. - pub glide_through: BTreeSet, /// `BlockTags.SOUL_SPEED_BLOCKS`: what Soul Speed's effects look for. pub soul_speed_blocks: BTreeSet, + /// `LivingEntity.onClimbable` tags plus open trapdoors above a ladder. + pub climbing: ClimbingRegistry<'static>, pub fall_reset: BTreeSet, + /// `BlockTags.INSIDE_STEP_SOUND_BLOCKS`. + pub inside_step_sound: BTreeSet, + /// `BlockTags.COMBINATION_STEP_SOUND_BLOCKS`. + pub combination_step_sound: BTreeSet, /// `BlockTags.CRYSTAL_SOUND_BLOCKS`: blocks that chime under footsteps. pub crystal_sound: BTreeSet, pub landing: BlockLandingRegistry, @@ -103,6 +108,12 @@ impl MotionResources { .cloned() .collect()) }; + let climbing = ClimbingRegistry::new( + assets.registry, + &tag("minecraft:trapdoors")?, + &tag("minecraft:climbable")?, + &tag("minecraft:can_glide_through")?, + )?; Ok(Self { landing: crate::landing::load(root, &properties)?, health: crate::health::HealthResources::load(root)?, @@ -114,9 +125,11 @@ impl MotionResources { suppresses_bounce: tag("minecraft:suppresses_bounce")?, })?, climbable: tag("minecraft:climbable")?, - glide_through: tag("minecraft:can_glide_through")?, soul_speed_blocks: tag("minecraft:soul_speed_blocks")?, + climbing, fall_reset: tag("minecraft:fall_damage_resetting")?, + inside_step_sound: tag("minecraft:inside_step_sound_blocks")?, + combination_step_sound: tag("minecraft:combination_step_sound_blocks")?, crystal_sound: tag("minecraft:crystal_sound_blocks")?, }) } @@ -162,11 +175,12 @@ pub enum MotionEvent { position: BlockPos, }, /// `Entity.walkingStepSound` on this block: `Player.playStepSound` - /// muffles it under a swim sound when `in_water`. + /// mutes it (`playMuffledStepSound`) under a swim sound in water or + /// under a combination block's own step. Emission { position: BlockPos, state: BlockStateId, - in_water: bool, + muffled: bool, }, /// `Entity.playAmethystStepSound`: `block.amethyst_block.chime`. Chime { @@ -352,6 +366,8 @@ pub struct PlayerMotion { pub leather_boots: bool, /// An armor piece in `#freeze_immune_wearables` (`LivingEntity.canFreeze`). pub freeze_immune: bool, + /// A worn enchantment's `damage_immunity` to `#burn_from_stepping` (frost walker). + pub burn_from_stepping_immune: bool, /// `Entity.oldPosition`: where this tick started. pub old_position: Vec3, /// The server's copy of a player another client moves (a LAN guest), while @@ -533,6 +549,7 @@ impl PlayerMotion { ticks_frozen: 0, leather_boots: false, freeze_immune: false, + burn_from_stepping_immune: false, old_position: position, server_copy: false, wall_hit_events: None, @@ -812,27 +829,15 @@ impl MotionWorld<'_, '_, '_> { supporting_block: self.player.ground.supporting_block, } } - /// `LivingEntity.onClimbable` at the player's feet (it remembers the block). + /// `Player.onClimbable` (never while flying) over `LivingEntity.onClimbable` + /// at the player's feet: the climbable tag or an open trapdoor above a + /// matching ladder. It remembers the block. pub fn climbable(&mut self) -> Result { - if self.player.spectator { + if self.player.flying { return Ok(false); } - let p = BlockPos::containing(self.player.position); - let name = &self - .assets - .registry - .state(self.block(p)) - .ok_or("missing scene state")? - .name; - // A gliding player passes through vines (`CAN_GLIDE_THROUGH`). - if self.player.fall_flying && self.resources.glide_through.contains(name) { - return Ok(false); - } - let climbable = self.resources.climbable.contains(name); - if climbable { - self.player.last_climbable = Some(p); - } - Ok(climbable) + let resources = self.resources; + climbing::on_climbable(self, &resources.climbing).map_err(|e| e.to_string().into()) } pub fn travel_in_air(&mut self, input: Vec3) -> Result<()> { living_air::travel_in_air(self, input) @@ -1800,6 +1805,30 @@ impl MotionWorld<'_, '_, '_> { Ok(()) } } +impl ClimbingWorld for MotionWorld<'_, '_, '_> { + type Error = std::convert::Infallible; + fn is_spectator(&mut self) -> std::result::Result { + Ok(self.player.spectator) + } + fn block_position(&mut self) -> std::result::Result { + Ok(BlockPos::containing(self.player.position)) + } + fn in_block_state(&mut self) -> std::result::Result { + Ok(self.block(BlockPos::containing(self.player.position))) + } + fn is_fall_flying(&mut self) -> std::result::Result { + Ok(self.player.fall_flying) + } + fn block_state( + &mut self, + position: BlockPos, + ) -> std::result::Result { + Ok(self.block(position)) + } + fn set_last_climbable_position(&mut self, position: BlockPos) { + self.player.last_climbable = Some(position); + } +} impl crate::auto_jump::AutoJumpWorld for MotionWorld<'_, '_, '_> { type Error = Box; fn collision_shape(&mut self, p: BlockPos) -> Result { @@ -1937,7 +1966,8 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> { let input = EdgeBackoffInput { movement, bounds: self.player.bounds(), - flying: false, + // Player.maybeBackOffFromEdge: not while flying. + flying: self.player.flying, self_or_player: matches!(mover, MoverType::SelfMovement | MoverType::Player), fall_distance: self.player.fall_distance, query_budget: 1_000_000, @@ -2180,18 +2210,54 @@ impl MovementEmissionWorld for MotionWorld<'_, '_, '_> { fn in_water(&mut self) -> Result { Ok(self.player.fluids.was_touching_water) } - /// `Player.playStepSound`: in water a swim sound, then the step muffled. + /// `Player.playStepSound`: in water a swim sound, then the step muffled; + /// on land the step of an inside-sound block above the floor, or of a + /// combination block above it with the floor's step muffled. fn walking_step_sound(&mut self, position: BlockPos, state: BlockStateId) -> Result<()> { - let in_water = self.player.fluids.was_touching_water; - if in_water { + let muffled = self.player.fluids.was_touching_water; + let mut stepped = false; + if muffled { self.water_swim_sound()?; + } else { + // Entity.getPrimaryStepSoundBlockPos. + let above = BlockPos { + y: position.y + 1, + ..position + }; + let above_state = self.block(above); + let name = &self + .assets + .registry + .state(above_state) + .ok_or("missing scene state")? + .name; + let combination = self.resources.combination_step_sound.contains(name); + if combination || self.resources.inside_step_sound.contains(name) { + self.player.events.push(MotionEvent::Emission { + position: above, + state: above_state, + muffled: false, + }); + if combination { + // Entity.playCombinationStepSounds. + self.player.events.push(MotionEvent::Emission { + position, + state, + muffled: true, + }); + } + stepped = true; + } } - self.player.events.push(MotionEvent::Emission { - position, - state, - in_water, - }); - // Entity.walkingStepSound: the amethyst chime after the step. + if !stepped { + self.player.events.push(MotionEvent::Emission { + position, + state, + muffled, + }); + } + // Entity.walkingStepSound: the amethyst chime after the step, by the + // floor's state even when the step sound was the block above's. let name = &self .assets .registry diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs index 5e9bdfec8..826cc31bb 100644 --- a/crates/horizon-client/src/motion/environment.rs +++ b/crates/horizon-client/src/motion/environment.rs @@ -10,6 +10,12 @@ impl MotionWorld<'_, '_, '_> { if self.player.invulnerable || self.player.spectator { return Ok(()); } + // Frost walker's `damage_immunity`: #burn_from_stepping (magma, campfire). + if self.player.burn_from_stepping_immune + && matches!(source, "minecraft:hot_floor" | "minecraft:campfire") + { + return Ok(()); + } let id = self .resources .health diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 2b852a4af..fbcf8ba98 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -81,6 +81,11 @@ impl Opt { Opt::Narrator | Opt::NarratorHotkey | Opt::ChatDelay + // Stored, but there are no blocked players, signed chat or + // chat drafts yet. + | Opt::HideMatchedNames + | Opt::OnlySecureChat + | Opt::SaveChatDrafts | Opt::DistortionEffects | Opt::MonochromeLogo | Opt::RotateWithMinecarts @@ -96,6 +101,9 @@ impl Opt { Opt::Narrator => "narrator", Opt::TextBackground => "backgroundForChatOnly", Opt::ChatDelay => "chatDelay", + Opt::HideMatchedNames => "hideMatchedNames", + Opt::OnlySecureChat => "onlyShowSecureChat", + Opt::SaveChatDrafts => "saveChatDrafts", Opt::DistortionEffects => "screenEffectScale", Opt::FovEffects => "fovEffectScale", Opt::DarknessPulsing => "darknessEffectScale", @@ -164,6 +172,9 @@ impl Opt { Opt::ChatHeightUnfocused => "options.chat.height.unfocused", Opt::ChatLineSpacing => "options.chat.line_spacing", Opt::AutoSuggestions => "options.autoSuggestCommands", + Opt::HideMatchedNames => "options.hideMatchedNames", + Opt::OnlySecureChat => "options.onlyShowSecureChat", + Opt::SaveChatDrafts => "options.chat.drafts", Opt::ReducedDebugInfo => "options.reducedDebugInfo", Opt::HighContrast => "options.accessibility.high_contrast", Opt::ShowSubtitles => "options.showSubtitles", @@ -437,6 +448,9 @@ impl Opt { Opt::HideLightningFlashes => on_off(s.file.bool("hideLightningFlashes")), Opt::MonochromeLogo => on_off(s.file.bool("darkMojangStudiosBackground")), Opt::HideSplashTexts => on_off(s.file.bool("hideSplashTexts")), + Opt::HideMatchedNames | Opt::OnlySecureChat | Opt::SaveChatDrafts => { + on_off(s.file.bool(self.file_key().unwrap())) + } Opt::NarratorHotkey => on_off(s.file.bool("narratorHotkey")), Opt::RotateWithMinecarts => on_off(s.file.bool("rotateWithMinecart")), Opt::HighContrastBlockOutlines => on_off(s.file.bool("highContrastBlockOutline")), @@ -635,7 +649,12 @@ impl Opt { value + 1 }; } - Opt::TextBackground | Opt::HideLightningFlashes | Opt::HideSplashTexts => { + Opt::TextBackground + | Opt::HideLightningFlashes + | Opt::HideSplashTexts + | Opt::HideMatchedNames + | Opt::OnlySecureChat + | Opt::SaveChatDrafts => { let key = self.file_key().unwrap(); s.file .set(key, crate::options_file::V::Bool(!s.file.bool(key))); @@ -1434,7 +1453,10 @@ impl OptionsUi { Opt::ChatHeightFocused, Opt::ChatHeightUnfocused, Opt::AutoSuggestions, + Opt::HideMatchedNames, Opt::ReducedDebugInfo, + Opt::OnlySecureChat, + Opt::SaveChatDrafts, ]), Page::Accessibility => { let mut rows = vec![Row::Buttons( diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs index 9d1c572a2..a9bed143a 100644 --- a/crates/horizon-client/src/particles.rs +++ b/crates/horizon-client/src/particles.rs @@ -588,15 +588,17 @@ pub fn on_block_faces_between( } } /// `ParticleUtils.spawnParticlesAlongAxis(axis, level, pos, 0.125, particle, -/// UniformInt.of(10, 19))` (level event 3002 on a lightning rod): sparks along -/// the rod, moving along it. `axis` is 0, 1, 2 for X, Y, Z. +/// UniformInt.of(min, max))` (`count` is the range; level event 3002 on a +/// lightning rod uses 10 to 19): sparks along the rod, moving along it. +/// `axis` is 0, 1, 2 for X, Y, Z. pub fn along_axis( random: &mut impl RandomSource, axis: usize, pos: [i32; 3], + (min, max): (i32, i32), mut emit: impl FnMut([f64; 3], [f64; 3]), ) { - let count = random.next_int_bound(19 - 10 + 1).unwrap_or(0) + 10; + let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min; for _ in 0..count { let p: [f64; 3] = std::array::from_fn(|i| { f64::from(pos[i]) @@ -1199,6 +1201,43 @@ impl ParticleEngine { self.add(&options, position, velocity); } } + /// `LevelEventHandler.levelEvent` 2018: an enderman's portal trail from + /// where it was (`from`) to where it went, which `data` packs within + /// (127, 127, 127). 128 portal particles along the way, spread about the + /// width and height of an enderman. + pub fn enderman_teleportation(&mut self, from: [i32; 3], data: i32, particle_level: u8) { + // EntityTypes.ENDERMAN's dimensions. + const WIDTH: f64 = 0.6_f32 as f64; + const HEIGHT: f64 = 2.9_f32 as f64; + let to = [ + from[0].wrapping_add(((data >> 16) & 255) - 127), + from[1].wrapping_add(((data >> 8) & 255) - 127), + from[2].wrapping_add((data & 255) - 127), + ] + .map(f64::from); + let from = from.map(f64::from); + let options = ParticleOptions::simple(ParticleType::Portal); + for _ in 0..128 { + let r = &mut self.level_random; + let t = r.next_double(); + let velocity = std::array::from_fn(|_| f64::from((r.next_float() - 0.5) * 0.2)); + // Mth.lerp(t, to, from). + let position = [ + to[0] + t * (from[0] - to[0]) + (r.next_double() - 0.5) * WIDTH * 2.0, + to[1] + t * (from[1] - to[1]) + r.next_double() * HEIGHT, + to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) * WIDTH * 2.0, + ]; + // The option roll shares the level random and precedes the distance check. + let limited = match particle_level { + 1 => r.next_int_bound(3).unwrap_or(0) == 0, + 2 => true, + _ => false, + }; + if !limited { + self.add(&options, position, velocity); + } + } + } /// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the /// explosion particle (the emitter unless `ServerExplosion.isSmall`) and up /// to 512 poof/smoke particles thrown from air inside the radius. diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs index b3e9938c9..43606839e 100644 --- a/crates/horizon-client/src/projectiles.rs +++ b/crates/horizon-client/src/projectiles.rs @@ -66,6 +66,23 @@ pub enum ProjectileKind { }, } impl ProjectileKind { + /// The width and height of its entity type's `sized(...)`. + pub fn size(&self) -> f64 { + match self { + Self::Arrow { .. } | Self::Trident => 0.5, + Self::Snowball + | Self::Egg + | Self::EnderPearl + | Self::LlamaSpit + | Self::Potion { .. } => 0.25, + Self::SmallFireball + | Self::WindCharge + | Self::BreezeWindCharge + | Self::ShulkerBullet { .. } + | Self::WitherSkull { .. } => 0.3125, + Self::LargeFireball { .. } => 1.0, + } + } /// Its entity type. pub fn id(&self) -> &'static str { match self { diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index e746bf946..d304da145 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -547,6 +547,11 @@ pub fn encode_block_entity( } } BlockEntity::Sculk(s) => entries.extend(s.to_nbt()), + // ChiseledBookShelfBlockEntity.saveAdditional. + BlockEntity::ChiseledBookshelf(b) => { + entries.push(("Items", encode_items(&b.items))); + entries.push(("last_interacted_slot", Tag::Int(b.last_slot))); + } // CampfireBlockEntity.saveAdditional. BlockEntity::Campfire(c) => { entries.push(("Items", encode_items(&c.items))); @@ -785,6 +790,13 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain } BlockEntity::Sign(sign) => sign.decode(tag), BlockEntity::Sculk(s) => s.load(tag), + // ChiseledBookShelfBlockEntity.loadAdditional. + BlockEntity::ChiseledBookshelf(b) => { + for (slot, item) in decode_items(tag.get("Items"), 6).into_iter().enumerate() { + b.items[slot] = item; + } + b.last_slot = int("last_interacted_slot").unwrap_or(-1); + } // CampfireBlockEntity.loadAdditional: missing time arrays stay zeros. BlockEntity::Campfire(c) => { for (slot, item) in decode_items(tag.get("Items"), 4).into_iter().enumerate() { @@ -2699,6 +2711,8 @@ pub struct Level { pub xp_seed: i32, /// ServerPlayer.seenCredits: the end poem has been shown. pub seen_credits: bool, + /// Player.lastDeathLocation: the dimension and block of the last death. + pub last_death: Option<(String, [i32; 3])>, /// Player.active_effects: (id, duration, amplifier, ambient, show_particles). pub active_effects: Vec<(String, i32, i32, bool, bool)>, /// Player.EnderItems: the ender chest inventory (27 slots). @@ -2899,6 +2913,15 @@ impl Level { self.fall_distance = f("fall_distance").unwrap_or(0.0); self.on_ground = n("OnGround").unwrap_or(0) != 0; self.seen_credits = n("seenCredits").unwrap_or(0) != 0; + self.last_death = p.get("LastDeathLocation").and_then(|d| { + let Some(Tag::IntArray(pos)) = d.get("pos") else { + return None; + }; + Some(( + text(d.get("dimension"))?, + [*pos.first()?, *pos.get(1)?, *pos.get(2)?], + )) + }); if let Some(mode) = n("playerGameType") { self.creative = mode == 1; self.game_mode = mode as i32; @@ -2999,6 +3022,7 @@ impl Level { "Pos", "respawn", "recipeBook", + "LastDeathLocation", ] { map.remove(&JavaString::from(key)); } @@ -3125,6 +3149,15 @@ impl Level { entries.push(("Pos", doubles(&pos))); } entries.push(("seenCredits", Tag::Byte(i8::from(self.seen_credits)))); + if let Some((dimension, pos)) = &self.last_death { + entries.push(( + "LastDeathLocation", + Tag::compound([ + ("dimension", string(dimension)), + ("pos", Tag::IntArray(pos.to_vec())), + ]), + )); + } // A respawn point other than the world spawn: an anchor elsewhere, or a bed. if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere { let mut respawn = vec![ diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 0c59c18f9..aeb366947 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -659,7 +659,10 @@ pub enum Opt { ChatHeightUnfocused, ChatLineSpacing, AutoSuggestions, + HideMatchedNames, ReducedDebugInfo, + OnlySecureChat, + SaveChatDrafts, HighContrast, ShowSubtitles, MusicFrequency, diff --git a/crates/horizon-client/src/spear.rs b/crates/horizon-client/src/spear.rs new file mode 100644 index 000000000..ae6d8f80d --- /dev/null +++ b/crates/horizon-client/src/spear.rs @@ -0,0 +1,351 @@ +//! Spears: `KineticWeapon` (what holding the use button does: the speed +//! conditions of a stab, `Item.Properties.spear`'s numbers) and +//! `SpearAnimations` (how the spear is held in first and third person while +//! it charges). +use glam::{Mat4, Vec3}; +use horizon_core::{geometry::trig::Mth, jmath::pow}; +use std::f32::consts::PI; + +/// `KineticWeapon.Condition`. +#[derive(Clone, Copy, Debug)] +pub struct Condition { + pub max_duration_ticks: i32, + pub min_speed: f32, + pub min_relative_speed: f32, +} +impl Condition { + pub fn test( + self, + ticks_used: i32, + attacker_speed: f64, + relative_speed: f64, + entity_factor: f64, + ) -> bool { + ticks_used <= self.max_duration_ticks + && attacker_speed >= f64::from(self.min_speed) * entity_factor + && relative_speed >= f64::from(self.min_relative_speed) * entity_factor + } +} + +/// `KineticWeapon`: a spear's charge. +#[derive(Clone, Copy, Debug)] +pub struct Kinetic { + pub contact_cooldown_ticks: i32, + pub delay_ticks: i32, + pub dismount: Condition, + pub knockback: Condition, + pub damage: Condition, + pub forward_movement: f32, + pub damage_multiplier: f32, + pub sound: &'static str, + pub hit_sound: &'static str, +} + +/// `AttackRange` of a spear: the reach of its stabs. +pub struct Reach { + pub min: f32, + pub max: f32, + pub min_creative: f32, + pub max_creative: f32, + pub hitbox_margin: f32, + pub mob_factor: f32, +} +pub const REACH: Reach = Reach { + min: 2.0, + max: 4.5, + min_creative: 2.0, + max_creative: 6.5, + hitbox_margin: 0.125, + mob_factor: 0.5, +}; + +impl Kinetic { + /// The `kinetic_weapon` of a spear item (`Item.Properties.spear`). + pub fn of(item: &str) -> Option { + // (damage multiplier, delay, dismount time and speed, knockback time + // and speed, damage time and speed): seconds and blocks per second. + let (multiplier, delay, dismount, knockback, damage) = match item { + "minecraft:wooden_spear" => (0.7, 0.75, (5.0, 14.0), (10.0, 5.1), (15.0, 4.6)), + "minecraft:stone_spear" => (0.82, 0.7, (4.5, 13.0), (9.0, 5.1), (13.75, 4.6)), + "minecraft:copper_spear" => (0.82, 0.65, (4.0, 12.0), (8.25, 5.1), (12.5, 4.6)), + "minecraft:iron_spear" => (0.95, 0.6, (2.5, 11.0), (6.75, 5.1), (11.25, 4.6)), + "minecraft:golden_spear" => (0.7, 0.7, (3.5, 13.0), (8.5, 5.1), (13.75, 4.6)), + "minecraft:diamond_spear" => (1.075, 0.5, (3.0, 10.0), (6.5, 5.1), (10.0, 4.6)), + "minecraft:netherite_spear" => (1.2, 0.4, (2.5, 9.0), (5.5, 5.1), (8.75, 4.6)), + _ => return None, + }; + let wood = item == "minecraft:wooden_spear"; + let ticks = |seconds: f32| (seconds * 20.0) as i32; + Some(Self { + contact_cooldown_ticks: 10, + delay_ticks: ticks(delay), + // `Condition.ofAttackerSpeed`, and `ofRelativeSpeed` for the damage. + dismount: Condition { + max_duration_ticks: ticks(dismount.0), + min_speed: dismount.1, + min_relative_speed: 0.0, + }, + knockback: Condition { + max_duration_ticks: ticks(knockback.0), + min_speed: knockback.1, + min_relative_speed: 0.0, + }, + damage: Condition { + max_duration_ticks: ticks(damage.0), + min_speed: 0.0, + min_relative_speed: damage.1, + }, + forward_movement: 0.38, + damage_multiplier: multiplier, + sound: if wood { + "minecraft:item.spear_wood.use" + } else { + "minecraft:item.spear.use" + }, + hit_sound: if wood { + "minecraft:item.spear_wood.hit" + } else { + "minecraft:item.spear.hit" + }, + }) + } +} + +/// `KineticWeapon.HIT_FEEDBACK_TICKS`. +pub const HIT_FEEDBACK_TICKS: i64 = 10; + +/// `Mth.clamp` on floats (a NaN stays one). +fn clamp(v: f32, lo: f32, hi: f32) -> f32 { + if v < lo { lo } else { v.min(hi) } +} +/// `SpearAnimations.progress`. +fn progress(time: f32, start: f32, end: f32) -> f32 { + clamp((time - start) / (end - start), 0.0, 1.0) +} +fn square(x: f32) -> f32 { + x * x +} +fn cube(x: f32) -> f32 { + x * x * x +} +fn p(x: f32, y: f64) -> f64 { + pow(f64::from(x), y) +} + +// `net.minecraft.util.Ease`. +fn in_quad(x: f32) -> f32 { + x * x +} +fn out_quart(x: f32) -> f32 { + 1.0 - square(square(1.0 - x)) +} +fn out_cubic(x: f32) -> f32 { + 1.0 - cube(1.0 - x) +} +fn out_back(x: f32) -> f32 { + 1.0 + 2.70158 * cube(x - 1.0) + 1.70158 * square(x - 1.0) +} +fn in_out_sine(x: f32) -> f32 { + -((PI * x).mcos() - 1.0) / 2.0 +} +fn in_out_expo(x: f32) -> f32 { + if x < 0.5 { + if x == 0.0 { + 0.0 + } else { + (p(2.0, f64::from(20.0 * x - 10.0)) / 2.0) as f32 + } + } else if x == 1.0 { + 1.0 + } else { + ((2.0 - p(2.0, f64::from(-20.0 * x + 10.0))) / 2.0) as f32 + } +} +fn in_out_back(x: f32) -> f32 { + if x < 0.5 { + return 4.0 * x * x * (7.189_819 * x - 2.594_909_4) / 2.0; + } + let dt = 2.0 * x - 2.0; + (dt * dt * (3.594_909_4 * dt + 2.594_909_4) + 2.0) / 2.0 +} +fn in_out_elastic(x: f32) -> f32 { + if x == 0.0 { + return 0.0; + } + if x == 1.0 { + return 1.0; + } + let sin = (f64::from(20.0 * x - 11.125) * f64::from(PI * 4.0 / 9.0)).sin(); + if x < 0.5 { + (-(p(2.0, f64::from(20.0 * x - 10.0)) * sin) / 2.0) as f32 + } else { + (p(2.0, f64::from(-20.0 * x + 10.0)) * sin / 2.0 + 1.0) as f32 + } +} +fn out_circ(x: f32) -> f32 { + f64::from(1.0 - square(x - 1.0)).sqrt() as f32 +} +fn in_circ(x: f32) -> f32 { + (-f64::from(1.0 - x * x).sqrt()) as f32 + 1.0 +} + +/// `SpearAnimations.UseParams`. +struct UseParams { + raise: f32, + raise_start: f32, + raise_middle: f32, + raise_end: f32, + sway: f32, + lower: f32, + raise_back: f32, + sway_intensity: f32, + sway_slow: f32, + sway_fast: f32, +} +impl UseParams { + fn of(k: &Kinetic, time: f32) -> Self { + let finish_raising = k.delay_ticks; + let finish_swaying = k.dismount.max_duration_ticks + finish_raising; + let start_swaying = finish_swaying - 20; + let finish_lowering = k.knockback.max_duration_ticks + finish_raising; + let start_lowering = finish_lowering - 40; + let finish_raising_back = k.damage.max_duration_ticks + finish_raising; + let raise = progress(time, 0.0, finish_raising as f32); + let sway = progress(time, start_swaying as f32, finish_swaying as f32); + let lower = out_cubic(in_out_elastic(progress( + time - 20.0, + start_lowering as f32, + finish_lowering as f32, + ))); + let raise_back = progress( + time, + (finish_raising_back - 5) as f32, + finish_raising_back as f32, + ); + let sway_intensity = 2.0 * out_circ(sway) - 2.0 * in_circ(raise_back); + let degrees = PI / 180.0; + Self { + raise, + raise_start: progress(raise, 0.0, 0.5), + raise_middle: progress(raise, 0.5, 0.8), + raise_end: progress(raise, 0.8, 1.0), + sway, + lower, + raise_back, + sway_intensity, + sway_slow: (time * 19.0 * degrees).msin() * sway_intensity, + sway_fast: (time * 30.0 * degrees).msin() * sway_intensity, + } + } +} + +/// `SpearAnimations.hitFeedbackAmount`. +fn hit_feedback(ticks_since: f32) -> f32 { + 0.4 * (out_quart(progress(ticks_since, 1.0, 3.0)) + - in_out_sine(progress(ticks_since, 3.0, 10.0))) +} + +/// `PoseStack.rotateAround`. +fn rotate_around(rotation: Mat4, about: Vec3) -> Mat4 { + Mat4::from_translation(about) * rotation * Mat4::from_translation(-about) +} + +/// `SpearAnimations.firstPersonUse`, after the hand's own +/// `translate(invert * 0.56, -0.52, -0.72)`. +pub fn first_person_use(k: &Kinetic, ticks_since_hit: f32, time_held: f32, right: bool) -> Mat4 { + let u = UseParams::of(k, time_held); + let invert = if right { 1.0 } else { -1.0 }; + let degrees = |d: f32| d.to_radians(); + let mut m = Mat4::from_translation(Vec3::new( + invert * (u.raise * 0.15 + u.raise_end * -0.05 + u.sway * -0.1 + u.sway_slow * 0.005), + u.raise * -0.075 + u.raise_middle * 0.075 + u.sway_fast * 0.01, + u.raise_start * 0.05 + u.raise_end * -0.05 + u.sway_slow * 0.005, + )); + m *= rotate_around( + Mat4::from_rotation_x(degrees( + -65.0 * in_out_back(u.raise) - 35.0 * u.lower + + 100.0 * u.raise_back + + -0.5 * u.sway_fast, + )), + Vec3::new(0.0, 0.1, 0.0), + ); + // Axis.YN: a turn the other way round. + m *= rotate_around( + Mat4::from_rotation_y(-degrees( + invert * (-90.0 * progress(u.raise, 0.5, 0.55) + 90.0 * u.sway + 2.0 * u.sway_slow), + )), + Vec3::new(invert * 0.15, 0.0, 0.0), + ); + m * Mat4::from_translation(Vec3::new(0.0, -hit_feedback(ticks_since_hit), 0.0)) +} + +/// `SpearAnimations.thirdPersonHandUse`: the angles (x, y and the z added to +/// the arm's own) of the arm holding a spear. `ticks_using` is the time the +/// item has been in use by this arm (0 when it is not). +pub fn third_person_arm( + k: &Kinetic, + ticks_using: f32, + right: bool, + head: (f32, f32), + gliding_or_swimming: bool, +) -> (f32, f32, f32) { + let invert = if right { 1.0 } else { -1.0 }; + let degrees = PI / 180.0; + let mut y = -0.1 * invert + head.1; + let mut x = -PI / 2.0 + head.0 + 0.8; + if gliding_or_swimming { + x -= 0.959_931_1; + } + y = degrees * clamp(180.0 / PI * y, -60.0, 60.0); + x = degrees * clamp(180.0 / PI * x, -120.0, 30.0); + let mut z = 0.0; + if ticks_using > 0.0 { + let u = UseParams::of(k, ticks_using); + y += -invert * u.sway_fast * degrees * u.sway_intensity; + z = -invert * u.sway_slow * degrees * u.sway_intensity * 0.5; + x += degrees + * (-40.0 * u.raise_start + + 30.0 * u.raise_middle + + -20.0 * u.raise_end + + 20.0 * u.lower + + 10.0 * u.raise_back + + 0.6 * u.sway_slow * u.sway_intensity); + } + (x, y, z) +} + +/// `SpearAnimations.thirdPersonUseItem`: the spear's own pose in the hand +/// held for `time_held` ticks, `swing` into the current swing. +pub fn third_person_use_item( + k: &Kinetic, + time_held: f32, + swing: f32, + ticks_since_hit: f32, + right: bool, +) -> Mat4 { + if time_held == 0.0 { + return Mat4::IDENTITY; + } + let attack = in_quad(progress(swing, 0.05, 0.2)); + let retract = in_out_expo(progress(swing, 0.4, 1.0)); + let u = UseParams::of(k, time_held); + let invert = if right { 1.0 } else { -1.0 }; + let raise_modified = 1.0 - out_back(1.0 - u.raise); + let hit = hit_feedback(ticks_since_hit); + let degrees = |d: f32| d.to_radians(); + Mat4::from_translation(Vec3::new( + 0.0, + -hit * 0.4, + -k.forward_movement * (raise_modified - u.raise_back) + hit, + )) * rotate_around( + Mat4::from_rotation_x(-degrees( + 70.0 * (u.raise - u.raise_back) - 40.0 * (attack - retract), + )), + Vec3::new(0.0, -0.031_25, 0.125), + ) * rotate_around( + Mat4::from_rotation_y(degrees( + invert * 90.0 * (u.raise - u.sway + 3.0 * retract + attack), + )), + Vec3::new(0.0, 0.0, 0.125), + ) +} diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs index b720c5bfd..0d5871915 100644 --- a/crates/horizon-client/src/sprites.rs +++ b/crates/horizon-client/src/sprites.rs @@ -115,6 +115,29 @@ impl Sprites { pub fn count(&self) -> usize { self.native.len() } + /// `SpriteContents.computeTransparency(u0, v0, u1, v1)` is NONE: every texel under + /// the quad's UV box is fully opaque in every frame, so the quad needs no alpha test. + pub fn region_opaque(&self, layer: u32, uv: &[[f32; 2]; 4]) -> bool { + if self.opaque[layer as usize] { + return true; + } + let (side, frames, _) = &self.native[layer as usize]; + let side = *side as usize; + let range = |axis: usize| { + let lo = uv.iter().map(|p| p[axis]).fold(f32::INFINITY, f32::min); + let hi = uv.iter().map(|p| p[axis]).fold(f32::NEG_INFINITY, f32::max); + let clamp = |v: f32| (v.max(0.0) as usize).min(side); + clamp((lo * side as f32).floor())..clamp((hi * side as f32).ceil()) + }; + let (columns, rows) = (range(0), range(1)); + frames.iter().all(|frame| { + rows.clone().all(|y| { + columns + .clone() + .all(|x| frame[(y * side + x) * 4 + 3] == 255) + }) + }) + } /// Lay every layer out at one size: the largest texture's (resource packs /// may ship 32x, 64x... textures, like vanilla's stitched atlas), rounded /// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs index 8183b415a..d05649f3a 100644 --- a/crates/horizon-client/src/structure_blocks.rs +++ b/crates/horizon-client/src/structure_blocks.rs @@ -69,6 +69,9 @@ pub fn loot_item_with_components(s: &horizon_world::loot::LootStack) -> ItemStac .stew_effects .push((Arc::from(effect.as_str()), *duration)); } + for (id, text) in &s.names { + item.data_mut().set_loot_name(id, text); + } item } @@ -287,6 +290,7 @@ mod tests { exploration: None, ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), }; // An End city chest's enchant_with_levels roll. let boots = loot_item_with_components(&stack( @@ -349,6 +353,7 @@ mod tests { })))), ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), }; let mut item = loot_item(&stack); assert!(has_pending_map(&item)); diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index b2fcfe8f4..d08917303 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -966,6 +966,11 @@ impl Title { } let version = format!("Horizon {} (Rust)", horizon_core::VANILLA_VERSION); batch.text(atlas, &version, 2.0, h - 10.0, u32::MAX, true); + // A nightly names its build in the top-left corner, the one spot no button reaches at any GUI + // scale, so screenshots and reports say which build they come from. + if let Some(nightly) = horizon_core::release::nightly_label() { + batch.text(atlas, &nightly, 2.0, 2.0, u32::MAX, true); + } let notice = "Not affiliated with Mojang or Microsoft"; let tw = HudBatch::text_width(atlas, notice); batch.text(atlas, notice, w - tw - 2.0, h - 10.0, u32::MAX, true); diff --git a/crates/horizon-client/src/toasts.rs b/crates/horizon-client/src/toasts.rs index b70a37036..3b6a467ea 100644 --- a/crates/horizon-client/src/toasts.rs +++ b/crates/horizon-client/src/toasts.rs @@ -63,6 +63,8 @@ impl Slide { /// has passed since its last change, or until it is hidden. pub struct SystemToast { pub slide: Slide, + /// `ToastInstance.firstSlotIndex`: its 32-pixel slot once shown. + pub slot: Option, title: String, message: Option, /// `changed`: the next update takes its time as `lastChanged`. @@ -76,6 +78,7 @@ impl SystemToast { pub fn new(title: String, message: Option) -> Self { Self { slide: Slide::default(), + slot: None, title, message, changed: false, diff --git a/crates/horizon-client/src/win_screen.rs b/crates/horizon-client/src/win_screen.rs index 8d2a1c145..9d100c744 100644 --- a/crates/horizon-client/src/win_screen.rs +++ b/crates/horizon-client/src/win_screen.rs @@ -309,11 +309,12 @@ mod tests { /// A resource root with only the credits texts: every glyph is the /// missing one, 6 pixels wide. fn screen(poem: bool, end: &str, credits: &str, post: &str) -> WinScreen { - let root = std::env::temp_dir().join(format!( - "horizon-win-screen-{}-{poem}-{}", - std::process::id(), - end.len() - )); + // One directory per call: tests run in parallel, and two of them with + // the same arguments used to remove each other's files. + static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); + let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let root = + std::env::temp_dir().join(format!("horizon-win-screen-{}-{n}", std::process::id())); let texts = root.join("assets/minecraft/texts"); std::fs::create_dir_all(&texts).unwrap(); std::fs::write(texts.join("end.txt"), end).unwrap(); diff --git a/crates/horizon-core/src/release.rs b/crates/horizon-core/src/release.rs index 54a3cb94e..4e7378601 100644 --- a/crates/horizon-core/src/release.rs +++ b/crates/horizon-core/src/release.rs @@ -15,8 +15,43 @@ pub const VERSION: &str = match RELEASE { None => env!("CARGO_PKG_VERSION"), }; +/// A nightly's date and commit (`2026-10-28 0c02067`): nightly-build.yml builds the opt-in Nightly +/// channel with `HORIZON_NIGHTLY` set (docs/release-flow.md). None for a release or a build from source. +pub const NIGHTLY: Option<&str> = match option_env!("HORIZON_NIGHTLY") { + Some(nightly) if !nightly.is_empty() => Some(nightly), + _ => None, +}; + +/// How a nightly names itself where players read it, so their reports say which build they come +/// from: `Nightly 2026-10-28 · 0c02067`. None for any other build. +pub fn nightly_label() -> Option { + NIGHTLY.map(label) +} + +/// A nightly's version as the launcher installs it (`nightly-2026-10-28-0c02067`). +pub fn nightly_version() -> Option { + NIGHTLY.map(|n| format!("nightly-{}", n.replace(' ', "-"))) +} + +fn label(nightly: &str) -> String { + match nightly.split_once(' ') { + Some((date, commit)) => format!("Nightly {date} · {commit}"), + None => format!("Nightly {nightly}"), + } +} + #[cfg(test)] mod tests { + #[test] + fn a_nightly_names_its_date_and_commit() { + assert_eq!( + super::label("2026-10-28 0c02067"), + "Nightly 2026-10-28 · 0c02067" + ); + assert_eq!(super::label("2026-10-28"), "Nightly 2026-10-28"); + assert_eq!(super::nightly_label().is_some(), super::NIGHTLY.is_some()); + } + #[test] fn the_version_is_the_release_or_the_crate() { assert_eq!( diff --git a/crates/horizon-protocol/src/item.rs b/crates/horizon-protocol/src/item.rs index 3d5bacfe9..07523b8f1 100644 --- a/crates/horizon-protocol/src/item.rs +++ b/crates/horizon-protocol/src/item.rs @@ -3,7 +3,7 @@ //! client sends back in container clicks (HashedStack). use crate::{ Result, - buf::{Codec, Reader, Writer}, + buf::{Codec, Reader, Writer, pack_block_pos, unpack_block_pos}, }; use horizon_world::nbt::Tag; @@ -40,6 +40,7 @@ pub mod component { pub const WRITABLE_BOOK_CONTENT: i32 = 56; pub const WRITTEN_BOOK_CONTENT: i32 = 57; pub const TRIM: i32 = 58; + pub const LODESTONE_TRACKER: i32 = 69; pub const FIREWORK_EXPLOSION: i32 = 70; pub const FIREWORKS: i32 = 71; } @@ -99,6 +100,12 @@ pub enum Component { }, /// `FireworkExplosion` (a firework star). FireworkExplosion(FireworkExplosion), + /// `LodestoneTracker`: the target's dimension and block, and whether it + /// follows the lodestone. + LodestoneTracker { + target: Option<(String, [i32; 3])>, + tracked: bool, + }, /// `ArmorTrim` naming its material and pattern by registry id (`trim_material`, /// `trim_pattern`); a trim with a direct holder stays [`Component::Raw`]. Trim { @@ -316,6 +323,17 @@ impl Component { } } FIREWORK_EXPLOSION => Self::FireworkExplosion(FireworkExplosion::read(r)?), + LODESTONE_TRACKER => { + let target = if r.bool()? { + Some((r.string(32767)?, unpack_block_pos(r.i64()?))) + } else { + None + }; + Self::LodestoneTracker { + target, + tracked: r.bool()?, + } + } // ArmorTrim.STREAM_CODEC: two holders, each a reference's id plus // one. A direct material or pattern has no registry name: read past. TRIM => { @@ -437,6 +455,14 @@ impl Component { explosions.iter().for_each(|e| e.write(w)); } Self::FireworkExplosion(e) => e.write(w), + Self::LodestoneTracker { target, tracked } => { + w.bool(target.is_some()); + if let Some((dimension, pos)) = target { + w.string(dimension); + w.i64(pack_block_pos(*pos)); + } + w.bool(*tracked); + } Self::WritableBook(pages) => { w.varint(pages.len() as i32); for page in pages { diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 0229706ce..2c3aa5d18 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -2243,6 +2243,7 @@ packet!( PaddleBoat { left: bool => Bool, right: bool => Bool } ); packet!(PickItemFromBlock { pos: [i32; 3] => Pos, include_data: bool => Bool }); +packet!(PickItemFromEntity { id: i32 => VarInt, include_data: bool => Bool }); packet!( /// ServerboundPlayerActionPacket.Action: 0 start destroy, 1 change destroy /// direction, 2 abort, 3 stop destroy, 4 drop all, 5 drop item, 6 release @@ -2321,6 +2322,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound { MoveVehicle(MoveVehicleRequest) = MOVE_VEHICLE, PaddleBoat(PaddleBoat) = PADDLE_BOAT, PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK, + PickItemFromEntity(PickItemFromEntity) = PICK_ITEM_FROM_ENTITY, PingRequest(crate::packets::status::Ping) = PING_REQUEST, PlayerAbilities(PlayerAbilitiesRequest) = PLAYER_ABILITIES, PlayerAction(PlayerAction) = PLAYER_ACTION, diff --git a/crates/horizon-release-sign/src/lib.rs b/crates/horizon-release-sign/src/lib.rs index ac527f15e..940d9259e 100644 --- a/crates/horizon-release-sign/src/lib.rs +++ b/crates/horizon-release-sign/src/lib.rs @@ -114,26 +114,67 @@ pub fn verify( parse_sums(text) } +/// The channel nightly builds are signed for (nightly-build.yml): their message is +/// `horizon release nightly`, which no release's tag is, so a nightly's signature never passes for a +/// release's, nor a release's for a nightly's. +pub const NIGHTLY: &str = "nightly"; + +/// Whether `tag` is a nightly's: `nightly`, or a past one kept as `nightly-`. +pub fn is_nightly(tag: &str) -> bool { + tag == NIGHTLY || tag.starts_with("nightly-") +} + /// The signed SHA-256 of `asset` in release `tag`, or why the download must be refused. /// `sums` and `signature` are the release's SHA256SUMS and SHA256SUMS.sig, None when it has none. +/// A nightly is never a release: its tags are refused here, whatever their signature +/// ([`nightly_digest`] checks those). pub fn signed_digest( tag: &str, asset: &str, sums: Option<&[u8]>, signature: Option<&str>, keys: &[PublicKey], +) -> Result { + if is_nightly(tag) { + return Err(format!( + "{tag} is a Nightly build: only a launcher with Nightly turned on installs it." + )); + } + digest_in(tag, tag, asset, sums, signature, keys) +} + +/// The signed SHA-256 of `asset` in the nightly build: its checksums must be signed for the +/// [`NIGHTLY`] channel, so a release's signed list (or one replayed from a release) is refused. +pub fn nightly_digest( + asset: &str, + sums: Option<&[u8]>, + signature: Option<&str>, + keys: &[PublicKey], +) -> Result { + digest_in(NIGHTLY, "The Nightly build", asset, sums, signature, keys) +} + +/// `asset`'s SHA-256 in `sums`, once one of `keys` is found to have signed them for `signed_for`; +/// `name` says which build in messages. +fn digest_in( + signed_for: &str, + name: &str, + asset: &str, + sums: Option<&[u8]>, + signature: Option<&str>, + keys: &[PublicKey], ) -> Result { let (Some(sums), Some(signature)) = (sums, signature) else { return Err(format!( - "{tag} is not signed, and Horizon installs only signed releases: pick a newer version." + "{name} is not signed, and Horizon installs only signed releases: pick a newer version." )); }; - verify(tag, sums, signature, keys)? + verify(signed_for, sums, signature, keys)? .into_iter() - .find(|(name, _)| name == asset) + .find(|(n, _)| n == asset) .map(|(_, hex)| hex) .ok_or_else(|| { - format!("{asset} is not in {tag}'s signed checksums, so it was not installed.") + format!("{asset} is not in {name}'s signed checksums, so it was not installed.") }) } @@ -320,6 +361,34 @@ mod tests { assert!(check("x", &sha256_hex(b"windows"), &sha256_hex(b"linux")).is_err()); } + /// The release channel refuses everything signed for the nightly channel, and the other way + /// round: one key signs both, and only the message's channel keeps them apart. + #[test] + fn nightly_and_release_signatures_never_pass_for_each_other() { + let (nightly, sums, signature) = signed(NIGHTLY); + let keys = [nightly.public()]; + let asset = "horizon-windows-x64.zip"; + let digest = nightly_digest(asset, Some(sums.as_bytes()), Some(&signature), &keys); + assert_eq!(digest, Ok(sha256_hex(b"windows"))); + // Served under a release's tag: the message names the nightly channel, not v0.2.81. + for tag in ["v0.2.81", "v2026.10.28", "0.2.81"] { + let as_release = + signed_digest(tag, asset, Some(sums.as_bytes()), Some(&signature), &keys); + assert!(as_release.is_err(), "{tag} took a nightly's signature"); + } + // Asked for by a nightly tag on the release channel: refused before any signature is read. + for tag in [NIGHTLY, "nightly-2026-10-27"] { + let err = signed_digest(tag, asset, Some(sums.as_bytes()), Some(&signature), &keys); + assert!(err.unwrap_err().contains("Nightly build"), "{tag}"); + } + // A release's signed list replayed as tonight's nightly. + let (release, sums, signature) = signed("v0.2.81"); + let keys = [release.public()]; + assert!(nightly_digest(asset, Some(sums.as_bytes()), Some(&signature), &keys).is_err()); + assert!(nightly_digest(asset, Some(sums.as_bytes()), None, &keys).is_err()); + assert!(is_nightly("nightly-2026-10-27") && !is_nightly("v0.2.81")); + } + #[test] fn tampering_is_refused() { let (key, sums, signature) = signed("v2026.10.19"); diff --git a/crates/horizon-server/src/engine.rs b/crates/horizon-server/src/engine.rs index fd7c86321..ce288fdff 100644 --- a/crates/horizon-server/src/engine.rs +++ b/crates/horizon-server/src/engine.rs @@ -315,18 +315,42 @@ mod tests { .unwrap(); std::fs::set_permissions(&game, std::fs::Permissions::from_mode(0o755)).unwrap(); std::fs::write(server.join("server.toml"), "").unwrap(); - let status = spawn( - &std::path::absolute(&game).unwrap(), - &root.join("res"), - &server, - ) - .unwrap() - .wait(); + // ETXTBSY: see `check_written`. + let mut tries = 0; + let status = loop { + match spawn( + &std::path::absolute(&game).unwrap(), + &root.join("res"), + &server, + ) { + Err(e) if e.raw_os_error() == Some(26) && tries < 50 => { + tries += 1; + std::thread::sleep(std::time::Duration::from_millis(20)); + } + child => break child.unwrap().wait(), + } + }; std::fs::remove_dir_all(&root).unwrap(); let status = status.unwrap(); assert!(status.success(), "{status}"); } + /// `check_starts` on a script this test process just wrote. Another test's spawn can fork while the + /// script's write handle is still open, and its child keeps that handle until it execs: running the + /// script meanwhile fails with ETXTBSY (Linux), so that one error is retried. + #[cfg(unix)] + fn check_written(program: &Path) -> Result<(), String> { + for _ in 0..50 { + match check_starts(program) { + Err(e) if e.contains("Text file busy") => { + std::thread::sleep(std::time::Duration::from_millis(20)) + } + other => return other, + } + } + check_starts(program) + } + #[cfg(unix)] #[test] fn the_check_runs_the_program() { @@ -340,10 +364,10 @@ mod tests { std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap(); path }; - assert_eq!(check_starts(&script("starts", "exit 0")), Ok(())); + assert_eq!(check_written(&script("starts", "exit 0")), Ok(())); let fails = script("fails", "echo 'no luck' >&2; exit 3"); assert_eq!( - check_starts(&fails), + check_written(&fails), Err(format!( "the game ({}) can't start (exit status 3): no luck", fails.display() diff --git a/crates/horizon-world/examples/probe/block_update_fixture.rs b/crates/horizon-world/examples/probe/block_update_fixture.rs index 5be9be731..fdb5e20e0 100644 --- a/crates/horizon-world/examples/probe/block_update_fixture.rs +++ b/crates/horizon-world/examples/probe/block_update_fixture.rs @@ -427,9 +427,11 @@ pub fn main() -> Result<(), Box> { // A fresh shrieker has warning level 0 and so never responds, // and no player is near enough for a portal to spawn a piglin. // A fresh command block has no command and is neither powered - // nor always active: `CommandBlock.tick` changes nothing. + // nor always active: `CommandBlock.tick` changes nothing. A + // fresh suspicious block was never brushed, so + // `BrushableBlockEntity.checkReset` has nothing to reset. LevelEvent::BlockEvent { - kind: "shrieker_respond" | "portal_spawn" | "command_block", + kind: "shrieker_respond" | "portal_spawn" | "command_block" | "brushable", .. } => {} LevelEvent::BlockEvent { kind, .. } => { diff --git a/crates/horizon-world/src/level/data.rs b/crates/horizon-world/src/level/data.rs index 4635e8b05..cda834217 100644 --- a/crates/horizon-world/src/level/data.rs +++ b/crates/horizon-world/src/level/data.rs @@ -571,6 +571,12 @@ props! { orientation = "orientation", crafting = "crafting", side_chain = "side_chain", + slot_0_occupied = "slot_0_occupied", + slot_1_occupied = "slot_1_occupied", + slot_2_occupied = "slot_2_occupied", + slot_3_occupied = "slot_3_occupied", + slot_4_occupied = "slot_4_occupied", + slot_5_occupied = "slot_5_occupied", copper_golem_pose = "copper_golem_pose", sculk_sensor_phase = "sculk_sensor_phase", shrieking = "shrieking", diff --git a/crates/horizon-world/src/level/hooks.rs b/crates/horizon-world/src/level/hooks.rs index f716449f5..db5a8457f 100644 --- a/crates/horizon-world/src/level/hooks.rs +++ b/crates/horizon-world/src/level/hooks.rs @@ -433,6 +433,29 @@ impl Sim<'_, L> { self.game_event(pos, "minecraft:block_destroy"); self.remove_block(pos, false) } + /// `IceBlock.playerDestroy` (after the drops): mined ice turns into water + /// when it sits over a solid block or a liquid, unless the tool prevents + /// ice melting (silk touch). In the nether, where water evaporates, the + /// block stays air. + pub(crate) fn ice_destroyed_by_player( + &mut self, + pos: BlockPos, + destroyed: BlockStateId, + prevents_melting: bool, + ) { + let b = self.b; + if !b.data(destroyed).is(Class::Ice) + || prevents_melting + || self.level.dimension() == super::Dimension::Nether + { + return; + } + let below = self.below_state(pos); + if b.in_set(below, &b.tags.blocks_motion) || b.liquid(below) { + let water = b.default_of(b.named.water); + self.set_block_and_update(pos, water); + } + } /// `entityInside` for entity-sensing blocks. pub(crate) fn entity_inside(&mut self, pos: BlockPos) { let b = self.b; diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs index 8f17ba1cc..210786493 100644 --- a/crates/horizon-world/src/level/interact.rs +++ b/crates/horizon-world/src/level/interact.rs @@ -1,11 +1,9 @@ //! `BlockBehaviour.useWithoutItem` (right-click with an empty hand or an item //! that does not handle the block itself). -use super::{ - Behaviours, LevelAccess, LevelEvent, Sim, Ticks, classes::Class, query::axis_of, update::below, -}; +use super::{Behaviours, LevelAccess, LevelEvent, Sim, Ticks, classes::Class, update::below}; use crate::registry::BlockStateId; use horizon_core::{ - geometry::{Axis, Direction, Vec3}, + geometry::{Direction, Vec3}, position::BlockPos, random::RandomSource, }; @@ -24,6 +22,44 @@ impl InteractionResult { } } +/// `SelectableSlotContainer.getHitSlot`: the slot of a block with `rows` by +/// `columns` slots on its front face (the way it `facing`) that the click at +/// `hit` on `face` of the block at `pos` lands in, if it is the front face. +pub fn hit_slot( + facing: Direction, + face: Direction, + pos: BlockPos, + hit: Vec3, + rows: i32, + columns: i32, +) -> Option { + if facing != face { + return None; + } + // The location relative to the block in front of the face, which only + // moves the axis the face points along: the others are the block's own. + let (dx, dy, dz) = ( + hit.x - f64::from(pos.x), + hit.y - f64::from(pos.y), + hit.z - f64::from(pos.z), + ); + let (x, y) = match face { + Direction::North => ((1.0 - dx) as f32, dy as f32), + Direction::South => (dx as f32, dy as f32), + Direction::West => (dz as f32, dy as f32), + Direction::East => ((1.0 - dz) as f32, dy as f32), + Direction::Down | Direction::Up => return None, + }; + // getSection + let section = |relative: f32, sections: i32| { + let size = 16.0f32 / sections as f32; + ((relative * 16.0f32 / size).floor() as i32).clamp(0, sections - 1) + }; + let row = section(1.0 - y, rows); + let column = section(x, columns); + Some((column + row * columns) as usize) +} + /// The interacting player, as far as block behaviour needs it. #[derive(Clone, Copy, Debug)] pub struct PlayerContext { @@ -326,19 +362,29 @@ impl Sim<'_, L> { Consume } } - Class::Bell => { - let click_y = hit.y - f64::from(pos.y); - let proper = axis_of(face) != Axis::Y && click_y <= 0.8124 && { - let facing_axis = axis_of(b.facing(state)); - match table.text(state, p.attachment) { - "floor" => facing_axis == axis_of(face), - "single_wall" | "double_wall" => facing_axis != axis_of(face), - "ceiling" => true, - _ => false, - } + Class::ChiseledBookShelf => { + // useItemOn and useWithoutItem agree on what a click takes: no + // slot under it passes, an empty slot consumes it, a book in + // it comes out (the block entity is the game's). + let Some(slot) = hit_slot(b.facing(state), face, pos, hit, 2, 3) else { + return Pass; }; - if proper { - self.bell_ring(pos, state, face); + let occupied = [ + p.slot_0_occupied, + p.slot_1_occupied, + p.slot_2_occupied, + p.slot_3_occupied, + p.slot_4_occupied, + p.slot_5_occupied, + ]; + if table.bool(state, occupied[slot]) { + Success + } else { + Consume + } + } + Class::Bell => { + if self.bell_hit(pos, state, face, hit.y - f64::from(pos.y)) { Success } else { Pass @@ -560,8 +606,9 @@ impl Behaviours { } /// `BlockBehaviour.attack` when mining begins: `RedStoneOreBlock.attack` - /// lights the ore, `NoteBlock.attack` plays the note. True for a note - /// block, whose player also earns the `play_noteblock` statistic. + /// lights the ore, `DragonEggBlock.attack` teleports the egg, + /// `NoteBlock.attack` plays the note. True for a note block, whose player + /// also earns the `play_noteblock` statistic. pub fn attack_block( &self, level: &mut L, @@ -571,6 +618,9 @@ impl Behaviours { let mut sim = self.sim(level, ticks); let state = sim.state(pos); let chain = &self.data(state).chain; + if chain.contains(&Class::DragonEgg) { + sim.dragon_egg_teleport(pos, state); + } if chain.contains(&Class::Note) { sim.note_play(pos, state); return true; diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index 0a8e160cd..4d228f898 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -137,7 +137,7 @@ mod tests; pub use buckets::BucketContent; pub use data::{BlockData, ItemBinding, ItemKind, Named, Props, PushReaction, StateFacts, Tags}; pub use falling::Landing; -pub use interact::{InteractionResult, PlayerContext, PlayerEffect}; +pub use interact::{InteractionResult, PlayerContext, PlayerEffect, hit_slot}; pub use pistons::{BlockEventData, MovingPiston}; pub use place::{PlaceContext, PlaceOutcome}; pub use states::{BlockId, PropKey, StateTable}; @@ -258,7 +258,8 @@ pub enum LevelEvent { /// event follow as their own events; the caller removes the block. PrimeTnt { pos: BlockPos, rot: f64 }, /// Block-entity or entity side effects the caller implements: `"dispense"` - /// (dispenser/dropper/crafter scheduled tick), `"hatch"` (frogspawn + /// (dispenser/dropper/crafter scheduled tick), `"brushable"` (a suspicious + /// block's scheduled tick: `checkReset`), `"hatch"` (frogspawn /// hatched into tadpoles; the block is already destroyed), `"portal_spawn"` /// (a nether portal won its zombified piglin roll; the caller checks /// `anyPlayerCloseEnoughForSpawning` and spawns below the portal). @@ -379,6 +380,12 @@ pub trait LevelAccess { ) -> i32 { 0 } + /// `ItemFrame.getAnalogOutput` of the one item frame in the block at + /// `pos` that faces `facing` (`ComparatorBlock.getItemFrame`), or None when + /// there is not exactly one. + fn item_frame_analog_output(&self, _pos: BlockPos, _facing: Direction) -> Option { + None + } /// `ContainerOpenersCounter.recheckOpenCount` for the chest or ender chest /// block entity at `pos`: recounts its openers and returns the previous /// and new counts (the caller plays open/close effects when they change), @@ -653,6 +660,20 @@ impl Behaviours { ) -> bool { self.sim(level, ticks).player_destroy(pos, creative) } + /// `IceBlock.playerDestroy` after the drops: mined ice melts into water + /// unless the tool prevents ice melting (silk touch). `destroyed` is the + /// state that was broken. + pub fn ice_destroyed_by_player( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + destroyed: BlockStateId, + prevents_melting: bool, + ) { + self.sim(level, ticks) + .ice_destroyed_by_player(pos, destroyed, prevents_melting); + } /// `BaseFireBlock.getState(level, pos)`: soul fire on its base blocks, /// otherwise fire shaped by its neighbours. pub fn fire_state_for( @@ -801,6 +822,22 @@ impl Behaviours { self.sim(level, ticks) .big_dripleaf_entity_inside(pos, on_ground, feet_y); } + /// `BellBlock.onProjectileHit` for a projectile that hit `face` of the + /// block at `pos` at height `hit_y`. False when the block is not a bell + /// or the hit missed the bell proper. + pub fn bell_projectile_hit( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + face: Direction, + hit_y: f64, + ) -> bool { + let mut sim = self.sim(level, ticks); + let state = sim.state(pos); + self.data(state).is(classes::Class::Bell) + && sim.bell_hit(pos, state, face, hit_y - f64::from(pos.y)) + } /// Redstone signal queries (`SignalGetter`). pub fn has_neighbor_signal( &self, diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs index 42ba42634..6676242e1 100644 --- a/crates/horizon-world/src/level/redstone.rs +++ b/crates/horizon-world/src/level/redstone.rs @@ -5,13 +5,13 @@ use super::{ LevelAccess, LevelEvent, Sim, classes::Class, data::state_flags, - query::{clockwise, counter_clockwise}, + query::{axis_of, clockwise, counter_clockwise}, states::BlockId, update::{HORIZONTAL, above, below, rel}, }; use crate::registry::BlockStateId; use horizon_core::{ - geometry::{Direction, trig}, + geometry::{Axis, Direction, trig}, position::BlockPos, random::RandomSource, ticks::TickPriority, @@ -493,8 +493,14 @@ impl Sim<'_, L> { } else if result < 15 && self.is_redstone_conductor(target_state, target) { let further = rel(target, facing); let further_state = self.state(further); - if b.has_flag(further_state, state_flags::ANALOG_OUTPUT) { - result = self.analog_output(further_state, further, facing.opposite()); + let block = b + .has_flag(further_state, state_flags::ANALOG_OUTPUT) + .then(|| self.analog_output(further_state, further, facing.opposite())); + // ComparatorBlock.getInputSignal: an item frame behind the + // conductor counts too, the larger signal winning. + let frame = self.level.item_frame_analog_output(further, facing); + if let Some(signal) = frame.into_iter().chain(block).max() { + result = signal; } } } @@ -1260,6 +1266,31 @@ impl Sim<'_, L> { self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, signal)); } } + /// `BellBlock.onHit` with `requireHitFromCorrectSide`: a hit on `face` at + /// height `click_y` in the block rings the bell only when it struck the + /// bell proper. False when the hit missed it. + pub(crate) fn bell_hit( + &mut self, + pos: BlockPos, + state: BlockStateId, + face: Direction, + click_y: f64, + ) -> bool { + let b = self.b; + let facing_axis = axis_of(b.facing(state)); + let proper = axis_of(face) != Axis::Y + && click_y <= f64::from(0.8124f32) + && match b.table.text(state, b.props.attachment) { + "floor" => facing_axis == axis_of(face), + "single_wall" | "double_wall" => facing_axis != axis_of(face), + "ceiling" => true, + _ => false, + }; + if proper { + self.bell_ring(pos, state, face); + } + proper + } /// `BellBlock.attemptToRing`: `BellBlockEntity.onHit` queues block event 1 /// with the struck direction, then the sound and game event. pub(crate) fn bell_ring(&mut self, pos: BlockPos, state: BlockStateId, direction: Direction) { diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 51b6b8083..d0af71808 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -127,6 +127,13 @@ impl Sim<'_, L> { } Class::FallingBlock => self.falling_block_tick(pos, state), Class::Brushable => { + // BrushableBlock.tick checks the brush reset first (the + // caller keeps the brush counts). + self.emit(LevelEvent::BlockEvent { + pos, + state, + kind: "brushable", + }); if self.is_free(self.below_state(pos)) && pos.y >= self.level.min_y() { self.falling_block_fall(pos, state); } diff --git a/crates/horizon-world/src/loot.rs b/crates/horizon-world/src/loot.rs index 399c76f69..934d1a8fc 100644 --- a/crates/horizon-world/src/loot.rs +++ b/crates/horizon-world/src/loot.rs @@ -34,6 +34,8 @@ pub struct LootStack { /// Added by set_stew_effect (the `suspicious_stew_effects` component): /// (effect id, duration in ticks). pub stew_effects: Vec<(String, i32)>, + /// Set by set_name: (`custom_name` or `item_name`, the text component). + pub names: Vec<(String, Value)>, } /// `ExplorationMapFunction`'s settings. #[derive(Clone, Debug, PartialEq, Eq)] @@ -78,6 +80,7 @@ impl LootStack { exploration: None, ominous_amplifier: None, stew_effects: Vec::new(), + names: Vec::new(), } } pub fn is_empty(&self) -> bool { @@ -1224,7 +1227,16 @@ impl Context<'_, R> { stack = smelted; } } - // Names, lore, components and other data without random draws. + // SetNameFunction: the component the target names (custom_name by + // default). The entity-resolved selectors and scores are not + // modelled; no table uses `entity`. + "minecraft:set_name" if !f["name"].is_null() => { + let target = f["target"].as_str().unwrap_or("custom_name"); + let id = format!("minecraft:{target}"); + stack.names.retain(|(k, _)| *k != id); + stack.names.push((id, f["name"].clone())); + } + // Lore, components and other data without random draws. _ => {} } stack diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index 5c83c6a33..f527c9476 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -42,7 +42,7 @@ The game logs into `HORIZON_HOME` and falls back to the player's own game folder Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 3 (on CPUs 0-3: its CI runner has 4-7). Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here. -Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on. +Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. A host's `exclude` also holds when `parity.py` runs on that host itself, as its CI runner does: the harness is skipped there with its reason (playhorizon skips `remote_fireball` and `remote_fireworks`, which its CPU-starved CI slice fails even on bare main), unless named on the command line. The Mac mini's runner and the nightly audit still run them. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on. The file's `solo` list names harnesses that drive game windows (`remote_fireworks`, `server_player_sculk`, `world_reopen`, ...). On a machine where `parity.py` has 4 CPUs or fewer, such as playhorizon's CI runner, each of them runs alone, after the others: there frames are drawn on the CPU, and beside other harnesses a screenshot or a control request took more ticks than the check allows. `PARITY_SOLO=1` or `0` forces this on or off. diff --git a/docs/release-flow.md b/docs/release-flow.md index be0ccbee8..5377b27bc 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -262,8 +262,11 @@ silent (no ping and Discord's @silent flag). Launcher releases post without a pi ### One channel -Since 2026-10-23 there is one channel. Every game release is published as the release, never a pre-release, and -marked GitHub's *latest*: the launcher, `horizon-server update` and `install.sh` take it at once. Because nothing +Since 2026-10-23 there is one release channel, and it is every launcher's default. Since 2026-10-27 (Ludovic's +decision, revising 2026-10-23's) players may also turn on [Nightly](#nightly-channel), an opt-in pre-release of main +plus pull requests the trusted reviewers picked, not all reviewed yet; nothing about releases changes for anyone who +doesn't. Every game release is published +as the release, never a pre-release, and marked GitHub's *latest*: the launcher, `horizon-server update` and `install.sh` take it at once. Because nothing promotes it later, the checks that used to gate a promotion run in the release itself, and the publish job (`tools/release_train.py gate`) publishes nothing unless both pass: @@ -407,6 +410,85 @@ With several game releases a day, the newest launcher release soon falls out of launcher and the website read: both then look the newest launcher tags up one by one (`git/matching-refs/tags/launcher@`, then `launcher-v` if there is none, then `releases/tags/`). +## Nightly channel + +`.github/workflows/nightly-build.yml` publishes an opt-in build once a night (20:17 UTC) and when a trusted +reviewer asks, for players who want fixes before they are released (#2681). It builds main plus the pull requests the +trusted reviewers picked, merged in their order. With none picked, it builds the newest `union/-` branch +on origin (main plus the pull requests the contribution gate proved together in one wave) when that union is newer +than main's head and holds something main lacks, otherwise main (`tools/ci/nightly.py pick`). A night with nothing +new publishes nothing. A Nightly can include pull requests not reviewed yet: that is what it is for, playing them +before the gate. + +### Trusted reviewers pick the pull requests + +The Nightly is where contributors test pull requests before the gate. The trusted reviewers listed in +`.github/nightly-reviewers.txt` (kacpherek, rdbtCVS and Online5277 since 2026-10-27) and Ludovic pick them with a +comment on any issue or pull request (`.github/workflows/nightly-command.yml`, `tools/ci/nightly_set.py`): + +```text +/nightly 2640 2642 the set becomes these pull requests, merged onto main in this order; builds now +/nightly add 2650 adds one, or takes its newest head again; builds now +/nightly remove 2640 drops one; builds now +/nightly clear empties the set: back to the proven union or main; builds now +/nightly status what the set holds +/nightly dry-run 2640 builds main + these and signs with a throwaway key; publishes nothing, the set stays +``` + +- **The answer.** The workflow answers in the thread with one comment starting `🤖 Nightly:`: the set, the build's + run, and later the published Nightly (or why it failed). +- **The set** is `set.json` on the `nightly-state` branch: who asked, when, and each pull request at the head it had + then. A head is taken again only when someone asks again or at the scheduled run, never silently in between. The + scheduled run takes every pull request's newest head and drops the merged and closed ones; the notes say so. + `builds.jsonl` there records each build's set (for `nightly_stats.py`). +- **Assembly.** `pick` (main's code) fetches each head and merges them onto main with `git merge-tree + --write-tree`: git objects only, no working tree, so no file, hook or filter of theirs reaches the runner. The + result is pushed as `nightly/build--` and `build` compiles that, without secrets, as for a release. + Equal inputs give the same commit, so an unchanged set and main publish nothing new. On a conflict the build + stops and answers which two pull requests conflict and where; a reviewer can then open an integration pull + request from their fork that combines them, and pick that one instead. +- **Refused.** A pull request that changes a path CODEOWNERS gives to Ludovic (`.github/`, `tools/ci/`, the + signing and update code, `launcher/src/backend.rs`, `launcher/links.json`…), more than 30 in a set, and more than + 6 builds a day (the scheduled one always runs). +- **No repository role.** Reviewers need no permission on the repository: the list file and the workflow are the + whole of it. +- **Ludovic stays in charge.** + - Ludovic's `/nightly clear` or `/nightly remove` always applies. A pull request he removed can only come back + when he adds it. + - A one-line pull request removing a login from `.github/nightly-reviewers.txt` revokes it as soon as it merges + (the file is his under CODEOWNERS). + - A line `paused` in that file stops every reviewer's `/nightly`; his own still work. + - Main, the gate and releases don't change: picks reach only players who turned Nightly on. + +- **Jobs.** `pick` chooses or assembles the commit and writes the notes (each pull request in it with its title, + author and who picked it, or for a union the open pull requests it holds beyond main). `build` is + `game-build.yml`, the same builds and smoke test as a release, with the version `nightly-` and + `HORIZON_NIGHTLY=" "` built in, macOS signed ad hoc. `sign` signs SHA256SUMS for the channel + (the message says `horizon release nightly`, so a nightly's signature never passes for a release's). `publish` + checks the signature and the smoke test (not `release-blocker`: a nightly is how blockers get tested), renames the + previous `nightly` pre-release to `nightly-`, publishes the new one as the `nightly` pre-release (never + GitHub's latest), and deletes the `nightly-` pre-releases and tags older than 7 days, nothing else. +- **The signing key never meets the pull requests' code.** Every workflow file and script runs from main's copy (a + schedule and `issue_comment` run the default branch; `uses: ./…` takes the caller's commit), never a pull + request's `.github/`, and a pull request that changes `.github/` or `tools/ci/` is refused. `build` compiles the + merge with a read-only token that isn't kept in the checkout and no secrets; the runner's Developer ID keychain + stays locked. `sign` is the only job with the key, and checks out only main's `tools/ci/sign_release.sh`, which + hashes the archives with the runner's `sha256sum` and signs with its OpenSSL: it never runs what `build` made. + `publish` runs main's `horizon-release-sign`, never the archives. Nothing a nightly's build leaves reaches a + release either: `game-build.yml`'s `trusted` input is true only for `release.yml`. An untrusted build runs its + macOS jobs on the runner that runs pull requests' parity jobs (`horizon-game`), never the release runner + (`MAC_RUNNER`), and its Rust cache has its own key and is never saved. A trusted build doesn't use the machine's + shared sccache, which pull requests' jobs write (`HORIZON_NO_SCCACHE`, `tools/ci/runner-env.sh`). +- **Players.** Releases stay the default and the only channel any launcher follows unless its player turns Nightly + on. `release_train.py`, `horizon-server update`, `install.sh` and the launcher's release list skip the tags: none + of them is `vX.Y.Z`. + +```sh +gh workflow run "nightly build" # now; skips when the pick is the commit already published +gh workflow run "nightly build" -f force=true # build and publish anyway +gh workflow run "nightly build" -f dry_run=true # build and sign with a throwaway key, publish nothing +``` + ## Nightly audit `.github/workflows/nightly.yml` runs every harness from scratch (`tools/parity.py --all`) on main at 03:00 Paris diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json index 189577fb3..b92252a92 100644 --- a/launcher/lang/fr.json +++ b/launcher/lang/fr.json @@ -158,5 +158,12 @@ "15% off": "-15 %", "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Pas préparé. Horizon a besoin des fichiers de votre propre Minecraft {version}.", "Prepared for Minecraft {version}": "Préparé pour Minecraft {version}", - "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Préparé pour Minecraft {version}, sans ses sons : le jeu sera muet. Préparez à nouveau pour les copier depuis votre installation de Minecraft." + "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Préparé pour Minecraft {version}, sans ses sons : le jeu sera muet. Préparez à nouveau pour les copier depuis votre installation de Minecraft.", + "Nightly builds": "Versions Nightly", + "Can include pull requests not reviewed yet, picked by trusted reviewers; may break.": "Peut inclure des pull requests pas encore relues, choisies par des relecteurs de confiance ; peut casser.", + "Plays in its own Nightly instance: your worlds and the release stay as they are.": "Se joue dans sa propre instance Nightly : vos mondes et la version publiée restent tels quels.", + "Installing the nightly, {percent}%": "Installation de la Nightly, {percent} %", + "The nightly could not be installed: {error}": "La Nightly n'a pas pu être installée : {error}", + "{version} in the Nightly instance. Choose Horizon in the sidebar to play the release.": "{version} dans l'instance Nightly. Choisissez Horizon dans la barre latérale pour jouer la version publiée.", + "No nightly build yet.": "Pas encore de version Nightly." } diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json index a992ef819..753132e4b 100644 --- a/launcher/lang/ru.json +++ b/launcher/lang/ru.json @@ -158,5 +158,12 @@ "15% off": "скидка 15%", "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Не подготовлено. Horizon нужны файлы вашего собственного Minecraft {version}.", "Prepared for Minecraft {version}": "Подготовлено для Minecraft {version}", - "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Подготовлено для Minecraft {version}, но без звуков: игра будет беззвучной. Подготовьте заново, чтобы скопировать их из вашей установки Minecraft." + "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Подготовлено для Minecraft {version}, но без звуков: игра будет беззвучной. Подготовьте заново, чтобы скопировать их из вашей установки Minecraft.", + "Nightly builds": "Ночные сборки", + "Can include pull requests not reviewed yet, picked by trusted reviewers; may break.": "Может включать ещё не проверенные pull request'ы, выбранные доверенными ревьюерами; что-то может сломаться.", + "Plays in its own Nightly instance: your worlds and the release stay as they are.": "Запускается в отдельной сборке Nightly: ваши миры и релиз остаются как есть.", + "Installing the nightly, {percent}%": "Установка ночной сборки, {percent}%", + "The nightly could not be installed: {error}": "Не удалось установить ночную сборку: {error}", + "{version} in the Nightly instance. Choose Horizon in the sidebar to play the release.": "{version} в сборке Nightly. Выберите Horizon на боковой панели, чтобы играть в релиз.", + "No nightly build yet.": "Ночных сборок пока нет." } diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 17840fe90..d7a3992b2 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -90,7 +90,7 @@ fn agent(url: &str) -> ureq::Agent { .build() } -fn get(url: &str) -> Result { +pub(crate) fn get(url: &str) -> Result { let mut request = agent(url).get(url); // CI runners share addresses and hit GitHub's anonymous rate limit; they pass their own token. if let Some(token) = std::env::var("HORIZON_GITHUB_TOKEN") @@ -239,7 +239,7 @@ fn release_list() -> Result { } /// The releases in `list` whose tag passes `keep`, newest first, with the asset named `asset`. -fn parse_releases( +pub(crate) fn parse_releases( list: &serde_json::Value, asset: Option<&str>, keep: fn(&str) -> bool, @@ -475,7 +475,7 @@ fn installed_in(versions: &Path) -> Vec { } /// A small release file (its checksums or their signature), whole; None when it has none. -fn fetch_small(url: &str) -> Result>, String> { +pub(crate) fn fetch_small(url: &str) -> Result>, String> { let response = match get(url) { Ok(response) => response, Err(e) if e.ends_with("answered 404") => return Ok(None), @@ -550,17 +550,28 @@ pub fn install(release: &Release, progress: impl Fn(f32)) -> Result<(), String> if !is_game_tag(tag) { return Err(format!("{tag} is not a Horizon release.")); } + let sha256 = signed_digest(tag, ASSET.unwrap_or_default())?; + install_as(release, tag, &sha256, progress) +} + +/// Downloads `release`'s archive for this platform, checks it against `sha256` (its signed +/// checksum), and unpacks it as the installed version `tag`. +pub(crate) fn install_as( + release: &Release, + tag: &str, + sha256: &str, + progress: impl Fn(f32), +) -> Result<(), String> { let (url, size) = release .asset .clone() .ok_or_else(|| format!("{tag} has no build for this platform."))?; - let sha256 = signed_digest(tag, ASSET.unwrap_or_default())?; let root = versions_dir(); let partial = root.join(format!(".{tag}.partial")); let _ = fs::remove_dir_all(&partial); fs::create_dir_all(&partial).map_err(|e| e.to_string())?; let archive = partial.join("download"); - download(&url, size, &sha256, &archive, &progress)?; + download(&url, size, sha256, &archive, &progress)?; let unpacked = partial.join("unpacked"); unpack(&archive, &url, &unpacked)?; progress(0.97); @@ -2439,6 +2450,10 @@ pub enum Msg { PackDone(Result, String>), /// How many play Horizon now, or none when the server can't be reached (`telemetry`). Playing(Option), + /// The nightly being installed, done this far (`nightly`). + NightlyProgress(f32), + /// A nightly check ended: the version installed (None: already up to date), or why not. + Nightly(Result, String>), } /// A running process; its output arrives as `Msg::Line`, its end as `Msg::Exit`. @@ -2617,6 +2632,10 @@ pub struct Settings { /// The window's language. Unset follows the system's (`i18n::Language::system`). #[serde(default, skip_serializing_if = "Option::is_none")] pub language: Option, + /// The player turned Nightly on (`nightly`): the nightly build installs and updates in its own + /// instance. Off by default. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub nightly: bool, } impl Settings { diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs index 43b28f42e..d3c498ec2 100644 --- a/launcher/src/lib.rs +++ b/launcher/src/lib.rs @@ -17,6 +17,7 @@ pub mod instances; pub mod launch; pub mod modpacks; pub mod mojang; +pub mod nightly; pub mod packs; pub mod process; pub mod proxy; diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 1eeb1477c..eefc653ac 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -52,6 +52,7 @@ use horizon_launcher::account::{self, Accounts, SignIn, SignInState}; use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates}; use horizon_launcher::i18n::{self, tr, trf}; use horizon_launcher::instances; +use horizon_launcher::nightly; use horizon_launcher::telemetry; use scrollbar::Scrollbar; use std::borrow::Cow; @@ -168,6 +169,12 @@ struct Launcher { /// nothing can launch, select or prepare it, and its row can't install or remove it again. removing: Option, install_error: Option<(String, String)>, + /// Nightly (`horizon_launcher::nightly`): how far the nightly being installed is, and why the + /// last check or install failed. + nightly_progress: Option, + nightly_error: Option, + /// Play the Nightly instance once its first install ends: the player just turned Nightly on. + nightly_select: bool, confirm_remove: Option, picker_open: bool, /// The top bar's quick switch of who plays (`switch_page.rs`). @@ -373,6 +380,9 @@ impl Launcher { installing: None, removing: None, install_error: None, + nightly_progress: None, + nightly_error: None, + nightly_select: false, confirm_remove: None, picker_open: false, account_menu: false, @@ -533,6 +543,41 @@ impl Launcher { self.install(&release); } + /// With Nightly on, installs the current nightly in the Nightly instance if it is new. + fn update_nightly(&mut self) { + if !self.settings.nightly || self.nightly_progress.is_some() { + return; + } + self.nightly_progress = Some(0.); + self.nightly_error = None; + let (tx, installed) = (self.tx.clone(), self.installed.clone()); + std::thread::spawn(move || { + let result = nightly::latest().and_then(|latest| { + let Some(release) = nightly::update(latest, &installed) else { + return Ok(None); + }; + let progress = |p| { + let _ = tx.send(Msg::NightlyProgress(p)); + }; + nightly::install(&release, progress).map(|_| Some(nightly::version_of(&release))) + }); + let _ = tx.send(Msg::Nightly(result)); + }); + } + + /// Turns Nightly on (install it, then play its instance) or off (play the release again; the + /// Nightly instance and its worlds stay). + fn set_nightly(&mut self, on: bool) { + self.settings.nightly = on; + if on { + self.nightly_select = true; + } else if self.settings.instance.as_deref() == Some(nightly::INSTANCE) { + self.settings.instance = None; + } + self.settings.save(); + self.update_nightly(); + } + fn fetch_releases(&mut self) { self.releases = Load::Loading; let tx = self.tx.clone(); @@ -703,8 +748,32 @@ impl Launcher { if let Some(release) = self.updates.launcher.clone() { self.update_launcher(release); } + self.update_nightly(); } Msg::Updates(Err(e)) => self.update_error = Some(e), + Msg::NightlyProgress(p) => self.nightly_progress = Some(p), + Msg::Nightly(result) => { + self.nightly_progress = None; + self.installed = backend::installed(); + self.reload_instances(); + match result { + Ok(_) + if self.nightly_select + && self.settings.nightly + && self + .instances + .list + .iter() + .any(|i| i.id == nightly::INSTANCE) => + { + self.nightly_select = false; + self.settings.instance = Some(nightly::INSTANCE.into()); + self.settings.save(); + } + Ok(_) => {} + Err(e) => self.nightly_error = Some(e), + } + } Msg::LauncherProgress(p) => { if let SelfUpdate::Downloading(_, f) = &mut self.self_update { *f = p; @@ -2743,6 +2812,7 @@ impl Launcher { Some(toggle.into_any_element()), &t, )) + .child(self.nightly_row(n + 2, cx)) .child(group("Launcher", "monitor")) .child(index_row( n + 3, @@ -2821,6 +2891,57 @@ impl Launcher { .children(self.agents_section(cx)) } + /// Settings' Nightly row: off by default; on, the nightly build installs and updates in its + /// own instance, and the release stays one click away (the Horizon instance). + fn nightly_row(&self, n: usize, cx: &mut Context) -> Div { + let t = self.theme; + let on = self.settings.nightly; + let toggle = + switch("nightly", on, &t).on_click(cx.listener(|this, _: &ClickEvent, _, cx| { + this.set_nightly(!this.settings.nightly); + cx.notify(); + })); + let what = tr( + "Can include pull requests not reviewed yet, picked by trusted reviewers; may break.", + ); + let status = match (&self.nightly_progress, &self.nightly_error) { + _ if !on => tr("Plays in its own Nightly instance: your worlds and the release stay as they are.") + .to_string(), + (Some(p), _) => trf( + "Installing the nightly, {percent}%", + &[("percent", &format!("{:.0}", p * 100.))], + ), + (None, Some(e)) => trf("The nightly could not be installed: {error}", &[("error", e)]), + (None, None) => match self + .instances + .list + .iter() + .find(|i| i.id == nightly::INSTANCE) + .and_then(|i| i.version.clone()) + { + Some(version) => trf( + "{version} in the Nightly instance. Choose Horizon in the sidebar to play the release.", + &[("version", &version)], + ), + None => tr("No nightly build yet.").to_string(), + }, + }; + index_row( + n, + tr("Nightly builds"), + Some( + div() + .flex() + .flex_col() + .child(what.to_string()) + .child(status) + .into_any_element(), + ), + Some(toggle.into_any_element()), + &t, + ) + } + /// Settings' Game arguments row: the extra arguments the game starts with, kept in /// `settings.json` and appended to the launcher's own (quotes group a word with spaces). fn game_args_row(&self, n: usize, cx: &mut Context) -> Div { diff --git a/launcher/src/nightly.rs b/launcher/src/nightly.rs new file mode 100644 index 000000000..4aed66434 --- /dev/null +++ b/launcher/src/nightly.rs @@ -0,0 +1,155 @@ +//! Nightly (docs/release-flow.md "Nightly channel"): an opt-in build of main plus pull requests +//! picked by trusted reviewers, some not reviewed yet, published as the `nightly` pre-release each +//! night and when a reviewer asks. Off by default (`Settings::nightly`). +//! +//! It never touches the release: it installs as its own version, `nightly--`, and plays +//! in its own instance, "Nightly" (`instances/nightly/` in the game's home), so the player's worlds +//! stay where they are and choosing the Horizon instance plays the release again. Its checksums +//! must be signed for the nightly channel (`signed::nightly_digest`); the release channel refuses +//! them. +use crate::backend::{self, Release, ASSET}; +use crate::instances::{self, Instance}; +use horizon_release_sign::NIGHTLY; + +/// The Nightly instance's id (its folder in `instances/`) and name. +pub const INSTANCE: &str = "nightly"; +const NAME: &str = "Nightly"; + +/// The version a nightly installs as: `nightly-2026-10-28-0c02067`, from its title +/// ("Nightly 2026-10-28 · 0c02067"), else its publication date. +pub fn version_of(release: &Release) -> String { + let mut words = release + .name + .strip_prefix("Nightly ") + .unwrap_or_default() + .split(" · "); + let date = words.next().filter(|d| is_date(d)).unwrap_or(&release.date); + let commit = words + .next() + .filter(|c| !c.is_empty() && c.chars().all(|c| c.is_ascii_hexdigit())); + match commit { + Some(commit) => format!("{NIGHTLY}-{date}-{commit}"), + None => format!("{NIGHTLY}-{date}"), + } +} + +fn is_date(text: &str) -> bool { + text.len() == 10 + && text.chars().enumerate().all(|(i, c)| { + if i == 4 || i == 7 { + c == '-' + } else { + c.is_ascii_digit() + } + }) +} + +/// The current nightly build, or None while there is none. +pub fn latest() -> Result, String> { + let url = format!( + "https://api.github.com/repos/{}/releases/tags/{NIGHTLY}", + backend::REPO + ); + let release: serde_json::Value = match backend::get(&url) { + Ok(response) => response.into_json().map_err(|e| e.to_string())?, + Err(e) if e.ends_with("answered 404") => return Ok(None), + Err(e) => return Err(e), + }; + Ok(parse(&release)) +} + +fn parse(release: &serde_json::Value) -> Option { + let list = serde_json::Value::Array(vec![release.clone()]); + backend::parse_releases(&list, ASSET, |tag| tag == NIGHTLY) + .into_iter() + .next() + .filter(|r| r.prerelease) +} + +/// The nightly to install: `latest` when it isn't installed yet. +pub fn update(latest: Option, installed: &[String]) -> Option { + latest.filter(|r| r.asset.is_some() && !installed.contains(&version_of(r))) +} + +/// Installs `release` (the current nightly) as its own version, points the Nightly instance at +/// it (making the instance the first time) and removes older nightly versions. Returns the +/// instance. +pub fn install(release: &Release, progress: impl Fn(f32)) -> Result { + let sha256 = crate::signed::nightly_digest( + ASSET.unwrap_or_default(), + &horizon_release_sign::trusted_keys(), + backend::fetch_small, + )?; + let version = version_of(release); + backend::install_as(release, &version, &sha256, progress)?; + let instance = instance_on(&version)?; + for old in backend::installed() { + if horizon_release_sign::is_nightly(&old) && old != version { + let _ = backend::remove(&old); + } + } + Ok(instance) +} + +/// The Nightly instance, made empty the first time (with the player's options and offline name), +/// playing `version`. +fn instance_on(version: &str) -> Result { + if instances::find(INSTANCE).is_err() { + instances::create(NAME, None)?; + } + instances::edit(INSTANCE, |meta| meta.version = Some(version.to_owned())) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn release(name: &str, date: &str, asset: bool) -> Release { + Release { + tag: NIGHTLY.into(), + name: name.into(), + body: String::new(), + date: date.into(), + asset: asset.then(|| ("https://example/horizon.zip".into(), 1)), + prerelease: true, + } + } + + #[test] + fn a_nightly_installs_under_its_date_and_commit() { + let r = release("Nightly 2026-10-28 · 0c02067", "2026-10-28", true); + assert_eq!(version_of(&r), "nightly-2026-10-28-0c02067"); + let untitled = release("Something else", "2026-10-29", true); + assert_eq!(version_of(&untitled), "nightly-2026-10-29"); + // Never a release version: the release channel's checks and lists leave it out. + assert!(!backend::is_game_tag(&version_of(&r))); + assert!(horizon_release_sign::is_nightly(&version_of(&r))); + } + + #[test] + fn only_a_new_nightly_with_a_build_here_is_an_update() { + let r = release("Nightly 2026-10-28 · 0c02067", "2026-10-28", true); + let name = |r: Option| r.map(|r| r.name); + assert_eq!( + name(update(Some(r.clone()), &["v0.2.80".into()])), + Some(r.name.clone()) + ); + let installed = ["nightly-2026-10-28-0c02067".to_string(), "v0.2.80".into()]; + assert!(update(Some(r), &installed).is_none()); + let no_build = release("Nightly 2026-10-29 · 1a2b3c4", "2026-10-29", false); + assert!(update(Some(no_build), &installed).is_none()); + assert!(update(None, &installed).is_none()); + } + + #[test] + fn only_the_nightly_pre_release_is_read() { + let json = |tag: &str, pre: bool| { + serde_json::json!({"tag_name": tag, "name": "Nightly 2026-10-28 · 0c02067", + "prerelease": pre, "published_at": "2026-10-28T20:40:00Z", + "assets": [{"name": ASSET.unwrap_or("none"), "browser_download_url": "u", "size": 1}]}) + }; + assert!(parse(&json("nightly", true)).is_some()); + assert!(parse(&json("nightly", false)).is_none()); + assert!(parse(&json("v0.2.81", true)).is_none()); + } +} diff --git a/launcher/src/signed.rs b/launcher/src/signed.rs index 4052f625d..4a9426bef 100644 --- a/launcher/src/signed.rs +++ b/launcher/src/signed.rs @@ -30,6 +30,20 @@ pub fn digest( horizon_release_sign::signed_digest(tag, asset, sums.as_deref(), signature.as_deref(), keys) } +/// The signed SHA-256 of `asset` in the current nightly build (the `nightly` pre-release): its +/// checksums must be signed for the nightly channel (`horizon_release_sign::nightly_digest`). +pub fn nightly_digest( + asset: &str, + keys: &[PublicKey], + fetch: impl Fn(&str) -> Result>, String>, +) -> Result { + let tag = horizon_release_sign::NIGHTLY; + let sums = fetch(&asset_url(tag, SUMS))?; + let signature = fetch(&asset_url(tag, SIGNATURE))? + .map(|bytes| String::from_utf8_lossy(&bytes).into_owned()); + horizon_release_sign::nightly_digest(asset, sums.as_deref(), signature.as_deref(), keys) +} + #[cfg(test)] mod tests { use super::*; @@ -93,4 +107,41 @@ mod tests { let offline = |_: &str| -> Result>, String> { Err("No connection".into()) }; assert!(digest("v2099.01.01", "horizon.zip", &keys, offline).is_err()); } + + /// The release channel never installs what was signed for the nightly channel, whatever tag it + /// is served under, and the nightly channel never installs a release's signed list. + #[test] + fn the_release_channel_refuses_nightly_signatures() { + let (key, _) = SigningKey::generate().unwrap(); + let keys = [key.public()]; + let sums = sums_file(&[("horizon.zip".into(), sha256_hex(b"game"))]); + let serving = |signed_for: &'static str| { + let signature = key.sign(signed_for, sums.as_bytes()); + let sums = sums.clone(); + move |url: &str| -> Result>, String> { + Ok(Some( + if url.ends_with(".sig") { + signature.clone() + } else { + sums.clone() + } + .into_bytes(), + )) + } + }; + let nightly = serving(horizon_release_sign::NIGHTLY); + assert_eq!( + nightly_digest("horizon.zip", &keys, &nightly), + Ok(sha256_hex(b"game")) + ); + for tag in ["v0.2.81", "nightly", "nightly-2026-10-27"] { + assert!( + digest(tag, "horizon.zip", &keys, &nightly).is_err(), + "{tag}" + ); + } + let release = serving("v0.2.81"); + assert!(digest("v0.2.81", "horizon.zip", &keys, &release).is_ok()); + assert!(nightly_digest("horizon.zip", &keys, &release).is_err()); + } } diff --git a/tests/test_nightly.py b/tests/test_nightly.py new file mode 100644 index 000000000..c44416044 --- /dev/null +++ b/tests/test_nightly.py @@ -0,0 +1,122 @@ +import datetime as dt +import unittest +from pathlib import Path + +from tools.ci import nightly +from tools.ci import nightly_set as ns + +NOW = "2026-10-28T12:00:00+00:00" +PATTERNS = ns.guarded_patterns((Path(__file__).resolve().parents[1] / ".github/CODEOWNERS").read_text()) + + +def pr(n, head="h", state="open", files=("crates/horizon-world/src/lib.rs",), base="main"): + return ns.PullRequest(n, state, f"{head}{n}", f"Fix {n}", f"dev{n}", base, list(files)) + + +def lookup(*prs): + known = {p.number: p for p in prs} + return lambda n: known.get(n) + + +def run(state, text, login="kacpherek", *prs): + return ns.apply(state, ns.parse(text), login, NOW, lookup(*prs), PATTERNS) + +T = dt.datetime(2026, 10, 28, 12, 0, tzinfo=dt.timezone.utc) + + +def ref(name, sha, hours): + return nightly.Ref(name, sha, T + dt.timedelta(hours=hours)) + + +class NightlyTests(unittest.TestCase): + def test_the_newest_union_newer_than_main_is_built(self): + main = ref("main", "m", 0) + unions = [ref("union/a", "a", 1), ref("union/b", "b", 3), ref("union/c", "c", -2)] + self.assertEqual(nightly.choose(main, unions, contains=lambda a, b: False).name, "union/b") + + def test_main_when_no_union_is_newer(self): + main = ref("main", "m", 5) + unions = [ref("union/a", "a", 1), ref("union/b", "b", 3)] + self.assertEqual(nightly.choose(main, unions, contains=lambda a, b: False).name, "main") + self.assertEqual(nightly.choose(main, [], contains=lambda a, b: False).name, "main") + + def test_a_union_main_already_holds_is_skipped(self): + main = ref("main", "m", 0) + unions = [ref("union/landed", "l", 2), ref("union/open", "o", 1)] + landed = lambda a, b: a == "l" # noqa: E731 + self.assertEqual(nightly.choose(main, unions, contains=landed).name, "union/open") + + def test_only_old_dated_nightlies_are_pruned(self): + tags = [{"tagName": "nightly", "isPrerelease": True}, + {"tagName": "nightly-2026-10-20", "isPrerelease": True}, + {"tagName": "nightly-2026-10-21", "isPrerelease": True}, + {"tagName": "nightly-2026-10-19", "isPrerelease": False}, + {"tagName": "v0.2.80", "isPrerelease": False}, + {"tagName": "nightly-2026-10-15-extra", "isPrerelease": True}] + self.assertEqual(nightly.stale(tags, dt.date(2026, 10, 28), 7), ["nightly-2026-10-20"]) + + def test_notes_list_what_is_not_on_main(self): + text = nightly.notes("2026-10-28", ref("union/a", "0c0206714abc", 1), + [{"number": 2476, "title": "Fix pistons", "headRefOid": "x"}]) + self.assertIn("Nightly 2026-10-28 · 0c02067", text) + self.assertIn("- Fix pistons (#2476)", text) + self.assertIn("Everything in it is on main.", nightly.notes("2026-10-28", ref("main", "m" * 40, 0), [])) + + + +class ScheduledTests(unittest.TestCase): + def test_the_scheduled_nightly_takes_new_heads_and_drops_closed_ones(self): + state = run({}, "/nightly 1 2 3 4", "kacpherek", pr(1), pr(2), pr(3), pr(4)).state + get = lookup(pr(1, head="new"), pr(2, state="merged"), pr(3, state="closed"), + pr(4, files=[".github/workflows/x.yml"])) + kept, left_out = nightly.refresh(state["prs"], get, PATTERNS) + self.assertEqual([(e["number"], e["head"]) for e in kept], [(1, "new1")]) + self.assertEqual(len(left_out), 3) + self.assertIn("merged", left_out[0]) + + def test_notes_list_each_pull_request_and_who_picked_it(self): + prs = run({}, "/nightly 1 2", "kacpherek", pr(1), pr(2)).state["prs"] + main = nightly.Ref("main", "m" * 40, None) + text = nightly.set_notes("2026-10-28", nightly.Ref("nightly/build-2026-10-28-1", "b" * 40, None), main, prs, + ["#3 Fix 3: closed, left out"]) + self.assertIn("can include pull requests not reviewed yet, picked by trusted reviewers", text) + self.assertIn("- Fix 1 (#1) by dev1, at h1, picked by kacpherek", text) + self.assertIn("### Left out (1)", text) + +if __name__ == "__main__": + unittest.main() + + +WORKFLOWS = Path(__file__).resolve().parents[1] / ".github" / "workflows" + + +class UntrustedBuildTests(unittest.TestCase): + """A nightly can hold unreviewed pull requests: nothing its build leaves may reach a release (game-build.yml).""" + + def setUp(self): + self.game = (WORKFLOWS / "game-build.yml").read_text() + + def test_only_the_release_is_trusted(self): + self.assertIn("trusted: true", (WORKFLOWS / "release.yml").read_text()) + nightly_build = (WORKFLOWS / "nightly-build.yml").read_text() + self.assertIn("trusted: false", nightly_build) + self.assertNotIn("trusted: true", nightly_build) + self.assertIn("default: false", self.game.split("trusted:", 1)[1].split("developer_id:", 1)[0]) + + def test_an_untrusted_build_neither_shares_nor_saves_the_release_cache(self): + self.assertIn("shared-key: ${{ inputs.trusted && 'release' || 'nightly' }}-${{ matrix.name }}", self.game) + self.assertIn("save-if: ${{ inputs.trusted }}", self.game) + self.assertEqual(self.game.count("Swatinem/rust-cache"), 1) + + def test_an_untrusted_build_never_runs_on_the_release_runner(self): + runs_on = [line for line in self.game.splitlines() if "runs-on:" in line] + self.assertEqual(len(runs_on), 2) + pr_runner = "fromJSON('[\"self-hosted\", \"macOS\", \"horizon-game\"]')" + for line in runs_on: + self.assertIn(f"inputs.trusted && vars.MAC_RUNNER || {pr_runner}", line) + + def test_a_trusted_build_never_reads_the_shared_sccache(self): + calls = self.game.count("bash tools/ci/runner-env.sh") + self.assertEqual(self.game.count("HORIZON_NO_SCCACHE: ${{ inputs.trusted && '1' || '' }}"), calls) + env = (Path(__file__).resolve().parents[1] / "tools/ci/runner-env.sh").read_text() + self.assertEqual(env.count('-z "${HORIZON_NO_SCCACHE:-}"'), 2) diff --git a/tests/test_nightly_set.py b/tests/test_nightly_set.py new file mode 100644 index 000000000..4ba8d43d3 --- /dev/null +++ b/tests/test_nightly_set.py @@ -0,0 +1,271 @@ +import os +import subprocess +import tempfile +import unittest +from pathlib import Path + +from tools.ci import nightly_set as ns + +ROOT = Path(__file__).resolve().parents[1] +NOW = "2026-10-28T12:00:00+00:00" +PATTERNS = ns.guarded_patterns((ROOT / ".github/CODEOWNERS").read_text()) + + +def pr(n, head="h", state="open", files=("crates/horizon-world/src/lib.rs",), base="main"): + return ns.PullRequest(n, state, f"{head}{n}", f"Fix {n}", f"dev{n}", base, list(files)) + + +def lookup(*prs): + known = {p.number: p for p in prs} + return lambda n: known.get(n) + + +def run(state, text, login="kacpherek", *prs): + return ns.apply(state, ns.parse(text), login, NOW, lookup(*prs), PATTERNS) + + +class ParseTests(unittest.TestCase): + def test_commands(self): + self.assertEqual(ns.parse("/nightly 2640 #2642, 2640"), ns.Command("set", [2640, 2642])) + self.assertEqual(ns.parse("/nightly add 2650"), ns.Command("add", [2650])) + self.assertEqual(ns.parse("/Nightly REMOVE 2640"), ns.Command("remove", [2640])) + self.assertEqual(ns.parse("/nightly clear"), ns.Command("clear", [])) + self.assertEqual(ns.parse("/nightly status"), ns.Command("status", [])) + self.assertEqual(ns.parse("/nightly"), ns.Command("status", [])) + self.assertEqual(ns.parse("/nightly dry-run 1 2"), ns.Command("dry-run", [1, 2])) + self.assertEqual(ns.parse("\n /nightly 7\nthanks!"), ns.Command("set", [7])) + + def test_other_comments_are_not_commands(self): + for body in ("", "LGTM", "please /nightly 2640", "/nightlyx 1", "> /nightly 1"): + self.assertIsNone(ns.parse(body), body) + + def test_wrong_commands_are_answered(self): + for body in ("/nightly please", "/nightly add", "/nightly clear 5", "/nightly 1 `rm -rf`", + "/nightly " + " ".join(str(n) for n in range(1, 32))): + with self.assertRaises(ns.Refused, msg=body): + ns.parse(body) + + def test_answers_never_quote_markdown_or_mentions(self): + with self.assertRaises(ns.Refused) as e: + ns.parse("/nightly @ludovic111`x`") + self.assertNotIn("@", str(e.exception).split("isn't")[0]) + self.assertNotIn("`x`", str(e.exception)) + + +class AllowTests(unittest.TestCase): + LIST = "# trusted\nkacpherek # added by Ludovic\nrdbtCVS\n\nnot a login!\n" + + def test_listed_reviewers_and_ludovic(self): + reviewers = ns.read_reviewers(self.LIST) + ns.authorize("kacpherek", reviewers) + ns.authorize("RDBTcvs", reviewers) + ns.authorize("ludovic111", reviewers) + for login in ("levzzz5154", "someone", "not"): + with self.assertRaises(ns.Refused): + ns.authorize(login, reviewers) + + def test_paused_stops_reviewers_not_ludovic(self): + reviewers = ns.read_reviewers(self.LIST + "paused # Ludovic, 2026-10-29\n") + self.assertTrue(reviewers.paused) + with self.assertRaises(ns.Refused): + ns.authorize("kacpherek", reviewers) + ns.authorize("ludovic111", reviewers) + + def test_the_repos_list_names_the_three_reviewers(self): + reviewers = ns.read_reviewers((ROOT / ns.REVIEWERS).read_text()) + self.assertEqual(reviewers.logins, {"kacpherek", "rdbtcvs", "online5277"}) + self.assertFalse(reviewers.paused) + +class RefusalTests(unittest.TestCase): + def test_what_codeowners_guards_is_refused(self): + for path in (".github/workflows/x.yml", "tools/ci/nightly.py", "crates/horizon-release-sign/src/lib.rs", + "crates/horizon-server/src/update.rs", "launcher/src/backend.rs", "launcher/links.json", + "launcher/src/signed.rs", "tools/release_train.py"): + self.assertTrue(ns.guarded(path, PATTERNS), path) + for path in ("crates/horizon-client/src/game.rs", "launcher/src/main.rs", "tools/ci.py", "docs/x.md", + "crates/horizon-server/src/main.rs"): + self.assertFalse(ns.guarded(path, PATTERNS), path) + self.assertTrue(ns.guarded("tools/ci/x.py", ns.guarded_patterns(""))) # even without CODEOWNERS + + def test_a_set_with_a_refused_pull_request_changes_nothing(self): + state = {"prs": []} + bad = [pr(2, files=["tools/ci/nightly.py"]), pr(3, state="closed"), pr(4, state="merged"), pr(5, base="x")] + for p in bad: + with self.assertRaises(ns.Refused): + run(state, f"/nightly 1 {p.number}", "kacpherek", pr(1), p) + with self.assertRaises(ns.Refused): + run(state, "/nightly 1 9", "kacpherek", pr(1)) # 9 doesn't exist + + def test_at_most_thirty(self): + state = {"prs": [ns.entry(pr(n), "a", NOW) for n in range(1, 31)]} + with self.assertRaises(ns.Refused): + run(state, "/nightly add 31", "kacpherek", pr(31)) + + +class SetTests(unittest.TestCase): + def test_set_add_remove_clear(self): + r = run({}, "/nightly 1 2", "kacpherek", pr(1), pr(2)) + self.assertTrue(r.build) + self.assertEqual([e["number"] for e in r.state["prs"]], [1, 2]) + self.assertEqual(r.state["prs"][0]["asked_by"], "kacpherek") + # add takes the newest head again and keeps its place + r = run(r.state, "/nightly add 1 3", "rdbtCVS", pr(1, head="new"), pr(3)) + self.assertEqual([(e["number"], e["head"]) for e in r.state["prs"]], [(1, "new1"), (2, "h2"), (3, "h3")]) + r = run(r.state, "/nightly remove 2", "rdbtCVS") + self.assertEqual([e["number"] for e in r.state["prs"]], [1, 3]) + r = run(r.state, "/nightly clear", "kacpherek") + self.assertEqual(r.state["prs"], []) + self.assertTrue(r.build) + + def test_status_and_dry_run_change_nothing(self): + state = run({}, "/nightly 1", "kacpherek", pr(1)).state + status = run(state, "/nightly status", "levzzz5154") + self.assertIs(status.state, state) + self.assertFalse(status.build) + self.assertIn("#1 Fix 1", status.answer) + dry = run(state, "/nightly dry-run 2 3", "kacpherek", pr(2), pr(3)) + self.assertIs(dry.state, state) + self.assertEqual([e["number"] for e in dry.dry_run], [2, 3]) + + def test_ludovics_remove_wins(self): + state = run({}, "/nightly 1 2", "kacpherek", pr(1), pr(2)).state + state = run(state, "/nightly remove 2", "ludovic111").state + self.assertEqual(state["blocked"], [2]) + for text in ("/nightly add 2", "/nightly 1 2", "/nightly dry-run 2"): + with self.assertRaises(ns.Refused): + run(state, text, "kacpherek", pr(1), pr(2)) + state = run(state, "/nightly add 2", "ludovic111", pr(2)).state + self.assertEqual(state["blocked"], []) + self.assertEqual([e["number"] for e in run(state, "/nightly add 2", "kacpherek", pr(2)).state["prs"]], [1, 2]) + + def test_titles_never_mention_anyone(self): + p = pr(1) + p.title = "Fix @everyone\nsecond line" + answer = run({}, "/nightly 1", "kacpherek", p).answer + self.assertNotIn("@everyone", answer) + self.assertNotIn("second line\n", answer) + + def test_builds_are_numbered_per_day(self): + self.assertEqual(ns.next_build("2026-10-28", []), "nightly/build-2026-10-28-1") + self.assertEqual(ns.next_build("2026-10-28", ["nightly/build-2026-10-28-1", "nightly/build-2026-10-28-4"]), + "nightly/build-2026-10-28-5") + + +def sh(repo, *args, env=None): + return subprocess.run(["git", *args], cwd=repo, check=True, capture_output=True, text=True, + env={**os.environ, **(env or {})}).stdout.strip() + + +class AssemblyTests(unittest.TestCase): + """A fixture repository: main and three pull requests, two of them touching the same line.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.repo = self.tmp.name + ident = {"GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", "GIT_COMMITTER_NAME": "t", + "GIT_COMMITTER_EMAIL": "t@t", "GIT_AUTHOR_DATE": "2026-10-28T10:00:00Z", + "GIT_COMMITTER_DATE": "2026-10-28T10:00:00Z"} + self.env = ident + sh(self.repo, "init", "-q", "-b", "main") + self.write({"a.txt": "a\n", "b.txt": "b\n", "c.txt": "c\n"}) + self.main = self.commit("main") + self.p1 = self.branch("p1", {"a.txt": "a from p1\n"}) + self.p2 = self.branch("p2", {"b.txt": "b from p2\n", ".gitattributes": "* filter=evil\n"}) + self.p3 = self.branch("p3", {"a.txt": "a from p3\n"}) + sh(self.repo, "checkout", "-q", "main") + + def tearDown(self): + self.tmp.cleanup() + + def write(self, files): + for name, text in files.items(): + Path(self.repo, name).write_text(text) + + def commit(self, message): + sh(self.repo, "add", "-A") + sh(self.repo, "commit", "-q", "-m", message, env=self.env) + return sh(self.repo, "rev-parse", "HEAD") + + def branch(self, name, files): + sh(self.repo, "checkout", "-q", "-b", name, self.main) + self.write(files) + return self.commit(name) + + def test_clean_merges_in_order_and_the_same_inputs_give_the_same_commit(self): + built = ns.assemble(self.main, [(1, self.p1), (2, self.p2)], cwd=self.repo) + self.assertEqual(sh(self.repo, "show", f"{built}:a.txt"), "a from p1") + self.assertEqual(sh(self.repo, "show", f"{built}:b.txt"), "b from p2") + self.assertEqual(sh(self.repo, "rev-list", "--count", f"{self.main}..{built}", "--first-parent"), "2") + self.assertEqual(ns.assemble(self.main, [(1, self.p1), (2, self.p2)], cwd=self.repo), built) + # nothing was checked out: the working tree is still main's + self.assertEqual(Path(self.repo, "a.txt").read_text(), "a\n") + self.assertFalse(Path(self.repo, ".gitattributes").exists()) + + def test_two_pull_requests_that_conflict_are_named(self): + with self.assertRaises(ns.Conflict) as e: + ns.assemble(self.main, [(1, self.p1), (2, self.p2), (3, self.p3)], cwd=self.repo) + self.assertEqual((e.exception.number, e.exception.other, e.exception.files), (3, 1, ["a.txt"])) + self.assertIn("#1 and #3 conflict in `a.txt`", e.exception.text()) + + def test_a_conflict_with_main_says_so(self): + sh(self.repo, "checkout", "-q", "main") + self.write({"a.txt": "a from main\n"}) + main = self.commit("main moves") + with self.assertRaises(ns.Conflict) as e: + ns.assemble(main, [(1, self.p1)], cwd=self.repo) + self.assertIsNone(e.exception.other) + self.assertIn("conflicts with main", e.exception.text()) + + def test_changed_files_finds_guarded_paths(self): + self.assertEqual(sorted(ns.changed_files(self.main, self.p2, cwd=self.repo)), [".gitattributes", "b.txt"]) + + +class StateTests(unittest.TestCase): + """The nightly-state branch on a local bare repository standing in for origin.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.origin, self.repo = Path(self.tmp.name, "origin.git"), Path(self.tmp.name, "work") + subprocess.run(["git", "init", "-q", "--bare", str(self.origin)], check=True) + subprocess.run(["git", "init", "-q", str(self.repo)], check=True) + sh(self.repo, "remote", "add", "origin", str(self.origin)) + + def tearDown(self): + self.tmp.cleanup() + + def test_first_save_then_load(self): + self.assertEqual(ns.load_state(str(self.repo)), ({}, "", None)) + ns.update_state(lambda st, b: ({"prs": [1]}, b + "{}\n", "first"), "t", cwd=str(self.repo)) + state, builds, head = ns.load_state(str(self.repo)) + self.assertEqual((state, builds), ({"prs": [1]}, "{}\n")) + self.assertIn("first", sh(self.repo, "log", "-1", "--format=%s", head)) + + def test_a_run_that_pushed_first_is_kept(self): + ns.update_state(lambda st, b: ({"prs": [1]}, b, "one"), "t", cwd=str(self.repo)) + other = Path(self.tmp.name, "other") + subprocess.run(["git", "init", "-q", str(other)], check=True) + sh(other, "remote", "add", "origin", str(self.origin)) + seen = [] + + def add_two(st, b): + seen.append(list(st.get("prs", []))) + if len(seen) == 1: # meanwhile another run saves first + ns.update_state(lambda s2, b2: ({"prs": s2["prs"] + [3]}, b2, "other"), "t", cwd=str(other)) + return {"prs": st["prs"] + [2]}, b, "two" + final = ns.update_state(add_two, "t", cwd=str(self.repo)) + self.assertEqual(seen, [[1], [1, 3]]) + self.assertEqual(final["prs"], [1, 3, 2]) + self.assertEqual(ns.load_state(str(self.repo))[0]["prs"], [1, 3, 2]) + + def test_builds_today_lists_the_days_branches(self): + sh(self.repo, "commit", "-q", "--allow-empty", "-m", "x", env={ + "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t"}) + head = sh(self.repo, "rev-parse", "HEAD") + for name in ("nightly/build-2026-10-28-1", "nightly/build-2026-10-28-2", "nightly/build-2026-10-27-1"): + self.assertTrue(ns.push(head, name, "t", cwd=str(self.repo))) + self.assertEqual(sorted(ns.builds_today("2026-10-28", cwd=str(self.repo))), + ["nightly/build-2026-10-28-1", "nightly/build-2026-10-28-2"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index fdc636a24..f26cbd5da 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -145,6 +145,13 @@ class ParityRunnerTests(unittest.TestCase): with mock.patch.object(parity.sys, "platform", "darwin"): self.assertEqual(parity.platform_skips(config), {"options": "libm"}) + def test_a_hosts_excludes_are_skipped_when_it_runs_parity_itself(self): + config = {"hosts": {"playhorizon": {"exclude": {"remote_fireworks": "starved"}}, "macmini": {"exclude": {}}}} + with mock.patch.object(parity.sys, "platform", "linux"): + self.assertEqual(parity.platform_skips(config, "playhorizon"), {"remote_fireworks": "starved"}) + self.assertEqual(parity.platform_skips(config, "macmini"), {}) + self.assertEqual(parity.platform_skips(config, "elsewhere"), {}) + def test_named_only_harnesses_are_listed_from_the_host_config(self): self.assertEqual(parity.named_only({"named_only": {"lan_integration": "slow"}}), {"lan_integration": "slow"}) self.assertEqual(parity.named_only({}), {}) diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py index 4c77f989d..e6c9940f4 100644 --- a/tests/test_remote_mining.py +++ b/tests/test_remote_mining.py @@ -26,7 +26,7 @@ class RemoteMiningTests(unittest.TestCase): struct Hit { pos: [i32; 3], face: u8 } struct Mining { pos: [i32; 3], progress: f32, ticks: u32 } #[derive(Default)] -struct Remote { destroy_delay: u32, destroying: Option<([i32; 3], u8, f32)> } +struct Remote { destroy_delay: u32, destroying: Option<([i32; 3], u8, f32)>, destroying_item: String } struct Ground { on_ground: bool } struct Player { ground: Ground } #[derive(Clone)] @@ -70,6 +70,8 @@ struct Game { hit: Hit, sequence: i32, packets: Vec, } impl Game { + fn main_hand_key(&self) -> String { String::new() } + fn reset_attack_strength(&mut self) {} fn new(hardness: f32, speed: f32, creative: bool) -> Self { Self { remote: Some(Remote::default()), mining: None, creative, diff --git a/tests/test_remote_motion.py b/tests/test_remote_motion.py index 59526b476..5148c2c1b 100644 --- a/tests/test_remote_motion.py +++ b/tests/test_remote_motion.py @@ -35,8 +35,8 @@ impl End { fn remote_eye_motion(&mut self, _id: u32, _v: [f64; 3]) {} } #[derive(Default)] struct Game { mobs: Vec, dropped: Vec, falling: Vec, tnts: Vec, - creatures: Creatures, dragon_fireballs: Vec, rockets: Vec, - remote: Option, + creatures: Creatures, dragon_fireballs: Vec, tridents: Vec, + rockets: Vec, remote: Option, potions: Potions, end: End, } impl Game { diff --git a/tools/ci/nightly.py b/tools/ci/nightly.py new file mode 100644 index 000000000..9a6dd8a3b --- /dev/null +++ b/tools/ci/nightly.py @@ -0,0 +1,283 @@ +#!/usr/bin/env python3 +"""The opt-in Nightly channel (.github/workflows/nightly-build.yml, docs/release-flow.md "Nightly"). + + nightly.py pick [--force] which commit tonight's nightly builds: GitHub outputs and nightly-notes.md + nightly.py rotate renames the current `nightly` pre-release to nightly-, frees the tag + nightly.py prune [--days 7] deletes the nightly- pre-releases and tags older than that, nothing else + +A nightly builds main plus the pull requests the trusted reviewers picked (the set: tools/ci/nightly_set.py), merged +in their order and pushed as nightly/build--. With no set it builds the newest union branch on origin +(`union/-`: main plus pull requests the contribution gate proved together), or main when no union is +newer than main's head. It is published as the `nightly` pre-release; the previous one stays a week as +nightly-. Runs from main's checkout with `gh`; it reads and merges the branches with git and never runs +anything from them. +""" +from __future__ import annotations + +import argparse +import datetime as dt +import json +import os +import re +import subprocess +import sys +from dataclasses import dataclass +from pathlib import Path + +if __package__: # imported as tools.ci.nightly (the tests) + from . import nightly_set as ns +else: # run as tools/ci/nightly.py: its folder is on the path + import nightly_set as ns + +DATED = re.compile(r"^nightly-(\d{4}-\d{2}-\d{2})$") +TITLE_DATE = re.compile(r"Nightly (\d{4}-\d{2}-\d{2})") + + +@dataclass +class Ref: + name: str + sha: str + date: dt.datetime # committer date + + +def git(*args: str) -> str: + return subprocess.run(["git", *args], check=True, capture_output=True, text=True).stdout.strip() + + +def gh(*args: str, check: bool = True) -> str: + out = subprocess.run(["gh", *args], capture_output=True, text=True) + if check and out.returncode != 0: + sys.exit(f"gh {' '.join(args)}: {out.stderr.strip()}") + return out.stdout.strip() if out.returncode == 0 else "" + + +def is_ancestor(a: str, b: str) -> bool: + return subprocess.run(["git", "merge-base", "--is-ancestor", a, b]).returncode == 0 + + +def choose(main: Ref, unions: list[Ref], contains=is_ancestor) -> Ref: + """The newest union whose head is newer than main's and holds something main lacks; else main.""" + for u in sorted(unions, key=lambda u: u.date, reverse=True): + if u.date <= main.date: + break + if not contains(u.sha, main.sha): + return u + return main + + +def refs(pattern: str) -> list[Ref]: + out = git("for-each-ref", "--format=%(refname:short) %(objectname) %(committerdate:iso-strict)", pattern) + return [Ref(n.removeprefix("origin/"), s, dt.datetime.fromisoformat(d)) + for n, s, d in (line.split(" ", 2) for line in out.splitlines())] + + +def output(**values: str) -> None: + with open(os.environ.get("GITHUB_OUTPUT", "/dev/stdout"), "a") as f: + for k, v in values.items(): + f.write(f"{k}={v}\n") + + +OPT_IN = ("**Opt-in, not a release.** A Nightly can include pull requests not reviewed yet, picked by trusted " + "reviewers: it may break. Turn it on in the launcher's settings; your release install and your worlds stay " + "as they are. Report bugs with the version the game shows (\"Nightly · \").") + + +def set_notes(today: str, chosen: Ref, main: Ref, prs: list[dict], left_out: list[str]) -> str: + """The notes of a build of main plus the reviewers' set.""" + lines = [f"Nightly {today} · {chosen.sha[:7]}: main ({main.sha[:7]}) with {len(prs)} pull requests merged in, " + f"built from `{chosen.name}` ({chosen.sha}).", "", OPT_IN, "", + f"### Pull requests in this Nightly ({len(prs)})", ""] + lines += [f"- {ns.plain(e['title'])} (#{e['number']}) by {e['author']}, at {e['head'][:7]}, picked by " + f"{e['asked_by']}" for e in prs] + if left_out: + lines += ["", f"### Left out ({len(left_out)})", ""] + [f"- {ns.plain(why)}" for why in left_out] + return "\n".join(lines) + "\n" + + +def notes(today: str, chosen: Ref, held: list[dict], left_out: list[str] | None = None) -> str: + lines = [f"Nightly {today} · {chosen.sha[:7]}: built from `{chosen.name}` ({chosen.sha}).", "", OPT_IN, ""] + if left_out: + lines += [f"The reviewers' set had nothing left to build: {'; '.join(ns.plain(w) for w in left_out)}.", ""] + if held: + lines += [f"### Not on main yet ({len(held)})", ""] + lines += [f"- {p['title']} (#{p['number']})" for p in held] + else: + lines += ["Everything in it is on main."] + return "\n".join(lines) + "\n" + + +def refresh(entries: list[dict], get, patterns: list[str]) -> tuple[list[dict], list[str]]: + """The scheduled nightly's set: each pull request at its newest head; merged, closed and refused ones out.""" + kept, left_out = [], [] + for e in entries: + pr = get(e["number"]) + if pr is not None and pr.state == "merged": + left_out.append(f"#{e['number']} {e['title']}: merged, so it's in main") + elif why := ns.check(pr, e["number"], patterns): + left_out.append(f"{why}: left out") + else: + kept.append({**e, "head": pr.head, "title": pr.title}) + return kept, left_out + + +def requested(spec: str, get) -> list[dict]: + """A dry run's set from its input: `2640@ 2642@`.""" + prs = [] + for word in spec.split(): + number, _, head = word.partition("@") + pr = get(int(number)) + prs.append({"number": int(number), "head": head or (pr.head if pr else ""), "title": pr.title if pr else "?", + "author": pr.author if pr else "?", "asked_by": "dry run"}) + return prs + + +def stop(repo: str, issue: str, text: str) -> None: + """Says why the build stopped, where it was asked for, and fails the job.""" + print(text) + if issue and repo: + ns.answer(repo, issue, text) + sys.exit(1) + + +def build_set(main: Ref, prs: list[dict], left_out: list[str], today: str, force: bool) -> None: + """main + the set, merged with git only (nightly_set.assemble), pushed as nightly/build--.""" + repo, issue = os.environ.get("GITHUB_REPOSITORY", ""), os.environ.get("NIGHTLY_ISSUE", "") + token, event = os.environ.get("GH_TOKEN", ""), os.environ.get("GITHUB_EVENT_NAME", "") + dry_run = os.environ.get("DRY_RUN") == "true" + patterns = ns.guarded_patterns(Path(ns.CODEOWNERS).read_text() if Path(ns.CODEOWNERS).exists() else "") + gone = set(ns.fetch_heads([(e["number"], e["head"]) for e in prs])) + kept = [] + for e in prs: + if e["number"] in gone: + left_out.append(f"#{e['number']} {e['title']}: its head {e['head'][:7]} is gone; ask for it again") + elif bad := [f for f in ns.changed_files(main.sha, e["head"]) if ns.guarded(f, patterns)]: + left_out.append(f"#{e['number']} {e['title']}: changes `{bad[0]}`, which only Ludovic merges") + else: + kept.append(e) + if not kept: + return build_union(main, today, force, left_out) + try: + sha = ns.assemble(main.sha, [(e["number"], e["head"]) for e in kept]) + except ns.Conflict as c: + state, _, _ = ns.load_state() + asked_in = issue or next((x["issue"] for x in reversed(state.get("log", [])) if x.get("issue")), "") + stop(repo, asked_in, f"the build stopped: {c.text()}") + previous = git("ls-remote", "--tags", "origin", "refs/tags/nightly").split("\t")[0] or None + build = force or previous != sha + name = "(unchanged)" + if build: + done = ns.builds_today(today) + if len(done) >= ns.MAX_BUILDS_PER_DAY and event != "schedule": + stop(repo, issue, f"{len(done)} Nightly builds today already, the most a day takes: the next scheduled " + "one (20:17 UTC) builds the set.") + name = ns.next_build(today, done) + if not ns.push(sha, name, token): + stop(repo, issue, f"could not push {name}") + record = {"ref": name, "sha": sha, "main": main.sha, "at": dt.datetime.now(dt.timezone.utc).isoformat( + timespec="seconds"), "event": event, "dry_run": dry_run, "run": os.environ.get("GITHUB_RUN_ID", ""), + "prs": [{k: e[k] for k in ("number", "head", "title", "author", "asked_by")} for e in kept], + "left_out": left_out} + ns.update_state(lambda st, builds: (st, builds + json.dumps(record) + "\n", f"build {name}"), token) + chosen = Ref(name, sha, dt.datetime.now(dt.timezone.utc)) + with open("nightly-notes.md", "w") as f: + f.write(set_notes(today, chosen, main, kept, left_out)) + output(build=str(build).lower(), sha=sha, short=sha[:7], source=name, date=today, version=f"nightly-{today}", + nightly=f"{today} {sha[:7]}") + print(f"{'build' if build else 'skip (unchanged since the last nightly)'}: {name} {sha}, main {main.sha[:7]} + " + + ", ".join(f"#{e['number']}" for e in kept)) + + +def pick(force: bool) -> None: + git("fetch", "--quiet", "origin", "+refs/heads/main:refs/remotes/origin/main", + "+refs/heads/union/*:refs/remotes/origin/union/*") + main = refs("refs/remotes/origin/main")[0] + today = dt.datetime.now(dt.timezone.utc).date().isoformat() + repo, token = os.environ.get("GITHUB_REPOSITORY", ""), os.environ.get("GH_TOKEN", "") + if spec := os.environ.get("NIGHTLY_PRS", "").strip(): # a dry run's own set; the saved one stays + return build_set(main, requested(spec, ns.lookup(repo)), [], today, force) + state, _, _ = ns.load_state() + prs, left_out = state.get("prs", []), [] + if prs and os.environ.get("GITHUB_EVENT_NAME") == "schedule": + patterns = ns.guarded_patterns(Path(ns.CODEOWNERS).read_text() if Path(ns.CODEOWNERS).exists() else "") + get = ns.lookup(repo) + + def fresh(st: dict, builds: str): + kept, out = refresh(st.get("prs", []), get, patterns) + left_out[:] = out + if kept == st.get("prs", []): + return None + return {**st, "prs": kept}, builds, "the scheduled nightly takes the newest heads" + prs = ns.update_state(fresh, token).get("prs", []) + if prs: + return build_set(main, prs, left_out, today, force) + build_union(main, today, force, left_out) + + +def build_union(main: Ref, today: str, force: bool, left_out: list[str] | None = None) -> None: + """No set: the newest proven union, or main.""" + chosen = choose(main, refs("refs/remotes/origin/union/")) + previous = git("ls-remote", "--tags", "origin", "refs/tags/nightly").split("\t")[0] or None + build = force or previous != chosen.sha + # The open pull requests this build holds beyond main: their heads are in it and not in main. + prs = json.loads(gh("pr", "list", "--state", "open", "--limit", "400", "--json", "number,title,headRefOid")) + held = [] + for pr in prs: + oid = pr["headRefOid"] + if subprocess.run(["git", "cat-file", "-e", oid], capture_output=True).returncode != 0: + continue # a fork's head that no fetched branch holds + if is_ancestor(oid, chosen.sha) and not is_ancestor(oid, main.sha): + held.append(pr) + held.sort(key=lambda p: p["number"]) + with open("nightly-notes.md", "w") as f: + f.write(notes(today, chosen, held, left_out)) + output(build=str(build).lower(), sha=chosen.sha, short=chosen.sha[:7], source=chosen.name, date=today, + version=f"nightly-{today}", nightly=f"{today} {chosen.sha[:7]}") + print(f"{'build' if build else 'skip (unchanged since the last nightly)'}: {chosen.name} {chosen.sha}, " + f"{len(held)} open pull requests beyond main") + + +def rotate() -> None: + """The current `nightly` becomes nightly-, so tonight's can take the tag.""" + current = gh("release", "view", "nightly", "--json", "name", check=False) + if not current: + return + m = TITLE_DATE.search(json.loads(current)["name"]) + dated = f"nightly-{m.group(1)}" if m else f"nightly-{dt.date.today() - dt.timedelta(days=1)}" + if gh("release", "view", dated, "--json", "tagName", check=False): + gh("release", "delete", dated, "--cleanup-tag", "--yes") # a second nightly the same day replaces the first + gh("release", "edit", "nightly", "--tag", dated) + gh("api", "-X", "DELETE", f"repos/{os.environ['GITHUB_REPOSITORY']}/git/refs/tags/nightly", check=False) + print(f"nightly -> {dated}") + + +def stale(tags: list[dict], today: dt.date, days: int) -> list[str]: + """The dated nightly pre-releases older than `days`: never a release, never `nightly` itself.""" + cutoff = today - dt.timedelta(days=days) + return [r["tagName"] for r in tags if r["isPrerelease"] and (m := DATED.match(r["tagName"])) + and dt.date.fromisoformat(m.group(1)) < cutoff] + + +def prune(days: int) -> None: + tags = json.loads(gh("release", "list", "--limit", "200", "--json", "tagName,isPrerelease")) + for tag in stale(tags, dt.datetime.now(dt.timezone.utc).date(), days): + gh("release", "delete", tag, "--cleanup-tag", "--yes") + print(f"deleted {tag}") + + +def main() -> None: + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + sub = ap.add_subparsers(dest="cmd", required=True) + sub.add_parser("pick").add_argument("--force", action="store_true") + sub.add_parser("rotate") + sub.add_parser("prune").add_argument("--days", type=int, default=7) + args = ap.parse_args() + if args.cmd == "pick": + pick(args.force) + elif args.cmd == "rotate": + rotate() + else: + prune(args.days) + + +if __name__ == "__main__": + main() diff --git a/tools/ci/nightly_set.py b/tools/ci/nightly_set.py new file mode 100644 index 000000000..a192993d4 --- /dev/null +++ b/tools/ci/nightly_set.py @@ -0,0 +1,528 @@ +#!/usr/bin/env python3 +"""Trusted reviewers pick the pull requests a Nightly holds (docs/release-flow.md "Nightly channel"). + + nightly_set.py command one `/nightly …` comment (nightly-command.yml): checks who asked, updates the set, + starts the build and answers in the thread + +A comment by Ludovic or by a login in .github/nightly-reviewers.txt, on any issue or pull request: + + /nightly 2640 2642 the set becomes these pull requests, merged onto main in this order; builds now + /nightly add 2650 adds one, or takes its newest head again; builds now + /nightly remove 2640 drops one; builds now. Ludovic's remove also keeps reviewers from adding it back + /nightly clear empties the set: the Nightly is the proven union or main again; builds now + /nightly status what the set holds + /nightly dry-run 2640 builds main + these and signs with a throwaway key; publishes nothing, the set stays + +The set (set.json on the nightly-state branch) keeps each pull request at the head it had when someone asked for +it; the scheduled nightly takes their newest heads and drops the merged and closed ones (nightly.py pick). +builds.jsonl there records every build's set, for the stats. Nothing here runs a pull request's code: its commits +are fetched and merged with `git merge-tree --write-tree`, which writes git objects and never a working tree, so no +file of theirs reaches the disk and no hook, filter or script of theirs runs. +""" +from __future__ import annotations + +import copy +import datetime as dt +import json +import os +import re +import subprocess +import sys +import tempfile +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import Callable + +OWNER = "ludovic111" +REVIEWERS = ".github/nightly-reviewers.txt" +CODEOWNERS = ".github/CODEOWNERS" +# What CODEOWNERS guards today, refused even if the file moved: what builds, signs and checks releases. +ALWAYS_GUARDED = ["/.github/", "/tools/ci/", "/crates/horizon-release-sign/", "/crates/horizon-server/src/update.rs", + "/launcher/src/backend.rs", "/launcher/links.json"] +STATE_BRANCH = "nightly-state" +BUILD_PREFIX = "nightly/build-" +MAX_PRS = 30 +MAX_BUILDS_PER_DAY = 6 +BOT = ("github-actions[bot]", "41898283+github-actions[bot]@users.noreply.github.com") +# Git never runs anything of the merged commits; these make sure nothing of the runner's either. +SAFE_GIT = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "-c", "merge.renormalize=false"] +NUMBER = re.compile(r"^#?(\d{1,6}),?$") +LOGIN = re.compile(r"^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$") +VERBS = ("add", "remove", "clear", "status", "dry-run") +USAGE = ("Use `/nightly 2640 2642`, `/nightly add 2650`, `/nightly remove 2640`, `/nightly clear`, " + "`/nightly status` or `/nightly dry-run 2640`.") + + +class Refused(Exception): + """A command that changes nothing; its text is the answer.""" + + +@dataclass +class Command: + verb: str # set, add, remove, clear, status, dry-run + prs: list[int] = field(default_factory=list) + + def text(self) -> str: + words = ["/nightly"] + ([] if self.verb == "set" else [self.verb]) + [str(n) for n in self.prs] + return " ".join(words) + + +def safe(word: str) -> str: + """A word of a comment, fit to quote back: no markdown, no mentions.""" + return re.sub(r"[^\w#:.-]", "", word)[:40] or "?" + + +def parse(body: str) -> Command | None: + """The command on a comment's first line; None when it isn't one. Raises Refused when it is one, but wrong.""" + line = next((line.strip() for line in body.splitlines() if line.strip()), "") + words = line.split() + if not words or words[0].lower() != "/nightly": + return None + rest = words[1:] + verb = "status" if not rest else "set" + if rest and rest[0].lower() in VERBS: + verb = rest.pop(0).lower() + prs: list[int] = [] + for word in rest: + m = NUMBER.match(word) + if not m: + raise Refused(f"`{safe(word)}` isn't a pull request number. {USAGE}") + if (n := int(m.group(1))) not in prs: + prs.append(n) + if verb in ("clear", "status") and prs: + raise Refused(f"`/nightly {verb}` takes no numbers. {USAGE}") + if verb not in ("clear", "status") and not prs: + raise Refused(f"`/nightly {'' if verb == 'set' else verb + ' '}` needs pull request numbers. {USAGE}") + if len(prs) > MAX_PRS: + raise Refused(f"A Nightly holds at most {MAX_PRS} pull requests; that's {len(prs)}.") + return Command(verb, prs) + + +@dataclass +class Reviewers: + logins: set[str] # lowercase + paused: bool + + +def read_reviewers(text: str) -> Reviewers: + """The list file: one login per line, `#` comments, and a `paused` line that stops every reviewer.""" + logins, paused = set(), False + for raw in text.splitlines(): + line = raw.split("#", 1)[0].strip() + if not line: + continue + words = line.split() + if len(words) != 1: # not a login: ignored rather than half-read + continue + word = words[0] + if word.lower() == "paused": + paused = True + elif LOGIN.match(word): + logins.add(word.lower()) + return Reviewers(logins, paused) + + +def is_owner(login: str) -> bool: + return login.lower() == OWNER + + +def authorize(login: str, reviewers: Reviewers) -> None: + """Ludovic always; a listed reviewer unless the list is paused; nobody else.""" + if is_owner(login): + return + if login.lower() not in reviewers.logins: + raise Refused(f"Only Ludovic and the trusted reviewers listed in `{REVIEWERS}` can pick the Nightly.") + if reviewers.paused: + raise Refused(f"`/nightly` is paused: Ludovic stopped it in `{REVIEWERS}`.") + + +def guarded_patterns(codeowners: str) -> list[str]: + """The paths CODEOWNERS gives to Ludovic, plus ALWAYS_GUARDED.""" + found = [line.split()[0] for line in codeowners.splitlines() if line.strip().startswith("/")] + return sorted(set(found + ALWAYS_GUARDED)) + + +def guarded(path: str, patterns: list[str]) -> bool: + p = "/" + path.lstrip("/") + return any(p.startswith(pat) if pat.endswith("/") else p == pat for pat in patterns) + + +@dataclass +class PullRequest: + number: int + state: str # open, closed, merged + head: str + title: str + author: str + base: str + files: list[str] + + +def check(pr: PullRequest | None, number: int, patterns: list[str]) -> str | None: + """Why `pr` can't go in a Nightly, or None.""" + if pr is None: + return f"#{number} isn't a pull request here" + if pr.state != "open": + return f"#{number} is {pr.state}" + if pr.base != "main": + return f"#{number} targets `{safe(pr.base)}`, not main" + bad = [f for f in pr.files if guarded(f, patterns)] + if bad: + more = f" and {len(bad) - 1} more" if len(bad) > 1 else "" + return f"#{number} changes `{bad[0]}`{more}, which only Ludovic merges (CODEOWNERS)" + return None + + +def entry(pr: PullRequest, asked_by: str, now: str) -> dict: + return {"number": pr.number, "head": pr.head, "title": pr.title, "author": pr.author, "asked_by": asked_by, + "asked_at": now} + + +@dataclass +class Result: + state: dict + answer: str + build: bool + dry_run: list[dict] | None = None # the set a dry run builds; the saved set stays + + +def plain(text: str) -> str: + """A title fit for a comment or the notes: no mention, no markdown that spans lines.""" + return text.replace("@", "@\u200b").replace("\n", " ").strip()[:200] + + +def describe(prs: list[dict], heading: str = "The set") -> str: + if not prs: + return "The set is empty: the Nightly is the newest proven union, or main." + lines = [f"{heading} ({len(prs)}), merged onto main in this order:"] + lines += [f"- #{e['number']} {plain(e['title'])} (by {e['author']}, at {e['head'][:7]}, asked by " + f"{e['asked_by']})" for e in prs] + return "\n".join(lines) + + +def apply(state: dict, cmd: Command, login: str, now: str, lookup: Callable[[int], PullRequest | None], + patterns: list[str]) -> Result: + """What `cmd` by `login` makes of `state` (set.json). Pure but for `lookup`; raises Refused.""" + st = copy.deepcopy(state) + prs: list[dict] = st.setdefault("prs", []) + blocked: list[int] = st.setdefault("blocked", []) + owner = is_owner(login) + if cmd.verb == "status": + extra = f"\nOnly Ludovic can add these back: {', '.join(f'#{n}' for n in blocked)}." if blocked else "" + return Result(state, describe(prs) + extra, False) + if cmd.verb == "clear": + st["prs"] = [] + elif cmd.verb == "remove": + absent = [n for n in cmd.prs if n not in [e["number"] for e in prs]] + if absent and len(absent) == len(cmd.prs) and not owner: + raise Refused(f"{', '.join(f'#{n}' for n in absent)} isn't in the set. " + describe(prs)) + st["prs"] = [e for e in prs if e["number"] not in cmd.prs] + if owner: + st["blocked"] = blocked + [n for n in cmd.prs if n not in blocked] + else: # set, add, dry-run + if not owner and (held := [n for n in cmd.prs if n in blocked]): + raise Refused(f"Ludovic took {', '.join(f'#{n}' for n in held)} out of the Nightly; only he can put " + "it back.") + problems, asked = [], [] + for n in cmd.prs: + pr = lookup(n) + if why := check(pr, n, patterns): + problems.append(why) + else: + asked.append(entry(pr, login, now)) + if problems: + raise Refused("Nothing changed: " + "; ".join(problems) + ".") + if cmd.verb == "add": + fresh = {e["number"]: e for e in asked} + new = [fresh.pop(e["number"], e) for e in prs] + list(fresh.values()) # keeps its place, newest head + else: + new = asked + if len(new) > MAX_PRS: + raise Refused(f"A Nightly holds at most {MAX_PRS} pull requests; that would be {len(new)}.") + if cmd.verb == "dry-run": + return Result(state, describe(new, "Dry run, the saved set stays as it is. It builds"), True, + dry_run=new) + if owner: + st["blocked"] = [n for n in blocked if n not in cmd.prs] + st["prs"] = new + return Result(st, describe(st["prs"]), True) + + +def log_command(state: dict, cmd: Command, login: str, now: str, issue: str, url: str) -> dict: + st = copy.deepcopy(state) + st["log"] = (st.get("log", []) + [{"at": now, "by": login, "command": cmd.text(), "issue": issue, + "url": url}])[-50:] + return st + + +# --- git ------------------------------------------------------------------------------------------------------- + + +def git(*args: str, cwd: str | None = None, env: dict | None = None, check: bool = True, + input: str | None = None) -> subprocess.CompletedProcess: + return subprocess.run(["git", *SAFE_GIT, *args], cwd=cwd, env={**os.environ, **(env or {})}, check=check, + capture_output=True, text=True, input=input) + + +def out(*args: str, cwd: str | None = None, env: dict | None = None) -> str: + return git(*args, cwd=cwd, env=env).stdout.strip() + + +def identity(date: str) -> dict: + """The bot's name, and a fixed date so the same inputs give the same commit.""" + name, email = BOT + return {"GIT_AUTHOR_NAME": name, "GIT_AUTHOR_EMAIL": email, "GIT_COMMITTER_NAME": name, + "GIT_COMMITTER_EMAIL": email, "GIT_AUTHOR_DATE": date, "GIT_COMMITTER_DATE": date} + + +def merge_tree(a: str, b: str, cwd: str | None = None) -> tuple[str | None, list[str]]: + """The merged tree of commits a and b, or None and the conflicted paths. Objects only, no working tree.""" + r = git("merge-tree", "--write-tree", "--name-only", "--no-messages", a, b, cwd=cwd, check=False) + if r.returncode == 0: + return r.stdout.split()[0], [] + if r.returncode == 1: + return None, [line for line in r.stdout.splitlines()[1:] if line.strip()] + raise RuntimeError(f"git merge-tree {a[:9]} {b[:9]}: {r.stderr.strip()}") + + +def commit_tree(tree: str, parents: list[str], message: str, date: str, cwd: str | None = None) -> str: + args = ["commit-tree", tree] + for p in parents: + args += ["-p", p] + return out(*args, "-m", message, cwd=cwd, env=identity(date)) + + +@dataclass +class Conflict(Exception): + number: int + other: int | None # the earlier pull request it conflicts with; None: main; 0: only with several together + files: list[str] + + def text(self) -> str: + where = ", ".join(f"`{f}`" for f in self.files[:8]) + (" and more" if len(self.files) > 8 else "") + if self.other is None: + return (f"#{self.number} conflicts with main in {where}: it needs main merged into it first.") + if self.other == 0: + return (f"#{self.number} conflicts with the pull requests before it, taken together, in {where}.") + return (f"#{self.other} and #{self.number} conflict in {where}. Make an integration pull request that " + "combines them (in your fork) and pick that one instead.") + + +def changed_files(base: str, head: str, cwd: str | None = None) -> list[str]: + """What `head` changes since it left `base`, renames' old paths included.""" + since = out("merge-base", base, head, cwd=cwd) + names = out("diff", "--name-status", "--no-renames", since, head, cwd=cwd) + return [line.split("\t", 1)[1] for line in names.splitlines() if "\t" in line] + + +def culprit(main: str, earlier: list[tuple[int, str]], head: str, date: str, cwd: str | None) -> int | None: + if merge_tree(main, head, cwd)[0] is None: + return None + for n, h in earlier: + tree, _ = merge_tree(main, h, cwd) + if tree is None: + continue + if merge_tree(commit_tree(tree, [main, h], "probe", date, cwd), head, cwd)[0] is None: + return n + return 0 + + +def assemble(main: str, heads: list[tuple[int, str]], cwd: str | None = None) -> str: + """main, then each pull request's head merged in order: the commit a Nightly builds. Raises Conflict.""" + date = out("show", "-s", "--format=%cI", main, cwd=cwd) + current = main + for i, (n, head) in enumerate(heads): + tree, files = merge_tree(current, head, cwd) + if tree is None: + raise Conflict(n, culprit(main, heads[:i], head, date, cwd), files) + current = commit_tree(tree, [current, head], f"Nightly: merge #{n} at {head[:12]}", date, cwd) + return current + + +def fetch_heads(heads: list[tuple[int, str]], cwd: str | None = None) -> list[int]: + """Fetches each head from origin; returns the numbers whose head is gone (force-pushed away and collected).""" + shas = [h for _, h in heads] + if shas and git("fetch", "--quiet", "--no-tags", "origin", *shas, cwd=cwd, check=False).returncode == 0: + return [] + gone = [] + for n, h in heads: + if git("cat-file", "-e", f"{h}^{{commit}}", cwd=cwd, check=False).returncode == 0: + continue + git("fetch", "--quiet", "--no-tags", "origin", h, cwd=cwd, check=False) + if git("cat-file", "-e", f"{h}^{{commit}}", cwd=cwd, check=False).returncode != 0: + gone.append(n) + return gone + + +def auth(token: str) -> list[str]: + """A `git -c` for pushing with the job's token, never written to a file or a log.""" + import base64 + basic = base64.b64encode(f"x-access-token:{token}".encode()).decode() + os.environ.setdefault("GIT_TERMINAL_PROMPT", "0") + return ["-c", f"http.https://github.com/.extraheader=AUTHORIZATION: basic {basic}"] + + +def push(sha: str, ref: str, token: str, cwd: str | None = None, force: bool = False) -> bool: + spec = f"{'+' if force else ''}{sha}:refs/heads/{ref}" + return git(*auth(token), "push", "--quiet", "--no-verify", "origin", spec, cwd=cwd, check=False).returncode == 0 + + +def builds_today(today: str, cwd: str | None = None) -> list[str]: + listed = out("ls-remote", "origin", f"refs/heads/{BUILD_PREFIX}{today}-*", cwd=cwd) + return [line.split("refs/heads/", 1)[1] for line in listed.splitlines() if "refs/heads/" in line] + + +def next_build(today: str, existing: list[str]) -> str: + taken = [int(m.group(1)) for b in existing if (m := re.search(r"-(\d+)$", b))] + return f"{BUILD_PREFIX}{today}-{max(taken, default=0) + 1}" + + +# --- the state branch ------------------------------------------------------------------------------------------ + + +def load_state(cwd: str | None = None) -> tuple[dict, str, str | None]: + """set.json, builds.jsonl and the branch's head (None before the first command).""" + if git("fetch", "--quiet", "--no-tags", "origin", f"+refs/heads/{STATE_BRANCH}:refs/nightly/state", cwd=cwd, + check=False).returncode != 0: + return {}, "", None + head = out("rev-parse", "refs/nightly/state", cwd=cwd) + state = json.loads(git("show", f"{head}:set.json", cwd=cwd, check=False).stdout or "{}") + builds = git("show", f"{head}:builds.jsonl", cwd=cwd, check=False).stdout + return state, builds, head + + +def write_state(state: dict, builds: str, parent: str | None, message: str, cwd: str | None = None) -> str: + """A commit of the state branch, made in a private index: the checkout isn't touched.""" + with tempfile.TemporaryDirectory() as tmp: + env = {"GIT_INDEX_FILE": str(Path(tmp) / "index")} + for name, text in (("set.json", json.dumps(state, indent=2) + "\n"), ("builds.jsonl", builds), + ("README.md", STATE_README)): + blob = git("hash-object", "-w", "--stdin", cwd=cwd, input=text).stdout.strip() + git("update-index", "--add", "--cacheinfo", f"100644,{blob},{name}", cwd=cwd, env=env) + tree = out("write-tree", cwd=cwd, env=env) + now = dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds") + return commit_tree(tree, [parent] if parent else [], message, now, cwd) + + +STATE_README = """# nightly-state + +Written by tools/ci/nightly_set.py and tools/ci/nightly.py, never by hand. `set.json`: the pull requests the trusted +reviewers picked for the Nightly (docs/release-flow.md "Nightly channel"), each at the head it was asked at. +`builds.jsonl`: one line per Nightly build with its set. +""" + + +def update_state(change: Callable[[dict, str], tuple[dict, str, str] | None], token: str, + cwd: str | None = None, tries: int = 5): + """Applies change(state, builds) -> (state, builds, message), or None for no change, and pushes it; when another + run pushed first, reads the branch again and applies it again. Returns the last state.""" + for _ in range(tries): + state, builds, head = load_state(cwd) + changed = change(state, builds) + if changed is None: + return state + new, new_builds, message = changed + if push(write_state(new, new_builds, head, message, cwd), STATE_BRANCH, token, cwd): + return new + time.sleep(2) + raise RuntimeError(f"could not update {STATE_BRANCH} after {tries} tries") + + +# --- GitHub ---------------------------------------------------------------------------------------------------- + + +def gh(*args: str, check: bool = True) -> str: + r = subprocess.run(["gh", *args], capture_output=True, text=True) + if check and r.returncode != 0: + raise RuntimeError(f"gh {args[0]} {args[1] if len(args) > 1 else ''}: {r.stderr.strip()[:300]}") + return r.stdout.strip() if r.returncode == 0 else "" + + +def lookup(repo: str) -> Callable[[int], PullRequest | None]: + def get(n: int) -> PullRequest | None: + raw = gh("api", f"repos/{repo}/pulls/{n}", check=False) + if not raw: + return None + p = json.loads(raw) + files = gh("api", "--paginate", f"repos/{repo}/pulls/{n}/files", "--jq", + ".[] | .filename, (.previous_filename // empty)").splitlines() + state = "merged" if p.get("merged_at") else p["state"] + return PullRequest(n, state, p["head"]["sha"], p["title"], p["user"]["login"], p["base"]["ref"], files) + return get + + +def answer(repo: str, issue: str, text: str) -> None: + gh("api", f"repos/{repo}/issues/{issue}/comments", "-f", f"body=🤖 Nightly: {text}") + + +def dispatch(repo: str, issue: str, request: str, dry_run: list[dict] | None) -> str: + """Starts `nightly build` for this request; returns its run's URL once GitHub lists it.""" + args = ["workflow", "run", "nightly-build.yml", "--repo", repo, "--ref", "main", "-f", f"issue={issue}", + "-f", f"request={request}", "-f", "force=true"] + if dry_run is not None: + args += ["-f", "dry_run=true", "-f", "prs=" + " ".join(f"{e['number']}@{e['head']}" for e in dry_run)] + gh(*args) + for _ in range(15): + time.sleep(4) + runs = json.loads(gh("run", "list", "--repo", repo, "--workflow", "nightly-build.yml", "--event", + "workflow_dispatch", "--limit", "20", "--json", "displayTitle,url", check=False) or "[]") + for r in runs: + if request in r["displayTitle"]: + return r["url"] + return f"https://github.com/{repo}/actions/workflows/nightly-build.yml" + + +def command() -> None: + """nightly-command.yml: the comment arrives in env vars, never in a shell line.""" + repo, issue = os.environ["GITHUB_REPOSITORY"], os.environ["ISSUE"] + login, body, url = os.environ["AUTHOR"], os.environ.get("BODY", ""), os.environ.get("COMMENT_URL", "") + token = os.environ["GH_TOKEN"] + try: + cmd = parse(body) + except Refused as e: + answer(repo, issue, str(e)) + return + if cmd is None: + return + now = dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds") + try: + reviewers = Path(REVIEWERS).read_text() if Path(REVIEWERS).exists() else "" + authorize(login, read_reviewers(reviewers)) + patterns = guarded_patterns(Path(CODEOWNERS).read_text() if Path(CODEOWNERS).exists() else "") + if cmd.verb != "status": + today = now[:10] + done = builds_today(today) + if len(done) >= MAX_BUILDS_PER_DAY: + raise Refused(f"{len(done)} Nightly builds today already, the most a day takes: the next scheduled " + "one (20:17 UTC) builds the set.") + results: list[Result] = [] + + def change(state: dict, builds: str): + result = apply(state, cmd, login, now, lookup(repo), patterns) + results.append(result) + if result.state is state: # status, dry run: nothing to save + return None + return log_command(result.state, cmd, login, now, issue, url), builds, f"{cmd.text()} by {login}" + + update_state(change, token) + result = results[-1] + except Refused as e: + answer(repo, issue, str(e)) + return + text = result.answer + if result.build: + run = dispatch(repo, issue, f"{issue}-{int(time.time())}", result.dry_run) + text += f"\n\nBuilding: {run}. I'll answer here when it's {'done' if result.dry_run else 'published'}." + answer(repo, issue, text) + + +def main() -> None: + if sys.argv[1:] == ["command"]: + command() + else: + sys.exit(__doc__) + + +if __name__ == "__main__": + main() diff --git a/tools/ci/runner-env.sh b/tools/ci/runner-env.sh index 14e9e6762..189bba980 100755 --- a/tools/ci/runner-env.sh +++ b/tools/ci/runner-env.sh @@ -15,7 +15,8 @@ if [ "$(uname)" = Darwin ]; then echo "JAVA_HOME=$java_home" >> "$GITHUB_ENV" # Builds go through the machine's sccache (shared with ~/fleet/rbuild), so the build folders runner-gc.sh # removes come back from the cache instead of compiling cold. - if [ -x /opt/homebrew/bin/sccache ]; then + # Not for a release (HORIZON_NO_SCCACHE=1, game-build.yml's trusted builds): pull requests' jobs write that cache. + if [ -x /opt/homebrew/bin/sccache ] && [ -z "${HORIZON_NO_SCCACHE:-}" ]; then { echo "RUSTC_WRAPPER=/opt/homebrew/bin/sccache"; echo "CARGO_INCREMENTAL=0"; } >> "$GITHUB_ENV" fi else @@ -40,7 +41,7 @@ else [ -n "$java_home" ] || { echo "::error::no JDK $java_major on this runner"; exit 1; } { echo "$bin"; echo "$java_home/bin"; } >> "$GITHUB_PATH" echo "JAVA_HOME=$java_home" >> "$GITHUB_ENV" - if sccache=$(command -v sccache); then + if [ -z "${HORIZON_NO_SCCACHE:-}" ] && sccache=$(command -v sccache); then { echo "RUSTC_WRAPPER=$sccache"; echo "CARGO_INCREMENTAL=0"; } >> "$GITHUB_ENV" fi fi diff --git a/tools/parity.py b/tools/parity.py index 38d113cab..f8f48fbcf 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -1454,11 +1454,13 @@ def affected_harnesses(found, records, changed, reach=True, base=None): return affected -def platform_skips(config): - """Harnesses tools/parity_hosts.json marks as giving different results on this platform: {name: reason}.""" - if sys.platform == "linux": - return {} - return dict(config.get("linux_only", {})) +def platform_skips(config, host=None): + """Harnesses tools/parity_hosts.json marks as giving different results on this platform, and those this host's + entry excludes (playhorizon's CI runner runs its own pull request jobs here, not only workers sent to it): + {name: reason}.""" + skips = {} if sys.platform == "linux" else dict(config.get("linux_only", {})) + skips.update(config.get("hosts", {}).get(HOST if host is None else host, {}).get("exclude", {})) + return skips def known_flaky(config): @@ -1593,7 +1595,7 @@ def main(): chosen = [name for name in found if stale(name, state, hasher, environment)] skips = platform_skips(host_config()) for name in [name for name in chosen if base_name(name) in skips and not args.names]: - print(f"skipped on {sys.platform}: {name}: {skips[base_name(name)]}", flush=True) + print(f"skipped on {HOST} ({sys.platform}): {name}: {skips[base_name(name)]}", flush=True) chosen.remove(name) manual = {} if args.names or args.all else named_only(host_config()) for name in [name for name in chosen if base_name(name) in manual]: diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json index cec022194..2df32ba41 100644 --- a/tools/parity_hosts.json +++ b/tools/parity_hosts.json @@ -31,7 +31,9 @@ "exclude": { "mob_ai": "the vanilla oracle runs out of its 3 GB heap here (OutOfMemoryError in IO workers; passes on the desktop and the Mac) - 2026-10-26 trial", "lan_integration": "two clients rendered on the CPU (lavapipe): different timing subtests fail on each run (elytra, consume-release, barter, critical-hits) - 2026-10-26 trial", - "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial" + "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial", + "remote_fireball": "fails here even alone, at bare main 3b19c386c (2 of 2 runs and the retry), and passes on the Mac mini: the guest's egg is seen in 2 of 6 samples. CPU-starved: the whole horizon-ci slice (runner on 4-7, workers on 0-3) shares a 700% quota and was throttled in 27% of periods, so lavapipe frames and screenshots outlast the projectile's flight - 2026-10-27", + "remote_fireworks": "fails here even alone, at bare main 3b19c386c (2 of 2 runs and the retry), and passes on the Mac mini: the guest's sparks are gone by its trail screenshot (same CPU starvation as remote_fireball; a private Xvfb on CPUs 0-3 did not help) - 2026-10-27" }, "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), its CI runner has CPUs 4-7, so workers get 0-3 (as tools/remote.sh runs do) and 3 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)" } diff --git a/tools/test_entity_death_loot_parity.py b/tools/test_entity_death_loot_parity.py index 2bb53ebbb..39aa6edda 100644 --- a/tools/test_entity_death_loot_parity.py +++ b/tools/test_entity_death_loot_parity.py @@ -31,7 +31,7 @@ SKIPPED = {'player', 'mannequin', 'armor_stand', 'ender_dragon', 'giant'} # Types Horizon keeps body armour for in the head slot: their corpus wears # body items instead of helmets. BODY = {'horse', 'donkey', 'mule', 'skeleton_horse', 'zombie_horse', 'camel', 'camel_husk', 'llama', 'trader_llama', - 'happy_ghast', 'nautilus', 'zombie_nautilus', 'sulfur_cube'} + 'happy_ghast', 'nautilus', 'zombie_nautilus', 'sulfur_cube', 'wolf'} WEAPONS = ['minecraft:iron_sword', 'minecraft:diamond_sword;looting:1', 'minecraft:diamond_sword;looting:2', 'minecraft:netherite_sword;looting:3', 'minecraft:golden_sword;fire_aspect:2', 'minecraft:diamond_axe;looting:3;fire_aspect:1'] ARMOUR = {'head': 'minecraft:iron_helmet', 'chest': 'minecraft:chainmail_chestplate', 'legs': 'minecraft:golden_leggings',