diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 60bbbf057..1ea2db6fa 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -8,7 +8,7 @@ name: nightly audit # gh workflow run "nightly audit" -f dry_run=true # the audit, without touching issues on: schedule: - # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:00 in Paris. + # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:07 in Paris today. - cron: '7 1 * * *' - cron: '7 2 * * *' workflow_dispatch: @@ -31,14 +31,19 @@ jobs: audit: # The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform. runs-on: [self-hosted, horizon-game, macOS] - timeout-minutes: 150 + timeout-minutes: 240 # every harness (~80 min) plus lan_integration (~40 min an attempt under load, retried) steps: - - name: 03:00 in Paris + - name: 03:07 in Paris id: when + env: + SCHEDULE: ${{ github.event.schedule }} run: | - hour=$(TZ=Europe/Paris date +%H) - if [[ "${{ github.event_name }}" == schedule && "$hour" != 03 ]]; then - echo "It is ${hour}:00 in Paris: the other schedule runs the audit." + # Which cron is 03:07 in Paris, from Paris's offset today: GitHub can start a schedule hours late, so the + # clock at start time can't tell (on 2026-10-26 both started after 04:00 Paris and both skipped). + offset=$(TZ=Europe/Paris date +%z) + ours=$([ "$offset" = +0200 ] && echo '7 1 * * *' || echo '7 2 * * *') + if [[ "${{ github.event_name }}" == schedule && "$SCHEDULE" != "$ours" ]]; then + echo "Paris is at UTC${offset} today: the '$ours' schedule runs the audit." echo "run=false" >> "$GITHUB_OUTPUT" else echo "run=true" >> "$GITHUB_OUTPUT" @@ -66,7 +71,8 @@ jobs: run: | echo "since=$(date +%Y-%m-%dT%H:%M:%S)" >> "$GITHUB_OUTPUT" set +e - python3 tools/parity.py --all --timeout 1800 2>&1 | tee "$RUNNER_TEMP/audit.log" + # lan_integration (the whole lan_e2e suite) takes ~2,400 s under load, past the usual 1,800. + python3 tools/parity.py --all --timeout 3000 2>&1 | tee "$RUNNER_TEMP/audit.log" echo "exit=${PIPESTATUS[0]}" >> "$GITHUB_OUTPUT" { echo '```'; tail -40 "$RUNNER_TEMP/audit.log"; echo '```'; } >> "$GITHUB_STEP_SUMMARY" - name: Issues for the harnesses that regressed diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml index 13be3c36d..c47005ab0 100644 --- a/.github/workflows/parity-main.yml +++ b/.github/workflows/parity-main.yml @@ -23,10 +23,10 @@ env: jobs: parity-main: - # The Mac mini's release runner (label added 2026-10-26), not the two `horizon-game` runners: behind PR parity jobs - # this run waited 2 h while every merge replaced the pending one, and releases wait for it. Releases need it green - # first, so the two never compete. Not the desktop: a job slowed down because the maintainer came back could time - # out, and a failure here bisects and comments on merges. + # A Mac mini runner of its own (ludovics-mac-mini-2 holds only this label since 2026-10-26): behind PR parity jobs + # this run waited 2 h while every merge replaced the pending one, and on the release runner a release then waited + # behind the next run. PR parity jobs have ludovics-mac-mini and the desktop. Not the desktop: a job slowed down + # because the maintainer came back could time out, and a failure here bisects and comments on merges. runs-on: [self-hosted, macOS, horizon-parity-main] timeout-minutes: 240 # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures steps: diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml index b48be1d05..1fc31d8cb 100644 --- a/.github/workflows/parity.yml +++ b/.github/workflows/parity.yml @@ -52,7 +52,14 @@ jobs: - name: The prepared output is the one the preparer's OUTPUT_VERSION says env: BASE_SHA: ${{ inputs.base }} - run: python3 tools/prepare_output.py check --cache --base "$BASE_SHA" + run: | + # The job runs main's workflow on the head's files: a head made before OUTPUT_VERSION (#1947) has neither + # the tool nor the number, so there is nothing to check. + if [ ! -f tools/prepare_output.py ] || ! grep -q OUTPUT_VERSION crates/horizon-prepare/src/lib.rs; then + echo "This head's preparer has no OUTPUT_VERSION: nothing to check" + exit 0 + fi + python3 tools/prepare_output.py check --cache --base "$BASE_SHA" - name: The version constants are the pinned jar's run: python3 tools/gen_version_consts.py --check - name: The harnesses this change can affect diff --git a/AGENTS.md b/AGENTS.md index 549fa5c7f..dcd4ca595 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -66,7 +66,7 @@ cargo build --profile fast -p horizon-client # optimized, quick to link: python3 tools/parity.py --changed origin/main # the harnesses your branch can affect (CI's parity job) python3 tools/parity.py --changed-files paths.txt --list # which harnesses cover these files, without running them python3 tools/parity.py mob_ai sculk # named harnesses -python3 tools/lan_e2e.py --check chest # two real games over LAN (host in-frame); --server-thread for the host on its server thread +python3 tools/lan_e2e.py --check chest # two real games over LAN (server-thread host); --in-frame compares the fallback python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end ``` @@ -156,7 +156,7 @@ python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end exactly as a LAN guest or a dedicated server's player does. This is what players run. Open `[server-thread]` issues list the gaps left. 2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks - the world itself, one level that follows the player (`fn enter_dimension`). Most harnesses test this path. + the world itself, one level that follows the player (`fn enter_dimension`). Deterministic rule fixtures still use this path; player-facing integration uses the default server thread. LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths when you touch player-facing gameplay: @@ -164,8 +164,8 @@ when you touch player-facing gameplay: ```sh cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T # server thread cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame # in-frame -python3 tools/lan_e2e.py --check # host in-frame, guest is a server client -python3 tools/lan_e2e.py --server-thread --check # host on its server thread (portals, levels, distance, lava need it) +python3 tools/lan_e2e.py --check # host on its server thread, guest is a server client +python3 tools/lan_e2e.py --in-frame --check # comparison (portals, levels, distance, lava need server-thread mode) python3 tools/parity.py dedicated_server server_entities server_player_damage ``` diff --git a/Cargo.lock b/Cargo.lock index 00da30cf1..0e93bba0e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1437,12 +1437,14 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2", "toml", + "wasmparser", "wasmtime", "wit-component", "wit-parser", @@ -2082,6 +2084,13 @@ dependencies = [ "libc", ] +[[package]] +name = "minimap" +version = "1.0.0" +dependencies = [ + "horizon-mod-sdk", +] + [[package]] name = "minisign-verify" version = "0.3.0" @@ -4140,6 +4149,28 @@ dependencies = [ "wit-parser", ] +[[package]] +name = "wast" +version = "254.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0" +dependencies = [ + "bumpalo", + "leb128fmt", + "memchr", + "unicode-width", + "wasm-encoder", +] + +[[package]] +name = "wat" +version = "1.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e" +dependencies = [ + "wast", +] + [[package]] name = "wayland-backend" version = "0.3.17" @@ -4287,6 +4318,13 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "welcome" +version = "0.1.0" +dependencies = [ + "horizon-mod-sdk", +] + [[package]] name = "wgpu" version = "30.0.1" @@ -4998,6 +5036,7 @@ dependencies = [ "wasm-encoder", "wasm-metadata", "wasmparser", + "wat", "wit-parser", ] @@ -5252,6 +5291,13 @@ version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" +[[package]] +name = "zoom" +version = "1.0.0" +dependencies = [ + "horizon-mod-sdk", +] + [[package]] name = "zopfli" version = "0.8.4" diff --git a/Cargo.toml b/Cargo.toml index cc88441a4..e4628f962 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"] -members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "mods/official/fps-overlay", "mods/official/keystrokes", "xtask"] +members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"] resolver = "2" [workspace.package] diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs index cf2968858..f42674da8 100644 --- a/crates/cargo-horizon-mod/src/check.rs +++ b/crates/cargo-horizon-mod/src/check.rs @@ -1,10 +1,11 @@ //! `cargo horizon-mod check `: what the registry checks of a submission, //! run anywhere: its kind's own checks (docs/api/mod-index.md), its signature //! when given a key, and for a mod a trial run in the sandbox: it must start, -//! survive ticks, frames, a chat line and each of its commands, and import -//! no more than its capabilities. +//! survive ticks, frames, a chat line and each of its commands (a server mod: +//! a player joining, chatting, typing them and leaving), and import no more +//! than its capabilities. use horizon_mods::{ - Clock, Mods, Output, Package, Player, Snapshot, Status, + Clock, GameMode, Mods, Output, Package, Player, ServerPlayer, Snapshot, Status, index::{self, Facts, Kind}, manifest::component_imports, }; @@ -46,6 +47,7 @@ impl Report { "api": self.facts.api, "side": self.facts.side, "capabilities": self.facts.capabilities, + "api_level": self.facts.api_level, "game": self.facts.game, "requires": requires, "sha256": self.sha256, @@ -69,6 +71,8 @@ impl Report { if let Some(side) = f.side { let side = serde_json::to_value(side).unwrap_or_default(); out += &format!(", API {}, {}", f.api, side.as_str().unwrap_or("?")); + } else if self.kind == Kind::Shader { + out += &format!(", shader API {}", f.api); } else if !f.api.is_empty() { out += &format!(", format {}", f.api); } @@ -84,6 +88,9 @@ impl Report { ")\n {} bytes, SHA-256 {}, {signed}\n", self.size, self.sha256 ); + if let Some(level) = f.api_level { + out += &format!(" needs mod API level {level} or newer\n"); + } for c in &f.capabilities { out += &format!(" may {}\n", c.describe()); } @@ -113,6 +120,7 @@ pub fn kind_of(path: &Path) -> Option { "hmod" => Some(Kind::Mod), "hpack" => Some(Kind::Modpack), "zip" => Some(Kind::ResourcePack), + "hshader" => Some(Kind::Shader), _ => None, } } @@ -191,40 +199,66 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> { if let Some(reason) = failed(&mods) { return Err(format!("it didn't start: {reason}")); } - report.commands = mods.commands().map(str::to_owned).collect(); + let client: Vec = mods.commands().map(str::to_owned).collect(); + let server: Vec = mods.server_commands().map(str::to_owned).collect(); + report.commands = [client.clone(), server.clone()].concat(); + // A server mod plays with one player on, who joins, chats and leaves. + let steve = ServerPlayer { + id: "00000000-0000-4000-8000-000000000001".into(), + name: "Steve".into(), + x: 0.5, + y: 64.0, + z: 0.5, + dimension: "minecraft:overworld".into(), + game_mode: GameMode::Survival, + health: 20.0, + }; + let snapshot = |t: u64| Snapshot { + player: Some(Player { + x: 0.5 + t as f64 * 0.1, + y: 64.0, + z: 0.5, + yaw: 90.0, + pitch: 0.0, + health: 20.0, + food: 20, + dimension: "minecraft:overworld".into(), + }), + clock: Some(Clock { + game_time: t, + day_time: 1000 + t, + }), + players: vec![steve.clone()], + // The GUI of a 1280 x 720 window at scale 3. + gui_size: (427.0, 240.0), + ..Snapshot::default() + }; + mods.set_snapshot(snapshot(0)); + mods.player_joined(&steve); for t in 0..TICKS { - mods.set_snapshot(Snapshot { - player: Some(Player { - x: 0.5 + t as f64 * 0.1, - y: 64.0, - z: 0.5, - yaw: 90.0, - pitch: 0.0, - health: 20.0, - food: 20, - dimension: "minecraft:overworld".into(), - }), - clock: Some(Clock { - game_time: t, - day_time: 1000 + t, - }), - // The GUI of a 1280 x 720 window at scale 3. - gui_size: (427.0, 240.0), - ..Snapshot::default() - }); + mods.set_snapshot(snapshot(t)); mods.tick(t); + mods.server_tick(t); for _ in 0..FRAMES_PER_TICK { mods.frame(1.0 / 60.0); } } mods.chat(" hello"); - for name in report.commands.clone() { - mods.command(&name); + mods.player_chat(&steve, "hello"); + for name in &client { + mods.command(name); } + for name in &server { + mods.server_command(&steve, name); + } + mods.set_snapshot(Snapshot::default()); + mods.player_left(&steve); for out in mods.drain() { report.output.push(match out { Output::Chat { text, .. } => format!("chat: {text}"), - Output::Feedback { text, error } => { + Output::Tell { text, .. } => format!("tell: {text}"), + Output::Broadcast { text, .. } => format!("broadcast: {text}"), + Output::Feedback { text, error } | Output::Reply { text, error, .. } => { format!("{}: {text}", if error { "error" } else { "feedback" }) } Output::Command { line } => format!("command: /{line}"), @@ -285,7 +319,7 @@ mod tests { .unwrap(); assert!(e.contains("signature"), "{e}"); let e = check(&pack, Kind::Shader, None, None).err().unwrap(); - assert!(e.contains("shader packs open"), "{e}"); + assert!(e.contains("horizon-shaders.toml"), "{e}"); assert!(check(&pack, Kind::Mod, None, None).is_err()); } } diff --git a/crates/cargo-horizon-mod/src/main.rs b/crates/cargo-horizon-mod/src/main.rs index a4585f680..b82c6d07f 100644 --- a/crates/cargo-horizon-mod/src/main.rs +++ b/crates/cargo-horizon-mod/src/main.rs @@ -6,12 +6,15 @@ //! `assets/` and `data/`; a folder without `Cargo.toml` is content only. //! - `run [--game ] [-- ]`: build, then play with //! the mod; run `build` again and the game reloads it. +//! - `test [--debug] [--hmod ] []`: build, then run the mod's +//! `tests/*.toml` scripts in the sandbox, with no game. //! - `check [--json]`: what the registry checks of a submission //! (`.hmod`, `.hpack`, resource pack `.zip`), with a trial run for a mod. //! - `registry build|review|check|list`: the registry repository's CI. use horizon_mods::{ Capability, Content, Manifest, Package, manifest::{MANIFEST, component_imports, componentize}, + testing::{Script, TestGame}, }; mod check; mod registry; @@ -36,9 +39,10 @@ fn main() -> ExitCode { println!("Built {}", p.display()); }), Some("run") => run(&args[1..]), + Some("test") => test(&args[1..]), Some("check") => check(&args[1..]), Some("registry") => registry::main(&args[1..]), - _ => Err("usage: cargo horizon-mod new [--template code|content] | build [--debug] | run [--game ] [-- ] | check [--kind ] [--key --signature ] [--json] | registry build|review|check|list".into()), + _ => Err("usage: cargo horizon-mod new [--template code|content] | build [--debug] | run [--game ] [-- ] | test [--debug] [--hmod ] [] | check [--kind ] [--key --signature ] [--json] | registry build|review|check|list".into()), }; match result { Ok(()) => ExitCode::SUCCESS, @@ -97,6 +101,10 @@ fn new(args: &[String]) -> Result<(), String> { (MANIFEST, include_str!("../template/horizon-mod.toml")), ("src/lib.rs", include_str!("../template/src/lib.rs")), (".gitignore", include_str!("../template/gitignore")), + ( + "tests/hello.toml", + include_str!("../template/tests/hello.toml"), + ), ]; // A block copying a vanilla one, with its model, name, loot, recipe and tag. let content = [ @@ -270,6 +278,63 @@ fn check(args: &[String]) -> Result<(), String> { Ok(()) } +/// `test`: every `tests/*.toml` script (those whose name holds ``) +/// against the built mod, or the `.hmod` given with `--hmod`. +fn test(args: &[String]) -> Result<(), String> { + let hmod = match flag(args, "--hmod") { + Some(p) => PathBuf::from(p), + None => build(!args.iter().any(|a| a == "--debug"))?, + }; + let filter = args + .iter() + .enumerate() + .find(|(i, a)| !a.starts_with("--") && (*i == 0 || args[i - 1] != "--hmod")) + .map(|(_, a)| a.as_str()); + let mut scripts: Vec = std::fs::read_dir("tests") + .map_err(|e| { + format!( + "tests/: {e} (a mod's tests are tests/.toml: docs/mods.md, \"Testing a mod\")" + ) + })? + .filter_map(|e| Some(e.ok()?.path())) + .filter(|p| p.extension().is_some_and(|e| e == "toml")) + .filter(|p| filter.is_none_or(|f| p.to_string_lossy().contains(f))) + .collect(); + scripts.sort(); + if scripts.is_empty() { + return Err("no tests/*.toml to run".into()); + } + println!( + "running {} scripts against {}", + scripts.len(), + hmod.display() + ); + let mut failed = 0; + for path in &scripts { + let result = std::fs::read_to_string(path) + .map_err(|e| e.to_string()) + .and_then(|text| Script::parse(&text)) + .and_then(|script| { + let mut game = TestGame::load(&hmod)?; + script.run(&mut game)?; + Ok(script.steps.len()) + }); + match result { + Ok(steps) => println!("test {} ... ok ({steps} steps)", path.display()), + Err(e) => { + failed += 1; + println!("test {} ... FAILED\n {e}", path.display()); + } + } + } + let passed = scripts.len() - failed; + if failed > 0 { + return Err(format!("{failed} failed, {passed} passed")); + } + println!("test result: ok. {passed} passed"); + Ok(()) +} + fn run(args: &[String]) -> Result<(), String> { let path = build(true)?; let game = flag(args, "--game") @@ -312,6 +377,8 @@ mod tests { ); let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap(); assert!(cargo.contains("name = \"my-mod\"") && cargo.contains(SDK_GIT)); + let script = std::fs::read_to_string(path.join("tests/hello.toml")).unwrap(); + assert_eq!(Script::parse(&script).unwrap().steps.len(), 3); assert!( new(&[path.display().to_string()]).is_err(), "never overwrites" diff --git a/crates/cargo-horizon-mod/template/tests/hello.toml b/crates/cargo-horizon-mod/template/tests/hello.toml new file mode 100644 index 000000000..17afd7e65 --- /dev/null +++ b/crates/cargo-horizon-mod/template/tests/hello.toml @@ -0,0 +1,14 @@ +# `cargo horizon-mod test` runs every tests/*.toml against the built mod, with no game: +# steps happen in order, and `expect` checks what the mod showed during the step. +# Every key: docs/mods.md, "Testing a mod". + +[[step]] +expect.commands = ["hello"] + +[[step]] +command = "hello world" +expect.chat = ["Hello world! (1 so far)"] + +[[step]] +command = "hello again" +expect.chat = ["Hello again! (2 so far)"] diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index a585ce19e..d7c6d812b 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -23,7 +23,7 @@ horizon-shader-api = { path = "../horizon-shader-api" } horizon-friends = { path = "../horizon-friends" } # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md). # Their runtime is the `mods` feature. -horizon-mods = { path = "../horizon-mods", default-features = false } +horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] } wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] } winit = "0.30.13" pollster = "0.4" diff --git a/crates/horizon-client/src/bin/horizon-ctl/commands.rs b/crates/horizon-client/src/bin/horizon-ctl/commands.rs index cf7be69a6..f722e2f9a 100644 --- a/crates/horizon-client/src/bin/horizon-ctl/commands.rs +++ b/crates/horizon-client/src/bin/horizon-ctl/commands.rs @@ -143,6 +143,7 @@ const PAGES: Ty = Ty::Enum(&[ "font", "packs", "mods", + "shader-packs", "graphics", "graphics-advanced", "extras", diff --git a/crates/horizon-client/src/bin/horizon-ctl/main.rs b/crates/horizon-client/src/bin/horizon-ctl/main.rs index 402808e81..33ea1f870 100644 --- a/crates/horizon-client/src/bin/horizon-ctl/main.rs +++ b/crates/horizon-client/src/bin/horizon-ctl/main.rs @@ -610,12 +610,17 @@ mod tests { #[test] fn unreachable_games_fail_with_status_3() { - let mut s = Session::new(std::env::temp_dir().join("horizon-ctl-nobody.sock"), None); + let home = + std::env::temp_dir().join(format!("horizon-ctl-unreachable-{}", std::process::id())); + std::fs::create_dir_all(&home).unwrap(); + let mut s = Session::new(home.join("nobody.sock"), None); + s.home = home.clone(); let f = s.run(&["state".to_owned()]).unwrap_err(); assert_eq!(f.status, UNREACHABLE); assert_eq!(f.reply["kind"], "connection"); let f = s.run(&["sleep".to_owned(), "x".to_owned()]).unwrap_err(); assert_eq!(f.status, USAGE); + std::fs::remove_dir_all(home).unwrap(); } #[test] diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index 41330df5f..c0bec476b 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy { Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed)) } +/// Frees `columns` (`count` of them) on a short-lived thread of its own +/// when there are many: a teleport or a dimension change drops a few +/// thousand columns at once, and freeing their sections took the frame +/// 15-20 ms. A few are freed here. +pub fn free_columns(columns: T, count: usize) { + if count < 64 { + return; + } + // Should the thread not start, the closure drops `columns` here. + let _ = std::thread::Builder::new() + .name("Chunk freeing".into()) + .spawn(move || drop(columns)); +} + /// Sizes the block states' global palette for a registry of `states`. pub fn set_block_states(states: usize) { let bits = horizon_core::paletted::ceil_log2(states).max(16); diff --git a/crates/horizon-client/src/debug_overlay.rs b/crates/horizon-client/src/debug_overlay.rs index fa969512c..f55d4ee6e 100644 --- a/crates/horizon-client/src/debug_overlay.rs +++ b/crates/horizon-client/src/debug_overlay.rs @@ -84,6 +84,33 @@ impl Displayer { } } +/// Horizon's own lines: the shader pack's GPU time, then its costliest passes (`passes`: each +/// pass's median milliseconds, in the order they run). +pub fn shader_pass_lines(passes: &[(String, f32)]) -> Vec { + const SHOWN: usize = 8; + if passes.is_empty() { + return Vec::new(); + } + let total: f32 = passes.iter().map(|p| p.1).sum(); + let mut lines = vec![format!( + "Shader pack GPU: {total:.2} ms in {} passes", + passes.len() + )]; + let mut costliest: Vec<&(String, f32)> = passes.iter().collect(); + costliest.sort_by(|a, b| b.1.total_cmp(&a.1)); + lines.extend( + costliest + .iter() + .take(SHOWN) + .map(|(name, ms)| format!("{name}: {ms:.2} ms")), + ); + if costliest.len() > SHOWN { + let rest: f32 = costliest[SHOWN..].iter().map(|p| p.1).sum(); + lines.push(format!("{} more: {rest:.2} ms", costliest.len() - SHOWN)); + } + lines +} + /// `Mth.wrapDegrees`. fn wrap_degrees(angle: f32) -> f32 { let wrapped = angle % 360.0; @@ -336,4 +363,15 @@ mod tests { (1.0, [640, 360]) ); } + + #[test] + fn shader_pass_lines_list_the_costliest_passes_first() { + assert!(shader_pass_lines(&[]).is_empty()); + let passes: Vec<(String, f32)> = (0..10).map(|i| (format!("p{i}"), i as f32)).collect(); + let lines = shader_pass_lines(&passes); + assert_eq!(lines[0], "Shader pack GPU: 45.00 ms in 10 passes"); + assert_eq!(lines[1], "p9: 9.00 ms"); + assert_eq!(lines[8], "p2: 2.00 ms"); + assert_eq!(lines[9], "2 more: 1.00 ms"); + } } diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index 65536d710..6e8089e9d 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -10,6 +10,8 @@ use crate::{ use horizon_core::geometry::{Aabb, Vec3}; use horizon_world::block_collision::BlockCollisionRegistry; +mod fluids; + #[derive(Clone, Debug)] pub struct ItemEntity { pub health: i32, @@ -165,18 +167,16 @@ impl ItemEntity { facts: &BlockFacts, collision: &BlockCollisionRegistry<'_>, no_physics: bool, + fluids: &crate::motion::FluidResources, ) -> bool { self.ticks += 1; self.previous = self.position; if self.pickup_delay > 0 && self.pickup_delay != u32::MAX { self.pickup_delay -= 1; } - let eye = world.block( - self.position.x.floor() as i32, - (self.position.y + 0.1).floor() as i32, - self.position.z.floor() as i32, - ); - let in_water = facts.get(eye).fluid == Fluid::Water; + // Entity.baseTick pushes before ItemEntity applies buoyancy and moves. + let (water_height, lava_height) = self.update_fluids(world, fluids); + let in_water = water_height > f64::from(0.1f32); if in_water { // ItemEntity.setUnderwaterMovement self.velocity = Vec3::new( @@ -184,7 +184,7 @@ impl ItemEntity { self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 }, self.velocity.z * 0.99, ); - } else if facts.get(eye).fluid == Fluid::Lava { + } else if lava_height > f64::from(0.1f32) { self.velocity = Vec3::new( self.velocity.x * 0.95, self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 }, @@ -245,6 +245,8 @@ impl ItemEntity { } } self.age += 1; + // ItemEntity.tick refreshes immersion and pushes again after moving. + self.update_fluids(world, fluids); self.age < 6000 && self.position.y > -128.0 } /// `ItemEntity.isMergable` at `age`: a stack below its size whose pickup diff --git a/crates/horizon-client/src/entities/fluids.rs b/crates/horizon-client/src/entities/fluids.rs new file mode 100644 index 000000000..fffa0ae2b --- /dev/null +++ b/crates/horizon-client/src/entities/fluids.rs @@ -0,0 +1,216 @@ +//! Dropped-item immersion and currents through the shared vanilla fluid helpers. +use super::ItemEntity; +use crate::{ + motion::{FluidResources, FluidTags, LAVA, WATER}, + world::World, +}; +use horizon_core::{ + geometry::{Aabb, Direction, Vec3}, + position::BlockPos, +}; +use horizon_world::{ + entity_fluid::{ + CurrentTarget, EntityFluidInteraction, FluidInteractionWorld, FluidMembership, + FluidSections, FluidTagId, + }, + fluid::{FluidHeightWorld, FluidKind, FluidState}, + fluid_flow::{FluidFlowWorld, flow_at}, + registry::BlockStateId, +}; +type Error = std::convert::Infallible; +struct ItemFluidWorld<'a> { + item: &'a mut ItemEntity, + world: &'a World, + fluids: &'a FluidResources, +} +impl ItemEntity { + pub(super) fn update_fluids(&mut self, world: &World, fluids: &FluidResources) -> (f64, f64) { + let mut interaction = EntityFluidInteraction::new([WATER, LAVA]); + let mut scene = ItemFluidWorld { + item: self, + world, + fluids, + }; + if interaction.update(&mut scene, false, 4096).is_err() { + return (0.0, 0.0); + } + let water_height = interaction.fluid_height(&scene, WATER); + let lava_height = interaction.fluid_height(&scene, LAVA); + let _ = interaction.apply_current(&mut scene, WATER, 0.014); + let _ = interaction.apply_current( + &mut scene, + LAVA, + if world.fast_lava { + 0.007 + } else { + 0.0023333333333333335 + }, + ); + (water_height, lava_height) + } +} +impl FluidMembership for ItemFluidWorld<'_> { + fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool { + FluidTags.fluid_in_tag(kind, tag) + } +} +impl CurrentTarget for ItemFluidWorld<'_> { + type Error = Error; + fn is_player_class(&self) -> bool { + false + } + fn velocity(&mut self) -> Result { + Ok(self.item.velocity) + } + fn add_delta_movement(&mut self, delta: Vec3) -> Result<(), Error> { + let v = self.item.velocity; + let sum = Vec3::new(v.x + delta.x, v.y + delta.y, v.z + delta.z); + if delta.is_finite() && sum.is_finite() { + self.item.velocity = sum; + } + Ok(()) + } +} +impl FluidInteractionWorld for ItemFluidWorld<'_> { + type Error = Error; + type Chunk = (); + fn interaction_box(&mut self) -> Result, Error> { + Ok(Some( + self.item.bounds().deflate(Vec3::new(0.001, 0.001, 0.001)), + )) + } + fn loaded_chunk(&mut self, x: i32, z: i32) -> Result, Error> { + Ok(self.world.chunks.contains_key(&(x, z)).then_some(())) + } + fn chunk_sections(&mut self, _: ()) -> Result, Error> { + static SECTIONS: [bool; crate::chunk::SECTIONS] = [true; crate::chunk::SECTIONS]; + Ok(FluidSections { + minimum_section_y: crate::chunk::MIN_Y >> 4, + has_fluid: &SECTIONS, + }) + } + fn bounding_box_min_y(&self) -> f64 { + self.item.position.y + } + fn block_x(&self) -> i32 { + self.item.position.x.floor() as i32 + } + fn eye_y(&mut self) -> Result { + Ok(self.item.position.y + f64::from(0.2125f32)) + } + fn block_z(&self) -> i32 { + self.item.position.z.floor() as i32 + } + fn fluid_state(&mut self, p: BlockPos) -> Result { + Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z))) + } + fn fluid_height(&mut self, f: FluidState, p: BlockPos) -> Result { + f.height_at(self, [p.x, p.y, p.z]) + } + fn camera_height(&mut self, f: FluidState, p: BlockPos) -> Result { + f.camera_height_at(self, [p.x, p.y, p.z]) + } + fn flow(&mut self, f: FluidState, p: BlockPos) -> Result { + flow_at(self, f, p) + } +} +impl FluidHeightWorld for ItemFluidWorld<'_> { + type Error = Error; + fn fluid(&mut self, p: [i32; 3]) -> Result { + Ok(self.fluids.fluid(self.world.block(p[0], p[1], p[2]))) + } + fn sturdy_down(&mut self, p: [i32; 3]) -> Result { + let state = self.world.block(p[0], p[1], p[2]); + Ok(self.fluids.sturdy(state, Direction::Down)) + } +} +impl FluidFlowWorld for ItemFluidWorld<'_> { + type Error = Error; + type Block = BlockStateId; + fn fluid(&mut self, p: BlockPos) -> Result { + Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z))) + } + fn block(&mut self, p: BlockPos) -> Result { + Ok(self.world.block(p.x, p.y, p.z)) + } + fn blocks_fluid_flow(&self, s: BlockStateId) -> bool { + self.fluids.blocks_flow(s) + } + fn is_ice_class(&self, s: BlockStateId) -> bool { + self.fluids.ice(s) + } + fn is_face_sturdy( + &mut self, + s: BlockStateId, + _: BlockPos, + d: Direction, + ) -> Result { + Ok(self.fluids.sturdy(s, d)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn items_follow_flowing_water_but_still_water_has_no_horizontal_push() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("movement-properties.nbt").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let render = assets.reload(&root).unwrap(); + let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap(); + let fluids = FluidResources::new(&assets, &facts).unwrap(); + let collision = crate::collisions::load(&root, assets.registry).unwrap(); + let mut world = World::test_scene(&assets, &render, 3).unwrap(); + let stone = assets.registry.default_state("minecraft:stone").unwrap(); + let water = assets.registry.default_state("minecraft:water").unwrap(); + let mut state = assets.registry.state(water).unwrap().clone(); + state.properties.insert("level".into(), "1".into()); + let flowing = assets.registry.resolve(&state).unwrap(); + for x in 19..=21 { + for z in 19..=21 { + world.set(x, 3, z, stone).unwrap(); + world.set(x, 4, z, water).unwrap(); + } + } + let at = Vec3::new(20.5, 4.0, 20.5); + let item = ItemEntity { + id: 1, + health: 5, + fire_ticks: 0, + stack: crate::items::ItemStack { + item: "minecraft:sugar_cane".into(), + count: 1, + damage: 0, + extra: None, + }, + thrower: None, + position: at, + previous: at, + velocity: Vec3::ZERO, + on_ground: false, + age: 0, + pickup_delay: 0, + bob_offset: 0.0, + ticks: 0, + }; + let mut still = item.clone(); + assert!(still.tick(&world, &facts, &collision, false, &fluids)); + assert_eq!(still.position.x, at.x); + assert_eq!(still.velocity.x, 0.0); + world.set(21, 4, 20, flowing).unwrap(); + let mut carried = item; + assert!(carried.tick(&world, &facts, &collision, false, &fluids)); + // First push is damped by buoyancy before motion, second follows drag. + assert!((carried.position.x - at.x - 0.014 * 0.99).abs() < 1e-12); + assert!((carried.velocity.x - (0.014 * 0.99 * 0.98 + 0.014)).abs() < 1e-12); + for _ in 0..20 { + carried.tick(&world, &facts, &collision, false, &fluids); + } + assert!(carried.position.x > at.x + 0.5); + } +} diff --git a/crates/horizon-client/src/extras.rs b/crates/horizon-client/src/extras.rs index 40e87214e..d2f0b4e9d 100644 --- a/crates/horizon-client/src/extras.rs +++ b/crates/horizon-client/src/extras.rs @@ -1,4 +1,4 @@ -//! Horizon's optional extras (zoom, FPS counter, keystroke overlay): their +//! Horizon's optional extras (minimap, lighting, inventory tools): their //! settings, kept in `horizon-extras.txt` next to `options.txt` so that file //! stays exactly vanilla's, and the logic behind them. Every extra is off by //! default; see `docs/extras.md`. Horizon's own switches outside the Extras page @@ -6,17 +6,8 @@ use std::{collections::VecDeque, fs, path::Path}; pub const FILE: &str = "horizon-extras.txt"; -/// The name the options screen uses while the zoom key waits for a key. -pub const ZOOM_KEY: &str = "horizon.zoom"; -/// The same for the sort key. +/// The name the options screen uses while the sort key waits for a key. pub const SORT_KEY: &str = "horizon.sort"; -/// Zoom levels the default cycles through, and the wheel's limits. -pub const ZOOM_LEVELS: [u8; 6] = [2, 3, 4, 6, 8, 10]; -pub const ZOOM_MIN: f32 = 1.25; -/// `Camera.tickFov` keeps the field-of-view modifier at 0.1 or more. -pub const ZOOM_MAX: f32 = 10.0; -/// Each wheel step multiplies the zoom by this. -const ZOOM_STEP: f32 = 1.25; /// The minimap's sizes in GUI pixels, and its zooms in blocks per pixel. pub const MINIMAP_SIZES: [(u8, &str); 3] = [(64, "Small"), (96, "Medium"), (128, "Large")]; @@ -81,6 +72,9 @@ pub struct Extras { pub zoom_smooth: bool, /// Divide mouse turning by the zoom. pub zoom_sensitivity: bool, + /// The FPS counter and keystrokes extras are official mods now + /// (`moved_extras`): their old settings stay here until the game has + /// installed the mod for a player who had one on. pub fps: bool, pub fps_corner: Corner, /// Also show the minimum and 1% low. @@ -89,6 +83,9 @@ pub struct Extras { pub keystrokes_corner: Corner, /// Clicks per second under the mouse buttons. pub keystrokes_cps: bool, + /// The official mods installed for the extras they replace, by mod id + /// (`movedToMods`): each is done once. + pub moved: Vec, pub minimap: bool, pub minimap_corner: Corner, /// Side in GUI pixels (`MINIMAP_SIZES`). @@ -132,6 +129,7 @@ impl Default for Extras { keystrokes: false, keystrokes_corner: Corner::TopLeft, keystrokes_cps: true, + moved: Vec::new(), minimap: false, minimap_corner: Corner::TopRight, minimap_size: 96, @@ -177,7 +175,7 @@ impl Extras { "zoomKey" if value.starts_with("key.") => e.zoom_key = value.to_owned(), "zoomLevel" => { if let Ok(v) = value.parse::() { - e.zoom_level = v.clamp(2, ZOOM_MAX as u8); + e.zoom_level = v.clamp(2, 10); } } "zoomSmooth" => e.zoom_smooth = flag(e.zoom_smooth), @@ -190,6 +188,14 @@ impl Extras { e.keystrokes_corner = Corner::parse(value, e.keystrokes_corner) } "keystrokesCps" => e.keystrokes_cps = flag(e.keystrokes_cps), + "movedToMods" => { + e.moved = value + .split(',') + .map(str::trim) + .filter(|id| !id.is_empty()) + .map(str::to_owned) + .collect() + } "minimap" => e.minimap = flag(e.minimap), "minimapCorner" => e.minimap_corner = Corner::parse(value, e.minimap_corner), "minimapSize" => { @@ -219,7 +225,7 @@ impl Extras { } pub fn serialize(&self) -> String { format!( - "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\n", + "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\n", bool_text(self.fullbright), bool_text(self.dynamic_lights), bool_text(self.zoom), @@ -233,6 +239,7 @@ impl Extras { bool_text(self.keystrokes), self.keystrokes_corner.name(), bool_text(self.keystrokes_cps), + self.moved.join(","), bool_text(self.minimap), self.minimap_corner.name(), self.minimap_size, @@ -254,11 +261,10 @@ impl Extras { bool_text(self.discord_presence), ) } - /// Binds the extra key `name` (`ZOOM_KEY`, `SORT_KEY`); false for + /// Binds the extra key `name` (`SORT_KEY`); false for /// another name (a vanilla mapping). pub fn set_key(&mut self, name: &str, value: String) -> bool { match name { - ZOOM_KEY => self.zoom_key = value, SORT_KEY => self.sort_key = value, _ => return false, } @@ -275,87 +281,12 @@ impl Extras { } } -/// The zoom key's state: held or not, and the zoom the wheel has set. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct Zoom { - held: bool, - factor: f32, -} -impl Default for Zoom { - fn default() -> Self { - Self { - held: false, - factor: 1.0, - } - } -} -impl Zoom { - /// The key went down: start at the default level. - pub fn press(&mut self, level: u8) { - self.held = true; - self.factor = f32::from(level).clamp(ZOOM_MIN, ZOOM_MAX); - } - pub fn release(&mut self) { - self.held = false; - } - /// A press or release of the zoom key. Only a press while `playing` (no - /// screen or text field open) zooms; anywhere else the key belongs to - /// the screen, and the zoom lets go. - pub fn key(&mut self, pressed: bool, repeat: bool, playing: bool, level: u8) { - if !pressed || !playing { - self.release(); - } else if !repeat { - self.press(level); - } - } - pub fn held(&self) -> bool { - self.held - } - /// Wheel steps while held (positive zooms in); false when not zooming. - pub fn scroll(&mut self, steps: f32) -> bool { - if !self.held { - return false; - } - self.factor = (self.factor * ZOOM_STEP.powf(steps)).clamp(ZOOM_MIN, ZOOM_MAX); - true - } - /// The zoom in effect: 1 when the key is up or the spyglass is in use - /// (scoping keeps vanilla's spyglass view). - pub fn factor(&self, scoping: bool) -> f32 { - if self.held && !scoping { - self.factor - } else { - 1.0 - } - } -} -/// Vanilla key mappings bound to the zoom key. The key still reaches them -/// (a key bound twice triggers both, as vanilla's do), so the Extras page -/// says so. -pub fn zoom_key_conflicts(e: &Extras, keys: &crate::keybinds::KeyBinds) -> Vec<&'static str> { - if e.zoom_key == "key.keyboard.unknown" { - return Vec::new(); - } - crate::keybinds::MAPPINGS - .iter() - .map(|m| m.0) - .filter(|name| keys.get(name) == e.zoom_key) - .collect() -} /// The field-of-view modifier target `Camera.tickFov` eases toward: vanilla's -/// (`getFieldOfViewModifier`) divided by the zoom. A zoom of 1 leaves it as is. +/// (`getFieldOfViewModifier`) divided by a mod's zoom (`render.set-zoom`). A +/// zoom of 1 leaves it as is. pub fn fov_target(vanilla: f32, zoom: f32) -> f32 { if zoom == 1.0 { vanilla } else { vanilla / zoom } } -/// The mouse turning scale while zoomed. -pub fn turn_scale(zoom: f32, lower_sensitivity: bool) -> f64 { - if lower_sensitivity && zoom > 1.0 { - 1.0 / f64::from(zoom) - } else { - 1.0 - } -} - /// Frame times over the last few seconds: frames per second, the minimum /// and the 1% low, recomputed twice a second. pub struct FpsCounter { @@ -447,23 +378,6 @@ impl Cps { pub enum Item { Fullbright, DynamicLights, - Zoom, - ZoomKey, - ZoomLevel, - ZoomSmooth, - ZoomSensitivity, - Fps, - FpsCorner, - FpsLows, - Keystrokes, - KeystrokesCorner, - KeystrokesCps, - Minimap, - MinimapCorner, - MinimapSize, - MinimapShape, - MinimapZoom, - MinimapRotate, AutoReconnect, MouseTweaks, MouseTweaksWheel, @@ -482,27 +396,6 @@ pub fn rows() -> Vec> { Err("Lighting"), Ok(Fullbright), Ok(DynamicLights), - Err("Zoom"), - Ok(Zoom), - Ok(ZoomKey), - Ok(ZoomLevel), - Ok(ZoomSmooth), - Ok(ZoomSensitivity), - Err("Minimap"), - Ok(Minimap), - Ok(MinimapCorner), - Ok(MinimapSize), - Ok(MinimapShape), - Ok(MinimapZoom), - Ok(MinimapRotate), - Err("FPS counter"), - Ok(Fps), - Ok(FpsCorner), - Ok(FpsLows), - Err("Keystrokes"), - Ok(Keystrokes), - Ok(KeystrokesCorner), - Ok(KeystrokesCps), Err("Inventory"), Ok(MouseTweaks), Ok(MouseTweaksWheel), @@ -512,46 +405,16 @@ pub fn rows() -> Vec> { Ok(AutoReconnect), ] } -/// "1 block", "2 blocks", "½ block". -fn block_count(n: f32) -> String { - if n < 1.0 { - "½ block".into() - } else if n == 1.0 { - "1 block".into() - } else { - format!("{n} blocks") - } -} -fn next(all: &[T], current: T, back: bool) -> T { - let i = all.iter().position(|v| *v == current).unwrap_or(0); - let n = all.len(); - all[if back { (i + n - 1) % n } else { (i + 1) % n }] -} impl Item { pub fn caption(self) -> &'static str { match self { Item::Fullbright => "Fullbright", Item::DynamicLights => "Dynamic lights", - Item::Zoom => "Zoom", - Item::ZoomKey => "Zoom key", - Item::ZoomLevel => "Starting zoom", - Item::ZoomSmooth => "Smooth zoom", - Item::ZoomSensitivity => "Slower turning", - Item::Fps => "FPS counter", - Item::FpsCorner | Item::KeystrokesCorner | Item::MinimapCorner => "Corner", - Item::Minimap => "Minimap", - Item::MinimapSize => "Size", - Item::MinimapShape => "Shape", - Item::MinimapZoom => "Zoom", - Item::MinimapRotate => "Turn with the player", Item::AutoReconnect => "Auto-reconnect", Item::MouseTweaks => "Mouse Tweaks controls", Item::MouseTweaksWheel => "Scroll wheel moves items", Item::Sort => "Sort buttons", Item::SortKey => "Sort key", - Item::FpsLows => "Minimum and 1% low", - Item::Keystrokes => "Keystrokes", - Item::KeystrokesCps => "Clicks per second", Item::NoAi => "No AI", Item::AgentControl => "Agent Control", Item::DiscordPresence => "Discord Rich Presence", @@ -561,14 +424,10 @@ impl Item { pub fn parent(self) -> Option { use Item::*; Some(match self { - ZoomKey | ZoomLevel | ZoomSmooth | ZoomSensitivity => Zoom, - MinimapCorner | MinimapSize | MinimapShape | MinimapZoom | MinimapRotate => Minimap, - FpsCorner | FpsLows => Fps, - KeystrokesCorner | KeystrokesCps => Keystrokes, MouseTweaksWheel => MouseTweaks, SortKey => Sort, - Fullbright | DynamicLights | Zoom | Minimap | Fps | Keystrokes | MouseTweaks | Sort - | AutoReconnect | NoAi | AgentControl | DiscordPresence => { + Fullbright | DynamicLights | MouseTweaks | Sort | AutoReconnect | NoAi + | AgentControl | DiscordPresence => { return None; } }) @@ -580,24 +439,9 @@ impl Item { Item::DynamicLights => { "Torches and other light sources held, dropped or on fire light the blocks around them." } - Item::Zoom => "Hold the zoom key to zoom; the wheel changes it while held.", - Item::ZoomKey => "Click, then press a key. Escape unbinds it.", - Item::ZoomLevel => "The zoom the key starts at.", - Item::ZoomSmooth => "Eases in and out like the spyglass.", - Item::ZoomSensitivity => "Turns slower the more you zoom in.", - Item::Fps => "Frames per second in a corner of the screen.", - Item::FpsCorner | Item::KeystrokesCorner | Item::MinimapCorner => { - "Overlays in one corner stack." - } - Item::Minimap => "A map of the loaded terrain around you, in map colours.", - Item::MinimapSize => "How big the map is on screen.", - Item::MinimapShape => "Square or round.", - Item::MinimapZoom => "Blocks per pixel: smaller shows more detail, larger more land.", - Item::MinimapRotate => "Forward is up; off keeps north up.", Item::AutoReconnect => { "Rejoins a server after a lost connection or a restart, never after a kick or ban." } - Item::FpsLows => "The slowest frame and the 1% low of the last 5 seconds.", Item::MouseTweaks => { "Right-drag places one per slot, left-drag gathers the held item, Shift + left-drag moves every slot." } @@ -610,8 +454,6 @@ impl Item { Item::SortKey => { "Sorts the part under the cursor. Click, then press a key; Escape unbinds it." } - Item::Keystrokes => "Movement keys, jump and mouse buttons as you press them.", - Item::KeystrokesCps => "Clicks in the last second under each mouse button.", Item::NoAi => { "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too." } @@ -627,8 +469,8 @@ impl Item { pub fn cost(self) -> Option { use crate::graphics_style::Cost; match self { - Item::Fullbright | Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None), - Item::Minimap | Item::DynamicLights => Some(Cost::Low), + Item::Fullbright => Some(Cost::None), + Item::DynamicLights => Some(Cost::Low), Item::AutoReconnect | Item::MouseTweaks | Item::Sort => Some(Cost::None), _ => None, } @@ -638,15 +480,6 @@ impl Item { Some(match self { Item::Fullbright => e.fullbright, Item::DynamicLights => e.dynamic_lights, - Item::Zoom => e.zoom, - Item::ZoomSmooth => e.zoom_smooth, - Item::ZoomSensitivity => e.zoom_sensitivity, - Item::Fps => e.fps, - Item::FpsLows => e.fps_lows, - Item::Keystrokes => e.keystrokes, - Item::KeystrokesCps => e.keystrokes_cps, - Item::Minimap => e.minimap, - Item::MinimapRotate => e.minimap_rotate, Item::AutoReconnect => e.auto_reconnect, Item::MouseTweaks => e.mouse_tweaks, Item::MouseTweaksWheel => e.mouse_tweaks_wheel, @@ -660,65 +493,32 @@ impl Item { /// The value of the other items, as their button shows it. pub fn value(self, e: &Extras) -> String { match self { - Item::ZoomKey => crate::keybinds::display_name(&e.zoom_key).plain(), Item::SortKey => crate::keybinds::display_name(&e.sort_key).plain(), - Item::ZoomLevel => format!("{}x", e.zoom_level), - Item::FpsCorner => e.fps_corner.label().into(), - Item::KeystrokesCorner => e.keystrokes_corner.label().into(), - Item::MinimapCorner => e.minimap_corner.label().into(), - Item::MinimapSize => MINIMAP_SIZES - .iter() - .find(|s| s.0 == e.minimap_size) - .map_or("Medium", |s| s.1) - .into(), - Item::MinimapShape => if e.minimap_round { "Round" } else { "Square" }.into(), - Item::MinimapZoom => format!("{} per pixel", block_count(e.minimap_zoom)), other => match other.switch(e) { Some(true) => "On".into(), _ => "Off".into(), }, } } - /// A click (`back` for the right button). The zoom key binds instead. - pub fn cycle(self, e: &mut Extras, back: bool) { + /// A click (`_back` for the right button: every item left is a switch, + /// so both flip it). The sort key binds instead. + pub fn cycle(self, e: &mut Extras, _back: bool) { match self { Item::Fullbright => e.fullbright = !e.fullbright, Item::DynamicLights => e.dynamic_lights = !e.dynamic_lights, - Item::Zoom => e.zoom = !e.zoom, - Item::ZoomSmooth => e.zoom_smooth = !e.zoom_smooth, - Item::ZoomSensitivity => e.zoom_sensitivity = !e.zoom_sensitivity, - Item::Fps => e.fps = !e.fps, - Item::FpsLows => e.fps_lows = !e.fps_lows, - Item::Keystrokes => e.keystrokes = !e.keystrokes, - Item::KeystrokesCps => e.keystrokes_cps = !e.keystrokes_cps, - Item::ZoomLevel => e.zoom_level = next(&ZOOM_LEVELS, e.zoom_level, back), - Item::FpsCorner => e.fps_corner = next(&Corner::ALL, e.fps_corner, back), - Item::KeystrokesCorner => { - e.keystrokes_corner = next(&Corner::ALL, e.keystrokes_corner, back) - } - Item::Minimap => e.minimap = !e.minimap, - Item::MinimapRotate => e.minimap_rotate = !e.minimap_rotate, Item::AutoReconnect => e.auto_reconnect = !e.auto_reconnect, Item::MouseTweaks => e.mouse_tweaks = !e.mouse_tweaks, Item::MouseTweaksWheel => e.mouse_tweaks_wheel = !e.mouse_tweaks_wheel, Item::Sort => e.sort = !e.sort, - Item::MinimapCorner => e.minimap_corner = next(&Corner::ALL, e.minimap_corner, back), - Item::MinimapSize => { - let sizes: Vec = MINIMAP_SIZES.iter().map(|s| s.0).collect(); - e.minimap_size = next(&sizes, e.minimap_size, back); - } - Item::MinimapShape => e.minimap_round = !e.minimap_round, - Item::MinimapZoom => e.minimap_zoom = next(&MINIMAP_ZOOMS, e.minimap_zoom, back), Item::NoAi => e.no_ai = !e.no_ai, Item::AgentControl => e.agent_control = !e.agent_control, Item::DiscordPresence => e.discord_presence = !e.discord_presence, - Item::ZoomKey | Item::SortKey => {} + Item::SortKey => {} } } /// The key name the options screen waits on for a key item. pub fn key_name(self) -> Option<&'static str> { match self { - Item::ZoomKey => Some(ZOOM_KEY), Item::SortKey => Some(SORT_KEY), _ => None, } @@ -750,6 +550,7 @@ mod tests { e.fps_corner = Corner::BottomRight; e.keystrokes = true; e.keystrokes_cps = false; + e.moved = vec!["fps_overlay".into(), "keystrokes".into()]; e.minimap = true; e.minimap_size = 128; e.minimap_round = true; @@ -775,43 +576,7 @@ mod tests { } #[test] - fn default_zoom_key_is_free_in_vanilla() { - let key = Extras::default().zoom_key; - assert!(crate::keybinds::key_code(&key).is_some()); - assert!( - crate::keybinds::MAPPINGS.iter().all(|m| m.1 != key), - "{key} is a vanilla binding" - ); - } - - #[test] - fn zoom_is_vanilla_unless_held_and_not_scoping() { - let mut z = Zoom::default(); - assert_eq!(z.factor(false), 1.0); - assert_eq!(fov_target(1.1, z.factor(false)), 1.1); - assert!(!z.scroll(1.0), "the wheel is the hotbar's when not zooming"); - z.press(4); - assert_eq!(z.factor(false), 4.0); - assert_eq!(z.factor(true), 1.0, "the spyglass wins"); - assert!((fov_target(1.0, 4.0) - 0.25).abs() < 1e-6); - assert!(z.scroll(1.0)); - assert!((z.factor(false) - 5.0).abs() < 1e-5); - for _ in 0..40 { - z.scroll(1.0); - } - assert_eq!(z.factor(false), ZOOM_MAX); - for _ in 0..80 { - z.scroll(-1.0); - } - assert_eq!(z.factor(false), ZOOM_MIN); - z.release(); - assert_eq!(z.factor(false), 1.0); - z.press(2); - assert_eq!(z.factor(false), 2.0, "each press starts at the default"); - } - - #[test] - fn zoom_target_eases_like_the_spyglass() { + fn a_mods_zoom_eases_like_the_spyglass() { // Camera.tickFov halves the distance to the target each tick. let mut camera = crate::camera::Camera::default(); camera.tick(None, 1.0); @@ -835,55 +600,6 @@ mod tests { assert!((floor - 7.0).abs() < 1e-3, "{floor}"); } - #[test] - fn the_zoom_key_only_zooms_while_playing() { - let mut z = Zoom::default(); - // In chat, a sign, a text field or any screen: no zoom. - z.key(true, false, false, 4); - assert!(!z.held()); - z.key(true, false, true, 4); - assert!(z.held()); - // A screen opening while held lets go (its key presses are the screen's). - z.key(true, true, false, 4); - assert!(!z.held()); - // Key repeats do not restart a zoom the wheel changed. - z.key(true, false, true, 4); - z.scroll(1.0); - z.key(true, true, true, 4); - assert!((z.factor(false) - 5.0).abs() < 1e-5); - z.key(false, false, true, 4); - assert!(!z.held()); - } - - #[test] - fn zoom_key_conflicts_name_the_vanilla_mappings() { - let mut e = Extras::default(); - let mut keys = crate::keybinds::KeyBinds::default(); - assert!(zoom_key_conflicts(&e, &keys).is_empty()); - e.zoom_key = "key.keyboard.c".into(); - assert_eq!( - zoom_key_conflicts(&e, &keys), - [ - "key.saveToolbarActivator", - "key.debug.crash", - "key.debug.copyLocation" - ] - ); - keys.set("key.drop", "key.keyboard.z"); - e.zoom_key = "key.keyboard.z".into(); - assert_eq!(zoom_key_conflicts(&e, &keys), ["key.drop"]); - e.zoom_key = "key.keyboard.unknown".into(); - keys.set("key.smoothCamera", "key.keyboard.unknown"); - assert!(zoom_key_conflicts(&e, &keys).is_empty()); - } - - #[test] - fn sensitivity_scales_with_zoom() { - assert_eq!(turn_scale(1.0, true), 1.0); - assert_eq!(turn_scale(4.0, false), 1.0); - assert_eq!(turn_scale(4.0, true), 0.25); - } - #[test] fn fps_counter_reports_rate_minimum_and_low() { let mut c = FpsCounter::default(); @@ -937,20 +653,9 @@ mod tests { #[test] fn items_cycle_through_their_values() { let mut e = Extras::default(); - Item::ZoomLevel.cycle(&mut e, false); - assert_eq!(e.zoom_level, 6); - Item::ZoomLevel.cycle(&mut e, true); - Item::ZoomLevel.cycle(&mut e, true); - assert_eq!(e.zoom_level, 3); - Item::FpsCorner.cycle(&mut e, true); - assert_eq!(e.fps_corner, Corner::BottomRight); - Item::Zoom.cycle(&mut e, false); - assert_eq!(Item::Zoom.switch(&e), Some(true)); - assert_eq!(Item::ZoomKey.value(&e), "Z"); - Item::MinimapZoom.cycle(&mut e, true); - assert_eq!(Item::MinimapZoom.value(&e), "½ block per pixel"); - Item::MinimapSize.cycle(&mut e, false); - assert_eq!(Item::MinimapSize.value(&e), "Large"); + Item::Sort.cycle(&mut e, true); + assert_eq!(Item::Sort.value(&e), "On"); + // The minimap's old keys still parse, for the move to its mod. assert_eq!( Extras::parse("minimapSize:7\nminimapZoom:3").minimap_zoom, 1.0 diff --git a/crates/horizon-client/src/extras_hud.rs b/crates/horizon-client/src/extras_hud.rs index f6fc1ba12..cc26e15d4 100644 --- a/crates/horizon-client/src/extras_hud.rs +++ b/crates/horizon-client/src/extras_hud.rs @@ -1,7 +1,7 @@ -//! The extras' HUD overlays (FPS counter, keystrokes): small boxes in the -//! vanilla font, in GUI pixels, stacked per corner (`docs/extras.md`). +//! HUD boxes in the corners: the minimap's place and mods' panels, small +//! boxes in GUI pixels stacked per corner (`docs/extras.md`). use crate::{ - extras::{Corner, FpsReading}, + extras::Corner, hud::{HudAtlas, HudBatch, Rect, rgba}, }; @@ -99,36 +99,6 @@ pub fn draw_minimap( } } -/// The FPS counter's text. -pub fn fps_text(r: FpsReading, lows: bool) -> String { - if lows { - format!("{} fps min {} 1% {}", r.fps, r.min, r.low) - } else { - format!("{} fps", r.fps) - } -} -pub fn draw_fps( - batch: &mut HudBatch, - atlas: &HudAtlas, - corners: &mut Corners, - corner: Corner, - reading: FpsReading, - lows: bool, -) { - let text = fps_text(reading, lows); - let w = HudBatch::text_width(atlas, &text) + 4.0; - let (x, y) = corners.place(corner, w, 12.0); - batch.fill(atlas, x, y, w, 12.0, BACKGROUND); - batch.text( - atlas, - &text, - x + 2.0, - y + 2.0, - rgba(255, 255, 255, 255), - true, - ); -} - /// A box of text lines (a mod's HUD panel): `(text, 0xRRGGBB)` each. pub fn draw_lines( batch: &mut HudBatch, @@ -155,95 +125,6 @@ pub fn draw_lines( } } -/// What the keystroke overlay shows. -pub struct Keystrokes { - /// Forward, left, back, right: held, and the bound key's name. - pub moves: [(bool, String); 4], - pub jump: bool, - pub attack: bool, - pub use_: bool, - /// Clicks per second of the left and right buttons, when shown. - pub cps: Option<(usize, usize)>, -} -const KEY: f32 = 22.0; -const GAP: f32 = 2.0; -/// The overlay's size. -pub fn keystrokes_size() -> (f32, f32) { - (3.0 * KEY + 2.0 * GAP, 3.0 * KEY + 3.0 * GAP + 10.0) -} -fn key_box(batch: &mut HudBatch, atlas: &HudAtlas, rect: [f32; 4], held: bool, lines: &[&str]) { - let [x, y, w, h] = rect; - let (fill, ink) = if held { - (rgba(255, 255, 255, 176), rgba(20, 20, 20, 255)) - } else { - (BACKGROUND, rgba(255, 255, 255, 255)) - }; - batch.fill(atlas, x, y, w, h, fill); - let total = lines.len() as f32 * 9.0 - 1.0; - for (i, line) in lines.iter().enumerate() { - let tw = HudBatch::text_width(atlas, line); - let tx = (x + (w - tw) / 2.0).round(); - let ty = (y + (h - total) / 2.0).round() + i as f32 * 9.0; - batch.text(atlas, line, tx, ty, ink, !held); - } -} -pub fn draw_keystrokes( - batch: &mut HudBatch, - atlas: &HudAtlas, - corners: &mut Corners, - corner: Corner, - k: &Keystrokes, -) { - let (w, h) = keystrokes_size(); - let (x, y) = corners.place(corner, w, h); - let step = KEY + GAP; - let [forward, left, back, right] = &k.moves; - key_box( - batch, - atlas, - [x + step, y, KEY, KEY], - forward.0, - &[&forward.1], - ); - for (i, key) in [left, back, right].into_iter().enumerate() { - key_box( - batch, - atlas, - [x + i as f32 * step, y + step, KEY, KEY], - key.0, - &[&key.1], - ); - } - let mw = (w - GAP) / 2.0; - let my = y + 2.0 * step; - for (i, (held, label, cps)) in [ - (k.attack, "LMB", k.cps.map(|c| c.0)), - (k.use_, "RMB", k.cps.map(|c| c.1)), - ] - .into_iter() - .enumerate() - { - let rate = cps.map(|n| format!("{n} CPS")); - let lines: Vec<&str> = std::iter::once(label).chain(rate.as_deref()).collect(); - key_box( - batch, - atlas, - [x + i as f32 * (mw + GAP), my, mw, KEY], - held, - &lines, - ); - } - // The space bar: a line in a short key. - let sy = my + step; - key_box(batch, atlas, [x, sy, w, 10.0], k.jump, &[]); - let ink = if k.jump { - rgba(20, 20, 20, 255) - } else { - rgba(255, 255, 255, 255) - }; - batch.fill(atlas, x + w / 2.0 - 12.0, sy + 4.0, 24.0, 2.0, ink); -} - #[cfg(test)] mod tests { use super::*; @@ -259,15 +140,4 @@ mod tests { assert_eq!(c.place(Corner::BottomRight, 50.0, 10.0), (348.0, 274.0)); assert_eq!(c.place(Corner::BottomLeft, 10.0, 10.0), (2.0, 288.0)); } - - #[test] - fn fps_text_with_and_without_lows() { - let r = FpsReading { - fps: 144, - min: 61, - low: 98, - }; - assert_eq!(fps_text(r, false), "144 fps"); - assert_eq!(fps_text(r, true), "144 fps min 61 1% 98"); - } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 4638a4667..b397882cd 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -103,6 +103,7 @@ mod mod_render; mod mods; mod mount_menu; mod mounts; +mod moved_extras; mod moving_pistons; mod music; mod names; @@ -130,6 +131,7 @@ mod pumpkin; mod raids; mod recipe_book; mod remote; +mod remote_chunks; mod remote_mob_data; mod remote_mob_use; mod remote_objects; @@ -557,6 +559,8 @@ struct GameLevel<'w> { /// Where the chunk tickets let blocks tick. tickets: horizon_client::ticket_levels::Levels, random_tick_sections: &'w mut horizon_client::random_tick_sections::RandomTickSections, + /// Players with each chest open (a trapped chest's signal). + lid_openers: &'w HashMap<(i32, i32, i32), i32>, } struct PlayerCollision { y: f64, @@ -692,6 +696,10 @@ impl LevelAccess for GameLevel<'_> { _state: BlockStateId, _direction: Direction, ) -> i32 { + // TrappedChestBlock.getSignal: the players with it open, at most 15. + if let Some(count) = self.lid_openers.get(&(pos.x, pos.y, pos.z)) { + return (*count).clamp(0, 15); + } jukebox::jukebox_signals(self.world, self.items, pos).map_or(0, |(signal, _)| signal) } fn biome_name(&self, pos: BlockPos) -> Option<&str> { @@ -1504,7 +1512,7 @@ struct Game<'a> { pending_bench: Option<(Instant, std::sync::mpsc::Sender)>, /// Recent frame times for the performance overlay. frame_graph: horizon_client::perf_overlay::FrameGraph, - /// Horizon's extras (zoom, FPS counter, keystrokes): `game/extras.rs`. + /// Horizon's extras (minimap, auto-reconnect; mods' counters): `game/extras.rs`. extras: extras::ExtrasState, /// Horizon mods (`game/mods.rs`), none running unless turned on. mods: mods::ModsState, @@ -2202,7 +2210,7 @@ impl Game<'_> { self.player_drop(thrown); } /// `Player.drop`: the statistics and a thrown item entity in front of the player. - fn player_drop(&mut self, thrown: ItemStack) { + pub(super) fn player_drop(&mut self, thrown: ItemStack) { let Some(eye) = self.eye_position() else { return; }; @@ -2264,7 +2272,13 @@ impl Game<'_> { let speed = self.world.random.next_float() * 0.2 + 0.1; item.move_towards_closest_space(&self.world, self.res.facts(), speed); } - let alive = item.tick(&self.world, self.res.facts(), self.collision, no_physics); + let alive = item.tick( + &self.world, + self.res.facts(), + self.collision, + no_physics, + &self.res.motion().fluids, + ); cells.moved(i, item.previous, item.position); // ItemEntity.tick: merge every 2 ticks while moving between // blocks, every 40 otherwise, before the lifetime check. @@ -2473,6 +2487,7 @@ impl Game<'_> { spill: &mut self.spill, tickets: self.tickets.levels(), random_tick_sections: &mut self.random_tick_sections, + lid_openers: &self.lid_openers, }; let result = f(self.res.behaviours(), &mut level, &mut self.block_ticks); self.flush_spill(); @@ -4185,6 +4200,9 @@ impl Game<'_> { self.with_level(|b, level, ticks| b.notify_written(level, ticks, position, flags)); } fn tick(&mut self) -> Result<()> { + if self.agent.hold_server { + return Ok(()); + } self.tick_debug_keys()?; self.tick_debug_charts(); if self.remote.is_some() { @@ -5592,6 +5610,8 @@ impl Game<'_> { self.craft_size = 2; self.craft_table = None; if let Some(key) = self.container.take() { + // A cart's or chest boat's items go back to it. + self.close_cart_container(key); self.container_opener_event(key, false); self.post_block_game_event( "minecraft:container_close", @@ -5631,7 +5651,6 @@ impl Game<'_> { self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } self.close_ender_chest(); - self.close_cart_container(); } /// `quickMoveStack` of the open plain menu for a shift-click. fn inventory_quick_move(&mut self, slot: usize) -> bool { @@ -6511,7 +6530,11 @@ impl Game<'_> { use horizon_client::menu::Input; let button = i32::from(right); if self.remote.is_some() { - self.remote_throw(right, input); + if self.screen == Screen::Creative { + self.remote_creative_drop(right); + } else { + self.remote_throw(right, input); + } return; } let before = self.carried.clone(); @@ -10495,7 +10518,10 @@ impl Game<'_> { menu_blur: self.menu_blur(), }; let result = match self.renderer.as_mut() { - Some(renderer) => horizon_client::spans::time("renderer", || renderer.render(&frame)), + Some(renderer) => { + renderer.set_pass_timing(self.debug); + horizon_client::spans::time("renderer", || renderer.render(&frame)) + } None => Err("renderer".into()), }; // Restore storage even when rendering fails (for example, a lost surface). @@ -10625,6 +10651,9 @@ impl Game<'_> { } return Ok(()); } + if self.screen == Screen::Mod && self.mod_screen_key(key) { + return Ok(()); + } if self.sort_key_press(key) { return Ok(()); } @@ -10992,11 +11021,7 @@ impl Game<'_> { bytes += size; } } - for c in unloaded { - for sy in 0..(HEIGHT / 16) { - renderer.remove((c.x, sy, c.z)); - } - } + renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z))); if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info); lod.set_near_loading(self.streaming.busy()); @@ -11292,7 +11317,6 @@ impl ApplicationHandler for Game<'_> { && self.sleeping.is_none() && self.player.is_some() && !self.mod_wheel(d) - && !self.extras_scroll(d) && let Some((wheel, (_, vertical_steps))) = self.mouse .on_scroll(raw_x, raw_y, discrete, wheel_sensitivity) @@ -11554,9 +11578,7 @@ impl ApplicationHandler for Game<'_> { self.stats_click(size); } Screen::Stats if button == MouseButton::Left => self.stats_release(), - Screen::Mod if pressed && button == MouseButton::Left => { - self.mod_screen_click() - } + Screen::Mod if pressed => self.mod_screen_click(button), _ => {} } } @@ -11705,7 +11727,6 @@ impl ApplicationHandler for Game<'_> { let PhysicalKey::Code(key) = event.physical_key else { return Ok(()); }; - self.extras_key(key, event.state == ElementState::Pressed, event.repeat); self.mod_key(key, event.state == ElementState::Pressed, event.repeat); // key.smoothCamera toggles the cinematic camera. if self.screen == Screen::Playing @@ -11798,6 +11819,7 @@ impl ApplicationHandler for Game<'_> { } self.extras_frame(elapsed); self.mods_frame(elapsed); + self.poll_moved_extras(); self.extras_retry()?; self.apply_mouse_look(); self.pad_look(elapsed.as_secs_f32()); @@ -13148,6 +13170,7 @@ fn start_game<'a>( // Benchmarks measure the game alone. if game.options.benchmark.is_none() { game.mods.dev = game.options.dev_mods.clone(); + game.start_moved_extras(); game.start_mods(); } game.start_agent_control()?; diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 2686b85fd..fa9dbf3c6 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -300,6 +300,8 @@ struct Glide { pub(super) struct Agent { task: Option, glide: Option, + /// Control-fixture barrier: hold simulation and packet handling, not transport threads. + pub hold_server: bool, } pub(super) enum Handled { @@ -479,6 +481,8 @@ impl Game<'_> { "absorption": p.health.absorption(), // The hurt animation's ticks left (the camera's hurt tilt). "hurt_time": p.health.hurt_animation_time, + // LivingEntity.deathTime while dead (the camera's death roll). + "death_time": self.death_time(), "air": p.air, "food": p.health.food.food, "saturation": p.health.food.saturation, @@ -667,6 +671,7 @@ impl Game<'_> { }); if let Some(chat) = &self.ui.chat_screen { v["chat_input"] = json!(chat.input.value); + v["chat_suggestions"] = json!(chat.suggestions_visible()); } if self.title.is_some() { v["menu"] = self.title_value(); diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs index 55f9c42ba..3d452596e 100644 --- a/crates/horizon-client/src/game/block_entity_anims.rs +++ b/crates/horizon-client/src/game/block_entity_anims.rs @@ -13,7 +13,10 @@ use horizon_client::{ save::number, skins, }; -use horizon_core::geometry::{Aabb, Vec3}; +use horizon_core::{ + geometry::{Aabb, Vec3}, + position::BlockPos, +}; use horizon_world::nbt::Tag; /// The handle of the local player among a bell's gathered entities. @@ -86,6 +89,16 @@ impl Game<'_> { self.lid_openers_changed(other, open); } } + _ if self + .res + .facts() + .get(self.world.block(pos[0], pos[1], pos[2])) + .name + .as_ref() + == "minecraft:barrel" => + { + self.barrel_openers_changed(key, open); + } Some(Ticker::Shulker { .. }) => { let shulker = self.be_anims.shulkers.entry(pos).or_default(); let (count, _) = if open { @@ -104,15 +117,48 @@ impl Game<'_> { /// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here /// and for the guests. fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { - let count = self.lid_openers.entry(key).or_default(); - *count = (*count + if open { 1 } else { -1 }).max(0); - let count = *count; - if count == 0 { - self.lid_openers.remove(&key); - } + let (before, count) = self.count_opener(key, open); let pos = [key.0, key.1, key.2]; self.block_entity_event(pos, 1, count); self.lan_block_event(pos, 1, count); + // TrappedChestBlockEntity.signalOpenCount: its signal is the count + // (`TrappedChestBlock.getSignal`), so the blocks around it and + // below it hear of a change. + let state = self.world.block(pos[0], pos[1], pos[2]); + if before != count && self.res.facts().get(state).name.as_ref() == "minecraft:trapped_chest" + { + let p = BlockPos::new(pos[0], pos[1], pos[2]); + self.with_level(|b, level, ticks| { + let block = b.block(state); + b.update_neighbors_at(level, ticks, p, block); + b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block); + }); + } + } + /// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel + /// (`open=true`), the last one to leave closes it (`updateBlockState`). + fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) { + let (before, count) = self.count_opener(key, open); + if (before == 0) != (count == 0) { + self.set_bool_prop( + key, + "open", + count > 0, + horizon_world::level::flags::UPDATE_ALL, + ); + } + } + /// One opener more (`open`) or less at `key`: the count before and after + /// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`). + fn count_opener(&mut self, key: (i32, i32, i32), open: bool) -> (i32, i32) { + let count = self.lid_openers.entry(key).or_default(); + let before = *count; + *count = (before + if open { 1 } else { -1 }).max(0); + let after = *count; + if after == 0 { + self.lid_openers.remove(&key); + } + (before, after) } /// `BellBlockEntity.updateEntities`: the living entities whose bounding /// box meets the bell's block box inflated by 48. @@ -173,6 +219,11 @@ impl Game<'_> { /// client tick (`ClientLevel.tickBlockEntities`). pub(super) fn tick_block_entity_anims(&mut self) { let Some(r) = &self.renderer else { + // A server has no window, but its gateways still run their + // server ticker. + if self.remote.is_none() { + self.tick_gateway_servers(); + } return; }; // Sorted by position: the order they tick in, and a quick lookup. @@ -332,6 +383,31 @@ impl Game<'_> { } self.be_anims.present = positions; } + /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the + /// gateways a server keeps a copy of, in block-ticking chunks + /// (`Level.tickBlockEntities`): the cooldown an entry started runs out, + /// and every 2400 ticks `triggerCooldown` sends its block event. + fn tick_gateway_servers(&mut self) { + let levels = self.tickets.levels(); + let mut positions: Vec<[i32; 3]> = self + .be_anims + .gateway_servers + .keys() + .copied() + .filter(|p| levels.block_ticking_at(p[0], p[2])) + .collect(); + positions.sort_unstable(); + for pos in positions { + let triggered = self + .be_anims + .gateway_servers + .get_mut(&pos) + .is_some_and(EndGateway::portal_tick); + if triggered { + self.block_entity_event(pos, 1, 0); + } + } + } /// `EndGatewayBlock.entityInside` on the server: whether the gateway at /// `pos` let the entity in (`triggerCooldown`, with its block event). pub(super) fn gateway_enter(&mut self, pos: [i32; 3]) -> bool { diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 76e10cb57..f3afdcab6 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1097,6 +1097,12 @@ impl Game<'_> { Target::Player => { // ServerPlayer.teleport: removeVehicle before placing the player. self.stop_riding(); + // A server's player teleported within their level is placed + // there at once: the arrival they were waiting for elsewhere + // in it (whose chunks lose their tickets) is abandoned. + if let Some(conn) = self.lan_acting { + self.server_trips.retain(|trip| !trip.is(conn)); + } if let Some(p) = self.player.as_mut() { p.position = v; p.velocity = Vec3::new(0.0, 0.0, 0.0); diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index f418b0b83..3202b23f4 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -11,6 +11,9 @@ use winit::{event::MouseButton, event_loop::ActiveEventLoop, keyboard::KeyCode}; const HELP: &[&str] = &[ "status game, player, streaming and renderer state", + "simulation authoritative projectiles in the owner's level", + "server-hold on|off hold simulation and player packets at a control-fixture barrier", + "stall MILLISECONDS stall the window thread (0..5000), leaving transport alive", "key KEY down|up|tap|repeat press, release or auto-repeat a key (w a s d space shift ctrl e q esc f3 1-9 arrows ...)", "release release every key and mouse button", "mouse left|right|middle down|up|click", @@ -238,6 +241,47 @@ impl Game<'_> { } "sculk" => Ok(Some(self.sculk_command(&words)?)), "status" => Ok(Some(self.control_status())), + "stall" => { + let millis: u64 = arg(1)?.parse()?; + if millis > 5000 { + return Err("stall is limited to 5000 milliseconds".into()); + } + std::thread::sleep(Duration::from_millis(millis)); + ok() + } + "simulation" => { + self.require_world()?; + let value = if let Some(server) = &self.integrated { + server + .call(|g| { + g.in_owner_level(|g| { + json!({ "game_time": g.world.game_time, "projectiles": g.projectiles_status() }) + }) + }) + .ok_or("the integrated server stopped")? + } else { + json!({ "game_time": self.world.game_time, "projectiles": self.projectiles_status() }) + }; + Ok(Some(value)) + } + "server-hold" => { + self.require_world()?; + let held = match arg(1)? { + "on" => true, + "off" => false, + _ => return Err("server-hold on|off".into()), + }; + if let Some(server) = &self.integrated { + server + .call(move |g| g.agent.hold_server = held) + .ok_or("the integrated server stopped")?; + } else if self.remote.is_some() { + return Err("server-hold requires the world's host".into()); + } else { + self.agent.hold_server = held; + } + ok() + } "pad" => Ok(Some(self.pad_command(&words)?)), "key" => { let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?; @@ -295,13 +339,9 @@ impl Game<'_> { self.debug_key(key, KeyAction::Release); } } - // The zoom extra sees the key as the keyboard hook does. + // Mods' keys (capability `input`) see the key as the keyboard + // hook does. let action = arg(2)?; - self.extras_key(physical, action != "up", action == "repeat"); - if action == "tap" { - self.extras_key(physical, false, false); - } - // So do mods' keys (capability `input`). self.mod_key(physical, action != "up", action == "repeat"); if action == "tap" { self.mod_key(physical, false, false); @@ -379,15 +419,19 @@ impl Game<'_> { match arg(2)? { "down" => { self.extras_mouse(button, true); + self.mod_mouse_key(button, true); self.play_mouse(button, true)? } "up" => { self.extras_mouse(button, false); + self.mod_mouse_key(button, false); self.play_mouse(button, false)? } "click" => { self.extras_mouse(button, true); + self.mod_mouse_key(button, true); self.extras_mouse(button, false); + self.mod_mouse_key(button, false); self.play_mouse(button, true)?; self.play_mouse(button, false)?; } @@ -508,10 +552,23 @@ impl Game<'_> { "mobs" => { self.require_world()?; let radius: f64 = words.get(1).map_or(Ok(64.0), |r| r.parse())?; + if let Some(server) = &self.integrated { + let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + let value = server + .call(move |g| g.in_owner_level(|g| g.control_mobs_at(radius, center))) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_mobs(radius))) } "hurtlog" => { self.require_world()?; + if let Some(server) = &self.integrated { + let value = server + .call(|g| g.control_hurt_log()) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_hurt_log())) } "resume" => { @@ -612,6 +669,7 @@ impl Game<'_> { "font" => Page::Font, "packs" => Page::Packs, "mods" => Page::Mods, + "shader-packs" => Page::ShaderPacks, "graphics" => Page::Graphics, "graphics-advanced" => Page::GraphicsAdvanced, "extras" => Page::Extras, @@ -625,6 +683,10 @@ impl Game<'_> { } self.open_options(self.title.is_some()); self.ui.options.show(page); + if page == Page::ShaderPacks { + self.settings.shader_packs = + horizon_client::shader_pack_list::scan(&Self::shader_packs_dir()); + } ok() } "chat-log" => { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..3a8562ee1 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -312,6 +312,9 @@ impl Game<'_> { /// The `mobs` command: nearby mobs with position, health and running goals. pub(super) fn control_mobs(&self, radius: f64) -> serde_json::Value { let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + self.control_mobs_at(radius, center) + } + pub(super) fn control_mobs_at(&self, radius: f64, center: Vec3) -> serde_json::Value { let list: Vec = self .mobs .iter() @@ -504,6 +507,17 @@ impl Game<'_> { Some(host) if !guests.is_empty() => std::mem::take(&mut host.mob_players), _ => Default::default(), }; + // The guests' entity ids by connection, for the shulker bullets fired + // at the guest a mob sees. + let guest_ids: Vec<(u32, u32)> = match self.lan.as_ref() { + Some(host) if !guests.is_empty() => host + .hub + .guests + .iter() + .map(|g| (g.conn, g.entity_id as u32)) + .collect(), + _ => Vec::new(), + }; let mut guest_events = Vec::new(); let level_random; { @@ -578,6 +592,19 @@ impl Game<'_> { let kept = m.tick(&w, &mut scratch, &mut events); horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes); if let Some(conn) = seen_guest { + // ShulkerBullet.finalTarget is the guest's entity: the + // bullet homes on it while the projectiles tick, where + // `Who::Player` is the host's own player. + if let Some(&(_, id)) = guest_ids.iter().find(|g| g.0 == conn) { + for e in &mut events[from..] { + if let MobEvent::Projectile(p) = e + && let ProjectileKind::ShulkerBullet { target, .. } = &mut p.kind + && *target == Who::Player + { + *target = Who::Mob(id); + } + } + } let mut k = from; while k < events.len() { if super::lan_mobs::acts_on_player(&events[k]) { diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index 61e2b2f05..16e7fc6e7 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -415,6 +415,13 @@ impl Game<'_> { ], ); } + // Horizon's own: the shader pack's GPU time per pass (an empty group would move others). + let pass_lines = self.renderer.as_ref().map_or_else(Vec::new, |r| { + debug_overlay::shader_pass_lines(&r.shader_pass_times()) + }); + if !pass_lines.is_empty() { + d.group("shader pack", pass_lines); + } // tps: DebugEntryTps for local and remote connections. if self.player.is_some() { let [tx, rx] = self.debug_charts.packet_rates.map(|n| n.round() as i64); diff --git a/crates/horizon-client/src/game/extras.rs b/crates/horizon-client/src/game/extras.rs index a04196b69..4d21f5288 100644 --- a/crates/horizon-client/src/game/extras.rs +++ b/crates/horizon-client/src/game/extras.rs @@ -1,24 +1,22 @@ -//! Horizon's extras in the game (`docs/extras.md`): the zoom key and wheel, -//! clicks for the keystroke overlay, frame times for the FPS counter, the -//! minimap's tiles and image, and their HUD. Each hook does nothing while its -//! extra is off. +//! Horizon's extras in the game (`docs/extras.md`); a mod's minimap +//! (`render.set-minimap`: its tiles, image and HUD) and zoom (`render.set-zoom`) on the camera; clicks +//! and frame times for mods (`input.clicks-per-second`, `render.frame-stats`). +//! Each hook does nothing while its extra is off and no mod runs. use super::{Dim, Game, Screen}; use horizon_client::{ - extras::{Corner, Cps, FpsCounter, Zoom, fov_target, turn_scale}, - extras_hud::{self, Corners, Keystrokes}, + extras::{Corner, Cps, FpsCounter, fov_target}, + extras_hud::{self, Corners}, hud::{HudBatch, MINIMAP_SPRITE}, - keybinds, minimap::{self, Layer, Minimap, View}, multiplayer, reconnect::{Retry, Tracker}, title::Mode, }; use std::time::Duration; -use winit::{event::MouseButton, keyboard::KeyCode}; +use winit::event::MouseButton; #[derive(Default)] pub(super) struct ExtrasState { - zoom: Zoom, fps: FpsCounter, /// Left and right mouse buttons: held, and their clicks. mouse: [bool; 2], @@ -36,42 +34,16 @@ impl Game<'_> { fn extras_now(&self) -> f64 { self.started.elapsed().as_secs_f64() } - fn zoom_key(&self) -> Option { - let e = &self.settings.extras; - e.zoom.then(|| keybinds::key_code(&e.zoom_key)).flatten() - } - /// A key press or release. The zoom key zooms only while playing with - /// no text open; the key itself always goes on to the screen and the key - /// binds, as a vanilla key mapping's would. - pub(super) fn extras_key(&mut self, key: KeyCode, pressed: bool, repeat: bool) { - if self.zoom_key() != Some(key) { - return; - } - let playing = self.screen == Screen::Playing - && self.title.is_none() - && self.sign_edit.is_none() - && self.book.is_none(); - let level = self.settings.extras.zoom_level; - self.extras.zoom.key(pressed, repeat, playing, level); - } - /// Wheel steps while playing; true when zooming took them from the hotbar. - pub(super) fn extras_scroll(&mut self, steps: f32) -> bool { - self.settings.extras.zoom && self.extras.zoom.scroll(steps) - } - /// Mouse buttons while playing, for zoom and the keystroke overlay. + /// Mouse buttons while playing, for mods' clicks. pub(super) fn extras_mouse(&mut self, button: MouseButton, pressed: bool) { - let e = &self.settings.extras; - if e.zoom && e.zoom_key == keybinds::mouse_name(button) { - self.extras.zoom.key(pressed, false, true, e.zoom_level); - } let i = match button { MouseButton::Left => 0, MouseButton::Right => 1, _ => return, }; self.extras.mouse[i] = pressed; - // Mods read the clicks too (`input.clicks-per-second`). - if pressed && (self.settings.extras.keystrokes || self.mods.running()) { + // For mods (`input.clicks-per-second`). + if pressed && self.mods.running() { let now = self.extras_now(); self.extras.cps[i].click(now); } @@ -81,15 +53,12 @@ impl Game<'_> { // Under agent control the window may lack focus without pausing. let focused = self.focused || self.control.is_some(); let playing = self.screen == Screen::Playing && self.title.is_none() && focused; - if !playing || !self.settings.extras.zoom { - self.extras.zoom.release(); - } if !playing { self.extras.mouse = [false; 2]; } self.update_minimap(); - // Mods read the counter too (`render.frame-stats`). - if self.settings.extras.fps || self.mods.running() { + // For mods (`render.frame-stats`). + if self.mods.running() { let now = self.extras_now(); self.extras.fps.record(now, elapsed.as_secs_f32() * 1000.0); } else { @@ -159,25 +128,29 @@ impl Game<'_> { } Ok(()) } - /// The minimap's view of the player, if it shows. - fn minimap_view(&self) -> Option { - let e = &self.settings.extras; + /// The minimap a mod shows (`render.set-minimap`): its corner, its side + /// in GUI pixels and its view of the player. + fn minimap_shown(&self) -> Option<(Corner, f32, View)> { let p = self.player.as_ref()?; - let shown = e.minimap && self.title.is_none() && !self.ui.hide_gui; - shown.then_some(View { + if self.title.is_some() || self.ui.hide_gui { + return None; + } + let m = self.mod_minimap()?; + let view = View { x: p.position.x, z: p.position.z, yaw: self.yaw, - rotate: e.minimap_rotate, - blocks_per_pixel: e.minimap_zoom, - round: e.minimap_round, - }) + rotate: m.rotate, + blocks_per_pixel: m.blocks_per_pixel, + round: m.round, + }; + Some((m.corner, m.size, view)) } /// Refresh the minimap's tiles within the frame budget, recompose its /// image when the view or a tile changed, and queue the upload. fn update_minimap(&mut self) { - let Some(view) = self.minimap_view() else { - if !self.settings.extras.minimap || self.player.is_none() { + let Some((_, _, view)) = self.minimap_shown() else { + if self.mod_minimap().is_none() || self.player.is_none() { self.extras.minimap.clear(); self.extras.minimap_dim = None; } @@ -225,24 +198,12 @@ impl Game<'_> { rgba: self.extras.minimap.image.clone(), }); } - /// The zoom in effect (1 unless the key is held). - fn zoom_factor(&self) -> f32 { - self.extras.zoom.factor(self.scoping()) - } - /// The zoom in effect, the extra's or a mod's (`render.set-zoom`), - /// whichever is stronger: (factor, smooth, turning scale). + /// A mod's zoom in effect (`render.set-zoom`): (factor, smooth, turning + /// scale); none is 1. fn zoom_now(&self) -> (f32, bool, f64) { - let factor = self.zoom_factor(); - let e = &self.settings.extras; - let own = ( - factor, - e.zoom_smooth, - turn_scale(factor, e.zoom_sensitivity), - ); - match self.mod_zoom() { - Some(z) if z.factor > factor => (z.factor, z.smooth, f64::from(z.turn)), - _ => own, - } + self.mod_zoom().map_or((1.0, true, 1.0), |z| { + (z.factor, z.smooth, f64::from(z.turn)) + }) } /// The field-of-view modifier target, divided by a smooth zoom. pub(super) fn zoomed_fov_target(&self, vanilla: f32) -> f32 { @@ -262,21 +223,18 @@ impl Game<'_> { pub(super) fn zoom_turn_scale(&self) -> f64 { self.zoom_now().2 } - /// The FPS counter and keystrokes, in the HUD layer (hidden with F1 by - /// the caller). The top left corner gives way to the debug screen. + /// The minimap and mods' corner panels, in the HUD layer (hidden with F1 + /// by the caller). The top left corner gives way to the debug screen. pub(super) fn draw_extras(&mut self, batch: &mut HudBatch) { - let e = &self.settings.extras; let mod_panels = self.mods.has_panels(); - if !e.fps && !e.keystrokes && !e.minimap && !mod_panels { + let map = self.minimap_shown(); + if map.is_none() && !mod_panels { return; } - let (fps_on, fps_corner, lows) = (e.fps, e.fps_corner, e.fps_lows); - let (keys_on, keys_corner, cps_on) = (e.keystrokes, e.keystrokes_corner, e.keystrokes_cps); - let (map_corner, map_size) = (e.minimap_corner, f32::from(e.minimap_size)); let visible = |corner| !(self.debug && corner == Corner::TopLeft); let mut corners = Corners::new(batch.width, batch.height, self.effect_rows_height()); let atlas = &self.gui.atlas; - if let Some(view) = self.minimap_view() + if let Some((map_corner, map_size, view)) = map && visible(map_corner) && !self.extras.minimap.image.is_empty() && let Some(image) = atlas.sprites.get(MINIMAP_SPRITE).copied() @@ -295,32 +253,6 @@ impl Game<'_> { }; extras_hud::draw_minimap(batch, atlas, &mut corners, &look); } - if fps_on && visible(fps_corner) { - let reading = self.extras.fps.reading(); - extras_hud::draw_fps(batch, atlas, &mut corners, fps_corner, reading, lows); - } - if keys_on && visible(keys_corner) { - let now = self.extras_now(); - let cps = cps_on.then(|| { - let [l, r] = &mut self.extras.cps; - (l.per_second(now), r.per_second(now)) - }); - let held = |k| self.keys.contains(&k); - let label = |name| keybinds::display_name(self.settings.keys.get(name)).plain(); - let k = Keystrokes { - moves: [ - (held(KeyCode::KeyW), label("key.forward")), - (held(KeyCode::KeyA), label("key.left")), - (held(KeyCode::KeyS), label("key.back")), - (held(KeyCode::KeyD), label("key.right")), - ], - jump: held(KeyCode::Space), - attack: self.extras.mouse[0], - use_: self.extras.mouse[1], - cps, - }; - extras_hud::draw_keystrokes(batch, &self.gui.atlas, &mut corners, keys_corner, &k); - } if mod_panels { self.draw_mod_panels(batch, &mut corners); } diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs index 7838c9590..e6b4eb136 100644 --- a/crates/horizon-client/src/game/fireworks.rs +++ b/crates/horizon-client/src/game/fireworks.rs @@ -71,6 +71,18 @@ impl Rocket { (self.position, self.velocity) } } +/// `damageAmount * (float)Math.sqrt((5.0 - this.distanceTo(target)) / 5.0)` +/// from the rocket at `from` to a target at `to`; `Entity.distanceTo` sums +/// the squared offsets in floats. +fn blast_damage(damage: f32, from: Vec3, to: Vec3) -> f32 { + let (x, y, z) = ( + (from.x - to.x) as f32, + (from.y - to.y) as f32, + (from.z - to.z) as f32, + ); + let distance = f64::from(x * x + y * y + z * z).sqrt() as f32; + damage * ((5.0 - f64::from(distance)) / 5.0).sqrt() as f32 +} pub(super) fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { // The item's default component: flight 1, no explosions. stack @@ -251,21 +263,24 @@ impl Game<'_> { let at = [r.position.x, r.position.y, r.position.z]; if !r.explosions.is_empty() { let damage = 5.0 + r.explosions.len() as f32 * 2.0; - // The player it boosts takes the full damage, a guest as well. - if r.attached { - match r.guest { - None => self.hurt_player_by("minecraft:fireworks", damage), - Some(conn) => { - if let Some(mut host) = self.lan.take() { - self.as_guest(&mut host, conn, |g| { - g.hurt_player_by("minecraft:fireworks", damage); - }); - self.lan = Some(host); - } - } - } - } let from = r.position; + // `attachedToEntity` takes the full damage, a guest as well; every + // other player in range and in sight takes the blast. + let boosted = r.guest.filter(|_| r.attached); + if r.attached && boosted.is_none() { + self.rocket_hurt_player(damage); + } else { + self.rocket_blast_player(from, damage); + } + if let Some(conn) = boosted + && let Some(mut host) = self.lan.take() + { + self.as_guest(&mut host, conn, |g| g.rocket_hurt_player(damage)); + self.lan = Some(host); + } + // Every other player in the level (LAN guests, the players of a + // server thread), each swapped in as the player. + self.each_guest_hit_except(boosted, |g| g.rocket_blast_player(from, damage)); let hits: Vec<(u32, f32)> = { let world = self.mob_world_base(&[]); self.mobs @@ -285,7 +300,7 @@ impl Game<'_> { ); world.clear_between(from, to, false) }); - sees.then(|| (m.id, damage * ((5.0 - d2.sqrt()) / 5.0).sqrt() as f32)) + sees.then(|| (m.id, blast_damage(damage, from, m.position))) }) .collect() }; @@ -307,6 +322,49 @@ impl Game<'_> { self.particles .fireworks(at, v, r.explosions.clone(), camera); } + /// `dealExplosionDamage` on a player that is not the rocket's + /// `attachedToEntity`: within 5 blocks, when the rocket sees its feet or + /// its middle (`ClipContext.Block.COLLIDER`, no fluids). + fn rocket_blast_player(&mut self, from: Vec3, damage: f32) { + let Some(p) = self.player.as_ref() else { + return; + }; + let feet = p.position; + let d2 = (feet.x - from.x).powi(2) + (feet.y - from.y).powi(2) + (feet.z - from.z).powi(2); + if d2 > 25.0 { + return; + } + let height = f64::from(p.dimensions.height); + let sees = { + let world = self.mob_world_base(&[]); + (0..2).any(|step| { + let to = Vec3::new(feet.x, feet.y + height * 0.5 * f64::from(step), feet.z); + world.clear_between(from, to, false) + }) + }; + if sees { + self.rocket_hurt_player(blast_damage(damage, from, feet)); + } + } + /// `hurtServer` with `damageSources().fireworks`: armor absorbs it and + /// wears (`hurtArmor`); creative and spectator players are immune. + fn rocket_hurt_player(&mut self, amount: f32) { + if self.creative || self.spectator() { + return; + } + let hurt = if let Some(p) = self.player.as_mut() + && !p.health.dead_or_dying() + && let Some(id) = self.motion.health.damage.id("minecraft:fireworks") + { + p.hurt(&self.motion.health, self.world.health_rules, id, amount) + .unwrap_or(false) + } else { + false + }; + if hurt { + self.hurt_armor(amount); + } + } /// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera, /// lit at the rocket's light probe. pub(super) fn rocket_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index 27d3fb61e..95e2e1e6e 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -64,14 +64,14 @@ impl Game<'_> { }); self.view.tick(eye, target); } - /// The player's `deathTime` while dead or dying. - fn death_time(&self) -> Option { + /// The player's `deathTime` while dead or dying: whole ticks counted by + /// `LivingEntity.tickDeath`, so `deathTime + partialTicks` in + /// `Camera.extractRenderState` rises smoothly across frames. + pub(super) fn death_time(&self) -> Option { let p = self.player.as_ref()?; - p.health.dead_or_dying().then(|| { - self.ui - .died_at - .map_or(0, |t| (t.elapsed().as_secs_f32() * 20.0) as i32) - }) + p.health + .dead_or_dying() + .then(|| self.ui.death_time.min(i32::MAX as u32) as i32) } /// The fluid at the camera, as `Camera.getFluidInCamera` reports it. pub(super) fn camera_fluid(&self, camera: [f64; 3]) -> CameraFluid { diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index abe6df9b3..14a18caa6 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -370,6 +370,12 @@ impl Game<'_> { let mut next = Instant::now(); while !flags.stop.load(Ordering::Relaxed) { self.run_tasks(); + if self.agent.hold_server { + // Keep servicing control requests so the fixture can release the barrier. + // Unlike /tick freeze, no player's queued packets are applied here. + self.wait_for_next_server_tick(&mut next, true); + continue; + } let paused = flags.paused.load(Ordering::Relaxed); if paused { // Only the connections run. diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 29dfc91d2..bbb0c37c0 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -38,6 +38,9 @@ pub(super) struct GuestPlay { use_delay: u32, /// The shield's ItemCooldowns entry: an axe disabled it for this many ticks. pub(super) shield_cooldown: u32, + /// `ServerGamePacketListenerImpl.dropSpamThrottler` (`TickThrottler(20, 1480)`): 20 for each + /// item a creative player drops from the creative screen, one less each tick. + creative_drops: u32, /// The guest's `Player.getCooldowns()` (`Game::cooldowns` for its turn). pub(super) cooldowns: horizon_client::cooldowns::Cooldowns, attack_ticks: u32, @@ -1086,6 +1089,35 @@ impl Game<'_> { } S::MoveVehicle(p) => self.guest_move_vehicle(host, conn, &p), S::PaddleBoat(p) => self.guest_paddle_boat(host, conn, [p.left, p.right]), + // handleSetCreativeModeSlot's drop: a slot below 0 is a stack thrown out of the + // creative screen (`handleCreativeModeItemDrop`), dropped from the player's hand. + S::SetCreativeModeSlot(p) if p.slot < 0 => { + if !host.hub.guests[gi].creative() { + return; + } + let Some(stack) = self.item_from_network(host, &p.item) else { + return; + }; + if stack.count + > self + .res + .items() + .get(&stack.item) + .map_or(64, |i| i.max_stack) + { + return; + } + let play = host.play.entry(conn).or_default(); + if play.creative_drops >= 1480 { + eprintln!( + "Player {} was dropping items too fast in creative mode, ignoring.", + host.hub.guests[gi].name + ); + return; + } + play.creative_drops += 20; + self.as_guest(host, conn, |g| g.player_drop(stack)); + } S::SetCreativeModeSlot(p) => { let g = &mut host.hub.guests[gi]; if !g.creative() || !(0..46).contains(&p.slot) { @@ -1160,6 +1192,10 @@ impl Game<'_> { { self.container_changed(key); } + // A vehicle's menu edits the vehicle's own items. + if let Some(Slots::Block(key)) = slots { + self.store_cart_items(key); + } self.drop_guest_items(host, gi, drops); } S::ContainerClose(p) => { @@ -1799,12 +1835,17 @@ impl Game<'_> { continue; } if self.on_server_trip(conn) { + // LivingEntity.hurt kills at once (die), whether the level + // has loaded around the player or not: its respawn request + // is taken as soon as it comes. + self.guest_die(host, gi, conn); continue; } let play = host.play.entry(conn).or_default(); // Player.tick's ItemCooldowns.tick, once a tick for each player // (the shield an axe disabled, a thrown pearl). play.shield_cooldown = play.shield_cooldown.saturating_sub(1); + play.creative_drops = play.creative_drops.saturating_sub(1); // ServerItemCooldowns.onCooldownEnded: a finished entry is told to // the guest (a duration of 0 removes it). for group in play.cooldowns.tick() { @@ -1883,69 +1924,72 @@ impl Game<'_> { self.guest_dig_feedback(host, conn); self.guest_pickups(host, gi); self.guest_orbs(host, gi); - if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead { - self.guest_forget_digging(host, conn); - // FishingHook.shouldStopFishing: its owner is dead. - if let Some(play) = host.play.get_mut(&conn) { - play.hook = None; - } + self.guest_die(host, gi, conn); + } + } + + /// `ServerPlayer.die` for a guest whose health has run out: the death + /// message, the loot and experience, the death screen. + fn guest_die(&mut self, host: &mut LanHost, gi: usize, conn: u32) { + if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead { + self.guest_forget_digging(host, conn); + // FishingHook.shouldStopFishing: its owner is dead. + if let Some(play) = host.play.get_mut(&conn) { + play.hook = None; } - 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)); - let (id, at) = (g.entity_id, g.position); - let reward = Experience { - level: g.xp_level, - progress: g.xp_progress, - total: g.xp_total, - } - .death_reward(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR); - let (name, uuid) = (g.name.clone(), g.uuid); - // ServerPlayer.die: dropAllDeathLoot unless a spectator, from the eyes less 0.3. - let drops = (g.game_mode != SPECTATOR) - .then(|| [at[0], at[1] + g.eye_height() - 0.3, at[2]]); - let cause = host.play.get_mut(&conn).and_then(|p| p.death_cause.take()); - // ServerPlayer.die: with showDeathMessages, the message goes to - // the dying player's death screen and to everyone the team lets - // see it; without it, the death screen gets an empty one. - let message = if self.ui.rules.bool("show_death_messages") { - let me = self.player_text(&name, uuid); - let text = match cause { - Some(key) => horizon_client::text::Text::translate(&key, &[me]), - None if at[1] < f64::from(horizon_client::chunk::MIN_Y - 64) => { - horizon_client::text::Text::translate("death.attack.outOfWorld", &[me]) - } - None => self.guest_death_message(conn, me), - }; - let message = horizon_client::lan::data::component_nbt(&text.component()); - let team = self.score.board.players_team(&name); - if horizon_client::scoreboard::own_death_message_shown(team) { - host.hub.system_message(message.clone()); - if self.options.dedicated.is_some() { - super::dedicated::log( - "INFO", - &format!("System chat: {}", text.plain()), - ); - } else if self.player.is_some() { - self.system_message(text); - } + } + 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)); + let (id, at) = (g.entity_id, g.position); + let reward = Experience { + level: g.xp_level, + progress: g.xp_progress, + total: g.xp_total, + } + .death_reward(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR); + let (name, uuid) = (g.name.clone(), g.uuid); + // ServerPlayer.die: dropAllDeathLoot unless a spectator, from the eyes less 0.3. + let drops = + (g.game_mode != SPECTATOR).then(|| [at[0], at[1] + g.eye_height() - 0.3, at[2]]); + let cause = host.play.get_mut(&conn).and_then(|p| p.death_cause.take()); + // ServerPlayer.die: with showDeathMessages, the message goes to + // the dying player's death screen and to everyone the team lets + // see it; without it, the death screen gets an empty one. + let message = if self.ui.rules.bool("show_death_messages") { + let me = self.player_text(&name, uuid); + let text = match cause { + Some(key) => horizon_client::text::Text::translate(&key, &[me]), + None if at[1] < f64::from(horizon_client::chunk::MIN_Y - 64) => { + horizon_client::text::Text::translate("death.attack.outOfWorld", &[me]) } - message - } else { - literal("") + None => self.guest_death_message(conn, me), }; - host.hub.send_to( - conn, - &C::PlayerCombatKill(play::PlayerCombatKill { id, message }), - ); - // LivingEntity.die: the death animation, the dying player included. - host.hub.entity_event(id, 3, at); - if let Some(eyes) = drops { - self.as_guest(host, conn, |game| game.drop_inventory(eyes)); + let message = horizon_client::lan::data::component_nbt(&text.component()); + let team = self.score.board.players_team(&name); + if horizon_client::scoreboard::own_death_message_shown(team) { + host.hub.system_message(message.clone()); + if self.options.dedicated.is_some() { + super::dedicated::log("INFO", &format!("System chat: {}", text.plain())); + } else if self.player.is_some() { + self.system_message(text); + } } - self.spawn_orbs(at, reward); + message + } else { + literal("") + }; + host.hub.send_to( + conn, + &C::PlayerCombatKill(play::PlayerCombatKill { id, message }), + ); + // LivingEntity.die: the death animation, the dying player included. + host.hub.entity_event(id, 3, at); + if let Some(eyes) = drops { + self.as_guest(host, conn, |game| game.drop_inventory(eyes)); } + self.spawn_orbs(at, reward); } } @@ -2143,6 +2187,9 @@ impl Game<'_> { let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); + // Player.tick ends with updatePlayerPose: a swimmer, or a player + // crawling under a block, takes the short box its moves are checked with. + let _ = w.update_player_pose(); let mut events = std::mem::take(&mut w.player.events); // LayeredCauldronBlock.handleEntityOnFireInside along those moves. for event in &events { diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index f74935522..db6235c4d 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -291,6 +291,11 @@ impl Game<'_> { let at = host.hub.guests[gi].position; self.award_furnace_recipes(pos, at); } + // Slot.setChanged on a changed container slot: BlockEntity.setChanged, + // so the chunk is saved and comparators read the block again. + if changed.iter().any(|&s| s < items.len()) { + self.container_changed(pos); + } host.play.entry(conn).or_default().crafting.machine = Some((p.container, menu)); host.hub.inventory_clicked(conn, p, &self.world, &changed); true diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index dc4d1eb42..4f53cec60 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -119,7 +119,17 @@ impl Game<'_> { /// Runs `f` as each guest in play here, for what strikes every player in /// an area (`Level.getEntities`), not only the window's own. - pub(super) fn each_guest_hit(&mut self, mut f: impl FnMut(&mut Self)) { + pub(super) fn each_guest_hit(&mut self, f: impl FnMut(&mut Self)) { + self.each_guest_hit_except(None, f); + } + + /// [`Self::each_guest_hit`] leaving out the guest `except` (the one a + /// firework rocket is attached to, which it hurts on its own). + pub(super) fn each_guest_hit_except( + &mut self, + except: Option, + mut f: impl FnMut(&mut Self), + ) { let Some(mut host) = self.lan.take() else { return; }; @@ -127,7 +137,7 @@ impl Game<'_> { .hub .guests .iter() - .filter(|g| host.hub.here(g) && g.loaded && !g.dead) + .filter(|g| host.hub.here(g) && g.loaded && !g.dead && Some(g.conn) != except) .map(|g| g.conn) .collect(); for conn in conns { diff --git a/crates/horizon-client/src/game/machines/crafter.rs b/crates/horizon-client/src/game/machines/crafter.rs index b76bafd64..1539ce641 100644 --- a/crates/horizon-client/src/game/machines/crafter.rs +++ b/crates/horizon-client/src/game/machines/crafter.rs @@ -33,7 +33,7 @@ fn recipe_matches(condition: &Value, id: &str) -> bool { impl Game<'_> { /// `Level.setBlock` of one boolean property of the block at `pos`. - fn set_bool_prop(&mut self, pos: Pos, key: &str, value: bool, flags: i32) { + pub(crate) fn set_bool_prop(&mut self, pos: Pos, key: &str, value: bool, flags: i32) { let registry = self.pack.assets.registry; let old = self.world.block(pos.0, pos.1, pos.2); let Some(mut state) = registry.state(old).cloned() else { diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 8d4920b48..a19b6df73 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -1117,22 +1117,35 @@ impl Game<'_> { self.swing_arm(); true } - /// Closing a cart's container copies the items back. - pub(super) fn close_cart_container(&mut self) { - let Some(key) = self.container.filter(|k| k.1 == CART_KEY_Y) else { - return; - }; - let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) else { + /// Closing the cart's container open under `key` copies the items back. + pub(super) fn close_cart_container(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + self.store_cart_items(key); + self.world.block_entities.remove(&key); + if let Some(c) = self.carts.iter().find(|c| c.id as i32 == key.2) + && c.kind == CartKind::Chest + { + let at = [c.position.x, c.position.y, c.position.z]; + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio + .play("minecraft:block.chest.close", Some(at), 0.5, pitch); + } + } + /// The menu of a chest or hopper minecart or a chest boat works on the + /// vehicle's own items (`ContainerEntity`): the placeholder under `key` + /// that the menu edits is copied back to the vehicle. + pub(super) fn store_cart_items(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&key) else { return; }; + let items = items.clone(); if let Some(c) = self.carts.iter_mut().find(|c| c.id as i32 == key.2) { c.items = items; - let at = [c.position.x, c.position.y, c.position.z]; - if c.kind == CartKind::Chest { - let pitch = self.world.random.next_float() * 0.1 + 0.9; - self.audio - .play("minecraft:block.chest.close", Some(at), 0.5, pitch); - } } else if let Some(b) = self.boats.iter_mut().find(|b| b.id as i32 == key.2) { b.items = items; } diff --git a/crates/horizon-client/src/game/mod_input.rs b/crates/horizon-client/src/game/mod_input.rs index 199669957..10faf6a81 100644 --- a/crates/horizon-client/src/game/mod_input.rs +++ b/crates/horizon-client/src/game/mod_input.rs @@ -28,6 +28,9 @@ impl Game<'_> { pub(super) fn mod_zoom(&self) -> Option { None } + pub(super) fn mod_minimap(&self) -> Option { + None + } } /// A mod's zoom (`render.set-zoom`), clamped by the runtime. @@ -38,6 +41,16 @@ pub(super) struct ModZoom { pub(super) turn: f32, } +/// A mod's minimap (`render.set-minimap`), clamped by the runtime. +#[derive(Clone, Copy)] +pub(super) struct ModMinimap { + pub(super) corner: horizon_client::extras::Corner, + pub(super) size: f32, + pub(super) blocks_per_pixel: f32, + pub(super) rotate: bool, + pub(super) round: bool, +} + #[cfg(feature = "mods")] impl Game<'_> { /// The main hand's stack as `input` shows it; none when it is empty. @@ -147,4 +160,22 @@ impl Game<'_> { turn: z.turn, }) } + /// The minimap the first mod showing one asks for. + pub(super) fn mod_minimap(&self) -> Option { + use horizon_client::extras::Corner; + use horizon_mods::RenderCorner; + let m = self.mods.mods.minimap()?; + Some(ModMinimap { + corner: match m.corner { + RenderCorner::TopLeft => Corner::TopLeft, + RenderCorner::TopRight => Corner::TopRight, + RenderCorner::BottomLeft => Corner::BottomLeft, + RenderCorner::BottomRight => Corner::BottomRight, + }, + size: m.size, + blocks_per_pixel: m.blocks_per_pixel, + rotate: m.rotate, + round: m.round, + }) + } } diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs index 129ea3f51..a83277376 100644 --- a/crates/horizon-client/src/game/mods.rs +++ b/crates/horizon-client/src/game/mods.rs @@ -27,8 +27,11 @@ use { text::{self, Text}, ui, }, - horizon_mods::{Clock, Mods, Output, Player, Snapshot, Status, UiScreen, UiWidget}, + horizon_mods::{ + Clock, ModKey, Mods, Output, Player, Runs, Snapshot, Status, UiScreen, UiWidget, + }, std::time::Instant, + winit::{event::MouseButton, keyboard::KeyCode}, }; #[derive(Default)] @@ -63,6 +66,9 @@ pub(super) struct ModsState { /// The HUD font's advances for `render.text-width`, made once. #[cfg(feature = "mods")] font_widths: std::sync::Arc<[f32]>, + /// Extras that are official mods now, being installed. + #[cfg(feature = "mods")] + pub(super) moved: super::moved_extras::MovedState, /// Playing at the last frame, for `mod_input_frame`. #[cfg(feature = "mods")] pub(super) playing: bool, @@ -101,6 +107,8 @@ struct ModScreen { under: Screen, /// One scroll per `list` widget, in widget order. scrolls: Vec, + /// A key row waiting for the key to bind: the mod key's name. + binding: Option, } impl ModsState { /// The chat's command tree: vanilla's, plus the running mods' commands. @@ -240,7 +248,10 @@ impl Game<'_> { pub(super) fn open_mod_screen(&mut self, _owner: usize, _settings: bool) {} pub(super) fn close_mod_screen(&mut self, _tell: bool) {} pub(super) fn draw_mod_screen(&mut self, _batch: &mut HudBatch) {} - pub(super) fn mod_screen_click(&mut self) {} + pub(super) fn mod_screen_click(&mut self, _button: winit::event::MouseButton) {} + pub(super) fn mod_screen_key(&mut self, _key: winit::keyboard::KeyCode) -> bool { + false + } pub(super) fn mod_screen_scroll(&mut self, _delta: f32) {} } @@ -261,8 +272,10 @@ impl Game<'_> { .collect(); let enabled = &self.settings.mods.enabled; let on = |id: &str| enabled.contains(id) || dev_ids.iter().any(|d| d == id); - let mods = Mods::load(&paths, on, vanilla_command); + let mods = Mods::load_for(Runs::Client, &paths, on, vanilla_command); self.mods.mods = mods; + let chosen = &self.settings.mods; + self.mods.mods.set_bindings(|id| chosen.keys_of(id)); // Entries were replaced wholesale: a screen's owner index is stale. self.mods.screen = None; self.list_mods(); @@ -401,6 +414,7 @@ impl Game<'_> { mappings, cps, font_widths: self.mods.font_widths.clone(), + players: Vec::new(), } } /// A game tick. @@ -429,6 +443,8 @@ impl Game<'_> { { self.mods.checked = Some(Instant::now()); if self.mods.mods.reload_changed(vanilla_command) { + let chosen = &self.settings.mods; + self.mods.mods.set_bindings(|id| chosen.keys_of(id)); self.list_mods(); self.sync_mod_commands(); self.system_message(Text::literal("Mods reloaded").with_color(text::GRAY)); @@ -509,6 +525,8 @@ impl Game<'_> { } continue; } + // Server mods' lines: this game runs no server mod yet. + Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. } => continue, }; // Not through system_message: a mod must not hear its own lines. // Written by this client, so the Chat option doesn't hide it. @@ -571,7 +589,7 @@ impl Game<'_> { fn mod_ui_view<'a>(mods: &'a Mods, ms: &ModScreen) -> Option<(&'a str, &'a [UiWidget])> { if ms.settings { let widgets = mods.settings_widgets(ms.owner); - if widgets.is_empty() { + if widgets.is_empty() && mods.keys_of(ms.owner).is_empty() { return None; } let name = mods @@ -585,11 +603,78 @@ impl Game<'_> { Some((s.title.as_str(), s.widgets.as_slice())) } } + /// The keys a settings page lists first: the mod's own (`input`). + fn mod_page_keys<'a>(mods: &'a Mods, ms: &ModScreen) -> &'a [ModKey] { + if ms.settings { + mods.keys_of(ms.owner) + } else { + &[] + } + } + /// A key row's label as Key Binds shows one, "Zoom: Z", marked + /// "> Zoom: Z <" in yellow while it waits for the new key. + fn mod_key_label(k: &ModKey, waiting: bool) -> Text { + let value = format!("{}: {}", k.label, keybinds::display_name(&k.key).plain()); + if waiting { + Text::literal(format!("> {value} <")).with_color(text::YELLOW) + } else { + Text::literal(value) + } + } + /// The player bound the key row that waited to `key`: the mod's key + /// follows it now and at the next start (`horizon-mods.txt`). + fn bind_mod_key(&mut self, key: String) { + let Some(ms) = self.mods.screen.as_mut() else { + return; + }; + let Some(name) = ms.binding.take() else { + return; + }; + let owner = ms.owner; + if !self.mods.mods.rebind(owner, &name, &key) { + return; + } + let Some(id) = self + .mods + .mods + .entries() + .get(owner) + .and_then(|e| e.manifest.as_ref()) + .map(|m| m.id.clone()) + else { + return; + }; + self.settings + .mods + .keys + .entry(id) + .or_default() + .insert(name, key); + self.settings.save(&Self::options_path()); + } + /// A key while a mod screen is up: true when a key row waited for + /// it (Key Binds: Escape binds none). + pub(super) fn mod_screen_key(&mut self, key: KeyCode) -> bool { + if self + .mods + .screen + .as_ref() + .is_none_or(|ms| ms.binding.is_none()) + { + return false; + } + let value = match key { + KeyCode::Escape => None, + k => keybinds::key_name(k), + }; + self.bind_mod_key(value.unwrap_or("key.keyboard.unknown").to_owned()); + true + } /// The layout the mod screen's widgets get at `h`: (widget, top, /// height), the column being `COLUMN` wide down the middle. - fn mod_ui_layout(h: f32, widgets: &[UiWidget]) -> Vec<(f32, f32)> { + fn mod_ui_layout(h: f32, top: f32, widgets: &[UiWidget]) -> Vec<(f32, f32)> { let mut out = Vec::with_capacity(widgets.len()); - let mut y = MOD_UI_TOP; + let mut y = top; for w in widgets { let wh = match w { UiWidget::Text(_) => 12.0, @@ -613,7 +698,8 @@ impl Game<'_> { } if settings { self.mods.mods.ui_settings_opened(owner); - if self.mods.mods.settings_widgets(owner).is_empty() { + let keys = self.mods.mods.keys_of(owner); + if self.mods.mods.settings_widgets(owner).is_empty() && keys.is_empty() { self.show_mod_output(); return; } @@ -623,6 +709,7 @@ impl Game<'_> { settings, under: self.screen, scrolls: Vec::new(), + binding: None, }); self.screen = Screen::Mod; if self.player.is_some() { @@ -684,7 +771,27 @@ impl Game<'_> { ); let cx = (batch.width / 2.0).floor(); let x = cx - MOD_UI_COLUMN / 2.0; - let layout = Self::mod_ui_layout(batch.height, widgets); + // A settings page starts with the mod's keys, as Key Binds rows. + let keys = Self::mod_page_keys(&self.mods.mods, ms); + for (i, k) in keys.iter().enumerate() { + let wy = MOD_UI_TOP + i as f32 * MOD_UI_KEY_ROW; + let hover = ui::hovered(self.cursor, x, wy, MOD_UI_COLUMN, 20.0); + let waiting = ms.binding.as_deref() == Some(k.name.as_str()); + let label = Self::mod_key_label(k, waiting); + ui::button( + batch, + atlas, + x, + wy, + MOD_UI_COLUMN, + 20.0, + &label, + true, + hover, + ); + } + let top = MOD_UI_TOP + keys.len() as f32 * MOD_UI_KEY_ROW; + let layout = Self::mod_ui_layout(batch.height, top, widgets); let mut list_i = 0usize; for (w, &(wy, wh)) in widgets.iter().zip(&layout) { match w { @@ -804,7 +911,20 @@ impl Game<'_> { } /// A click on the mod screen: Done leaves it, a `list` row is the mod's /// `ui-events::select`. - pub(super) fn mod_screen_click(&mut self) { + pub(super) fn mod_screen_click(&mut self, button: MouseButton) { + // Key Binds: a mouse button pressed while waiting binds it. + if self + .mods + .screen + .as_ref() + .is_some_and(|ms| ms.binding.is_some()) + { + self.bind_mod_key(keybinds::mouse_name(button)); + return; + } + if button != MouseButton::Left { + return; + } let (w, h) = self.gui_size(); let cursor = self.cursor; if ui::hovered(cursor, (w / 2.0).floor() - 100.0, h - 27.0, 200.0, 20.0) { @@ -820,7 +940,22 @@ impl Game<'_> { }; let owner = ms.owner; let x = (w / 2.0).floor() - MOD_UI_COLUMN / 2.0; - let layout = Self::mod_ui_layout(h, widgets); + // A key row waits for the key to bind. + let keys = Self::mod_page_keys(&self.mods.mods, ms); + let picked = (0..keys.len()).find(|&i| { + let wy = MOD_UI_TOP + i as f32 * MOD_UI_KEY_ROW; + ui::hovered(cursor, x, wy, MOD_UI_COLUMN, 20.0) + }); + if let Some(i) = picked { + let name = keys[i].name.clone(); + self.audio.play_button_click(); + if let Some(ms) = self.mods.screen.as_mut() { + ms.binding = Some(name); + } + return; + } + let top = MOD_UI_TOP + keys.len() as f32 * MOD_UI_KEY_ROW; + let layout = Self::mod_ui_layout(h, top, widgets); let mut list_i = 0usize; // The `ui_select` call needs `&mut`: find the pick first. let mut hit = None; @@ -864,7 +999,9 @@ impl Game<'_> { return; }; let x = (w / 2.0).floor() - MOD_UI_COLUMN / 2.0; - let layout = Self::mod_ui_layout(h, widgets); + let top = + MOD_UI_TOP + Self::mod_page_keys(&self.mods.mods, ms).len() as f32 * MOD_UI_KEY_ROW; + let layout = Self::mod_ui_layout(h, top, widgets); let mut list_i = 0usize; for (w, &(wy, wh)) in widgets.iter().zip(&layout) { let UiWidget::List(l) = w else { continue }; @@ -884,3 +1021,6 @@ impl Game<'_> { const MOD_UI_TOP: f32 = 40.0; #[cfg(feature = "mods")] const MOD_UI_COLUMN: f32 = 200.0; +/// A key row's height with its gap, as the widgets below it space out. +#[cfg(feature = "mods")] +const MOD_UI_KEY_ROW: f32 = 26.0; diff --git a/crates/horizon-client/src/game/moved_extras.rs b/crates/horizon-client/src/game/moved_extras.rs new file mode 100644 index 000000000..bd277033e --- /dev/null +++ b/crates/horizon-client/src/game/moved_extras.rs @@ -0,0 +1,122 @@ +//! Extras that are official mods now (`horizon_client::moved_extras`): on +//! the first start after the update, a player who had one on gets the mod +//! installed from Horizon's registry, turned on, with their settings, and +//! one line in the chat saying so. The download runs on its own thread; if +//! it fails (offline), the game tries again at the next start. + +#[cfg(not(feature = "mods"))] +impl super::Game<'_> { + pub(super) fn start_moved_extras(&mut self) {} + pub(super) fn poll_moved_extras(&mut self) {} +} + +#[cfg(feature = "mods")] +mod with_mods { + use super::super::Game; + use horizon_client::{ + moved_extras::{self, Moved}, + text::{self, Text}, + }; + use std::sync::mpsc::{Receiver, channel}; + + type Done = Vec<(&'static Moved, Result<(), String>)>; + + #[derive(Default)] + pub(in crate::game) struct MovedState { + /// The installs under way. + running: Option>, + /// Lines for the player, shown once a world is open. + notices: Vec, + } + + impl Game<'_> { + /// At start: remembers the moved extras that were off, and installs + /// the ones that were on, in the background. + pub(in crate::game) fn start_moved_extras(&mut self) { + let off = moved_extras::nothing_to_do(&self.settings.extras); + let pending = moved_extras::pending(&self.settings.extras); + if off.is_empty() && pending.is_empty() { + return; + } + if !off.is_empty() { + let e = &mut self.settings.extras; + e.moved.extend(off.iter().map(|m| m.id.to_owned())); + self.settings.save(&Self::options_path()); + } + if pending.is_empty() { + return; + } + let extras = self.settings.extras.clone(); + let dir = Self::options_path() + .parent() + .map(std::path::Path::to_path_buf) + .unwrap_or_default(); + let (tx, rx) = channel(); + self.mods.moved.running = Some(rx); + let spawned = std::thread::Builder::new() + .name("Moved extras".into()) + .spawn(move || { + let done = match moved_extras::fetch_index() { + Ok(index) => pending + .into_iter() + .map(|m| (m, moved_extras::install(&index, m, &extras, &dir))) + .collect(), + Err(e) => pending.into_iter().map(|m| (m, Err(e.clone()))).collect(), + }; + let _ = tx.send(done); + }); + if spawned.is_err() { + self.mods.moved.running = None; + } + } + /// Once a frame: the installs that finished turn their mods on; + /// their lines wait for a world. + pub(in crate::game) fn poll_moved_extras(&mut self) { + if let Some(rx) = &self.mods.moved.running + && let Ok(done) = rx.try_recv() + { + self.mods.moved.running = None; + let mut installed = false; + for (m, result) in done { + match result { + Ok(()) => { + self.settings.extras.moved.push(m.id.to_owned()); + self.settings.mods.enabled.insert(m.id.to_owned()); + // The install wrote the key to horizon-mods.txt; + // the settings save below must keep it. + let keys = self.settings.mods.keys.entry(m.id.to_owned()).or_default(); + for (name, key) in m.keys(&self.settings.extras) { + keys.entry(name.to_owned()).or_insert(key); + } + self.settings.mods.keys.retain(|_, k| !k.is_empty()); + self.mods.moved.notices.push(Text::literal(m.notice())); + installed = true; + } + Err(e) => { + log::warn!("Horizon: {} not installed, next start retries: {e}", m.id); + self.mods.moved.notices.push( + Text::literal(format!( + "{} moved to the mod browser; it couldn't be installed for you yet, Horizon tries again at the next start", + m.name + )) + .with_color(text::GRAY), + ); + } + } + } + if installed { + self.settings.save(&Self::options_path()); + self.start_mods(); + } + } + if !self.mods.moved.notices.is_empty() && self.player.is_some() && self.title.is_none() + { + for line in std::mem::take(&mut self.mods.moved.notices) { + self.system_message(line); + } + } + } + } +} +#[cfg(feature = "mods")] +pub(super) use with_mods::MovedState; diff --git a/crates/horizon-client/src/game/native_shaders.rs b/crates/horizon-client/src/game/native_shaders.rs index 62aaafc42..e72892b0e 100644 --- a/crates/horizon-client/src/game/native_shaders.rs +++ b/crates/horizon-client/src/game/native_shaders.rs @@ -1,7 +1,6 @@ -//! Horizon's own shader packs in the game (docs/shaders.md), for development until the Shader -//! Packs page exists: `HORIZON_SHADER_PACK=` naming one in `shaderpacks/` (a folder with -//! `horizon-shaders.toml`, or a `.hshader`) runs it once it passes `horizon_shader_api::check`. -//! The pack is looked at twice a second: a saved file is checked and the pack rebuilt, and a +//! Horizon's own shader packs in the game (docs/shaders.md): the pick in `shaderpacks/` (a +//! folder with `horizon-shaders.toml`, or a `.hshader`; `game/shader_packs.rs`) runs once it +//! passes `horizon_shader_api::check`. The pack is looked at twice a second: a saved file is checked and the pack rebuilt, and a //! pack that fails is refused with its problems in the chat while the last good one keeps //! drawing. @@ -21,11 +20,22 @@ const RED: u32 = 0xFF5555; #[derive(Default)] pub(super) struct NativeShaders { + /// The pack's name in `shaderpacks/`, of either kind (`game/shader_packs.rs`); empty: none. + pub picked: String, /// The pack's files when it was last read (`fingerprint`). stamp: Option, looked: Option, } +impl NativeShaders { + pub fn picking(name: &str) -> Self { + Self { + picked: name.to_owned(), + ..Self::default() + } + } +} + impl Game<'_> { /// Builds the pack at `path` when its files changed since it was last read. pub(super) fn tick_native_shader_pack(&mut self, path: &Path) { diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs index a30cf822a..353ad216c 100644 --- a/crates/horizon-client/src/game/nether_portal.rs +++ b/crates/horizon-client/src/game/nether_portal.rs @@ -270,6 +270,18 @@ impl Game<'_> { self.portals.player.set_inside(pos, PLAYER_DELAY); self.portals.client_inside = true; } + /// The same on a server's client: `Entity.canUsePortal` (alive, not a + /// passenger), then only the client's `setAsInsidePortal`, which drives + /// the confusion effect (`client_portal_effect`). + pub(super) fn client_inside_nether_portal(&mut self) { + let alive = self + .player + .as_ref() + .is_some_and(|p| !p.health.dead_or_dying()); + if alive && self.riding.is_none() { + self.portals.client_inside = true; + } + } /// `ServerPlayer.handlePortal` (not while changing dimension: there is no /// player then). Players wait `players_nether_portal_default_delay` /// ticks, or the creative delay with invulnerable abilities. diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs index 0e385e25c..243eced5c 100644 --- a/crates/horizon-client/src/game/options.rs +++ b/crates/horizon-client/src/game/options.rs @@ -57,14 +57,7 @@ impl Game<'_> { .map(str::trim) .filter(|v| !v.is_empty()) .ok_or("options-set KEY VALUE: missing the value")?; - let mut file = self.settings.to_file(); - file.set_text(key, value)?; - let mut settings = horizon_client::settings::Settings::from_file(file); - // Horizon's own files are not in options.txt. - std::mem::swap(&mut settings.horizon, &mut self.settings.horizon); - std::mem::swap(&mut settings.controller, &mut self.settings.controller); - std::mem::swap(&mut settings.extras, &mut self.settings.extras); - self.settings = settings; + self.settings = self.settings.with_option(key, value)?; // As the options screen applies a change. self.handle_option_events(vec![Event::Changed])?; match *key { @@ -85,6 +78,10 @@ impl Game<'_> { .unwrap_or_default() .join("options.txt") } + /// `shaderpacks/` beside `options.txt`. + pub(super) fn shader_packs_dir() -> std::path::PathBuf { + Self::options_path().with_file_name(horizon_client::shader_pack_list::DIR) + } pub(super) fn gui_size(&self) -> (f32, f32) { let size = self .renderer @@ -237,6 +234,17 @@ impl Game<'_> { let _ = std::fs::create_dir_all(&dir); super::packs::open_folder(&dir); } + Event::ListShaderPacks => { + self.settings.shader_packs = + horizon_client::shader_pack_list::scan(&Self::shader_packs_dir()); + } + // Saved; the next frame's `shader_pack_inputs` loads the pick. + Event::ShaderPack => self.settings.save(&Self::options_path()), + Event::OpenShaderPackFolder => { + let dir = Self::shader_packs_dir(); + let _ = std::fs::create_dir_all(&dir); + super::packs::open_folder(&dir); + } Event::ModSettings(i) => self.open_mod_screen(i, true), Event::Credits => self.open_win_screen(false, super::win::Finish::Options), } diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 3a2dd1d69..1474858b8 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -6,11 +6,12 @@ //! clicks). The player still moves with the local physics, as the vanilla //! client predicts its own movement; the server stays authoritative for //! everything else. +use super::remote_chunks::{ChunkDecoder, ChunkFormat, Next}; use super::{Dim, Game, Mining, Screen}; use horizon_client::first_person::{Hand, SwingAnimation}; use horizon_client::{ Result, - chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy}, + chunk::Chunk, containers::{BlockEntity, Furnace, FurnaceKind}, entities::{Experience, ExperienceOrb, ItemEntity}, hud::{HudBatch, rgba}, @@ -25,11 +26,7 @@ use horizon_client::{ tab_list::SPECTATOR, world::World, }; -use horizon_core::{ - geometry::Vec3, - paletted::{PalettedContainer, Strategy}, - random::RandomSource, -}; +use horizon_core::{geometry::Vec3, random::RandomSource}; use horizon_protocol::{ entity_data::{ITEM_ENTITY_ITEM, Value}, item::{Hashed, Stack}, @@ -64,9 +61,6 @@ fn menu_title(tag: &Tag) -> horizon_client::text::Text { remote_text(tag).resolve_legacy() } -/// A section's sky and block light layers from the wire. -type LightLayers = (Option>, Option>); - /// Streaming needs a generator; a server world never generates. struct NoTerrain; impl ChunkGenerator for NoTerrain { @@ -104,6 +98,14 @@ fn place_interpolated(m: &mut Mob, at: PosRot) { m.head_pitch = (at.pitch % 360.0).clamp(-90.0, 90.0); } +/// What the network thread delivered, in order: an event, or a chunk packet +/// handed to the decoder (with the format it decodes with), whose column +/// comes back from `ChunkDecoder::next`. +enum Received { + Event(Event), + Chunk(Arc), +} + pub(super) struct Remote { pub session: Session, pub brand: String, @@ -114,8 +116,11 @@ pub(super) struct Remote { status: String, pub(super) entity_id: i32, dimension: DimensionType, - biome_map: Vec, - biome_bits: u8, + /// 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, + /// Decodes chunk packets as they arrive, off the frame. + decoder: ChunkDecoder, view_distance: i32, sequence: i32, position_sender: horizon_client::player_sync::PositionSender, @@ -200,7 +205,7 @@ pub(super) struct Remote { chunk_center: (i32, i32), /// Received events a frame left for the next one, in order, and when /// the oldest of them first waited (`poll_remote`). - backlog: VecDeque, + backlog: VecDeque, backlog_since: Option, /// `ClientboundTransferPacket`'s target: when the connection ends the /// game connects here, the stored cookies carried over (`TransferState`). @@ -210,11 +215,12 @@ pub(super) struct Remote { /// The time a frame spends on chunk packets before it leaves the rest of /// the received events for the next frame. A batch of 25 to 60 columns /// (0.1 ms each on an M4 Pro) all in one frame was a 3 to 8 ms frame every -/// time the player crossed a chunk border at 32 chunks. +/// time the player crossed a chunk border at 32 chunks; they decode on the +/// chunk decoder's thread now, and the frame only inserts them. const CHUNK_PACKETS_PER_FRAME: Duration = Duration::from_millis(1); /// Events that have waited this long are all handled in the next frame, -/// whatever their cost: the packets after a slow machine's chunks never -/// wait more than a tick. +/// whatever inserting their columns costs, up to a column still decoding: +/// the packets after a slow machine's chunks don't wait on its frames. const BACKLOG_LIMIT: Duration = Duration::from_millis(50); /// The open menu name of a server's horse inventory, then its chest's /// columns (the packet names no `MenuType`). @@ -420,8 +426,12 @@ impl Game<'_> { status: "Connecting to the server...".into(), entity_id: 0, dimension: DimensionType::vanilla("minecraft:overworld"), - biome_map: Vec::new(), - biome_bits: 7, + chunk_format: Arc::new(ChunkFormat::new( + &DimensionType::vanilla("minecraft:overworld"), + Vec::new(), + 7, + )), + decoder: ChunkDecoder::new(), view_distance: self.settings.render_distance, sequence: 0, position_sender: Default::default(), @@ -741,25 +751,63 @@ impl Game<'_> { /// client's packet processor), in order. Chunk packets get /// `CHUNK_PACKETS_PER_FRAME`: once a frame has spent it, the events from /// the next chunk packet on wait for the next frame, unless they have - /// already waited `BACKLOG_LIMIT`. + /// already waited `BACKLOG_LIMIT`. A chunk packet still decoding holds + /// back what follows it. pub(super) fn poll_remote(&mut self) -> Result<()> { let Some(r) = self.remote.as_mut() else { return Ok(()); }; let mut events = std::mem::take(&mut r.backlog); - events.extend(r.session.poll()); + // Chunk packets start decoding now; the frame that reaches one in + // order inserts its column. + for event in r.session.poll() { + events.push_back(match event { + Event::Packet(p) if matches!(*p, C::LevelChunkWithLight(_)) => { + match r.decoder.submit(r.chunk_format.clone(), p) { + None => Received::Chunk(r.chunk_format.clone()), + Some(p) => Received::Event(Event::Packet(p)), + } + } + event => Received::Event(event), + }); + } let overdue = r .backlog_since .is_some_and(|since| since.elapsed() >= BACKLOG_LIMIT); let mut chunks = Duration::ZERO; - while let Some(event) = events.pop_front() { - let chunk = - matches!(&event, Event::Packet(p) if matches!(**p, C::LevelChunkWithLight(_))); + while let Some(item) = events.pop_front() { + let chunk = matches!(item, Received::Chunk(_)); if chunk && !overdue && chunks >= CHUNK_PACKETS_PER_FRAME { - events.push_front(event); + events.push_front(item); break; } let started = chunk.then(Instant::now); + let event = match item { + Received::Event(event) => event, + Received::Chunk(format) => { + // A column still decoding waits for the next frame, with + // what came after it, overdue or not. + let Some(next) = self.remote.as_ref().map(|r| r.decoder.next()) else { + break; + }; + let (packet, column) = match next { + Next::Ready(decoded) => decoded, + Next::Decoding => { + events.push_front(Received::Chunk(format)); + break; + } + Next::Lost => { + log::warn!("Horizon: the chunk decoder stopped; a column is missing"); + continue; + } + }; + if let C::LevelChunkWithLight(p) = *packet { + self.remote_chunk(&p, Some((&format, column))); + } + chunks += started.map_or(Duration::ZERO, |t| t.elapsed()); + continue; + } + }; match event { Event::Status(s) => { if let Some(r) = self.remote.as_mut() { @@ -915,8 +963,8 @@ impl Game<'_> { }) .unwrap_or_default(); if let Some(r) = self.remote.as_mut() { - r.biome_bits = ceil_log2(biomes.len()); - r.biome_map = biomes; + let bits = ceil_log2(biomes.len()); + r.chunk_format = Arc::new(ChunkFormat::new(&r.dimension, biomes, bits)); r.registries = registries; } } @@ -927,6 +975,7 @@ impl Game<'_> { }; let dimension = r.registries.dimension(spawn.dimension_type); let same = r.dimension.name == dimension.name && keep_world; + r.chunk_format = Arc::new(r.chunk_format.with_dimension(&dimension)); r.dimension = dimension; r.game_mode = spawn.game_type; r.loaded_sent = false; @@ -949,6 +998,9 @@ impl Game<'_> { self.world.day_time, self.world.weather, ); + let old = std::mem::take(&mut self.world.chunks); + let count = old.len(); + horizon_client::chunk::free_columns(old, count); self.world = World::new(self.res.facts().air, spawn.seed); self.world.game_time = time; self.world.day_time = day; @@ -989,145 +1041,10 @@ impl Game<'_> { self.apply_settings(); } - /// LevelChunkSection data into the client's fixed -64..320 column. - fn remote_chunk(&self, p: &play::LevelChunkWithLight) -> std::result::Result { - let r = self.remote.as_ref().ok_or("no connection")?; - let sections = p - .chunk - .sections(r.dimension.sections(), 16, r.biome_bits) - .map_err(|e| e.to_string())?; - let mut chunk = Chunk::empty(p.x, p.z); - let offset = (r.dimension.min_y - MIN_Y).div_euclid(16); - // Biome table index per quart cell of the dimension's own sections. - let mut biome_cells: Vec<[u32; 64]> = Vec::with_capacity(sections.len()); - for (i, s) in sections.iter().enumerate() { - let target = offset + i as i32; - let mut cells = [0u32; 64]; - for (j, cell) in cells.iter_mut().enumerate() { - *cell = u32::from( - r.biome_map - .get(s.biomes.get(j) as usize) - .copied() - .unwrap_or(0), - ); - } - biome_cells.push(cells); - if !(0..SECTIONS as i32).contains(&target) { - continue; - } - // A global section is as wide as the server's registry: 16 bits - // from a vanilla server, wider from a Horizon host with the same - // content mods. Read it at that width, then widen it to ours. - let ours = block_strategy(); - let strategy = if ours.wire_has_palette(s.states.bits) { - ours - } else { - Strategy::blocks(s.states.bits) - }; - let palette = s.states.palette.iter().map(|&p| p as u32).collect(); - let words = s.states.data.iter().map(|&w| w as u64).collect(); - let mut blocks = PalettedContainer::from_wire(strategy, s.states.bits, palette, words) - .map_err(|e| e.to_string())?; - if strategy.global_bits != ours.global_bits { - let mut values = [0u32; 4096]; - blocks.unpack(&mut values); - // Ids past our registry (a host with mods we lack) read as air. - let limit = 1u64 << ours.global_bits; - for v in &mut values { - if u64::from(*v) >= limit { - *v = 0; - } - } - blocks = PalettedContainer::from_values(ours, &values); - } - let mut section = Section { - blocks, - biomes: PalettedContainer::from_values(BIOME_STRATEGY, &cells), - light: Light::Uniform(0xF0), - }; - section.compact(); - chunk.sections[target as usize] = Arc::new(section); - } - // Sections outside the dimension's range take its nearest biomes - // (the column's top or bottom cell layer repeated). - if !biome_cells.is_empty() { - let last = biome_cells.len() - 1; - for si in 0..SECTIONS as i32 { - let i = si - offset; - if (0..sections.len() as i32).contains(&i) { - continue; - } - let (edge, layer) = if i < 0 { (0, 0) } else { (last, 3) }; - let mut cells = [0u32; 64]; - for (j, cell) in cells.iter_mut().enumerate() { - *cell = biome_cells[edge][layer * 16 + j % 16]; - } - Arc::make_mut(&mut chunk.sections[si as usize]).biomes = - PalettedContainer::from_values(BIOME_STRATEGY, &cells); - } - } - // ClientPacketListener.applyLightData: the column keeps the light - // the server sent; nothing is relit. - let (layers, above) = self.wire_light(&p.light); - let sky = r.dimension.has_skylight; - horizon_client::light::light_from_layers(&mut chunk, &layers, above, sky); - Ok(chunk) - } - /// `ClientPacketListener.readSectionList`: the sky and block layers of a - /// light packet, by section of the client's column, and the sky light - /// above the column's top section (from the light section just above - /// it, else open sky). - fn wire_light( - &self, - light: &horizon_protocol::chunk::LightData, - ) -> (Vec, [u8; 256]) { - let mut layers: Vec = vec![(None, None); SECTIONS]; - let Some(r) = self.remote.as_ref() else { - return (layers, [0; 256]); - }; - let sky = r.dimension.has_skylight; - let mut above = [if sky { 15 } else { 0 }; 256]; - // Light section b is the dimension's section b - 1. - let first = (r.dimension.min_y - MIN_Y).div_euclid(16) - 1; - for (b, layer) in light - .layers(r.dimension.sections() + 2) - .into_iter() - .enumerate() - { - let si = first + b as i32; - if (0..SECTIONS as i32).contains(&si) { - layers[si as usize] = layer; - } else if si == SECTIONS as i32 - && sky - && let Some(l) = &layer.0 - { - for (i, a) in above.iter_mut().enumerate() { - *a = (l[i >> 1] >> ((i & 1) * 4)) & 15; - } - } - } - (layers, above) - } - /// `handleLightUpdatePacket`: the sections it names take its light. - fn remote_light_update(&mut self, p: &play::LightUpdate) { - let Some(sky) = self.remote.as_ref().map(|r| r.dimension.has_skylight) else { - return; - }; - if !self.world.chunks.contains_key(&(p.x, p.z)) { - return; - } - let (layers, _) = self.wire_light(&p.light); - let Some(chunk) = self.world.chunks.get_mut(&(p.x, p.z)) else { - return; - }; - let changed = - horizon_client::light::update_light_layers(Arc::make_mut(chunk), &layers, sky); - Streaming::light_updated(&mut self.world, p.x, p.z, &changed); - } /// `ClientChunkCache.Storage.inRange`: within the storage around the /// view centre, `calculateStorageRange` (the server's radius, at least /// two, plus three) chunks each way. - fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool { + pub(super) fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool { self.remote.as_ref().is_none_or(|r| { let range = r.view_distance.max(2) + 3; (x - r.chunk_center.0).abs() <= range && (z - r.chunk_center.1).abs() <= range @@ -1135,29 +1052,33 @@ impl Game<'_> { } /// The columns a moved or resized storage no longer holds. fn drop_remote_chunks_out_of_range(&mut self) { - let gone: Vec<(i32, i32)> = self + let gone: horizon_client::fast_hash::FxHashSet<(i32, i32)> = self .world .chunks .keys() .copied() .filter(|&(x, z)| !self.remote_chunk_in_range(x, z)) .collect(); - for (x, z) in gone { - self.streaming.forget(&mut self.world, x, z); - self.world - .block_entities - .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); - if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } - } + if gone.is_empty() { + return; } + let mut freed = Vec::with_capacity(gone.len()); + for &(x, z) in &gone { + freed.extend(self.streaming.forget(&mut self.world, x, z)); + } + if let Some(renderer) = self.renderer.as_mut() { + renderer.remove_columns(gone.iter().copied()); + } + horizon_client::chunk::free_columns(freed, gone.len()); + // One pass for all of them. + self.world + .block_entities + .retain(|k, _| !gone.contains(&(k.0 >> 4, k.2 >> 4))); } /// `handleBlockEntityData`: the block entity at `pos`, when it is of the /// packet's type, loads the tag (`loadWithComponents`); an empty tag /// changes nothing. - fn remote_block_entity_data(&mut self, pos: [i32; 3], kind: i32, tag: &Tag) { + pub(super) fn remote_block_entity_data(&mut self, pos: [i32; 3], kind: i32, tag: &Tag) { let key = (pos[0], pos[1], pos[2]); let Some(name) = self .remote @@ -1248,7 +1169,7 @@ impl Game<'_> { } } /// Keep the renderable block entities (chests, furnaces) in step with blocks. - fn sync_block_entity(&mut self, pos: (i32, i32, i32), state: BlockStateId) { + pub(super) fn sync_block_entity(&mut self, pos: (i32, i32, i32), state: BlockStateId) { let name = self.res.facts().get(state).name.clone(); match BlockEntity::for_block(&name) { Some(entity) => { @@ -1704,36 +1625,7 @@ impl Game<'_> { }) .clamp(-90.0, 90.0); } - // ClientChunkCache.replaceWithPacketData: a column outside the - // storage around the view centre is ignored. - C::LevelChunkWithLight(p) if !self.remote_chunk_in_range(p.x, p.z) => { - log::warn!( - "Ignoring chunk since it's not in the view range: {}, {}", - p.x, - p.z - ); - } - C::LevelChunkWithLight(p) => match self.remote_chunk(&p) { - Ok(chunk) => { - let (x, z) = (p.x, p.z); - self.streaming.insert_remote(&mut self.world, chunk); - self.world - .block_entities - .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); - for info in &p.chunk.block_entities { - let pos = ( - x * 16 + i32::from(info.packed_xz as u8 >> 4), - i32::from(info.y), - z * 16 + i32::from(info.packed_xz as u8 & 15), - ); - let state = self.world.block(pos.0, pos.1, pos.2); - self.sync_block_entity(pos, state); - // LevelChunk.replaceWithPacketData: the block entity loads its update tag. - self.remote_block_entity_data([pos.0, pos.1, pos.2], info.kind, &info.tag); - } - } - Err(e) => log::warn!("Horizon: chunk {} {}: {e}", p.x, p.z), - }, + C::LevelChunkWithLight(p) => self.remote_chunk(&p, None), C::LightUpdate(p) => self.remote_light_update(&p), C::ForgetLevelChunk(p) => { let [x, z] = p.pos; @@ -1742,9 +1634,7 @@ impl Game<'_> { .block_entities .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } + renderer.remove_columns([(x, z)]); } } C::ChunkBatchFinished(_) => { @@ -2234,6 +2124,7 @@ impl Game<'_> { self.apply_remote_health(); if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -2250,6 +2141,7 @@ impl Game<'_> { // screen, whatever health was last sent. if me && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -3288,6 +3180,11 @@ impl Game<'_> { ); let was_flying = player.flying; self.sync_player_body(); + // LivingEntity.tickDeath: the local player counts its deathTime once + // per client tick while dead (the camera's death roll and zoom). + if self.screen == Screen::Dead { + self.ui.death_time = self.ui.death_time.saturating_add(1); + } let Some(player) = self.player.as_mut() else { return Ok(()); }; @@ -3343,6 +3240,12 @@ impl Game<'_> { self.audio .play("minecraft:entity.player.swim", Some(feet), volume, pitch); } + // NetherPortalBlock.entityInside on the client's own level: + // the portal overlay and its trigger sound (the server moves + // the player). + horizon_client::motion::MotionEvent::InsidePortal { .. } => { + self.client_inside_nether_portal(); + } _ => {} } } @@ -3610,7 +3513,7 @@ impl Game<'_> { // ticks), and only the server removes it. let (world, facts, collision) = (&self.world, self.res.facts(), self.collision); for d in self.dropped.iter_mut().filter(|_| running) { - d.tick(world, facts, collision, false); + d.tick(world, facts, collision, false, &self.res.motion().fluids); } head_lerps.retain(|_, (_, steps)| *steps > 0); for (item, ticks, at, eye, pitch, yaw) in using { @@ -4060,6 +3963,10 @@ impl Game<'_> { if let Some(placed) = &placed { self.predict_place(placed, seq); self.with_hand(hand, Game::consume_held); + } else if let Some(r) = self.remote.as_mut() { + // BlockItem.place plays its sound only once the block is set: the + // server's resend of the target it refused is no placement. + r.placing = None; } if reacts || placed.is_some() { self.with_hand(hand, Game::swing_arm); @@ -4828,6 +4735,34 @@ impl Game<'_> { carried, })); } + /// `CreativeModeInventoryScreen.slotClicked` outside the window: the server knows nothing of + /// a stack picked from the creative screen, so the carried stack (an item tab's right click: + /// one of it) is dropped through `handleCreativeModeItemDrop`, a SetCreativeModeSlot to slot + /// -1, and the hand swings as `Player.drop` predicts. + pub(super) fn remote_creative_drop(&mut self, right: bool) { + let one = right && !self.creative_inventory_open(); + let Some(carried) = self.carried.as_mut() else { + return; + }; + let thrown = if one && carried.count > 1 { + carried.count -= 1; + ItemStack { + count: 1, + ..carried.clone() + } + } else { + self.carried.take().expect("carried") + }; + if !self.creative { + return; + } + self.swing_arm(); + let item = self.to_network(&Some(thrown)); + self.send(S::SetCreativeModeSlot(play::SetCreativeModeSlot { + slot: -1, + item, + })); + } pub(super) fn remote_close_container(&mut self) { let id = self .remote diff --git a/crates/horizon-client/src/game/remote_chunks.rs b/crates/horizon-client/src/game/remote_chunks.rs new file mode 100644 index 000000000..47f474619 --- /dev/null +++ b/crates/horizon-client/src/game/remote_chunks.rs @@ -0,0 +1,355 @@ +//! A server's chunk columns (`ClientboundLevelChunkWithLightPacket`): the +//! sections and light of each packet become a client column on a decoder +//! thread as soon as the packet arrives, so the frame that handles it in +//! order only inserts the result (`ClientPacketListener.handleLevelChunkWithLight`). +use super::Game; +use horizon_client::{ + chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy}, + streaming::Streaming, +}; +use horizon_core::paletted::{PalettedContainer, Strategy}; +use horizon_protocol::{ + chunk::{LightData, SectionLight}, + packets::play::{self, Clientbound as C}, + registry::DimensionType, +}; +use std::sync::{ + Arc, + mpsc::{self, TryRecvError}, +}; + +/// What turning a chunk packet into a client column depends on: the +/// dimension's height and sky, and the server's biome registry mapped to +/// ours. The connection replaces it when either changes, so a column decoded +/// with an older one is decoded again. +#[derive(Default)] +pub(super) struct ChunkFormat { + min_y: i32, + sections: usize, + has_skylight: bool, + biome_map: Vec, + biome_bits: u8, +} + +impl ChunkFormat { + pub(super) fn new(dimension: &DimensionType, biome_map: Vec, biome_bits: u8) -> Self { + Self { + min_y: dimension.min_y, + sections: dimension.sections(), + has_skylight: dimension.has_skylight, + biome_map, + biome_bits, + } + } + pub(super) fn with_dimension(&self, dimension: &DimensionType) -> Self { + Self::new(dimension, self.biome_map.clone(), self.biome_bits) + } + + /// LevelChunkSection data into the client's fixed -64..320 column. + fn column(&self, p: &play::LevelChunkWithLight) -> Result { + let sections = p + .chunk + .sections(self.sections, 16, self.biome_bits) + .map_err(|e| e.to_string())?; + let mut chunk = Chunk::empty(p.x, p.z); + let offset = (self.min_y - MIN_Y).div_euclid(16); + // Biome table index per quart cell of the dimension's own sections. + let mut biome_cells: Vec<[u32; 64]> = Vec::with_capacity(sections.len()); + for (i, s) in sections.iter().enumerate() { + let target = offset + i as i32; + let mut cells = [0u32; 64]; + for (j, cell) in cells.iter_mut().enumerate() { + *cell = u32::from( + self.biome_map + .get(s.biomes.get(j) as usize) + .copied() + .unwrap_or(0), + ); + } + biome_cells.push(cells); + if !(0..SECTIONS as i32).contains(&target) { + continue; + } + // A global section is as wide as the server's registry: 16 bits + // from a vanilla server, wider from a Horizon host with the same + // content mods. Read it at that width, then widen it to ours. + let ours = block_strategy(); + let strategy = if ours.wire_has_palette(s.states.bits) { + ours + } else { + Strategy::blocks(s.states.bits) + }; + let palette = s.states.palette.iter().map(|&p| p as u32).collect(); + let words = s.states.data.iter().map(|&w| w as u64).collect(); + let mut blocks = PalettedContainer::from_wire(strategy, s.states.bits, palette, words) + .map_err(|e| e.to_string())?; + if strategy.global_bits != ours.global_bits { + let mut values = [0u32; 4096]; + blocks.unpack(&mut values); + // Ids past our registry (a host with mods we lack) read as air. + let limit = 1u64 << ours.global_bits; + for v in &mut values { + if u64::from(*v) >= limit { + *v = 0; + } + } + blocks = PalettedContainer::from_values(ours, &values); + } + let mut section = Section { + blocks, + biomes: PalettedContainer::from_values(BIOME_STRATEGY, &cells), + light: Light::Uniform(0xF0), + }; + section.compact(); + chunk.sections[target as usize] = Arc::new(section); + } + // Sections outside the dimension's range take its nearest biomes + // (the column's top or bottom cell layer repeated). + if !biome_cells.is_empty() { + let last = biome_cells.len() - 1; + for si in 0..SECTIONS as i32 { + let i = si - offset; + if (0..sections.len() as i32).contains(&i) { + continue; + } + let (edge, layer) = if i < 0 { (0, 0) } else { (last, 3) }; + let mut cells = [0u32; 64]; + for (j, cell) in cells.iter_mut().enumerate() { + *cell = biome_cells[edge][layer * 16 + j % 16]; + } + Arc::make_mut(&mut chunk.sections[si as usize]).biomes = + PalettedContainer::from_values(BIOME_STRATEGY, &cells); + } + } + // ClientPacketListener.applyLightData: the column keeps the light + // the server sent; nothing is relit. + let (layers, above) = self.light(&p.light); + horizon_client::light::light_from_layers(&mut chunk, &layers, above, self.has_skylight); + Ok(chunk) + } + + /// `ClientPacketListener.readSectionList`: the sky and block layers of a + /// light packet, by section of the client's column, and the sky light + /// above the column's top section (from the light section just above + /// it, else open sky). + pub(super) fn light(&self, light: &LightData) -> (Vec, [u8; 256]) { + let mut layers: Vec = vec![(None, None); SECTIONS]; + let sky = self.has_skylight; + let mut above = [if sky { 15 } else { 0 }; 256]; + // Light section b is the dimension's section b - 1. + let first = (self.min_y - MIN_Y).div_euclid(16) - 1; + for (b, layer) in light.layers(self.sections + 2).into_iter().enumerate() { + let si = first + b as i32; + if (0..SECTIONS as i32).contains(&si) { + layers[si as usize] = layer; + } else if si == SECTIONS as i32 + && sky + && let Some(l) = &layer.0 + { + for (i, a) in above.iter_mut().enumerate() { + *a = (l[i >> 1] >> ((i & 1) * 4)) & 15; + } + } + } + (layers, above) + } +} + +type Decoded = (Box, Result); + +/// One thread that decodes chunk packets in the order they arrived; its +/// results come back in that order, one per `submit`. +pub(super) struct ChunkDecoder { + jobs: mpsc::Sender<(Arc, Box)>, + done: mpsc::Receiver, +} + +impl ChunkDecoder { + pub(super) fn new() -> Self { + let (jobs, todo) = mpsc::channel::<(Arc, Box)>(); + let (finished, done) = mpsc::channel(); + // The thread ends with the connection, when `jobs` is dropped. + let spawned = std::thread::Builder::new() + .name("Chunk decoder".into()) + .spawn(move || { + // A frame waits for its columns, as it would for the render + // thread's own work. + horizon_threads::favour_current(); + for (format, packet) in todo { + let column = match &*packet { + C::LevelChunkWithLight(p) => format.column(p), + _ => Err("not a chunk packet".into()), + }; + if finished.send((packet, column)).is_err() { + break; + } + } + }); + if let Err(e) = spawned { + log::warn!("Horizon: no chunk decoder thread ({e}); chunks decode in the frame"); + } + Self { jobs, done } + } + + /// Start decoding a chunk packet with the format it arrived under. + /// Without a decoder thread the packet comes back undecoded. + pub(super) fn submit(&self, format: Arc, packet: Box) -> Option> { + self.jobs.send((format, packet)).err().map(|e| (e.0).1) + } + + /// The oldest submitted packet and its column, unless it is still + /// decoding: a frame never waits for the decoder. + pub(super) fn next(&self) -> Next { + match self.done.try_recv() { + Ok(decoded) => Next::Ready(decoded), + Err(TryRecvError::Empty) => Next::Decoding, + // The decoder thread panicked: its columns are gone. + Err(TryRecvError::Disconnected) => Next::Lost, + } + } +} + +pub(super) enum Next { + Ready(Decoded), + Decoding, + Lost, +} + +impl Game<'_> { + /// `handleLevelChunkWithLight`: the column replaces any loaded one, and + /// its block entities load their update tags. `decoded` is the column the + /// decoder made with `format`; another format since means decode again. + pub(super) fn remote_chunk( + &mut self, + p: &play::LevelChunkWithLight, + decoded: Option<(&Arc, Result)>, + ) { + // ClientChunkCache.replaceWithPacketData: a column outside the + // storage around the view centre is ignored. + if !self.remote_chunk_in_range(p.x, p.z) { + log::warn!( + "Ignoring chunk since it's not in the view range: {}, {}", + p.x, + p.z + ); + return; + } + let Some(format) = self.remote.as_ref().map(|r| r.chunk_format.clone()) else { + return; + }; + let column = match decoded { + Some((used, column)) if Arc::ptr_eq(used, &format) => column, + _ => format.column(p), + }; + let chunk = match column { + Ok(chunk) => chunk, + Err(e) => { + log::warn!("Horizon: chunk {} {}: {e}", p.x, p.z); + return; + } + }; + let (x, z) = (p.x, p.z); + self.streaming.insert_remote(&mut self.world, chunk); + self.world + .block_entities + .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); + for info in &p.chunk.block_entities { + let pos = ( + x * 16 + i32::from(info.packed_xz as u8 >> 4), + i32::from(info.y), + z * 16 + i32::from(info.packed_xz as u8 & 15), + ); + let state = self.world.block(pos.0, pos.1, pos.2); + self.sync_block_entity(pos, state); + // LevelChunk.replaceWithPacketData: the block entity loads its update tag. + self.remote_block_entity_data([pos.0, pos.1, pos.2], info.kind, &info.tag); + } + } + + /// `handleLightUpdatePacket`: the sections it names take its light. + pub(super) fn remote_light_update(&mut self, p: &play::LightUpdate) { + let Some(format) = self.remote.as_ref().map(|r| r.chunk_format.clone()) else { + return; + }; + if !self.world.chunks.contains_key(&(p.x, p.z)) { + return; + } + let (layers, _) = format.light(&p.light); + let Some(chunk) = self.world.chunks.get_mut(&(p.x, p.z)) else { + return; + }; + let changed = horizon_client::light::update_light_layers( + Arc::make_mut(chunk), + &layers, + format.has_skylight, + ); + Streaming::light_updated(&mut self.world, p.x, p.z, &changed); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_protocol::chunk::{ChunkData, Paletted, Section as Wire, Strategy as Wiring}; + + /// A column of `state` with biome 1 everywhere, unlit. + fn packet(x: i32, state: i32) -> Box { + let section = Wire { + non_empty: 4096, + fluids: 0, + states: Paletted::from_values(&[state; 4096], Wiring::Blocks, 16), + biomes: Paletted::from_values(&[1; 64], Wiring::Biomes, 2), + }; + let none = LightData { + sky_mask: Vec::new(), + block_mask: Vec::new(), + empty_sky_mask: Vec::new(), + empty_block_mask: Vec::new(), + sky: Vec::new(), + block: Vec::new(), + }; + Box::new(C::LevelChunkWithLight(play::LevelChunkWithLight { + x, + z: -3, + chunk: ChunkData { + heightmaps: Vec::new(), + buffer: ChunkData::from_sections(&vec![section; 24]), + block_entities: Vec::new(), + }, + light: none, + })) + } + + /// Columns come back one per packet, in the order the packets went in, + /// as the frame would have decoded them itself. + #[test] + fn the_decoder_returns_columns_in_order() { + let overworld = DimensionType::vanilla("minecraft:overworld"); + let format = Arc::new(ChunkFormat::new(&overworld, vec![0, 7, 9], 2)); + let decoder = ChunkDecoder::new(); + for x in 0..20 { + assert!(decoder.submit(format.clone(), packet(x, 1 + x)).is_none()); + } + for x in 0..20 { + let (packet, column) = loop { + match decoder.next() { + Next::Ready(decoded) => break decoded, + Next::Decoding => std::thread::yield_now(), + Next::Lost => panic!("the decoder stopped"), + } + }; + let C::LevelChunkWithLight(p) = *packet else { + panic!("not a chunk packet"); + }; + let (column, direct) = (column.unwrap(), format.column(&p).unwrap()); + assert_eq!((column.x, column.z), (x, -3)); + for (cx, y, cz) in [(0, -64, 0), (5, 70, 9), (15, 319, 15)] { + assert_eq!(column.get(cx, y, cz), 1 + x as u32); + assert_eq!(column.get(cx, y, cz), direct.get(cx, y, cz)); + // Wire biome 1 is our biome 7. + assert_eq!(column.biome(cx, y, cz), 7); + } + } + assert!(matches!(decoder.next(), Next::Decoding)); + } +} diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 2ba4510ea..a117b1b7c 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -353,7 +353,8 @@ impl Game<'_> { out.push(json!({"id": t.id, "kind": "minecraft:trident", "position": at(t.position)})); } for p in &self.creatures.projectiles { - out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position)})); + out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position), "velocity": at(p.velocity), + "player_owned": p.owner == Some(horizon_client::mobs::Who::Player)})); } for (kind, p, _) in self.potions.thrown_entities() { out.push(json!({"kind": kind, "position": at(p)})); diff --git a/crates/horizon-client/src/game/shader_packs.rs b/crates/horizon-client/src/game/shader_packs.rs index ed8ad61b7..4146283d3 100644 --- a/crates/horizon-client/src/game/shader_packs.rs +++ b/crates/horizon-client/src/game/shader_packs.rs @@ -1,7 +1,8 @@ -//! Shader packs, for development until the Shader Packs page exists: `HORIZON_SHADER_PACK=` -//! runs `shaderpacks/` (a folder or a zip beside `options.txt`) over the world; Horizon's -//! own packs go to `game/native_shaders.rs`. The -//! programs of the current dimension's folder are loaded when the dimension changes (spec 1.2). +//! Shader packs: the one picked on Options > Horizon Settings > Shader Packs, or +//! `HORIZON_SHADER_PACK=` (development; it wins over the pick), runs `shaderpacks/` +//! (a folder or a zip beside `options.txt`) over the world; Horizon's own packs go to +//! `game/native_shaders.rs`. The programs of the current dimension's folder are loaded when the +//! dimension changes (spec 1.2). use horizon_client::camera::CameraFluid; use horizon_client::gfx::pack_uniforms::PackInputs; @@ -34,25 +35,34 @@ impl Game<'_> { /// Loads the pack for the current dimension when it changed, and returns this frame's /// inputs to the pack's uniforms. pub(super) fn shader_pack_inputs(&mut self, camera: glam::DVec3, partial: f32) -> PackInputs { - let Some(name) = std::env::var_os("HORIZON_SHADER_PACK") else { + static DEV_PACK: std::sync::OnceLock> = std::sync::OnceLock::new(); + let dev = DEV_PACK.get_or_init(|| std::env::var("HORIZON_SHADER_PACK").ok()); + let picked = dev.as_deref().unwrap_or(&self.settings.horizon.shader_pack); + if self.native_shaders.picked != picked { + // Another pack, or none: drop what ran. + self.native_shaders = super::native_shaders::NativeShaders::picking(picked); + self.pack_ids = None; + if let Some(renderer) = &mut self.renderer { + renderer.drop_shader_packs(); + } + } + if picked.is_empty() { return PackInputs::default(); - }; + } + let name = picked.to_owned(); let dimension = match self.dim { Dim::Overworld => 0, Dim::Nether => -1, Dim::End => 1, }; - let path = std::env::current_dir() - .unwrap_or_default() - .join("shaderpacks") - .join(&name); + let path = Self::shader_packs_dir().join(&name); if horizon_shader_api::package::is_pack(&path) { // One of Horizon's own packs (game/native_shaders.rs). self.tick_native_shader_pack(&path); } else if let Some(renderer) = &mut self.renderer && renderer.shader_pack_dimension() != Some(dimension) { - let name = name.to_string_lossy(); + let name = name.as_str(); let started = std::time::Instant::now(); match Pack::open(&path) { Ok(pack) => { diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index f7be6241f..ed5971324 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -366,6 +366,16 @@ impl Loading { let _ = std::fs::create_dir_all(&dir); packs::open_folder(&dir); } + Event::ListShaderPacks => { + self.settings.shader_packs = + horizon_client::shader_pack_list::scan(&Game::shader_packs_dir()); + } + Event::ShaderPack => self.save_menu_settings(), + Event::OpenShaderPackFolder => { + let dir = Game::shader_packs_dir(); + let _ = std::fs::create_dir_all(&dir); + packs::open_folder(&dir); + } Event::Credits => { if let Some(gui) = &self.gui { let name = self.options.as_ref().map_or_else( diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 5db82b19a..08668b5ef 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -67,7 +67,9 @@ mod end_sky; mod flat; pub mod lightning; mod lod; +mod native_pack; mod native_post; +mod native_sky; mod occlusion; mod pack_atlas; pub mod pack_draw; @@ -86,6 +88,7 @@ mod stars; mod timing; pub mod translucency; pub(crate) mod upload; +mod wgsl_prefix; mod world_post; /// A column whose every section has its mesh (`Renderer::lod_detail_columns`). @@ -457,7 +460,7 @@ pub struct Renderer { lod_retiring: crate::fast_hash::FxHashSet, /// Finished tile meshes `upload_lods` has yet to upload. lod_pending: Option, - detail_columns: HashMap<(i32, i32), u32>, + detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>, /// Bumped whenever a column becomes or stops being complete. detail_revision: u64, arena: arena::Arena, @@ -491,7 +494,7 @@ pub struct Renderer { /// The shadow camera's draws by page, in bands of distance from the light. shadow_runs: page_runs::PageRuns, /// Block-entity blocks per meshed section (world position, state id). - block_entities: HashMap>, + block_entities: crate::fast_hash::FxHashMap>, /// Changes whenever `block_entities` does (unique across renderers). block_entity_revision: u64, /// VisGraph face connectivity per meshed section (cave culling). @@ -501,7 +504,9 @@ pub struct Renderer { /// The shader pack's post-processing, and the dimension (legacy id) it was loaded for. pack_post: Option<(i32, Option)>, /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s. - native_post: Option, + native: Option, + /// Time the shader pack's passes on the GPU (F3, or `HORIZON_SHADER_PACK_TIMING`). + pass_timing: bool, /// The entity vertices Horizon draws itself while a shader pack draws the others. pack_entity_rest: Vec, /// Set 1 of the cloud pipeline, for a shader pack's `gbuffers_clouds`. @@ -2386,7 +2391,7 @@ impl Renderer { lod_cutout: Default::default(), lod_retiring: Default::default(), lod_pending: None, - detail_columns: HashMap::new(), + detail_columns: Default::default(), detail_revision: 0, arena, sorted_indices, @@ -2407,12 +2412,13 @@ impl Renderer { solid_runs: page_runs::PageRuns::default(), phase2_runs: page_runs::PageRuns::default(), shadow_runs: page_runs::PageRuns::default(), - block_entities: HashMap::new(), + block_entities: Default::default(), block_entity_revision: next_block_entity_revision(), occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16), world_post, pack_post: None, - native_post: None, + native: None, + pass_timing: pack_timing::PassTiming::logging(), pack_entity_rest: Vec::new(), cloud_bindings, pack_weather: None, @@ -2842,18 +2848,47 @@ impl Renderer { self.detail_columns.insert(column, next); } } - pub fn remove(&mut self, key: SectionKey) { - self.set_detail(key, false); - if self.block_entities.remove(&key).is_some() { + /// Every section of these columns goes: one lookup per column where the + /// tables are by column, and the meshes' ranges freed in one batch. A + /// teleport removes a few thousand columns in one frame. + pub fn remove_columns(&mut self, columns: impl IntoIterator) { + let mut released = Vec::new(); + let mut block_entities = false; + for (x, z) in columns { + if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) { + self.detail_revision += 1; + } + self.occlusion.remove_column(x, z); + let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z)); + for sy in 0..crate::chunk::SECTIONS as i32 { + let key = (x, sy, z); + block_entities |= self.block_entities.remove(&key).is_some(); + if retiring { + // Distant tiles still leave its column out: drawn until they don't. + self.lod_retiring.insert(key); + } else if let Some(section) = self.sections.remove(key) { + released.push(section); + } + } + } + if block_entities { self.block_entity_revision = next_block_entity_revision(); } - self.occlusion.remove(key); - if !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(key.0, key.2)) { - // Distant tiles still leave its column out: drawn until they don't. - self.lod_retiring.insert(key); - } else { - self.release_section(key); + if let Some(flat) = &mut self.flat { + for id in released.iter().filter_map(|s| s.flat_id) { + flat.remove(id); + } } + self.sorted_indices + .release_all(released.iter().filter_map(|s| { + let (page, start) = s.sorted_indices?; + Some((page, start, u64::from(s.translucent) * 6)) + })); + self.arena.release_all( + released + .iter() + .map(|s| (s.page, s.start, u64::from(s.solid + s.translucent) * 4)), + ); } /// Horizon's resolution scale (world pixels per window pixel) and FXAA. pub fn set_world_post(&mut self, scale: f32, antialias: bool) { @@ -2921,35 +2956,40 @@ impl Renderer { }); self.pack_post = Some((dimension, post)); if self.pack_post.as_ref().is_some_and(|p| p.1.is_some()) { - self.native_post = None; + self.native = None; } report } - /// Runs the post passes of one of Horizon's own shader packs over the world from now on - /// (`None`: no pack), with its options' values; replaces a `shaders/` pack. Returns the - /// passes' labels; on an error the passes that ran keep running. + /// Drops the running shader pack, of either kind. + pub fn drop_shader_packs(&mut self) { + self.pack_post = None; + self.native = None; + self.pack_atlas = None; + } + /// Runs the sky and post stages of one of Horizon's own shader packs from now on (`None`: + /// no pack), with its options' values; replaces a `shaders/` pack. Returns the stages' + /// labels; on an error the pack that ran keeps running. pub fn set_native_shader_pack( &mut self, pack: Option<(horizon_shader_api::Report, Vec<(String, f64)>)>, ) -> std::result::Result, String> { - let stages = pack.map(|(report, constants)| { - let post: Vec<_> = report - .stages - .into_iter() - .filter(|s| s.kind == horizon_shader_api::StageKind::Post) - .collect(); - (post, constants) - }); - let Some((post, constants)) = stages.filter(|(post, _)| !post.is_empty()) else { - self.native_post = None; + let Some((report, constants)) = pack else { + self.native = None; return Ok(Vec::new()); }; let format = self.config.format.remove_srgb_suffix(); - let post = native_post::NativePost::new(&self.device, post, &constants, format)?; - let labels = post.labels().into_iter().map(str::to_owned).collect(); - self.pack_post = None; - self.pack_atlas = None; - self.native_post = Some(post); + let (pack, labels) = native_pack::NativePack::new( + &self.device, + &self.terrain_layout, + report, + &constants, + format, + )?; + self.native = pack.draws().then_some(pack); + if self.native.is_some() { + self.pack_post = None; + self.pack_atlas = None; + } Ok(labels) } /// What a shader pack's gbuffers programs read from Horizon's geometry: the sky's, and @@ -2992,6 +3032,34 @@ impl Renderer { .terrain_inputs(self.pack_terrain_flat), ) } + /// Times the shader pack's passes on the GPU while `on` (the F3 overlay is open), or always + /// with `HORIZON_SHADER_PACK_TIMING`. + pub fn set_pass_timing(&mut self, on: bool) { + self.pass_timing = on || pack_timing::PassTiming::logging(); + } + /// The running shader pack's timer, of either kind. + fn pass_timer<'a>( + pack: &'a mut Option<(i32, Option)>, + native: &'a mut Option, + ) -> Option<&'a mut Option> { + match (pack, native) { + (Some((_, Some(post))), _) => Some(&mut post.timing), + (_, Some(native)) => Some(&mut native.timing), + _ => None, + } + } + /// Each pass of the running shader pack with its median GPU time in milliseconds, while + /// they are timed (`set_pass_timing`). + pub fn shader_pass_times(&self) -> Vec<(String, f32)> { + let timer = match (&self.pack_post, &self.native) { + (Some((_, Some(post))), _) => post.timing.as_ref(), + (_, Some(native)) => native.timing.as_ref(), + _ => None, + }; + timer + .map(pack_timing::PassTiming::medians) + .unwrap_or_default() + } /// The dimension the shader pack was last set for. pub fn shader_pack_dimension(&self) -> Option { self.pack_post.as_ref().map(|p| p.0) @@ -4015,7 +4083,15 @@ impl Renderer { // The world's targets: the screen, or the scaled target of `post`. let pack_post = !frame.title && self.pack_post.as_ref().is_some_and(|p| p.1.is_some()); // One of Horizon's own packs reads the same world target. - let native_post = !frame.title && self.native_post.is_some(); + let native_post = !frame.title && self.native.as_ref().is_some_and(|n| n.post.is_some()); + if let Some(timer) = Self::pass_timer(&mut self.pack_post, &mut self.native) + && timer.is_some() != self.pass_timing + { + *timer = self + .pass_timing + .then(|| pack_timing::PassTiming::new(&self.device, &self.queue)) + .flatten(); + } let pack_reads_world = pack_post || native_post; // The pack's program reads the vertices this frame's draws bind. let pack_draws_terrain = pack_terrain && flat_frame == self.pack_terrain_flat; @@ -4070,24 +4146,79 @@ impl Renderer { cull.bind_depth(&self.device, world_depth); } let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0); + let clear = if frame.title || (frame.end_sky && !frame.underwater) { + wgpu::Color::BLACK + } else { + wgpu::Color { + r: f64::from(fog_color[0]), + g: f64::from(fog_color[1]), + b: f64::from(fog_color[2]), + a: 1.0, + } + }; + let sky_visible = sky_open(frame); + // One of Horizon's own packs: this frame's inputs; in a timed frame its sky draws in a + // pass of its own, so that it has a time of its own. + let mut native_sky_pass = false; + if !frame.title + && let Some(native) = &mut self.native + { + let size = self + .world_post + .size() + .filter(|_| scaled.is_some()) + .unwrap_or([self.config.width, self.config.height]); + native.frame.write(&self.queue, frame, size); + if let Some(t) = &mut native.timing { + t.begin(&self.device, &self.queue); + native_sky_pass = + native.sky.is_some() && t.recording() && sky_visible && frame.skybox; + } + } + if native_sky_pass + && let Some(native) = &mut self.native + && let Some(sky) = &native.sky + { + if let Some(t) = &mut native.timing { + let format = self.config.format.remove_srgb_suffix(); + t.mark(&self.device, &mut encoder, (world_view, format)); + } + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some(&sky.label), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: world_view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(clear), + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: world_depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + timestamp_writes: native.timing.as_mut().and_then(|t| t.writes(&sky.label)), + ..Default::default() + }); + pass.set_bind_group(0, &self.group, &[]); + sky.draw(&mut pass, &native.frame); + } { let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, resolve_target: None, depth_slice: None, ops: wgpu::Operations { - load: wgpu::LoadOp::Clear( - if frame.title || (frame.end_sky && !frame.underwater) { - wgpu::Color::BLACK - } else { - wgpu::Color { - r: f64::from(fog_color[0]), - g: f64::from(fog_color[1]), - b: f64::from(fog_color[2]), - a: 1.0, - } - }, - ), + load: if native_sky_pass { + wgpu::LoadOp::Load + } else { + wgpu::LoadOp::Clear(clear) + }, store: wgpu::StoreOp::Store, }, })]; @@ -4110,11 +4241,19 @@ impl Renderer { ..Default::default() }); pass.set_bind_group(0, &self.group, &[]); - let sky_visible = sky_open(frame); if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) { - if !frame.title && frame.skybox && !pack_draws_sky { - pass.set_pipeline(&self.sky); - pass.draw(0..3, 0..1); + if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass { + match self + .native + .as_ref() + .and_then(|n| Some((n.sky.as_ref()?, &n.frame))) + { + Some((sky, native)) => sky.draw(&mut pass, native), + None => { + pass.set_pipeline(&self.sky); + pass.draw(0..3, 0..1); + } + } } if frame.title { self.panorama.draw(&mut pass); @@ -4466,17 +4605,17 @@ impl Renderer { self.pack_post = Some((dimension, Some(post))); } else if let Some((color, depth)) = &scaled && native_post - && let Some(post) = &mut self.native_post + && let Some(native) = &mut self.native + && let Some(post) = &mut native.post { let size = self.world_post.size().unwrap_or([1, 1]); post.run( &self.device, - &self.queue, &mut encoder, (color, depth), &view_target, - frame, size, + native.timing.as_mut(), ); } else if scaled.is_some() { self.world_post.finish(&mut encoder, &view_target); @@ -4649,6 +4788,9 @@ impl Renderer { timer.submitted(&self.queue); timer.collect(&self.device, &mut self.gpu_times); } + if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native) { + timer.submitted(&self.queue); + } if let Some((path, buffer)) = readback { self.screenshot_result = Some( self.write_screenshot(&path, &buffer) diff --git a/crates/horizon-client/src/gfx/arena.rs b/crates/horizon-client/src/gfx/arena.rs index 34b4d332d..8f320a408 100644 --- a/crates/horizon-client/src/gfx/arena.rs +++ b/crates/horizon-client/src/gfx/arena.rs @@ -39,6 +39,35 @@ impl FreeList { } self.0.insert(start, len); } + /// `give` for many ranges: one merge of the sorted ranges into the list, + /// where giving them one by one costs a few tree lookups each. + fn give_all(&mut self, mut ranges: Vec<(u64, u64)>) { + if ranges.len() < 64 { + for (start, len) in ranges { + self.give(start, len); + } + return; + } + ranges.sort_unstable(); + let mut free = std::mem::take(&mut self.0).into_iter().peekable(); + let mut given = ranges.into_iter().peekable(); + let mut merged: Vec<(u64, u64)> = Vec::new(); + loop { + let next = match (free.peek(), given.peek()) { + (Some(a), Some(b)) if a.0 <= b.0 => free.next(), + (_, Some(_)) => given.next(), + (Some(_), None) => free.next(), + (None, None) => break, + }; + let (start, len) = next.expect("peeked"); + match merged.last_mut() { + Some(last) if last.0 + last.1 == start => last.1 += len, + _ => merged.push((start, len)), + } + } + // Sorted: the tree is built in one pass. + self.0 = merged.into_iter().collect(); + } } /// One vertex buffer of the arena; only the newest page grows. @@ -237,6 +266,26 @@ impl Arena { .free .give(start, len); } + /// `release` for many ranges (page, start, vertices) at once. + pub fn release_all(&mut self, ranges: impl IntoIterator) { + let mut by_page: Vec> = Vec::new(); + for (page, start, vertices) in ranges { + let page = page as usize; + if by_page.len() <= page { + by_page.resize_with(page + 1, Vec::new); + } + by_page[page].push((start, Self::span(vertices).min(self.page_limit))); + } + for (page, ranges) in by_page.into_iter().enumerate() { + if !ranges.is_empty() { + self.pages[page] + .as_mut() + .expect("live arena page") + .free + .give_all(ranges); + } + } + } /// Moves a page into a larger buffer; false (the page unchanged) when /// there is no memory for it. fn grow( @@ -435,6 +484,44 @@ mod tests { assert_eq!(free, FreeList::new(4 * GRAIN)); } + #[test] + fn many_ranges_given_at_once_coalesce_as_one_by_one() { + let fill = || { + let mut free = FreeList::new(1 << 30); + let taken: Vec<(u64, u64)> = (0..500u64) + .map(|i| { + let len = GRAIN * (1 + i * 7 % 5); + (free.take(len).unwrap(), len) + }) + .collect(); + for &(start, len) in taken.iter().step_by(3) { + free.give(start, len); + } + (free, taken) + }; + // Every other range of those still taken, in a scattered order. + let (mut one_by_one, taken) = fill(); + let (mut at_once, _) = fill(); + let mut given: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 == 0) + .map(|i| taken[i]) + .collect(); + given.sort_by_key(|&(start, _)| start.wrapping_mul(0x9E37_79B9_7F4A_7C15)); + assert!(given.len() >= 64); + for &(start, len) in &given { + one_by_one.give(start, len); + } + at_once.give_all(given); + assert_eq!(at_once, one_by_one); + // The rest too: everything is free again, in one range. + let rest: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 != 0) + .map(|i| taken[i]) + .collect(); + at_once.give_all(rest); + assert_eq!(at_once, FreeList::new(1 << 30)); + } + #[test] fn first_fit_reuses_the_lowest_hole() { let mut free = FreeList::new(8 * GRAIN); diff --git a/crates/horizon-client/src/gfx/native_pack.rs b/crates/horizon-client/src/gfx/native_pack.rs new file mode 100644 index 000000000..3f9206e11 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_pack.rs @@ -0,0 +1,60 @@ +//! One of Horizon's own shader packs while it runs (docs/shaders.md): the frame its stages +//! read, its sky and post stages, and the timer of their passes. + +use horizon_shader_api::{Report, StageKind}; + +use super::native_post::{NativeFrame, NativePost}; +use super::native_sky::NativeSky; +use super::pack_timing::PassTiming; + +pub struct NativePack { + pub frame: NativeFrame, + pub sky: Option, + pub post: Option, + /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). + pub timing: Option, +} + +impl NativePack { + /// The pack of the checked stages `report` with the option values `constants`, drawing + /// onto targets of `format`; `globals` is the terrain's group 0, which the sky reads. + /// Also returns its stages' labels, in the order they draw. Errors name the stage wgpu + /// refused. + pub fn new( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + report: Report, + constants: &[(String, f64)], + format: wgpu::TextureFormat, + ) -> Result<(Self, Vec), String> { + let frame = NativeFrame::new(device); + let (post, others): (Vec<_>, Vec<_>) = report + .stages + .into_iter() + .partition(|s| s.kind == StageKind::Post); + let sky = others + .iter() + .find(|s| s.kind == StageKind::Sky) + .map(|stage| NativeSky::new(device, globals, &frame, stage, constants, format)) + .transpose()?; + let post = (!post.is_empty()) + .then(|| NativePost::new(device, post, constants, format, &frame)) + .transpose()?; + let mut labels: Vec = sky.iter().map(|s| s.label.clone()).collect(); + if let Some(post) = &post { + labels.extend(post.labels().into_iter().map(str::to_owned)); + } + let pack = Self { + frame, + sky, + post, + timing: None, + }; + Ok((pack, labels)) + } + + /// Whether the pack draws anything the game runs today. + pub fn draws(&self) -> bool { + self.sky.is_some() || self.post.is_some() + } +} diff --git a/crates/horizon-client/src/gfx/native_post.rs b/crates/horizon-client/src/gfx/native_post.rs index c4af862d7..89515f5db 100644 --- a/crates/horizon-client/src/gfx/native_post.rs +++ b/crates/horizon-client/src/gfx/native_post.rs @@ -3,7 +3,8 @@ //! the pack's options as pipeline constants. A pass reads bind group 3: the frame, the world's //! colour and depth, the previous pass's output and two samplers. Passes before the last write //! half-float targets of the world's size, so values over 1 carry to the next; the last draws -//! onto the screen. +//! onto the screen. Every stage of a pack reads the same `frame`, written once a frame +//! (`NativeFrame`). use glam::{Mat4, Vec3}; use horizon_shader_api::{Frame as FrameInputs, check::CheckedStage, stages::GROUP}; @@ -25,10 +26,89 @@ pub struct NativePost { targets: Option<([u32; 2], [wgpu::TextureView; 2])>, /// One bind group per pass, for these world views. groups: Option<(WorldViews, Vec)>, + /// The screen's colour format, the world target's too. + format: wgpu::TextureFormat, +} + +/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame. +pub struct NativeFrame { + pub(super) buffer: wgpu::Buffer, + /// Group 3 of the stages that read only the frame (the sky). + pub layout: wgpu::BindGroupLayout, + pub group: wgpu::BindGroup, start: std::time::Instant, frames: u32, } +/// The uniform `frame` at binding 0, read by `visibility`. +fn frame_entry(visibility: wgpu::ShaderStages) -> wgpu::BindGroupLayoutEntry { + wgpu::BindGroupLayoutEntry { + binding: 0, + visibility, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: wgpu::BufferSize::new(size_of::() as u64), + }, + count: None, + } +} + +impl NativeFrame { + pub fn new(device: &wgpu::Device) -> Self { + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Native shader pack frame"), + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Native shader pack frame"), + entries: &[frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT)], + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Native shader pack frame"), + layout: &layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: buffer.as_entire_binding(), + }], + }); + Self { + buffer, + layout, + group, + start: std::time::Instant::now(), + frames: 0, + } + } + + /// Writes this frame's inputs, for a world of `size`. + pub fn write(&mut self, queue: &wgpu::Queue, frame: &Frame, size: [u32; 2]) { + let seconds = self.start.elapsed().as_secs_f32() % 3600.0; + let inputs = frame_inputs(frame, size, seconds, self.frames); + self.frames = self.frames.wrapping_add(1); + queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(&inputs)); + } +} + +/// The option values of `constants` that `module` declares as overrides (wgpu refuses others). +pub fn present_constants<'a>( + module: &naga::Module, + constants: &'a [(String, f64)], +) -> Vec<(&'a str, f64)> { + constants + .iter() + .filter(|(id, _)| { + module + .overrides + .iter() + .any(|(_, o)| o.name.as_ref() == Some(id)) + }) + .map(|(id, v)| (id.as_str(), *v)) + .collect() +} + fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry { binding, @@ -59,21 +139,13 @@ impl NativePost { stages: Vec, constants: &[(String, f64)], format: wgpu::TextureFormat, + frame: &NativeFrame, ) -> Result { let float = wgpu::TextureSampleType::Float { filterable: true }; let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Native shader pack post"), entries: &[ - wgpu::BindGroupLayoutEntry { - binding: 0, - visibility: wgpu::ShaderStages::FRAGMENT, - ty: wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: wgpu::BufferSize::new(size_of::() as u64), - }, - count: None, - }, + frame_entry(wgpu::ShaderStages::FRAGMENT), texture_entry(1, float), texture_entry(2, wgpu::TextureSampleType::Depth), texture_entry(3, float), @@ -91,17 +163,7 @@ impl NativePost { let count = stages.len(); let mut passes = Vec::with_capacity(count); for (i, stage) in stages.into_iter().enumerate() { - let present: Vec<(&str, f64)> = constants - .iter() - .filter(|(id, _)| { - stage - .module - .overrides - .iter() - .any(|(_, o)| o.name.as_ref() == Some(id)) - }) - .map(|(id, v)| (id.as_str(), *v)) - .collect(); + let present = present_constants(&stage.module, constants); let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some(&stage.label), @@ -141,12 +203,6 @@ impl NativePost { } passes.push((stage.label, pipeline)); } - let frame = device.create_buffer(&wgpu::BufferDescriptor { - label: Some("Native shader pack frame"), - size: size_of::() as u64, - usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); let sampler = |label, filter| { device.create_sampler(&wgpu::SamplerDescriptor { label: Some(label), @@ -158,13 +214,12 @@ impl NativePost { Ok(Self { passes, layout, - frame, + frame: frame.buffer.clone(), linear: sampler("Native shader pack linear", wgpu::FilterMode::Linear), nearest: sampler("Native shader pack nearest", wgpu::FilterMode::Nearest), targets: None, groups: None, - start: std::time::Instant::now(), - frames: 0, + format, }) } @@ -258,35 +313,20 @@ impl NativePost { } /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto - /// `screen`. + /// `screen`, timed by `timing` when it times this frame. pub fn run( &mut self, device: &wgpu::Device, - queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, world: (&wgpu::TextureView, &wgpu::TextureView), screen: &wgpu::TextureView, - frame: &Frame, - size: [u32; 2], - ) { - let seconds = self.start.elapsed().as_secs_f32() % 3600.0; - let inputs = frame_inputs(frame, size, seconds, self.frames); - self.frames = self.frames.wrapping_add(1); - self.draw(device, queue, encoder, world, screen, &inputs, size); - } - - fn draw( - &mut self, - device: &wgpu::Device, - queue: &wgpu::Queue, - encoder: &mut wgpu::CommandEncoder, - world: (&wgpu::TextureView, &wgpu::TextureView), - screen: &wgpu::TextureView, - inputs: &FrameInputs, size: [u32; 2], + mut timing: Option<&mut super::pack_timing::PassTiming>, ) { self.prepare(device, world, size); - queue.write_buffer(&self.frame, 0, bytemuck::bytes_of(inputs)); + if let Some(t) = timing.as_deref_mut() { + t.mark(device, encoder, (world.0, self.format)); + } let Some((_, groups)) = &self.groups else { return; }; @@ -307,6 +347,7 @@ impl NativePost { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some(label), color_attachments: &attachments, + timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes(label)), ..Default::default() }); pass.set_pipeline(pipeline); @@ -426,8 +467,20 @@ mod tests { .into(); let report = check(&Pack::from_files(files).unwrap()).unwrap(); let format = wgpu::TextureFormat::Rgba8Unorm; - let mut post = - NativePost::new(&device, report.stages, &[("gain".into(), 1.0)], format).unwrap(); + let frame = NativeFrame::new(&device); + queue.write_buffer( + &frame.buffer, + 0, + bytemuck::bytes_of(&FrameInputs::default()), + ); + let mut post = NativePost::new( + &device, + report.stages, + &[("gain".into(), 1.0)], + format, + &frame, + ) + .unwrap(); assert_eq!(post.labels(), ["a.wgsl", "b.wgsl"]); let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING; @@ -467,15 +520,7 @@ mod tests { ..Default::default() }); let view = screen.create_view(&Default::default()); - post.draw( - &device, - &queue, - &mut encoder, - (&color, &depth), - &view, - &FrameInputs::default(), - [4, 4], - ); + post.run(&device, &mut encoder, (&color, &depth), &view, [4, 4], None); let buffer = device.create_buffer(&wgpu::BufferDescriptor { label: None, size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4), diff --git a/crates/horizon-client/src/gfx/native_sky.rs b/crates/horizon-client/src/gfx/native_sky.rs new file mode 100644 index 000000000..3b3c9a3b7 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_sky.rs @@ -0,0 +1,379 @@ +//! The sky stage of Horizon's own shader packs (docs/shaders.md): the pack's `sky` function, +//! called for each pixel of the sky disc with vanilla's colour along its view ray. The +//! pipeline's shader is the pack's stage (`CheckedStage::source`) followed by a copy of the +//! renderer's sky (terrain.wgsl's `Globals`, `linear_fog` and sky section) whose names all +//! take a `horizon_sky_` prefix, so none can meet a pack's (the check refuses `horizon_` +//! names). It reads the renderer's globals (group 0) and the pack's frame (group 3), and +//! draws where vanilla's sky draws; the sun, moon, stars and the dark disc are drawn over it. + +use horizon_shader_api::{check::CheckedStage, stages::GROUP}; + +use super::native_post::{NativeFrame, present_constants}; +use super::wgsl_prefix::{TERRAIN, prefixed, section}; + +const PREFIX: &str = "horizon_sky_"; + +/// The fragment entry that calls the pack: vanilla's colour in, an opaque colour out. +const PACK_ENTRY: &str = " +@fragment fn horizon_sky_fs_pack(in: horizon_sky_SkyOut) -> @location(0) vec4 { + let d = horizon_sky_view_ray(in.ndc); + return vec4(sky(SkyInput(d, vec4(horizon_sky_sky_along_ray(d), 1.0))).rgb, 1.0); +} +"; + +pub struct NativeSky { + pipeline: wgpu::RenderPipeline, + pub label: String, +} + +/// terrain.wgsl's sky with every name it declares (and `globals`) prefixed. +fn vanilla_sky() -> String { + let text = [ + section(TERRAIN, "struct Globals {", "@group(0) @binding(1)"), + section(TERRAIN, "fn linear_fog(", "fn apply_fog("), + section(TERRAIN, "struct SkyOut {", "// rendertype_lines"), + ] + .concat(); + prefixed(&text, PREFIX) +} + +/// The sky shader for the pack's sky stage `source`. +fn shader_source(source: &str) -> String { + format!( + "{source}\n// Horizon's sky (terrain.wgsl)\n{}{PACK_ENTRY}", + vanilla_sky() + ) +} + +/// A sky pipeline over `module` whose fragment entry is `fragment`. +fn pipeline( + device: &wgpu::Device, + layout: &wgpu::PipelineLayout, + module: &wgpu::ShaderModule, + fragment: &str, + constants: &[(&str, f64)], + format: wgpu::TextureFormat, +) -> wgpu::RenderPipeline { + let options = wgpu::PipelineCompilationOptions { + constants, + ..Default::default() + }; + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Native shader pack sky"), + layout: Some(layout), + vertex: wgpu::VertexState { + module, + entry_point: Some("horizon_sky_vs_sky"), + compilation_options: options.clone(), + buffers: &[], + }, + primitive: Default::default(), + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(false), + depth_compare: Some(wgpu::CompareFunction::Always), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module, + entry_point: Some(fragment), + compilation_options: options, + targets: &[Some(wgpu::ColorTargetState { + format, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) +} + +/// The sky's naga module and the layout of its pipelines: `globals` at group 0, the frame +/// at group 3. +fn build( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + frame: &NativeFrame, + stage: &CheckedStage, +) -> Result<(naga::Module, wgpu::PipelineLayout), String> { + let text = shader_source(&stage.source); + let module = naga::front::wgsl::parse_str(&text) + .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?; + let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default(); + groups[0] = Some(globals); + groups[GROUP as usize] = Some(&frame.layout); + let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Native shader pack sky"), + bind_group_layouts: &groups, + ..Default::default() + }); + Ok((module, layout)) +} + +impl NativeSky { + /// The pipeline of the pack's sky `stage` with the option values `constants`, drawing + /// onto the world's target of `format`; `globals` is the terrain's group 0. + pub fn new( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + frame: &NativeFrame, + stage: &CheckedStage, + constants: &[(String, f64)], + format: wgpu::TextureFormat, + ) -> Result { + let (module, layout) = build(device, globals, frame, stage)?; + let present = present_constants(&module, constants); + let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(&stage.label), + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + let pipeline = pipeline( + device, + &layout, + &module, + "horizon_sky_fs_pack", + &present, + format, + ); + if let Some(e) = pollster::block_on(scope.pop()) { + return Err(format!("{}: {e}", stage.file)); + } + Ok(Self { + pipeline, + label: stage.label.clone(), + }) + } + + /// Draws the sky in a pass whose group 0 is the terrain's. + pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, frame: &NativeFrame) { + pass.set_pipeline(&self.pipeline); + pass.set_bind_group(GROUP, &frame.group, &[]); + pass.draw(0..3, 0..1); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_shader_api::{Frame as FrameInputs, MANIFEST, Pack, StageKind, check}; + + fn stage(sky: &str) -> CheckedStage { + let mut manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\ + [sky]\nfile = \"sky.wgsl\"\n" + .to_owned(); + if sky.contains("gain") { + manifest += "[[options]]\nid = \"gain\"\nname = \"Gain\"\ntype = \"float\"\n\ + default = 1.0\nmin = 0.0\nmax = 2.0\n"; + } + let manifest = manifest.as_str(); + let files = [(MANIFEST, manifest), ("sky.wgsl", sky)] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + let mut report = check(&Pack::from_files(files).unwrap()).unwrap(); + assert_eq!(report.stages[0].kind, StageKind::Sky); + report.stages.remove(0) + } + + #[test] + fn the_renderer_s_sky_takes_a_prefix_and_validates_with_a_pack() { + let sky = vanilla_sky(); + for name in [ + "Globals", + "SkyOut", + "view_ray", + "PI", + "sky_along_ray", + "linear_fog", + "fs_sky", + ] { + assert!(sky.contains(&format!("{PREFIX}{name}")), "{name}"); + } + // A pack may use the renderer's names for its own things. + let own = "override gain: f32;\nconst PI: f32 = 3.0;\nfn view_ray() -> f32 { return PI; }\n\ + fn sky(input: SkyInput) -> vec4 { return input.color * gain * view_ray(); }\n"; + let text = shader_source(&stage(own).source); + let module = naga::front::wgsl::parse_str(&text).unwrap_or_else(|e| { + panic!("{}", e.emit_to_string(&text)); + }); + naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::default(), + ) + .validate(&module) + .unwrap(); + } + + /// Vanilla's sky and two packs over the same globals: one that returns its input draws + /// vanilla's pixels, one that inverts them draws the inverse (and stays opaque). + #[test] + fn a_pack_gets_vanilla_s_colour_and_draws_opaque() { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else { + return; + }; + let (device, queue) = + pollster::block_on(adapter.request_device(&Default::default())).unwrap(); + let format = wgpu::TextureFormat::Rgba8Unorm; + let globals_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: None, + entries: &[wgpu::BindGroupLayoutEntry { + binding: 0, + visibility: wgpu::ShaderStages::VERTEX_FRAGMENT, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }], + }); + let mut globals: super::super::Globals = bytemuck::Zeroable::zeroed(); + globals.inverse_view = glam::Mat4::IDENTITY.to_cols_array_2d(); + globals.misc = [0.0, 0.0, 1.0, 1.0]; + globals.fog_color = [0.2, 0.4, 0.6, 1.0]; + globals.sky_color = [0.5, 0.7, 1.0, 1.0]; + globals.fog_ends = [64.0, 0.0, 0.0, 0.0]; + let globals_buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + queue.write_buffer(&globals_buffer, 0, bytemuck::bytes_of(&globals)); + let globals_group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &globals_layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: globals_buffer.as_entire_binding(), + }], + }); + let frame = NativeFrame::new(&device); + queue.write_buffer( + &frame.buffer, + 0, + bytemuck::bytes_of(&FrameInputs::default()), + ); + + let gain = [("gain".to_owned(), 1.0)]; + let draw = |stage: &CheckedStage, vanilla: bool| -> Vec { + let sky = + NativeSky::new(&device, &globals_layout, &frame, stage, &gain, format).unwrap(); + let pipeline = if vanilla { + let (module, layout) = build(&device, &globals_layout, &frame, stage).unwrap(); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: None, + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + pipeline(&device, &layout, &module, "horizon_sky_fs_sky", &[], format) + } else { + sky.pipeline.clone() + }; + let texture = |format, usage| { + device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 4, + height: 4, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage, + view_formats: &[], + }) + }; + let color = texture( + format, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + ); + let depth = texture( + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT, + ); + let (color_view, depth_view) = ( + color.create_view(&Default::default()), + depth.create_view(&Default::default()), + ); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: None, + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &color_view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: &depth_view, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + ..Default::default() + }); + pass.set_bind_group(0, &globals_group, &[]); + pass.set_pipeline(&pipeline); + pass.set_bind_group(GROUP, &frame.group, &[]); + pass.draw(0..3, 0..1); + } + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4), + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + encoder.copy_texture_to_buffer( + color.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &buffer, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT), + rows_per_image: Some(4), + }, + }, + color.size(), + ); + queue.submit([encoder.finish()]); + buffer + .slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + let bytes = buffer.slice(..).get_mapped_range().unwrap().to_vec(); + (0..4) + .flat_map(|row| { + let start = row * wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize; + bytes[start..start + 16].to_vec() + }) + .collect() + }; + let same = stage("fn sky(input: SkyInput) -> vec4 { return input.color; }\n"); + let vanilla = draw(&same, true); + assert_eq!(draw(&same, false), vanilla); + // The top row looks up into the sky disc, the bottom one down into the fog. + assert_ne!(vanilla[..4], vanilla[vanilla.len() - 4..]); + let inverse = stage( + "override gain: f32;\nfn sky(input: SkyInput) -> vec4 { return vec4(vec3(gain) - input.color.rgb, 0.25); }\n", + ); + let inverted = draw(&inverse, false); + for (got, want) in inverted.chunks(4).zip(vanilla.chunks(4)) { + assert_eq!(got[3], 255); + for i in 0..3 { + assert!(got[i].abs_diff(255 - want[i]) <= 1, "{got:?} {want:?}"); + } + } + } +} diff --git a/crates/horizon-client/src/gfx/occlusion.rs b/crates/horizon-client/src/gfx/occlusion.rs index e17ba87d1..22e2f3c81 100644 --- a/crates/horizon-client/src/gfx/occlusion.rs +++ b/crates/horizon-client/src/gfx/occlusion.rs @@ -522,16 +522,27 @@ impl Occlusion { } pub fn set(&mut self, key: SectionKey, vis: u64) { if self.columns.set(key, vis) { - self.edits.push(Edit::Set(key, vis)); - self.dirty = true; - self.changed.push(key); - if self.running.is_some() { - self.changed_late.push(key); - } + self.changed(key, vis); } } - pub fn remove(&mut self, key: SectionKey) { - self.set(key, ALL_VISIBLE); + fn changed(&mut self, key: SectionKey, vis: u64) { + self.edits.push(Edit::Set(key, vis)); + self.dirty = true; + self.changed.push(key); + if self.running.is_some() { + self.changed_late.push(key); + } + } + /// Every section of the column `x`, `z` goes (sees through every face). + pub fn remove_column(&mut self, x: i32, z: i32) { + let Some(column) = self.columns.map.remove(&(x, z)) else { + return; + }; + for (y, &vis) in column.iter().enumerate() { + if vis != ALL_VISIBLE { + self.changed((x, y as i32, z), ALL_VISIBLE); + } + } } pub fn clear(&mut self) { self.columns.map.clear(); diff --git a/crates/horizon-client/src/gfx/pack_post.rs b/crates/horizon-client/src/gfx/pack_post.rs index 19f0d7349..b9320277a 100644 --- a/crates/horizon-client/src/gfx/pack_post.rs +++ b/crates/horizon-client/src/gfx/pack_post.rs @@ -297,8 +297,8 @@ pub struct PackPost { /// with the page buffer it was made for. block_ids: Option<(wgpu::BindGroupLayout, wgpu::Buffer)>, page_groups: HashMap, - /// `HORIZON_SHADER_PACK_TIMING`: GPU time of each pass, in the log. - timing: Option, + /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). + pub timing: Option, /// `shaders.properties`' custom uniforms, after the frame's in `uniforms.values`. custom: horizon_shaders::Custom, atlas: Option, @@ -1430,7 +1430,7 @@ impl PackPost { draws, block_ids, page_groups: HashMap::new(), - timing: super::pack_timing::PassTiming::new(device, queue), + timing: None, custom, atlas: world.atlas.as_ref().map(|a| a.0.clone()), lightmap: world.lightmap, diff --git a/crates/horizon-client/src/gfx/pack_timing.rs b/crates/horizon-client/src/gfx/pack_timing.rs index acfdb698f..2a8dcf4a5 100644 --- a/crates/horizon-client/src/gfx/pack_timing.rs +++ b/crates/horizon-client/src/gfx/pack_timing.rs @@ -1,31 +1,53 @@ -//! Developers' aid: `HORIZON_SHADER_PACK_TIMING=1` times every pass of a shader pack on the -//! GPU, one frame in `EVERY`, and logs each pass's median every `REPORT` timed frames. The -//! frame after a timed one waits for the GPU before reading the timestamps (Metal resolves -//! them without waiting for the passes that write them), so timing slows the game. +//! GPU time of each pass of a shader pack, of either kind: shown in the F3 overlay while it is +//! open, and logged every `REPORT` timed frames with `HORIZON_SHADER_PACK_TIMING=1`. One frame +//! at a time is timed, and the CPU never waits for it: its timestamps are resolved in a later +//! frame, once the GPU has finished it (Metal resolves them without waiting for the passes that +//! write them), then read back when mapped. The next frame after that is timed again. + +use std::collections::VecDeque; +use std::sync::{ + Arc, + atomic::{AtomicBool, Ordering}, +}; -const EVERY: u32 = 30; const REPORT: usize = 30; /// Passes timed per frame at most (two timestamps each). const CAPACITY: u32 = 64; +/// Timed frames each pass's median is taken over. +const WINDOW: usize = 15; -pub(super) struct PassTiming { +enum Stage { + /// The next frame is timed. + Idle, + /// The frame being recorded is timed. + Recording, + /// Submitted; the flag is set once the GPU has finished it. + Running(Arc), + /// Resolved and copied; the flag is set once the copy is mapped. + Reading(Arc, u64), +} + +pub struct PassTiming { queries: wgpu::QuerySet, resolve: wgpu::Buffer, read: wgpu::Buffer, period_ns: f32, - frame: u32, - /// The passes timed in the frame being recorded or waiting to be read, in order. + stage: Stage, + /// The passes of the timed frame, in order. names: Vec, - timed: bool, - samples: Vec<(String, Vec)>, + /// Each pass's last `WINDOW` times, in milliseconds. + samples: Vec<(String, VecDeque)>, + /// Log the medians every `REPORT` timed frames. + log: bool, + /// `mark`'s pipeline, for the target format it was made for. + marker: Option<(wgpu::TextureFormat, wgpu::RenderPipeline)>, reports: usize, } impl PassTiming { + /// `None` when the device can't time passes. pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Option { - if std::env::var_os("HORIZON_SHADER_PACK_TIMING").is_none() - || !device.features().contains(wgpu::Features::TIMESTAMP_QUERY) - { + if !device.features().contains(wgpu::Features::TIMESTAMP_QUERY) { return None; } let size = u64::from(CAPACITY) * 2 * 8; @@ -52,51 +74,138 @@ impl PassTiming { wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, ), period_ns: queue.get_timestamp_period(), - frame: 0, + stage: Stage::Idle, names: Vec::new(), - timed: false, samples: Vec::new(), + log: Self::logging(), + marker: None, reports: 0, }) } - /// At the start of a frame: reads the last timed frame's passes, and decides whether this - /// one is timed. + /// Whether `HORIZON_SHADER_PACK_TIMING` asks for timing without the F3 overlay. + pub fn logging() -> bool { + static LOG: std::sync::OnceLock = std::sync::OnceLock::new(); + *LOG.get_or_init(|| std::env::var_os("HORIZON_SHADER_PACK_TIMING").is_some()) + } + + /// At the start of a frame's passes: moves the last timed frame along, and decides whether + /// this one is timed. pub fn begin(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) { - if self.timed && !self.names.is_empty() { - self.collect(device, queue); + match &self.stage { + // A timed frame that was never submitted: time this one instead. + Stage::Recording => self.stage = Stage::Idle, + Stage::Running(done) if done.load(Ordering::Acquire) => { + let bytes = self.names.len() as u64 * 16; + let mut encoder = device.create_command_encoder(&Default::default()); + encoder.resolve_query_set( + &self.queries, + 0..self.names.len() as u32 * 2, + &self.resolve, + 0, + ); + encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.read, 0, bytes); + queue.submit([encoder.finish()]); + let mapped = Arc::new(AtomicBool::new(false)); + let flag = mapped.clone(); + self.read + .slice(..bytes) + .map_async(wgpu::MapMode::Read, move |r| { + flag.store(r.is_ok(), Ordering::Release) + }); + self.stage = Stage::Reading(mapped, bytes); + } + Stage::Reading(mapped, bytes) if mapped.load(Ordering::Acquire) => { + let bytes = *bytes; + self.collect(bytes); + self.stage = Stage::Idle; + } + _ => {} } - self.names.clear(); - self.frame += 1; - self.timed = self.frame.is_multiple_of(EVERY); + if matches!(self.stage, Stage::Idle) { + self.names.clear(); + self.stage = Stage::Recording; + } + } + + /// Whether the frame being recorded is timed. + pub fn recording(&self) -> bool { + matches!(self.stage, Stage::Recording) } /// Timestamp writes for the pass `name`, in a timed frame. pub fn writes(&mut self, name: &str) -> Option> { + let i = self.push(name)?; + Some(stamps(&self.queries, i)) + } + + /// The index of the timed frame's next pass, `name`. + fn push(&mut self, name: &str) -> Option { let i = self.names.len() as u32; - if !self.timed || i >= CAPACITY { + if !matches!(self.stage, Stage::Recording) || i >= CAPACITY { return None; } self.names.push(name.to_owned()); - Some(wgpu::RenderPassTimestampWrites { - query_set: &self.queries, - beginning_of_pass_write_index: Some(2 * i), - end_of_pass_write_index: Some(2 * i + 1), - }) + Some(i) } - fn collect(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) { - // The timed frame first, then the resolve, so every timestamp is written. - _ = device.poll(wgpu::PollType::wait_indefinitely()); - let count = self.names.len() as u32 * 2; - let bytes = u64::from(count) * 8; - let mut encoder = device.create_command_encoder(&Default::default()); - encoder.resolve_query_set(&self.queries, 0..count, &self.resolve, 0); - encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.read, 0, bytes); - queue.submit([encoder.finish()]); + /// A pass that ends once everything drawn into `target` before it has, in a timed frame: + /// the next pass counts from there, not from when the GPU queued it behind them. + pub fn mark( + &mut self, + device: &wgpu::Device, + encoder: &mut wgpu::CommandEncoder, + (target, format): super::timing::Target, + ) { + if self.marker.as_ref().is_none_or(|(f, _)| *f != format) { + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Shader pack timing mark"), + source: wgpu::ShaderSource::Wgsl(super::timing::MARKER.into()), + }); + let pipeline = super::timing::end_pipeline(device, &module, format); + self.marker = Some((format, pipeline)); + } + // An unnamed pass: its end counts, it is never listed. + let Some(i) = self.push("") else { + return; + }; + let (_, pipeline) = self.marker.as_ref().expect("made above"); + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("Shader pack timing mark"), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: target, + depth_slice: None, + resolve_target: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })], + timestamp_writes: Some(stamps(&self.queries, i)), + ..Default::default() + }); + pass.set_pipeline(pipeline); + pass.set_scissor_rect(0, 0, 1, 1); + pass.draw(0..3, 0..1); + } + + /// After the frame is submitted. + pub fn submitted(&mut self, queue: &wgpu::Queue) { + if !matches!(self.stage, Stage::Recording) { + return; + } + if self.names.is_empty() { + self.stage = Stage::Idle; + return; + } + let done = Arc::new(AtomicBool::new(false)); + let flag = done.clone(); + queue.on_submitted_work_done(move || flag.store(true, Ordering::Release)); + self.stage = Stage::Running(done); + } + + fn collect(&mut self, bytes: u64) { let slice = self.read.slice(..bytes); - slice.map_async(wgpu::MapMode::Read, |_| {}); - _ = device.poll(wgpu::PollType::wait_indefinitely()); let Ok(data) = slice.get_mapped_range() else { return; }; @@ -108,41 +217,91 @@ impl PassTiming { .collect(); drop(data); self.read.unmap(); - // Passes overlap on tiled GPUs (a pass begins before the one before it ends): a pass - // costs the time from the later of its beginning and the previous pass's end. - let mut previous_end = 0; - for (name, pair) in self.names.iter().zip(stamps.as_chunks::<2>().0) { - if pair[0] == 0 || pair[1] < pair[0] { + let times = pass_times(&stamps, self.period_ns); + for (name, ms) in self.names.iter().zip(times) { + let Some(ms) = ms.filter(|_| !name.is_empty()) else { continue; + }; + let i = match self.samples.iter().position(|s| s.0 == *name) { + Some(i) => i, + None => { + self.samples.push((name.clone(), VecDeque::new())); + self.samples.len() - 1 + } + }; + let window = &mut self.samples[i].1; + if window.len() == WINDOW { + window.pop_front(); } - let from = pair[0].max(previous_end).min(pair[1]); - previous_end = pair[1]; - let ms = (pair[1] - from) as f32 * self.period_ns / 1e6; - match self.samples.iter_mut().find(|s| s.0 == *name) { - Some(s) => s.1.push(ms), - None => self.samples.push((name.clone(), vec![ms])), - } + window.push_back(ms); } self.reports += 1; - if self.reports.is_multiple_of(REPORT) { - self.report(); + if self.log && self.reports.is_multiple_of(REPORT) { + let medians = self.medians(); + let total: f32 = medians.iter().map(|m| m.1).sum(); + let parts: Vec = medians + .iter() + .map(|(n, ms)| format!("{n} {ms:.3}")) + .collect(); + log::info!( + "shader pack GPU time per pass (median ms of the last {WINDOW} timed frames): {} = {total:.3}", + parts.join(", ") + ); } } - fn report(&mut self) { - let mut total = 0.0; - let mut parts = Vec::new(); - // A pass that did not run in this window (no entities, the sky out of sight) is left out. - for (name, v) in self.samples.iter_mut().filter(|s| !s.1.is_empty()) { - v.sort_by(f32::total_cmp); - let median = v[v.len() / 2]; - total += median; - parts.push(format!("{name} {median:.3}")); - v.clear(); - } - log::info!( - "shader pack GPU time per pass (median ms of {REPORT} frames): {} = {total:.3}", - parts.join(", ") - ); + /// Each pass's median time in milliseconds over its last timed frames, in the order the + /// passes first ran. + pub fn medians(&self) -> Vec<(String, f32)> { + self.samples + .iter() + .filter(|s| !s.1.is_empty()) + .map(|(name, v)| { + let mut v: Vec = v.iter().copied().collect(); + v.sort_by(f32::total_cmp); + (name.clone(), v[v.len() / 2]) + }) + .collect() + } +} + +/// Pass `i`'s beginning and end timestamps. +fn stamps(queries: &wgpu::QuerySet, i: u32) -> wgpu::RenderPassTimestampWrites<'_> { + wgpu::RenderPassTimestampWrites { + query_set: queries, + beginning_of_pass_write_index: Some(2 * i), + end_of_pass_write_index: Some(2 * i + 1), + } +} + +/// Each pass's time in milliseconds from its (beginning, end) timestamps, `None` for a pass +/// the GPU left unstamped. Passes overlap on tiled GPUs (a pass begins before the one before it +/// ends): a pass costs the time from the later of its beginning and the previous pass's end. +fn pass_times(stamps: &[u64], period_ns: f32) -> Vec> { + let mut previous_end = 0; + stamps + .as_chunks::<2>() + .0 + .iter() + .map(|&[begin, end]| { + if begin == 0 || end < begin { + return None; + } + let from = begin.max(previous_end).min(end); + previous_end = end; + Some((end - from) as f32 * period_ns / 1e6) + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::pass_times; + + #[test] + fn overlapping_passes_cost_from_the_previous_end() { + // Pass 2 begins before pass 1 ends; pass 3 was never stamped. + let stamps = [1_000_000, 3_000_000, 2_000_000, 5_000_000, 0, 0]; + assert_eq!(pass_times(&stamps, 1.0), [Some(2.0), Some(2.0), None]); } } diff --git a/crates/horizon-client/src/gfx/timing.rs b/crates/horizon-client/src/gfx/timing.rs index 5fc566fe7..7d2b17b3b 100644 --- a/crates/horizon-client/src/gfx/timing.rs +++ b/crates/horizon-client/src/gfx/timing.rs @@ -60,7 +60,7 @@ struct Markers { /// The start's one thread; the end's triangle over the whole target (the /// pass's scissor keeps one pixel), shading nothing it writes. -const MARKER: &str = +pub(super) const MARKER: &str = "@vertex fn cover(@builtin(vertex_index) i: u32) -> @builtin(position) vec4 { return vec4(f32(i & 1u) * 4.0 - 1.0, f32(i >> 1u) * 4.0 - 1.0, 0.0, 1.0); } @@ -254,7 +254,7 @@ impl GpuTimer { } /// The end marker's pipeline for a `format` target, every write masked. -fn end_pipeline( +pub(super) fn end_pipeline( device: &wgpu::Device, module: &wgpu::ShaderModule, format: wgpu::TextureFormat, diff --git a/crates/horizon-client/src/gfx/wgsl_prefix.rs b/crates/horizon-client/src/gfx/wgsl_prefix.rs new file mode 100644 index 000000000..03d84a56e --- /dev/null +++ b/crates/horizon-client/src/gfx/wgsl_prefix.rs @@ -0,0 +1,124 @@ +//! Copies of the renderer's own WGSL that run beside a shader pack's code in one module (the +//! sky and material stages of Horizon's packs, docs/shaders.md): every name such a copy +//! declares takes a prefix starting with `horizon_`, which the pack check refuses in a pack, +//! so no pack name can meet one of Horizon's. + +/// terrain.wgsl, which the copies are taken from. +pub const TERRAIN: &str = include_str!("../terrain.wgsl"); + +/// The text of `source` from the line starting with `start` up to (not including) the one +/// starting with `end`. +pub fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str { + let from = source + .find(&format!("\n{start}")) + .expect("the source has the section") + + 1; + let to = from + + source[from..] + .find(&format!("\n{end}")) + .expect("the source ends the section") + + 1; + &source[from..to] +} + +/// The names `text` declares at its top level: functions, structs, constants, overrides and +/// module variables (bindings). +fn declared(text: &str) -> Vec<&str> { + let mut names = Vec::new(); + for line in text.lines() { + // Top level only: a function's own `var` and `let` stay as they are. + if line.starts_with(char::is_whitespace) { + continue; + } + let mut line = line; + while let Some(rest) = line.strip_prefix('@') { + // An attribute: `@vertex`, `@group(0)`, `@binding(1)`. + let end = rest.find(' ').unwrap_or(rest.len()); + line = rest[end..].trim_start(); + } + let rest = ["fn ", "struct ", "const ", "override ", "var "] + .iter() + .find_map(|k| line.strip_prefix(k)) + .or_else(|| { + // `var name`, `var name`. + let rest = line.strip_prefix("var<")?; + Some(rest[rest.find('>')? + 1..].trim_start()) + }); + if let Some(rest) = rest { + let end = rest + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .unwrap_or(rest.len()); + names.push(&rest[..end]); + } + } + names +} + +/// `text` with every name it declares at its top level, and every use of one, prefixed by +/// `prefix`. Comments are rewritten too, which is harmless. +pub fn prefixed(text: &str, prefix: &str) -> String { + let names = declared(text); + let mut out = String::with_capacity(text.len() * 2); + let mut word = String::new(); + let flush = |word: &mut String, out: &mut String| { + if names.contains(&word.as_str()) { + out.push_str(prefix); + } + out.push_str(word); + word.clear(); + }; + for c in text.chars() { + if c.is_ascii_alphanumeric() || c == '_' { + word.push(c); + } else { + flush(&mut word, &mut out); + out.push(c); + } + } + flush(&mut word, &mut out); + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn prefixes_top_level_names_and_their_uses_only() { + let text = "struct S { a: f32, }\n\ + @group(0) @binding(0) var g: S;\n\ + @group(1) @binding(2) var list: array;\n\ + override N: u32 = 1u;\n\ + const K: f32 = 2.0;\n\ + @fragment fn f(x: f32) -> @location(0) vec4 {\n \ + var a = g.a * K;\n \ + return vec4(a + f32(list[N]) + x);\n\ + }\n"; + let out = prefixed(text, "p_"); + assert_eq!( + out, + "struct p_S { a: f32, }\n\ + @group(0) @binding(0) var p_g: p_S;\n\ + @group(1) @binding(2) var p_list: array;\n\ + override p_N: u32 = 1u;\n\ + const p_K: f32 = 2.0;\n\ + @fragment fn p_f(x: f32) -> @location(0) vec4 {\n \ + var a = p_g.a * p_K;\n \ + return vec4(a + f32(p_list[p_N]) + x);\n\ + }\n" + ); + // Every top-level declaration of terrain.wgsl is found. + let names = declared(TERRAIN); + for name in [ + "Globals", + "globals", + "sprites_7", + "SPRITE_SPLIT", + "block_slots", + "fs_sky", + ] { + assert!(names.contains(&name), "{name}"); + } + assert!(!names.contains(&"out")); + } +} diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index d3318aab2..b51a586ab 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -261,6 +261,10 @@ pub struct Graphics { pub battery: bool, /// The graphics API (Windows only; see `GraphicsApi`). pub api: GraphicsApi, + /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is + /// not `shaderPack`, which versions before the clean-room rewrite saved and which stays + /// ignored. + pub shader_pack: String, } impl Default for Graphics { fn default() -> Self { @@ -284,6 +288,7 @@ impl Default for Graphics { fxaa: false, battery: false, api: GraphicsApi::Auto, + shader_pack: String::new(), } } } @@ -334,6 +339,7 @@ impl Graphics { "fxaa" => g.fxaa = flag(g.fxaa), "batteryMode" => g.battery = flag(g.battery), "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(), + "pickedShaderPack" => g.shader_pack = value.to_owned(), "overlay" => { g.overlay = match value { "fps" => Overlay::Fps, @@ -348,7 +354,7 @@ impl Graphics { } pub fn serialize(&self) -> String { format!( - "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\ngraphicsApi:{}\n", + "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n", self.preset.name(), self.lod_distance, self.far_detail.name(), @@ -375,6 +381,7 @@ impl Graphics { bool_text(self.fxaa), bool_text(self.battery), self.api.name(), + self.shader_pack, ) } pub fn save(&self, dir: &Path) { @@ -471,6 +478,7 @@ mod tests { fxaa: true, battery: true, api: GraphicsApi::Dx12, + shader_pack: "Golden Hour".into(), }; assert_eq!(Graphics::parse(&g.serialize()), g); assert_eq!(Graphics::parse(""), Graphics::default()); diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index b462536b9..910911d80 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -2175,17 +2175,24 @@ impl Hub { if g.spectator() || g.sleeping { return (false, false); } - let height = if g.fall_flying { - 0.6 + // getBoundingBox: the box of the body's pose (swimming and crawling + // are 0.6 tall), so a swimmer under a ceiling isn't sent back. + let (half, height) = if g.fall_flying { + (0.3, 0.6) + } else if let Some(m) = &g.motion { + ( + f64::from(m.dimensions.width) / 2.0, + f64::from(m.dimensions.height), + ) } else if g.sneaking { - 1.5 + (0.3, 1.5) } else { - 1.8 + (0.3, 1.8) }; let at = |p: [f64; 3]| { Aabb::new( - Vec3::new(p[0] - 0.3, p[1], p[2] - 0.3), - Vec3::new(p[0] + 0.3, p[1] + height, p[2] + 0.3), + Vec3::new(p[0] - half, p[1], p[2] - half), + Vec3::new(p[0] + half, p[1] + height, p[2] + half), ) }; let (old, new) = (at(g.position), at(to)); diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 7ab6d3f61..6bf40d1f0 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -127,6 +127,7 @@ mod model_library; pub mod models; pub mod motion; pub mod mouse; +pub mod moved_extras; pub mod multiplayer; pub mod music; pub mod nbt_path; @@ -167,6 +168,7 @@ pub mod sculk; pub use horizon_server_files as server; pub mod server_packs; pub mod settings; +pub mod shader_pack_list; pub mod shadows; pub mod signs; pub mod skins; diff --git a/crates/horizon-client/src/main.rs b/crates/horizon-client/src/main.rs index 8004b2fa7..7144a1670 100644 --- a/crates/horizon-client/src/main.rs +++ b/crates/horizon-client/src/main.rs @@ -4,7 +4,13 @@ mod game; use horizon_client::{crash, logging}; +/// The mod API level this game serves, kept in the program for the launcher +/// to read without running it (`horizon_mods::api_level::MARK`). `main` +/// reads it, so the linker keeps it. +static MOD_API_LEVEL: [u8; 27] = horizon_mods::api_level::MARK; + fn main() { + std::hint::black_box(&MOD_API_LEVEL); horizon_client::telemetry::mark_start(); let args: Vec = std::env::args().skip(1).collect(); let game_args = args.iter().take_while(|a| *a != "--dedicated"); diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs index f16e0e18d..394821ace 100644 --- a/crates/horizon-client/src/mobs/living.rs +++ b/crates/horizon-client/src/mobs/living.rs @@ -64,6 +64,31 @@ impl MobWorld<'_> { let b = bounds.deflate(Vec3::new(0.001, 0.001, 0.001)); let (lo, hi) = (b.min_position(), b.max_position()); let mut out = Fluids::default(); + // The eye column below, in the box but for a box thinner than the + // deflation. + let (ex, ez) = ( + ((lo.x + hi.x) / 2.0).floor() as i32, + ((lo.z + hi.z) / 2.0).floor() as i32, + ); + // Most boxes are in sections without a fluid: no cell to read. + let cells = ( + [ + (lo.x.floor() as i32).min(ex), + lo.y.floor() as i32, + (lo.z.floor() as i32).min(ez), + ], + [ + (hi.x.ceil() as i32 - 1).max(ex), + hi.y.ceil() as i32 - 1, + (hi.z.ceil() as i32 - 1).max(ez), + ], + ); + if !self + .world + .may_hold(cells.0, cells.1, |s| self.facts.get(s).fluid != Fluid::None) + { + return out; + } for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) { for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) { for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) { @@ -92,10 +117,6 @@ impl MobWorld<'_> { // EntityFluidInteraction.update: the eyes are in a fluid block of // the box in the entity's column, between its bottom and its height // for the camera. - let (ex, ez) = ( - ((lo.x + hi.x) / 2.0).floor() as i32, - ((lo.z + hi.z) / 2.0).floor() as i32, - ); for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) { let (fluid, h) = self.fluid_height(ex, y, ez); if fluid != Fluid::Water || f64::from(y) + h < lo.y || eye_y < f64::from(y) { @@ -155,14 +176,28 @@ impl MobWorld<'_> { let c = f64::from(c); c < area.max(axis) && c + 1.0 > area.min(axis) }; + // Where no section of the cursor holds a block reaching out of its + // cell, only the cells meeting `area` can hold the support. + let (rx, ry, rz) = (range(Axis::X), range(Axis::Y), range(Axis::Z)); + let outer = self.world.may_hold( + [*rx.start(), *ry.start(), *rz.start()], + [*rx.end(), *ry.end(), *rz.end()], + |s| self.collision.reaches_out(s), + ); let mut best: Option<(f64, [i32; 3])> = None; - for x in range(Axis::X) { - for z in range(Axis::Z) { + for x in rx { + for z in rz.clone() { + let column = meets(Axis::X, x) && meets(Axis::Z, z); + if !outer && !column { + continue; + } let Some(chunk) = self.world.chunks.get(&(x >> 4, z >> 4)) else { continue; }; - let column = meets(Axis::X, x) && meets(Axis::Z, z); - for y in range(Axis::Y) { + for y in ry.clone() { + if !outer && !meets(Axis::Y, y) { + continue; + } let state = chunk.block(x & 15, y, z & 15); let Ok(block) = self.collision.collision_block(state) else { continue; diff --git a/crates/horizon-client/src/mod_list.rs b/crates/horizon-client/src/mod_list.rs index db2ea9194..325839738 100644 --- a/crates/horizon-client/src/mod_list.rs +++ b/crates/horizon-client/src/mod_list.rs @@ -1,7 +1,11 @@ //! Which of the installed Horizon mods are on (`docs/mods.md`), kept in //! `horizon-mods.txt` beside `options.txt` as `mod.:true` lines. Every //! mod is off until the player turns it on in Options > Mods. -use std::{collections::BTreeSet, fs, path::Path}; +use std::{ + collections::{BTreeMap, BTreeSet}, + fs, + path::Path, +}; pub const FILE: &str = "horizon-mods.txt"; /// The folder holding `.hmod` files, beside `options.txt`. @@ -11,6 +15,9 @@ pub const DIR: &str = "horizon-mods"; pub struct ModList { /// Ids of the mods the player turned on. pub enabled: BTreeSet, + /// The keys the player chose for mods' keys, mod id → key name → key + /// (`key..:key.keyboard.x` lines). + pub keys: BTreeMap>, /// What the Mods page shows, filled by the game from the mods it found. pub installed: Vec, } @@ -45,20 +52,41 @@ impl ModList { .filter_map(|(k, _)| k.trim().strip_prefix("mod.")) .map(str::to_owned) .collect(); + let mut keys: BTreeMap> = BTreeMap::new(); + for (k, v) in text.lines().filter_map(|l| l.split_once(':')) { + // Mod ids have no dots; a key's name may. + if let Some((id, name)) = k + .trim() + .strip_prefix("key.") + .and_then(|r| r.split_once('.')) + { + let entry = keys.entry(id.to_owned()).or_default(); + entry.insert(name.to_owned(), v.trim().to_owned()); + } + } Self { enabled, + keys, installed: Vec::new(), } } pub fn serialize(&self) -> String { - self.enabled - .iter() - .map(|id| format!("mod.{id}:true\n")) - .collect() + let on = self.enabled.iter().map(|id| format!("mod.{id}:true\n")); + let keys = self.keys.iter().flat_map(|(id, keys)| { + keys.iter() + .map(move |(name, key)| format!("key.{id}.{name}:{key}\n")) + }); + on.chain(keys).collect() + } + /// Mod `id`'s chosen keys, for `Mods::set_bindings`. + pub fn keys_of(&self, id: &str) -> Vec<(&str, &str)> { + self.keys.get(id).map_or_else(Vec::new, |k| { + k.iter().map(|(n, k)| (n.as_str(), k.as_str())).collect() + }) } pub fn save(&self, dir: &Path) { let path = dir.join(FILE); - if self.enabled.is_empty() && !path.exists() { + if self.enabled.is_empty() && self.keys.is_empty() && !path.exists() { return; } let _ = fs::write(path, self.serialize()); @@ -91,6 +119,18 @@ mod tests { assert_eq!(ModList::default().serialize(), ""); } + #[test] + fn keeps_the_keys_players_chose() { + let text = "mod.zoom:true\nkey.zoom.zoom.in:key.mouse.4\nkey.zoom.out:key.keyboard.x\n"; + let list = ModList::parse(text); + assert_eq!( + list.keys_of("zoom"), + [("out", "key.keyboard.x"), ("zoom.in", "key.mouse.4")] + ); + assert!(list.keys_of("other").is_empty()); + assert_eq!(ModList::parse(&list.serialize()), list); + } + #[test] fn toggles_installed_mods_but_not_dev_ones() { let installed = |id: &str, dev| Installed { diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index a6f97981e..0bce8927c 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -44,7 +44,7 @@ use std::{ pub(crate) mod environment; mod fluids; -pub use fluids::{FluidResources, LAVA, PlayerFluids, WATER}; +pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER}; pub struct MotionResources { pub attributes: Arc, diff --git a/crates/horizon-client/src/motion/fluids.rs b/crates/horizon-client/src/motion/fluids.rs index 89affeb64..894e6d907 100644 --- a/crates/horizon-client/src/motion/fluids.rs +++ b/crates/horizon-client/src/motion/fluids.rs @@ -103,10 +103,10 @@ fn is_tagged(kind: FluidKind, tag: FluidTagId) -> bool { } impl PlayerMotion { pub fn fluid_height(&self, tag: FluidTagId) -> f64 { - self.fluids.interaction.fluid_height(&Membership, tag) + self.fluids.interaction.fluid_height(&FluidTags, tag) } pub fn is_eye_in_fluid(&self, tag: FluidTagId) -> bool { - self.fluids.interaction.is_eye_in_fluid(&Membership, tag) + self.fluids.interaction.is_eye_in_fluid(&FluidTags, tag) } /// `LocalPlayer.isUnderWater`: `wasUnderwater`, the eye sample `Player.tick` /// takes before the base tick (`Entity.isUnderWater` also needs the body @@ -116,11 +116,12 @@ impl PlayerMotion { } /// `Entity.isInLava`. pub fn is_in_lava(&self) -> bool { - !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&Membership, LAVA) + !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA) } } -struct Membership; -impl FluidMembership for Membership { +/// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold. +pub struct FluidTags; +impl FluidMembership for FluidTags { fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool { is_tagged(kind, tag) } diff --git a/crates/horizon-client/src/moved_extras.rs b/crates/horizon-client/src/moved_extras.rs new file mode 100644 index 000000000..4c99a49bf --- /dev/null +++ b/crates/horizon-client/src/moved_extras.rs @@ -0,0 +1,286 @@ +//! Extras that became official mods (docs/mods.md, "Horizon's official +//! mods"). For a player who had one on, the game installs the mod from +//! Horizon's registry once, checked as the launcher checks it, turns it on +//! and carries the extra's settings over into the mod's storage. A player +//! who had it off gets nothing: the mod is in the mod browser. +use crate::{extras::Extras, mod_list::ModList}; +use horizon_mods::index::{self, Index}; +use std::{ + fs, + io::Read, + path::{Path, PathBuf}, +}; + +/// Horizon's registry; `HORIZON_MOD_INDEX` points elsewhere (a local file +/// for trials, whose files may then be `file://`), as for the launcher. +pub const INDEX_URL: &str = "https://ludovic111.github.io/horizon-mods/index.json"; +const MAX_INDEX: u64 = 16 << 20; + +/// An extra that is an official mod now. +#[derive(Debug, PartialEq)] +pub struct Moved { + /// The mod's id in the registry. + pub id: &'static str, + /// The extra's name, for the line the player reads. + pub name: &'static str, +} + +pub const MOVED: [Moved; 4] = [ + Moved { + id: "fps_overlay", + name: "FPS counter", + }, + Moved { + id: "keystrokes", + name: "Keystrokes", + }, + Moved { + id: "zoom", + name: "Zoom", + }, + Moved { + id: "minimap", + name: "Minimap", + }, +]; + +impl Moved { + fn was_on(&self, e: &Extras) -> bool { + match self.id { + "fps_overlay" => e.fps, + "keystrokes" => e.keystrokes, + "zoom" => e.zoom, + _ => e.minimap, + } + } + /// The extra's settings as the mod keeps them (its storage keys). + pub fn settings(&self, e: &Extras) -> Vec<(&'static str, String)> { + let flag = |b: bool| if b { "true" } else { "false" }.to_owned(); + match self.id { + "fps_overlay" => vec![ + ("corner", e.fps_corner.name().into()), + ("lows", flag(e.fps_lows)), + ], + "keystrokes" => vec![ + ("corner", e.keystrokes_corner.name().into()), + ("cps", flag(e.keystrokes_cps)), + ], + "zoom" => vec![ + ("level", e.zoom_level.to_string()), + ("smooth", flag(e.zoom_smooth)), + ("sensitivity", flag(e.zoom_sensitivity)), + ], + _ => vec![ + ("corner", e.minimap_corner.name().into()), + ("size", e.minimap_size.to_string()), + ( + "shape", + if e.minimap_round { "round" } else { "square" }.into(), + ), + ("zoom", e.minimap_zoom.to_string()), + ("rotate", flag(e.minimap_rotate)), + ], + } + } + /// The extra's key as the mod's key (`horizon-mods.txt`), when the + /// player had changed it from the mod's default. + pub fn keys(&self, e: &Extras) -> Vec<(&'static str, String)> { + match self.id { + "zoom" if e.zoom_key != "key.keyboard.z" => vec![("zoom", e.zoom_key.clone())], + _ => Vec::new(), + } + } + /// The line the player reads once it is installed. + pub fn notice(&self) -> String { + format!("{} moved to the mod browser: installed for you", self.name) + } +} + +/// The moved extras still to install: on, and not done yet. +pub fn pending(e: &Extras) -> Vec<&'static Moved> { + MOVED + .iter() + .filter(|m| m.was_on(e) && !e.moved.iter().any(|d| d == m.id)) + .collect() +} + +/// The moved extras that were off and not marked yet: nothing to install, +/// only to remember. +pub fn nothing_to_do(e: &Extras) -> Vec<&'static Moved> { + MOVED + .iter() + .filter(|m| !m.was_on(e) && !e.moved.iter().any(|d| d == m.id)) + .collect() +} + +fn location() -> String { + std::env::var("HORIZON_MOD_INDEX") + .ok() + .filter(|v| !v.is_empty()) + .unwrap_or_else(|| INDEX_URL.to_owned()) +} + +/// `url`'s bytes, at most `max`: `https://` from the network; `file://` only +/// with a local index (a trial registry). +fn get(url: &str, local: bool, max: u64) -> Result, String> { + let mut out = Vec::new(); + if url.starts_with("https://") { + let response = ureq::AgentBuilder::new() + .timeout(std::time::Duration::from_secs(60)) + .build() + .get(url) + .call() + .map_err(|e| format!("{url}: {e}"))?; + response + .into_reader() + .take(max + 1) + .read_to_end(&mut out) + .map_err(|e| e.to_string())?; + } else { + let path = match url.strip_prefix("file://") { + Some(p) if local => p, + _ if local && !url.contains("://") => url, + _ => return Err(format!("{url}: not an https address")), + }; + out = fs::read(path).map_err(|e| format!("{path}: {e}"))?; + } + if out.len() as u64 > max { + return Err(format!("{url}: over {max} bytes")); + } + Ok(out) +} + +/// The registry's index, from the network (or `HORIZON_MOD_INDEX`). +pub fn fetch_index() -> Result { + let at = location(); + let local = !at.starts_with("https://"); + let text = String::from_utf8(get(&at, local, MAX_INDEX)?).map_err(|e| e.to_string())?; + if local { + Index::parse_local(&text) + } else { + Index::parse(&text) + } +} + +/// Installs `m` into the game folder `dir` (where `options.txt` is), for a +/// player whose extras were `e`: its newest version for this game that +/// wasn't taken down and that this Horizon's mod API level runs, checked +/// against the index (size, SHA-256, signature, manifest), as +/// `horizon-mods/.hmod`, turned on, with the extra's settings in its +/// storage unless the mod has its own already. +pub fn install(index: &Index, m: &Moved, e: &Extras, dir: &Path) -> Result<(), String> { + let project = index + .project(m.id) + .ok_or_else(|| format!("{} isn't in Horizon's registry yet", m.id))?; + let version = index + .installable( + project, + horizon_core::version::VERSION_ID, + horizon_mods::api_level::LEVEL, + ) + .ok_or_else(|| format!("{} has no version this Horizon can run", m.id))?; + let mods = dir.join(crate::mod_list::DIR); + fs::create_dir_all(&mods).map_err(|e| format!("{}: {e}", mods.display()))?; + let target = mods.join(format!("{}.hmod", m.id)); + let current = index::sha256_file(&target).ok(); + if current.as_deref() != Some(version.file.sha256.as_str()) { + let local = !location().starts_with("https://"); + let bytes = get(&version.file.url, local, index::MAX_FILE)?; + let partial: PathBuf = mods.join(format!(".{}.hmod.download", m.id)); + fs::write(&partial, bytes).map_err(|e| format!("{}: {e}", partial.display()))?; + if let Err(e) = index::check_file(index, project, version, &partial) { + let _ = fs::remove_file(&partial); + return Err(format!("{}: {e}", m.id)); + } + fs::rename(&partial, &target).map_err(|e| format!("{}: {e}", target.display()))?; + } + let storage = mods.join(horizon_mods::manifest::STORAGE_DIR).join(m.id); + fs::create_dir_all(&storage).map_err(|e| format!("{}: {e}", storage.display()))?; + for (key, value) in m.settings(e) { + let path = storage.join(key); + if !path.exists() { + fs::write(&path, value).map_err(|e| format!("{}: {e}", path.display()))?; + } + } + let mut list = ModList::load(dir); + list.enabled.insert(m.id.to_owned()); + // A key the player already chose for the mod stays. + let keys = list.keys.entry(m.id.to_owned()).or_default(); + for (name, key) in m.keys(e) { + keys.entry(name.to_owned()).or_insert(key); + } + list.keys.retain(|_, k| !k.is_empty()); + list.save(dir); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::extras::Corner; + + #[test] + fn only_extras_that_were_on_are_installed_and_each_once() { + let mut e = Extras::default(); + assert!(pending(&e).is_empty()); + assert_eq!(nothing_to_do(&e).len(), 4); + e.fps = true; + e.fps_corner = Corner::BottomRight; + e.fps_lows = true; + assert_eq!(pending(&e), [&MOVED[0]]); + assert_eq!( + MOVED[0].settings(&e), + [("corner", "bottom_right".into()), ("lows", "true".into())] + ); + assert_eq!( + MOVED[1].settings(&e), + [("corner", "top_left".into()), ("cps", "true".into())] + ); + e.moved.push("fps_overlay".into()); + assert!(pending(&e).is_empty()); + assert_eq!(nothing_to_do(&e), [&MOVED[1], &MOVED[2], &MOVED[3]]); + // Zoom: its settings, and its key only when the player changed it. + e.zoom = true; + e.zoom_level = 8; + e.zoom_smooth = false; + assert_eq!(pending(&e), [&MOVED[2]]); + assert_eq!( + MOVED[2].settings(&e), + [ + ("level", "8".into()), + ("smooth", "false".into()), + ("sensitivity", "true".into()) + ] + ); + assert!(MOVED[2].keys(&e).is_empty()); + e.zoom_key = "key.mouse.4".into(); + assert_eq!(MOVED[2].keys(&e), [("zoom", "key.mouse.4".into())]); + // The minimap: its five settings, in the extra's values. + e.minimap = true; + e.minimap_corner = Corner::BottomLeft; + e.minimap_size = 128; + e.minimap_round = true; + e.minimap_zoom = 0.5; + assert_eq!(pending(&e), [&MOVED[2], &MOVED[3]]); + assert_eq!( + MOVED[3].settings(&e), + [ + ("corner", "bottom_left".into()), + ("size", "128".into()), + ("shape", "round".into()), + ("zoom", "0.5".into()), + ("rotate", "false".into()) + ] + ); + assert_eq!( + MOVED[0].notice(), + "FPS counter moved to the mod browser: installed for you" + ); + } + + #[test] + fn a_file_url_needs_a_local_index() { + assert!(get("file:///etc/hosts", false, 1 << 20).is_err()); + assert!(get("http://example.com/x", true, 1 << 20).is_err()); + } +} diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 9f91254bd..61fda9878 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -863,6 +863,8 @@ pub enum Page { Font, Packs, Mods, + /// Horizon's shader packs, either kind (`shader_pack_list`). + ShaderPacks, /// Horizon's graphics settings (`graphics_ui`). Graphics, GraphicsAdvanced, @@ -893,6 +895,9 @@ enum Act { ResetPadKey(&'static str), ResetPadKeys, ToggleMod(usize), + /// Pick `s.shader_packs[i]`, or turn it off when it is the pick. + PickShaderPack(usize), + OpenShaderPackFolder, /// The installed mod's own settings page (capability `ui`), shown as a /// screen: `Event::ModSettings` has the game open it. ModSettings(usize), @@ -947,6 +952,11 @@ pub enum Event { Packs(Vec), OpenPackFolder, OpenModFolder, + /// The Shader Packs page opened: list `shaderpacks/` into `shader_packs`. + ListShaderPacks, + /// A shader pack was picked or turned off: save and apply it. + ShaderPack, + OpenShaderPackFolder, /// Open the mod's own settings page (capability `ui`): the installed /// mod's index in `mods.installed`. ModSettings(usize), @@ -1092,6 +1102,9 @@ fn horizon_page_tooltip(page: Page) -> Option<&'static str> { "Optional additions, all off by default: the game stays vanilla until you turn one on." } Page::Agent => "Let your own AI agent play: horizon-ctl and MCP clients on this computer.", + Page::ShaderPacks => { + "Shader packs from the shaderpacks folder: Horizon's own and those in the shaders/ format. One runs at a time." + } Page::Mods => { "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on." } @@ -1183,6 +1196,7 @@ impl OptionsUi { Page::Font => "options.font.title", Page::Packs => "resourcePack.title", Page::Mods => "Mods", + Page::ShaderPacks => "Shader Packs", Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle", Page::Controller => "Controller Settings", Page::PadBinds => "Controller Binds", @@ -1299,23 +1313,30 @@ impl OptionsUi { Some(open("Advanced Graphics...", Page::GraphicsAdvanced)), ), Row::Buttons( - open("Controller Settings...", Page::Controller), - Some(self.extra_button(s, crate::extras::Item::DiscordPresence)), + open("Shader Packs...", Page::ShaderPacks), + Some(open("Controller Settings...", Page::Controller)), ), Row::Buttons( open("Extras...", Page::Extras), Some(open("Mods...", Page::Mods)), ), // No AI hides the AI Agent page and everything AI. - if s.extras.no_ai { - Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None) - } else { - Row::Buttons( - open("AI Agent...", Page::Agent), - Some(self.extra_button(s, crate::extras::Item::NoAi)), - ) - }, + Row::Buttons( + self.extra_button(s, crate::extras::Item::DiscordPresence), + Some(if s.extras.no_ai { + self.extra_button(s, crate::extras::Item::NoAi) + } else { + open("AI Agent...", Page::Agent) + }), + ), ] + .into_iter() + .chain( + (!s.extras.no_ai).then(|| { + Row::Buttons(self.extra_button(s, crate::extras::Item::NoAi), None) + }), + ) + .collect() } Page::Agent => { let mut rows = vec![Row::Buttons( @@ -1532,6 +1553,26 @@ impl OptionsUi { }) .collect() } + Page::ShaderPacks => { + if s.shader_packs.is_empty() { + return vec![Row::Header( + "No shader packs: put them in the shaderpacks folder", + )]; + } + s.shader_packs + .iter() + .enumerate() + .map(|(i, pack)| { + let kind = match pack.kind { + crate::shader_pack_list::Kind::Horizon => " (Horizon)", + crate::shader_pack_list::Kind::Classic => "", + }; + let label = Text::literal(format!("{}{kind}: ", pack.title)) + .append(on_off(s.horizon.shader_pack == pack.file)); + Row::Buttons(button(0.0, 0.0, 310.0, label, Act::PickShaderPack(i)), None) + }) + .collect() + } _ => { let _ = s; Vec::new() @@ -2017,13 +2058,18 @@ impl OptionsUi { } content = y + self.scroll - top + 2.0; out[list_start..].iter_mut().for_each(|w| w.list = true); - if page == Page::Mods { + let folder = match page { + Page::Mods => Some(("Open Mod Folder", Act::OpenModFolder)), + Page::ShaderPacks => Some(("Open Pack Folder", Act::OpenShaderPackFolder)), + _ => None, + }; + if let Some((label, act)) = folder { out.push(button( cx - 154.0, h - 27.0, 150.0, - Text::literal("Open Mod Folder"), - Act::OpenModFolder, + Text::literal(label), + act, )); out.push(button(cx + 4.0, h - 27.0, 150.0, tr("gui.done"), Act::Done)); } else { @@ -2475,7 +2521,12 @@ impl OptionsUi { } => { events.push(Event::ButtonClick); match act { - Act::Push(p) => self.push(p), + Act::Push(p) => { + if p == Page::ShaderPacks { + events.push(Event::ListShaderPacks); + } + self.push(p) + } Act::Done => events.extend(self.back(s)), Act::Cycle(opt) => { opt.cycle(s, right, framebuffer); @@ -2520,6 +2571,17 @@ impl OptionsUi { events.push(Event::ModSettings(i)); } Act::OpenModFolder => events.push(Event::OpenModFolder), + Act::PickShaderPack(i) => { + if let Some(pack) = s.shader_packs.get(i) { + s.horizon.shader_pack = if s.horizon.shader_pack == pack.file { + String::new() + } else { + pack.file.clone() + }; + events.push(Event::ShaderPack); + } + } + Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder), Act::Credits => events.push(Event::Credits), Act::CopyAgentDetails => events.push(Event::CopyAgentDetails), Act::None => {} @@ -3296,26 +3358,29 @@ mod tests { crate::extras::rows().iter().filter(|r| r.is_ok()).count() ); assert_eq!( - click(&mut ui, &mut s, Act::Extra(crate::extras::Item::Zoom)), + click(&mut ui, &mut s, Act::Extra(crate::extras::Item::Sort)), vec![Event::ButtonClick, Event::Changed] ); - assert!(s.extras.zoom); + assert!(s.extras.sort); assert_eq!( - click(&mut ui, &mut s, Act::Extra(crate::extras::Item::ZoomKey)), + click(&mut ui, &mut s, Act::Extra(crate::extras::Item::SortKey)), vec![Event::ButtonClick] ); - assert_eq!(ui.selected_key, Some(crate::extras::ZOOM_KEY)); + assert_eq!(ui.selected_key, Some(crate::extras::SORT_KEY)); assert_eq!( ui.key(&mut s, &atlas, winit::keyboard::KeyCode::KeyC, None), vec![Event::Changed] ); - assert_eq!(s.extras.zoom_key, "key.keyboard.c"); + assert_eq!(s.extras.sort_key, "key.keyboard.c"); assert_eq!( crate::extras::Extras::parse(&s.extras.serialize()), s.extras ); - ui.scroll(&s, size, -1000.0); - let (_, top, bottom, content) = ui.layout(&s, size.0, size.1); + // In a window too short for the page, the wheel scrolls to its end. + let short = (480.0, 180.0); + ui.scroll(&s, short, -1000.0); + let (_, top, bottom, content) = ui.layout(&s, short.0, short.1); + assert!(content > bottom - top); assert_eq!(ui.scroll, content - (bottom - top)); assert_eq!( ui.key(&mut s, &atlas, winit::keyboard::KeyCode::Escape, None), @@ -3867,7 +3932,7 @@ mod tests { #[test] fn extras_and_vanilla_bindings_accept_mouse_buttons() { - use crate::extras::{Extras, SORT_KEY, ZOOM_KEY}; + use crate::extras::{Extras, SORT_KEY}; use winit::event::MouseButton; for button in [ MouseButton::Left, @@ -3876,7 +3941,7 @@ mod tests { MouseButton::Back, MouseButton::Forward, ] { - for name in [SORT_KEY, ZOOM_KEY, "key.jump"] { + for name in [SORT_KEY, "key.jump"] { let mut ui = OptionsUi::default(); let mut s = Settings::default(); ui.selected_key = Some(name); @@ -3885,7 +3950,6 @@ mod tests { let value = keybinds::mouse_name(button); match name { SORT_KEY => assert_eq!(s.extras.sort_key, value), - ZOOM_KEY => assert_eq!(s.extras.zoom_key, value), _ => assert_eq!(s.keys.get(name), value), } assert_eq!(Extras::parse(&s.extras.serialize()), s.extras); @@ -4064,6 +4128,7 @@ mod tests { [ Page::Graphics, Page::GraphicsAdvanced, + Page::ShaderPacks, Page::Controller, Page::Extras, Page::Mods, diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 2a53e1702..74c428923 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -182,6 +182,9 @@ pub struct Settings { pub extras: crate::extras::Extras, /// The Horizon mods turned on (`horizon-mods.txt`), all off by default. pub mods: crate::mod_list::ModList, + /// The packs in `shaderpacks/`, listed when the Shader Packs page opens; the pick is + /// `horizon.shader_pack`. + pub shader_packs: Vec, } impl Default for Settings { fn default() -> Self { @@ -255,6 +258,7 @@ impl Default for Settings { controller: Default::default(), extras: Default::default(), mods: Default::default(), + shader_packs: Vec::new(), } } } @@ -415,6 +419,7 @@ impl Settings { controller: Default::default(), extras: Default::default(), mods: Default::default(), + shader_packs: Vec::new(), auto_jump: f.bool("autoJump"), language: f.string("lang"), force_unicode: f.bool("forceUnicodeFont"), @@ -538,6 +543,21 @@ impl Settings { } f } + /// These settings with one `options.txt` value changed (`horizon-ctl + /// options-set`, as `OptionsFile::set_text` reads it). Horizon's own + /// files (graphics, controller, extras, the mod list) aren't in + /// `options.txt`, so they stay as they are. + pub fn with_option(&self, key: &str, value: &str) -> Result { + let mut file = self.to_file(); + file.set_text(key, value)?; + Ok(Self { + horizon: self.horizon.clone(), + controller: self.controller.clone(), + extras: self.extras.clone(), + mods: self.mods.clone(), + ..Self::from_file(file) + }) + } /// The `options.txt` text (Options.save). pub fn serialize(&self) -> String { self.to_file().serialize() @@ -592,6 +612,21 @@ impl Settings { mod tests { use super::*; #[test] + fn an_option_set_keeps_horizon_files() { + let mut s = Settings::parse("fov:70\n"); + s.mods.enabled.insert("zoom".into()); + s.extras.minimap = true; + s.horizon.fog = !s.horizon.fog; + s.controller.vibration = !s.controller.vibration; + let set = s.with_option("fov", "90").unwrap(); + assert_eq!(set.fov, 90.0); + assert_eq!(set.mods, s.mods); + assert_eq!(set.extras, s.extras); + assert_eq!(set.horizon, s.horizon); + assert_eq!(set.controller, s.controller); + assert!(s.with_option("fov", "200").is_err()); + } + #[test] fn gui_scale_survives_temporary_small_framebuffer() { for requested in [0, 1, 2, 6] { let settings = Settings::parse(&format!("guiScale:{requested}\n")); diff --git a/crates/horizon-client/src/shader_pack_list.rs b/crates/horizon-client/src/shader_pack_list.rs new file mode 100644 index 000000000..c9a8f338b --- /dev/null +++ b/crates/horizon-client/src/shader_pack_list.rs @@ -0,0 +1,109 @@ +//! The shader packs in the `shaderpacks` folder beside `options.txt`, as Options > Horizon +//! Settings > Shader Packs lists them: Horizon's own (docs/shaders.md) and those in the +//! `shaders/` format, side by side. + +use std::path::Path; + +pub const DIR: &str = "shaderpacks"; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Kind { + /// A folder with `horizon-shaders.toml`, or a `.hshader`. + Horizon, + /// A folder with a `shaders` folder, or a `.zip`. + Classic, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Entry { + /// The folder's or file's name in `shaderpacks`: what the pick saves. + pub file: String, + /// The pack's own name for Horizon's packs, else `file`. + pub title: String, + pub kind: Kind, +} + +/// The packs in `dir`, Horizon's first, each kind by title. A missing folder has none. +pub fn scan(dir: &Path) -> Vec { + let Ok(entries) = std::fs::read_dir(dir) else { + return Vec::new(); + }; + let mut packs: Vec = entries.flatten().filter_map(|e| entry(&e.path())).collect(); + packs.sort_by(|a, b| { + (a.kind == Kind::Classic, a.title.to_lowercase()) + .cmp(&(b.kind == Kind::Classic, b.title.to_lowercase())) + }); + packs +} + +fn entry(path: &Path) -> Option { + let file = path.file_name()?.to_str()?.to_owned(); + if file.starts_with('.') { + return None; + } + if horizon_shader_api::package::is_pack(path) { + // Its manifest's name; a pack that can't be read is still listed, under its file + // name: picking it says why in the chat. + let manifest = if path.is_dir() { + std::fs::read_to_string(path.join(horizon_shader_api::MANIFEST)) + .ok() + .and_then(|t| horizon_shader_api::Manifest::parse(&t).ok()) + } else { + horizon_shader_api::Pack::read(path) + .ok() + .map(|p| p.manifest) + }; + let title = manifest.map_or_else(|| file.clone(), |m| m.name); + return Some(Entry { + file, + title, + kind: Kind::Horizon, + }); + } + let zip = path.is_file() + && path + .extension() + .is_some_and(|e| e.eq_ignore_ascii_case("zip")); + (zip || path.join("shaders").is_dir()).then(|| Entry { + title: file.clone(), + file, + kind: Kind::Classic, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lists_both_kinds_horizon_first_and_skips_the_rest() { + let dir = std::env::temp_dir().join(format!("horizon-shader-list-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + let d = dir.as_path(); + let manifest = "schema = 1\nid = \"warm\"\nname = \"Warm Light\"\nversion = \"1\"\n\ + api = \"0.1\"\n[[post]]\nfile = \"p.wgsl\"\n"; + std::fs::create_dir(d.join("warm")).unwrap(); + std::fs::write(d.join("warm").join(horizon_shader_api::MANIFEST), manifest).unwrap(); + std::fs::create_dir_all(d.join("Classic Folder/shaders")).unwrap(); + std::fs::write(d.join("archive.zip"), b"").unwrap(); + std::fs::write(d.join("notes.txt"), b"").unwrap(); + std::fs::create_dir(d.join("empty")).unwrap(); + std::fs::create_dir_all(d.join(".hidden/shaders")).unwrap(); + let packs = scan(d); + let listed: Vec<(&str, &str, Kind)> = packs + .iter() + .map(|e| (e.file.as_str(), e.title.as_str(), e.kind)) + .collect(); + assert_eq!( + listed, + [ + ("warm", "Warm Light", Kind::Horizon), + ("archive.zip", "archive.zip", Kind::Classic), + ("Classic Folder", "Classic Folder", Kind::Classic), + ] + ); + assert!(scan(&d.join("missing")).is_empty()); + std::fs::remove_dir_all(d).unwrap(); + } +} diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 103f7402b..643a604bc 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -639,8 +639,12 @@ impl Streaming { self.lit.remove(&(x, z)); self.meshed.remove(&(x, z)); self.lighting.remove(&(x, z)); - self.meshing.retain(|k, _| (k.0, k.2) != (x, z)); - self.waiting.retain(|k| (k.0, k.2) != (x, z)); + // By key, not by a pass over every pending section: a moved or + // shrunk storage forgets thousands of columns in one frame. + for sy in 0..SECTIONS as i32 { + self.meshing.remove(&(x, sy, z)); + self.waiting.remove(&(x, sy, z)); + } world.dirty_sections.take_column(x, z); world.chunks.remove(&(x, z)) } diff --git a/crates/horizon-client/src/terrain.wgsl b/crates/horizon-client/src/terrain.wgsl index c0a2fc6fd..711a2fce7 100644 --- a/crates/horizon-client/src/terrain.wgsl +++ b/crates/horizon-client/src/terrain.wgsl @@ -227,8 +227,9 @@ fn sunrise_weight(d: vec3) -> f32 { } return best; } -@fragment fn fs_sky(in: SkyOut) -> @location(0) vec4 { - let d = view_ray(in.ndc); +// The sky's colour along the view ray `d` (a shader pack's sky stage gets it as its input: +// gfx/native_sky.rs builds that stage from this section). +fn sky_along_ray(d: vec3) -> vec3 { var color = globals.fog_color.rgb; let dist = disc_distance(d, 16.0); if dist.x >= 0.0 { @@ -238,7 +239,10 @@ fn sunrise_weight(d: vec3) -> f32 { if w > 0.0 { color = mix(color, globals.sunrise.rgb, w * globals.sunrise.a); } - return vec4(color, 1.0); + return color; +} +@fragment fn fs_sky(in: SkyOut) -> @location(0) vec4 { + return vec4(sky_along_ray(view_ray(in.ndc)), 1.0); } @fragment fn fs_dark_disc(in: SkyOut) -> @location(0) vec4 { let d = view_ray(in.ndc); diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs index 3b2920ade..d73956d85 100644 --- a/crates/horizon-client/src/world.rs +++ b/crates/horizon-client/src/world.rs @@ -311,6 +311,40 @@ impl World { .get(&(x >> 4, z >> 4)) .map_or(self.air, |chunk| chunk.block(x & 15, y, z & 15)) } + /// Whether a block of the box `lo..=hi` may match, from the palettes of + /// the sections it reaches (a palette of the whole registry may hold + /// anything): `false` means [`Self::block`] matches in none of its cells, + /// so a scan over them can stop before reading one. + pub fn may_hold( + &self, + lo: [i32; 3], + hi: [i32; 3], + mut matches: impl FnMut(BlockStateId) -> bool, + ) -> bool { + let top = MIN_Y + SECTIONS as i32 * 16 - 1; + // Heights outside the sections read as state 0. + if (lo[1] < MIN_Y || hi[1] > top) && matches(BlockStateId(0)) { + return true; + } + let sections = (lo[1].max(MIN_Y) - MIN_Y) >> 4..=(hi[1].min(top) - MIN_Y) >> 4; + for cx in lo[0] >> 4..=hi[0] >> 4 { + for cz in lo[2] >> 4..=hi[2] >> 4 { + let Some(chunk) = self.chunks.get(&(cx, cz)) else { + if matches(self.air) { + return true; + } + continue; + }; + for s in sections.clone() { + let blocks = &chunk.sections[s as usize].blocks; + if blocks.is_global() || blocks.maybe_has(|v| matches(BlockStateId(v))) { + return true; + } + } + } + } + false + } /// The block entities to tick this tick, in order (`BlockEntities::tickers`). pub fn block_entity_tickers(&mut self) -> Vec<(crate::block_entities::Pos, u32)> { let (chunks, air) = (&self.chunks, self.air); @@ -333,3 +367,32 @@ impl World { self.chunks.contains_key(&(x >> 4, z >> 4)) } } + +#[cfg(test)] +mod tests { + use super::World; + use crate::chunk::Chunk; + use horizon_world::registry::BlockStateId; + use std::sync::Arc; + + /// A box misses a state only where no section it reaches lists it, and + /// unloaded columns or heights past the world count as their air. + #[test] + fn may_hold_reads_the_palettes_of_the_reached_sections() { + let mut world = World::new(BlockStateId(0), 0); + let mut chunk = Chunk::empty(0, 0); + chunk.set(3, 70, 3, 9); + world.chunks.insert((0, 0), Arc::new(chunk)); + let nine = |s: BlockStateId| s.0 == 9; + // The section of y 64..80 holds 9, the one below does not. + assert!(world.may_hold([0, 64, 0], [1, 65, 1], nine)); + assert!(world.may_hold([10, 79, 10], [12, 80, 12], nine)); + assert!(!world.may_hold([0, 50, 0], [15, 63, 15], nine)); + // A box over the unloaded column next door sees only air. + assert!(!world.may_hold([16, 70, 0], [17, 71, 1], nine)); + assert!(world.may_hold([16, 70, 0], [17, 71, 1], |s| s.0 == 0)); + // Past the top, and the palette of air below it. + assert!(!world.may_hold([0, 400, 0], [0, 401, 0], nine)); + assert!(world.may_hold([0, 400, 0], [0, 401, 0], |s| s.0 == 0)); + } +} diff --git a/crates/horizon-mod-registry/Cargo.lock b/crates/horizon-mod-registry/Cargo.lock index 44ef1e078..f80068fcc 100644 --- a/crates/horizon-mod-registry/Cargo.lock +++ b/crates/horizon-mod-registry/Cargo.lock @@ -17,12 +17,24 @@ dependencies = [ "derive_arbitrary", ] +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + [[package]] name = "atomic-waker" version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + [[package]] name = "axum" version = "0.8.9" @@ -80,6 +92,27 @@ version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + [[package]] name = "block-buffer" version = "0.10.4" @@ -95,6 +128,26 @@ version = "3.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + [[package]] name = "bytes" version = "1.12.1" @@ -117,6 +170,21 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "unicode-width", +] + [[package]] name = "core_detect" version = "1.0.0" @@ -147,6 +215,12 @@ version = "0.8.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + [[package]] name = "crypto-common" version = "0.1.7" @@ -165,7 +239,7 @@ checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -187,7 +261,7 @@ checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -236,6 +310,12 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + [[package]] name = "form_urlencoded" version = "1.2.2" @@ -302,11 +382,28 @@ dependencies = [ "wasip2", ] +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + [[package]] name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash", + "serde", + "serde_core", +] [[package]] name = "hmac" @@ -340,12 +437,27 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2", "toml", + "wasmparser", + "zip", +] + +[[package]] +name = "horizon-shader-api" +version = "0.1.0" +dependencies = [ + "bytemuck", + "naga", + "serde", + "serde_json", + "sha2", + "toml", "zip", ] @@ -540,6 +652,8 @@ checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", "hashbrown", + "serde", + "serde_core", ] [[package]] @@ -554,6 +668,12 @@ version = "0.2.191" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + [[package]] name = "litemap" version = "0.8.3" @@ -634,6 +754,54 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d" +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "rustc-hash", + "spirv", + "thiserror", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown", + "indexmap", + "rustc-hash", + "thiserror", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -699,6 +867,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + [[package]] name = "rustls" version = "0.23.46" @@ -752,6 +926,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + [[package]] name = "serde" version = "1.0.229" @@ -779,7 +959,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -894,6 +1074,15 @@ version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e" +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -906,6 +1095,17 @@ version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "syn" version = "3.0.9" @@ -931,7 +1131,27 @@ checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", ] [[package]] @@ -968,7 +1188,7 @@ checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -1049,6 +1269,12 @@ version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + [[package]] name = "untrusted" version = "0.9.0" @@ -1111,6 +1337,19 @@ dependencies = [ "wit-bindgen", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", + "serde", +] + [[package]] name = "webpki-roots" version = "0.26.11" @@ -1254,10 +1493,30 @@ checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", "synstructure", ] +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "zerofrom" version = "0.1.8" @@ -1275,7 +1534,7 @@ checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", "synstructure", ] @@ -1315,7 +1574,7 @@ checksum = "c3743ddbf47738d929cd1ae2e199d40d0162979dfe31aef8ae646d2bf00bf97a" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] diff --git a/crates/horizon-mod-registry/tests/submit.rs b/crates/horizon-mod-registry/tests/submit.rs index f586effac..f27f18697 100644 --- a/crates/horizon-mod-registry/tests/submit.rs +++ b/crates/horizon-mod-registry/tests/submit.rs @@ -342,11 +342,12 @@ async fn what_the_form_refuses() { ); let (status, json) = client.submit(&csrf, &f, &file).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); - // Shader packs aren't open. + // A shader pack runs the game's own check: a mod's file isn't one. let mut f = form(); f["kind"] = json!("shader"); let (status, json) = client.submit(&csrf, &f, &file).await; - refused(status, &json, "shader packs open"); + assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); + refused(status, &json, "horizon-shaders.toml: missing"); // An update by someone who isn't an owner. let owned = "id = \"coords_hud\"\nkind = \"mod\"\nname = \"C\"\nsummary = \"s\"\nowners = [\"bob\"]\nlicense = \"MIT\"\nsource = \"https://x.test\"\n\n[[versions]]\nversion = \"0.0.1\"\npublished = \"2026-01-01\"\ngame = \"26.3\"\nfile = \"coords_hud-0.0.1.hmod\"\nsha256 = \"0000000000000000000000000000000000000000000000000000000000000000\"\n"; mock.lock() diff --git a/crates/horizon-mod-sdk/examples/coords-hud/tests/panel.toml b/crates/horizon-mod-sdk/examples/coords-hud/tests/panel.toml new file mode 100644 index 000000000..eed41a461 --- /dev/null +++ b/crates/horizon-mod-sdk/examples/coords-hud/tests/panel.toml @@ -0,0 +1,36 @@ +# The panel follows the player and the clock; /coords hides and shows it. + +[player] +x = 12.5 +z = -3.25 +yaw = 180.0 + +[clock] +day-time = 29999 + +[[step]] +ticks = 1 +expect.panel = ["XYZ 12.5 / 64.0 / -3.2", "Facing North (-Z)", "Day 2, 12:00"] +expect.corner = "top-left" + +[[step]] +player = { x = -100.0, yaw = 90.0 } +ticks = 1 +expect.panel = ["XYZ -100.0 / 64.0 / -3.2", "Facing West (-X)", "Day 2, 12:00"] + +[[step]] +command = "coords" +expect.feedback = "Coordinates panel hidden" + +# A step's ticks come before its command: the panel goes at the next tick. +[[step]] +ticks = 1 +expect.panel = [] + +[[step]] +command = "coords" +expect.feedback = "Coordinates panel shown" + +[[step]] +ticks = 1 +expect.panel = ["XYZ -100.0 / 64.0 / -3.2", "Facing West (-X)", "Day 2, 12:00"] diff --git a/crates/horizon-mod-sdk/examples/coords-hud/tests/where.toml b/crates/horizon-mod-sdk/examples/coords-hud/tests/where.toml new file mode 100644 index 000000000..99a4aecdf --- /dev/null +++ b/crates/horizon-mod-sdk/examples/coords-hud/tests/where.toml @@ -0,0 +1,17 @@ +# /where puts the position in chat; on the title screen it answers with an error. + +[player] +x = 12.5 +y = 70.2 +z = -3.25 +dimension = "minecraft:the_nether" + +[[step]] +command = "where" +expect.chat = ["12, 70, -4 in minecraft:the_nether"] + +[[step]] +title-screen = true +command = "where" +expect.chat = [] +expect.error = "Not in a world" diff --git a/crates/horizon-mod-sdk/examples/welcome/Cargo.toml b/crates/horizon-mod-sdk/examples/welcome/Cargo.toml new file mode 100644 index 000000000..50ab1a10a --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "welcome" +version = "0.1.0" +edition.workspace = true +license.workspace = true +publish = false +description = "Example Horizon server mod: greets players, announces newcomers, /online and /mined" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +horizon-mod-sdk = { path = "../.." } + +[lints] +workspace = true diff --git a/crates/horizon-mod-sdk/examples/welcome/horizon-mod.toml b/crates/horizon-mod-sdk/examples/welcome/horizon-mod.toml new file mode 100644 index 000000000..f8e73c482 --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/horizon-mod.toml @@ -0,0 +1,8 @@ +id = "welcome" +name = "Welcome" +version = "0.1.0" +description = "Greets each player who joins, announces a newcomer to everyone, /online lists who is on, /mined counts the blocks you broke." +authors = ["Horizon"] +api = "0.3" +side = "server" +capabilities = ["players", "storage"] diff --git a/crates/horizon-mod-sdk/examples/welcome/src/lib.rs b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs new file mode 100644 index 000000000..c45712c88 --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs @@ -0,0 +1,84 @@ +//! Example Horizon server mod (`docs/mods.md`, "Server mods"): greets each +//! player who joins, announces a newcomer to everyone (the players it has +//! seen are kept in `storage`), `/online` lists who is on and where, and +//! `/mined` counts the blocks the player broke since the server started. +use horizon_mod_sdk::{ + server::{BlockPos, Player, Registration, ServerMod, players}, + storage, +}; +use std::collections::HashMap; + +struct Welcome { + /// Ids of every player seen, one per line in storage key `seen`. + seen: Vec, + mined: HashMap, +} + +impl ServerMod for Welcome { + fn init() -> Result<(Self, Registration), String> { + let seen = storage::get("seen") + .map(|b| { + String::from_utf8_lossy(&b) + .lines() + .map(str::to_owned) + .collect() + }) + .unwrap_or_default(); + let hooks = Registration::new() + .command("online") + .command("mined") + .on_joins() + .on_blocks(); + Ok(( + Welcome { + seen, + mined: HashMap::new(), + }, + hooks, + )) + } + + fn player_joined(&mut self, player: &Player) { + let others = players::online().len() - 1; + players::tell( + &player.id, + &format!("Welcome, {}! {others} other player(s) online.", player.name), + ); + if !self.seen.contains(&player.id) { + self.seen.push(player.id.clone()); + let _ = storage::set("seen", self.seen.join("\n").as_bytes()); + players::broadcast(&format!("{} is here for the first time", player.name)); + } + } + + fn command( + &mut self, + player: &Player, + name: &str, + _args: &str, + ) -> Result, String> { + Ok(Some(match name { + "online" => players::online() + .iter() + .map(|p| { + format!( + "{} ({})", + p.name, + p.dimension.trim_start_matches("minecraft:") + ) + }) + .collect::>() + .join(", "), + _ => { + let n = self.mined.get(&player.id).copied().unwrap_or(0); + format!("You broke {n} block(s)") + } + })) + } + + fn block_broken(&mut self, player: &Player, _pos: BlockPos, _state: &str) { + *self.mined.entry(player.id.clone()).or_default() += 1; + } +} + +horizon_mod_sdk::export_server_mod!(Welcome); diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml new file mode 100644 index 000000000..5f0018346 --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml @@ -0,0 +1,31 @@ +# /online lists the players and their dimension; /mined counts the acting player's blocks. + +[[step]] +join = "Alex" +expect.commands = ["online", "mined"] + +[[step]] +join = "Steve" +as = "Steve" +player = { dimension = "minecraft:the_nether" } +command = "online" +expect.feedback = "Alex (overworld), Steve (the_nether)" + +[[step]] +as = "Alex" +break = { x = 1, y = 63, z = 0, state = "minecraft:stone" } + +[[step]] +as = "Alex" +break = { x = 2, y = 63, z = 0, state = "minecraft:dirt" } + +# A step's command comes before its break and place. +[[step]] +as = "Alex" +command = "mined" +expect.feedback = "You broke 2 block(s)" + +[[step]] +as = "Steve" +command = "mined" +expect.feedback = "You broke 0 block(s)" diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml b/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml new file mode 100644 index 000000000..c8a1836db --- /dev/null +++ b/crates/horizon-mod-sdk/examples/welcome/tests/welcome.toml @@ -0,0 +1,21 @@ +# Joins are greeted; a newcomer is announced once, even after a reload (storage). + +[[step]] +join = "Alex" +expect.told = ["Alex: Welcome, Alex! 0 other player(s) online."] +expect.broadcast = ["Alex is here for the first time"] + +[[step]] +join = "Steve" +expect.told = ["Steve: Welcome, Steve! 1 other player(s) online."] +expect.broadcast = ["Steve is here for the first time"] + +[[step]] +leave = "Alex" +expect.told = [] + +[[step]] +reload = true +join = "Alex" +expect.told = ["Alex: Welcome, Alex! 1 other player(s) online."] +expect.broadcast = [] diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs index 734fffb89..679fdc7b8 100644 --- a/crates/horizon-mod-sdk/src/lib.rs +++ b/crates/horizon-mod-sdk/src/lib.rs @@ -21,7 +21,8 @@ //! ``` //! //! Every interface but `log` is a capability: list the ones the mod uses in -//! `horizon-mod.toml` (`game-read`, `chat`, `hud`, `storage`, `command`, `ui`). +//! `horizon-mod.toml` (`game-read`, `chat`, `hud`, `storage`, `command`, `ui`; +//! a server mod `storage` and `players`). Server mods: [`server`]. //! //! Widgets (capability `ui`): a mod shows a screen it owns with //! [`ui::open_screen`] and a page in Options > Mods with @@ -173,3 +174,152 @@ macro_rules! export_mod { }; }; } + +/// Server mods (manifest `side = "server"`, `api = "0.3"`, experimental): a +/// type implementing [`ServerMod`](server::ServerMod), exported with +/// [`export_server_mod!`]. It runs where the world is simulated, and reads +/// and messages the players with capability `players`. +pub mod server { + wit_bindgen::generate!({ + path: "wit", + world: "horizon-server-mod", + pub_export_macro: true, + export_macro_name: "__export_horizon_server_mod", + default_bindings_module: "horizon_mod_sdk::server", + with: { + "horizon:mods/log@0.1.0": crate::log, + "horizon:mods/storage@0.1.0": crate::storage, + }, + }); + + pub use exports::horizon::mods::server_events::{BlockPos, Guest as __Guest, Registration}; + pub use horizon::mods::players::{self, GameMode, Player}; + + /// The server's calls into a mod. Only the hooks [`Registration`] asks + /// for are called; the others may stay as their defaults. + pub trait ServerMod: Sized + 'static { + /// Once, after loading: the mod's state and the hooks it wants. An + /// error keeps the mod off and is logged. + fn init() -> Result<(Self, Registration), String>; + /// Every server tick, when [`Registration::tick`] is set. + fn tick(&mut self, _tick: u64) {} + /// When [`Registration::joins`] is set. + fn player_joined(&mut self, _player: &Player) {} + fn player_left(&mut self, _player: &Player) {} + /// A chat message a player sent, when [`Registration::chat`] is set. + fn chat(&mut self, _player: &Player, _text: &str) {} + /// `/name args` typed by `player`. `Ok(Some(text))` is their + /// feedback, `Err(text)` their error in red. + fn command( + &mut self, + _player: &Player, + _name: &str, + _args: &str, + ) -> Result, String> { + Err("This command does nothing".into()) + } + /// When [`Registration::blocks`] is set: `state` is what was there. + fn block_broken(&mut self, _player: &Player, _pos: BlockPos, _state: &str) {} + fn block_placed(&mut self, _player: &Player, _pos: BlockPos, _state: &str) {} + } + + impl Registration { + /// No commands and no hooks. + pub fn new() -> Self { + Self { + commands: Vec::new(), + tick: false, + joins: false, + chat: false, + blocks: false, + } + } + /// Adds `/name`. + pub fn command(mut self, name: &str) -> Self { + self.commands.push(name.into()); + self + } + pub fn on_tick(mut self) -> Self { + self.tick = true; + self + } + pub fn on_joins(mut self) -> Self { + self.joins = true; + self + } + pub fn on_chat(mut self) -> Self { + self.chat = true; + self + } + pub fn on_blocks(mut self) -> Self { + self.blocks = true; + self + } + } + impl Default for Registration { + fn default() -> Self { + Self::new() + } + } +} + +/// Exports a [`ServerMod`](server::ServerMod) as the component's +/// `server-events` interface, as [`export_mod!`] does for a client mod. +#[macro_export] +macro_rules! export_server_mod { + ($t:ty) => { + const _: () = { + use ::std::cell::RefCell; + use $crate::server::{BlockPos, Player, Registration, ServerMod}; + ::std::thread_local! { + static STATE: RefCell> = const { RefCell::new(None) }; + } + fn with(f: impl FnOnce(&mut $t)) { + STATE.with(|s| { + if let Some(m) = s.borrow_mut().as_mut() { + f(m) + } + }) + } + struct Export; + impl $crate::server::__Guest for Export { + fn init() -> Result { + let (m, registration) = <$t as ServerMod>::init()?; + STATE.with(|s| *s.borrow_mut() = Some(m)); + Ok(registration) + } + fn tick(tick: u64) { + with(|m| m.tick(tick)) + } + fn player_joined(player: Player) { + with(|m| m.player_joined(&player)) + } + fn player_left(player: Player) { + with(|m| m.player_left(&player)) + } + fn chat(player: Player, text: String) { + with(|m| m.chat(&player, &text)) + } + fn command( + player: Player, + name: String, + args: String, + ) -> Result, String> { + let mut out = Err("The mod is not running".to_string()); + with(|m| out = m.command(&player, &name, &args)); + out + } + fn block_broken(player: Player, pos: BlockPos, state: String) { + with(|m| m.block_broken(&player, pos, &state)) + } + fn block_placed(player: Player, pos: BlockPos, state: String) { + with(|m| m.block_placed(&player, pos, &state)) + } + } + #[cfg(target_arch = "wasm32")] + $crate::server::__export_horizon_server_mod!(Export); + #[cfg(not(target_arch = "wasm32"))] + let _ = ::init; + }; + }; +} diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 820a82483..84be4d4f0 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -220,7 +220,9 @@ interface input { claim-items: func(ids: list); /// A key of the mod's: `name` comes back in `key-down` and `key-up`, /// `label` says what it does, `key` is the key as options.txt writes - /// it (`key.keyboard.r`). At most 16; an unknown key is an error. + /// it (`key.keyboard.r`), the default: the player can bind another + /// one on the mod's page in Options > Mods, and that one wins. At most + /// 16; an unknown key is an error. register-key: func(name: string, label: string, key: string) -> result<_, string>; /// The main hand's stack, as of this tick; none when it is empty. held: func() -> option; @@ -362,6 +364,27 @@ interface render { /// wins) leave the camera vanilla's. With several mods, the strongest /// zoom counts. set-zoom: func(zoom: zoom); + record minimap { + corner: corner, + /// Its side in GUI pixels, 16 to 256. + size: f32, + /// World blocks per map pixel, 0.5 to 4; the map is 128 × 128 pixels. + blocks-per-pixel: f32, + /// The map turns with the player, who faces up, and an N on its rim + /// marks north. Otherwise north is up and the player's arrow turns. + rotate: bool, + /// Round, the corners left clear; otherwise square. + round: bool, + } + /// Shows a map of the world around the player in `corner`, stacked with + /// the game's overlays and the mods' panels, until the next call (none + /// hides it). It looks like a map item: vanilla's map colours with their + /// height shading and water depth, and the player's arrow. Underground, + /// under a roof and in the Nether it maps the floor around the player's + /// height. The game keeps the map's tiles and refreshes them within its + /// own frame budget; hidden, they are dropped. One map shows at a time: + /// the first loaded mod's. + set-minimap: func(minimap: option); } /// What the game calls. Only the hooks `init` asks for are ever called. @@ -389,6 +412,84 @@ interface events { chat: func(text: string); } +/// Capability `players`, server mods only (manifest `api = "0.3"`, +/// experimental): the players on the server, and messages to them. +interface players { + enum game-mode { + survival, + creative, + adventure, + spectator, + } + record player { + /// The player's UUID, `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`. + id: string, + name: string, + /// Feet position, in blocks. + x: f64, + y: f64, + z: f64, + /// `minecraft:overworld`, `minecraft:the_nether`, ... + dimension: string, + game-mode: game-mode, + /// Hit points as vanilla counts them: 20 is full health without effects. + health: f32, + } + /// The players online, in the order they joined. + online: func() -> list; + /// A system message to one player, after the mod's name; false when no + /// player with that id is online. Up to 8 messages per call. + tell: func(player: string, text: string) -> bool; + /// A system message to every player and the server's log, after the + /// mod's name. Counts toward the same 8 per call. + broadcast: func(text: string); +} + +/// What the server calls in a server mod (manifest `api = "0.3"`, +/// experimental). Only the hooks `init` asks for are ever called. The player +/// in each event is as the server saw them when it happened. +interface server-events { + use players.{player}; + + record registration { + /// Commands players may type, without the slash. A name vanilla + /// already uses is refused (vanilla's command runs). + commands: list, + /// Call `tick` every server tick (20 per second). + tick: bool, + /// Call `player-joined` and `player-left`. + joins: bool, + /// Call `chat` for each chat message a player sends. + chat: bool, + /// Call `block-broken` and `block-placed`. + blocks: bool, + } + record block-pos { + x: s32, + y: s32, + z: s32, + } + /// Once, after loading. An error keeps the mod off and is logged. + init: func() -> result; + /// Each server tick, with the server's tick counter. + tick: func(tick: u64); + /// A player joined the server; they are in `players.online` already. + player-joined: func(player: player); + /// A player left the server; they are no longer in `players.online`. + player-left: func(player: player); + /// A chat message a player sent, as plain text. + chat: func(player: player, text: string); + /// `/name args` typed by `player`: ok(some(text)) is their feedback, + /// err(text) their error in red. + command: func(player: player, name: string, args: string) -> result, string>; + /// A player broke the block at `pos` in their dimension: `state` is what + /// was there, as `minecraft:oak_log[axis=y]`. + block-broken: func(player: player, pos: block-pos, state: string); + /// A player placed `state` at `pos` in their dimension. + block-placed: func(player: player, pos: block-pos, state: string); +} + +/// A client mod: runs in the player's game. world horizon-mod { import log; import game; @@ -399,6 +500,16 @@ world horizon-mod { export events; } +/// A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): +/// runs where the world is simulated, on the dedicated server, a LAN host +/// and single player's own server. +world horizon-server-mod { + import log; + import storage; + import players; + export server-events; +} + /// A mod with widgets (capability `ui`): the SDK builds every mod against /// this world. Mods built for `horizon-mod` alone (no `ui-events` export) /// still load and simply hear nothing of their widgets. diff --git a/crates/horizon-mods/Cargo.toml b/crates/horizon-mods/Cargo.toml index a398e4d8b..8bfa58bcd 100644 --- a/crates/horizon-mods/Cargo.toml +++ b/crates/horizon-mods/Cargo.toml @@ -17,18 +17,27 @@ wasmtime = { version = "48.0.7", default-features = false, features = ["runtime" # Turns a mod's core module into a component (cargo horizon-mod build, the tests). wit-component = { version = "0.254", optional = true } wit-parser = { version = "0.254", optional = true } +# The functions a mod imports, for its API level (src/api_level.rs): the game and the registry index. +wasmparser = { version = "0.254", optional = true } # The registry index's checks (feature `index`): SHA-256, and minisign signatures (no dependencies of its own). sha2 = { version = "0.10", optional = true } minisign-verify = { version = "0.3", optional = true } +# A shader pack's check (kind `shader`): the one the game runs before it loads a pack. +horizon-shader-api = { path = "../horizon-shader-api", optional = true } + +[dev-dependencies] +# A component made for a newer Horizon, from the WIT alone (tests/sandbox.rs). +wit-component = { version = "0.254", features = ["dummy-module"] } +wit-parser = "0.254" [features] # Loads and runs mods (the game's `mods` feature); without it only manifests, # content and packaging. Off by default so builds that don't run mods (the # game's tests and probes) skip wasmtime and cranelift. -runtime = ["dep:wasmtime"] +runtime = ["dep:wasmtime", "dep:wasmparser"] pack = ["dep:wit-component", "dep:wit-parser"] # The mod registry's index (docs/api/mod-index.md): the launcher, the registry server and its CI. -index = ["dep:sha2", "dep:minisign-verify"] +index = ["dep:sha2", "dep:minisign-verify", "dep:horizon-shader-api", "dep:wasmparser"] # Runs real mods: `cargo test -p horizon-mods --features runtime,pack`. [[test]] diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs new file mode 100644 index 000000000..9f00dc4a1 --- /dev/null +++ b/crates/horizon-mods/src/api_level.rs @@ -0,0 +1,189 @@ +//! Mod API levels: which of the WIT contract's functions a Horizon has +//! (`docs/api/stability.md`). Every function the game offers mods has the +//! level it arrived at; a Horizon serves every level up to its [`LEVEL`]. +//! A mod needs the level of the newest function it imports, so a mod that +//! calls a function this Horizon doesn't have is refused with "update +//! Horizon" instead of a linking error, and the registry lists each +//! version's level so the launcher can tell before it installs. + +/// The newest level this Horizon serves. +pub const LEVEL: u32 = 1; + +/// Every function the game offers mods, as `interface.function`, with its +/// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new +/// function takes the next level and raises [`LEVEL`] (the `api_reference` +/// test fails until it is listed here). +pub const FUNCTIONS: [(&str, u32); 32] = [ + ("log.write", 0), + ("game.get-player", 0), + ("game.get-clock", 0), + ("chat.show", 0), + ("hud.set-panel", 0), + ("hud.clear", 0), + ("storage.get", 0), + ("storage.set", 0), + ("storage.delete", 0), + ("command.run", 0), + ("ui.open-screen", 0), + ("ui.close-screen", 0), + ("ui.set-settings", 0), + ("input.claim-items", 0), + ("input.register-key", 0), + ("input.held", 0), + ("input.poll", 0), + ("input.claim-wheel", 0), + ("input.mapping", 0), + ("input.clicks-per-second", 0), + ("render.set-hud", 0), + ("render.gui-size", 0), + ("render.shake", 0), + ("render.set-corner", 0), + ("render.clear-corner", 0), + ("render.text-width", 0), + ("render.frame-stats", 0), + ("render.set-zoom", 0), + ("render.set-minimap", 1), + ("players.online", 1), + ("players.tell", 1), + ("players.broadcast", 1), +]; + +/// What the game's program carries so the launcher can read its level +/// without running it: `horizon-mod-api-level:0001;` (four digits). A +/// program from before the mark serves level 0. +pub const MARK: [u8; 27] = { + let mut mark = *b"horizon-mod-api-level:0000;"; + let mut level = LEVEL; + let mut i = 25; + while level > 0 { + mark[i] = b'0' + (level % 10) as u8; + level /= 10; + i -= 1; + } + mark +}; + +/// The level a program's bytes carry in their [`MARK`], if any. +pub fn read_mark(program: &[u8]) -> Option { + let prefix = &MARK[..22]; + program + .windows(MARK.len()) + .filter(|w| w.starts_with(prefix) && w[26] == b';') + .find_map(|w| std::str::from_utf8(&w[22..26]).ok()?.parse().ok()) +} + +/// A function's level; None for one this Horizon doesn't have. +pub fn level_of(function: &str) -> Option { + FUNCTIONS + .iter() + .find(|(name, _)| *name == function) + .map(|&(_, level)| level) +} + +/// The level a mod needs, from the functions it imports (as [`imports`] +/// names them): its newest function's. A function this Horizon doesn't +/// know comes from a newer one, so it needs more than [`LEVEL`]; that +/// function is returned with it, for the message. +pub fn needed<'a>(imports: impl IntoIterator) -> (u32, Option<&'a str>) { + let mut needed = (0, None); + for name in imports { + match level_of(name) { + Some(level) if level > needed.0 => needed = (level, Some(name)), + Some(_) => {} + None => return (LEVEL + 1, Some(name)), + } + } + needed +} + +/// Why this Horizon can't run a mod that needs `level`, or None when it can. +pub fn too_new(level: u32, function: Option<&str>) -> Option { + (level > LEVEL).then(|| { + let uses = function.map_or(String::new(), |f| format!(" (it uses {f})")); + format!("made for a newer Horizon{uses}: update Horizon to run it") + }) +} + +/// The functions a mod's component imports from Horizon (`horizon:mods/*`), +/// as `interface.function`, in the component's order. +#[cfg(any(feature = "runtime", feature = "index"))] +pub fn imports(wasm: &[u8]) -> Result, String> { + use wasmparser::{ + Parser, Payload, Validator, WasmFeatures, component_types::ComponentEntityType, + }; + let types = Validator::new_with_features(WasmFeatures::all()) + .validate_all(wasm) + .map_err(|e| format!("not a component: {e}"))?; + let types = types.as_ref(); + let mut out = Vec::new(); + for payload in Parser::new(0).parse_all(wasm) { + let Payload::ComponentImportSection(section) = payload.map_err(|e| e.to_string())? else { + continue; + }; + for import in section { + let name = import.map_err(|e| e.to_string())?.name.name; + // `horizon:mods/render@0.1.0` → `render`. + let Some(interface) = name.strip_prefix("horizon:mods/") else { + continue; + }; + let interface = interface.split('@').next().unwrap_or(interface); + let Some(item) = types.component_item_for_import(name) else { + continue; + }; + if let ComponentEntityType::Instance(id) = item.ty { + for (function, export) in &types[id].exports { + if matches!(export.ty, ComponentEntityType::Func(_)) { + out.push(format!("{interface}.{function}")); + } + } + } + } + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn levels_are_listed_once_and_up_to_this_horizons() { + for (i, (name, level)) in FUNCTIONS.iter().enumerate() { + assert!(*level <= LEVEL, "{name}"); + assert!( + FUNCTIONS[..i].iter().all(|(other, _)| other != name), + "{name} twice" + ); + } + assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL)); + } + + #[test] + fn the_mark_carries_the_level() { + assert_eq!(read_mark(&MARK), Some(LEVEL)); + let mut program = b"\0\x7fELF horizon-mod-api-level: horizon-mod-api-level:".to_vec(); + program.extend_from_slice(&MARK); + program.extend_from_slice(b"\0rest"); + assert_eq!(read_mark(&program), Some(LEVEL)); + assert_eq!(read_mark(b"horizon-mod-api-level:12;"), None); + assert_eq!(read_mark(b"no mark"), None); + } + + #[test] + fn a_mod_needs_its_newest_function() { + assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None)); + assert_eq!( + needed(["log.write", "render.set-minimap", "hud.clear"]), + (1, Some("render.set-minimap")) + ); + assert_eq!( + needed(["render.set-minimap", "render.set-sky"]), + (LEVEL + 1, Some("render.set-sky")) + ); + assert_eq!(too_new(LEVEL, None), None); + assert_eq!( + too_new(LEVEL + 1, Some("render.set-sky")).as_deref(), + Some("made for a newer Horizon (it uses render.set-sky): update Horizon to run it") + ); + } +} diff --git a/crates/horizon-mods/src/index.rs b/crates/horizon-mods/src/index.rs index db860fd9f..544c52980 100644 --- a/crates/horizon-mods/src/index.rs +++ b/crates/horizon-mods/src/index.rs @@ -47,8 +47,8 @@ pub enum Kind { Modpack, /// A resource pack (`.zip` with `pack.mcmeta`) made or tested for Horizon. ResourcePack, - /// A Horizon shader pack (the native WGSL format, not Iris or OptiFine - /// packs). Listed by the schema; submissions open with its API. + /// A Horizon shader pack (`.hshader`, the native WGSL format of + /// docs/shaders.md; not the shaders/-folder packs, which stay on Modrinth). Shader, Other(String), } @@ -69,7 +69,8 @@ impl Kind { match self { Kind::Mod => Some("hmod"), Kind::Modpack => Some("hpack"), - Kind::ResourcePack | Kind::Shader => Some("zip"), + Kind::ResourcePack => Some("zip"), + Kind::Shader => Some(horizon_shader_api::EXTENSION), Kind::Other(_) => None, } } @@ -137,6 +138,11 @@ pub struct Version { pub side: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub capabilities: Vec, + /// The mod API level a mod's code needs ([`crate::api_level`]), read + /// from its file; none for content and other kinds, and in indexes + /// built before levels. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub api_level: Option, /// The Minecraft version it is for. pub game: String, /// A modpack's mods, as its manifest lists them. @@ -316,6 +322,21 @@ impl Index { Ok(()) } + /// A project's newest version for Minecraft `game` that wasn't taken + /// down and that a Horizon serving mod API `level` can run (an unknown + /// level counts as runnable: the game still checks when it starts it). + pub fn installable<'a>( + &self, + project: &'a Project, + game: &str, + level: u32, + ) -> Option<&'a Version> { + project.versions.iter().find(|v| { + v.game == game + && v.api_level.is_none_or(|l| l <= level) + && self.revoked(&project.id, &v.file.sha256).is_none() + }) + } pub fn project(&self, id: &str) -> Option<&Project> { self.projects.iter().find(|p| p.id == id) } @@ -448,7 +469,7 @@ pub fn check_file( (None, None) => Trust::Unsigned, _ => return Err("its signature and the project's key don't go together".into()), }; - if matches!(project.kind, Kind::Shader | Kind::Other(_)) { + if matches!(project.kind, Kind::Other(_)) { return Err(format!( "this Horizon can't install a {} yet", project.kind.name() @@ -471,6 +492,8 @@ pub struct Facts { pub side: Option, /// In the manifest's order. pub capabilities: Vec, + /// The mod API level a mod's code needs, from the functions it imports. + pub api_level: Option, /// The Minecraft version, when the file names one (a modpack does). pub game: Option, pub requires: Vec, @@ -487,6 +510,7 @@ impl Facts { || self.api != version.api || self.side != version.side || caps != listed + || version.api_level.is_some() && self.api_level != version.api_level || self.game.as_ref().is_some_and(|g| *g != version.game) || self.requires != version.requires; if !differs { @@ -502,6 +526,13 @@ impl Facts { names(&self.capabilities) ), Kind::Modpack => format!("its {} isn't what the index lists", modpack::MANIFEST), + Kind::Shader => format!( + "its {} ({} {}, shader API {}) isn't what the index lists", + horizon_shader_api::MANIFEST, + self.id.as_deref().unwrap_or("?"), + self.version.as_deref().unwrap_or("?"), + self.api + ), _ => format!("its pack format {} isn't what the index lists", self.api), }) } @@ -509,14 +540,22 @@ impl Facts { /// Reads and checks a file as its kind: a mod's manifest and content, a /// modpack's manifest and overrides, a resource pack's `pack.mcmeta` and -/// paths. Shader packs and kinds this build doesn't know are refused: their -/// checks come with their formats. +/// paths, a shader pack's `horizon_shader_api::check` (the game's own). Kinds +/// this build doesn't know are refused: their checks come with their formats. pub fn inspect(kind: &Kind, path: &Path) -> Result { match kind { Kind::Mod => { - let m = Package::read(path)?.manifest; + let Package { manifest: m, wasm } = Package::read(path)?; crate::Content::read(path, &m)?; + let api_level = match wasm { + Some(wasm) => { + let functions = crate::api_level::imports(&wasm)?; + Some(crate::api_level::needed(functions.iter().map(String::as_str)).0) + } + None => None, + }; Ok(Facts { + api_level, capabilities: m.capabilities, id: Some(m.id), version: Some(m.version), @@ -540,9 +579,23 @@ pub fn inspect(kind: &Kind, path: &Path) -> Result { api: check_resource_pack(path)?, ..Facts::default() }), - Kind::Shader => Err( - "Horizon's own shader pack format isn't out yet: shader packs open when it is".into(), - ), + Kind::Shader => { + let pack = horizon_shader_api::Pack::read(path)?; + if let Err(problems) = horizon_shader_api::check(&pack) { + let lines: Vec = problems.iter().map(ToString::to_string).collect(); + return Err(format!( + "the shader pack fails its check:\n{}", + lines.join("\n") + )); + } + let m = pack.manifest; + Ok(Facts { + id: Some(m.id), + version: Some(m.version), + api: m.api, + ..Facts::default() + }) + } Kind::Other(name) => Err(format!("this Horizon can't read a {name} yet")), } } @@ -591,14 +644,11 @@ fn check_resource_pack(path: &Path) -> Result { Ok(format) } -/// The kinds the registry takes submissions for. Shader packs wait for -/// Horizon's own format; other kinds for theirs. +/// The kinds the registry takes submissions for; other kinds wait for their +/// formats. pub fn open(kind: &Kind) -> Result<(), String> { match kind { - Kind::Mod | Kind::Modpack | Kind::ResourcePack => Ok(()), - Kind::Shader => Err( - "shader packs open when Horizon's own shader pack format is out (Iris and OptiFine packs stay on Modrinth)".into(), - ), + Kind::Mod | Kind::Modpack | Kind::ResourcePack | Kind::Shader => Ok(()), Kind::Other(name) => Err(format!("the registry doesn't take {name} yet")), } } diff --git a/crates/horizon-mods/src/index/registry.rs b/crates/horizon-mods/src/index/registry.rs index 21b5de9fb..90453c621 100644 --- a/crates/horizon-mods/src/index/registry.rs +++ b/crates/horizon-mods/src/index/registry.rs @@ -283,6 +283,7 @@ fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/index") @@ -61,6 +62,23 @@ file = "cozy-1.0.0.hpack" sha256 = "241ac840f9c5ea3f6252d849da10c90d36cb1da4d6cd8d1d268c2760a353cd65" "#; +const GLOW: &str = r#"id = "glow" +kind = "shader" +name = "Soft Glow" +summary = "A post-processing pass over the world." +authors = ["Horizon"] +owners = ["ludovic111"] +license = "MIT" +source = "https://github.com/ludovic111/horizon-mods" + +[[versions]] +version = "1.0.0" +published = "2026-10-26" +game = "26.3" +file = "glow-1.0.0.hshader" +sha256 = "331cfe29a666a0de804e9a9ff3d19d246eebcfbfa70b4f49bba8482d30ad9f02" +"#; + const REVOKED_TOML: &str = r#"[[revoked]] id = "bad_mod" sha256 = "1111111111111111111111111111111111111111111111111111111111111111" @@ -82,9 +100,14 @@ impl Scratch { let s = Scratch(dir); s.write("mods/coords_hud.toml", &hud_entry()); s.write("mods/cozy.toml", COZY); + s.write("mods/glow.toml", GLOW); s.write("revoked.toml", REVOKED_TOML); s.write("icons/coords_hud.png", "png"); - for (name, hash) in [("coords_hud-0.1.0.hmod", HMOD), ("cozy-1.0.0.hpack", HPACK)] { + for (name, hash) in [ + ("coords_hud-0.1.0.hmod", HMOD), + ("cozy-1.0.0.hpack", HPACK), + ("glow-1.0.0.hshader", HSHADER), + ] { std::fs::copy(fixtures().join(name), s.0.join("files").join(hash)).unwrap(); } s @@ -117,7 +140,7 @@ fn builds_the_sample_index() { let s = Scratch::new("sample"); let built = s.build().unwrap(); let sample = sample(); - assert_eq!(built.projects, sample.projects[..2]); + assert_eq!(built.projects, sample.projects[..3]); assert_eq!(built.revoked, sample.revoked); assert_eq!(built.generated, sample.generated); // What it writes reads back. @@ -154,7 +177,11 @@ fn lists_every_problem_of_a_registry() { "{errors:?}" ); assert!(has("coords_hud 0.1.0: the project has a key"), "{errors:?}"); - assert!(has("glow: shader packs open when"), "{errors:?}"); + // A shader entry is taken now, and checked like the others. + assert!( + has("glow 1.0.0: the file isn't the one its sha256 names"), + "{errors:?}" + ); assert!( has("other 0.1.0: the file's id is \"coords_hud\""), "{errors:?}" @@ -219,7 +246,7 @@ fn a_review_protects_published_files() { #[test] fn only_open_kinds_are_taken() { assert!(open(&Kind::Mod).is_ok() && open(&Kind::ResourcePack).is_ok()); - assert!(open(&Kind::Shader).unwrap_err().contains("Iris")); + assert!(open(&Kind::Shader).is_ok()); assert!(open(&Kind::Other("world".into())).is_err()); let mut submit: Entry = toml::from_str(COZY).unwrap(); submit.id = "submit".into(); diff --git a/crates/horizon-mods/src/index/tests.rs b/crates/horizon-mods/src/index/tests.rs index e3883f79e..ef0299ad9 100644 --- a/crates/horizon-mods/src/index/tests.rs +++ b/crates/horizon-mods/src/index/tests.rs @@ -1,7 +1,8 @@ //! The sample index (`tests/index/index-v1.json`, the one docs/api/mod-index.md //! shows) and its files: `coords_hud-0.1.0.hmod`, signed with the throwaway -//! key `test.pub` by minisign 0.12 (its secret key was deleted), and -//! `cozy-1.0.0.hpack`, unsigned. +//! key `test.pub` by minisign 0.12 (its secret key was deleted), +//! `cozy-1.0.0.hpack`, unsigned, and `glow-1.0.0.hshader`, unsigned +//! (`horizon-shader new --template post`, then `horizon-shader pack`). use super::*; use std::path::PathBuf; @@ -25,8 +26,8 @@ fn reads_the_sample_and_keeps_unknown_kinds() { let index = sample(); assert_eq!(index.schema, SCHEMA); let kinds: Vec<&str> = index.projects.iter().map(|p| p.kind.name()).collect(); - assert_eq!(kinds, ["mod", "modpack", "world"]); - assert_eq!(index.projects[2].kind, Kind::Other("world".into())); + assert_eq!(kinds, ["mod", "modpack", "shader", "world"]); + assert_eq!(index.projects[3].kind, Kind::Other("world".into())); let hud = index.project("coords_hud").unwrap(); assert_eq!( hud.versions[0].capabilities, @@ -44,6 +45,8 @@ fn files_pass_against_their_entries() { assert_eq!(check(&index, "coords_hud", &hmod), Ok(Trust::Verified)); let hpack = fixtures().join("cozy-1.0.0.hpack"); assert_eq!(check(&index, "cozy", &hpack), Ok(Trust::Unsigned)); + let hshader = fixtures().join("glow-1.0.0.hshader"); + assert_eq!(check(&index, "glow", &hshader), Ok(Trust::Unsigned)); let world = index.project("skyblock_start").unwrap(); let e = check_file(&index, world, &world.versions[0], &hpack).unwrap_err(); assert!(e.contains("bytes"), "{e}"); @@ -73,6 +76,15 @@ fn a_changed_file_key_or_manifest_is_refused() { let e = check(&more_caps, "coords_hud", &hmod).unwrap_err(); assert!(e.contains("isn't what the index lists"), "{e}"); + let mut other_level = index.clone(); + other_level.projects[0].versions[0].api_level = Some(1); + let e = check(&other_level, "coords_hud", &hmod).unwrap_err(); + assert!(e.contains("isn't what the index lists"), "{e}"); + // An index built before levels lists none: the file still passes. + let mut no_level = index.clone(); + no_level.projects[0].versions[0].api_level = None; + assert_eq!(check(&no_level, "coords_hud", &hmod), Ok(Trust::Verified)); + let mut revoked = index.clone(); revoked.revoked.push(Revoked { id: "coords_hud".into(), @@ -163,3 +175,79 @@ fn resource_packs_need_a_pack_mcmeta() { assert!(e.contains("plain path"), "{e}"); std::fs::remove_dir_all(&dir).unwrap(); } + +#[test] +fn the_newest_version_this_horizon_runs_is_installed() { + let mut index = sample(); + let mut newer = index.projects[0].versions[0].clone(); + newer.version = "0.2.0".into(); + newer.file.sha256 = "2".repeat(64); + newer.api_level = Some(crate::api_level::LEVEL + 1); + index.projects[0].versions.insert(0, newer); + let p = index.project("coords_hud").unwrap(); + let pick = |level| { + index + .installable(p, "26.3", level) + .map(|v| v.version.as_str()) + }; + assert_eq!(pick(crate::api_level::LEVEL), Some("0.1.0")); + assert_eq!(pick(crate::api_level::LEVEL + 1), Some("0.2.0")); + assert_eq!(index.installable(p, "26.4", crate::api_level::LEVEL), None); + // No level listed: runnable as far as the index knows. + index.projects[0].versions[0].api_level = None; + let p = index.project("coords_hud").unwrap(); + let v = index.installable(p, "26.3", 0).unwrap(); + assert_eq!(v.version, "0.2.0"); +} + +#[test] +fn shader_packs_pass_the_game_s_own_check() { + let manifest = "schema = 1\nid = \"glow\"\nname = \"Glow\"\nversion = \"1.0.0\"\napi = \"0.1\"\n\ + [[post]]\nfile = \"post.wgsl\"\n"; + let pack = |post: &str| { + let files = [ + (horizon_shader_api::MANIFEST, manifest), + ("post.wgsl", post), + ] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + horizon_shader_api::Pack::from_files(files) + .unwrap() + .package() + .unwrap() + }; + let dir = std::env::temp_dir().join(format!("horizon-mods-shader-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let good = dir.join("glow-1.0.0.hshader"); + std::fs::write( + &good, + pack("fn post(input: PostInput) -> vec4 { return input.color; }\n"), + ) + .unwrap(); + let bad = dir.join("bad.hshader"); + std::fs::write( + &bad, + pack("fn post(input: PostInput) -> vec4 { return input.color }\n"), + ) + .unwrap(); + let facts = inspect(&Kind::Shader, &good); + let refused = inspect(&Kind::Shader, &bad).unwrap_err(); + let not_a_pack = inspect(&Kind::Shader, &fixtures().join("cozy-1.0.0.hpack")).unwrap_err(); + std::fs::remove_dir_all(&dir).unwrap(); + let facts = facts.unwrap(); + assert_eq!( + ( + facts.id.as_deref(), + facts.version.as_deref(), + facts.api.as_str() + ), + (Some("glow"), Some("1.0.0"), "0.1") + ); + assert!(refused.contains("post.wgsl:1:"), "{refused}"); + assert!( + not_a_pack.contains(horizon_shader_api::MANIFEST), + "{not_a_pack}" + ); + assert_eq!(Kind::Shader.extension(), Some("hshader")); + assert!(open(&Kind::Shader).is_ok()); +} diff --git a/crates/horizon-mods/src/lib.rs b/crates/horizon-mods/src/lib.rs index 17a6c5aa0..20f475165 100644 --- a/crates/horizon-mods/src/lib.rs +++ b/crates/horizon-mods/src/lib.rs @@ -5,6 +5,7 @@ //! //! Nothing here runs unless a mod is installed and turned on: an empty //! [`Mods`] makes no engine and every hook returns at once. +pub mod api_level; pub mod content; #[cfg(feature = "index")] pub mod index; @@ -12,6 +13,8 @@ pub mod manifest; pub mod modpack; #[cfg(feature = "runtime")] mod runtime; +#[cfg(feature = "runtime")] +pub mod testing; pub use content::Content; pub use manifest::{Capability, Manifest, Package, Side, find}; diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs index d520d55e3..5ad7823aa 100644 --- a/crates/horizon-mods/src/manifest.rs +++ b/crates/horizon-mods/src/manifest.rs @@ -16,7 +16,10 @@ pub const API: &str = "0.1"; /// The manifest `api` lines this build loads. 0.2 is 0.1 plus content: /// `assets/` and `data/` in the `.hmod`, with blocks and items declared in /// `data//horizon/` (docs/modpacks.md). Code still links API 0.1. -pub const APIS: [&str; 2] = [API, "0.2"]; +/// 0.3 is a server mod (experimental): the `horizon-server-mod` world. +pub const APIS: [&str; 3] = [API, "0.2", SERVER_API]; +/// The line of server mods, experimental: `side = "server"`. +pub const SERVER_API: &str = "0.3"; /// Namespaces no mod may claim: vanilla's, the convention tags' (mods add /// to those, docs/mods.md) and the game's own. const RESERVED_NAMESPACES: [&str; 3] = ["minecraft", "c", "horizon"]; @@ -63,7 +66,7 @@ pub enum Side { /// Runs in the player's game only (HUD, keys, chat commands). #[default] Client, - /// Runs where the world is simulated (rules, blocks); not run yet. + /// Runs where the world is simulated (rules, blocks): `api = "0.3"`. Server, /// Both, and the server tells clients which version it expects. Both, @@ -92,9 +95,11 @@ pub enum Capability { /// The use button on items the mod claims, and its own keys /// (interface `input`). Input, + /// The players on the server and messages to them (server mods). + Players, } impl Capability { - pub const ALL: [Capability; 9] = [ + pub const ALL: [Capability; 10] = [ Capability::GameRead, Capability::Chat, Capability::Hud, @@ -104,7 +109,12 @@ impl Capability { Capability::Ui, Capability::Render, Capability::Input, + Capability::Players, ]; + /// Whether a server mod may have it: the others act on a local player. + pub fn on_server(self) -> bool { + matches!(self, Capability::Storage | Capability::Players) + } /// The WIT interface it grants, in `horizon:mods`. pub fn interface(self) -> &'static str { match self { @@ -117,6 +127,7 @@ impl Capability { Capability::Ui => "ui", Capability::Render => "render", Capability::Input => "input", + Capability::Players => "players", } } /// May change in any release: a mod uses it only with @@ -141,6 +152,7 @@ impl Capability { Capability::Input => { "see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys" } + Capability::Players => "see who is on the server and message them", } } /// The capability a component import needs, `Ok(None)` for one every @@ -175,6 +187,7 @@ impl fmt::Display for Capability { Capability::Ui => "ui", Capability::Render => "render", Capability::Input => "input", + Capability::Players => "players", }; f.write_str(name) } @@ -205,6 +218,20 @@ impl Manifest { "{MANIFEST}: capability registries needs api = \"0.2\"" )); } + let server = m.side == Side::Server; + if server != (m.api == SERVER_API) { + return Err(format!( + "{MANIFEST}: a server mod is side = \"server\" with api = \"{SERVER_API}\", and only it" + )); + } + if let Some(c) = m + .capabilities + .iter() + .find(|c| c.on_server() != server && **c != Capability::Storage) + { + let side = if server { "client" } else { "server" }; + return Err(format!("{MANIFEST}: capability {c} is for {side} mods")); + } if let Some(c) = m .capabilities .iter() @@ -435,12 +462,32 @@ capabilities = ["game-read", "hud"] fn refuses_bad_ids_and_apis() { let bad_id = EXAMPLE.replace("coords_hud", "Coords HUD"); assert!(Manifest::parse(&bad_id).unwrap_err().contains("is not")); - let bad_api = EXAMPLE.replace("api = \"0.1\"", "api = \"0.3\""); - assert!(Manifest::parse(&bad_api).unwrap_err().contains("API 0.3")); + let bad_api = EXAMPLE.replace("api = \"0.1\"", "api = \"0.4\""); + assert!(Manifest::parse(&bad_api).unwrap_err().contains("API 0.4")); let unknown = format!("{EXAMPLE}network = true\n"); assert!(Manifest::parse(&unknown).is_err()); } + #[test] + fn server_mods_are_api_0_3_with_server_capabilities() { + let server = |api: &str, side: &str, caps: &str| { + Manifest::parse(&format!( + "id = \"w\"\nname = \"W\"\nversion = \"1\"\napi = \"{api}\"\nside = \"{side}\"\ncapabilities = [{caps}]\n" + )) + }; + let m = server("0.3", "server", "\"players\", \"storage\"").unwrap(); + let imports = ["horizon:mods/players@0.1.0", "horizon:mods/storage@0.1.0"]; + assert_eq!(m.check_imports(imports), Ok(())); + for (api, side) in [("0.3", "client"), ("0.3", "both"), ("0.1", "server")] { + let e = server(api, side, "").unwrap_err(); + assert!(e.contains("a server mod is side"), "{e}"); + } + let e = server("0.3", "server", "\"hud\"").unwrap_err(); + assert!(e.contains("capability hud is for client mods"), "{e}"); + let e = server("0.1", "client", "\"players\"").unwrap_err(); + assert!(e.contains("capability players is for server mods"), "{e}"); + } + #[test] fn checks_extra_namespaces() { let content = "id = \"t_and_t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.2\"\ncapabilities = [\"registries\"]\n"; diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs index 0e7c079d2..f1859337d 100644 --- a/crates/horizon-mods/src/runtime.rs +++ b/crates/horizon-mods/src/runtime.rs @@ -1,5 +1,9 @@ //! Loading and calling mods with wasmtime's component model. use crate::manifest::{Manifest, Package, Side}; +use server_bindings::{ + HorizonServerMod, exports::horizon::mods::server_events::Registration as ServerRegistration, + horizon::mods::players, +}; use std::{ path::{Path, PathBuf}, sync::Arc, @@ -16,6 +20,17 @@ mod bindings { world: "horizon-mod", }); } +/// The server mods' world: `log` and `storage` are the client world's. +mod server_bindings { + wasmtime::component::bindgen!({ + path: "../horizon-mod-sdk/wit", + world: "horizon-server-mod", + with: { + "horizon:mods/log": super::bindings::horizon::mods::log, + "horizon:mods/storage": super::bindings::horizon::mods::storage, + }, + }); +} /// Capability `ui`'s world beyond `horizon-mod` (docs/mods.md): a second /// world, so mods built before it (no `ui-events` export) still instantiate /// as `horizon-mod` and simply hear nothing of their widgets. @@ -34,6 +49,12 @@ use bindings::{ exports::horizon::mods::events::Registration, horizon::mods::{chat, command, game, hud, log as mod_log, storage}, }; +pub use server_bindings::{ + exports::horizon::mods::server_events::BlockPos, + horizon::mods::players::{GameMode, Player as ServerPlayer}, +}; +type ClientEvents = bindings::exports::horizon::mods::events::Guest; +type ServerEvents = server_bindings::exports::horizon::mods::server_events::Guest; /// The widget model a `ui` screen or settings page shows (WIT `interface /// ui`), for the game to draw with its menus' own widgets. pub use ui_bindings::horizon::mods::ui::{ @@ -52,8 +73,9 @@ use render_bindings::horizon::mods::input; pub use render_bindings::horizon::mods::input::{Event as InputEvent, HeldItem, ItemUse}; /// What capability `render` asks the game to draw (WIT `interface render`). pub use render_bindings::horizon::mods::render::{ - Corner as RenderCorner, FillShape, FrameRate, ItemShape, Point as RenderPoint, QuadShape, - Rect as RenderRect, Shape, SpriteShape, TextShape, Zoom as ModZoom, + Corner as RenderCorner, FillShape, FrameRate, ItemShape, Minimap as ModMinimap, + Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape, TextShape, + Zoom as ModZoom, }; use render_bindings::{RenderHost, horizon::mods::render}; @@ -100,6 +122,26 @@ pub struct Snapshot { /// The HUD font's advance per character from U+0000 /// (`render.text-width`); empty: 6 each. pub font_widths: Arc<[f32]>, + /// The players on the server, for server mods. + pub players: Vec, +} + +/// Which mods a game starts: the window's game the client mods, the game +/// simulating the world the server mods, single player in the frame both. +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum Runs { + Client, + Server, + Both, +} +impl Runs { + fn starts(self, side: Side) -> bool { + match self { + Runs::Both => true, + Runs::Client => side != Side::Server, + Runs::Server => side == Side::Server, + } + } } /// What mods asked the game to show since the last [`Mods::drain`]. @@ -114,6 +156,20 @@ pub enum Output { Command { line: String }, /// The mod was turned off: it trapped, overran or failed to start. Stopped { name: String, reason: String }, + /// `players.tell`: a line after the mod's name, to the player with this id. + Tell { + name: String, + player: String, + text: String, + }, + /// `players.broadcast`: a line after the mod's name, to every player. + Broadcast { name: String, text: String }, + /// A server mod command's feedback, to the player who typed it. + Reply { + player: String, + text: String, + error: bool, + }, /// `ui.open-screen`: the mod's entry in `entries()`; what it shows is /// [`Mods::screen`]. OpenScreen { owner: usize }, @@ -135,6 +191,9 @@ pub enum Status { /// Installed and turned off by the player. Off, Running, + /// Turned on, and run by another game: a server mod in the window while + /// the world runs on its server thread. + Elsewhere, /// Could not load or start, or stopped while running. Failed(String), } @@ -152,20 +211,48 @@ pub struct Entry { } impl Entry { /// The running mod has a settings page (capability `ui` set widgets - /// with `ui.set-settings`): its row in Options > Mods gains a button. + /// with `ui.set-settings`, or `input` registered keys the player may + /// bind there): its row in Options > Mods gains a button. pub fn has_ui_settings(&self) -> bool { - self.run - .as_ref() - .is_some_and(|r| !r.store.data().ui.settings.is_empty()) + self.run.as_ref().is_some_and(|r| { + let d = r.store.data(); + !d.ui.settings.is_empty() || !d.input.keys.is_empty() + }) } } struct Running { store: Store, - exports: HorizonMod, - /// The mod's `ui-events` export; none for a mod built before `ui`. + /// The mod's `ui-events` export; none for a mod built before `ui`, or a + /// server mod. ui: Option, - hooks: Registration, + hooks: Hooks, +} + +/// A running mod's exports and the hooks its `init` asked for. +enum Hooks { + Client(HorizonMod, Registration), + Server(HorizonServerMod, ServerRegistration), +} +impl Hooks { + fn client(&self) -> Option<&Registration> { + match self { + Hooks::Client(_, r) => Some(r), + Hooks::Server(..) => None, + } + } + fn server(&self) -> Option<&ServerRegistration> { + match self { + Hooks::Server(_, r) => Some(r), + Hooks::Client(..) => None, + } + } + fn commands(&self) -> &[String] { + match self { + Hooks::Client(_, r) => &r.commands, + Hooks::Server(_, r) => &r.commands, + } + } } /// What capability `ui` pushed since the hooks last ran. @@ -194,6 +281,8 @@ struct State { corner: Option, /// Capability `render`'s zoom, when the mod zooms. zoom: Option, + /// Capability `render`'s minimap, when the mod shows one. + minimap: Option, input: InputState, /// Capability `storage`'s folder; made on first `set`. data_dir: PathBuf, @@ -216,13 +305,23 @@ pub struct Mods { } impl Mods { - /// Reads every mod at `paths` and starts those `enabled` says are on. - /// A command that `reserved` (vanilla's commands) or an earlier mod - /// already uses is refused. + /// Reads every mod at `paths` and starts those `enabled` says are on, + /// client and server mods alike. A command that `reserved` (vanilla's + /// commands) or an earlier mod already uses is refused. pub fn load( paths: &[PathBuf], enabled: impl Fn(&str) -> bool, reserved: impl Fn(&str) -> bool, + ) -> Mods { + Mods::load_for(Runs::Both, paths, enabled, reserved) + } + /// [`Mods::load`], starting only the mods `runs` says this game runs; the + /// others that are on are [`Status::Elsewhere`]. + pub fn load_for( + runs: Runs, + paths: &[PathBuf], + enabled: impl Fn(&str) -> bool, + reserved: impl Fn(&str) -> bool, ) -> Mods { let mut mods = Mods::default(); for path in paths { @@ -240,7 +339,9 @@ impl Mods { Ok(package) => { let on = enabled(&package.manifest.id); entry.manifest = Some(package.manifest.clone()); - if on { + if on && !runs.starts(package.manifest.side) { + entry.status = Status::Elsewhere; + } else if on { // Content is read before the world loads; a mod whose // content is refused stays off, with the reason. let content = crate::Content::read(path, &package.manifest); @@ -271,6 +372,8 @@ impl Mods { let mut linker = Linker::new(&engine); HorizonMod::add_to_linker::>(&mut linker, |s| s) .map_err(|e| e.to_string())?; + players::add_to_linker::>(&mut linker, |s| s) + .map_err(|e| e.to_string())?; UiHost::add_to_linker::>(&mut linker, |s| s) .map_err(|e| e.to_string())?; RenderHost::add_to_linker::>(&mut linker, |s| s) @@ -294,9 +397,6 @@ impl Mods { let Some(wasm) = &package.wasm else { return Ok(None); }; - if m.side == Side::Server { - return Err("server mods do not run yet".into()); - } // Two running mods with the same id would share one `data_dir` // (capability `storage`): the first loaded keeps the id. if self @@ -306,11 +406,13 @@ impl Mods { { return Err(format!("another running mod already uses id {}", m.id)); } + let server = m.side == Side::Server; let taken: Vec = self .entries .iter() .filter_map(|e| e.run.as_ref()) - .flat_map(|r| r.hooks.commands.iter().cloned()) + .filter(|r| r.hooks.server().is_some() == server) + .flat_map(|r| r.hooks.commands().iter().cloned()) .collect(); let snapshot = self.snapshot.clone(); let (engine, linker) = self.engine()?; @@ -322,6 +424,12 @@ impl Mods { .map(|(name, _)| name.to_string()) .collect(); m.check_imports(imports.iter().map(String::as_str))?; + // A function this Horizon doesn't have: say so, not wasmtime's linking error. + let functions = crate::api_level::imports(wasm)?; + let (level, function) = crate::api_level::needed(functions.iter().map(String::as_str)); + if let Some(why) = crate::api_level::too_new(level, function) { + return Err(why); + } let data_dir = path .parent() .unwrap_or(Path::new(".")) @@ -337,6 +445,7 @@ impl Mods { shapes: Vec::new(), corner: None, zoom: None, + minimap: None, input: InputState::default(), data_dir, storage_budget: STORAGE_WRITE_BUDGET, @@ -351,15 +460,29 @@ impl Mods { let instance = linker .instantiate(&mut store, &component) .map_err(|e| reason(&e))?; - let exports = HorizonMod::new(&mut store, &instance).map_err(|e| reason(&e))?; - // `ui-events` is a mod built since `ui`'s; older mods have no export - // and stay callable through `events` alone. - let ui = UiHost::new(&mut store, &instance).ok(); - let mut hooks = exports - .horizon_mods_events() - .call_init(&mut store) - .map_err(|e| reason(&e))??; - hooks.commands.retain(|c| { + let (mut hooks, ui) = if server { + let exports = HorizonServerMod::new(&mut store, &instance).map_err(|e| reason(&e))?; + let r = exports + .horizon_mods_server_events() + .call_init(&mut store) + .map_err(|e| reason(&e))??; + (Hooks::Server(exports, r), None) + } else { + let exports = HorizonMod::new(&mut store, &instance).map_err(|e| reason(&e))?; + // `ui-events` is a mod built since `ui`'s; older mods have no export + // and stay callable through `events` alone. + let ui = UiHost::new(&mut store, &instance).ok(); + let r = exports + .horizon_mods_events() + .call_init(&mut store) + .map_err(|e| reason(&e))??; + (Hooks::Client(exports, r), ui) + }; + let commands = match &mut hooks { + Hooks::Client(_, r) => &mut r.commands, + Hooks::Server(_, r) => &mut r.commands, + }; + commands.retain(|c| { let free = !reserved(c) && !taken.contains(c); if !free { log::warn!("Horizon: mod {} cannot take /{c}: already a command", m.id); @@ -367,18 +490,19 @@ impl Mods { free }); self.out.append(&mut store.data_mut().out); - Ok(Some(Running { - store, - exports, - ui, - hooks, - })) + Ok(Some(Running { store, ui, hooks })) } /// True when at least one mod runs: the game skips its mod work otherwise. pub fn is_running(&self) -> bool { self.entries.iter().any(|e| e.run.is_some()) } + /// True when a server mod runs: the server skips its mod work otherwise. + pub fn runs_server(&self) -> bool { + self.entries + .iter() + .any(|e| e.run.as_ref().is_some_and(|r| r.hooks.server().is_some())) + } pub fn entries(&self) -> &[Entry] { &self.entries } @@ -391,7 +515,7 @@ impl Mods { fn each( &mut self, fuel: u64, - wants: impl Fn(&Registration) -> bool, + wants: impl Fn(&Hooks) -> bool, mut f: impl FnMut(&mut Running) -> wasmtime::Result<()>, ) { for i in 0..self.entries.len() { @@ -404,6 +528,38 @@ impl Mods { } } } + /// [`Mods::each`] over the client mods. + fn each_client( + &mut self, + fuel: u64, + wants: impl Fn(&Registration) -> bool, + mut f: impl FnMut(&ClientEvents, &mut Store) -> wasmtime::Result<()>, + ) { + self.each( + fuel, + |h| h.client().is_some_and(&wants), + |run| match &run.hooks { + Hooks::Client(m, _) => f(m.horizon_mods_events(), &mut run.store), + Hooks::Server(..) => Ok(()), + }, + ); + } + /// [`Mods::each`] over the server mods. + fn each_server( + &mut self, + fuel: u64, + wants: impl Fn(&ServerRegistration) -> bool, + mut f: impl FnMut(&ServerEvents, &mut Store) -> wasmtime::Result<()>, + ) { + self.each( + fuel, + |h| h.server().is_some_and(&wants), + |run| match &run.hooks { + Hooks::Server(m, _) => f(m.horizon_mods_server_events(), &mut run.store), + Hooks::Client(..) => Ok(()), + }, + ); + } /// One call into mod `i`; a trap or an overrun turns the mod off. fn call( @@ -451,62 +607,39 @@ impl Mods { /// A game tick. pub fn tick(&mut self, tick: u64) { - self.each( - FUEL_TICK, - |h| h.tick, - |run| { - run.exports - .horizon_mods_events() - .call_tick(&mut run.store, tick) - }, - ); + self.each_client(FUEL_TICK, |h| h.tick, |m, s| m.call_tick(s, tick)); } /// A rendered frame, `seconds` after the last. pub fn frame(&mut self, seconds: f32) { - self.each( - FUEL_FRAME, - |h| h.frame, - |run| { - run.exports - .horizon_mods_events() - .call_frame(&mut run.store, seconds) - }, - ); + self.each_client(FUEL_FRAME, |h| h.frame, |m, s| m.call_frame(s, seconds)); } /// A chat line the player received, as plain text. pub fn chat(&mut self, text: &str) { - self.each( - FUEL_EVENT, - |h| h.chat, - |run| { - run.exports - .horizon_mods_events() - .call_chat(&mut run.store, text) - }, - ); + self.each_client(FUEL_EVENT, |h| h.chat, |m, s| m.call_chat(s, text)); } - /// Whether a running mod owns `/name`. + /// Whether a running client mod owns `/name`. pub fn has_command(&self, name: &str) -> bool { - self.command_owner(name).is_some() + self.command_owner(false, name).is_some() } - fn command_owner(&self, name: &str) -> Option { + fn command_owner(&self, server: bool, name: &str) -> Option { self.entries.iter().position(|e| { - e.run - .as_ref() - .is_some_and(|r| r.hooks.commands.iter().any(|c| c == name)) + e.run.as_ref().is_some_and(|r| { + r.hooks.server().is_some() == server && r.hooks.commands().iter().any(|c| c == name) + }) }) } - /// Runs `line` (without its slash) if a mod owns its command; false - /// when none does. + /// Runs `line` (without its slash) if a client mod owns its command; + /// false when none does. pub fn command(&mut self, line: &str) -> bool { let (name, args) = line.split_once(' ').unwrap_or((line, "")); - let Some(i) = self.command_owner(name) else { + let Some(i) = self.command_owner(false, name) else { return false; }; - let result = self.call(i, FUEL_EVENT, |run| { - run.exports + let result = self.call(i, FUEL_EVENT, |run| match &run.hooks { + Hooks::Client(m, _) => m .horizon_mods_events() - .call_command(&mut run.store, name, args) + .call_command(&mut run.store, name, args), + Hooks::Server(..) => Ok(Ok(None)), }); match result { Some(Ok(Some(text))) => self.out.push(Output::Feedback { text, error: false }), @@ -515,14 +648,89 @@ impl Mods { } true } - /// The commands running mods own, for suggestions. + /// The commands running client mods own, for suggestions. pub fn commands(&self) -> impl Iterator { + self.owned_commands(false) + } + fn owned_commands(&self, server: bool) -> impl Iterator { self.entries .iter() .filter_map(|e| e.run.as_ref()) - .flat_map(|r| r.hooks.commands.iter().map(String::as_str)) + .filter(move |r| r.hooks.server().is_some() == server) + .flat_map(|r| r.hooks.commands().iter().map(String::as_str)) } + /// A server tick. + pub fn server_tick(&mut self, tick: u64) { + self.each_server(FUEL_TICK, |h| h.tick, |m, s| m.call_tick(s, tick)); + } + /// `player` joined the server (they are in the snapshot's players). + pub fn player_joined(&mut self, player: &ServerPlayer) { + self.each_server( + FUEL_EVENT, + |h| h.joins, + |m, s| m.call_player_joined(s, player), + ); + } + /// `player` left the server (they are no longer in the snapshot's players). + pub fn player_left(&mut self, player: &ServerPlayer) { + self.each_server( + FUEL_EVENT, + |h| h.joins, + |m, s| m.call_player_left(s, player), + ); + } + /// A chat message `player` sent, as plain text. + pub fn player_chat(&mut self, player: &ServerPlayer, text: &str) { + self.each_server(FUEL_EVENT, |h| h.chat, |m, s| m.call_chat(s, player, text)); + } + /// `player` broke `state` at `pos`. + pub fn block_broken(&mut self, player: &ServerPlayer, pos: BlockPos, state: &str) { + self.each_server( + FUEL_EVENT, + |h| h.blocks, + |m, s| m.call_block_broken(s, player, pos, state), + ); + } + /// `player` placed `state` at `pos`. + pub fn block_placed(&mut self, player: &ServerPlayer, pos: BlockPos, state: &str) { + self.each_server( + FUEL_EVENT, + |h| h.blocks, + |m, s| m.call_block_placed(s, player, pos, state), + ); + } + /// The commands running server mods own, for the server's command tree. + pub fn server_commands(&self) -> impl Iterator { + self.owned_commands(true) + } + /// Runs `line` (without its slash), typed by `player`, if a server mod + /// owns its command; its feedback is an [`Output::Reply`]. False when + /// none does. + pub fn server_command(&mut self, player: &ServerPlayer, line: &str) -> bool { + let (name, args) = line.split_once(' ').unwrap_or((line, "")); + let Some(i) = self.command_owner(true, name) else { + return false; + }; + let result = self.call(i, FUEL_EVENT, |run| match &run.hooks { + Hooks::Server(m, _) => { + m.horizon_mods_server_events() + .call_command(&mut run.store, player, name, args) + } + Hooks::Client(..) => Ok(Ok(None)), + }); + let reply = |text, error| Output::Reply { + player: player.id.clone(), + text, + error, + }; + match result { + Some(Ok(Some(text))) => self.out.push(reply(text, false)), + Some(Err(text)) => self.out.push(reply(text, true)), + Some(Ok(None)) | None => {} + } + true + } /// The running mods' HUD panels. pub fn panels(&self) -> impl Iterator { self.entries @@ -538,9 +746,11 @@ impl Mods { /// Some running mod has a `frame` hook: the game refreshes the snapshot /// every frame for it. pub fn wants_frames(&self) -> bool { - self.entries - .iter() - .any(|e| e.run.as_ref().is_some_and(|r| r.hooks.frame)) + self.entries.iter().any(|e| { + e.run + .as_ref() + .is_some_and(|r| r.hooks.client().is_some_and(|h| h.frame)) + }) } /// Some running mod claimed items (capability `input`). pub fn claims_any(&self) -> bool { @@ -564,6 +774,48 @@ impl Mods { d.input.keys.iter().map(move |k| (d.name.as_str(), k)) }) } + /// Mod `i`'s keys, as it registered them (with the player's choices). + pub fn keys_of(&self, i: usize) -> &[ModKey] { + self.entries + .get(i) + .and_then(|e| e.run.as_ref()) + .map_or(&[], |r| r.store.data().input.keys.as_slice()) + } + /// The keys the player chose (`ui`'s key widget), by mod id: each + /// running mod's `name → key`. They replace the defaults registered + /// so far and later ones. Keys that aren't keys are skipped. + pub fn set_bindings<'a>(&mut self, chosen: impl Fn(&str) -> Vec<(&'a str, &'a str)>) { + for e in &mut self.entries { + let (Some(m), Some(run)) = (&e.manifest, e.run.as_mut()) else { + continue; + }; + let input = &mut run.store.data_mut().input; + input.bindings = chosen(&m.id) + .into_iter() + .filter(|(_, key)| key_ok(key)) + .map(|(n, k)| (n.to_owned(), k.to_owned())) + .collect(); + for (name, key) in input.bindings.clone() { + input.rebind(&name, key); + } + } + } + /// The player binds mod `i`'s key `name` to `key` (`key.keyboard.x`, + /// `key.mouse.4`, `key.keyboard.unknown` for none). False when the mod + /// has no such key or `key` isn't one. + pub fn rebind(&mut self, i: usize, name: &str, key: &str) -> bool { + let Some(run) = self.entries.get_mut(i).and_then(|e| e.run.as_mut()) else { + return false; + }; + let input = &mut run.store.data_mut().input; + if !key_ok(key) || !input.keys.iter().any(|k| k.name == name) { + return false; + } + input.bindings.retain(|(n, _)| n != name); + input.bindings.push((name.to_owned(), key.to_owned())); + input.rebind(name, key.to_owned()); + true + } /// The use button went down with `item`: `use-start` to each mod that /// claimed it. pub fn use_start(&mut self, item: &HeldItem) { @@ -640,6 +892,12 @@ impl Mods { .filter_map(|e| e.run.as_ref()?.store.data().zoom) .max_by(|a, b| a.factor.total_cmp(&b.factor)) } + /// The minimap the first running mod shows (capability `render`). + pub fn minimap(&self) -> Option { + self.entries + .iter() + .find_map(|e| e.run.as_ref()?.store.data().minimap) + } fn inputs(&self) -> impl Iterator { self.entries .iter() @@ -727,7 +985,7 @@ impl Mods { for i in 0..self.entries.len() { let entry = &self.entries[i]; let now = modified(&entry.path); - let was_on = entry.status != Status::Off; + let was_on = !matches!(entry.status, Status::Off | Status::Elsewhere); if now == entry.modified || !was_on { continue; } @@ -836,20 +1094,51 @@ impl game::Host for State { self.snapshot.clock } } -impl chat::Host for State { - fn show(&mut self, text: String) { +impl State { + /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`]. + fn say(&mut self, line: impl FnOnce(String) -> Output) -> bool { let shown = self .out .iter() - .filter(|o| matches!(o, Output::Chat { .. })) + .filter(|o| { + matches!( + o, + Output::Chat { .. } | Output::Tell { .. } | Output::Broadcast { .. } + ) + }) .count(); if shown < CHAT_PER_CALL { let name = self.name.clone(); - self.out.push(Output::Chat { - name, - text: clip(text), - }); + self.out.push(line(name)); } + shown < CHAT_PER_CALL + } +} +impl chat::Host for State { + fn show(&mut self, text: String) { + self.say(|name| Output::Chat { + name, + text: clip(text), + }); + } +} +impl players::Host for State { + fn online(&mut self) -> Vec { + self.snapshot.players.clone() + } + fn tell(&mut self, player: String, text: String) -> bool { + self.snapshot.players.iter().any(|p| p.id == player) + && self.say(|name| Output::Tell { + name, + player, + text: clip(text), + }) + } + fn broadcast(&mut self, text: String) { + self.say(|name| Output::Broadcast { + name, + text: clip(text), + }); } } /// A key a mod registered (capability `input`). @@ -873,6 +1162,9 @@ struct InputState { down: Vec, /// It holds the mouse wheel. wheel: bool, + /// The keys the player chose, `name → key`: they win over + /// `register-key`'s. + bindings: Vec<(String, String)>, } /// Events kept for `poll`, items claimed and keys, per mod. const INPUT_EVENTS: usize = 256; @@ -893,6 +1185,17 @@ fn key_ok(key: &str) -> bool { } impl InputState { + /// Key `name` is `key` now; held, it lets go first. + fn rebind(&mut self, name: &str, key: String) { + let Some(k) = self.keys.iter_mut().find(|k| k.name == name) else { + return; + }; + k.key = key; + if let Some(i) = self.down.iter().position(|n| n == name) { + let name = self.down.swap_remove(i); + self.push(InputEvent::KeyUp(name)); + } + } fn push(&mut self, event: InputEvent) { if self.events.len() == INPUT_EVENTS { self.events.pop_front(); @@ -912,6 +1215,10 @@ impl input::Host for State { )); } let (name, label) = (clip(name), clip(label)); + let key = match self.input.bindings.iter().find(|(n, _)| *n == name) { + Some((_, chosen)) => chosen.clone(), + None => key, + }; if let Some(k) = self.input.keys.iter_mut().find(|k| k.name == name) { (k.label, k.key) = (label, key); return Ok(()); @@ -951,6 +1258,9 @@ const SHAKE_SECONDS: f32 = 10.0; /// or more, and turning never stops. const ZOOM_MAX: f32 = 10.0; const TURN_MIN: f32 = 0.05; +/// `set-minimap`'s side in GUI pixels and its blocks per map pixel. +const MINIMAP_SIZE: (f32, f32) = (16.0, 256.0); +const MINIMAP_SCALE: (f32, f32) = (0.5, 4.0); /// A mod's corner panel: shapes in a `width` × `height` box the game /// places in `corner`, stacked with the other overlays. @@ -1032,6 +1342,14 @@ impl render::Host for State { }, }); } + fn set_minimap(&mut self, minimap: Option) { + let finite = |v: f32, lo: f32, hi: f32| if v.is_finite() { v.clamp(lo, hi) } else { lo }; + self.minimap = minimap.map(|m| ModMinimap { + size: finite(m.size, MINIMAP_SIZE.0, MINIMAP_SIZE.1), + blocks_per_pixel: finite(m.blocks_per_pixel, MINIMAP_SCALE.0, MINIMAP_SCALE.1), + ..m + }); + } fn frame_stats(&mut self) -> FrameRate { let (fps, min, low) = self.snapshot.frame; FrameRate { fps, min, low } diff --git a/crates/horizon-mods/src/testing.rs b/crates/horizon-mods/src/testing.rs new file mode 100644 index 000000000..3a7422377 --- /dev/null +++ b/crates/horizon-mods/src/testing.rs @@ -0,0 +1,642 @@ +//! A mod run with no game: `cargo horizon-mod test` (docs/mods.md, "Testing a mod"). +//! +//! [`TestGame`] loads one `.hmod` from a scratch copy (its `storage` lives and +//! dies with the run) into the same sandbox the game uses, and plays the game's +//! part: the snapshot, ticks, frames, chat lines and commands, and for a +//! server mod the players joining, leaving, chatting and breaking or placing +//! blocks. [`Script`] is a +//! test written in TOML, `tests/.toml` in the mod's folder: steps, each +//! saying what happens and what the mod must have shown by then. +use crate::{ + BlockPos, Clock, Corner, GameMode, Mods, Output, Panel, Player, ServerPlayer, Snapshot, Status, +}; +use serde::Deserialize; +use std::{ + path::{Path, PathBuf}, + sync::atomic::{AtomicUsize, Ordering}, +}; + +/// One mod in the sandbox, driven by a test. +pub struct TestGame { + mods: Mods, + dir: PathBuf, + hmod: PathBuf, + /// What the mod reads with `game-read`; ticks move the clock as the game does. + pub player: Option, + pub clock: Option, + /// The players on the server, for a server mod, in join order. + pub players: Vec, + /// Every name that joined, for their id. + names: Vec, + tick: u64, +} + +/// Where a script starts: standing at 0.5 64 0.5 in the Overworld, facing +/// south, full health and food, at the first tick of a new world's first morning. +pub fn default_player() -> Player { + Player { + x: 0.5, + y: 64.0, + z: 0.5, + yaw: 0.0, + pitch: 0.0, + health: 20.0, + food: 20, + dimension: "minecraft:overworld".into(), + } +} + +impl TestGame { + /// Starts the mod at `hmod`, as the game would with it turned on. Errs + /// when it doesn't start, with the game's reason. + pub fn load(hmod: &Path) -> Result { + static RUN: AtomicUsize = AtomicUsize::new(0); + let dir = std::env::temp_dir().join(format!( + "horizon-mod-test-{}-{}", + std::process::id(), + RUN.fetch_add(1, Ordering::Relaxed) + )); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?; + let copy = dir.join(hmod.file_name().unwrap_or("mod.hmod".as_ref())); + let mut game = TestGame { + mods: Mods::default(), + hmod: copy.clone(), + dir, + player: Some(default_player()), + clock: Some(Clock { + game_time: 0, + day_time: 0, + }), + players: Vec::new(), + names: Vec::new(), + tick: 0, + }; + copy_mod(hmod, ©)?; + game.start()?; + Ok(game) + } + + fn start(&mut self) -> Result<(), String> { + self.mods = Mods::load(std::slice::from_ref(&self.hmod), |_| true, |_| false); + match &self.mods.entries()[0].status { + Status::Failed(reason) => Err(format!("the mod didn't start: {reason}")), + _ if !self.mods.is_running() => Err("the mod has no code to run".into()), + _ => Ok(()), + } + } + + /// Stops the mod and starts it again, as a rebuild does in the game: its + /// memory starts over, its `storage` stays. + pub fn reload(&mut self) -> Result<(), String> { + self.mods = Mods::default(); + self.start() + } + + fn snapshot(&mut self) { + self.mods.set_snapshot(Snapshot { + player: self.player.clone(), + clock: self.clock, + players: self.players.clone(), + // The GUI of a 1280 x 720 window at scale 3, as the trial run's. + gui_size: (427.0, 240.0), + ..Snapshot::default() + }); + } + /// Whether the mod is a server mod. + pub fn server(&self) -> bool { + self.mods.runs_server() + } + + /// `n` game ticks; each moves the clock one tick on, as the game does. + pub fn tick(&mut self, n: u64) { + for _ in 0..n { + self.tick += 1; + if let Some(clock) = &mut self.clock { + clock.game_time += 1; + clock.day_time += 1; + } + self.snapshot(); + self.mods.tick(self.tick); + self.mods.server_tick(self.tick); + } + } + /// `n` frames, 1/60 s apart. + pub fn frames(&mut self, n: u64) { + self.snapshot(); + for _ in 0..n { + self.mods.frame(1.0 / 60.0); + } + } + /// A chat line the player receives. + pub fn chat(&mut self, line: &str) { + self.snapshot(); + self.mods.chat(line); + } + /// `/line` typed by the player (without the slash); false when the mod + /// owns no such command. + pub fn command(&mut self, line: &str) -> bool { + self.snapshot(); + self.mods.command(line) + } + + /// A player named `name` joins the server, standing where a script starts + /// in survival. Their id is `00000000-0000-4000-8000-000000000001` for + /// the first name that joined, `...0002` for the second, and so on. + pub fn join(&mut self, name: &str) -> ServerPlayer { + let n = match self.names.iter().position(|n| n == name) { + Some(i) => i + 1, + None => { + self.names.push(name.to_owned()); + self.names.len() + } + }; + let p = default_player(); + let player = ServerPlayer { + id: format!("00000000-0000-4000-8000-{n:012x}"), + name: name.to_owned(), + x: p.x, + y: p.y, + z: p.z, + dimension: p.dimension, + game_mode: GameMode::Survival, + health: p.health, + }; + self.players.push(player.clone()); + self.snapshot(); + self.mods.player_joined(&player); + player + } + /// The player named `name` leaves; false when no such player is on. + pub fn leave(&mut self, name: &str) -> bool { + let Some(i) = self.players.iter().position(|p| p.name == name) else { + return false; + }; + let player = self.players.remove(i); + self.snapshot(); + self.mods.player_left(&player); + true + } + /// A chat message `player` sends, for a server mod. + pub fn player_chat(&mut self, player: &ServerPlayer, line: &str) { + self.snapshot(); + self.mods.player_chat(player, line); + } + /// `/line` typed by `player`, for a server mod; false when the mod owns + /// no such command. + pub fn player_command(&mut self, player: &ServerPlayer, line: &str) -> bool { + self.snapshot(); + self.mods.server_command(player, line) + } + /// `player` breaks (or places) `state` at `pos`. + pub fn block(&mut self, player: &ServerPlayer, pos: BlockPos, state: &str, placed: bool) { + self.snapshot(); + if placed { + self.mods.block_placed(player, pos, state); + } else { + self.mods.block_broken(player, pos, state); + } + } + + /// The scratch copy the mod runs from; its `storage` is beside it. + pub fn hmod(&self) -> &Path { + &self.hmod + } + /// The commands the mod registered. + pub fn commands(&self) -> Vec { + let server = self.mods.server_commands(); + self.mods + .commands() + .chain(server) + .map(str::to_owned) + .collect() + } + pub fn panel(&self) -> Option<&Panel> { + self.mods.panels().next() + } + pub fn status(&self) -> &Status { + &self.mods.entries()[0].status + } + /// What the mod showed since the last call. + pub fn drain(&mut self) -> Vec { + self.mods.drain() + } +} + +impl Drop for TestGame { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.dir); + } +} + +/// A `.hmod` file, or a mod folder (`horizon-mod.toml` + `mod.wasm`). +fn copy_mod(from: &Path, to: &Path) -> Result<(), String> { + let err = |e: std::io::Error| format!("{}: {e}", from.display()); + if !from.is_dir() { + return std::fs::copy(from, to).map(drop).map_err(err); + } + std::fs::create_dir_all(to).map_err(err)?; + for entry in std::fs::read_dir(from).map_err(err)? { + let entry = entry.map_err(err)?; + if entry.file_type().map_err(err)?.is_file() { + std::fs::copy(entry.path(), to.join(entry.file_name())).map_err(err)?; + } + } + Ok(()) +} + +/// A test in TOML: where a client mod's player starts, then steps run in order. +#[derive(Debug, Default, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] +pub struct Script { + #[serde(default)] + pub player: PlayerSet, + #[serde(default)] + pub clock: ClockSet, + #[serde(default, rename = "step")] + pub steps: Vec, +} + +/// Fields of the player to change; the others keep their values. A server +/// mod's players have no `yaw`, `pitch` or `food`, and a client mod's player +/// no `game-mode`. +#[derive(Debug, Default, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] +pub struct PlayerSet { + x: Option, + y: Option, + z: Option, + yaw: Option, + pitch: Option, + health: Option, + food: Option, + dimension: Option, + game_mode: Option, +} + +/// `players.game-mode` as a script spells it. +#[derive(Clone, Copy, Debug, Deserialize)] +#[serde(rename_all = "lowercase")] +enum Mode { + Survival, + Creative, + Adventure, + Spectator, +} +impl From for GameMode { + fn from(m: Mode) -> GameMode { + match m { + Mode::Survival => GameMode::Survival, + Mode::Creative => GameMode::Creative, + Mode::Adventure => GameMode::Adventure, + Mode::Spectator => GameMode::Spectator, + } + } +} + +/// A block a player breaks or places. +#[derive(Debug, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct BlockSet { + x: i32, + y: i32, + z: i32, + state: String, +} + +#[derive(Debug, Default, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] +pub struct ClockSet { + game_time: Option, + day_time: Option, +} + +/// One step. Its parts happen in this order: `reload`, `title-screen`, +/// `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`, `break`, +/// `place`, `leave`; then `expect` is checked against what the mod showed +/// during the step. For a server mod, `player`, `chat`, `command`, `break` +/// and `place` are the doing of the player named by `as`, or of the first +/// player on. +#[derive(Debug, Default, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] +pub struct Step { + #[serde(default)] + reload: bool, + /// Leave the world: the mod reads no player and no clock until a step sets them. + #[serde(default)] + title_screen: bool, + player: Option, + clock: Option, + #[serde(default)] + ticks: u64, + #[serde(default)] + frames: u64, + chat: Option, + command: Option, + /// Server mods: a player joins, leaves, breaks or places a block. + join: Option, + leave: Option, + #[serde(rename = "as")] + actor: Option, + #[serde(rename = "break")] + broken: Option, + place: Option, + #[serde(default)] + expect: Expect, +} + +/// What a step checks; a part left out is not checked. +#[derive(Debug, Default, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "kebab-case")] +pub struct Expect { + /// The commands the mod owns. + commands: Option>, + /// Every chat line shown during the step, in order. + chat: Option>, + /// The command's feedback, and its red error. + feedback: Option, + error: Option, + /// Server mods: every `players.tell` as `"Name: text"`, and every + /// `players.broadcast`, in order. + told: Option>, + broadcast: Option>, + /// The panel's lines (`[]`: no panel) and its corner. + panel: Option>, + corner: Option, + /// The mod is turned off during this step, for a reason holding this text. + /// Without it, a mod that stops fails the test. + stopped: Option, +} + +impl Script { + pub fn parse(text: &str) -> Result { + toml::from_str(text).map_err(|e| e.to_string()) + } + + /// Runs every step on `game`; the error names the first step that failed. + pub fn run(&self, game: &mut TestGame) -> Result<(), String> { + if let Some(p) = &mut game.player { + self.player.apply(p); + } + if let Some(c) = &mut game.clock { + self.clock.apply(c); + } + for (i, step) in self.steps.iter().enumerate() { + step.run(game) + .map_err(|e| format!("step {} ({}): {e}", i + 1, step.describe()))?; + } + Ok(()) + } +} + +impl PlayerSet { + fn apply(&self, p: &mut Player) { + let set = |to: &mut f64, v: Option| *to = v.unwrap_or(*to); + set(&mut p.x, self.x); + set(&mut p.y, self.y); + set(&mut p.z, self.z); + p.yaw = self.yaw.unwrap_or(p.yaw); + p.pitch = self.pitch.unwrap_or(p.pitch); + p.health = self.health.unwrap_or(p.health); + p.food = self.food.unwrap_or(p.food); + if let Some(d) = &self.dimension { + p.dimension.clone_from(d); + } + } + fn apply_server(&self, p: &mut ServerPlayer) { + let set = |to: &mut f64, v: Option| *to = v.unwrap_or(*to); + set(&mut p.x, self.x); + set(&mut p.y, self.y); + set(&mut p.z, self.z); + p.health = self.health.unwrap_or(p.health); + p.game_mode = self.game_mode.map_or(p.game_mode, GameMode::from); + if let Some(d) = &self.dimension { + p.dimension.clone_from(d); + } + } +} + +impl ClockSet { + fn apply(&self, c: &mut Clock) { + c.game_time = self.game_time.unwrap_or(c.game_time); + c.day_time = self.day_time.unwrap_or(c.day_time); + } +} + +impl Step { + fn describe(&self) -> String { + let mut parts = Vec::new(); + if self.reload { + parts.push("reload".to_string()); + } + let count = |n: u64, what: &str| format!("{n} {what}{}", if n == 1 { "" } else { "s" }); + if self.ticks > 0 { + parts.push(count(self.ticks, "tick")); + } + if self.frames > 0 { + parts.push(count(self.frames, "frame")); + } + if let Some(line) = &self.chat { + parts.push(format!("chat {line:?}")); + } + if let Some(line) = &self.command { + parts.push(format!("/{line}")); + } + if let Some(name) = &self.join { + parts.insert(0, format!("{name} joins")); + } + for (what, b) in [("breaks", &self.broken), ("places", &self.place)] { + if let Some(b) = b { + parts.push(format!("{what} {} at {} {} {}", b.state, b.x, b.y, b.z)); + } + } + if let Some(name) = &self.leave { + parts.push(format!("{name} leaves")); + } + if parts.is_empty() { + parts.push("checks".into()); + } + parts.join(", ") + } + + fn run(&self, game: &mut TestGame) -> Result<(), String> { + if self.reload { + game.reload()?; + } + if self.title_screen { + game.player = None; + game.clock = None; + } + if let Some(name) = &self.join { + game.join(name); + } + let server = game.server(); + let actor = |game: &TestGame| match &self.actor { + Some(name) => game + .players + .iter() + .position(|p| p.name == *name) + .ok_or_else(|| format!("{name} is not on the server")), + None => (!game.players.is_empty()) + .then_some(0) + .ok_or_else(|| "no player is on the server: add join = \"Name\"".to_string()), + }; + let acts = self.player.is_some() + || self.chat.is_some() + || self.command.is_some() + || self.broken.is_some() + || self.place.is_some(); + let actor = if server && acts { + Some(actor(game)?) + } else { + None + }; + if let Some(set) = &self.player { + match actor { + Some(i) => set.apply_server(&mut game.players[i]), + None => set.apply(game.player.get_or_insert_with(default_player)), + } + } + if let Some(set) = &self.clock { + set.apply(game.clock.get_or_insert(Clock { + game_time: 0, + day_time: 0, + })); + } + game.tick(self.ticks); + game.frames(self.frames); + let who = actor.map(|i| game.players[i].clone()); + if let Some(line) = &self.chat { + match &who { + Some(p) => game.player_chat(p, line), + None => game.chat(line), + } + } + let owned = self.command.as_ref().map(|line| match &who { + Some(p) => game.player_command(p, line), + None => game.command(line), + }); + for (b, placed) in [(&self.broken, false), (&self.place, true)] { + if let (Some(b), Some(p)) = (b, &who) { + let pos = BlockPos { + x: b.x, + y: b.y, + z: b.z, + }; + game.block(p, pos, &b.state, placed); + } + } + if let Some(name) = &self.leave + && !game.leave(name) + { + return Err(format!("{name} is not on the server")); + } + let out = game.drain(); + let stopped = out.iter().find_map(|o| match o { + Output::Stopped { reason, .. } => Some(reason.as_str()), + _ => None, + }); + let e = &self.expect; + match (stopped, &e.stopped) { + (Some(reason), Some(want)) if !reason.contains(want.as_str()) => { + return Err(format!("the mod stopped ({reason}), expected {want:?}")); + } + (Some(_), Some(_)) => return Ok(()), + (Some(reason), None) => return Err(format!("the mod stopped: {reason}")), + (None, Some(want)) => { + return Err(format!( + "the mod kept running, expected it to stop ({want:?})" + )); + } + (None, None) => {} + } + if owned == Some(false) { + let line = self.command.as_deref().unwrap_or_default(); + let name = line.split(' ').next().unwrap_or_default(); + return Err(format!("the mod owns no command /{name}")); + } + if let Some(want) = &e.commands { + same("commands", want, &game.commands())?; + } + if let Some(want) = &e.chat { + let got: Vec = out + .iter() + .filter_map(|o| match o { + Output::Chat { text, .. } => Some(text.clone()), + _ => None, + }) + .collect(); + same("chat", want, &got)?; + } + let feedback = |error: bool| { + out.iter().rev().find_map(|o| match o { + Output::Feedback { text, error: e } | Output::Reply { text, error: e, .. } + if *e == error => + { + Some(text.clone()) + } + _ => None, + }) + }; + if let Some(want) = &e.told { + let name = |id: &str| { + let p = game.players.iter().find(|p| p.id == id); + p.map_or(id.to_owned(), |p| p.name.clone()) + }; + let got: Vec = out + .iter() + .filter_map(|o| match o { + Output::Tell { player, text, .. } => Some(format!("{}: {text}", name(player))), + _ => None, + }) + .collect(); + same("told", want, &got)?; + } + if let Some(want) = &e.broadcast { + let got: Vec = out + .iter() + .filter_map(|o| match o { + Output::Broadcast { text, .. } => Some(text.clone()), + _ => None, + }) + .collect(); + same("broadcast", want, &got)?; + } + if let Some(want) = &e.feedback { + same("feedback", &Some(want.clone()), &feedback(false))?; + } + if let Some(want) = &e.error { + same("error", &Some(want.clone()), &feedback(true))?; + } + if let Some(want) = &e.panel { + let got: Vec = game + .panel() + .map(|p| p.lines.iter().map(|l| l.text.clone()).collect()) + .unwrap_or_default(); + same("panel", want, &got)?; + } + if let Some(want) = &e.corner { + let got = game.panel().map(|p| corner_name(p.corner).to_string()); + same("corner", &Some(want.clone()), &got)?; + } + Ok(()) + } +} + +fn corner_name(c: Corner) -> &'static str { + match c { + Corner::TopLeft => "top-left", + Corner::TopRight => "top-right", + Corner::BottomLeft => "bottom-left", + Corner::BottomRight => "bottom-right", + } +} + +fn same(what: &str, want: &T, got: &T) -> Result<(), String> { + if want == got { + return Ok(()); + } + Err(format!( + "{what}\n expected: {want:?}\n got: {got:?}" + )) +} diff --git a/crates/horizon-mods/tests/api_reference.rs b/crates/horizon-mods/tests/api_reference.rs index b3d2363a9..6e9a92c85 100644 --- a/crates/horizon-mods/tests/api_reference.rs +++ b/crates/horizon-mods/tests/api_reference.rs @@ -302,3 +302,38 @@ fn every_capability_with_an_interface_is_in_the_contract() { } } } + +/// Every function the game offers (an interface some world imports and none +/// exports) has an API level, and the levels list nothing else. +#[test] +fn every_function_has_an_api_level() { + let mut resolve = Resolve::default(); + let package = resolve.push_file(root().join(WIT)).unwrap(); + let package = &resolve.packages[package]; + let exported: Vec<_> = package + .worlds + .values() + .flat_map(|&w| resolve.worlds[w].exports.values()) + .filter_map(|item| match item { + WorldItem::Interface { id, .. } => Some(*id), + _ => None, + }) + .collect(); + let mut offered = Vec::new(); + for (name, &id) in &package.interfaces { + if !exported.contains(&id) { + for function in resolve.interfaces[id].functions.keys() { + offered.push(format!("{name}.{function}")); + } + } + } + for f in &offered { + assert!( + horizon_mods::api_level::level_of(f).is_some(), + "{f} has no level in crates/horizon-mods/src/api_level.rs: add it at the next level" + ); + } + for (f, _) in horizon_mods::api_level::FUNCTIONS { + assert!(offered.iter().any(|o| o == f), "{f} isn't in the WIT"); + } +} diff --git a/crates/horizon-mods/tests/index/glow-1.0.0.hshader b/crates/horizon-mods/tests/index/glow-1.0.0.hshader new file mode 100644 index 000000000..dda1651f8 Binary files /dev/null and b/crates/horizon-mods/tests/index/glow-1.0.0.hshader differ diff --git a/crates/horizon-mods/tests/index/index-v1.json b/crates/horizon-mods/tests/index/index-v1.json index 215c94667..4f92c7c1d 100644 --- a/crates/horizon-mods/tests/index/index-v1.json +++ b/crates/horizon-mods/tests/index/index-v1.json @@ -29,6 +29,7 @@ "hud", "chat" ], + "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", @@ -75,6 +76,34 @@ } ] }, + { + "id": "glow", + "kind": "shader", + "name": "Soft Glow", + "summary": "A post-processing pass over the world.", + "authors": [ + "Horizon" + ], + "owners": [ + "ludovic111" + ], + "license": "MIT", + "source": "https://github.com/ludovic111/horizon-mods", + "versions": [ + { + "version": "1.0.0", + "published": "2026-10-26", + "api": "0.1", + "game": "26.3", + "file": { + "name": "glow-1.0.0.hshader", + "url": "https://github.com/ludovic111/horizon-mods/releases/download/glow-1.0.0/glow-1.0.0.hshader", + "size": 689, + "sha256": "331cfe29a666a0de804e9a9ff3d19d246eebcfbfa70b4f49bba8482d30ad9f02" + } + } + ] + }, { "id": "skyblock_start", "kind": "world", diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index 29577a9c6..c04de3204 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -2,8 +2,10 @@ //! examples and a guest //! that misbehaves on command. Needs `rustup target add wasm32-unknown-unknown`. use horizon_mods::{ - Clock, Corner, HeldItem, Mods, Output, Package, Player, Shape, Snapshot, Status, + BlockPos, Clock, Corner, GameMode, HeldItem, Mods, Output, Package, Player, Runs, ServerPlayer, + Shape, Snapshot, Status, manifest::componentize, + testing::{Script, TestGame}, }; use std::{ path::{Path, PathBuf}, @@ -43,6 +45,8 @@ fn mods_dir() -> &'static Path { "-p", "predator-missile", "-p", + "welcome", + "-p", "horizon-mods-test-guest", "-p", "horizon-mods-test-ui-guest", @@ -65,6 +69,7 @@ fn mods_dir() -> &'static Path { let mods = [ ("coords_hud", example("coords-hud")), ("predator_missile", example("predator-missile")), + ("welcome", example("welcome")), ("horizon_mods_test_guest", GUEST_MANIFEST.to_string()), ("horizon_mods_test_ui_guest", UI_MANIFEST.to_string()), ]; @@ -192,6 +197,65 @@ fn undeclared_capabilities_are_refused() { assert_eq!(mods.entries()[0].status, refused); } +/// A mod calling a function this Horizon doesn't have is refused with +/// "update Horizon", not a linking error; the test mods' levels are read +/// from the functions they import. +#[test] +fn a_mod_for_a_newer_horizon_is_refused() { + use horizon_mods::api_level::{LEVEL, imports, needed}; + use wit_parser::{ManglingAndAbi, Resolve}; + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit")) + .unwrap() + .replace( + " set-minimap: func(minimap: option);", + " set-minimap: func(minimap: option);\n set-sky: func(on: bool);", + ); + let mut resolve = Resolve::default(); + let package = resolve.push_str("horizon.wit", &wit).unwrap(); + let world = resolve + .select_world(&[package], Some("horizon-ui-mod")) + .unwrap(); + let mut module = wit_component::dummy_module(&resolve, world, ManglingAndAbi::Standard32); + wit_component::embed_component_metadata( + &mut module, + &resolve, + world, + wit_component::StringEncoding::UTF8, + ) + .unwrap(); + let wasm = wit_component::ComponentEncoder::default() + .module(&module) + .unwrap() + .encode() + .unwrap(); + let functions = imports(&wasm).unwrap(); + assert!(functions.iter().any(|f| f == "render.set-sky")); + let dir = mods_dir().join("too_new"); + std::fs::create_dir_all(&dir).unwrap(); + let manifest = r#" +id = "too_new" +name = "Too New" +version = "0.1.0" +api = "0.1" +capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"] +experimental = ["ui", "render", "input"] +"#; + std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap(); + std::fs::write(dir.join("mod.wasm"), wasm).unwrap(); + let mods = Mods::load(&[dir], |_| true, |_| false); + let refused = "made for a newer Horizon (it uses render.set-sky): update Horizon to run it"; + assert_eq!(mods.entries()[0].status, Status::Failed(refused.into())); + + let level = |file: &str| { + let wasm = Package::read(&mods_dir().join(file)).unwrap().wasm.unwrap(); + needed(imports(&wasm).unwrap().iter().map(String::as_str)).0 + }; + assert_eq!(level("coords_hud.hmod"), 0); + // The UI guest shows a minimap (`render.set-minimap`). + assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL); +} + #[test] fn vanilla_commands_win() { let mods = Mods::load( @@ -553,6 +617,43 @@ fn input_claims_keys_and_events() { assert_eq!(chat(&mut mods), ["key-down wheel", "key-up wheel"]); } +#[test] +fn the_players_key_choice_wins() { + let chat = |mods: &mut Mods| -> Vec { + mods.drain() + .into_iter() + .filter_map(|o| match o { + Output::Chat { text, .. } => Some(text), + _ => None, + }) + .collect() + }; + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + assert!(mods.command("input_claim")); + // Its keys alone give it a page in Options > Mods, where the game lists them. + assert!(mods.settings_widgets(0).is_empty() && mods.entries()[0].has_ui_settings()); + // Rebinding while held lets the old key go. + mods.key("key.keyboard.r", true); + assert!(mods.rebind(0, "wheel", "key.mouse.4")); + assert_eq!(mods.keys_of(0)[0].key, "key.mouse.4"); + mods.key("key.keyboard.r", false); + mods.key("key.mouse.4", true); + assert!(!mods.rebind(0, "wheel", "R") && !mods.rebind(0, "nope", "key.keyboard.g")); + chat(&mut mods); + assert!(mods.command("input_poll")); + assert_eq!( + chat(&mut mods), + ["key-down wheel", "key-up wheel", "key-down wheel"] + ); + // A choice saved earlier replaces the default, registered before or after. + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + mods.set_bindings(|_| vec![("wheel", "key.keyboard.g"), ("bad", "G")]); + assert!(mods.command("input_claim")); + assert_eq!(mods.keys_of(0)[0].key, "key.keyboard.g"); + mods.set_bindings(|_| vec![("wheel", "key.keyboard.h")]); + assert_eq!(mods.keys_of(0)[0].key, "key.keyboard.h"); +} + #[test] fn input_wheel_is_the_mods_while_claimed() { let mut mods = load("horizon_mods_test_ui_guest.hmod"); @@ -595,6 +696,32 @@ fn render_zoom_is_clamped_and_the_strongest_counts() { assert_eq!(zoom(&mut mods, "x 0 1"), None); } +#[test] +fn render_minimap_is_clamped_and_hidden() { + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + let map = |mods: &mut Mods, args: &str| { + assert!(mods.command(&format!("minimap {args}"))); + mods.minimap() + .map(|m| (m.corner, m.size, m.blocks_per_pixel, m.rotate, m.round)) + }; + assert!(mods.minimap().is_none()); + let corner = horizon_mods::RenderCorner::BottomLeft; + assert_eq!( + map(&mut mods, "96 2 1 0"), + Some((corner, 96.0, 2.0, true, false)) + ); + // The side and the scale are clamped; NaN takes the smallest. + assert_eq!( + map(&mut mods, "999 0.1 0 1"), + Some((corner, 256.0, 0.5, false, true)) + ); + assert_eq!( + map(&mut mods, "x 9 0 0"), + Some((corner, 16.0, 4.0, false, false)) + ); + assert_eq!(map(&mut mods, "off"), None); +} + #[test] fn corner_panels_text_width_and_readings() { let mut mods = load("horizon_mods_test_ui_guest.hmod"); @@ -666,3 +793,159 @@ capabilities = ["registries"] // Content has no hooks: the game's per-tick mod work stays skipped. assert!(!mods.is_running()); } + +/// `cargo horizon-mod test` on the examples: their own `tests/*.toml` pass. +#[test] +fn the_examples_test_scripts_pass() { + let examples = Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples"); + let mut ran = 0; + for (example, hmod) in [("coords-hud", "coords_hud"), ("welcome", "welcome")] { + for entry in std::fs::read_dir(examples.join(example).join("tests")).unwrap() { + let path = entry.unwrap().path(); + let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap(); + let mut game = TestGame::load(&mods_dir().join(format!("{hmod}.hmod"))).unwrap(); + script + .run(&mut game) + .unwrap_or_else(|e| panic!("{}: {e}", path.display())); + ran += 1; + } + } + assert_eq!(ran, 4); +} + +#[test] +fn a_test_script_says_which_step_failed_and_why() { + let script = Script::parse( + r#" + [[step]] + ticks = 3 + command = "hello there" + expect.chat = ["hello there after 2 ticks"] + "#, + ) + .unwrap(); + let mut game = TestGame::load(&mods_dir().join("horizon_mods_test_guest.hmod")).unwrap(); + assert_eq!( + script.run(&mut game).unwrap_err(), + "step 1 (3 ticks, /hello there): chat\n expected: [\"hello there after 2 ticks\"]\n \ + got: [\"hello there after 3 ticks\"]" + ); + assert!( + Script::parse("[[step]]\ntick = 1").is_err(), + "a typo is an error" + ); + + let mut game = TestGame::load(&mods_dir().join("welcome.hmod")).unwrap(); + let script = "[[step]]\njoin = \"Alex\"\n\n[[step]]\nas = \"Steve\"\ncommand = \"mined\""; + assert_eq!( + Script::parse(script).unwrap().run(&mut game).unwrap_err(), + "step 2 (/mined): Steve is not on the server" + ); +} + +#[test] +fn a_test_script_reloads_and_expects_a_stop() { + let script = Script::parse( + r#" + [[step]] + command = "save kept" + expect.feedback = "saved" + + [[step]] + reload = true + command = "load" + expect.chat = ["kept"] + + [[step]] + command = "panic" + expect.stopped = "panic" + + [[step]] + reload = true + command = "nope" + "#, + ) + .unwrap(); + let mut game = TestGame::load(&mods_dir().join("horizon_mods_test_guest.hmod")).unwrap(); + let dir = game.hmod().parent().unwrap().to_path_buf(); + assert_eq!( + script.run(&mut game).unwrap_err(), + "step 4 (reload, /nope): the mod owns no command /nope" + ); + drop(game); + assert!( + !dir.exists(), + "the scratch copy and its storage are removed" + ); +} + +fn alex() -> ServerPlayer { + ServerPlayer { + id: "00000000-0000-4000-8000-000000000001".into(), + name: "Alex".into(), + x: 0.5, + y: 64.0, + z: 0.5, + dimension: "minecraft:the_nether".into(), + game_mode: GameMode::Survival, + health: 20.0, + } +} + +#[test] +fn a_server_mod_runs_only_where_the_world_does() { + // A fresh folder: what the mod stored in an earlier run is beside it. + let dir = mods_dir().join("server"); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("welcome.hmod"); + std::fs::copy(mods_dir().join("welcome.hmod"), &path).unwrap(); + let paths = std::slice::from_ref(&path); + let window = Mods::load_for(Runs::Client, paths, |_| true, |_| false); + assert_eq!(window.entries()[0].status, Status::Elsewhere); + assert!(!window.is_running()); + + let mut mods = Mods::load_for(Runs::Server, paths, |_| true, |c| c == "give"); + assert!(mods.runs_server()); + assert_eq!( + mods.server_commands().collect::>(), + ["online", "mined"] + ); + assert_eq!(mods.commands().count(), 0, "not the window's chat commands"); + let alex = alex(); + mods.set_snapshot(Snapshot { + players: vec![alex.clone()], + ..Snapshot::default() + }); + mods.player_joined(&alex); + let greeted = [ + Output::Tell { + name: "Welcome".into(), + player: alex.id.clone(), + text: "Welcome, Alex! 0 other player(s) online.".into(), + }, + Output::Broadcast { + name: "Welcome".into(), + text: "Alex is here for the first time".into(), + }, + ]; + assert_eq!(mods.drain(), greeted); + let stone = BlockPos { x: 1, y: 63, z: 0 }; + mods.block_broken(&alex, stone, "minecraft:stone"); + assert!(mods.server_command(&alex, "mined")); + assert!(mods.server_command(&alex, "online")); + let reply = |text: &str| Output::Reply { + player: alex.id.clone(), + text: text.into(), + error: false, + }; + assert_eq!( + mods.drain(), + [reply("You broke 1 block(s)"), reply("Alex (the_nether)")] + ); + assert!(!mods.server_command(&alex, "where")); + assert!( + !mods.command("online"), + "a server command isn't the window's" + ); +} diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs index 9bede11f9..3d4c66076 100644 --- a/crates/horizon-mods/tests/ui_guest/src/lib.rs +++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs @@ -96,6 +96,7 @@ impl Mod for Guest { "input_held", "input_wheel", "zoom", + "minimap", "corner", "readings", ] @@ -198,6 +199,24 @@ impl Mod for Guest { turn, }); } + // `minimap off`, or `minimap SIZE BLOCKS-PER-PIXEL ROTATE ROUND`. + "minimap" => { + let words: Vec<&str> = args.split(' ').collect(); + let number = |i: usize| { + words + .get(i) + .and_then(|w| w.parse().ok()) + .unwrap_or(f32::NAN) + }; + let map = (args != "off").then(|| render::Minimap { + corner: render::Corner::BottomLeft, + size: number(0), + blocks_per_pixel: number(1), + rotate: words.get(2) == Some(&"1"), + round: words.get(3) == Some(&"1"), + }); + render::set_minimap(map); + } // Clamped to (1, 10); the two after it shake nothing. "render_shake" => { render::shake(2.0, 99.0); diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index 82dbf11af..a87f92ede 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -828,9 +828,9 @@ pub fn carry( // Additions to other sets and pools, as files the game merges. let modifier = serde_json::from_slice::(&bytes).ok(); let types = &mut report.worldgen_types; - if let Some((kind, mut added)) = modifier.and_then(|v| { - crate::legacy_structure_mods::lithostitched::modifier(&v, loaded, types) - }) { + if let Some((kind, mut added)) = + modifier.and_then(|v| crate::lithostitched::modifier(&v, loaded, types)) + { crate::processors::carry( kind, &mut added, diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs index af46174ae..62c25739f 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs @@ -157,6 +157,7 @@ mod tests { } #[test] + #[ignore = "modular compat is crate::lithostitched's now (its tests)"] fn modular_compat_runs_its_list_only_with_its_mod() { let mut data = ProcessorData::default(); let swap = json!({"processor_type": "minecraft:rule", "rules": []}); diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs b/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs deleted file mode 100644 index 54415a76a..000000000 --- a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs +++ /dev/null @@ -1,503 +0,0 @@ -//! Lithostitched: its jigsaw structure, its worldgen modifiers and its -//! processors. -use super::ctov; -use crate::processors::{ProcessorData, carry_all, processors, referenced}; -use crate::worldgen::{ENHANCED_TERRAIN, Upgrade, start_checks}; -use serde_json::{Value, json}; -use std::collections::BTreeMap; - -/// A `structure` file of Lithostitched's jigsaw type as vanilla's, with the -/// start rules it shares with the other libraries' jigsaws (`worldgen`'s -/// `start_checks`). `None` for any other file. -pub(crate) fn upgrade( - kind: &str, - v: &mut Value, - lost: &mut BTreeMap, -) -> Option { - if kind != "structure" || v["type"] != "lithostitched:jigsaw" { - return None; - } - start_checks(v, "lowest", lost, false); - if v.as_object_mut() - .and_then(|o| o.remove(ENHANCED_TERRAIN)) - .is_some() - { - *lost.entry(ENHANCED_TERRAIN.into()).or_default() += 1; - } - v["type"] = "minecraft:jigsaw".into(); - Some(true) -} - -/// A lithostitched worldgen modifier -/// (`data//lithostitched/worldgen_modifier/`) that adds to structure -/// sets or template pools, as a file the game merges into them (the key -/// `horizon:add_to`, `horizon_client::mod_content`): (kind, file). The -/// modifier's conditions are checked against `loaded`, the mods ported -/// along: a compat addition for a mod that is not would place that mod's -/// blocks, which the game does not have. Other modifier types are left out. -/// Both are counted in `report`. -pub(crate) fn modifier( - v: &Value, - loaded: &dyn Fn(&str) -> bool, - report: &mut Upgrade, -) -> Option<(&'static str, Value)> { - let t = v["type"].as_str().unwrap_or_default(); - let mut left = |why: &str| *report.modifiers_left.entry(why.to_owned()).or_default() += 1; - let (kind, targets, from, to) = match t { - "lithostitched:add_structure_set_entries" => { - ("structure_set", "structure_sets", "entries", "structures") - } - "lithostitched:add_template_pool_elements" => { - ("template_pool", "template_pools", "elements", "elements") - } - _ => { - left(t); - return None; - } - }; - if !conditions_hold(v, loaded) { - left("conditions"); - return None; - } - let targets: Option> = match &v[targets] { - Value::String(s) => Some(vec![s.as_str()]), - Value::Array(a) => a.iter().map(Value::as_str).collect(), - _ => None, - }; - let Some(targets) = targets.filter(|t| !t.is_empty() && t.iter().all(|t| !t.starts_with('#'))) - else { - left("target"); - return None; - }; - let entries = v[from].as_array().cloned().unwrap_or_default(); - for target in &targets { - *report.added_to.entry((*target).to_owned()).or_default() += entries.len(); - } - Some(( - kind, - serde_json::json!({"horizon:add_to": targets, to: entries}), - )) -} - -/// Whether a modifier's load conditions hold: lithostitched's `predicate`, -/// and the loader's conditions (NeoForge's, else Fabric's). A condition -/// type not known here does not hold. -fn conditions_hold(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let all = |list: &Value, test: &dyn Fn(&Value) -> bool| { - list.as_array().is_some_and(|a| a.iter().all(test)) - }; - fn predicate(p: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| predicate(q, loaded); - let list = &p["predicates"]; - match p["type"] - .as_str() - .map(|t| t.trim_start_matches("lithostitched:")) - { - Some("true") => true, - Some("mod_loaded") => p["mod_id"].as_str().is_some_and(loaded), - Some("not") => !predicate(&p["predicate"], loaded), - Some("all_of") => list.as_array().is_some_and(|a| a.iter().all(test)), - Some("any_of") => list.as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn neoforge(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| neoforge(q, loaded); - match c["type"].as_str() { - Some("neoforge:true") => true, - Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), - Some("neoforge:not") => !neoforge(&c["value"], loaded), - Some("neoforge:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("neoforge:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn fabric(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| fabric(q, loaded); - let mods = || { - c["values"] - .as_array() - .into_iter() - .flatten() - .map(Value::as_str) - }; - match c["condition"].as_str() { - Some("fabric:true") => true, - Some("fabric:all_mods_loaded") => mods().all(|m| m.is_some_and(loaded)), - Some("fabric:any_mods_loaded") => mods().any(|m| m.is_some_and(loaded)), - Some("fabric:not") => !fabric(&c["value"], loaded), - Some("fabric:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("fabric:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - let litho = v.get("predicate").is_none_or(|p| predicate(p, loaded)); - let loader = match ( - v.get("neoforge:conditions"), - v.get("fabric:load_conditions"), - ) { - (Some(c), _) => all(c, &|c| neoforge(c, loaded)), - // One condition or a list of them. - (None, Some(c)) if c.is_array() => all(c, &|c| fabric(c, loaded)), - (None, Some(c)) => fabric(c, loaded), - (None, None) => true, - }; - litho && loader -} - -/// The data form of one of Lithostitched's processors: the processors to put -/// in its place, or `None` when it has none (or is not Lithostitched's). -pub(crate) fn processor( - kind: &str, - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option> { - match kind { - "lithostitched:apply_random" => apply_random(p, data, carried).map(|p| vec![p]), - "lithostitched:condition" => condition(p, data, carried).map(|p| vec![p]), - "lithostitched:block_swap" => { - // The same map; the game's swap keeps the properties both have. - p["blocks"].as_object()?; - Some(vec![ - json!({"processor_type": "horizon:block_swap", "blocks": p["blocks"]}), - ]) - } - "lithostitched:set_block" => { - // A simple or weighted state provider, the block entity left as - // it is. - let provider = p["state_provider"]["type"].as_str()?; - let modifier = p["block_entity_modifier"]["type"].as_str(); - let plain = - modifier.is_none_or(|m| m.trim_start_matches("minecraft:") == "passthrough"); - if !plain - || !matches!( - provider, - "minecraft:simple_state_provider" | "minecraft:weighted_state_provider" - ) - { - return None; - } - let mut out = p.clone(); - out["processor_type"] = "horizon:set_block".into(); - if let Some(o) = out.as_object_mut() { - o.remove("block_entity_modifier"); - } - Some(vec![out]) - } - _ => None, - } -} - -/// The references (Lithostitched's, and CTOV's compat processors) in a -/// processor list written in; whether any was. -pub(crate) fn expand_references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> (Vec, bool) { - references(list, data, carried, 0) -} - -/// A processor list inside a carried processor: an id stays (the game reads -/// that file, carried on its own); an inline one is carried here. -fn nested(list: &Value, data: &ProcessorData, carried: &mut BTreeMap) -> Value { - let mut list = list.clone(); - if let Some(ps) = processors(&mut list) { - *ps = carry_all(std::mem::take(ps), data, carried).0; - } - list -} - -/// Lithostitched's `apply_random` as `horizon:apply_random`: its weighted -/// lists, or its set of lists at weight 1. A tag is not carried. -fn apply_random( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - let lists = &p["processor_lists"]; - let weighted = lists.as_array().is_some_and(|a| { - a.iter() - .all(|e| e.get("weight").is_some() && e.get("data").is_some()) - }); - let entries: Vec<(Value, Value)> = if weighted { - lists - .as_array()? - .iter() - .map(|e| (e["weight"].clone(), e["data"].clone())) - .collect() - } else { - match lists { - Value::String(id) if !id.starts_with('#') => vec![(1.into(), lists.clone())], - Value::Array(a) if a.iter().any(|x| x.get("processor_type").is_some()) => { - vec![(1.into(), lists.clone())] - } - Value::Array(a) - if a.iter() - .all(|x| x.as_str().is_some_and(|s| !s.starts_with('#')) || x.is_object()) => - { - a.iter().map(|x| (1.into(), x.clone())).collect() - } - Value::Object(_) => vec![(1.into(), lists.clone())], - _ => return None, - } - }; - let lists: Vec = entries - .into_iter() - .map(|(weight, list)| json!({"weight": weight, "data": nested(&list, data, carried)})) - .collect(); - let mut out = json!({"processor_type": "horizon:apply_random", "processor_lists": lists}); - if let Some(mode) = p.get("mode") { - out["mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's `condition` as `horizon:condition`, when the game runs -/// every condition in it (true, all_of, any_of, not, random_chance, -/// matching_blocks with plain property values); else it stays Java. -fn condition( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - fn runs(c: &Value) -> bool { - if let Some(all) = c.as_array() { - return all.iter().all(runs); - } - let kind = c["type"].as_str().unwrap_or_default(); - match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" | "random_chance" => true, - "all_of" | "any_of" => c["conditions"] - .as_array() - .is_some_and(|a| a.iter().all(runs)), - "not" => runs(&c["condition"]), - "matching_blocks" => c.get("properties").is_none_or(|p| { - p.as_object() - .is_some_and(|o| o.values().all(Value::is_string)) - }), - _ => false, - } - } - if !runs(&p["if_true"]) { - return None; - } - // One processor or a list of them. - let mut branch = |key: &str| -> Value { - let list = match p.get(key) { - None => Vec::new(), - Some(Value::Array(a)) => a.clone(), - Some(one) => vec![one.clone()], - }; - carry_all(list, data, carried).0.into() - }; - let (then, otherwise) = (branch("then"), branch("else")); - let mut out = json!({"processor_type": "horizon:condition", "if_true": p["if_true"], - "then": then, "else": otherwise}); - if let Some(mode) = p.get("random_mode") { - out["random_mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's references in a list, each replaced by the processors of -/// the lists it names, in order (references in them too, to a depth of 8). -/// One naming a tag or a list the mod does not have stays, to be dropped. -/// Whether any was replaced. -fn references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, - depth: usize, -) -> (Vec, bool) { - let mut out = Vec::with_capacity(list.len()); - let mut changed = false; - for p in list { - if let Some(inner) = ctov::modular_compat(&p, data, carried, depth) { - changed = true; - out.extend(references(inner, data, carried, depth + 1).0); - continue; - } - let named = (p["processor_type"] == "lithostitched:reference" && depth < 8) - .then(|| referenced(&p["processor_lists"], data)) - .flatten(); - match named { - Some(inner) => { - *carried.entry("lithostitched:reference".into()).or_default() += 1; - out.extend(references(inner, data, carried, depth + 1).0); - changed = true; - } - None => out.push(p), - } - } - (out, changed) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::legacy_structure_mods::data; - use crate::processors::carry; - - #[test] - fn modifiers_add_to_sets_and_pools() { - let mut report = Upgrade::default(); - let only_fd = |m: &str| m == "farmersdelight"; - let set = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "minecraft:villages", - "entries": [{"structure": "x:village", "weight": 4}]}); - let (kind, added) = modifier(&set, &only_fd, &mut report).unwrap(); - assert_eq!(kind, "structure_set"); - assert_eq!( - added, - json!({"horizon:add_to": ["minecraft:villages"], - "structures": [{"structure": "x:village", "weight": 4}]}) - ); - // A compat addition holds only when its mod is ported along. - let pool = |modid: &str| { - json!({"type": "lithostitched:add_template_pool_elements", - "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}], - "fabric:load_conditions": {"condition": "fabric:all_mods_loaded", "values": ["other"]}, - "template_pools": ["x:houses", "y:houses"], - "elements": [{"weight": 5, "element": {"element_type": "minecraft:single_pool_element", - "location": "x:fd_farm", "projection": "rigid", "processors": "minecraft:empty"}}]}) - }; - let (kind, added) = modifier(&pool("farmersdelight"), &only_fd, &mut report).unwrap(); - assert_eq!(kind, "template_pool"); - assert_eq!(added["horizon:add_to"], json!(["x:houses", "y:houses"])); - assert_eq!(added["elements"][0]["weight"], 5); - assert!(modifier(&pool("create"), &only_fd, &mut report).is_none()); - // Fabric's conditions when there are no NeoForge ones; lithostitched's own. - let fabric = json!({"type": "lithostitched:add_structure_set_entries", - "fabric:load_conditions": [{"condition": "fabric:not", - "value": {"condition": "fabric:any_mods_loaded", "values": ["create"]}}], - "predicate": {"type": "lithostitched:all_of", "predicates": [ - {"type": "lithostitched:mod_loaded", "mod_id": "farmersdelight"}, - {"type": "lithostitched:true"}]}, - "structure_sets": "minecraft:villages", "entries": []}); - assert!(modifier(&fabric, &only_fd, &mut report).is_some()); - let tagged = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "#x:sets", "entries": []}); - assert!(modifier(&tagged, &only_fd, &mut report).is_none()); - let features = json!({"type": "lithostitched:add_features"}); - assert!(modifier(&features, &only_fd, &mut report).is_none()); - assert_eq!( - report.added_to, - BTreeMap::from([ - ("minecraft:villages".into(), 1), - ("x:houses".into(), 1), - ("y:houses".into(), 1), - ]) - ); - assert_eq!( - report.modifiers_left, - BTreeMap::from([ - ("conditions".into(), 1), - ("lithostitched:add_features".into(), 1), - ("target".into(), 1), - ]) - ); - } - - #[test] - fn lithostitched_block_swaps_become_the_games() { - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}, - {"processor_type": "lithostitched:block_swap", "blocks": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data(), &mut carried)); - let p = list["processors"].as_array().unwrap(); - assert_eq!( - p[0], - json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}) - ); - // A map that is not one stays Java (dropped later). - assert_eq!(p[1]["processor_type"], "lithostitched:block_swap"); - } - - #[test] - fn lithostitched_references_are_written_in() { - let mut data = data(); - let gravity = json!({"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": 0}); - data.lists - .insert("v:road".into(), json!({"processors": [gravity.clone()]})); - data.lists.insert( - "v:house".into(), - json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:road"}, - {"processor_type": "lithostitched:block_swap", "blocks": {"minecraft:dirt": "minecraft:grass_block"}}]}), - ); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": ["v:house", "v:road"]}, - {"processor_type": "lithostitched:reference", "processor_lists": "#v:roads"}, - {"processor_type": "lithostitched:reference", "processor_lists": ["v:nowhere"]}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - // House (its own reference to road first, then its swap), then road; - // the swap inside is carried too. - assert_eq!(p[0], gravity); - assert_eq!(p[1]["processor_type"], "horizon:block_swap"); - assert_eq!(p[2], gravity); - // A tag or a list the mod lacks stays, to be dropped. - assert_eq!(p[3]["processor_lists"], "#v:roads"); - assert_eq!(p[4]["processor_lists"], json!(["v:nowhere"])); - assert_eq!(carried["lithostitched:reference"], 2); - } - - #[test] - fn lithostitched_random_and_condition_become_the_games() { - let mut data = data(); - let swap = json!({"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - data.lists - .insert("v:green".into(), json!({"processors": [swap.clone()]})); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:green"}, - {"processor_type": "v:java"}]}}]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": ["v:green", "v:red"]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": "#v:colours"}, - {"processor_type": "lithostitched:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": swap, "else": {"processor_type": "lithostitched:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}}, - {"processor_type": "lithostitched:condition", - "if_true": {"type": "lithostitched:matching_biomes", "biomes": "#c:is_cold"}, - "then": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - let green = json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - // Inline lists are carried; Java left in them is dropped later. - assert_eq!( - p[0], - json!({"processor_type": "horizon:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [green.clone(), {"processor_type": "v:java"}]}}]}) - ); - assert_eq!( - p[1]["processor_lists"], - json!([{"weight": 1, "data": "v:green"}, {"weight": 1, "data": "v:red"}]) - ); - assert_eq!(p[2]["processor_type"], "lithostitched:apply_random"); - assert_eq!( - p[3], - json!({"processor_type": "horizon:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": [green], "else": [{"processor_type": "horizon:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}]}) - ); - assert_eq!(p[4]["processor_type"], "lithostitched:condition"); - assert_eq!(carried["lithostitched:apply_random"], 2); - assert_eq!(carried["lithostitched:condition"], 1); - } -} diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs index 1faa1b39f..980798720 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs @@ -13,10 +13,11 @@ //! The general code reaches them only through the `pub(crate)` entry points //! of these three modules. Nothing in them is used by another mod's //! conversion. +#[allow(dead_code)] // its modular compat is `crate::lithostitched`'s now; the rest goes with C1 pub(crate) mod ctov; -pub(crate) mod lithostitched; #[cfg(test)] +#[allow(dead_code)] // the old Lithostitched tests used it fn data() -> crate::processors::ProcessorData { let mut d = crate::processors::ProcessorData::default(); d.spawners.insert( diff --git a/crates/horizon-port-pack/src/lib.rs b/crates/horizon-port-pack/src/lib.rs index 3b17f1c9c..b47c93754 100644 --- a/crates/horizon-port-pack/src/lib.rs +++ b/crates/horizon-port-pack/src/lib.rs @@ -14,6 +14,7 @@ pub mod import; pub mod inventory; pub mod jar; pub(crate) mod legacy_structure_mods; +mod lithostitched; pub mod modrinth; pub mod oracle; pub mod pipeline; diff --git a/crates/horizon-port-pack/src/lithostitched.rs b/crates/horizon-port-pack/src/lithostitched.rs new file mode 100644 index 000000000..e65efcf0e --- /dev/null +++ b/crates/horizon-port-pack/src/lithostitched.rs @@ -0,0 +1,434 @@ +//! Lithostitched's worldgen, carried as the game reads it (clean room: +//! `cleanroom/structures/spec-lithostitched.md`; CTOV's processor: +//! `spec-ctov.md` §4). +//! +//! - `lithostitched:jigsaw` structures become vanilla's jigsaw. Lithostitched +//! lays jigsaws out its own way (OPEN-L5): Horizon keeps vanilla's layouts. +//! - Its processors (`block_swap`, `reference`, `apply_random`, `condition`, +//! `set_block`, `discard_input`) are the game's own types +//! (`horizon_world`'s `structure::processor`): they are carried as written, +//! the processors nested in them carried in turn. CTOV's +//! `ctov:modular_compat` (a reference that runs only when its mod is loaded) +//! becomes a `reference` when the mod is ported along, else nothing. +//! - `add_template_pool_elements` modifiers become `horizon:add_to` pool files +//! (`docs/mods.md`), when their load conditions pass. Lithostitched's own +//! pool elements (`limited`, `guaranteed`, `delegating`) place their +//! `delegate`; what they add to it is counted as lost. +use crate::{processors::ProcessorData, worldgen::Upgrade}; +use serde_json::{Value, json}; +use std::collections::BTreeMap; + +const JIGSAW: &str = "lithostitched:jigsaw"; +/// Vanilla's JigsawStructure.MAX_DEPTH. +const MAX_SIZE: i64 = 20; +const MODULAR_COMPAT: &str = "ctov:modular_compat"; +/// The processor types the game reads. +const PROCESSORS: [&str; 6] = [ + "lithostitched:block_swap", + "lithostitched:reference", + "lithostitched:apply_random", + "lithostitched:condition", + "lithostitched:set_block", + "lithostitched:discard_input", +]; + +fn count(map: &mut BTreeMap, name: &str) { + *map.entry(name.to_owned()).or_default() += 1; +} + +/// A `lithostitched:jigsaw` structure as vanilla's jigsaw: `Some(true)`, else +/// `None`. +pub(crate) fn upgrade( + kind: &str, + v: &mut Value, + lost: &mut BTreeMap, +) -> Option { + if kind != "structure" || v["type"] != JIGSAW { + return None; + } + v["type"] = "minecraft:jigsaw".into(); + // `size` may be an int provider (sampled per start): its largest value. + let size = match &v["size"] { + Value::Null => None, + Value::Number(n) => n.as_i64(), + provider => { + count(lost, "lithostitched:jigsaw size provider"); + ["max_inclusive", "value"] + .iter() + .find_map(|k| provider[k].as_i64()) + } + }; + if let Some(size) = size { + if size > MAX_SIZE { + count(lost, "lithostitched:jigsaw size over 20"); + } + v["size"] = size.clamp(0, MAX_SIZE).into(); + } + let o = v.as_object_mut()?; + match o.remove("start_projection") { + Some(Value::String(heightmap)) if heightmap != "floor" && heightmap != "ceiling" => { + o.entry("project_start_to_heightmap") + .or_insert(heightmap.into()); + } + Some(_) => count(lost, "lithostitched:jigsaw start_projection"), + None => {} + } + if o.remove("fixed_rotation").is_some_and(|f| f == true) { + count(lost, "lithostitched:jigsaw fixed_rotation"); + } + Some(true) +} + +/// Lithostitched's pool elements as the element they wrap; whether `element` +/// was one. +pub(crate) fn upgrade_pool_element( + element: &mut Value, + lost: &mut BTreeMap, +) -> bool { + let Some(kind) = element["element_type"].as_str() else { + return false; + }; + match kind { + "lithostitched:limited" | "lithostitched:guaranteed" | "lithostitched:delegating" => { + count(lost, kind); + let delegate = element["delegate"].take(); + *element = delegate; + // A delegate wrapping another (only `delegating` allows it). + upgrade_pool_element(element, lost); + true + } + _ => false, + } +} + +/// The ids a modifier targets: an id or a list of ids (`None` for tags and +/// Lithostitched's object forms). +fn ids(v: &Value) -> Option> { + let id = |v: &Value| { + v.as_str() + .filter(|s| !s.starts_with('#')) + .map(str::to_owned) + }; + match v { + Value::Array(a) => a.iter().map(id).collect(), + other => Some(vec![id(other)?]), + } +} + +/// NeoForge's load conditions (`neoforge:conditions`): all must pass. +fn conditions_pass(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + fn pass(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + let all = |key: &str| { + c[key] + .as_array() + .into_iter() + .flatten() + .all(|c| pass(c, loaded)) + }; + match c["type"].as_str() { + Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), + Some("neoforge:true") => true, + Some("neoforge:not") => !pass(&c["value"], loaded), + Some("neoforge:and") => all("values"), + Some("neoforge:or") => { + (c["values"].as_array().into_iter().flatten()).any(|c| pass(c, loaded)) + } + _ => false, + } + } + (v["neoforge:conditions"].as_array().into_iter().flatten()).all(|c| pass(c, loaded)) +} + +/// A worldgen modifier as a file the game merges: `("template_pool", file)` +/// for `add_template_pool_elements`; the others are counted in +/// `report.modifiers_left`. +pub(crate) fn modifier( + v: &Value, + loaded: &dyn Fn(&str) -> bool, + report: &mut Upgrade, +) -> Option<(&'static str, Value)> { + let kind = v["type"].as_str().unwrap_or("no type"); + if !conditions_pass(v, loaded) { + count(&mut report.modifiers_left, "conditions"); + return None; + } + if kind != "lithostitched:add_template_pool_elements" { + count(&mut report.modifiers_left, kind); + return None; + } + let (Some(targets), Some(elements)) = (ids(&v["template_pools"]), v["elements"].as_array()) + else { + count(&mut report.modifiers_left, "target"); + return None; + }; + for target in &targets { + *report.added_to.entry(target.clone()).or_default() += elements.len(); + } + Some(( + "template_pool", + json!({"horizon:add_to": targets, "elements": elements}), + )) +} + +/// Whether the game reads a Lithostitched processor as it is: one of its +/// types, with no processor list named by tag (the game has no processor +/// list tags) and a state provider it runs. +pub(crate) fn game_reads(p: &Value) -> bool { + let Some(kind) = p["processor_type"] + .as_str() + .filter(|t| PROCESSORS.contains(t)) + else { + return false; + }; + let tag = |v: &Value| v.as_str().is_some_and(|s| s.starts_with('#')); + match kind { + "lithostitched:reference" => match &p["processor_lists"] { + Value::Array(a) => !a.iter().any(tag), + other => other.is_string() && !tag(other), + }, + "lithostitched:apply_random" => p["processor_lists"] + .as_array() + .is_some_and(|a| a.iter().all(|e| !tag(e) && !tag(&e["data"]))), + "lithostitched:set_block" => matches!( + p["state_provider"]["type"].as_str(), + Some("minecraft:simple_state_provider" | "minecraft:weighted_state_provider") + ), + "lithostitched:block_swap" => p["blocks"].is_object(), + "lithostitched:condition" => !p["if_true"].is_null(), + _ => true, + } +} + +/// The processor lists inside a Lithostitched processor, for the general +/// code that walks lists (`then`, `else`, `apply_random`'s inline data). +pub(crate) fn inner_lists(p: &mut Value) -> Vec<&mut Value> { + match p["processor_type"].as_str() { + Some("lithostitched:apply_random") => (p["processor_lists"].as_array_mut().into_iter()) + .flatten() + .filter_map(|e| e.get_mut("data").filter(|d| !d.is_string())) + .collect(), + Some("lithostitched:condition") => (p.as_object_mut().into_iter()) + .flat_map(|o| o.iter_mut()) + .filter(|(k, _)| *k == "then" || *k == "else") + .map(|(_, v)| v) + .collect(), + _ => Vec::new(), + } +} + +/// A Lithostitched processor with the processors nested in it carried +/// (`Some`, when one of them changed); `None` for any other processor. +pub(crate) fn processor( + kind: &str, + p: &Value, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> Option> { + if !PROCESSORS.contains(&kind) { + return None; + } + let mut out = p.clone(); + let mut changed = false; + for list in inner_lists(&mut out) { + // One processor alone is a list of one. + if list.get("processor_type").is_some() { + *list = Value::Array(vec![list.take()]); + changed = true; + } + if let Some(processors) = crate::processors::processors(list) { + let (inner, inner_changed) = + crate::processors::carry_all(std::mem::take(processors), data, carried); + *processors = inner; + changed |= inner_changed; + } + } + changed.then(|| vec![out]) +} + +/// The list with CTOV's modular compat processors written as the game's +/// `reference` (its mod is ported along) or taken out; whether any was. +pub(crate) fn expand_references( + list: Vec, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> (Vec, bool) { + let mut changed = false; + let mut out = Vec::with_capacity(list.len()); + for p in list { + if p["processor_type"] != MODULAR_COMPAT { + out.push(p); + continue; + } + changed = true; + count(carried, MODULAR_COMPAT); + let loaded = p["modid"] + .as_str() + .is_some_and(|m| data.compat_loaded.contains(m)); + if loaded { + out.push(json!({"processor_type": "lithostitched:reference", + "processor_lists": p["reference"].clone()})); + } + } + (out, changed) +} + +/// Notes which mods CTOV's modular compat processors name are `loaded`. +pub(crate) fn mark_loaded(data: &mut ProcessorData, loaded: &dyn Fn(&str) -> bool) { + fn visit(v: &Value, out: &mut Vec) { + match v { + Value::Object(o) => { + if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT) + && let Some(m) = o.get("modid").and_then(Value::as_str) + { + out.push(m.to_owned()); + } + o.values().for_each(|v| visit(v, out)); + } + Value::Array(a) => a.iter().for_each(|v| visit(v, out)), + _ => {} + } + } + let mut named = Vec::new(); + data.lists.values().for_each(|l| visit(l, &mut named)); + data.compat_loaded + .extend(named.into_iter().filter(|m| loaded(m))); +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::worldgen::upgrade as upgrade_file; + + #[test] + fn jigsaws_become_vanillas() { + let mut lost = BTreeMap::new(); + let mut s = json!({"type": JIGSAW, "size": {"type": "uniform", "min_inclusive": 3, + "max_inclusive": 40}, "start_projection": "WORLD_SURFACE_WG", "fixed_rotation": true}); + assert_eq!(upgrade("structure", &mut s, &mut lost), Some(true)); + assert_eq!( + s, + json!({"type": "minecraft:jigsaw", "size": 20, + "project_start_to_heightmap": "WORLD_SURFACE_WG"}) + ); + assert_eq!(lost.len(), 3); + assert_eq!( + upgrade( + "structure", + &mut json!({"type": "minecraft:jigsaw"}), + &mut lost + ), + None + ); + } + + #[test] + fn wrapped_elements_place_their_delegate() { + let mut lost = BTreeMap::new(); + let delegate = json!({"element_type": "minecraft:single_pool_element", "location": "a:b", + "projection": "rigid", "processors": "minecraft:empty"}); + let mut e = + json!({"element_type": "lithostitched:limited", "limit": 1, "delegate": delegate}); + assert!(upgrade_pool_element(&mut e, &mut lost)); + assert_eq!(e, delegate); + assert_eq!(lost["lithostitched:limited"], 1); + assert!(!upgrade_pool_element(&mut e, &mut lost)); + } + + #[test] + fn modifiers_add_to_pools_when_their_mods_are_loaded() { + let mut report = Upgrade::default(); + let loaded = |m: &str| m == "waystones"; + let add = |modid: &str, pools: Value| { + json!({"type": "lithostitched:add_template_pool_elements", "template_pools": pools, + "elements": [{"weight": 2, "element": {"element_type": "minecraft:empty_pool_element"}}], + "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}]}) + }; + let (kind, file) = modifier( + &add("waystones", json!("ctov:village/plains/house")), + &loaded, + &mut report, + ) + .unwrap(); + assert_eq!(kind, "template_pool"); + assert_eq!(file["horizon:add_to"], json!(["ctov:village/plains/house"])); + assert_eq!(file["elements"][0]["weight"], 2); + assert_eq!(report.added_to["ctov:village/plains/house"], 1); + assert!(modifier(&add("sawmill", json!("a:b")), &loaded, &mut report).is_none()); + assert!(modifier(&add("waystones", json!("#a:pools")), &loaded, &mut report).is_none()); + let aliases = json!({"type": "lithostitched:set_pool_aliases"}); + assert!(modifier(&aliases, &loaded, &mut report).is_none()); + assert_eq!( + report.modifiers_left, + BTreeMap::from([ + ("conditions".into(), 1), + ("lithostitched:set_pool_aliases".into(), 1), + ("target".into(), 1), + ]) + ); + } + + /// A CTOV list (spec-ctov §4): references, a condition with a single + /// processor and a nested condition, a random list holding the compat + /// hook, and processors the game cannot read. + #[test] + fn processors_stay_lithostitcheds_with_their_insides_carried() { + let hook = json!({"processor_type": MODULAR_COMPAT, "modid": "natures_spirit", + "reference": "ctov:village/mesa/house_wisteria"}); + let list = json!({"processors": [ + {"processor_type": "lithostitched:reference", "processor_lists": ["ctov:village/mesa/house"]}, + {"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", + "match_type": "location"}, + "then": {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:spruce_planks"}}}, + "else": [{"processor_type": "somemod:java_processor"}]}, + {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ + {"weight": 1, "data": "minecraft:empty"}, + {"weight": 1, "data": {"processors": [hook]}}]}, + {"processor_type": "lithostitched:reference", "processor_lists": "#ctov:palettes"}, + {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:noise_provider"}}]}); + for (loaded, wisteria) in [ + (false, json!([])), + ( + true, + json!([{"processor_type": + "lithostitched:reference", "processor_lists": "ctov:village/mesa/house_wisteria"}]), + ), + ] { + let mut data = ProcessorData::default(); + data.lists + .insert("ctov:village/mesa/house".into(), list.clone()); + mark_loaded(&mut data, &|m| loaded && m == "natures_spirit"); + let mut v = list.clone(); + let mut report = Upgrade::default(); + crate::processors::carry( + "processor_list", + &mut v, + &data, + &mut report.processors_carried, + ); + upgrade_file("processor_list", &mut v, &mut report, &BTreeMap::new()); + let p = &v["processors"]; + assert_eq!(p.as_array().unwrap().len(), 3, "{p}"); + assert_eq!(p[0], list["processors"][0]); + // One processor is a list of one; the Java one is taken out. + assert_eq!( + p[1]["then"][0]["state_provider"]["state"]["id"], + "minecraft:spruce_planks" + ); + assert_eq!(p[1]["else"], json!([])); + assert_eq!(p[2]["processor_lists"][0]["data"], "minecraft:empty"); + assert_eq!(p[2]["processor_lists"][1]["data"]["processors"], wisteria); + assert_eq!(report.processors_carried[MODULAR_COMPAT], 1); + assert_eq!( + report.processors_dropped, + BTreeMap::from([ + ("lithostitched:reference".into(), 1), + ("lithostitched:set_block".into(), 1), + ("somemod:java_processor".into(), 1), + ]) + ); + } + } +} diff --git a/crates/horizon-port-pack/src/processors.rs b/crates/horizon-port-pack/src/processors.rs index af1595f92..046eaa0bf 100644 --- a/crates/horizon-port-pack/src/processors.rs +++ b/crates/horizon-port-pack/src/processors.rs @@ -10,13 +10,13 @@ //! - Repurposed Structures' mineshaft sky view becomes the game's //! `horizon:mineshaft_sky_view`. //! -//! The processors of YUNG's mods, Lithostitched and Choice Theorem's Overhauled -//! Village are carried by `legacy_structure_mods`, called from [`carry`]. +//! Lithostitched's processors and Choice Theorem's Overhauled Village's +//! compat hook are carried by `crate::lithostitched`, called from [`carry`]. //! //! What is not here is taken out of its list later and counted //! (`worldgen::upgrade`). The entity NBT is written in 26.3's shape (an //! `equipment` map, not 1.21.1's `HandItems` and `ArmorItems`). -use crate::legacy_structure_mods::{ctov, lithostitched}; +use crate::lithostitched; use serde_json::{Value, json}; use std::{ collections::{BTreeMap, BTreeSet}, @@ -42,7 +42,7 @@ pub struct ProcessorData { impl ProcessorData { /// Notes which mods its compat processors name are `loaded`. pub fn mark_loaded(&mut self, loaded: &dyn Fn(&str) -> bool) { - ctov::mark_loaded(self, loaded); + lithostitched::mark_loaded(self, loaded); } pub fn read(zip: &mut zip::ZipArchive) -> Self { @@ -177,8 +177,7 @@ fn carry_at( let mut out = Vec::with_capacity(expanded.len()); for p in expanded { let kind = p["processor_type"].as_str().unwrap_or_default().to_owned(); - // Lithostitched's processors are carried apart from this code - // (`legacy_structure_mods`). + // Lithostitched's processors stay theirs, with what they hold carried. let replacement = lithostitched::processor(&kind, &p, data, carried).or_else(|| { match pillar_type(&kind) { Some(to) => Some(vec![pillar(&p, to, data, carried, depth)]), diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index 298179acf..0e3d968e3 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -15,10 +15,10 @@ //! closely. //! //! YUNG's API's files are carried as written ([`crate::yung`]). -//! Lithostitched's and CTOV's worldgen files are converted by -//! `legacy_structure_mods`, called from [`upgrade`], [`crate::carry`] and the -//! processors. -use crate::{legacy_structure_mods::lithostitched, yung}; +//! Lithostitched's jigsaws, elements, modifiers and processors are carried by +//! [`crate::lithostitched`]; the entries CTOV adds to vanilla's structure sets +//! by `legacy_structure_mods`, called from [`crate::carry`]. +use crate::{lithostitched, yung}; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet}, @@ -191,28 +191,19 @@ fn drop_java_processors(list: &mut Value, dropped: &mut BTreeMap) let before = processors.len(); processors.retain(|p| { let t = p["processor_type"].as_str().unwrap_or_default(); - let java = !t.starts_with("minecraft:") && !t.starts_with("horizon:"); + let java = !t.starts_with("minecraft:") + && !t.starts_with("horizon:") + && !lithostitched::game_reads(p); if java { *dropped.entry(t.to_owned()).or_default() += 1; } !java }); let mut changed = processors.len() != before; - // The inline lists inside the game's apply_random and condition. + // The inline lists inside Lithostitched's apply_random and condition. for p in processors.iter_mut() { let inner: Vec<&mut Value> = match p["processor_type"].as_str() { - Some("horizon:apply_random") => p["processor_lists"] - .as_array_mut() - .into_iter() - .flatten() - .map(|e| &mut e["data"]) - .collect(), - Some("horizon:condition") => { - let o = p.as_object_mut().into_iter().flat_map(|o| o.iter_mut()); - o.filter(|(k, _)| *k == "then" || *k == "else") - .map(|(_, v)| v) - .collect() - } + Some(t) if t.starts_with("lithostitched:") => lithostitched::inner_lists(p), Some("horizon:pillar" | "horizon:bottom_pillar") => { p.get_mut("pillar_processor_list").into_iter().collect() } @@ -398,7 +389,9 @@ fn upgrade_types( } } for element in elements { - if yung::upgrade_pool_element(element, lost) { + if yung::upgrade_pool_element(element, lost) + || lithostitched::upgrade_pool_element(element, lost) + { changed = true; continue; } diff --git a/crates/horizon-shader-api/src/check.rs b/crates/horizon-shader-api/src/check.rs index 6c43718f7..c3ecdd158 100644 --- a/crates/horizon-shader-api/src/check.rs +++ b/crates/horizon-shader-api/src/check.rs @@ -60,6 +60,10 @@ pub struct CheckedStage { pub label: String, pub module: naga::Module, pub info: ModuleInfo, + /// The stage's WGSL without the entry points (the prelude, the shared + /// files, the file), for a renderer that calls the stage function from + /// its own shader (the sky). + pub source: String, pub expressions: usize, pub texture_reads: usize, } @@ -169,6 +173,7 @@ pub fn check_stage(pack: &Pack, kind: StageKind, file: &str) -> Result, random: &mut impl ProcessorRandom) -> Option { + match self { + Self::Passthrough => nbt.cloned(), + Self::Clear => Some(Compound::new()), + Self::AppendLoot(table) => { + let mut nbt = nbt.cloned().unwrap_or_default(); + nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); + nbt.insert("LootTableSeed".into(), Tag::Long(random.long())); + Some(nbt) + } + Self::AppendStatic(data) => Some(edited(nbt, &[], data)), + Self::Edit { remove, data } => Some(edited(nbt, remove, data)), + } + } +} /// A block entity with `remove`'s keys taken out and `data` merged in /// (append_static is the one with nothing to remove). fn edited(nbt: Option<&Compound>, remove: &[String], data: &Compound) -> Compound { @@ -292,17 +309,21 @@ pub enum Processor { SpawnerMobs(Box), Pick(Box), CountCap(Box), - /// `horizon:block_swap` (Lithostitched's `block_swap`): blocks by name - /// become others, keeping the properties both have. + /// `lithostitched:block_swap`: blocks by name become others, keeping + /// the properties both have (a block the game lacks is left alone). BlockSwap(std::collections::BTreeMap), - /// `horizon:apply_random` (Lithostitched's `apply_random`): a processor - /// list drawn by weight runs on the block. - ApplyRandom(Box), - /// `horizon:condition` (Lithostitched's `condition`): `then` or `else` + /// `lithostitched:apply_random`: a processor list drawn by weight runs + /// on the block. + ApplyRandom(Box), + /// `lithostitched:reference`: the named lists run on the block in turn. + Reference(Vec), + /// `lithostitched:discard_input`: the world's block stays. + DiscardInput, + /// `lithostitched:condition`: `then` or `else` /// runs on the block, by a test of it. - Condition(Box), - /// `horizon:set_block` (Lithostitched's `set_block`). - SetBlock(Box), + Condition(Box), + /// `lithostitched:set_block`: the block from a state provider. + SetBlock(Box), /// `horizon:pillar` (Repurposed Structures' and Moog's pillars): a /// trigger block starts a column down to the ground. Pillar(Box), @@ -786,7 +807,7 @@ impl Processor { })?)) } "horizon:pick" => Self::Pick(Box::new(Pick::decode(value, state)?)), - "horizon:block_swap" => Self::BlockSwap( + "lithostitched:block_swap" => Self::BlockSwap( value["blocks"] .as_object() .ok_or(DecodeError::Field("blocks"))? @@ -801,12 +822,16 @@ impl Processor { .collect::>()?, ), "horizon:count_cap" => Self::CountCap(Box::new(CountCap::decode(value, state)?)), - "horizon:apply_random" => Self::ApplyRandom(Box::new( - lithostitched::ApplyRandom::decode(value, resources, bindings)?, + "lithostitched:apply_random" => Self::ApplyRandom(Box::new( + litho::ApplyRandom::decode(value, resources, bindings)?, )), - "horizon:set_block" => { - Self::SetBlock(Box::new(lithostitched::SetBlock::decode(value, state)?)) + "lithostitched:set_block" => { + Self::SetBlock(Box::new(litho::SetBlock::decode(value, state)?)) } + "lithostitched:reference" => { + Self::Reference(litho::reference(value, resources, bindings)?) + } + "lithostitched:discard_input" => Self::DiscardInput, "horizon:pillar" => Self::Pillar(Box::new(pillars::Pillar::decode( value, resources, bindings, state, )?)), @@ -834,7 +859,7 @@ impl Processor { "horizon:keep_world_block" => { Self::KeepWorldBlock(Box::new(sea_level::KeepWorldBlock::decode(value)?)) } - "horizon:condition" => Self::Condition(Box::new(lithostitched::Conditional::decode( + "lithostitched:condition" => Self::Condition(Box::new(litho::Conditional::decode( value, resources, bindings, )?)), _ => return Err(DecodeError::Field("structure processor type")), @@ -1115,24 +1140,10 @@ fn process_block( if !position_ok { continue; } - let nbt = match &rule.modifier { - Modifier::Passthrough => info.nbt.clone(), - Modifier::Clear => Some(Compound::new()), - Modifier::AppendLoot(table) => { - let mut nbt = info.nbt.clone().unwrap_or_default(); - nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); - nbt.insert("LootTableSeed".into(), Tag::Long(random.next_long())); - Some(nbt) - } - Modifier::AppendStatic(data) => Some(edited(info.nbt.as_ref(), &[], data)), - Modifier::Edit { remove, data } => { - Some(edited(info.nbt.as_ref(), remove, data)) - } - }; return Ok(Some(BlockInfo { pos: info.pos, state: rule.output, - nbt, + nbt: rule.modifier.apply(info.nbt.as_ref(), &mut random), })); } Some(info) @@ -1165,8 +1176,7 @@ fn process_block( false => Some(info), }, Processor::ApplyRandom(apply) => { - let seed = world.world_seed()?; - let mut random = apply.random.create(seed, position, reference, info.pos); + let mut random = apply.draws.random(world.world_seed()?, position, info.pos); match apply.pick(&mut random) { Some(list) => { return process_list( @@ -1176,21 +1186,34 @@ fn process_block( None => Some(info), } } + Processor::Reference(lists) => { + let mut current = info; + for list in lists { + match process_list( + list, world, resources, position, reference, relative, current, settings, + )? { + Some(next) => current = next, + None => return Ok(None), + } + } + Some(current) + } + Processor::DiscardInput => None, Processor::SetBlock(set) => { - let seed = world.world_seed()?; - let state = set.state(seed, position, reference, info.pos); - let state = match set.preserves() { + let mut random = set.draws.random(world.world_seed()?, position, info.pos); + let state = set.state(&mut random); + let state = match set.preserve { true => registry .state(state) .and_then(|s| with_properties_of(registry, &s.name, info.state)) .unwrap_or(state), false => state, }; - Some(BlockInfo { state, ..info }) + let nbt = set.modifier.apply(info.nbt.as_ref(), &mut random); + Some(BlockInfo { state, nbt, ..info }) } Processor::Condition(c) => { - let seed = world.world_seed()?; - let mut random = c.random.create(seed, position, reference, info.pos); + let mut random = c.draws.random(world.world_seed()?, position, info.pos); let location = world.block_state(info.pos)?; let passed = c .condition diff --git a/crates/horizon-world/src/worldgen/structure/processor/litho.rs b/crates/horizon-world/src/worldgen/structure/processor/litho.rs new file mode 100644 index 000000000..6ba006fd6 --- /dev/null +++ b/crates/horizon-world/src/worldgen/structure/processor/litho.rs @@ -0,0 +1,841 @@ +//! Lithostitched's processors (spec-lithostitched §5), read as its data +//! writes them: `lithostitched:block_swap` (in `processor.rs`), `reference`, +//! `apply_random`, `condition`, `set_block` and `discard_input`. +//! +//! The draws of `random_chance`, `apply_random` and `set_block` follow +//! Lithostitched's `random_mode` (per block or per piece), but its seeding is +//! not known (OPEN-L6): a positional random of the world seed, the block's or +//! the piece's position and the processor itself, so the shares match while +//! the blocks chosen do not. +use super::{BlockStateId, DecodeError, Modifier, ProcessorList, ProcessorRandom}; +use crate::worldgen::{block_feature::FeatureBlockBindings, structure::StructureResources}; +use horizon_core::{ + position::BlockPos, + random::{LegacyRandom, position_seed}, +}; +use serde_json::Value; +use std::collections::BTreeSet; + +/// `random_mode` (`condition`, `set_block`) or `mode` (`apply_random`). +#[derive(Clone, Copy, Debug)] +pub(super) struct Draws { + per_piece: bool, + /// The processor's own salt, so two processors on a block draw apart. + salt: i64, +} +impl Draws { + fn decode(mode: Option<&Value>, processor: &Value) -> Result { + let per_piece = match mode.and_then(Value::as_str) { + None | Some("per_block") => false, + Some("per_piece") => true, + _ => return Err(DecodeError::Field("random_mode")), + }; + // FNV-1a over the processor's JSON: the same in every run. + let salt = (processor.to_string().bytes()).fold(0xcbf2_9ce4_8422_2325_u64, |h, b| { + (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3) + }) as i64; + Ok(Self { per_piece, salt }) + } + /// The random for the block at `pos` of the piece at `piece`. + pub(super) fn random(self, world_seed: i64, piece: [i32; 3], pos: [i32; 3]) -> LegacyRandom { + let [x, y, z] = if self.per_piece { piece } else { pos }; + LegacyRandom::new(world_seed ^ self.salt ^ position_seed(BlockPos::new(x, y, z))) + } +} + +/// A processor or a list of them (`then`, `else`, `apply_random`'s data): +/// a list holder (`ProcessorList::decode`), or one processor object. +fn processors( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result { + let one = value.get("processor_type").is_some(); + let holder = if one { + Value::Array(vec![value.clone()]) + } else { + value.clone() + }; + ProcessorList::decode(&holder.to_string(), resources, bindings) +} + +/// `reference`: the named lists, run in turn on the block. +pub(super) fn reference( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names = match &value["processor_lists"] { + Value::Array(a) => a.clone(), + other => vec![other.clone()], + }; + (names.iter()) + .map(|name| match name.as_str() { + Some(n) if n.starts_with('#') => Err(DecodeError::Field("processor list tag")), + Some(_) => ProcessorList::decode(&name.to_string(), resources, bindings), + None => Err(DecodeError::Field("processor_lists")), + }) + .collect() +} + +/// `apply_random`: one list drawn by weight runs on the block. +#[derive(Clone, Debug)] +pub struct ApplyRandom { + pub(super) draws: Draws, + lists: Vec<(i32, ProcessorList)>, + total: i32, +} +impl ApplyRandom { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let entries = value["processor_lists"] + .as_array() + .ok_or(DecodeError::Field("apply_random processor_lists"))?; + let lists = (entries.iter()) + .map(|e| match e.get("data") { + Some(data) => { + let weight = e["weight"] + .as_i64() + .unwrap_or(1) + .clamp(0, i64::from(i32::MAX)); + Ok((weight as i32, processors(data, resources, bindings)?)) + } + None => Ok((1, processors(e, resources, bindings)?)), + }) + .collect::, DecodeError>>()?; + let total = lists + .iter() + .map(|(w, _)| *w) + .fold(0i32, i32::saturating_add); + Ok(Self { + draws: Draws::decode(value.get("mode"), value)?, + lists, + total, + }) + } + /// The list drawn: one bounded draw over the total weight. + pub(super) fn pick(&self, random: &mut impl ProcessorRandom) -> Option<&ProcessorList> { + if self.total <= 0 { + return None; + } + let mut at = random.int(self.total); + for (weight, list) in &self.lists { + at -= weight; + if at < 0 { + return Some(list); + } + } + None + } +} + +/// Lithostitched's processor conditions. +#[derive(Clone, Debug)] +pub(super) enum Condition { + True, + AllOf(Vec), + AnyOf(Vec), + Not(Box), + Chance(f32), + /// `matching_blocks`: the template's block (`input`) or the world's + /// (`location`) is one of `blocks`, with `properties`. + Matching { + blocks: BTreeSet, + properties: Vec<(String, String)>, + location: bool, + }, +} +impl Condition { + /// One condition, or a list of them that must all pass (`if_true`). + pub(super) fn decode( + value: &Value, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let list = |v: &Value| -> Result, DecodeError> { + (v.as_array().ok_or(DecodeError::Field("conditions"))?.iter()) + .map(|c| Self::decode(c, bindings)) + .collect() + }; + if value.is_array() { + return Ok(Self::AllOf(list(value)?)); + } + let kind = value["type"].as_str().unwrap_or_default(); + Ok(match crate::worldgen::tags::identifier(kind)?.as_str() { + "lithostitched:true" => Self::True, + "lithostitched:all_of" => Self::AllOf(list(&value["conditions"])?), + "lithostitched:any_of" => Self::AnyOf(list(&value["conditions"])?), + "lithostitched:not" => { + Self::Not(Box::new(Self::decode(&value["condition"], bindings)?)) + } + "lithostitched:random_chance" => Self::Chance( + value["chance"] + .as_f64() + .ok_or(DecodeError::Field("random_chance chance"))? as f32, + ), + "lithostitched:matching_blocks" => Self::Matching { + blocks: blocks(&value["blocks"], bindings)?, + properties: (value + .get("properties") + .and_then(Value::as_object) + .into_iter()) + .flatten() + .map(|(k, v)| { + ( + k.clone(), + v.as_str().map_or_else(|| v.to_string(), str::to_owned), + ) + }) + .collect(), + location: match value.get("match_type").and_then(Value::as_str) { + None | Some("input") => false, + Some("location") => true, + _ => return Err(DecodeError::Field("matching_blocks match_type")), + }, + }, + _ => return Err(DecodeError::Field("lithostitched condition type")), + }) + } + pub(super) fn test( + &self, + input: BlockStateId, + location: BlockStateId, + registry: &crate::registry::BlockRegistry, + random: &mut impl ProcessorRandom, + ) -> bool { + match self { + Self::True => true, + Self::AllOf(all) => all + .iter() + .all(|c| c.test(input, location, registry, random)), + Self::AnyOf(any) => any + .iter() + .any(|c| c.test(input, location, registry, random)), + Self::Not(c) => !c.test(input, location, registry, random), + Self::Chance(chance) => random.float() < *chance, + Self::Matching { + blocks, + properties, + location: at_location, + } => { + let Some(state) = registry.state(if *at_location { location } else { input }) + else { + return false; + }; + blocks.contains(&state.name) + && (properties.iter()).all(|(k, v)| state.properties.get(k) == Some(v)) + } + } + } +} +/// A block set (an id, a list, `#tag`) by block name. Blocks the game does +/// not have are left out: no template block can be one. +fn blocks( + value: &Value, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names: Vec<&str> = match value { + Value::String(s) => vec![s.as_str()], + Value::Array(a) => a.iter().filter_map(Value::as_str).collect(), + _ => return Err(DecodeError::Field("matching_blocks blocks")), + }; + let registry = bindings.registry(); + let mut out = BTreeSet::new(); + for name in names { + match name.strip_prefix('#') { + Some(tag) => { + let tag = crate::worldgen::tags::identifier(tag)?; + let states = bindings.tags.get(&tag).into_iter().flat_map(|s| s.iter()); + out.extend(states.filter_map(|s| Some(registry.state(*s)?.name.clone()))); + } + None => { + out.insert(crate::worldgen::tags::identifier(name)?.to_string()); + } + } + } + Ok(out) +} + +/// `condition`: `then` when the conditions pass, else `else` (none: the +/// block as it is). +#[derive(Clone, Debug)] +pub struct Conditional { + pub(super) draws: Draws, + pub(super) condition: Condition, + pub(super) then: ProcessorList, + pub(super) otherwise: ProcessorList, +} +impl Conditional { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let branch = |key| match value.get(key) { + Some(v) => processors(v, resources, bindings), + None => Ok(ProcessorList(Vec::new())), + }; + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + condition: Condition::decode(&value["if_true"], bindings)?, + then: branch("then")?, + otherwise: branch("else")?, + }) + } +} + +/// `set_block`: the block from a state provider (simple or weighted). +#[derive(Clone, Debug)] +pub struct SetBlock { + pub(super) draws: Draws, + states: Vec<(i32, BlockStateId)>, + total: i32, + /// `preserve_state` (true by default): the template block's properties + /// the new block has too are kept. + pub(super) preserve: bool, + pub(super) modifier: Modifier, +} +impl SetBlock { + pub(super) fn decode( + value: &Value, + state: impl Fn(&Value) -> Result, + ) -> Result { + let provider = &value["state_provider"]; + let kind = provider["type"].as_str().unwrap_or_default(); + let states = match crate::worldgen::tags::identifier(kind)?.as_str() { + "minecraft:simple_state_provider" => vec![(1, state(&provider["state"])?)], + "minecraft:weighted_state_provider" => (provider["entries"].as_array().into_iter()) + .flatten() + .map(|e| { + Ok(( + e["weight"].as_i64().unwrap_or(1).clamp(0, 1 << 30) as i32, + state(&e["data"])?, + )) + }) + .collect::>()?, + _ => return Err(DecodeError::Field("set_block state_provider")), + }; + let total = states.iter().map(|(w, _)| *w).sum(); + if total <= 0 { + return Err(DecodeError::Field("set_block state_provider")); + } + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + states, + total, + preserve: value + .get("preserve_state") + .and_then(Value::as_bool) + .unwrap_or(true), + modifier: Modifier::decode(value.get("block_entity_modifier"))?, + }) + } + /// The provider's state: WeightedList.getRandom, one bounded draw. + pub(super) fn state(&self, random: &mut impl ProcessorRandom) -> BlockStateId { + let mut at = random.int(self.total); + for (weight, state) in &self.states { + at -= weight; + if at < 0 { + return *state; + } + } + self.states[0].1 + } +} + +#[cfg(test)] +mod tests { + use super::super::{BlockInfo, PlaceSettings, ProcessorList, process_list}; + use crate::{ + heightmap::HeightmapType, + nbt::{JavaString, Tag}, + registry::{BlockRegistry, BlockStateId}, + worldgen::{ + anchor::WorldGenerationContext, + block_feature::FeatureBlockBindings, + placement::{PlacementContext, PlacementQueryError}, + structure::{ + Rotation, StateTransforms, StructureResources, template::parse_state_string, + }, + }, + }; + use serde_json::{Value, json}; + use std::collections::{BTreeMap, BTreeSet}; + + /// Every combination of `properties`' values, the first one the default. + fn states(name: &str, properties: &[(&str, &[&str])]) -> Vec { + let mut out = vec![serde_json::Map::new()]; + for (key, values) in properties { + out = (out.iter()) + .flat_map(|o| { + values.iter().map(move |v| { + let mut o = o.clone(); + o.insert((*key).into(), (*v).into()); + o + }) + }) + .collect(); + } + (out.into_iter()) + .map(|p| json!([name, name.ends_with("air"), false, "", {"id": name, "properties": p}])) + .collect() + } + + /// A registry of the blocks CTOV's lists and the probe pack use. + fn registry() -> &'static BlockRegistry { + let ages: Vec = (0..8).map(|a| a.to_string()).collect(); + let ages: Vec<&str> = ages.iter().map(String::as_str).collect(); + let levels: Vec = (0..16).map(|a| a.to_string()).collect(); + let levels: Vec<&str> = levels.iter().map(String::as_str).collect(); + let water = [("level", &levels[..])]; + let stairs: &[(&str, &[&str])] = + &[("facing", &["north", "east"]), ("half", &["bottom", "top"])]; + let blocks: Vec<(&str, &[(&str, &[&str])])> = vec![ + ("minecraft:air", &[]), + ("minecraft:cave_air", &[]), + ("minecraft:void_air", &[]), + ("minecraft:lava", &water), + ("minecraft:cobblestone", &[]), + ("minecraft:blackstone", &[]), + ("minecraft:deepslate", &[]), + ("minecraft:water", &water), + ("minecraft:spruce_planks", &[]), + ("minecraft:chest", &[]), + ("minecraft:oak_log", &[("axis", &["y", "x"])]), + ("minecraft:stripped_cherry_log", &[("axis", &["y", "x"])]), + ("minecraft:oak_stairs", stairs), + ("minecraft:warped_stairs", stairs), + ]; + let wheat = [("age", &ages[..])]; + let beetroots = [("age", &ages[..4])]; + let mut rows = Vec::new(); + let mut defaults = BTreeMap::new(); + let crops: [(&str, &[(&str, &[&str])]); 3] = [ + ("minecraft:wheat", &wheat), + ("minecraft:carrots", &wheat), + ("minecraft:beetroots", &beetroots), + ]; + for (name, properties) in blocks.into_iter().chain(crops) { + defaults.insert(name, rows.len()); + rows.extend(states(name, properties)); + } + let facts = json!({"states": rows, "defaults": defaults}); + let registry = BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap(); + Box::leak(Box::new(registry)) + } + + /// The world a piece is placed in: one block everywhere. + struct World { + seed: i64, + block: BlockStateId, + } + impl PlacementContext for World { + fn world_seed(&mut self) -> Result { + Ok(self.seed) + } + fn block_state(&mut self, _: [i32; 3]) -> Result { + Ok(self.block) + } + fn generation(&self) -> WorldGenerationContext { + WorldGenerationContext::new(-64, 384, 63) + } + fn min_y(&mut self) -> Result { + Ok(-64) + } + fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result { + Err(PlacementQueryError::Unavailable) + } + } + + struct Lists { + registry: &'static BlockRegistry, + resources: StructureResources, + } + impl Lists { + fn new(lists: &[(&str, Value)]) -> Self { + let registry = registry(); + let lists = (lists.iter()) + .map(|(id, list)| ((*id).to_owned(), list.to_string())) + .collect(); + let resources = StructureResources::new( + registry, + StateTransforms::default(), + std::path::Path::new("/nonexistent"), + lists, + &BTreeMap::new(), + ); + Self { + registry, + resources, + } + } + fn id(&self, state: &str) -> BlockStateId { + parse_state_string(self.registry, state).unwrap() + } + fn decode(&self, processors: Value) -> Result { + let bindings = FeatureBlockBindings::new(self.registry, BTreeSet::new()).unwrap(); + ProcessorList::decode(&processors.to_string(), &self.resources, &bindings) + } + /// The block the list makes of template block `state` at `pos` of the + /// piece at `piece`, in a world of `world`: None when it is not placed. + fn run( + &self, + list: &ProcessorList, + world: (i64, &str), + piece: [i32; 3], + pos: [i32; 3], + state: &str, + ) -> Option { + let mut world = World { + seed: world.0, + block: self.id(world.1), + }; + let info = BlockInfo { + pos, + state: self.id(state), + nbt: None, + }; + let mut settings = PlaceSettings::new(Rotation::None); + process_list( + list, + &mut world, + &self.resources, + piece, + piece, + [0; 3], + info, + &mut settings, + ) + .unwrap() + } + fn name(&self, info: Option) -> String { + match info { + None => "none".into(), + Some(info) => { + let s = self.registry.state(info.state).unwrap(); + let props: Vec = s + .properties + .iter() + .map(|(k, v)| format!("{k}={v}")) + .collect(); + match props.is_empty() { + true => s.name.clone(), + false => format!("{}[{}]", s.name, props.join(",")), + } + } + } + } + /// `name(run(...))` for one template block in an air world of seed 0. + fn out(&self, list: &ProcessorList, state: &str) -> String { + self.name(self.run(list, (0, "minecraft:air"), [0; 3], [0; 3], state)) + } + } + + fn swap(blocks: Value) -> Value { + json!({"processor_type": "lithostitched:block_swap", "blocks": blocks}) + } + fn set_block(provider: Value) -> Value { + json!({"processor_type": "lithostitched:set_block", "state_provider": provider}) + } + fn simple(name: &str) -> Value { + json!({"type": "minecraft:simple_state_provider", "state": {"id": name}}) + } + + #[test] + fn block_swap_keeps_the_properties_the_new_block_can_have() { + let t = Lists::new(&[]); + let list = t + .decode(json!([swap(json!({ + "minecraft:wheat": "minecraft:carrots", + "oak_stairs": "minecraft:warped_stairs", + "minecraft:cobblestone": "natures_spirit:missing"}))])) + .unwrap(); + assert_eq!( + t.out(&list, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&list, "minecraft:oak_stairs[facing=east,half=top]"), + "minecraft:warped_stairs[facing=east,half=top]" + ); + // A block the game lacks leaves the template's; others pass. + assert_eq!( + t.out(&list, "minecraft:cobblestone"), + "minecraft:cobblestone" + ); + assert_eq!( + t.out(&list, "minecraft:oak_log[axis=x]"), + "minecraft:oak_log[axis=x]" + ); + // Beetroots' age stops at 3: ripe wheat gives the default (spec-ctov §4). + let beet = t + .decode(json!([swap( + json!({"minecraft:wheat": "minecraft:beetroots"}) + )])) + .unwrap(); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=7]"), + "minecraft:beetroots[age=0]" + ); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=2]"), + "minecraft:beetroots[age=2]" + ); + } + + #[test] + fn references_run_the_named_lists_in_turn() { + let t = Lists::new(&[ + ( + "t:logs", + json!({"processors": [swap(json!({"minecraft:oak_log": "minecraft:stripped_cherry_log"}))]}), + ), + ( + "t:stone", + json!([swap( + json!({"minecraft:stripped_cherry_log": "minecraft:cobblestone"}) + )]), + ), + ( + "t:discard", + json!([{"processor_type": "lithostitched:discard_input"}]), + ), + ]); + let reference = |lists: Value| json!([{"processor_type": "lithostitched:reference", "processor_lists": lists}]); + let one = t.decode(reference(json!("t:logs"))).unwrap(); + assert_eq!( + t.out(&one, "minecraft:oak_log[axis=x]"), + "minecraft:stripped_cherry_log[axis=x]" + ); + let both = t.decode(reference(json!(["t:logs", "t:stone"]))).unwrap(); + assert_eq!(t.out(&both, "minecraft:oak_log"), "minecraft:cobblestone"); + let reversed = t.decode(reference(json!(["t:stone", "t:logs"]))).unwrap(); + assert_eq!( + t.out(&reversed, "minecraft:oak_log"), + "minecraft:stripped_cherry_log[axis=y]" + ); + // discard_input: the template block is not placed, and the lists after it do not run. + let discard = t.decode(reference(json!(["t:discard", "t:logs"]))).unwrap(); + assert_eq!(t.out(&discard, "minecraft:oak_log"), "none"); + // The game has no processor list tags; unknown lists are errors. + assert!(t.decode(reference(json!(["#t:palettes"]))).is_err()); + assert!(t.decode(reference(json!("t:missing"))).is_err()); + } + + /// The probe pack's nested condition (spec-lithostitched §7.3): template + /// cobblestone becomes blackstone or deepslate, half each. + #[test] + fn conditions_run_then_or_else() { + let t = Lists::new(&[]); + let inner = json!({"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:random_chance", "chance": 0.5}, + "then": set_block(simple("minecraft:blackstone")), + "else": [set_block(simple("minecraft:deepslate"))]}); + let list = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], + "then": [inner]}])) + .unwrap(); + let mut counts = BTreeMap::::new(); + for i in 0..4000 { + let out = t.run( + &list, + (1234, "minecraft:air"), + [0; 3], + [i % 64, i / 64, 7], + "minecraft:cobblestone", + ); + *counts.entry(t.name(out)).or_default() += 1; + } + assert_eq!(counts.len(), 2, "{counts:?}"); + assert!( + (1850..2150).contains(&counts["minecraft:blackstone"]), + "{counts:?}" + ); + // Not cobblestone, and no `else`: the block as it is. + assert_eq!( + t.out(&list, "minecraft:oak_log"), + "minecraft:oak_log[axis=y]" + ); + + // `location` tests the world's block, with properties on the input. + let water = t + .decode( + json!([{"processor_type": "lithostitched:condition", "random_mode": "per_piece", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": ["minecraft:water"], + "match_type": "location"}, + "then": set_block(simple("minecraft:spruce_planks"))}]), + ) + .unwrap(); + let at = |world| { + t.name(t.run( + &water, + (0, world), + [0; 3], + [1, 2, 3], + "minecraft:cobblestone", + )) + }; + assert_eq!(at("minecraft:water"), "minecraft:spruce_planks"); + assert_eq!(at("minecraft:air"), "minecraft:cobblestone"); + let ripe = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": {"type": "lithostitched:all_of", "conditions": [ + {"type": "lithostitched:true"}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:wheat", "properties": {"age": "7"}}, + {"type": "lithostitched:not", "condition": {"type": "lithostitched:any_of", "conditions": [ + {"type": "lithostitched:random_chance", "chance": 0.0}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", "match_type": "location"}]}}]}, + "then": swap(json!({"minecraft:wheat": "minecraft:carrots"}))}])) + .unwrap(); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=6]"), + "minecraft:wheat[age=6]" + ); + let bad = json!([{"processor_type": "lithostitched:condition", "random_mode": "per_chunk", + "if_true": {"type": "lithostitched:true"}}]); + assert!(t.decode(bad).is_err()); + } + + /// `apply_random` (spec-lithostitched §7.3: crimson 1 : birch 3, one + /// choice per piece): here blackstone 1 : deepslate 3. + #[test] + fn apply_random_draws_per_piece_or_per_block() { + let t = Lists::new(&[( + "t:deepslate", + json!([swap( + json!({"minecraft:cobblestone": "minecraft:deepslate"}) + )]), + )]); + let random = |mode: &str| { + t.decode(json!([{"processor_type": "lithostitched:apply_random", "mode": mode, + "processor_lists": [ + {"weight": 1, "data": [swap(json!({"minecraft:cobblestone": "minecraft:blackstone"}))]}, + {"weight": 3, "data": "t:deepslate"}]}])) + .unwrap() + }; + let (per_piece, per_block) = (random("per_piece"), random("per_block")); + let outcomes = |list: &ProcessorList, seed: i64, piece: [i32; 3]| -> Vec { + (0..20) + .map(|i| { + let pos = [piece[0] + i, piece[1], piece[2] + 3 * i]; + t.name(t.run( + list, + (seed, "minecraft:air"), + piece, + pos, + "minecraft:cobblestone", + )) + }) + .collect() + }; + let mut blackstone_pieces = 0; + for p in 0..400 { + let piece = [16 * p, 70, -40 * p]; + let blocks = outcomes(&per_piece, 1234, piece); + assert!(blocks.iter().all(|b| *b == blocks[0]), "{blocks:?}"); + blackstone_pieces += u32::from(blocks[0] == "minecraft:blackstone"); + // The same piece and seed give the same blocks. + assert_eq!(outcomes(&per_piece, 1234, piece), blocks); + } + assert!( + (70..130).contains(&blackstone_pieces), + "{blackstone_pieces}" + ); + // Per block, one piece mixes both. + let mixed: BTreeSet = (0..10) + .flat_map(|p| outcomes(&per_block, 1234, [p, 0, 0])) + .collect(); + assert_eq!(mixed.len(), 2, "{mixed:?}"); + // A plain list: every entry weight 1. An entry list holding nothing is a no-op. + let plain = t + .decode( + json!([{"processor_type": "lithostitched:apply_random", "mode": "per_block", + "processor_lists": ["t:deepslate", []]}]), + ) + .unwrap(); + let seen: BTreeSet = (0..10) + .flat_map(|p| outcomes(&plain, 9, [p, 0, 0])) + .collect(); + assert_eq!( + seen, + BTreeSet::from(["minecraft:cobblestone".into(), "minecraft:deepslate".into()]) + ); + } + + #[test] + fn set_block_runs_its_provider() { + let t = Lists::new(&[]); + let stairs = "minecraft:oak_stairs[facing=east,half=top]"; + let warped = |preserve: Value| { + let mut p = set_block(simple("minecraft:warped_stairs")); + if !preserve.is_null() { + p["preserve_state"] = preserve; + } + t.decode(json!([p])).unwrap() + }; + // preserve_state (true by default) keeps the properties both blocks have. + assert_eq!( + t.out(&warped(Value::Null), stairs), + "minecraft:warped_stairs[facing=east,half=top]" + ); + assert_eq!( + t.out(&warped(json!(false)), stairs), + "minecraft:warped_stairs[facing=north,half=bottom]" + ); + + let weighted = t + .decode(json!([set_block( + json!({"type": "minecraft:weighted_state_provider", "entries": [ + {"weight": 1, "data": {"id": "minecraft:blackstone"}}, + {"weight": 3, "data": {"id": "minecraft:deepslate"}}]}) + )])) + .unwrap(); + let blackstone = (0..2000) + .filter(|i| { + let out = t.run( + &weighted, + (42, "minecraft:air"), + [0; 3], + [*i, 0, -*i], + "minecraft:cobblestone", + ); + t.name(out) == "minecraft:blackstone" + }) + .count(); + assert!((420..580).contains(&blackstone), "{blackstone}"); + + // block_entity_modifier gives the output its block entity. + let mut loot = set_block(simple("minecraft:chest")); + loot["block_entity_modifier"] = + json!({"type": "minecraft:append_loot", "loot_table": "t:chests/house"}); + let out = t + .run( + &t.decode(json!([loot])).unwrap(), + (0, "minecraft:air"), + [0; 3], + [0; 3], + "minecraft:air", + ) + .unwrap(); + let table = out + .nbt + .as_ref() + .and_then(|n| n.get(&JavaString::from("LootTable"))); + assert_eq!(table, Some(&Tag::String("t:chests/house".into()))); + + // Providers the game does not run are refused. + assert!( + t.decode(json!([set_block( + json!({"type": "minecraft:noise_provider"}) + )])) + .is_err() + ); + } +} diff --git a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs b/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs deleted file mode 100644 index f0bb1c6ba..000000000 --- a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs +++ /dev/null @@ -1,434 +0,0 @@ -//! Lithostitched's processors that pick processors, carried as data -//! (`horizon:apply_random` and `horizon:condition`): one runs a processor -//! list drawn by weight, the other one list or another by a test of the -//! block. Both draw from Lithostitched's RandomSettings: a random seeded from -//! the world seed and a name, at the block, the piece or the structure. -//! `horizon:set_block` is its `set_block`, which the conditions mostly run. -use super::{Processor, ProcessorList}; -use crate::{ - registry::{BlockRegistry, BlockStateId}, - worldgen::{DecodeError, block_feature::FeatureBlockBindings, structure::StructureResources}, -}; -use horizon_core::{ - position::BlockPos, - random::{LegacyRandom, PositionalRandom, RandomSource}, -}; -use serde_json::Value; -use std::{collections::BTreeSet, sync::Arc}; - -/// RandomSettings: where the random is taken, and the name salting it. -#[derive(Clone, Debug, PartialEq)] -pub struct RandomSettings { - mode: Mode, - /// ResourceLocation.hashCode of the name (`lithostitched:default`). - salt: i32, -} -#[derive(Clone, Copy, Debug, PartialEq)] -enum Mode { - Block, - Piece, - Structure, -} -impl RandomSettings { - /// A mode alone, or `{"mode": ..., "name": ...}`; per block when unset. - fn decode(v: Option<&Value>) -> Result { - let mode = Mode::decode; - let (mode, name) = match v { - None => (Mode::Block, "lithostitched:default"), - Some(Value::String(m)) => (mode(Some(m))?, "lithostitched:default"), - Some(o) => ( - mode(o["mode"].as_str())?, - o["name"] - .as_str() - .ok_or(DecodeError::Field("random name"))?, - ), - }; - let (namespace, path) = name.split_once(':').unwrap_or(("minecraft", name)); - Ok(Self { - mode, - salt: java_hash(namespace) - .wrapping_mul(31) - .wrapping_add(java_hash(path)), - }) - } - /// RandomSource.create(seed + hash).forkPositional().at(the chosen - /// position): the piece's position, the structure's pivot or the block. - pub(super) fn create( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> LegacyRandom { - let [x, y, z] = self.mode.select(piece, pivot, block); - LegacyRandom::new(seed.wrapping_add(i64::from(self.salt))) - .fork_positional() - .at(BlockPos::new(x, y, z)) - } -} -impl Mode { - fn decode(m: Option<&str>) -> Result { - match m { - None | Some("per_block") => Ok(Self::Block), - Some("per_piece") => Ok(Self::Piece), - Some("per_structure") => Ok(Self::Structure), - _ => Err(DecodeError::Field("random mode")), - } - } - fn select(self, piece: [i32; 3], pivot: [i32; 3], block: [i32; 3]) -> [i32; 3] { - match self { - Self::Block => block, - Self::Piece => piece, - Self::Structure => pivot, - } - } -} - -/// SetBlockProcessor with a simple or weighted state provider and no block -/// entity change: the block becomes the state, keeping the properties it -/// shares with the old one unless `preserve_state` is off. -#[derive(Clone, Debug)] -pub struct SetBlock { - /// The states and their weights; one state alone is a simple provider, - /// which draws nothing. - states: Vec<(BlockStateId, i32)>, - weighted: bool, - preserve: bool, - mode: Mode, -} -impl SetBlock { - pub(super) fn decode( - v: &Value, - state: impl Fn(&Value) -> Result, - ) -> Result { - let provider = &v["state_provider"]; - let (states, weighted) = match provider["type"].as_str() { - Some("minecraft:simple_state_provider") => { - (vec![(state(&provider["state"])?, 1)], false) - } - Some("minecraft:weighted_state_provider") => ( - provider["entries"] - .as_array() - .ok_or(DecodeError::Field("set_block entries"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("set_block weight"))?; - Ok((state(&e["data"])?, weight as i32)) - }) - .collect::>()?, - true, - ), - _ => return Err(DecodeError::Field("set_block state_provider")), - }; - if states.is_empty() { - return Err(DecodeError::Field("set_block entries")); - } - Ok(Self { - states, - weighted, - preserve: v["preserve_state"].as_bool().unwrap_or(true), - mode: Mode::decode(v["random_mode"].as_str())?, - }) - } - /// The state to set, before `preserve`: drawn with - /// RandomSource.create(seed).forkPositional().at(the chosen position). - pub(super) fn state( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> BlockStateId { - if !self.weighted { - return self.states[0].0; - } - let [x, y, z] = self.mode.select(piece, pivot, block); - let mut random = LegacyRandom::new(seed) - .fork_positional() - .at(BlockPos::new(x, y, z)); - let total: i32 = self.states.iter().map(|s| s.1).sum(); - let mut value = random.next_int_bound(total.max(1)).unwrap_or(0); - for (state, weight) in &self.states { - if value < *weight { - return *state; - } - value -= weight; - } - self.states[0].0 - } - pub(super) fn preserves(&self) -> bool { - self.preserve - } -} - -/// String.hashCode over UTF-16 units. -fn java_hash(s: &str) -> i32 { - s.encode_utf16() - .fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c))) -} - -fn list( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, -) -> Result { - ProcessorList::decode(&v.to_string(), resources, bindings) -} - -/// ApplyRandomStructureProcessor: a weighted list of processor lists, one -/// drawn per block with `nextInt(total)`. -#[derive(Clone, Debug)] -pub struct ApplyRandom { - pub(super) random: RandomSettings, - lists: Vec<(ProcessorList, i32)>, - total: i32, -} -impl ApplyRandom { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - let lists = v["processor_lists"] - .as_array() - .ok_or(DecodeError::Field("apply_random processor_lists"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("apply_random weight"))?; - Ok((list(&e["data"], resources, bindings)?, weight as i32)) - }) - .collect::, DecodeError>>()?; - Ok(Self { - random: RandomSettings::decode(v.get("mode"))?, - total: lists.iter().map(|l| l.1).sum(), - lists, - }) - } - /// WeightedList.getRandom: none when the weights add up to 0. - pub(super) fn pick(&self, random: &mut impl RandomSource) -> Option<&ProcessorList> { - if self.total <= 0 { - return None; - } - let mut value = random.next_int_bound(self.total).unwrap_or(0); - for (list, weight) in &self.lists { - if value < *weight { - return Some(list); - } - value -= weight; - } - None - } -} - -/// ConditionProcessor: `then` when the condition holds for the block, else -/// `else`. -#[derive(Clone, Debug)] -pub struct Conditional { - pub(super) random: RandomSettings, - pub(super) condition: Condition, - pub(super) then: ProcessorList, - pub(super) otherwise: ProcessorList, -} -impl Conditional { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - // A processor alone or a list of them. - let processors = |key: &str| -> Result { - match v.get(key) { - None => Ok(ProcessorList::default()), - Some(Value::Object(p)) if p.contains_key("processor_type") => Ok(ProcessorList( - vec![Processor::decode(&v[key], resources, bindings)?], - )), - Some(other) => list(other, resources, bindings), - } - }; - Ok(Self { - random: RandomSettings::decode(v.get("random_mode"))?, - condition: Condition::decode(&v["if_true"], bindings)?, - then: processors("then")?, - otherwise: processors("else")?, - }) - } -} - -/// Lithostitched's processor conditions the game runs. -#[derive(Clone, Debug)] -pub(super) enum Condition { - True, - AllOf(Vec), - AnyOf(Vec), - Not(Box), - RandomChance(f32), - /// The block placed (`input`) or the one in the world (`location`) is - /// one of these, with these property values. - MatchingBlocks { - blocks: Arc>, - properties: Vec<(String, String)>, - location: bool, - }, -} -impl Condition { - fn decode(v: &Value, bindings: &FeatureBlockBindings<'_>) -> Result { - let all = |a: &Value| -> Result, DecodeError> { - a.as_array() - .ok_or(DecodeError::Field("processor conditions"))? - .iter() - .map(|c| Self::decode(c, bindings)) - .collect() - }; - if v.is_array() { - return Ok(Self::AllOf(all(v)?)); - } - let kind = v["type"].as_str().unwrap_or_default(); - Ok(match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" => Self::True, - "all_of" => Self::AllOf(all(&v["conditions"])?), - "any_of" => Self::AnyOf(all(&v["conditions"])?), - "not" => Self::Not(Box::new(Self::decode(&v["condition"], bindings)?)), - "random_chance" => Self::RandomChance(super::float(v, "chance")?), - "matching_blocks" => Self::MatchingBlocks { - blocks: super::holder_set(&v["blocks"], bindings)?, - properties: match v.get("properties") { - None => Vec::new(), - Some(p) => p - .as_object() - .ok_or(DecodeError::Field("matching_blocks properties"))? - .iter() - .map(|(k, x)| { - let x = x - .as_str() - .ok_or(DecodeError::Field("matching_blocks property"))?; - Ok((k.clone(), x.to_owned())) - }) - .collect::>()?, - }, - location: match v["match_type"].as_str() { - None | Some("input") => false, - Some("location") => true, - _ => return Err(DecodeError::Field("matching_blocks match_type")), - }, - }, - _ => return Err(DecodeError::Field("processor condition type")), - }) - } - /// ProcessorCondition.test with the block placed and the one there. - pub(super) fn test( - &self, - input: BlockStateId, - location: BlockStateId, - registry: &BlockRegistry, - random: &mut impl RandomSource, - ) -> bool { - match self { - Self::True => true, - Self::AllOf(all) => all - .iter() - .all(|c| c.test(input, location, registry, random)), - Self::AnyOf(any) => any - .iter() - .any(|c| c.test(input, location, registry, random)), - Self::Not(c) => !c.test(input, location, registry, random), - Self::RandomChance(chance) => random.next_float() < *chance, - Self::MatchingBlocks { - blocks, - properties, - location: at_location, - } => { - let state = if *at_location { location } else { input }; - blocks.contains(&state) - && properties.iter().all(|(k, x)| { - registry - .state(state) - .and_then(|s| s.properties.get(k)) - .is_some_and(|v| v == x) - }) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn random_settings_salt_and_position() { - // ResourceLocation.hashCode: 31 * namespace + path. - let default = RandomSettings::decode(Some(&"per_piece".into())).unwrap(); - assert_eq!( - default.salt, - java_hash("lithostitched") - .wrapping_mul(31) - .wrapping_add(java_hash("default")) - ); - assert_eq!(java_hash("default"), 1544803905); - let (seed, piece, pivot, block) = (12345, [16, 64, -32], [8, 70, 8], [17, 65, -30]); - let mut ours = default.create(seed, piece, pivot, block); - let mut theirs = LegacyRandom::new(seed + i64::from(default.salt)) - .fork_positional() - .at(BlockPos::new(16, 64, -32)); - assert_eq!(ours.next_long(), theirs.next_long()); - let named: Value = serde_json::json!({"mode": "per_structure", "name": "v:roof"}); - let named = RandomSettings::decode(Some(&named)).unwrap(); - assert_eq!(named.mode, Mode::Structure); - assert_eq!( - named.salt, - java_hash("v") - .wrapping_mul(31) - .wrapping_add(java_hash("roof")) - ); - } - - #[test] - fn apply_random_draws_by_weight() { - let apply = ApplyRandom { - random: RandomSettings { - mode: Mode::Block, - salt: 0, - }, - lists: vec![ - (ProcessorList(vec![Processor::Nop]), 3), - (ProcessorList::default(), 1), - ], - total: 4, - }; - let mut ours = LegacyRandom::new(9); - let mut theirs = LegacyRandom::new(9); - for _ in 0..32 { - let draw = theirs.next_int_bound(4).unwrap(); - let picked = apply.pick(&mut ours).unwrap(); - assert_eq!(picked.0.len(), usize::from(draw < 3)); - } - } - - #[test] - fn set_block_draws_from_the_unsalted_seed() { - let (a, b) = (BlockStateId(1), BlockStateId(2)); - let set = SetBlock::decode( - &serde_json::json!({"state_provider": {"type": "minecraft:weighted_state_provider", - "entries": [{"weight": 1, "data": 1}, {"weight": 2, "data": 2}]}, - "random_mode": "per_piece"}), - |v| Ok(BlockStateId(v.as_u64().unwrap() as u32)), - ) - .unwrap(); - assert!(set.preserves()); - for x in 0..16 { - let mut java = LegacyRandom::new(77) - .fork_positional() - .at(BlockPos::new(x, 5, 3)); - let want = if java.next_int_bound(3).unwrap() < 1 { - a - } else { - b - }; - assert_eq!(set.state(77, [x, 5, 3], [0; 3], [9, 9, 9]), want); - } - } -} diff --git a/docs/api/mod-index.md b/docs/api/mod-index.md index 6b807d950..e8476cdf0 100644 --- a/docs/api/mod-index.md +++ b/docs/api/mod-index.md @@ -1,7 +1,7 @@ # The registry index and `.hpack` Horizon's registry lists what is made for Horizon and reviewed: mods (`.hmod`), modpacks (`.hpack`), resource packs -and, once their format exists, Horizon shader packs. Submissions are pull requests in +and Horizon shader packs (`.hshader`, [shaders.md](../shaders.md)). Submissions are pull requests in [ludovic111/horizon-mods](https://github.com/ludovic111/horizon-mods); merging one publishes it. The launcher and the website read one file, `index.json`, which that repository's CI builds. The Rust types and every check below are `horizon_mods::index` and `horizon_mods::modpack` (feature `index`); the sample is @@ -21,7 +21,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. "license": "MIT", "source": "https://github.com/...", "icon": "https://...png", "key": "RWT...", "versions": [{ "version": "0.1.0", "published": "2026-10-24", "changelog": "", - "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "game": "26.3", + "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", "url": "https://github.com/ludovic111/horizon-mods/releases/download/...", "size": 438, "sha256": "e113...", "signature": "untrusted comment: ...\n...\ntrusted comment: ...\n...\n" } }] @@ -43,6 +43,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. | `versions` | Newest first, at least one. | | `api` | A mod's API line (its manifest's `api`); a modpack's manifest format (`1`). | | `side`, `capabilities` | A mod's, read from its manifest by CI, never typed by hand. | +| `api_level` | The mod API level a mod's code needs ([stability.md](stability.md#mod-api-levels)): its newest imported function's, read from the file by CI. Absent for content-only mods and in indexes built before levels. Installers take the newest version whose level the running game serves. | | `game` | The Minecraft version it is for. | | `requires` | A modpack's mods: `{ id, version, sha256 }`, each a version in this index with that hash. | | `file` | A plain name with the kind's extension (`.hmod`, `.hpack`, `.zip`), an `https://` URL, the size (at most 64 MiB), the lowercase hex SHA-256, and the `.minisig` text when the project has a key. | @@ -57,9 +58,11 @@ changing what one means, makes schema 2. 1. Its size and SHA-256 are the ones the entry lists, and it isn't revoked. 2. With a project key: its signature verifies with that key (minisign's prehashed and legacy signatures both). -3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities) and its +3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities), its API + level when the entry lists one, and its content's fence ([mods.md](../mods.md#content-mods-api-02)); a modpack's manifest (id, version, format, game, - mods); a resource pack's `pack.mcmeta`. + mods); a resource pack's `pack.mcmeta`; a shader pack's `horizon_shader_api::check` and manifest (id, version, + shader API). 4. A kind this build can't install is refused with "this Horizon can't install a … yet". The game still checks a mod's component imports against its capabilities when it starts it, as for any mod. @@ -99,7 +102,7 @@ own check (`index::inspect`): a mod's API, side and capabilities, a modpack's mo ```toml id = "coords_hud" # the file's name, and the manifest's id -kind = "mod" # mod | modpack | resourcepack; shader once its format exists +kind = "mod" # mod | modpack | resourcepack | shader name = "Coordinates HUD" summary = "One line, at most 160 characters." description = """Markdown.""" # optional @@ -156,10 +159,14 @@ How the repository runs (its workflows are in `.github/workflows/`): - **Taking a file down** is a pull request adding it to `revoked.toml`. Removing an entry outright (a test, a project nobody installed) fails `registry review` on purpose and needs an administrator's merge. -Kinds open to submissions: `mod`, `modpack`, `resourcepack`. `shader` is in the schema and stays closed until -Horizon's own shader pack format exists (Iris and OptiFine packs are for the Modrinth browser); its check will compile -the pack in a headless Horizon. A new kind gets its own check before it opens. +Kinds open to submissions: `mod`, `modpack`, `resourcepack`, `shader`. A shader pack (`.hshader`) passes +`horizon_shader_api::check`, the check the game runs before it loads one (`horizon-shader check`, [shaders.md](../shaders.md)): +every stage validated by naga and translated for Vulkan, Metal and DirectX 12; its manifest's id, version and shader +API line are its facts. Iris and OptiFine packs are for the Modrinth browser. A new kind gets its own check before it +opens. ## Changelog +- 2026-10-26: the launcher installs `shader` files into `shaderpacks/`; the sample index lists one (`glow`). +- 2026-10-25: `shader` opens, checked by `horizon_shader_api::check`; its files are `.hshader`. - Schema 1 (2026-10-24): kinds `mod`, `modpack`, `resourcepack`, `shader`; `.hpack` format 1. diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md index 0deeb0ddd..d7bf879b8 100644 --- a/docs/api/mods-reference.md +++ b/docs/api/mods-reference.md @@ -1,7 +1,7 @@ # Mod API reference -The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`, every interface, type, function and hook in it, and the capabilities a manifest may list. The guide is [mods.md](../mods.md); stability and versions: [stability.md](stability.md). Manifest `api` lines this game serves: `0.1`, `0.2`. +The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`, every interface, type, function and hook in it, and the capabilities a manifest may list. The guide is [mods.md](../mods.md); stability and versions: [stability.md](stability.md). Manifest `api` lines this game serves: `0.1`, `0.2`, `0.3`. ## Capabilities @@ -16,12 +16,22 @@ The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`, | `ui` | [`ui`](#ui) | show its own screens and a settings page | | `render` | [`render`](#render) | draw on your screen, shake and zoom the camera | | `input` | [`input`](#input) | see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys | +| `players` | [`players`](#players) | see who is on the server and message them | ## World `horizon-mod` +A client mod: runs in the player's game. + - Imports (what the game offers): `log`, `game`, `chat`, `hud`, `storage`, `command` - Exports (what the mod provides): `events` +## World `horizon-server-mod` + +A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): runs where the world is simulated, on the dedicated server, a LAN host and single player's own server. + +- Imports (what the game offers): `log`, `storage`, `players` +- Exports (what the mod provides): `server-events` + ## World `horizon-ui-mod` A mod with widgets (capability `ui`): the SDK builds every mod against this world. Mods built for `horizon-mod` alone (no `ui-events` export) still load and simply hear nothing of their widgets. @@ -278,7 +288,7 @@ A mapping as the player has bound it. | Function | Signature | What it does | | --- | --- | --- | | `claim-items` | `func(ids: list)` | The items whose use the mod handles instead of the game, by id (at most 64). Replaces the previous list. | -| `register-key` | `func(name: string, label: string, key: string) -> result<_, string>` | A key of the mod's: `name` comes back in `key-down` and `key-up`, `label` says what it does, `key` is the key as options.txt writes it (`key.keyboard.r`). At most 16; an unknown key is an error. | +| `register-key` | `func(name: string, label: string, key: string) -> result<_, string>` | A key of the mod's: `name` comes back in `key-down` and `key-up`, `label` says what it does, `key` is the key as options.txt writes it (`key.keyboard.r`), the default: the player can bind another one on the mod's page in Options > Mods, and that one wins. At most 16; an unknown key is an error. | | `held` | `func() -> option` | The main hand's stack, as of this tick; none when it is empty. | | `poll` | `func() -> list` | The events since the last call, oldest first. | | `claim-wheel` | `func(on: bool)` | Takes the mouse wheel while playing (true) or gives it back: while taken, its steps are the mod's `wheel` events and the hotbar doesn't move. The game gives it back when the mod stops. | @@ -390,6 +400,16 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun | `smooth` | `bool` | Ease in and out through the game's field-of-view easing, as the spyglass does, instead of at once. | | `turn` | `f32` | Mouse turning is multiplied by it while zoomed: 1 keeps the player's sensitivity, at least 0.05. | +### record `minimap` + +| Field | Type | | +| --- | --- | --- | +| `corner` | `corner` | | +| `size` | `f32` | Its side in GUI pixels, 16 to 256. | +| `blocks-per-pixel` | `f32` | World blocks per map pixel, 0.5 to 4; the map is 128 × 128 pixels. | +| `rotate` | `bool` | The map turns with the player, who faces up, and an N on its rim marks north. Otherwise north is up and the player's arrow turns. | +| `round` | `bool` | Round, the corners left clear; otherwise square. | + | Function | Signature | What it does | | --- | --- | --- | | `set-hud` | `func(shapes: list)` | Replaces the mod's HUD shapes: up to 1024, drawn every frame in order over the HUD (after the hotbar, under chat and screens), hidden with the HUD (F1). An empty list removes them. | @@ -400,6 +420,7 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun | `text-width` | `func(text: string) -> f32` | The width of one line of text in GUI pixels, in the HUD's font: exact for Latin letters (U+0000 to U+024F), 6 per other character. | | `frame-stats` | `func() -> frame-rate` | The game's frame counter, recomputed twice a second. | | `set-zoom` | `func(zoom: zoom)` | Zooms the camera until the next call (`factor` 1 ends it), only while playing: a screen opening or the spyglass's own view (which wins) leave the camera vanilla's. With several mods, the strongest zoom counts. | +| `set-minimap` | `func(minimap: option)` | Shows a map of the world around the player in `corner`, stacked with the game's overlays and the mods' panels, until the next call (none hides it). It looks like a map item: vanilla's map colours with their height shading and water depth, and the player's arrow. Underground, under a roof and in the Nether it maps the floor around the player's height. The game keeps the map's tiles and refreshes them within its own frame budget; hidden, they are dropped. One map shows at a time: the first loaded mod's. | ## `events` @@ -423,3 +444,76 @@ What the game calls. Only the hooks `init` asks for are ever called. | `frame` | `func(seconds: f32)` | Each rendered frame, with the seconds since the last one. | | `command` | `func(name: string, args: string) -> result, string>` | `/name args`: ok(some(text)) is shown as feedback, err(text) in red. | | `chat` | `func(text: string)` | Each chat line the player receives, as plain text. | + +## `players` + +Access: capability `players`. + +Capability `players`, server mods only (manifest `api = "0.3"`, experimental): the players on the server, and messages to them. + +### enum `game-mode` + +| Case | | +| --- | --- | +| `survival` | | +| `creative` | | +| `adventure` | | +| `spectator` | | + +### record `player` + +| Field | Type | | +| --- | --- | --- | +| `id` | `string` | The player's UUID, `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`. | +| `name` | `string` | | +| `x` | `f64` | Feet position, in blocks. | +| `y` | `f64` | | +| `z` | `f64` | | +| `dimension` | `string` | `minecraft:overworld`, `minecraft:the_nether`, ... | +| `game-mode` | `game-mode` | | +| `health` | `f32` | Hit points as vanilla counts them: 20 is full health without effects. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `online` | `func() -> list` | The players online, in the order they joined. | +| `tell` | `func(player: string, text: string) -> bool` | A system message to one player, after the mod's name; false when no player with that id is online. Up to 8 messages per call. | +| `broadcast` | `func(text: string)` | A system message to every player and the server's log, after the mod's name. Counts toward the same 8 per call. | + +## `server-events` + +Access: exported by the mod: the game calls it. + +What the server calls in a server mod (manifest `api = "0.3"`, experimental). Only the hooks `init` asks for are ever called. The player in each event is as the server saw them when it happened. + +### type `player` + +`type player = player` + +### record `registration` + +| Field | Type | | +| --- | --- | --- | +| `commands` | `list` | Commands players may type, without the slash. A name vanilla already uses is refused (vanilla's command runs). | +| `tick` | `bool` | Call `tick` every server tick (20 per second). | +| `joins` | `bool` | Call `player-joined` and `player-left`. | +| `chat` | `bool` | Call `chat` for each chat message a player sends. | +| `blocks` | `bool` | Call `block-broken` and `block-placed`. | + +### record `block-pos` + +| Field | Type | | +| --- | --- | --- | +| `x` | `s32` | | +| `y` | `s32` | | +| `z` | `s32` | | + +| Function | Signature | What it does | +| --- | --- | --- | +| `init` | `func() -> result` | Once, after loading. An error keeps the mod off and is logged. | +| `tick` | `func(tick: u64)` | Each server tick, with the server's tick counter. | +| `player-joined` | `func(player: player)` | A player joined the server; they are in `players.online` already. | +| `player-left` | `func(player: player)` | A player left the server; they are no longer in `players.online`. | +| `chat` | `func(player: player, text: string)` | A chat message a player sent, as plain text. | +| `command` | `func(player: player, name: string, args: string) -> result, string>` | `/name args` typed by `player`: ok(some(text)) is their feedback, err(text) their error in red. | +| `block-broken` | `func(player: player, pos: block-pos, state: string)` | A player broke the block at `pos` in their dimension: `state` is what was there, as `minecraft:oak_log[axis=y]`. | +| `block-placed` | `func(player: player, pos: block-pos, state: string)` | A player placed `state` at `pos` in their dimension. | diff --git a/docs/api/mods.md b/docs/api/mods.md index 7b8c5a464..59f4221a3 100644 --- a/docs/api/mods.md +++ b/docs/api/mods.md @@ -13,14 +13,14 @@ the player before the mod is turned on, and checked against the component's real | | Count | | --- | --- | -| Interfaces the game offers | 5: `log`, `game`, `chat`, `hud`, `storage` | -| Functions in them | 9 | -| Hooks a mod exports | 5: `init`, `tick`, `frame`, `command`, `chat` | -| Capabilities | 5: `game-read`, `chat`, `hud`, `storage`, `registries` | -| Manifest `api` lines served | 2: `0.1` (code), `0.2` (content) | -| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers | -| `cargo horizon-mod` | `new` (templates `code` and `content`), `build`, `run`, `check` | -| Example mods | `coords-hud` (code), `ruby-content` (content) | +| Interfaces the game offers | 6: `log`, `game`, `chat`, `hud`, `storage`; `players` for server mods | +| Functions in them | 12 | +| Hooks a mod exports | 5: `init`, `tick`, `frame`, `command`, `chat`; a server mod 8: `init`, `tick`, `player-joined`, `player-left`, `chat`, `command`, `block-broken`, `block-placed` | +| Capabilities | 6: `game-read`, `chat`, `hud`, `storage`, `registries`, `players` | +| Manifest `api` lines served | 3: `0.1` (code), `0.2` (content), `0.3` (server mods, experimental) | +| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers; `server::ServerMod` (8 methods), `server::Registration` (5 builders), `export_server_mod!` | +| `cargo horizon-mod` | `new` (templates `code` and `content`), `build`, `run`, `test`, `check` | +| Example mods | `coords-hud` (code), `ruby-content` (content), `welcome` (server) | ## Guide @@ -33,7 +33,10 @@ The step-by-step guide, from installing the tools to publishing on the registry, ([The manifest](../mods.md#the-manifest)). 3. `cargo horizon-mod run` builds the `.hmod` and starts the game with it as a dev mod; after an edit, `cargo horizon-mod build` and the running game reloads it. -4. Content mods: [Content mods (API 0.2)](../mods.md#content-mods-api-02). +4. `cargo horizon-mod test` runs the mod's `tests/*.toml` scripts in the sandbox, with no game: ticks, commands, + chat lines and the player's position in, chat, feedback and the HUD panel checked + ([Testing a mod](../mods.md#testing-a-mod)). +5. Content mods: [Content mods (API 0.2)](../mods.md#content-mods-api-02). ## Reference @@ -46,6 +49,8 @@ call, 4 MiB of storage, fuel per call). - `crates/horizon-mod-sdk/examples/coords-hud`: coordinates, facing and time on the HUD; `/where`, `/coords`; storage. - `crates/horizon-mod-sdk/examples/ruby-content`: no code; a gem and a block of ruby from vanilla templates, with their recipes, loot, tags, models, textures and names. +- `crates/horizon-mod-sdk/examples/welcome`: a server mod; greets players who join, announces newcomers (kept in + storage), `/online` and `/mined`. - `crates/horizon-mods/tests/guest`: a mod that misbehaves on command (spins, panics, grows its memory), for the sandbox tests. @@ -75,15 +80,16 @@ scripting runtime in the game. ## Stability Preview ([stability.md](stability.md)): API 0.1 and content 0.2 are served together; a mod built for 0.1.0 keeps -loading on every 0.1.x game. Server mods come as their own line, `api = "0.3"`, experimental first. +loading on every 0.1.x game. Server mods are their own line, `api = "0.3"`, experimental: they may change in any +release. ## Not there yet What real mods need next, in the order modpacks and servers need it: -- **Server mods** (`api = "0.3"`): the same component running on the server thread and the dedicated server, with world events (block - broken or placed, entity spawned or killed, player joined or left), game rules and server commands with typed - arguments. +- **Server mods in the game** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): the + contract, runtime and SDK are here; next the server thread, LAN host and dedicated server start them and call + their hooks, then entity events, game rules and server commands with typed arguments. - **World and blocks**: read blocks, block states and biomes in loaded chunks; change them through the server's block log, so clients and the parity harnesses see vanilla's updates. - **Items and inventories**: the player's inventory, held item and open container; item stacks with components. @@ -94,11 +100,14 @@ What real mods need next, in the order modpacks and servers need it: - **Config**: typed settings the game shows and stores for the mod, on the server too. - **Keys and the crosshair target**: keybinds in Controls; what the player is looking at. - **Script mods and other languages**: see [Ways in](#ways-in). -- **SDK**: a headless test runner (load a mod, feed it ticks and events, assert on its output, no window), templates - per kind of mod, typed wrappers in the SDK for every interface. Dev mods already reload when rebuilt. +- **SDK**: templates per kind of mod, typed wrappers in the SDK for every interface. Dev mods already reload when + rebuilt, and `cargo horizon-mod test` runs a mod headless. ## Changelog +- API 0.3 (server mods, experimental): world `horizon-server-mod`, capability `players`, the `server-events` + hooks; SDK `server::ServerMod`; example `welcome`. +- SDK: `cargo horizon-mod test` and `horizon_mods::testing`, test scripts in TOML; the template has one. - Experimental: `ui` button widget; `render.set-corner`, `text-width`, `frame-stats`; `input.mapping`, `clicks-per-second` (what the official FPS, keystrokes and zoom mods need). - Experimental `input` (`experimental = ["input"]`): `claim-items`, `register-key`, `held`, `poll` (use-start, diff --git a/docs/api/shaders.md b/docs/api/shaders.md index 675c5e3fc..7461332e4 100644 --- a/docs/api/shaders.md +++ b/docs/api/shaders.md @@ -91,11 +91,12 @@ pack exist ([stability.md](stability.md)). ## Not there yet -The stages and everything that runs a pack (the format above is read and checked). The order: the renderer hooks shared with the format loader, then the material and post -stages with options and hot reload, then the overlay, lighting, sky and shadow stages. +The material stage in the game (the sky and post stages run, with hot reload), option values other than the defaults, +then the overlay, lighting and shadow stages. ## Changelog +- 2026-10-26: the sky stage in the game: the pack's `sky` gets vanilla's colour along each ray. - 2026-10-26: the post stage in the game (`HORIZON_SHADER_PACK`, hot reload with the last good pack kept). - 2026-10-25: `horizon-shader` (`new`, `check`, `pack`), three templates, the example pack and the guide. - 2026-10-25: the check (naga validation, signatures, options, budgets, SPIR-V/Metal/HLSL translation). diff --git a/docs/api/stability.md b/docs/api/stability.md index 132c971f9..65cfc0c13 100644 --- a/docs/api/stability.md +++ b/docs/api/stability.md @@ -26,12 +26,29 @@ promise, how something is deprecated and removed, and the tests that keep old mo ## What counts as a breaking change Breaking: removing or renaming anything; changing a type, a default, a unit or a meaning; making something optional -required; refusing input that was accepted; a new case in a WIT `enum` or `variant` the game sends to mods (an older -component cannot decode it); a JSON field that changes type. +required; refusing input that was accepted; any change to a WIT type a function uses, a new `enum` or `variant` case +included, in either direction (the runtime links a component only when each imported function's types match exactly: +a mod built before the change no longer loads); a JSON field that changes type. Not breaking: a new function, interface, capability, command, endpoint, tool or `server.toml` key; a new optional -argument or JSON field (readers must ignore fields they don't know); a new WIT case the mod *sends* (the game decodes -every case it ever served); faster, or fixing behaviour to what the reference already says. +argument or JSON field (readers must ignore fields they don't know); a new WIT function or type (mods built earlier +don't import it); faster, or fixing behaviour to what the reference already says. + +### Mod API levels + +A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every +function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`): +level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`. A mod needs the level of +the newest function it imports (a component imports only the functions it calls). The level is read from the file, +never declared: + +- the game refuses a mod that needs a function it doesn't have, with "made for a newer Horizon (it uses + render.set-minimap): update Horizon to run it", instead of a linking error; +- the registry's CI writes each mod version's level into the index (`api_level`), and installers take the newest + version the running game can run. + +A pull request that adds a function lists it in `api_level.rs` at the next level and raises `LEVEL`; the +`api_reference` test fails until it does. ## Stability levels @@ -91,7 +108,7 @@ Deprecations and breaking changes are in bold. The release notes of the game rel | Mod API: `render` (HUD shapes, camera shake and zoom; drawn by the game, no mod shaders) | experimental | manifest `experimental = ["render"]` | | Mod API: `input` (claimed items' use, the mod's keys, the mouse wheel) | experimental | manifest `experimental = ["input"]` | | Content mods (`registries`: data-driven blocks and items) | preview | manifest `api = "0.2"` | -| Server mods (events, world, server commands) | not started | manifest `api = "0.3"`, experimental first | +| Server mods: world `horizon-server-mod`, `players`, `server-events` | experimental | manifest `api = "0.3"` | | Script mods (Lua run by an interpreter mod, [mods.md](mods.md#ways-in)) | not started | | | `cargo horizon-mod` (`new`, `build`, `run`), `horizon-mod-sdk` | preview | 0.1.0 | | Shader API | not started | | @@ -113,3 +130,7 @@ Deprecations and breaking changes are in bold. The release notes of the game rel keys may consume too is decided before `input` becomes preview. - **`input`'s `wheel` event** is a new case in a variant the game sends, so it breaks mods built before it (allowed because `input` is experimental): an `input` mod that calls `poll` needs a rebuild against the new WIT. +- **`render.set-minimap`** draws a map the game makes, not one a mod composes: reading the blocks around the player + for a map image costs too much through hook calls, so the game keeps the tiles (vanilla's map colours) and the mod + picks the corner, side, scale and shape. One map shows at a time, the first loaded mod's. It is a new function and a + new type, so mods built before it keep loading. diff --git a/docs/architecture.md b/docs/architecture.md index f95073e57..0350bd1ea 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -51,7 +51,7 @@ file selects ~103. | 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` | | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser | | 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle | -| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e --server-thread` (portals, levels, distance, lava) | +| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e` (server-thread by default; portals, levels, distance, lava) | | 38 | Command parsing (34) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) | | 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) | | 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet | diff --git a/docs/extras.md b/docs/extras.md index 26ddbe161..ac0196c17 100644 --- a/docs/extras.md +++ b/docs/extras.md @@ -1,8 +1,7 @@ # Horizon extras -Optional conveniences built into the client: fullbright, dynamic lights, zoom, a minimap, an FPS counter, a -keystroke overlay, auto-reconnect, Mouse Tweaks-style inventory controls and -inventory sorting. **Every one is off by default**: a fresh +Optional conveniences built into the client: fullbright, dynamic lights, auto-reconnect, +Mouse Tweaks-style inventory controls and inventory sorting. **Every one is off by default**: a fresh install looks and behaves exactly like vanilla 26.3, and turning an extra off again restores vanilla's behaviour completely. @@ -11,10 +10,10 @@ again restores vanilla's behaviour completely. | Part | Code | |---|---| | Settings, parsing and saving | `crates/horizon-client/src/extras.rs` | -| Zoom curve, FPS and click counters | `extras.rs` (pure logic, unit tested) | +| FPS and click counters (for mods) | `extras.rs` (pure logic, unit tested) | | Dynamic lights: item glow, nearest sources | `crates/horizon-client/src/dynamic_light.rs` (unit tested), `game/dynamic_lights.rs`, `terrain.wgsl` and `entity.wgsl` (`dynamic_block_light`) | -| HUD drawing (FPS, keystrokes, minimap frame) | `crates/horizon-client/src/extras_hud.rs` | -| Minimap colours, tiles and image | `crates/horizon-client/src/minimap.rs` | +| HUD drawing (a mod's minimap, corner stacking) | `crates/horizon-client/src/extras_hud.rs` | +| Minimap colours, tiles and image (for `render.set-minimap`) | `crates/horizon-client/src/minimap.rs` | | Reconnect policy and backoff | `crates/horizon-client/src/reconnect.rs` | | Game glue (input hooks, per-frame update) | `crates/horizon-client/src/game/extras.rs` | | Mouse Tweaks-style controls, sort buttons | `crates/horizon-client/src/game/tweaks.rs` | @@ -35,10 +34,9 @@ extras stay out of the way of other input and options work. `horizon-graphics.txt`. `options.txt` is untouched, so a vanilla client can share the folder. Unknown or broken lines fall back to the defaults. -The zoom key is a Horizon setting stored in that file (`zoomKey:key.keyboard.z`) -and bound on the Extras page, not in vanilla's Key Binds screen: Horizon has no -Horizon category in Controls, and adding one would put a non-vanilla mapping into -`options.txt`. +Extras' keys (the sort key) are Horizon settings stored in that file and bound on +the Extras page, not in vanilla's Key Binds screen: Horizon has no Horizon category +in Controls, and adding one would put a non-vanilla mapping into `options.txt`. ## The extras @@ -62,50 +60,25 @@ Horizon category in Controls, and adding one would put a non-vanilla mapping int - Off: nothing is gathered and the shaders' loop runs zero times (the count is 0), so it costs nothing measurable (numbers in the pull request, #814). -### Zoom (`zoom`, default off) -- Hold the zoom key (default **Z**, unused by every vanilla 26.3 key mapping; C - is `key.saveToolbarActivator`) to zoom. The key does nothing while zoom is off. -- It zooms only while playing: in chat, signs, books, text fields and every - other screen the key is typed or handled as usual. The key is never taken - from vanilla's mappings: one bound to the same key still acts (a key bound - twice triggers both, as vanilla's do), and the Extras page marks the zoom key - "Also bound" and names the mapping. -- Starts at the default level (4x, settable 2x to 10x); the scroll wheel changes - it while the key is held (and does not move the hotbar then). -- **Smooth** (default on) goes through vanilla's own FOV easing: the zoom divides - the field-of-view modifier target `Camera.tickFov` eases toward, the path the - spyglass uses (`AbstractClientPlayer.getFieldOfViewModifier` returns 0.1 while - scoping). The modifier keeps vanilla's 0.1 floor, so 10x is the deepest zoom. - Off applies the zoom to the final FOV with no easing. -- While scoping with a spyglass the zoom does nothing: the spyglass view and its - overlay stay exactly vanilla's. -- **Slower turning** (default on) divides mouse turning by the zoom factor. -- With zoom off (or the key up) the FOV target and mouse are vanilla's, bit for - bit; the FOV harness covers this. +### Moved to the mod browser -### FPS counter (`fps`, default off) -- A small "N fps" line in a corner (default top left), optionally followed by - the minimum and the 1% low over the last 5 seconds. -- Separate from the Advanced graphics "Overlay" (the frame-time graph). +The **FPS counter**, **Keystrokes**, **Zoom** and the **Minimap** are official mods now (`mods/official/`, [mods.md](mods.md#horizons-official-mods)), +with the same look and options. On the first start after the update, a player who had one on gets the mod installed +from Horizon's registry and turned on, with their corner and options carried over (Zoom's key too, into +`horizon-mods.txt`, when it wasn't Z), and reads one line in the chat ("Zoom moved to the mod browser: installed for +you"). The install is checked like the launcher's (size, +SHA-256, signature, manifest); if it fails (offline), the next start tries again. `horizon-extras.txt` keeps the old +keys and lists what was done in `movedToMods`. Code: `crates/horizon-client/src/moved_extras.rs`, +`game/moved_extras.rs`. -### Keystrokes (`keystrokes`, default off) -- W A S D, Space, LMB and RMB keys that light up while held, with clicks per - second under the mouse buttons (clicks in the last second). The letters follow - the bound keys. - -### Minimap (`minimap`, default off) -- A corner map (top right by default), square or round, small/medium/large, - zoom 0.5 to 4 blocks per pixel, rotating with the player or north up, with the - player arrow (vanilla's map decoration sprite). -- Colours are vanilla's `MapColor` per block, as map items use, with the map - item's height shading and water-depth dithering. -- Underground, in the Nether and under any roof, it maps the floor around the - player's height instead of the top block, so caves read sensibly. -- Cost: one cached 16x16 tile per loaded chunk (packed map colour and height). - Tiles are filled nearest first and refreshed when blocks change, within a time - budget of 0.3 ms a frame; composing the 128x128 image is a few thousand - lookups, done only when the view moved or a tile changed, and uploaded into a - dedicated atlas slot. With the minimap off nothing runs. +The game still draws the minimap, for the mod (`render.set-minimap`, [mods.md](mods.md)): +- a corner map (top right by default), square or round, small/medium/large, zoom 0.5 to 4 blocks per pixel, rotating + with the player or north up, with the player arrow (vanilla's map decoration sprite); +- vanilla's `MapColor` per block, as map items use, with the map item's height shading and water-depth dithering; +- underground, in the Nether and under any roof, the floor around the player's height instead of the top block; +- one cached 16x16 tile per loaded chunk (packed map colour and height), filled nearest first and refreshed when + blocks change within 0.3 ms a frame; the 128x128 image is recomposed only when the view moved or a tile changed, and + uploaded into a dedicated atlas slot. With no mod showing a map, nothing runs. ### Auto-reconnect (`autoReconnect`, default off) - On the "Connection lost" screen after a multiplayer connection drops, a @@ -162,11 +135,11 @@ and the container screen tests are unchanged). the world, like vanilla's HUD. Extras in the top left corner give way to the debug screen (F3), which shows the FPS anyway. - Corners stack: extras placed in the same corner stack downward (top corners) - or upward (bottom corners) in the order minimap, FPS, keystrokes. The top + or upward (bottom corners) in the order a mod's minimap, then mods' panels. The top right corner starts below the status effect icons. ## Perf budget Off: a flag check per frame per extra (no allocations, no world access). -On: FPS and keystrokes are a few quads; the minimap stays under 0.3 ms of CPU +A mod's minimap stays under 0.3 ms of CPU per frame (tile budget) plus a 64 KiB texture upload when its image changes. diff --git a/docs/horizon-ctl-commands.md b/docs/horizon-ctl-commands.md index 394aac5bf..9b3d792c7 100644 --- a/docs/horizon-ctl-commands.md +++ b/docs/horizon-ctl-commands.md @@ -94,7 +94,7 @@ Every command `horizon-ctl` takes, its MCP tool in `horizon-ctl mcp` (the launch | `respawn` | `respawn` | Respawn from the death screen | none | | `pause` | `pause` | Open the pause menu | none | | `resume` | `resume` | Leave the pause menu | none | -| `options [PAGE]` | `options` | Open the options screen, or one of its pages (Horizon's too) | `page` (main, video, sound, controls, keybinds, controller, controller-binds, mouse, chat, accessibility, language, font, packs, mods, graphics, graphics-advanced, extras, horizon, agent): the page (default: the main options) | +| `options [PAGE]` | `options` | Open the options screen, or one of its pages (Horizon's too) | `page` (main, video, sound, controls, keybinds, controller, controller-binds, mouse, chat, accessibility, language, font, packs, mods, shader-packs, graphics, graphics-advanced, extras, horizon, agent): the page (default: the main options) | | `book [next\|back\|take\|done]` | `book` | The open book or lectern: its page text, or press one of its buttons | `action` (next, back, take, done): a button to press | | `signedit X Y Z [front\|back]` | `signedit` | Open the sign editor of the sign at X Y Z (then type and close) | `x` (integer, required): block X
`y` (integer, required): block Y
`z` (integer, required): block Z
`side` (front, back): which side | | `mount-menu` | `mount_menu` | Open the inventory of the horse, donkey, mule or llama being ridden | none | diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md index 7c9562441..f3ef37977 100644 --- a/docs/launcher-commands.md +++ b/docs/launcher-commands.md @@ -321,7 +321,7 @@ Search for packs Horizon loads. horizon-launcher mods search [TEXT]... - `TEXT` -- `--kind` (mod, resource, modpack) +- `--kind` (mod, resource, modpack, shader) - `--everything`: Also what was made for other versions or runs only partly, each marked - `--source` (modrinth, curseforge, horizon) diff --git a/docs/mod-browser.md b/docs/mod-browser.md index a803420c3..dfdd1617d 100644 --- a/docs/mod-browser.md +++ b/docs/mod-browser.md @@ -1,7 +1,7 @@ # The launcher's mod browser -Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks, resource packs and shader -packs, see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in +Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks and resource packs, and Horizon's +registry for Horizon's own mods, modpacks, resource packs and shader packs; see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in `launcher/src/browser.rs` and `launcher/src/browser/`. ## What it offers @@ -16,6 +16,7 @@ yet (Modrinth has no `horizon` loader). | Java mods (Fabric, NeoForge, Forge, Quilt) | ported into `horizon-mods//` and turned on | Checked from its jar before install: **Works**, **Partly** or **Doesn't run** ([below](#java-mods)) | | Resource packs | `resourcepacks/` beside `options.txt` | **Works** when made for 26.3 ([resource-packs.md](resource-packs.md) lists what Horizon reads). Older packs are **Partly**: they load with vanilla's compatibility warning | | Modpacks (`.mrpack`, CurseForge zip) | the Modpacks page's import | **Partly**: Horizon runs the mods it can port, from the player's own downloads ([modpacks.md](modpacks.md)) | +| Shader packs (`.hshader`, Horizon's registry only) | `shaderpacks/` beside `options.txt` | **Works** when made for 26.3: checked by the game's own check before install ([shaders.md](shaders.md)). The `shaders/`-format packs on Modrinth and CurseForge are not offered | By default a search shows only what runs: Java mods made for 26.3, resource packs made for 26.3, and every modpack. **Show everything** lists the rest of the kind too, each marked with how well it runs; what doesn't run is never offered for install. @@ -74,7 +75,8 @@ start); the hedge places and its recipe crafts 4. ## The Mods page -The launcher's **Mods** page has the three kinds as tabs (Mods, Modpacks, Resource packs), a search field (Enter searches), **Show everything** and +The launcher's **Mods** page has the four kinds as tabs (Mods, Modpacks, Resource packs, Shader packs; the last +searches Horizon's registry), a search field (Enter searches), **Show everything** and the source: Modrinth, with **CurseForge (coming soon)** beside it, disabled. Each result is an index row: its summary, author, downloads, source and licence, how well it runs (and why), **Page** (the project's page on its source) and **Install** (**Import** for a modpack). The Modpacks tab lists the imported packs first, with their coverage @@ -125,7 +127,8 @@ same name the player put there is never overwritten. - **Install** picks the newest version that runs, then its required dependencies, checked before any download: a dependency that isn't a pack Horizon loads (a Java mod) stops the install. Dependencies go in first. A resource - pack still has to be turned on in the game's Resource Packs screen, as in vanilla. + pack still has to be turned on in the game's Resource Packs screen, as in vanilla, and a shader pack picked in + the game's Shader Packs page. - **Update** installs the newer version and removes the old file. - **Remove** deletes the file and its entry. Packs installed as dependencies stay. - **A modpack** is downloaded (checked the same way) into `ports/downloads/`, imported, and ported straight away @@ -149,7 +152,7 @@ horizon-launcher mods remove faithful-32x ## Sources -**Horizon's registry.** Mods (`.hmod`) and resource packs made for Horizon, reviewed as pull requests in +**Horizon's registry.** Mods (`.hmod`), modpacks (`.hpack`), resource packs and shader packs (`.hshader`) made for Horizon, reviewed as pull requests in [ludovic111/horizon-mods](https://github.com/ludovic111/horizon-mods) ([api/mod-index.md](api/mod-index.md)). The launcher reads its `index.json` (`browser/horizon.rs`; `HORIZON_MOD_INDEX=` reads a test registry instead, whose files may then be on disk) at most every ten minutes, and keeps the last copy in @@ -164,7 +167,8 @@ checked pack, `pack.json` and `home/`, the profile's game folder, where each of like any registry mod and turned on or off as the pack says; its overrides (settings, resource packs, a mod's saved settings) are copied in on the first install only, so the player's changes survive updates. A pack whose mod was taken down installs nothing. It is listed on the Modpacks tab with **Play** and **Remove**, and plays like an imported pack -(`modpacks::apply_profile`). Shader packs are listed by the index but not installed by this launcher yet. +(`modpacks::apply_profile`). A shader pack goes to `shaderpacks/` once `check_file` has run the game's own +check on it (`horizon_shader_api::check`); a taken-down one is named, for the player to remove. ```sh horizon-launcher mods search --source horizon --kind mod coords # with whether it is signed and what it may do diff --git a/docs/modpacks.md b/docs/modpacks.md index 13ad619ed..8e3980dd2 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -504,21 +504,22 @@ Two cases the oracle fills in: mod. Better Dungeons' small dungeons keep one chest and each other one with a fifth's chance, two at most (the game's `horizon:count_cap`, counted per placement as the mod's DungeonContext is): 12 chests in five small dungeons at seed 1234 become 6. - Lithostitched's `block_swap` (137 lists, all in ChoiceTheorem's Overhauled Village) is the - game's `horizon:block_swap`: the same map, with Block.withPropertiesOf's properties kept; - a target block the game does not have (most of them are Nature's Spirit's and Croptopia's) - leaves the block as it is, as the mod does. Lithostitched's `reference` (CTOV builds most - of its lists from others) has the referenced lists' processors written in its place; its - `apply_random`, `condition` and `set_block` are the game's `horizon:apply_random`, - `horizon:condition` and `horizon:set_block`, with Lithostitched's random (the world seed - plus the name's hash, at the block, piece or structure). In a CTOV plains village at seed - 1234 the farms now grow carrots, potatoes and beetroot besides wheat, and 1,655 - cobblestone blocks become paths, grass, mossy cobblestone and planks. No Lithostitched processor is - dropped now (130 before). CTOV's compat hooks for other mods inside them (its - `modular_compat`, 142 copies) run a list of their own only when the mod they name is - loaded: carry writes that list in when the mod is ported along and takes the hook out (a - no-op, as in the mod) when it is not. In ATM10 all 142 name Nature's Spirit, which the - pack does not have. + Lithostitched's processors (all in ChoiceTheorem's Overhauled Village in ATM10) are the + game's own types, read as the mod writes them. `block_swap` keeps the properties the new + block can have: a farm's ripe wheat becomes ripe carrots, but beetroot, whose age stops at + 3, keeps its default; a target block the game does not have (most are Nature's Spirit's and + Croptopia's) leaves the block as it is. `reference` runs the lists it names, `condition` + tests the template's block or the world's, `apply_random` and `set_block` draw per block or + per piece as the data says. Lithostitched's own random is not known yet, so the shares of a + random choice are the Java pack's but the blocks chosen differ. Lists named by tag and state + providers other than simple and weighted ones are dropped and counted (ATM10 has none). + CTOV's compat hooks for other mods (its `modular_compat`, 30 of them in 17 lists) become a + `reference` when the mod they name is ported along, and are taken out (a no-op, as in the + mod) when it is not. In ATM10 they all name Nature's Spirit, which the pack does not have. + In Java, Lithostitched also lays out every jigsaw structure its own way (villages, + outposts, trial chambers; CTOV's villages are `lithostitched:jigsaw`, carried as vanilla's + jigsaw). Horizon keeps vanilla's layouts, so with Lithostitched in a pack, structure layouts + differ from the Java pack's for the same seed (their positions do not). The processors that build outside their template are carried too: Repurposed's and Moog's pillar processors become the game's `horizon:pillar` (a column from a placeholder block down to the ground, with the processor list they run on each of its blocks written diff --git a/docs/mods.md b/docs/mods.md index 03fcf39ae..49d30eed6 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -15,9 +15,9 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | The contract (WIT) | `crates/horizon-mod-sdk/wit/horizon.wit` | 0.1: log, game-read, chat, hud, storage, command, ui; tick, frame, chat and command hooks | | SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 | | Example mods | `crates/horizon-mod-sdk/examples/coords-hud`, `examples/predator-missile` | coordinates, facing and time HUD, `/where`, `/coords`; `/missile`, a guided missile from vanilla commands | -| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes | +| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap | | Runtime | `crates/horizon-mods` | wasmtime 48 LTS, component model | -| Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / check`, and the registry's CI (`registry build / review / list`) | +| Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / test / check`, and the registry's CI (`registry build / review / list`) | | In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods | | Launcher mod browser (Modrinth, CurseForge with a key) | [mod-browser.md](mod-browser.md) | resource packs, modpacks | | Registry index (`index.json`, `.hpack`), signatures | `horizon_mods::index`, [api/mod-index.md](api/mod-index.md) | schema 1; launcher and website next | @@ -89,8 +89,8 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call | | `command` | `command` | `run(line)`: a vanilla command run as the player, with the player's permissions, after the hook returns (8 per call); mods' own commands are not run | | `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code. **Experimental:** the manifest needs `experimental = ["ui"]` | -| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` | -| `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` | +| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` | +| `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key..:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` | | Hook (export) | When | |---|---| @@ -120,7 +120,7 @@ loading. Ordered by what the first native ports need: | `world-read` | blocks and biomes around the player, within the render distance | minimaps, schematics | | `render` (world) | world-space lines, boxes and billboards, beside the HUD shapes `render` has | Litematica-style placement, waypoints | | `registries` | new blocks, items, entities and recipes, mostly data: JSON models, textures, loot and recipes in the `.hmod`'s `assets/` and `data/` | server side; see [Multiplayer](#multiplayer) | -| `server` | world events (block break/place, entity spawn/death, player join), game rules, server commands | runs where the world is simulated | +| `server` | world events (entity spawn/death), game rules, world read/write, typed server commands | after [server mods 0.3](#server-mods-api-03-experimental)'s players, chat, blocks and commands | | `net` | a mod's own client↔server channel (custom payloads) | only between the two halves of the same mod | There is no file, socket, process or raw-input interface, on purpose. @@ -220,11 +220,12 @@ Benchmarks (`--benchmark`) never load mods. ```sh rustup target add wasm32-unknown-unknown cargo install --git https://github.com/ludovic111/horizon cargo-horizon-mod -cargo horizon-mod new my-mod # Cargo.toml, horizon-mod.toml, src/lib.rs +cargo horizon-mod new my-mod # Cargo.toml, horizon-mod.toml, src/lib.rs, tests/hello.toml # (--template content: a content mod, no code) cd my-mod cargo horizon-mod run # build, then start the game with it cargo horizon-mod build # again after an edit: the running game reloads it +cargo horizon-mod test # build, then run tests/*.toml with no game ``` `run` starts `horizon-client` (on `PATH`, or `--game PATH`, or @@ -245,13 +246,85 @@ and each of its commands: it must start and never trap or overrun. It checks a `.hpack` and a resource pack `.zip` too, and a signature with `--key --signature .minisig`. +### Testing a mod + +`cargo horizon-mod test` builds the mod, then runs each `tests/.toml` in +the sandbox the game uses, with no game and no window: the test plays the +game's part (the player and the clock the mod reads, ticks, frames, chat lines, +commands; for a server mod, players joining, chatting, typing commands, +breaking and placing blocks and leaving) and checks what the mod showed. A script fails at its first wrong +step, with what it expected and what it got; the command fails if any script +does. `--debug` builds without optimizing, `--hmod ` tests a `.hmod` +already built, and a name runs only the scripts whose path holds it. Each +script gets a scratch copy of the mod, so its `storage` starts empty and is +removed afterwards. + +```toml +# tests/panel.toml (examples/coords-hud) +[player] # where the script starts; unset fields keep the defaults +x = 12.5 # (0.5 64 0.5, yaw 0, 20 health and food, the Overworld) +z = -3.25 +yaw = 180.0 + +[clock] # day-time 0 is 6:00 on day 1; each tick adds one +day-time = 29999 + +[[step]] +ticks = 1 +expect.panel = ["XYZ 12.5 / 64.0 / -3.2", "Facing North (-Z)", "Day 2, 12:00"] +expect.corner = "top-left" + +[[step]] +command = "coords" +expect.feedback = "Coordinates panel hidden" +``` + +A step's parts happen in this order: + +| Key | Does | +| --- | --- | +| `reload = true` | stops the mod and starts it again, as a rebuild does in the game: its memory starts over, its `storage` stays | +| `title-screen = true` | no player and no clock until a step sets them | +| `player = { x = 3.0, ... }`, `clock = { day-time = 0 }` | changes those fields (`x y z yaw pitch health food dimension`, `game-time day-time`) | +| `ticks = n`, `frames = n` | that many ticks (the game's tick counter and the clock move on), then frames 1/60 s apart | +| `chat = " hi"` | a chat line the player receives | +| `command = "where north"` | the player types `/where north`; a command the mod doesn't own fails the step | +| `break = { x = 1, y = 63, z = 0, state = "minecraft:stone" }`, `place = { ... }` | server mods: the player breaks or places that block | +| `leave = "Alex"` | server mods: that player leaves | + +A server mod starts with nobody on: `join = "Alex"` (after `reload` and `title-screen`) brings a +player in at the defaults, in survival, with the id +`00000000-0000-4000-8000-000000000001` for the first name that joined, `...2` +for the second, the same id when a name joins again. `player`, `chat`, +`command`, `break` and `place` are then that player's doing: the one named by +`as = "Steve"`, or the first one on. `player` takes `game-mode` there, and the +script's own `[player]` and `[clock]` are a client mod's. + +Then `expect` checks what the mod did during the step; a key left out is not +checked: + +| `expect.` | Checks | +| --- | --- | +| `commands = ["where"]` | the commands the mod owns | +| `chat = ["..."]` | every chat line it showed, in order (`[]`: none) | +| `feedback = "..."`, `error = "..."` | the command's answer, shown plain or in red | +| `panel = ["..."]`, `corner = "top-left"` | its HUD panel's lines (`[]`: no panel) and corner | +| `told = ["Alex: Welcome!"]`, `broadcast = ["..."]` | server mods: every `players.tell` (as `name: text`) and `players.broadcast`, in order | +| `stopped = "panic"` | the mod was turned off, for a reason holding this text; without it, a mod that traps, panics or overruns fails the test | + +Unknown keys are errors, so a typo never passes silently. The same runner is +`horizon_mods::testing` for Rust code that drives a mod (`TestGame`, +`Script`): Horizon's own tests run the examples' scripts with it. Scripts test +any mod, whatever it was written in. + ### Template layout ``` my-mod/ ├── Cargo.toml # cdylib, horizon-mod-sdk, release: opt-level "s", LTO ├── horizon-mod.toml # the manifest -└── src/lib.rs # impl Mod, export_mod! +├── src/lib.rs # impl Mod, export_mod! +└── tests/hello.toml # cargo horizon-mod test ``` A mod is a type implementing `horizon_mod_sdk::Mod`; its state lives in the @@ -391,6 +464,38 @@ none. "top": "carve", "bottom": "none", "rigid_junctions": true, "inflate": true } } ``` +### Server mods (API 0.3, experimental) + +A server mod runs where the world is simulated: on the dedicated server, on a +LAN host and on single player's own server, never in a player's window. Its +manifest says `side = "server"` and `api = "0.3"` (and only a server mod may); +its component targets the WIT world `horizon-server-mod` instead of +`horizon-mod`. Experimental: it may change in any release +([stability](api/stability.md)). + +| Interface | Capability | Functions | +|---|---|---| +| `log` | always | as for client mods | +| `storage` | `storage` | as for client mods, in the server's `horizon-mods/` | +| `players` | `players` | `online()`: id, name, position, dimension, game mode, health of each player on; `tell(id, text)`, `broadcast(text)`: system messages after the mod's name, 8 per call | + +| Hook (export `server-events`) | When | +|---|---| +| `init() -> result` | once, after loading | +| `tick(tick)` | each server tick | +| `player-joined(player)`, `player-left(player)` | `registration.joins` | +| `chat(player, text)` | `registration.chat`: each chat message a player sends | +| `command(player, name, args)` | `/name args` typed by a player, for a command it registered; `ok(some)` is that player's feedback, `err` their red error | +| `block-broken(player, pos, state)`, `block-placed(player, pos, state)` | `registration.blocks`, with the state as `minecraft:oak_log[axis=y]` | + +Capabilities that act on a local player (`game-read`, `chat`, `hud`) are for +client mods; `players` is for server mods. In Rust: `impl +horizon_mod_sdk::server::ServerMod` and `export_server_mod!`; the example is +[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs). The +runtime, the registry's `check` and the SDK run them today; the game starts +them once its server code calls these hooks (the next step), and until then a +server mod that is turned on shows as run elsewhere. + ## Publish your mod Horizon's registry lists mods, modpacks (`.hpack`) and resource packs made for Horizon, each reviewed before it is @@ -428,6 +533,8 @@ so the same rustc and `Cargo.lock` give the same file. |---|---|---|---| | FPS Counter | `fps_overlay` | Extras > FPS counter | `corner`: `top_left` (default), `top_right`, `bottom_left`, `bottom_right`; `lows`: `false` (default), `true` | | Keystrokes | `keystrokes` | Extras > Keystrokes | `corner`: as above, default `top_left`; `cps`: `true` (default), `false` | +| Zoom | `zoom` | Extras > Zoom | `level`: `2`, `3`, `4` (default), `6`, `8`, `10`; `smooth`: `true` (default), `false`; `sensitivity` (slower turning): `true` (default), `false`. The key is the game's: `key.zoom.zoom` in `horizon-mods.txt`, default `key.keyboard.z` | +| Minimap | `minimap` | Extras > Minimap | `corner`: as above, default `top_right`; `size`: `64`, `96` (default), `128`; `shape`: `square` (default), `round`; `zoom` (blocks per pixel): `0.5`, `1` (default), `2`, `4`; `rotate`: `false` (default), `true`. The game draws the map (`render.set-minimap`) | ## Versions and compatibility @@ -438,6 +545,12 @@ so the same rustc and `Cargo.lock` give the same file. release cycle, so existing mods keep working while authors move. - The manifest's `api` names the line it needs (`0.1`); the game refuses a line it does not serve with a clear message. +- Within a line, each function has an API level, the one it arrived at + ([stability](api/stability.md#mod-api-levels)). A mod needs the level of + the newest function it calls, read from its file: an older Horizon refuses + it with "made for a newer Horizon: update Horizon", and the registry lists + the level so installers take a version the game can run. + `cargo horizon-mod check` prints it ("needs mod API level 1 or newer"). - Horizon follows Minecraft releases; the mod API does not have to. Vanilla concepts mods see (dimensions, block and item ids) are the game's own ids, so a version port changes the data, not the API. diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index e8e030c83..5eaac1a1d 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -53,7 +53,7 @@ A harness can declare, at the top level of its script: ### Which harnesses a change affects -`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `.local/parity-runner/reach-cache.json`. `--by-crate` turns the narrowing off. On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses. +`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses. ## The gate @@ -111,3 +111,53 @@ and shrieker. They supplement the deterministic component comparisons. ## Reading vanilla Besides the Vineflower sources in `.local/minecraft//sources/`, `tools/rea_vanilla.py` queries the shipped bytecode through REA (callers through lambdas, overloads, a second decompiler); see [decompilation status](decompilation-status.md#querying-the-shipped-bytecode-with-rea). + +## Player-facing integration and deterministic fixtures + +`python3 tools/lan_e2e.py` runs every LAN check with an integrated server thread, +the same path as normal single player. `python3 tools/test_friends.py --client +target/fast/horizon-client --relay target/fast/horizon-relay --baseline` covers +plain LAN, direct invitations, a local relay and ended invitations in that mode. +Both accept `--in-frame` for comparison and retain `--server-thread` for existing +callers. Run Linux games under `xvfb-run -a` when no display is available. Each +process gets scratch game, launcher, XDG data and config homes; telemetry, audio +and launcher self-update are disabled. + +`lan_integration` and `friends_integration` register these suites with `parity.py`. +`friends_integration` (under a minute) is selected like any harness when the +drivers or game implementation change. `lan_integration` is the whole LAN suite +(~40 minutes on a loaded runner, and single checks flake under load), so +`tools/parity_hosts.json` lists it under `named_only`: no automatic selection +(`--changed`, `--failed`, `--flake-check`, CI, parity-main) picks it; it runs +when named and in the nightly audit (`--all`). LAN writes `results.json` +with the host mode and each result beside its screenshots and logs. A skipped +case is recorded explicitly and does not count as passing coverage. + +The game-binary fixture audit keeps these complementary direct rule tests: + +- `command_harness.rs`: command feedback, styled spans and result callbacks, + held player position, explicit ticks and portal completion matching + `VanillaCommandExecOracle`. LAN `commands`, `feedback`, `styles`, `levels` and + `portals` cover command input, packet feedback and travel across the boundary. +- `dispense_fixture.rs`: seeded synthetic worlds, block/event traces, item + use/mining and combat hooks matching `VanillaDispenserOracle`. These isolate + rule results and RNG order; LAN machines, crafting, clicks, fireball, mining + and combat exercise real input and server handling separately. The new + `dispenser_input_host` / `dispenser_input_guest` checks press a button and + verify authoritative inventory consumption and exactly one drop on both clients. +- `sculk_fixture.rs`: scripted events and exact per-tick sculk/warden traces + matching `VanillaSculkOracle`; introducing wall-clock network ticks would + destroy that deterministic oracle contract. `sculk_input_host` and + `sculk_input_guest` separately exercise real footsteps reaching a sensor; + failures remain visible rather than changing the oracle trace. +- `net_harness.rs`: already a real network client of a dedicated server; keep + its handshake, world loading, chat and command packet assertions. + +Library probes, `lan_bot`'s protocol hub fixture, generation/save tests and +streaming/mesh tests remain fast deterministic coverage. They do not become +full game launches. Setup and authoritative reads use the owning server; +interactions stay on the client. `server-hold on|off` provides a prediction-test +barrier between server ticks, including player packet handling, while transport +threads and control calls remain responsive. `stall MILLISECONDS` stalls only +the window to test recovery from a hung frame without process signals interrupting +socket reads. Neither mechanism changes normal gameplay. diff --git a/docs/shaders.md b/docs/shaders.md index ef8521cfe..d64ca041c 100644 --- a/docs/shaders.md +++ b/docs/shaders.md @@ -13,8 +13,9 @@ Horizon's own format. | Authoring tool | `horizon-shader` (same crate) | `new`, `check`, `pack` | | Templates | `crates/horizon-shader-api/templates/` | post, sky, material | | Example pack | `crates/horizon-shader-api/packs/golden_hour` | a warm sky and two post passes | -| In the game: the post stage | `HORIZON_SHADER_PACK=` (for development, until the Shader Packs page) | post passes, hot reload | -| In the game: sky and material; the launcher and the registry | | not yet | +| In the game: the sky and post stages | Options > Horizon Settings > Shader Packs | sky, post passes, hot reload | +| The registry and the launcher | `shader` kind ([api/mod-index.md](api/mod-index.md)); the Mods page's Shader packs tab | checked, then installed into `shaderpacks/` | +| In the game: the material stage | | not yet | ## Quick start @@ -46,12 +47,14 @@ my_pack 0.1.0 (shader API 0.1): FAILED ## Trying a pack in the game -Until the Shader Packs page lists them, put the pack folder (or its `.hshader`) in `shaderpacks/` beside `options.txt` -and start the game with `HORIZON_SHADER_PACK=`. The game checks the pack first, and refuses -one that fails, with its problems in the chat. While it runs, the game looks at the pack twice a second: save a file +Put the pack folder (or its `.hshader`) in `shaderpacks/` beside `options.txt` (Open Pack Folder opens it) and pick +it on Options > Horizon Settings > Shader Packs, which lists Horizon's packs, marked (Horizon), beside packs in the +`shaders/` format; one runs at a time, and clicking it again turns it off. `HORIZON_SHADER_PACK=` runs a pack whatever the page says, for development. The game checks the pack first, and refuses one that +fails, with its problems in the chat. While it runs, the game looks at the pack twice a second: save a file and the pack is checked and rebuilt in place ("Shader pack ... reloaded"); if the new version fails, the chat says -where and the last good version keeps drawing. The post passes run today; the sky and material stages are checked -but not drawn yet. +where and the last good version keeps drawing. The sky and post stages run today; the material stage is checked but +not drawn yet. ## A pack @@ -86,7 +89,7 @@ by Horizon: a pack changes how things look, not how they are drawn. | Stage | Your function | What it does | | --- | --- | --- | -| `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray; the sun, moon, stars and clouds are drawn over it | +| `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray, opaque (alpha is ignored), drawn where vanilla draws its sky dome (the Overworld's sky; not the Nether's or the End's); the sun, moon, stars and clouds are drawn over it | | `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog | | `[[post]]` | `fn post(input: PostInput) -> vec4` | a full-screen pass over the world's picture (up to 8, in order), under the hand and HUD | @@ -127,11 +130,11 @@ one keeps drawing), the launcher before it installs one, and the registry's CI b 6. Every entry point translated for Vulkan (SPIR-V), Metal and DirectX 12 (HLSL), with the options at their defaults, minimums and maximums. -`[budget] gpu_ms` is the GPU time your pack aims to add to a frame; the game's overlay will show each pass's time -against it. +`[budget] gpu_ms` is the GPU time your pack aims to add to a frame. To compare, open F3 in the game: while it is +open, each pass is timed on the GPU and the overlay shows the pack's total and its costliest passes, by their `name` +(the median of the last 15 timed frames). Timing waits for nothing, so it does not slow the game. In a timed frame the sky +stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. ## Next -The renderer hooks (shared with the Iris/OptiFine loader), then the post stage in the game with hot reload and the -GPU time per pass, Options > Shader packs listing these packs, then the material and sky stages, and the registry's -`shader` kind with installs from the launcher. +The material stage in the game. diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock index ee0cb882a..dd9313df6 100644 --- a/launcher/Cargo.lock +++ b/launcher/Cargo.lock @@ -565,7 +565,16 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" dependencies = [ - "bit-vec", + "bit-vec 0.8.0", +] + +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec 0.9.1", ] [[package]] @@ -574,6 +583,12 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + [[package]] name = "bit_field" version = "0.10.3" @@ -611,7 +626,7 @@ dependencies = [ "ash-window", "bitflags 2.13.2", "bytemuck", - "codespan-reporting", + "codespan-reporting 0.12.0", "glow", "gpu-alloc", "gpu-alloc-ash", @@ -621,7 +636,7 @@ dependencies = [ "libloading", "log", "mint", - "naga", + "naga 25.0.1", "objc2", "objc2-app-kit", "objc2-core-foundation", @@ -1037,6 +1052,15 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "unicode-width", +] + [[package]] name = "color_quant" version = "1.1.0" @@ -2295,7 +2319,7 @@ dependencies = [ "log", "lyon", "metal", - "naga", + "naga 25.0.1", "num_cpus", "objc", "oo7", @@ -2560,6 +2584,11 @@ name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash 0.2.0", + "serde", + "serde_core", +] [[package]] name = "heck" @@ -2700,12 +2729,14 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2 0.10.9", "toml 1.1.8+spec-1.1.0", + "wasmparser", "zip", ] @@ -2742,6 +2773,19 @@ dependencies = [ "ring", ] +[[package]] +name = "horizon-shader-api" +version = "0.1.0" +dependencies = [ + "bytemuck", + "naga 30.0.1", + "serde", + "serde_json", + "sha2 0.10.9", + "toml 1.1.8+spec-1.1.0", + "zip", +] + [[package]] name = "horizon-telemetry" version = "0.1.0" @@ -3543,10 +3587,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b977c445f26e49757f9aca3631c3b8b836942cb278d69a92e7b80d3b24da632" dependencies = [ "arrayvec", - "bit-set", + "bit-set 0.8.0", "bitflags 2.13.2", "cfg_aliases", - "codespan-reporting", + "codespan-reporting 0.12.0", "half", "hashbrown 0.15.5", "hexf-parse", @@ -3555,12 +3599,50 @@ dependencies = [ "num-traits", "once_cell", "rustc-hash 1.1.0", - "spirv", + "spirv 0.3.0+sdk-1.3.268.0", "strum 0.26.3", "thiserror 2.0.21", "unicode-ident", ] +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set 0.10.0", + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "codespan-reporting 0.13.1", + "half", + "hashbrown 0.17.1", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "rustc-hash 1.1.0", + "spirv 0.4.0+sdk-1.4.341.0", + "thiserror 2.0.21", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown 0.17.1", + "indexmap", + "rustc-hash 1.1.0", + "thiserror 2.0.21", +] + [[package]] name = "nanorand" version = "0.7.0" @@ -5405,6 +5487,15 @@ dependencies = [ "bitflags 2.13.2", ] +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags 2.13.2", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -6516,6 +6607,19 @@ dependencies = [ "web-sys", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags 2.13.2", + "hashbrown 0.17.1", + "indexmap", + "semver", + "serde", +] + [[package]] name = "wayland-backend" version = "0.3.17" diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index a2d870a84..dba6bcd25 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -422,6 +422,37 @@ pub fn version_dir(tag: &str) -> PathBuf { const COMPLETE: &str = ".installed"; +/// The mod API level of the game players run: the selected version's, else the newest installed +/// one's. None with no version installed: the launcher doesn't know yet which game will run mods. +pub fn game_mod_api_level() -> Option { + let installed = installed(); + let tag = Settings::load() + .selected + .filter(|s| installed.contains(s)) + .or_else(|| installed.into_iter().next())?; + Some(mod_api_level(&tag)) +} + +/// A game version's mod API level, read once from the mark its program carries +/// (`horizon_mods::api_level::MARK`). A program from before the mark serves level 0, the +/// contract of Horizon 0.2.67 and 0.2.68. +pub fn mod_api_level(tag: &str) -> u32 { + static LEVELS: Mutex> = Mutex::new(Vec::new()); + let mut levels = LEVELS.lock().unwrap_or_else(|e| e.into_inner()); + if let Some(&(_, level)) = levels.iter().find(|(t, _)| t == tag) { + return level; + } + let level = program_mod_api_level(&version_dir(tag).join(CLIENT)); + levels.push((tag.to_owned(), level)); + level +} + +/// The mod API level in the game program at `path`: its mark's, else 0. +fn program_mod_api_level(path: &Path) -> u32 { + let program = fs::read(path).unwrap_or_default(); + horizon_mods::api_level::read_mark(&program).unwrap_or(0) +} + /// Installed versions, newest tag first. pub fn installed() -> Vec { installed_in(&versions_dir()) @@ -2557,6 +2588,24 @@ mod tests { use super::*; use std::cmp::Ordering::*; + /// The game program's mod API level is its mark's; a program from before the mark (0.2.68 + /// and older) or none at all serves level 0. + #[test] + fn a_game_program_says_its_mod_api_level() { + let dir = std::env::temp_dir().join(format!("horizon-api-level-{}", std::process::id())); + fs::create_dir_all(&dir).unwrap(); + let marked = dir.join("marked"); + let mut program = b"\x7fELF code code".to_vec(); + program.extend_from_slice(b"horizon-mod-api-level:0007;"); + fs::write(&marked, &program).unwrap(); + let old = dir.join("old"); + fs::write(&old, b"\x7fELF code without a mark").unwrap(); + assert_eq!(program_mod_api_level(&marked), 7); + assert_eq!(program_mod_api_level(&old), 0); + assert_eq!(program_mod_api_level(&dir.join("missing")), 0); + fs::remove_dir_all(&dir).unwrap(); + } + /// A preparation that reuses the imported game files still reads the assets from the /// launcher that has them: a Prism Launcher instance's are in the launcher root, linked into /// the official layout (jan.sonki on Discord: silent, grey title screen since 0.2.48). diff --git a/launcher/src/browser.rs b/launcher/src/browser.rs index 7f81d5e37..295ba3c08 100644 --- a/launcher/src/browser.rs +++ b/launcher/src/browser.rs @@ -28,16 +28,20 @@ pub enum Kind { Modpack, /// A Java mod: its content is ported ([`java`]). Mod, + /// One of Horizon's own shader packs (`.hshader`, docs/shaders.md), from Horizon's registry + /// only. + Shader, } impl Kind { - pub const ALL: [Kind; 3] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack]; + pub const ALL: [Kind; 4] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack, Kind::Shader]; pub fn label(self) -> &'static str { match self { Kind::Mod => "Mods", Kind::ResourcePack => "Resource packs", Kind::Modpack => "Modpacks", + Kind::Shader => "Shader packs", } } @@ -46,6 +50,7 @@ impl Kind { pub fn folder(self) -> Option<&'static str> { match self { Kind::ResourcePack => Some("resourcepacks"), + Kind::Shader => Some("shaderpacks"), Kind::Modpack | Kind::Mod => None, } } @@ -237,6 +242,9 @@ pub trait Source: Send + Sync { /// What the launcher says wherever CurseForge would be. pub const CURSEFORGE_SOON: &str = "CurseForge support is coming soon."; +/// What another source answers for shader packs: Horizon's own are on its registry only. +pub const SHADERS_ON_HORIZON: &str = + "Horizon's shader packs are on Horizon's registry: pick Horizon."; /// The sources this launcher uses: Modrinth and Horizon's registry. CurseForge support is coming /// soon: its API needs a paid key, so no search or install goes to it; `curseforge` is kept for @@ -277,6 +285,7 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp Kind::Modpack => { Support::Partial("Horizon runs the mods it can port, from your own downloads.".into()) } + Kind::Shader => Support::No("Not one of Horizon's own shader packs.".into()), Kind::Mod => { if !loaders.iter().any(|l| java::LOADERS.contains(&l.as_str())) { Support::No("Not a Fabric, NeoForge or Forge mod.".into()) diff --git a/launcher/src/browser/curseforge.rs b/launcher/src/browser/curseforge.rs index e17a6b822..1db533a93 100644 --- a/launcher/src/browser/curseforge.rs +++ b/launcher/src/browser/curseforge.rs @@ -24,11 +24,16 @@ fn class(kind: Kind) -> u64 { Kind::ResourcePack => 12, Kind::Modpack => 4471, Kind::Mod => 6, + Kind::Shader => 6552, } } +/// The kind of a CurseForge class; its shader packs (the shaders/ format) are not offered. fn kind_of(class_id: u64) -> Option { - Kind::ALL.into_iter().find(|k| class(*k) == class_id) + Kind::ALL + .into_iter() + .filter(|k| *k != Kind::Shader) + .find(|k| class(*k) == class_id) } /// The key: the environment's, else the one built in. Empty counts as none. @@ -196,6 +201,9 @@ impl Source for CurseForge { } fn search(&self, query: &Query) -> Result, String> { + if query.kind == Kind::Shader { + return Err(super::SHADERS_ON_HORIZON.into()); + } let found = self.get(&search_url(query))?; Ok(found["data"] .as_array() diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs index 66553ab50..3bf465faf 100644 --- a/launcher/src/browser/horizon.rs +++ b/launcher/src/browser/horizon.rs @@ -111,13 +111,14 @@ fn fetch_index() -> Result<(Index, String), String> { } /// The browser's kind for a registry kind; None for one the launcher doesn't install yet -/// (shader packs, kinds newer than this launcher). +/// (kinds newer than this launcher). fn kind_of(kind: &index::Kind) -> Option { match kind { index::Kind::Mod => Some(Kind::Mod), index::Kind::ResourcePack => Some(Kind::ResourcePack), index::Kind::Modpack => Some(Kind::Modpack), - index::Kind::Shader | index::Kind::Other(_) => None, + index::Kind::Shader => Some(Kind::Shader), + index::Kind::Other(_) => None, } } @@ -167,7 +168,14 @@ fn project_of(p: &index::Project) -> Option { }) } -fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version { +/// Version `v` of `p` as the browser shows it; blocked when taken down, or when it needs a newer +/// mod API level than `level`, the game's. +fn version_of( + index: &Index, + p: &index::Project, + v: &index::Version, + level: Option, +) -> Version { Version { id: v.version.clone(), number: v.version.clone(), @@ -186,7 +194,8 @@ fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version required: v.requires.iter().map(|r| r.id.clone()).collect(), blocked: index .revoked(&p.id, &v.file.sha256) - .map(|r| format!("taken down: {}", r.reason)), + .map(|r| format!("taken down: {}", r.reason)) + .or_else(|| needs_newer(v, level).then(|| NEEDS_NEWER.to_string())), } } @@ -253,9 +262,10 @@ impl Source for Registry { let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; + let level = crate::backend::game_mod_api_level(); Ok(p.versions .iter() - .map(|v| version_of(&index, p, v)) + .map(|v| version_of(&index, p, v, level)) .collect()) } @@ -372,24 +382,29 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result { match kind { Kind::Mod => Ok(format!("{}/{id}.hmod", java::MODS_DIR)), Kind::ResourcePack => Ok(format!("resourcepacks/{file_name}")), + Kind::Shader => Ok(format!("shaderpacks/{file_name}")), Kind::Modpack => Err("A modpack installs as its own profile (pack::install).".into()), } } -/// Installs a registry project into the game folder `home`: its newest version for this game, -/// downloaded into `mod-browser/downloads/`, checked against the index, then moved into place. -/// A mod is `horizon-mods/.hmod`, turned on in `horizon-mods.txt`. +/// Installs a registry project into the game folder `home`: its newest version for this game that +/// the game the player runs can load, downloaded into `mod-browser/downloads/`, checked against +/// the index, then moved into place. A mod is `horizon-mods/.hmod`, turned on in +/// `horizon-mods.txt`. pub fn install( project: &Project, home: &Path, progress: &dyn Fn(&str, f32), ) -> Result, String> { - install_from(&*index()?, local(), project, home, progress) + let level = crate::backend::game_mod_api_level(); + install_from(&*index()?, local(), level, project, home, progress) } +/// [`install`] from `index`, for a game serving mod API `level`. fn install_from( index: &Index, local: bool, + level: Option, project: &Project, home: &Path, progress: &dyn Fn(&str, f32), @@ -397,28 +412,43 @@ fn install_from( let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; - let v = newest(index, p)?; + let v = newest(index, p, level)?; install_version(index, local, p, v, home, progress).map(|e| vec![e]) } -/// A project's newest version for this game that wasn't taken down. -fn newest<'a>(index: &Index, p: &'a index::Project) -> Result<&'a index::Version, String> { - let mut taken_down = None; +/// A project's newest version for this game that wasn't taken down and that a game serving mod +/// API `level` runs (any, when the level isn't known). +fn newest<'a>( + index: &Index, + p: &'a index::Project, + level: Option, +) -> Result<&'a index::Version, String> { + let (mut taken_down, mut too_new) = (None, false); for v in p.versions.iter().filter(|v| v.game == GAME) { - match index.revoked(&p.id, &v.file.sha256) { - None => return Ok(v), - Some(r) => { - taken_down.get_or_insert(r); - } + if let Some(r) = index.revoked(&p.id, &v.file.sha256) { + taken_down.get_or_insert(r); + } else if needs_newer(v, level) { + too_new = true; + } else { + return Ok(v); } } Err(match taken_down { + _ if too_new => format!("{} {NEEDS_NEWER}: update it first.", p.name), Some(r) => format!("{} was taken down: {}", p.name, r.reason), None => format!("{} has no version for {GAME} to install.", p.name), }) } -/// Installs version `v` of the registry's mod or resource pack `p` into the game folder `home`. +const NEEDS_NEWER: &str = "needs a newer Horizon than the game you play"; + +/// Whether version `v` calls mod API functions a game serving `level` doesn't have. +fn needs_newer(v: &index::Version, level: Option) -> bool { + matches!((v.api_level, level), (Some(needed), Some(level)) if needed > level) +} + +/// Installs version `v` of the registry's mod, resource pack or shader pack `p` into the game +/// folder `home`. fn install_version( index: &Index, local: bool, @@ -447,15 +477,19 @@ fn install_version( other.title )); } - if (target.exists() && old.as_ref().is_none_or(|o| o.file != relative)) || folder_mod.exists() { + let clash = target.exists() && old.as_ref().is_none_or(|o| o.file != relative); + if project.kind == Kind::Mod && (clash || folder_mod.exists()) { return Err(format!( "A mod with the id {} is already in {}: move it away first.", p.id, java::MODS_DIR )); } + if clash { + return Err(format!("{relative} is already there: move it away first.")); + } let line = format!("{} {}", p.name, v.version); - let file = &version_of(index, p, v).files[0]; + let file = &version_of(index, p, v, None).files[0]; let staging = home.join("mod-browser/downloads"); let path = fetch(file, &staging, local, &|f| progress(&line, f))?; let trust = index::check_file(index, p, v, &path).inspect_err(|_| { @@ -518,7 +552,7 @@ pub fn turn_off_revoked(index: &Index, home: &Path) -> Vec { e.title, r.reason )); } - } else if e.kind == Kind::ResourcePack { + } else if matches!(e.kind, Kind::ResourcePack | Kind::Shader) { out.push(format!( "{} was taken down: {} Remove it.", e.title, r.reason diff --git a/launcher/src/browser/horizon/pack.rs b/launcher/src/browser/horizon/pack.rs index 3cb6d7c9b..95235a505 100644 --- a/launcher/src/browser/horizon/pack.rs +++ b/launcher/src/browser/horizon/pack.rs @@ -84,7 +84,7 @@ fn install_in( if p.kind != idx::Kind::Modpack { return Err(format!("{} is a {}, not a modpack.", p.name, p.kind.name())); } - let v = newest(index, p)?; + let v = newest(index, p, None)?; let work = dir.join(&p.id); let fresh = !work.exists(); let result = install_version_in(index, local, p, v, &work, progress); diff --git a/launcher/src/browser/horizon/tests.rs b/launcher/src/browser/horizon/tests.rs index fb99462e1..7e1b8f585 100644 --- a/launcher/src/browser/horizon/tests.rs +++ b/launcher/src/browser/horizon/tests.rs @@ -48,6 +48,7 @@ fn searches_by_kind_and_words() { // Modpacks under Modpacks; a kind this launcher can't install yet (a world) never. assert_eq!(found("", Kind::Modpack), ["cozy"]); assert!(found("skyblock", Kind::ResourcePack).is_empty()); + assert_eq!(found("", Kind::Shader), ["glow"]); let p = hud(&index); assert_eq!(p.support(), super::super::Support::Works); assert_eq!(p.page, "https://playhorizon.dev/mods/coords_hud"); @@ -58,7 +59,7 @@ fn installs_checked_turns_on_and_removes() { let index = sample(); let home = scratch("install"); let p = hud(&index); - let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(done[0].file, "horizon-mods/coords_hud.hmod"); assert_eq!(done[0].verdict.as_deref(), Some("Verified")); assert!(done[0].checksum.starts_with("SHA-256:e1135345")); @@ -72,7 +73,7 @@ fn installs_checked_turns_on_and_removes() { 0 ); // Installed already: nothing to do. - let again = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let again = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(again, done); let mut revoked = index.clone(); @@ -95,6 +96,41 @@ fn installs_checked_turns_on_and_removes() { fs::remove_dir_all(&home).unwrap(); } +#[test] +fn installs_a_shader_pack_into_shaderpacks() { + let index = sample(); + let home = scratch("shader"); + let p = project_of(index.project("glow").unwrap()).unwrap(); + assert_eq!(p.support(), super::super::Support::Works); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); + assert_eq!(done[0].file, "shaderpacks/glow-1.0.0.hshader"); + assert_eq!(done[0].kind, Kind::Shader); + assert!(home.join("shaderpacks/glow-1.0.0.hshader").is_file()); + // Not a mod: nothing turns on in horizon-mods.txt; the game's Shader Packs page picks it. + assert!(!home.join("horizon-mods.txt").exists()); + + let mut revoked = index.clone(); + revoked.revoked.push(index::Revoked { + id: "glow".into(), + sha256: None, + reason: "Test.".into(), + date: String::new(), + }); + let said = turn_off_revoked(&revoked, &home); + assert_eq!(said, ["Soft Glow was taken down: Test. Remove it."]); + + installed::remove(&home, "glow").unwrap(); + assert!(!home.join("shaderpacks/glow-1.0.0.hshader").exists()); + // A file of the same name the registry didn't put there is left alone. + fs::write(home.join("shaderpacks/glow-1.0.0.hshader"), b"mine").unwrap(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); + assert_eq!( + e, + "shaderpacks/glow-1.0.0.hshader is already there: move it away first." + ); + fs::remove_dir_all(&home).unwrap(); +} + #[test] fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { let index = sample(); @@ -104,15 +140,15 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { let mut tampered = index.clone(); let cozy = tampered.projects[1].versions[0].file.url.clone(); tampered.projects[0].versions[0].file.url = cozy; - let e = install_from(&tampered, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&tampered, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("larger than its source says"), "{e}"); assert!(!home.join("horizon-mods").exists()); - let e = install_from(&index, false, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, false, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("file servers"), "{e}"); fs::create_dir_all(home.join("horizon-mods/coords_hud")).unwrap(); - let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("already in horizon-mods"), "{e}"); let mut taken_down = index.clone(); @@ -122,7 +158,7 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { reason: "Test.".into(), date: String::new(), }); - let e = install_from(&taken_down, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&taken_down, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert_eq!(e, "Coordinates HUD was taken down: Test."); fs::remove_dir_all(&home).unwrap(); } @@ -139,7 +175,7 @@ fn registry_versions_run_when_made_for_this_game() { let versions: Vec = p .versions .iter() - .map(|x| version_of(&index, p, x)) + .map(|x| version_of(&index, p, x, None)) .collect(); assert_eq!(pick(Kind::Mod, &versions, false).unwrap().number, "0.1.0"); } @@ -162,3 +198,21 @@ fn owner_links_only_take_github_logins() { assert!(!github_login(bad), "{bad}"); } } + +/// A version that calls mod API functions the game doesn't have is marked and skipped. +#[test] +fn versions_for_a_newer_horizon_are_not_installed() { + let mut index = sample(); + index.projects[0].versions[0].api_level = Some(1); + let p = index.project("coords_hud").unwrap(); + let e = newest(&index, p, Some(0)).unwrap_err(); + assert_eq!( + e, + "Coordinates HUD needs a newer Horizon than the game you play: update it first." + ); + assert!(newest(&index, p, Some(1)).is_ok()); + assert!(newest(&index, p, None).is_ok()); + let v = version_of(&index, p, &p.versions[0], Some(0)); + assert_eq!(v.blocked.as_deref(), Some(NEEDS_NEWER)); + assert_eq!(version_of(&index, p, &p.versions[0], Some(1)).blocked, None); +} diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs index 52e0aa7f0..dabd9a604 100644 --- a/launcher/src/browser/modrinth.rs +++ b/launcher/src/browser/modrinth.rs @@ -13,12 +13,15 @@ fn project_type(kind: Kind) -> &'static str { Kind::ResourcePack => "resourcepack", Kind::Modpack => "modpack", Kind::Mod => "mod", + Kind::Shader => "shader", } } +/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered. fn kind_of(project_type: &str) -> Option { Kind::ALL .into_iter() + .filter(|k| *k != Kind::Shader) .find(|k| self::project_type(*k) == project_type) } @@ -170,6 +173,9 @@ impl Source for Modrinth { } fn search(&self, query: &Query) -> Result, String> { + if query.kind == Kind::Shader { + return Err(super::SHADERS_ON_HORIZON.into()); + } let found = get(&search_url(query))?; Ok(found["hits"] .as_array() diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index 25bbe0bee..64ddb1bd2 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -210,6 +210,8 @@ enum KindArg { Mod, Resource, Modpack, + /// Horizon's own shader packs (Horizon's registry only) + Shader, } #[derive(Clone, Copy, clap::ValueEnum)] @@ -1120,6 +1122,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> { KindArg::Resource => Kind::ResourcePack, KindArg::Modpack => Kind::Modpack, KindArg::Mod => Kind::Mod, + KindArg::Shader => Kind::Shader, }; let query = Query { everything, diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index e420576b5..45763296a 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -394,7 +394,7 @@ mod tests { let kinds = &schema["inputSchema"]["properties"]["kind"]["enum"]; assert!( kinds.as_array().unwrap().contains(&json!("modpack")) - && !kinds.as_array().unwrap().contains(&json!("shader")), + && kinds.as_array().unwrap().contains(&json!("shader")), "{kinds}" ); assert_eq!( diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 9105f71a2..7d778b6b9 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -54,11 +54,11 @@ enum Page { } impl Page { - /// `HORIZON_LAUNCHER_PAGE=mods` (or `modpacks`, `servers`, `versions`, `notes`, `settings`) - /// opens on that page, for screenshots; Home otherwise. + /// `HORIZON_LAUNCHER_PAGE=mods` (or `modpacks`, `shaders`, `servers`, `versions`, `notes`, + /// `settings`) opens on that page, for screenshots; Home otherwise. fn from_env() -> Page { match std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() { - Ok("mods" | "modpacks") => Page::Mods, + Ok("mods" | "modpacks" | "shaders") => Page::Mods, Ok("servers") => Page::Servers, Ok("versions") => Page::Versions, Ok("notes") => Page::Notes, diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs index 50434756c..e6ebedc5b 100644 --- a/launcher/src/mods_page.rs +++ b/launcher/src/mods_page.rs @@ -14,10 +14,11 @@ use horizon_port_pack::check::Check; use std::collections::HashMap; /// The kinds, as the Mods page's tabs: name and icon. -const KINDS: [(PackKind, &str, &str); 3] = [ +const KINDS: [(PackKind, &str, &str); 4] = [ (PackKind::Mod, "Mods", "box"), (PackKind::Modpack, "Modpacks", "archive"), (PackKind::ResourcePack, "Resource packs", "image"), + (PackKind::Shader, "Shader packs", "zap"), ]; /// Java mods checked at once. const CHECKING: usize = 2; @@ -99,14 +100,18 @@ impl Mods { pub(super) fn new(cx: &mut App) -> Self { let (tx, rx) = channel(); + let page = std::env::var("HORIZON_LAUNCHER_PAGE"); + let kind = match page.as_deref() { + Ok("modpacks") => PackKind::Modpack, + Ok("shaders") => PackKind::Shader, + _ => PackKind::Mod, + }; Self { - kind: if std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() == Ok("modpacks") { - PackKind::Modpack - } else { - PackKind::Mod - }, - // `HORIZON_LAUNCHER_SOURCE=horizon` opens on Horizon's registry, for screenshots. + kind, + // `HORIZON_LAUNCHER_SOURCE=horizon` opens on Horizon's registry, for screenshots; + // shader packs are only there. source: match std::env::var("HORIZON_LAUNCHER_SOURCE").as_deref() { + _ if kind == PackKind::Shader => SourceId::Horizon, Ok("horizon") => SourceId::Horizon, _ => SourceId::Modrinth, }, @@ -602,9 +607,9 @@ impl Launcher { } let header = page_header( "Mods", - "Mods made for Horizon from its own reviewed registry, and Java mods, modpacks and \ - resource packs from Modrinth: Horizon ports what a Java mod carries (blocks, items, \ - recipes, worldgen) and says before you install what runs. Each file is checked \ + "Mods and shader packs made for Horizon from its own reviewed registry, and Java \ + mods, modpacks and resource packs from Modrinth: Horizon ports what a Java mod \ + carries (blocks, items, recipes, worldgen) and says before you install what runs. Each file is checked \ against its source's checksum before it reaches your game folder.", &t, ); @@ -615,6 +620,10 @@ impl Launcher { let _ = this.update(cx, |this, cx| { if this.mods.kind != kind { this.mods.kind = kind; + // Horizon's own shader packs are on its registry only. + if kind == PackKind::Shader { + this.mods.source = SourceId::Horizon; + } // Categories and loaders differ by kind. this.mods.browse.filters = Default::default(); this.mods.browse.open = None; diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java index d8c0483b6..0c02fa9aa 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java @@ -5,9 +5,12 @@ import io.netty.buffer.Unpooled; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.io.PrintStream; import java.io.PrintWriter; import java.net.InetSocketAddress; import java.net.Socket; @@ -76,7 +79,8 @@ import net.minecraft.world.phys.Vec3; * {@code step LABEL}, {@code join NAME}, {@code cmd NAME COMMAND...} (waits * for its feedback), {@code pos NAME X Y Z YAW PITCH GROUND} (one client tick * at that place, on the ground or not), {@code sprint NAME on|off}, {@code - * attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a + * sync NAME} (a round trip through the server thread; "synced NAME" on stdout when + * it is back), {@code attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a * player's name or an entity type's path, the last one added), {@code use * NAME} (ServerboundUseItemPacket, main hand) and {@code end}. Each player * records the ClientboundSetEntityMotionPacket it receives, its own sprint @@ -88,6 +92,8 @@ public final class KnockbackClient { private static final Map NAMES = new LinkedHashMap<>(); public static void main(String[] args) throws Exception { + // Bootstrap sends System.out to the logger: `synced` lines go to the real stdout. + PrintStream stdout = new PrintStream(new FileOutputStream(FileDescriptor.out), true, StandardCharsets.UTF_8); ParityData.init(); String host = args[0]; int port = Integer.parseInt(args[1]); @@ -116,6 +122,13 @@ public final class KnockbackClient { case "attack" -> players.get(w[1]).attack(w[2]); case "use" -> players.get(w[1]).send(new ServerboundUseItemPacket(InteractionHand.MAIN_HAND, 0, 0, 0)); case "punch" -> players.get(w[1]).send(net.minecraft.network.protocol.game.ServerboundPunchPacket.INSTANCE); + case "sync" -> { + try { + players.get(w[1]).sync(); + } finally { + stdout.println("synced " + w[1]); + } + } case "mark" -> players.get(w[1]).mark(); case "await" -> players.get(w[1]).await(); case "end" -> { @@ -157,6 +170,7 @@ public final class KnockbackClient { private final Map last = new java.util.concurrent.ConcurrentHashMap<>(); private final Object replyLock = new Object(); private int replies; + private int syncs; /** The motion packets about this player it was sent, and how many there were at the last `mark`. */ private int pushes; private int marked; @@ -181,6 +195,24 @@ public final class KnockbackClient { } } + /** A round trip through the server thread, its reply left out of the transcript: every packet this player + * was sent before the reply has been recorded when it returns. */ + void sync() throws Exception { + synchronized (replyLock) { + int before = syncs; + send(new ServerboundChatCommandPacket("time query gametime")); + long until = System.nanoTime() + 30_000_000_000L; + while (syncs == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to sync"); + return; + } + replyLock.wait(left); + } + } + } + void mark() { synchronized (replyLock) { marked = pushes; @@ -327,6 +359,13 @@ public final class KnockbackClient { for (var value : d.packedItems()) { if (value.id() == 0) record("sprinting " + ((((Byte) value.value()) & 8) != 0)); } + } else if (p instanceof ClientboundSystemChatPacket c + && c.content().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t + && t.getKey().equals("commands.time.query.gametime")) { + synchronized (replyLock) { + syncs++; + replyLock.notifyAll(); + } } else if (p instanceof ClientboundSystemChatPacket c) { record("chat " + c.content().getString()); synchronized (replyLock) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java index 09e9911d6..3390b37f6 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java @@ -10,6 +10,8 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Path; import java.util.ArrayList; import java.util.List; +import java.util.HashSet; +import java.util.Set; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GlyphSource; import net.minecraft.client.gui.font.glyphs.BakedGlyph; @@ -31,9 +33,13 @@ import net.minecraft.util.RandomSource; */ public final class ParityFont { public static ResourceManager resources() throws Exception { + return resources(Path.of("/nonexistent-horizon-assets")); + } + + public static ResourceManager resources(Path assets) throws Exception { var method = net.minecraft.client.resources.ClientPackSource.class.getDeclaredMethod("createVanillaPackSource", Path.class); method.setAccessible(true); - var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, Path.of("/nonexistent-horizon-assets")); + var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, assets); return pack.asResourceManager(); } @@ -50,6 +56,38 @@ public final class ParityFont { } } } + return create(providers); + } + + /** The full default font, including references and the external Unihex fallback. */ + public static Font createDefault(ResourceManager resources) throws Exception { + List providers = new ArrayList<>(); + loadProviders(resources, Identifier.withDefaultNamespace("default"), providers, new HashSet<>()); + return create(providers); + } + + private static void loadProviders(ResourceManager resources, Identifier font, List providers, + Set visiting) throws Exception { + if (!visiting.add(font)) throw new IllegalArgumentException("Cyclic font reference: " + font); + var file = font.withPath("font/" + font.getPath() + ".json"); + try (var reader = new InputStreamReader(resources.open(file), StandardCharsets.UTF_8)) { + var json = JsonParser.parseReader(reader).getAsJsonObject(); + for (var element : json.getAsJsonArray("providers")) { + var conditional = GlyphProviderDefinition.Conditional.CODEC.parse(JsonOps.INSTANCE, element).getOrThrow(); + if (!conditional.filter().apply(Set.of())) continue; + var definition = conditional.definition().unpack(); + if (definition.left().isPresent()) { + providers.add(definition.left().orElseThrow().load(resources)); + } else { + loadProviders(resources, definition.right().orElseThrow().id(), providers, visiting); + } + } + } finally { + visiting.remove(font); + } + } + + private static Font create(List providers) { GlyphSource source = new GlyphSource() { @Override public BakedGlyph getGlyph(int codepoint) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java index 9b3509e94..d3513d3ac 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java @@ -370,7 +370,7 @@ public final class VanillaPackScreenOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - font = ParityFont.create(ParityFont.resources()); + font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); Minecraft mc = alloc(Minecraft.class); put(mc, Minecraft.class, "font", font); put(mc, Minecraft.class, "lastInputType", InputType.MOUSE); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java index b48d45041..532c8823c 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java @@ -230,7 +230,7 @@ public final class VanillaTabListOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - Font font = ParityFont.create(ParityFont.resources()); + Font font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); var gson = new Gson(); var out = new StringBuilder(); for (String line : Files.readAllLines(Path.of(args[0]))) { @@ -284,6 +284,8 @@ public final class VanillaTabListOracle { put(mc, Minecraft.class, "user", user); var skins = skinManager(c); put(mc, Minecraft.class, "skinManager", skins); + var profiles = new ArrayList(); + var lookups = new ArrayList>(); for (var p : c.getAsJsonArray("players")) { var o = p.getAsJsonObject(); var uuid = UUID.fromString(o.get("uuid").getAsString()); @@ -296,12 +298,22 @@ public final class VanillaTabListOracle { : new Property("textures", t.get("value").getAsString(), sig.getAsString())); } var profile = new GameProfile(uuid, o.get("name").getAsString(), new PropertyMap(properties)); - // Let the lookup's unpacking and downloads run before the first frame, - // as they would have by the time a player list shows. - try { - skins.get(profile).get(1, java.util.concurrent.TimeUnit.SECONDS); - } catch (java.util.concurrent.TimeoutException pending) { - } + profiles.add(profile); + lookups.add(skins.get(profile)); + } + // Start every lookup before waiting: intentionally pending fake + // downloads must not add a second for each player in the list. + // Keep the same observation window and leave those futures pending. + try { + CompletableFuture.allOf(lookups.toArray(CompletableFuture[]::new)) + .get(1, java.util.concurrent.TimeUnit.SECONDS); + } catch (java.util.concurrent.TimeoutException pending) { + } + int profileIndex = 0; + for (var p : c.getAsJsonArray("players")) { + var o = p.getAsJsonObject(); + var profile = profiles.get(profileIndex++); + var uuid = profile.id(); var info = new PlayerInfo(profile, false); put(info, PlayerInfo.class, "gameMode", GameType.byId(o.get("gameMode").getAsInt())); put(info, PlayerInfo.class, "latency", o.get("latency").getAsInt()); diff --git a/mods/official/minimap/Cargo.toml b/mods/official/minimap/Cargo.toml new file mode 100644 index 000000000..e6aafb7c4 --- /dev/null +++ b/mods/official/minimap/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "minimap" +version = "1.0.0" +edition.workspace = true +license.workspace = true +publish = false +description = "Horizon's official minimap: a map of the terrain around you in a corner." + +[lib] +crate-type = ["cdylib"] + +[dependencies] +horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" } + +[lints] +workspace = true diff --git a/mods/official/minimap/horizon-mod.toml b/mods/official/minimap/horizon-mod.toml new file mode 100644 index 000000000..51bd7ef94 --- /dev/null +++ b/mods/official/minimap/horizon-mod.toml @@ -0,0 +1,9 @@ +id = "minimap" +name = "Minimap" +version = "1.0.0" +description = "A map of the terrain around you in a corner, in map colours, square or round, north up or turning with you. Horizon's own, formerly an extra." +authors = ["Horizon"] +api = "0.1" +side = "client" +capabilities = ["render", "ui", "storage"] +experimental = ["render", "ui"] diff --git a/mods/official/minimap/src/lib.rs b/mods/official/minimap/src/lib.rs new file mode 100644 index 000000000..ea8c45b72 --- /dev/null +++ b/mods/official/minimap/src/lib.rs @@ -0,0 +1,135 @@ +//! Horizon's official minimap, formerly the built-in extra: a map of the +//! terrain around the player in a corner (`render.set-minimap`; the game +//! keeps its tiles). Its settings page has the extra's five options, kept in +//! the mod's storage (`corner`, `size`, `shape`, `zoom`, `rotate`) with the +//! extra's values, where the game writes a player's old extra settings when +//! it installs the mod for them. +use horizon_mod_sdk::{ + Mod, Registration, + render::{self, Corner, Minimap as MapView}, + storage, + ui::{self, ButtonWidget, Widget}, +}; + +/// (corner, stored value, label), in the extra's order. +const CORNERS: [(Corner, &str, &str); 4] = [ + (Corner::TopLeft, "top_left", "Top left"), + (Corner::TopRight, "top_right", "Top right"), + (Corner::BottomLeft, "bottom_left", "Bottom left"), + (Corner::BottomRight, "bottom_right", "Bottom right"), +]; +/// (side in GUI pixels, label). +const SIZES: [(u8, &str); 3] = [(64, "Small"), (96, "Medium"), (128, "Large")]; +/// Blocks per map pixel. +const ZOOMS: [f32; 4] = [0.5, 1.0, 2.0, 4.0]; +/// Settings page buttons. +const CORNER_BUTTON: u32 = 1; +const SIZE_BUTTON: u32 = 2; +const SHAPE_BUTTON: u32 = 3; +const ZOOM_BUTTON: u32 = 4; +const ROTATE_BUTTON: u32 = 5; + +/// Indexes into the tables above, and the two switches. +struct Minimap { + corner: usize, + size: usize, + round: bool, + zoom: usize, + rotate: bool, +} + +impl Minimap { + fn show(&self) { + render::set_minimap(Some(MapView { + corner: CORNERS[self.corner].0, + size: f32::from(SIZES[self.size].0), + blocks_per_pixel: ZOOMS[self.zoom], + rotate: self.rotate, + round: self.round, + })); + } + fn page(&self) { + let button = |id, label: String| Widget::Button(ButtonWidget { id, label }); + let n = ZOOMS[self.zoom]; + let blocks = if n < 1.0 { + "½ block".to_owned() + } else if n == 1.0 { + "1 block".to_owned() + } else { + format!("{n} blocks") + }; + ui::set_settings(&[ + button(CORNER_BUTTON, format!("Corner: {}", CORNERS[self.corner].2)), + button(SIZE_BUTTON, format!("Size: {}", SIZES[self.size].1)), + button( + SHAPE_BUTTON, + format!("Shape: {}", if self.round { "Round" } else { "Square" }), + ), + button(ZOOM_BUTTON, format!("Zoom: {blocks} per pixel")), + button( + ROTATE_BUTTON, + format!( + "Turn with the player: {}", + if self.rotate { "ON" } else { "OFF" } + ), + ), + ]); + } + fn save(&self) { + let _ = storage::set("corner", CORNERS[self.corner].1.as_bytes()); + let _ = storage::set("size", SIZES[self.size].0.to_string().as_bytes()); + let _ = storage::set("shape", if self.round { b"round" } else { b"square" }); + let _ = storage::set("zoom", ZOOMS[self.zoom].to_string().as_bytes()); + let _ = storage::set("rotate", if self.rotate { b"true" } else { b"false" }); + } +} + +fn stored(key: &str) -> Option { + storage::get(key) + .and_then(|v| String::from_utf8(v).ok()) + .map(|v| v.trim().to_owned()) +} + +impl Mod for Minimap { + fn init() -> Result<(Self, Registration), String> { + // The extra's defaults: top right, medium, square, 1 block per + // pixel, north up. An unknown value keeps the default. + let find = |key: &str, values: &[String], default: usize| { + stored(key) + .and_then(|v| values.iter().position(|s| *s == v)) + .unwrap_or(default) + }; + let corners: Vec = CORNERS.iter().map(|c| c.1.to_owned()).collect(); + let sizes: Vec = SIZES.iter().map(|s| s.0.to_string()).collect(); + let zooms: Vec = ZOOMS.iter().map(f32::to_string).collect(); + let map = Minimap { + corner: find("corner", &corners, 1), + size: find("size", &sizes, 1), + round: stored("shape").as_deref() == Some("round"), + zoom: find("zoom", &zooms, 1), + rotate: stored("rotate").as_deref() == Some("true"), + }; + map.show(); + map.page(); + Ok((map, Registration::new())) + } + fn ui_select(&mut self, id: u32, _row: u32) { + let next = |i: usize, n: usize| (i + 1) % n; + match id { + CORNER_BUTTON => self.corner = next(self.corner, CORNERS.len()), + SIZE_BUTTON => self.size = next(self.size, SIZES.len()), + SHAPE_BUTTON => self.round = !self.round, + ZOOM_BUTTON => self.zoom = next(self.zoom, ZOOMS.len()), + ROTATE_BUTTON => self.rotate = !self.rotate, + _ => return, + } + self.save(); + self.show(); + self.page(); + } + fn ui_settings_opened(&mut self) { + self.page(); + } +} + +horizon_mod_sdk::export_mod!(Minimap); diff --git a/mods/official/zoom/Cargo.toml b/mods/official/zoom/Cargo.toml new file mode 100644 index 000000000..2225b00e8 --- /dev/null +++ b/mods/official/zoom/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "zoom" +version = "1.0.0" +edition.workspace = true +license.workspace = true +publish = false +description = "Horizon's official zoom: hold a key to zoom, the wheel changes it while held." + +[lib] +crate-type = ["cdylib"] + +[dependencies] +horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" } + +[lints] +workspace = true diff --git a/mods/official/zoom/horizon-mod.toml b/mods/official/zoom/horizon-mod.toml new file mode 100644 index 000000000..bd699d0b5 --- /dev/null +++ b/mods/official/zoom/horizon-mod.toml @@ -0,0 +1,9 @@ +id = "zoom" +name = "Zoom" +version = "1.0.0" +description = "Hold a key to zoom in; the mouse wheel changes the zoom while you hold it. Horizon's own, formerly an extra." +authors = ["Horizon"] +api = "0.1" +side = "client" +capabilities = ["render", "input", "ui", "storage"] +experimental = ["render", "input", "ui"] diff --git a/mods/official/zoom/src/lib.rs b/mods/official/zoom/src/lib.rs new file mode 100644 index 000000000..072a40eb0 --- /dev/null +++ b/mods/official/zoom/src/lib.rs @@ -0,0 +1,141 @@ +//! Horizon's official zoom, formerly the built-in extra: hold the key (Z +//! by default) to zoom in, and turn the mouse wheel while holding it to zoom +//! further in or out. Its settings page has the extra's four options: the +//! game lists the key there first and keeps the player's choice +//! (`horizon-mods.txt`); the rest is kept in the mod's storage (`level`, +//! `smooth`, `sensitivity`), +//! where the game writes a player's old extra settings when it installs the +//! mod for them. +use horizon_mod_sdk::{ + Mod, Registration, + input::{self, Event}, + render::{self, Zoom as ZoomView}, + storage, + ui::{self, ButtonWidget, Widget}, +}; + +/// The key's name for `register-key`. +const KEY: &str = "zoom"; +/// The zooms the starting zoom cycles through, and the wheel's limits. +const LEVELS: [u8; 6] = [2, 3, 4, 6, 8, 10]; +const MIN: f32 = 1.25; +const MAX: f32 = 10.0; +/// Each wheel step multiplies the zoom by this. +const STEP: f32 = 1.25; +/// Settings page buttons, under the key's row. +const LEVEL_BUTTON: u32 = 2; +const SMOOTH_BUTTON: u32 = 3; +const SENSITIVITY_BUTTON: u32 = 4; + +struct Zoom { + /// The zoom the key starts at, one of `LEVELS`. + level: u8, + /// Ease in and out like the spyglass. + smooth: bool, + /// Turn slower the more you zoom in. + sensitivity: bool, + /// The zoom while the key is held; None when it is up. + held: Option, +} + +impl Zoom { + /// Tells the game the zoom in effect. + fn show(&self) { + let factor = self.held.unwrap_or(1.0); + render::set_zoom(ZoomView { + factor, + smooth: self.smooth, + turn: if self.sensitivity { 1.0 / factor } else { 1.0 }, + }); + } + fn page(&self) { + let on = |b: bool| if b { "ON" } else { "OFF" }; + ui::set_settings(&[ + Widget::Button(ButtonWidget { + id: LEVEL_BUTTON, + label: format!("Starting zoom: {}x", self.level), + }), + Widget::Button(ButtonWidget { + id: SMOOTH_BUTTON, + label: format!("Smooth zoom: {}", on(self.smooth)), + }), + Widget::Button(ButtonWidget { + id: SENSITIVITY_BUTTON, + label: format!("Slower turning: {}", on(self.sensitivity)), + }), + ]); + } + fn save(&self) { + let flag = |b: bool| if b { &b"true"[..] } else { &b"false"[..] }; + let _ = storage::set("level", self.level.to_string().as_bytes()); + let _ = storage::set("smooth", flag(self.smooth)); + let _ = storage::set("sensitivity", flag(self.sensitivity)); + } +} + +fn stored(key: &str) -> Option { + storage::get(key).and_then(|v| String::from_utf8(v).ok()) +} + +impl Mod for Zoom { + fn init() -> Result<(Self, Registration), String> { + input::register_key(KEY, "Zoom key", "key.keyboard.z")?; + // The extra's defaults: 4x, smooth, slower turning. + let level = stored("level") + .and_then(|v| v.trim().parse::().ok()) + .map_or(4, |v| v.clamp(2, MAX as u8)); + let flag = |key: &str| stored(key).is_none_or(|v| v.trim() != "false"); + let zoom = Zoom { + level, + smooth: flag("smooth"), + sensitivity: flag("sensitivity"), + held: None, + }; + zoom.page(); + Ok((zoom, Registration::new().on_frame())) + } + fn frame(&mut self, _seconds: f32) { + let mut changed = false; + for event in input::poll() { + match event { + Event::KeyDown(k) if k == KEY => { + self.held = Some(f32::from(self.level).clamp(MIN, MAX)); + // While held, the wheel zooms instead of moving the hotbar. + input::claim_wheel(true); + } + Event::KeyUp(k) if k == KEY => { + self.held = None; + input::claim_wheel(false); + } + Event::Wheel(steps) => { + let Some(z) = &mut self.held else { continue }; + *z = (*z * STEP.powf(steps)).clamp(MIN, MAX); + } + _ => continue, + } + changed = true; + } + if changed { + self.show(); + } + } + fn ui_select(&mut self, id: u32, _row: u32) { + match id { + LEVEL_BUTTON => { + // As the extra cycled: an unknown level counts as the first. + let i = LEVELS.iter().position(|&l| l == self.level).unwrap_or(0); + self.level = LEVELS[(i + 1) % LEVELS.len()]; + } + SMOOTH_BUTTON => self.smooth = !self.smooth, + SENSITIVITY_BUTTON => self.sensitivity = !self.sensitivity, + _ => return, + } + self.save(); + self.page(); + } + fn ui_settings_opened(&mut self) { + self.page(); + } +} + +horizon_mod_sdk::export_mod!(Zoom); diff --git a/tests/test_game_home.py b/tests/test_game_home.py index b4d9e017f..b0561a9a2 100644 --- a/tests/test_game_home.py +++ b/tests/test_game_home.py @@ -29,6 +29,7 @@ EXEMPT = { "build_release.py": "builds and packs the release", "release_train.py": "release bookkeeping", "pr_ready.py": "runs cargo checks and parity.py", + "test_friends_integration_parity.py": "builds binaries; test_friends.Game isolates every game through integration_env", "port_harness.py": "ports Java code, starts no game", } diff --git a/tests/test_integration_env.py b/tests/test_integration_env.py new file mode 100644 index 000000000..018b02763 --- /dev/null +++ b/tests/test_integration_env.py @@ -0,0 +1,50 @@ +"""Automated game runs must never inherit a real player's data directories.""" +import json +import os +from pathlib import Path +import sys +import tempfile +import unittest + +from tools.integration_env import game_environment, run_game, require_server_reports + + +class IntegrationEnvironmentTests(unittest.TestCase): + def test_all_data_homes_and_network_settings_are_overridden(self): + keys = ('HORIZON_HOME', 'HORIZON_LAUNCHER_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME') + with tempfile.TemporaryDirectory() as root: + env = game_environment({**dict.fromkeys(keys, '/real/player'), 'DISPLAY': ':123'}, root) + homes = [Path(env[key]) for key in keys] + self.assertEqual(len(set(homes)), 4) + self.assertTrue(all(p.is_dir() and p.is_relative_to(root) for p in homes)) + self.assertEqual(env['DISPLAY'], ':123') + self.assertEqual(env['HORIZON_TELEMETRY_URL'], 'off') + self.assertEqual(env['HORIZON_LAUNCHER_NO_SELF_UPDATE'], '1') + self.assertEqual(env['HORIZON_NO_AUDIO'], '1') + + def test_each_fixture_process_gets_fresh_homes_and_cleanup(self): + script = ('import json, os; from pathlib import Path; ' + 'homes = [os.environ[k] for k in ' + '("HORIZON_HOME", "HORIZON_LAUNCHER_HOME", "XDG_DATA_HOME", "XDG_CONFIG_HOME")]; ' + 'assert all(Path(p).is_dir() for p in homes); print(json.dumps(homes))') + runs = [json.loads(run_game([sys.executable, '-c', script], env=os.environ, + capture_output=True, text=True, check=True).stdout) for _ in range(2)] + self.assertFalse(set(runs[0]) & set(runs[1])) + self.assertTrue(all(not Path(p).exists() for homes in runs for p in homes)) + + +class PreparedReportTests(unittest.TestCase): + def test_partial_report_install_shadows_complete_fallback(self): + with tempfile.TemporaryDirectory() as root: + resources = Path(root) / 'horizon-client' / '26.3' + fallback = Path(root) / 'datagen' / 'out' / 'reports' + resources.mkdir(parents=True) + fallback.mkdir(parents=True) + for name in ('registries.json', 'commands.json'): + (fallback / name).write_text('{}') + self.assertEqual(require_server_reports(resources).resolve(), fallback.resolve()) + (resources / 'registries.json').write_text('{}') + with self.assertRaisesRegex(ValueError, 'installed together'): + require_server_reports(resources) + (resources / 'commands.json').write_text('{}') + self.assertEqual(require_server_reports(resources), resources) diff --git a/tests/test_parity_reach.py b/tests/test_parity_reach.py index 9b7464b47..07e3df9e3 100644 --- a/tests/test_parity_reach.py +++ b/tests/test_parity_reach.py @@ -101,6 +101,16 @@ class ReachTests(unittest.TestCase): (self.root / "crates/a/src/unused.rs").unlink() self.assertIn("crates/a/src/unused.rs", self.narrowed()) + def test_a_search_told_to_stop_still_keeps_the_file_it_stopped_at(self): + graph = parity_reach.SourceGraph(self.root, parity.rust_code) + kept = parity_reach.narrow(self.dependencies, PROBE, graph, {"crates/a/src/used.rs"}, {"crates/a/src/used.rs"}) + self.assertEqual(kept["crates/a/src/used.rs"], (True, set())) + self.assertFalse(graph.results, "a partial search is not remembered") + # A stop file outside the harness's sources doesn't end its search. + full = parity_reach.narrow(self.dependencies, PROBE, graph, (), {"crates/b/src/lib.rs"}) + self.assertIn("crates/a/src/display.rs", full) + self.assertTrue(graph.results) + def test_unknown_probes_keep_everything(self): self.assertEqual(set(self.narrowed(artifacts=[])), set(self.dependencies)) self.assertEqual(set(self.narrowed(artifacts=[["example", "missing", "release", ["-p", "a"], True]])), diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index 2d16e7179..a85f1e969 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -145,6 +145,11 @@ class ParityRunnerTests(unittest.TestCase): with mock.patch.object(parity.sys, "platform", "darwin"): self.assertEqual(parity.platform_skips(config), {"options": "libm"}) + 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({}), {}) + self.assertIn("lan_integration", parity.named_only(parity.host_config())) + def test_a_pass_from_another_worktree_counts_only_for_the_same_content(self): with tempfile.TemporaryDirectory() as temp: elsewhere, here, shared = Path(temp, "a"), Path(temp, "b"), Path(temp, "shared") diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 7f0c52bce..116aed49b 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -75,6 +75,8 @@ def game_env(screen, home=None): extra['HORIZON_HOME'] = home if sys.platform == 'darwin': return lab.game_env(**extra) + if not shutil.which('vscreen') and os.environ.get('DISPLAY'): + return lab.game_env(**extra) env = lab.game_env(VSCREEN=screen, **extra) subprocess.run(['vscreen', 'up'], env=env, check=False, capture_output=True) text = subprocess.run(['vscreen', 'env'], env=env, capture_output=True, text=True, check=True).stdout diff --git a/tools/integration_env.py b/tools/integration_env.py new file mode 100644 index 000000000..ed7122c1e --- /dev/null +++ b/tools/integration_env.py @@ -0,0 +1,54 @@ +"""Per-process scratch data for game integration tests (never a player's home).""" +from pathlib import Path +from contextlib import contextmanager +import os +import subprocess +import tempfile + +try: + from . import lab +except ImportError: + import lab + + +def game_environment(base, root): + root = Path(root) + env = dict(base, HORIZON_TELEMETRY_URL='off') + for key, folder in [('HORIZON_HOME', 'home'), ('HORIZON_LAUNCHER_HOME', 'launcher'), + ('XDG_DATA_HOME', 'data'), ('XDG_CONFIG_HOME', 'config')]: + path = root / folder + path.mkdir(parents=True, exist_ok=True) + env[key] = str(path) + return lab.game_env(env) + + +def run_game(command, **kwargs): + """Run a headless game fixture with the same isolation as real-client tests.""" + with tempfile.TemporaryDirectory(prefix='hz-fixture-') as root: + kwargs['env'] = game_environment(kwargs.pop('env', os.environ), root) + if any(key in kwargs['env'] for key in + ('HORIZON_COMMAND_SCRIPT', 'HORIZON_DISPENSE_FIXTURE', 'HORIZON_SCULK_FIXTURE')): + # These compare seeded rule/callback traces, not the client/server boundary. + command = [*command, '--in-frame'] + return subprocess.run(command, **kwargs) + + +@contextmanager +def suite_lock(): + """Real-client CI suites share a GPU, even when parity.py runs harnesses in parallel.""" + import fcntl + with (Path(tempfile.gettempdir()) / 'horizon-integration-gpu.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + yield + + +def require_server_reports(resources): + """Match Builtin.find: a registry report shadows later fallback directories.""" + resources = Path(resources) + reports = next((p for p in (resources, resources / '../../datagen/out/reports', + resources / '../datagen/out/reports') + if (p / 'registries.json').is_file()), None) + if reports is None or not (reports / 'commands.json').is_file(): + raise ValueError(f'incomplete prepared resources in {resources}: registries.json and ' + 'commands.json must be installed together; prepare the pinned resources again') + return reports diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..449d47c0b 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -1,7 +1,8 @@ #!/usr/bin/env python3 """LAN multiplayer end to end: a host opens its world to LAN and a guest joins, both real games. -Two Horizon clients run side by side under horizon-ctl, each in its own scratch folder. The host +The host uses its integrated server thread by default; --in-frame compares the fallback, and +--server-thread remains accepted. Two Horizon clients run under horizon-ctl in scratch folders. The host creates a survival world and opens it to LAN with commands allowed; the guest connects to it by address. The script then checks, from both sides, what a guest's game used to get wrong (#366): @@ -272,7 +273,6 @@ import math import os import re import shutil -import signal import subprocess import sys import tempfile @@ -284,11 +284,12 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from agent_control_e2e import Cli, Failed, game_env # noqa: E402 import lab # noqa: E402 +from integration_env import game_environment, require_server_reports # noqa: E402 ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' -# The host plays single player on its server thread (--server-thread). -SERVER_THREAD = False +# Match normal single player; --in-frame is the comparison path. +SERVER_THREAD = True CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] @@ -302,6 +303,7 @@ class Game: os.symlink(resources, self.work / '.local/horizon-client' / lab.VERSION) self.socket = self.work / 'c.sock' env = game_env(os.environ.get('VSCREEN', 'lan-e2e'), home=self.work / 'home') + env = game_environment(env, self.work) self.d = Cli(ctl, self.socket, self.work, env) self.d.name = name @@ -327,6 +329,28 @@ class Game: def wait(self, ticks): self.d('wait', ticks=ticks) + def script(self, lines): + """Keep tick-sensitive input in one ctl process, through the normal control commands.""" + result = subprocess.run(self.d.base + ['script'], input='\n'.join(lines) + '\n', + cwd=self.work, env=self.d.env, capture_output=True, text=True, + timeout=600) + replies = [json.loads(line) for line in result.stdout.splitlines() if line.strip()] + ticks = [r['ticks'] for r in replies if 'ticks' in r] + print(f'[{self.name}] script {lines} -> {replies[-1] if replies else result.stderr[:400]}; ticks={ticks}') + assert result.returncode == 0 and replies and not any('error' in r for r in replies), result.stdout + return replies[-1] + + def until(self, observe, predicate, ticks=100): + """Wait for an observable answer, within the existing tick budget.""" + last = observe() + for _ in range(ticks): + if predicate(last): + return last + self.wait(1) + last = observe() + assert predicate(last), f'{self.name}: state did not arrive within {ticks} ticks: {last}' + return last + def close(self): try: self.d('quit') @@ -534,6 +558,8 @@ def check_sign(host, guest, out): host.shot(out, 'sign') assert placed and 'sign' in placed, f'the guest placed {placed}' host_unaffected(host, "the guest's sign") + guest.raw('key', 'esc', 'tap') + guest.raw('wait-for', 'screen', 'playing') return placed @@ -678,7 +704,7 @@ def check_levels(host, guest, out): for name, step in LEVEL_STEPS: try: steps[name] = step(host, guest, out) - except (Failed, AssertionError, StopIteration, KeyError) as e: + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: steps[name], failed = repr(e), failed + [name] for g in (host, guest): back_to_game(g) @@ -751,10 +777,12 @@ def level_ticking(host, guest, out): has its own id across the levels.""" gx, gy, gz = pos_of(guest) hx, hy, hz = pos_of(host) - # A floor of its own beside the host (earlier checks may have broken the open one there). - bx, by, bz = int(hx // 1), int(hy // 1), int(hz // 1) - host('command', command=f'fill {bx - 4} {by - 1} {bz - 4} {bx + 4} {by - 1} {bz - 2} minecraft:stone') - host('command', command=f'fill {bx - 4} {by} {bz - 4} {bx + 4} {by + 4} {bz - 2} minecraft:air') + # Clear the whole walking area in each level: normal pig AI can leave a + # narrow landing strip during the fall/observation window. + for game, x, y, z in ((host, hx, hy, hz), (guest, gx, gy, gz)): + bx, by, bz = int(x // 1), int(y // 1), int(z // 1) + game('command', command=f'fill {bx - 12} {by - 1} {bz - 12} {bx + 12} {by - 1} {bz + 12} minecraft:stone') + game('command', command=f'fill {bx - 12} {by} {bz - 12} {bx + 12} {by + 6} {bz + 12} minecraft:air') guest('command', command=f'summon minecraft:pig {gx + 2.5:.2f} {gy + 3:.2f} {gz:.2f}') guest('command', command=f'summon minecraft:armor_stand {gx - 2.5:.2f} {gy + 3:.2f} {gz:.2f}') host('command', command=f'summon minecraft:pig {hx + 2.5:.2f} {hy + 3:.2f} {hz - 3:.2f}') @@ -766,6 +794,7 @@ def level_ticking(host, guest, out): mobs = [m for m in g.raw('mobs', 8)['near'] if m['kind'] == 'minecraft:pig'] stands = [o for o in g('status')['objects'] if o['kind'] == 'minecraft:armor_stand'] seen[name] = {'pigs': [(m['id'], round(m['pos'][1], 2)) for m in mobs], + 'pig_positions': [m['pos'] for m in mobs], 'stands': [(o['id'], round(o['position'][1], 2)) for o in stands], 'floor': floor} finally: guest('command', command='kill @e[type=!minecraft:player,distance=..8]') @@ -1993,12 +2022,11 @@ def chat_input(game): def complete(guest, text): """Opens the chat on `/`, types `text` and presses Tab: the input after it.""" guest.raw('key', 'slash', 'tap') - guest.wait(3) + guest.until(lambda: guest('screen').get('screen'), lambda s: s == 'chat', ticks=3) guest.raw('type', text) - guest.wait(2) + guest.until(lambda: guest('screen').get('chat_suggestions'), bool, ticks=2) guest.raw('key', 'tab', 'tap') - guest.wait(2) - return chat_input(guest) + return guest.until(lambda: chat_input(guest), lambda value: value != '/' + text, ticks=2) def check_commands(host, guest, out): @@ -2408,7 +2436,8 @@ def check_predict(host, guest, out): seen = {} creaks = lambda game: sum(n for s, n in game('status')['heard'].items() if 'door' in s) heard = {'guest': creaks(guest), 'host': creaks(host)} - os.kill(host.pid, signal.SIGSTOP) + host.raw('server-hold', 'on') + held_at = host.raw('simulation')['game_time'] try: guest.raw('interact', *wood) seen['guest_frozen'] = (state(guest, wood), state(guest, (wood[0], wood[1] + 1, wood[2]))) @@ -2416,8 +2445,9 @@ def check_predict(host, guest, out): seen['guest_heard_frozen'] = creaks(guest) - heard['guest'] guest.raw('interact', *iron) seen['guest_iron_frozen'] = state(guest, iron) + assert host.raw('simulation')['game_time'] == held_at, 'server barrier advanced the world' finally: - os.kill(host.pid, signal.SIGCONT) + host.raw('server-hold', 'off') guest.wait(20) seen['guest_after'] = state(guest, wood) seen['host_after'] = state(host, wood) @@ -2529,7 +2559,11 @@ def check_swings(host, guest, out): guest.wait(10) guest.raw('select', 'minecraft:wooden_hoe') before = guest('state')['swings'] - guest.raw('interact', *soil) + guest.raw('look-at', soil[0] + 0.5, soil[1] + 1, soil[2] + 0.5) + guest.wait(1) + target = guest('state')['looking_at']['block'] + assert target and target['pos'] == list(soil) and target['face'] == 'up', target + guest.raw('mouse', 'right', 'click') guest.wait(10) hoe = {'swings': guest('state')['swings'] - before, 'soil': host.raw('block', *soil)['block']} guest('command', command=f'setblock {soil[0]} {soil[1]} {soil[2]} minecraft:stone') @@ -2636,16 +2670,22 @@ def check_xp(host, guest, out): x, y, z = pos_of(guest) # Three orbs of 7 points 4 blocks east of the guest (out of reach, within the 8 blocks orbs # follow from): they fly to the guest. + # Freeze setup so command/IPC latency cannot let all three be collected + # before the two-tick in-flight observation. + host('command', command='tick freeze') for _ in range(3): guest('command', command=f'summon minecraft:experience_orb {x + 4:.2f} {y + 0.5:.2f} {z:.2f} {{Value:7s}}') + host('command', command='tick step 2') guest.wait(2) seen = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) guest.shot(out, 'xp-orbs') + host('command', command='tick unfreeze') guest.wait(60) xp = guest('state')['player']['xp'] host_xp = host('state')['player']['xp'] left = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) finally: + host('command', command='tick unfreeze') host('command', command='gamemode survival') # Back where it stood: a spectator sinks (Player.travel keeps 0.6 of its fall speed each tick, # about 0.2 blocks from standing), and a later check that makes it survival again would land @@ -2671,9 +2711,7 @@ def check_time(host, guest, out): guest.wait(20) # A stalled game runs at most 10 missed ticks when it wakes (DeltaTracker); the server's # game time, sent every second, moves the guest's clock on (ClientClockManager.tick). - os.kill(guest.pid, signal.SIGSTOP) - time.sleep(4) - os.kill(guest.pid, signal.SIGCONT) + guest.raw('stall', 4000) guest.wait(60) stalled = times() detail = {'paused': paused, 'after_stall': stalled} @@ -3126,12 +3164,10 @@ def same_light(host, guest, lo, hi, what, ticks=100): def check_flight(host, guest, out): def double_jump(game): # LocalPlayer.aiStep: a second jump press within 7 ticks of the first toggles flight. + lines = [] for hold in (1, 4): - game.raw('key', 'space', 'down') - game.wait(hold) - game.raw('key', 'space', 'up') - game.wait(2) - game.wait(10) + lines += ['key space down', f'wait {hold}', 'key space up', 'wait 2'] + game.script(lines + ['wait 10']) return game('state')['player'] def set_mode(game, mode): @@ -3146,6 +3182,9 @@ def check_flight(host, guest, out): players = [('guest', guest)] + ([('host', host)] if SERVER_THREAD else []) seen = {} + # The rule is seven simulation ticks, independent of wall time. A slow + # server clock leaves enough time to deliver the key events even on busy CI. + host('command', command='tick rate 4') try: for name, game in players: set_mode(game, 'creative') @@ -3159,6 +3198,7 @@ def check_flight(host, guest, out): 'stayed': round(later['position'][1] - up['position'][1], 2), 'survival_flying': fell['flying']} finally: + host('command', command='tick rate 20') for _, game in players: game('command', command='gamemode survival') for name, s in seen.items(): @@ -3673,15 +3713,16 @@ def leave_vehicle(player, kind): def break_vehicle(player, vehicle_id, kind): """Hit it with fists until it breaks: VehicleEntity.tick takes 1 off its damage every tick.""" - for _ in range(10): - here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] - if not here: - return - vp = here[0]['position'] - player.raw('look-at', f'{vp[0]:.2f}', f'{vp[1] + 0.3:.2f}', f'{vp[2]:.2f}') - player.raw('mouse', 'left', 'click') - player.wait(2) - raise AssertionError(f'ten hits left the {kind} in place') + here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] + if not here: + return + vp = here[0]['position'] + # Keep the original ten hits/two-tick spacing in one connection. Starting + # several ctl processes per hit lets the vehicle's damage decay between hits. + player.script([f'look-at {vp[0]:.2f} {vp[1] + 0.3:.2f} {vp[2]:.2f}', + *[line for _ in range(10) for line in ('mouse left click', 'wait 2')]]) + assert not any(o['id'] == vehicle_id for o in player('status')['objects']), \ + f'ten hits left the {kind} in place' def check_boats(host, guest, out): @@ -4338,10 +4379,8 @@ def check_deflect(host, guest, out): (Player.attack: AIM_DEFLECT on #redirectable_projectile; Ghast.isReflectedFireball). The ghast is caged (a window toward the host); the game runs at 4 ticks a second, and once the fireball is within 4.5 blocks the host looks at the ghast and clicks.""" - if SERVER_THREAD: - # The fireball's position and the host's hurts are read from the host's own level. - return 'skipped (in-frame only)' - x, y, z = (int(v // 1) for v in pos_of(host)) + back = pos_of(host) + x, y, z = (int(v // 1) for v in back) guest('command', command='gamemode creative') host('command', command='gamemode survival') host('command', command='difficulty normal') @@ -4362,23 +4401,36 @@ def check_deflect(host, guest, out): try: deadline = time.monotonic() + 120 while time.monotonic() < deadline: - balls = [q for q in host.raw('status')['projectiles'] if q['kind'] == 'LargeFireball'] + # Aim and click at the projectile the client actually sees. Holding + # non-player simulation keeps the reach window open while ordinary + # player input and its attack packet cross the connection. + balls = [q for q in host('status')['projectiles'] if q['kind'] == 'LargeFireball'] near = min((math.dist(q['position'], eye) for q in balls), default=None) if near is not None and near < 4.5: + ball = min(balls, key=lambda q: math.dist(q['position'], eye)) + host('command', command='tick freeze') + held_tick = host.raw('simulation')['game_time'] g = [m['pos'] for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast')][0] - host.raw('look-at', f'{g[0]:.2f}', f'{g[1] + 2:.2f}', f'{g[2]:.2f}') - host.raw('mouse', 'left', 'down') - host.raw('mouse', 'left', 'up') + host.script([f'look-at {g[0]:.2f} {g[1] + 2:.2f} {g[2]:.2f}', + 'wait 1', 'mouse left click', 'wait 1']) + host.until(lambda: host.raw('simulation')['projectiles'], + lambda qs: any(q.get('id') == ball['id'] and q.get('player_owned') for q in qs), + ticks=60) + assert host.raw('simulation')['game_time'] == held_tick, 'the deflection barrier advanced simulation' + host('command', command='tick unfreeze') turned = near break host('command', command='tick rate 20') host.wait(60) ghast = [m for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast') and m['health'] > 0] - hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == 'host' for h in pl['hurts'] + hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == (host.player if SERVER_THREAD else 'host') for h in pl['hurts'] if 'fireball' in h['source'] or 'explosion' in h['source']] finally: + host('command', command='tick unfreeze') host('command', command='tick rate 20') host('command', command='kill @e[type=minecraft:ghast]') + host('command', command=f'tp @s {back[0]} {back[1]} {back[2]}') + host.until(lambda: pos_of(host), lambda p: math.dist(p, back) < 0.1) host('command', command=f'fill {gx - 3} {gy - 1} {gz - 3} {gx + 24} {gy + 8} {gz + 3} minecraft:air') guest('command', command='gamemode survival') assert turned is not None, f'no fireball came within 4.5 blocks (nearest {near})' @@ -4564,8 +4616,22 @@ def run(ctl, out, resources, checks): guest.shot(out, 'joined') for name in checks: try: - results[name] = {'pass': True, 'detail': CHECK_FNS[name](host, guest, out)} - except (Failed, AssertionError, StopIteration, KeyError) as e: + # Cases assert their own deaths, menus and held actions before returning. + # Do not let those states turn later independent cases into false failures. + for game in (host, guest): + game.raw('release') + back_to_game(game) + state = game('state') + assert state.get('player') is not None, f'{game.name} lost its session before {name}: {state}' + if state.get('screen') == 'dead' or state['player']['health'] <= 0: + game.raw('respawn') + game.until(lambda: game('state'), + lambda s: s.get('screen') == 'playing' and s['player']['health'] > 0, + ticks=40) + detail = CHECK_FNS[name](host, guest, out) + skipped = isinstance(detail, str) and detail.startswith('skipped') + results[name] = {'pass': not skipped, 'skipped': skipped, 'detail': detail} + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: results[name] = {'pass': False, 'detail': repr(e)} for g in (host, guest): back_to_game(g) @@ -4584,14 +4650,19 @@ def main(): parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build with the fast profile)') parser.add_argument('--check', action='append', choices=CHECKS, help='run only these checks (repeatable)') parser.add_argument('--out', default=str(ROOT / '.local/lan-e2e'), help='screenshots and game logs go here') - parser.add_argument('--server-thread', action='store_true', help="the host's world runs on its server thread") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') args = parser.parse_args() global SERVER_THREAD SERVER_THREAD = args.server_thread if args.bin_dir: bins = Path(args.bin_dir).resolve() else: - subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bins'], + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '--bin', 'horizon-client', '--bin', 'horizon-ctl'], cwd=ROOT, check=True) meta = json.loads(subprocess.run(['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=ROOT, capture_output=True, text=True, check=True).stdout) @@ -4599,9 +4670,16 @@ def main(): resources = lab.RESOURCES.resolve() if not (resources / 'horizon-resources.json').exists(): sys.exit(f'no prepared resources in {resources}') - out = Path(args.out) + try: + require_server_reports(resources) + except ValueError as error: + sys.exit(str(error)) + out = Path(args.out).resolve() out.mkdir(parents=True, exist_ok=True) + print(f'LAN host mode: {"server-thread" if SERVER_THREAD else "in-frame"}') results = run(bins / 'horizon-ctl', out, resources, args.check or CHECKS) + (out / 'results.json').write_text(json.dumps({'mode': 'server-thread' if SERVER_THREAD else 'in-frame', + 'checks': results}, indent=2) + '\n') print(json.dumps(results, indent=1)) sys.exit(0 if results and all(r['pass'] for r in results.values()) else 1) @@ -4658,16 +4736,33 @@ def check_keep_inventory(host, guest, out): neither; with it on, nothing drops and it respawns with both (#1284).""" hx, hy, hz = (int(v // 1) for v in pos_of(host)) seen = {} + # Totem coverage leaves both players near one health. Protect the waiting + # player from residual fire/damage while the other player's death is tested. + for game in (host, guest): + game('command', command='gamemode creative') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') host('command', command=f'setworldspawn {hx} {hy} {hz}') host('command', command='gamerule respawn_radius 0') + # Keep the inactive player alive and away from the death drops. Earlier + # fixtures may leave a personal respawn point or an unsafe waiting position. + host('command', command=f'fill {hx - 6} {hy - 1} {hz - 6} {hx + 6} {hy - 1} {hz + 6} minecraft:stone') + host('command', command=f'fill {hx - 6} {hy} {hz - 6} {hx + 6} {hy + 3} {hz + 6} minecraft:air') + for game, dz in ((host, -3), (guest, 3)): + waiting = (hx - 3.5, hy, hz + dz + 0.5) + game('command', command=f'spawnpoint @s {hx} {hy} {hz}') + game('command', command=f'tp @s {waiting[0]} {waiting[1]} {waiting[2]}') + game.until(lambda: pos_of(game), lambda p: math.dist(p, waiting) < 0.1) try: for keep in ('false', 'true'): host('command', command=f'gamerule keep_inventory {keep}') for game, dz in ((host, -3), (guest, 3)): # 14 blocks from the world spawn: nothing dropped is picked up on respawning. x, z = hx + 14, hz + dz - host('command', command=f'fill {x - 2} {hy - 1} {z - 1} {x + 2} {hy - 1} {z + 1} minecraft:stone') - host('command', command=f'fill {x - 2} {hy} {z - 1} {x + 2} {hy + 2} {z + 1} minecraft:air') + # Death drops scatter several blocks before landing. Keep the + # entire observation area solid so they cannot fall off a ledge. + host('command', command=f'fill {x - 6} {hy - 1} {z - 6} {x + 6} {hy - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 6} {hy} {z - 6} {x + 6} {hy + 3} {z + 6} minecraft:air') host('command', command='kill @e[type=minecraft:item]') game('command', command='gamemode survival') game('command', command='clear @s') @@ -4675,8 +4770,10 @@ def check_keep_inventory(host, guest, out): game('command', command='item replace entity @s armor.head with minecraft:iron_helmet') game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5}') game.wait(20) + assert game('state').get('screen') == 'playing', f'{game.name} died during setup' game('command', command='kill @s') game.wait(30) + assert game('state').get('screen') == 'dead', f'{game.name} did not die' dropped = sorted((e['item']['item'], e['item']['count']) for e in game.raw('entities', 8, 'minecraft:item')['entities']) game.shot(out, f'keepinv-{keep}') @@ -4686,12 +4783,14 @@ def check_keep_inventory(host, guest, out): seen[f'{game.name}-keep-{keep}'] = { 'dropped': dropped, 'kept': {item: server_count(game, item) for item in ('diamond', 'iron_helmet')}} + game('command', command='gamemode creative') finally: host('command', command='gamerule keep_inventory false') host('command', command='gamerule respawn_radius 10') host('command', command='kill @e[type=minecraft:item]') for game in (host, guest): game('command', command='clear @s') + game('command', command='gamemode survival') face_each_other(host, guest) for case, s in seen.items(): want = ({'dropped': [], 'kept': {'diamond': 7, 'iron_helmet': 1}} if case.endswith('true') else @@ -4709,6 +4808,16 @@ def check_signs(host, guest, out): seen = {} for game, other, dz in ((host, guest, -2), (guest, host, 2)): spot = (hx + 2, hy, hz + dz) + for viewer in (game, other): + back_to_game(viewer) + # Earlier death/travel checks leave the players at different spawn points. + # Give this placement case its own floor, line of sight and reachable target. + host('command', command=f'fill {spot[0] - 3} {hy - 1} {spot[2] - 1} {spot[0] + 3} {hy - 1} {spot[2] + 1} minecraft:stone') + host('command', command=f'fill {spot[0] - 3} {hy} {spot[2] - 1} {spot[0] + 3} {hy + 3} {spot[2] + 1} minecraft:air') + for viewer, dx in ((game, -2), (other, 2)): + at = (spot[0] + dx + 0.5, hy, spot[2] + 0.5) + viewer('command', command=f'tp @s {at[0]} {at[1]} {at[2]}') + viewer.until(lambda: pos_of(viewer), lambda p: math.dist(p, at) < 0.1) game('command', command=f'setblock {spot[0]} {spot[1] - 1} {spot[2]} minecraft:stone') game('command', command=f'setblock {spot[0]} {spot[1]} {spot[2]} minecraft:air') game('command', command='gamemode survival') @@ -4716,7 +4825,12 @@ def check_signs(host, guest, out): game('command', command='give @s minecraft:oak_sign 1') game.wait(10) game.raw('place', *spot, '--item', 'minecraft:oak_sign') - game.wait(10) + game.until(lambda: game('state').get('screen'), lambda s: s == 'sign', ticks=10) + # Drain the placement's initial block-entity data before typing. The + # reply travels on the same connection after that data, unlike a local + # screen check which may see the editor before the initial data arrives. + server_reply(game, f'data get block {spot[0]} {spot[1]} {spot[2]} front_text.messages', + 'following block data') opened = {g.name: g('state').get('screen') for g in (game, other)} game.shot(out, 'signs-editor') lines = [f'{game.name} wrote', 'line two'] @@ -4724,11 +4838,13 @@ def check_signs(host, guest, out): game.raw('key', 'enter', 'tap') game.raw('type', lines[1]) game.raw('key', 'esc', 'tap') - game.wait(20) + game.until(lambda: game('state').get('screen'), lambda s: s == 'playing', ticks=20) back_to_game(other) + shown = {g.name: g.until(lambda: (g.raw('block', *spot).get('sign') or {}).get('front'), + lambda front: front == lines + ['', ''], ticks=20) + for g in (game, other)} seen[game.name] = {'opened': opened, - 'shown': {g.name: (g.raw('block', *spot).get('sign') or {}).get('front') - for g in (game, other)}} + 'shown': shown} other.shot(out, 'signs-shown') for name, s in seen.items(): other = 'guest' if name == 'host' else 'host' @@ -5079,8 +5195,12 @@ def check_fishing(host, guest, out): tracked to the clients as a fishing bobber under its owner), lands on the ground and reels back in; cast into open water with Lure III, a fish bites and reeling in during the bite catches it for 1 (#1348).""" + # Both players need a safe floor for the entire other player's fishing wait. + apart(host, guest) hx, hy, hz = (int(v // 1) for v in pos_of(host)) host('command', command='weather clear') + for game in (host, guest): + game('command', command='effect give @s minecraft:instant_health 1 5 true') seen = {} try: for game, other, dz in ((host, guest, -5), (guest, host, 5)): @@ -5396,12 +5516,8 @@ def check_digging(host, guest, out): before = heard('minecraft:block.stone.break') guest.raw('look-at', *at(stone)) guest.raw('mouse', 'left', 'down') - time.sleep(0.4) - os.kill(guest.pid, signal.SIGSTOP) - try: - time.sleep(1.0) - finally: - os.kill(guest.pid, signal.SIGCONT) + guest.wait(8) + guest.raw('stall', 1000) resumed = {'guest': guest.raw('block', *stone).get('block'), 'server': host.raw('block', *stone).get('block'), 'mining': guest('state').get('mining')} # Let go once it breaks: past it the crosshair reaches the floor. @@ -5597,6 +5713,68 @@ CHECKS += ['knockback'] CHECK_FNS.update(knockback=check_knockback) + +def check_fixture_input(host, guest, out, kind, role): + """Complement seeded rules with real client input and authoritative observations.""" + player = host if role == 'host' else guest + hx, y, hz = (int(v // 1) for v in pos_of(host)) + x, z = hx + 6, hz + (-8 if role == 'host' else 8) + sensor, dispenser, button = (x + 3, y, z + 1), (x, y, z + 3), (x, y, z + 2) + player('command', command='gamemode survival') + player('command', command='item replace entity @s weapon.mainhand with minecraft:air') + host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 5} {y - 1} {z + 5} minecraft:stone') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + start = (x + 0.5, y, z + 0.5) + player('command', command=f'tp @s {start[0]} {start[1]} {start[2]} 0 0') + player.until(lambda: pos_of(player), lambda p: math.dist(p, start) < 0.1) + player.raw('look', 0, 0) + try: + if kind == 'sculk': + player.wait(2) # finish setup movement before installing the listener + host.raw('setblock', *sensor, 'minecraft:sculk_sensor') + phase = lambda: host.raw('getblock', *sensor)['block'] + host.until(phase, lambda state: 'sculk_sensor_phase=inactive' in state) + player.wait(10) + assert 'sculk_sensor_phase=inactive' in phase(), 'setup activated the sensor before player input' + player.raw('key', 'w', 'down') + try: + player.wait(15) # defined input duration; no wall-clock simulation sleep + finally: + player.raw('key', 'w', 'up') + moved = {'client': math.dist(pos_of(player), start), + 'server': math.dist(server_player(host, player)['position'], start)} + assert all(d > 1 for d in moved.values()), f'{role} did not walk on both sides: {moved}' + active = host.until(phase, lambda state: 'sculk_sensor_phase=active' in state, ticks=85) + for viewer in (host, guest): + viewer.until(lambda: state_of(viewer, sensor, 'sculk_sensor_phase'), lambda v: v == 'active') + return {'moved': moved, 'phase': active} + host.raw('setblock', *dispenser, 'minecraft:dispenser[facing=east]') + host.raw('container', *dispenser, 'minecraft:diamond', 1) + host.raw('setblock', *button, 'minecraft:stone_button[face=wall,facing=north]') + player.until(lambda: player.raw('block', *button)['block'], lambda v: v == 'minecraft:stone_button') + player.raw('interact', *button) + slots = host.until(lambda: host.raw('container', *dispenser)['slots'], lambda v: all(s is None for s in v)) + dropped = {} + for viewer in (host, guest): + dropped[viewer.name] = viewer.until( + lambda: [e for e in viewer.raw('entities', 24, 'minecraft:item')['entities'] + if e.get('item', {}).get('item') == 'minecraft:diamond' + and math.dist(e['pos'], (x + 1.5, y + 0.5, z + 3.5)) < 3], + lambda drops: len(drops) == 1 and drops[0]['item']['count'] == 1) + player.shot(out, f'{kind}-input') + return {'slots': slots, 'drops': dropped} + finally: + player.raw('key', 'w', 'up') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + + +for _kind in ('sculk', 'dispenser'): + for _role in ('host', 'guest'): + _name = f'{_kind}_input_{_role}' + CHECKS.append(_name) + CHECK_FNS[_name] = lambda h, g, o, kind=_kind, role=_role: check_fixture_input(h, g, o, kind, role) + + def check_hero_trading(host, guest, out): """Villager.updateSpecialPrices keeps the trading player's Hero effect: the offer sent to the client and the server's payment consumption agree, independently of the other player's effect.""" diff --git a/tools/oracle_harness.py b/tools/oracle_harness.py index 92e2a26a2..787c8a293 100644 --- a/tools/oracle_harness.py +++ b/tools/oracle_harness.py @@ -9,13 +9,16 @@ import subprocess try: from . import lab, test_rust_parity as base, test_model_baking_parity as baking + from .integration_env import run_game except ImportError: import lab, test_rust_parity as base, test_model_baking_parity as baking + from integration_env import run_game def run_logged(command, build, name, timeout=900, **kwargs): with (build / (name + '.log')).open('w') as log: - subprocess.run([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + runner([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, stdout=log, stderr=subprocess.STDOUT, **kwargs) diff --git a/tools/parity.py b/tools/parity.py index 3f18b922d..dbff8c146 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -11,6 +11,9 @@ python3 tools/parity.py --list # what would run, without running it python3 tools/parity.py --status # last result of every harness +Harnesses in parity_hosts.json's "named_only" run only when named or with --all +(the nightly audit): no automatic selection picks them. + Each harness runs unmodified, in parallel, under a tracer that records what it read: its Python modules, Java oracle sources, other repository files, and the Rust sources of every probe it executed (from Cargo's dep-info). A harness @@ -1245,14 +1248,20 @@ def affected_harnesses(found, records, changed, reach=True, base=None): commit), only declarations of modules the harness doesn't reach changed (tools/parity_reach.py).""" if changed & SHARED_INPUTS: return set(found) - graph = None + graph, stop = None, frozenset() + # Parses are keyed by content, so every worktree sharing the vanilla data shares them. + cache_path = (SHARED if SHARED.is_dir() else STATE_DIR) / "reach-cache.json" if reach and any(path.startswith("crates/") for path in changed): - cache_path = STATE_DIR / "reach-cache.json" try: cache = json.loads(cache_path.read_text(encoding="utf-8")) except (OSError, ValueError): cache = {} graph = parity_reach.SourceGraph(ROOT, rust_code, cache) + # A changed file that differs in more than its `mod` declarations counts as soon as a harness reaches it, + # so the search for that harness can stop there. + stop = frozenset(path for path in changed if parity_reach.is_workspace_rust(path) + and parity_reach.declarations_changed(ROOT, path, (), base, True)) + budget, started, over = float(os.environ.get("PARITY_REACH_BUDGET") or 180), time.monotonic(), False affected = set() for name, script in found.items(): record = records.get(name) or {} @@ -1265,16 +1274,31 @@ def affected_harnesses(found, records, changed, reach=True, base=None): affected.add(name) continue plain = {path.split(KEEP)[0] for path in dependencies} - if graph is not None and plain & changed: - narrowed = parity_reach.narrow(dependencies, recorded_artifacts(record), graph, changed) - if any(path.split(KEEP)[0] in changed and (children is None or parity_reach.declarations_changed( - ROOT, path.split(KEEP)[0], children, base, whole)) for path, (whole, children) in narrowed.items()): - affected.add(name) - elif plain & changed: + hit = plain & changed + if not hit: + continue + if graph is None or any(not path.startswith("crates/") for path in hit): + affected.add(name) # no narrowing, or a file narrowing always keeps (tools/, Java oracles) + continue + if not over and time.monotonic() - started > budget: + over = True + print(f"note: choosing harnesses took over {budget:.0f} s (PARITY_REACH_BUDGET): the rest count every " + "source their probes link", flush=True) + if over: + affected.add(name) + continue + narrowed = parity_reach.narrow(dependencies, recorded_artifacts(record), graph, changed, stop) + if any(path.split(KEEP)[0] in changed and (children is None or parity_reach.declarations_changed( + ROOT, path.split(KEEP)[0], children, base, whole)) for path, (whole, children) in narrowed.items()): affected.add(name) if graph is not None: - STATE_DIR.mkdir(parents=True, exist_ok=True) - cache_path.write_text(json.dumps(graph.saved_cache()), encoding="utf-8") + saved = graph.saved_cache() + if len(cache) + len(saved) < 4 * max(len(saved), 1): + saved = {**cache, **saved} # other worktrees' versions of the files too, within bounds + cache_path.parent.mkdir(parents=True, exist_ok=True) + temporary = cache_path.with_suffix(f".{os.getpid()}.tmp") + temporary.write_text(json.dumps(saved), encoding="utf-8") + temporary.replace(cache_path) return affected @@ -1285,6 +1309,12 @@ def platform_skips(config): return dict(config.get("linux_only", {})) +def named_only(config): + """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default, + --flake-check): they run only when named or with --all, the nightly audit. {name: reason}""" + return dict(config.get("named_only", {})) + + def finished_run(failed): """Record that this run completed, for tools/gate.py: a crashed runner never writes it.""" STATE_DIR.mkdir(parents=True, exist_ok=True) @@ -1369,9 +1399,13 @@ def main(): 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) 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]: + print(f"not selected (runs when named, and nightly): {name}: {manual[base_name(name)]}", flush=True) + chosen.remove(name) rounds = {name: args.repeat for name in chosen} if args.repeat > 1 else {} if args.flake_check: - changed = changed_harnesses(found, records, args.flake_check) + changed = {name for name in changed_harnesses(found, records, args.flake_check) if base_name(name) not in manual} for name in sorted(changed): # A pass counts for a changed harness only if it held over enough runs. if name not in chosen and records.get(name, {}).get("rounds", 1) < args.flake_rounds: diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json index f2ba65c68..164a3ff42 100644 --- a/tools/parity_hosts.json +++ b/tools/parity_hosts.json @@ -36,5 +36,8 @@ "local_only": { "save_roundtrip": "runs the game on a virtual screen (vscreen) with a null ALSA device, or offscreen in the logged-in macOS session" }, - "linux_only": {} + "linux_only": {}, + "named_only": { + "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py" + } } diff --git a/tools/parity_reach.py b/tools/parity_reach.py index 0c3051b86..dc61f6215 100644 --- a/tools/parity_reach.py +++ b/tools/parity_reach.py @@ -25,8 +25,9 @@ assets, fonts) that only unreached sources name; a dependency that no longer exi a change adds take part. """ +import functools import hashlib -from pathlib import Path, PurePosixPath +from pathlib import Path import re import subprocess @@ -478,9 +479,10 @@ class SourceGraph: seeds=seeds, node_sets={}) return self.tables - def reachable(self, entries, universe, reasons=None): + def reachable(self, entries, universe, reasons=None, stop=frozenset()): """The files of universe (workspace Rust sources) holding an item reachable from entries (by the rules in - this module's doc), and the entries. reasons, a dict, gets why each file was reached (for debugging).""" + this module's doc), and the entries. reasons, a dict, gets why each file was reached (for debugging). The + search ends early, with only part of the answer, once it reaches a file of stop.""" # Searching every source of the crates involved (not only those Cargo listed) only adds reach, and lets # harnesses with the same entries (the game binary's) share one search. crates = frozenset(crate_of(path) for path in universe) @@ -488,11 +490,12 @@ class SourceGraph: if reasons is None and key in self.results: return self.results[key] & set(universe) everything = {path for path in self.files if crate_of(path) in crates} | set(universe) - files = self.search(entries, everything, reasons) - self.results[key] = files + files, complete = self.search(entries, everything, reasons, stop) + if complete: + self.results[key] = files return files & set(universe) - def search(self, entries, universe, reasons): + def search(self, entries, universe, reasons, stop=frozenset()): targets = {self.target(path) for path in entries} universe = {path for path in universe if (self.is_library(path) or self.target(path) in targets) and path not in self.test_only} @@ -600,71 +603,80 @@ class SourceGraph: files.add(path) if reasons is not None: reasons[path] = why + if path in stop: + raise Stop - for path in universe: - if path.endswith("/src/lib.rs") or path in entries or path not in self.parent: - open_module(path, "crate root or entry") - for node in seeds: - reach(node, "entry" if node[0] in entries else "always counted") - for path in entries & universe: - files.add(path) - if reasons is not None: - reasons.setdefault(path, "entry") - while queue: - node = queue.pop() - path, index, member = node - item = item_of(node) - crate = crate_of(path) - label = (item.get("names") or [item["kind"]])[0] if member is None else item["members"][member]["name"] - source = sets_of(node, item) - why = f"{path} ({label})" - # Plain mentions reach items of this file and of the modules above it. - ancestor, new = path, source["mentions"] - while ancestor is not None and new: - known = local.setdefault(ancestor, set()) - new = new - known - known |= new + try: + for path in universe: + if path.endswith("/src/lib.rs") or path in entries or path not in self.parent: + open_module(path, "crate root or entry") + for node in seeds: + reach(node, "entry" if node[0] in entries else "always counted") + for path in entries & universe: + files.add(path) + if reasons is not None: + reasons.setdefault(path, "entry") + while queue: + node = queue.pop() + path, index, member = node + item = item_of(node) + crate = crate_of(path) + label = (item.get("names") or [item["kind"]])[0] if member is None else item["members"][member]["name"] + source = sets_of(node, item) + why = f"{path} ({label})" + # Plain mentions reach items of this file and of the modules above it. + ancestor, new = path, source["mentions"] + while ancestor is not None and new: + known = local.setdefault(ancestor, set()) + new = new - known + known |= new + for name in new: + wake(by_file_name.get((ancestor, name), ()), f"{why} mentions {name}") + ancestor = self.parent.get(ancestor) + if item["kind"] == "use" and item["glob"]: + for name in item["names"]: + for target in sees.get(crate, {crate}): + for module in list(by_module.get((target, name), ())) + \ + ([f"crates/{idents[name]}/src/lib.rs"] if name in idents else []): + if module not in globbed and module in universe: + globbed.add(module) + wake([(module, index, None) for index in range(len(self.parse(module)["items"]))] + if self.parse(module) else [], f"{why} glob-imports {name}") + visible_to = sees.get(crate, {crate}) + new = source["paths"] - done["paths"].setdefault(crate, set()) + done["paths"][crate] |= new for name in new: - wake(by_file_name.get((ancestor, name), ()), f"{why} mentions {name}") - ancestor = self.parent.get(ancestor) - if item["kind"] == "use" and item["glob"]: - for name in item["names"]: - for target in sees.get(crate, {crate}): - for module in list(by_module.get((target, name), ())) + \ - ([f"crates/{idents[name]}/src/lib.rs"] if name in idents else []): - if module not in globbed and module in universe: - globbed.add(module) - wake([(module, index, None) for index in range(len(self.parse(module)["items"]))] - if self.parse(module) else [], f"{why} glob-imports {name}") - visible_to = sees.get(crate, {crate}) - new = source["paths"] - done["paths"].setdefault(crate, set()) - done["paths"][crate] |= new - for name in new: - for target in visible_to: - path_names.setdefault(target, set()).add(name) - for module in by_module.get((target, name), ()): - if module in universe and self.parent[module] in opened: - open_module(module, f"{why} names {name}") - for key, table, wanted in (("qualified", qualified, lambda other: True), - ("invokes", invoked, lambda other: item_of(other)["kind"] == "macro"), - ("mentions", mentioned, lambda other: other[2] is not None or other[0] in globbed)): - new = source[key] - done[key].setdefault(crate, set()) - done[key][crate] |= new - for name in new: - table.setdefault(name, set()).add(crate) - wake([other for other in by_name.get(name, ()) if crate_of(other[0]) in visible_to and wanted(other)], - f"{why} {key} {name}") - if item["kind"] in TYPE_KINDS and member is None: - own = types.setdefault(crate, set()) - local_types.setdefault(path, set()).update(names(node)) - if not names(node) <= own: - own |= names(node) - visible_cache.clear() - seeing = seen_by.get(crate, {crate}) - for name in names(node): # also when the crate has one by that name already: impls of this one - wake([other for other in by_type.get(name, ()) if crate_of(other[0]) in seeing], - f"implements for {name}, defined in {path}") - return files + for target in visible_to: + path_names.setdefault(target, set()).add(name) + for module in by_module.get((target, name), ()): + if module in universe and self.parent[module] in opened: + open_module(module, f"{why} names {name}") + for key, table, wanted in (("qualified", qualified, lambda other: True), + ("invokes", invoked, lambda other: item_of(other)["kind"] == "macro"), + ("mentions", mentioned, lambda other: other[2] is not None or other[0] in globbed)): + new = source[key] - done[key].setdefault(crate, set()) + done[key][crate] |= new + for name in new: + table.setdefault(name, set()).add(crate) + wake([other for other in by_name.get(name, ()) if crate_of(other[0]) in visible_to and wanted(other)], + f"{why} {key} {name}") + if item["kind"] in TYPE_KINDS and member is None: + own = types.setdefault(crate, set()) + local_types.setdefault(path, set()).update(names(node)) + if not names(node) <= own: + own |= names(node) + visible_cache.clear() + seeing = seen_by.get(crate, {crate}) + for name in names(node): # also when the crate has one by that name already: impls of this one + wake([other for other in by_type.get(name, ()) if crate_of(other[0]) in seeing], + f"implements for {name}, defined in {path}") + except Stop: + return files, False + return files, True + + +class Stop(Exception): + """A search reached a file it was told to stop at.""" def impl_subject(header): @@ -682,13 +694,19 @@ def impl_subject(header): return parameters, re.split(r"\bwhere\b", header)[0] +_CRATES = {} + + def crate_of(path): - return path.split("/", 2)[1] + """The crate folder of a crates//... path (called millions of times by a search: cached).""" + crate = _CRATES.get(path) + if crate is None: + crate = _CRATES[path] = path.split("/", 2)[1] + return crate def is_workspace_rust(path): - parts = PurePosixPath(path).parts - return len(parts) > 2 and parts[0] == "crates" and path.endswith(".rs") + return path.startswith("crates/") and path.endswith(".rs") and path.count("/") >= 2 DECLARATION_LINE = re.compile(rf"\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+({IDENT})\s*;") @@ -718,6 +736,11 @@ def declarations_changed(root, path, children, base, whole): missing.""" if base is None: return True + return _declarations_changed(str(root), path, frozenset(children), base, whole) + + +@functools.lru_cache(maxsize=None) +def _declarations_changed(root, path, children, base, whole): try: head = (Path(root) / path).read_text(encoding="utf-8", errors="replace") before = subprocess.run(["git", "show", f"{base}:{path}"], cwd=root, capture_output=True, text=True, check=True).stdout @@ -726,36 +749,37 @@ def declarations_changed(root, path, children, base, whole): return declarations(head, children, whole) != declarations(before, children, whole) -def narrow(dependencies, artifacts, graph, changed=()): +def narrow(dependencies, artifacts, graph, changed=(), stop=frozenset()): """A harness's dependencies narrowed to what its entry points can reach: {dependency: (whole, children)}, where whole says the file counts for its own content (else only through its `mod` declarations of children, as a module ancestor of a reached file) and children are its reached child modules. Without known entry points (a - probe or binary the harness built that isn't found here), every dependency is kept whole.""" + probe or binary the harness built that isn't found here), every dependency is kept whole. The search may end + as soon as it reaches a file of stop (changed files that count once reached): then only part is returned.""" plain = [dependency.split("#keep:")[0] for dependency in dependencies] - crates = {PurePosixPath(path).parts[1] for path in plain if path.startswith("crates/")} + crates = {crate_of(path) for path in plain if path.startswith("crates/") and path.count("/") >= 2} rust = {path for path in plain if is_workspace_rust(path)} - added = {path for path in changed if is_workspace_rust(path) and PurePosixPath(path).parts[1] in crates + added = {path for path in changed if is_workspace_rust(path) and crate_of(path) in crates and path not in rust and (graph.root / path).is_file()} entries = graph.entries(artifacts, rust) if entries is None: return {dependency: (True, None) for dependency in dependencies} missing = {path for path in rust if graph.parse(path) is None} - reached = graph.reachable(entries, rust | added | entries) | missing + reached = graph.reachable(entries, rust | added | entries, stop=frozenset(stop) & (rust | added)) | missing named, named_in_crate = set(), {} for path in rust | added: parsed = graph.parse(path) file_names = set(parsed["file_names"]) if parsed else set() if path in reached: named |= file_names - named_in_crate.setdefault(PurePosixPath(path).parts[1], set()).update(file_names) + named_in_crate.setdefault(crate_of(path), set()).update(file_names) kept = {} for dependency, path in zip(dependencies, plain): if is_workspace_rust(path): if path in reached: kept[dependency] = (True, set()) elif not path.startswith("crates/") or path.endswith(("Cargo.toml", "build.rs")) \ - or PurePosixPath(path).name in named \ - or PurePosixPath(path).name not in named_in_crate.get(PurePosixPath(path).parts[1], ()): + or path.rsplit("/", 1)[-1] in named \ + or path.rsplit("/", 1)[-1] not in named_in_crate.get(crate_of(path), ()): kept[dependency] = (True, None) for path in sorted(added & reached): kept[path] = (True, set()) diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py index 75f38c351..7993a93a7 100644 --- a/tools/test_command_exec_parity.py +++ b/tools/test_command_exec_parity.py @@ -25,9 +25,11 @@ import sys try: from . import lab, test_rust_parity as base + from .integration_env import run_game from . import command_exec_corpus as corpus_module except ImportError: import lab + from integration_env import run_game import test_rust_parity as base import command_exec_corpus as corpus_module @@ -55,7 +57,8 @@ def main(): def run(command, name, **kw): with (build / (name + '.log')).open('w', encoding='utf-8') as log: - result = subprocess.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + result = runner(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) if result.returncode: tail = (build / (name + '.log')).read_text(errors='replace')[-3000:] sys.exit(f'{name} failed ({result.returncode}):\n{tail}') diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index 49a934987..7572ee3e2 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -65,13 +65,16 @@ import struct import subprocess import sys import threading +import tempfile import time import zlib try: from . import lab, oracle_harness as oh, test_rust_parity as base + from .integration_env import game_environment, run_game from .lab import free_port # the other server harnesses import it from here except ImportError: + from integration_env import game_environment, run_game import lab import oracle_harness as oh import test_rust_parity as base @@ -124,9 +127,11 @@ class Server: self.log_path = directory.parent / f'{log_name}.log' self.log = self.log_path.open('w', encoding='utf-8') self.lines = [] - self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE, + self.scratch = tempfile.TemporaryDirectory(prefix='hz-server-') + env = game_environment(os.environ, self.scratch.name) + self.process = subprocess.Popen(list(map(str, command)), cwd=directory, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, - encoding='utf-8', errors='replace', env=lab.game_env()) + encoding='utf-8', errors='replace') self.reader = threading.Thread(target=self._read, daemon=True) self.reader.start() @@ -163,6 +168,7 @@ class Server: self.process.wait() self.reader.join(timeout=10) self.log.close() + self.scratch.cleanup() def settle(server, ticks=600, timeout=600): @@ -200,6 +206,17 @@ def game_time(server, timeout=300): raise AssertionError(f'{server.log_path.name}: no game time in {timeout:.0f} s') +def wait_ticks(server, count, timeout=300): + """Waits until the server's game clock has advanced `count` ticks: a server that stalls under load still gets + as many ticks as an idle one, where a sleep gives it fewer. (Not while ticking is frozen.)""" + deadline = time.time() + timeout + until = game_time(server, timeout) + count + while game_time(server, max(1.0, deadline - time.time())) < until: + if time.time() > deadline: + raise AssertionError(f'{server.log_path.name}: the game clock did not advance {count} ticks in {timeout} s') + time.sleep(0.2) + + def legacy_ping(port): """The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler).""" host = 'localhost' @@ -327,7 +344,9 @@ def run_side(label, command, directory, client): joined.join() if failure: raise failure[0] - time.sleep(1) + # The client has gone; `list` must find no one, once the server has handled its leaving (a busy machine + # took longer than a second). + server.wait_for(rf'{PLAYER} left the game', timeout=60) server.console('list') server.console('say console says hi') server.wait_for(r'\[Server\] console says hi', timeout=30) @@ -359,7 +378,7 @@ def horizon_client_joins(vanilla_server, binary, world, build, reference): server.wait_for(r'Done \(') env = lab.game_env(HORIZON_NET_REPORT=report) with (build / 'horizon-client-run.log').open('w') as log: - subprocess.run([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, + run_game([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, '--server', f'127.0.0.1:{port}', '--name', PLAYER]], cwd=client_dir, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) server.wait_for(r'left the game', timeout=30) diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py index 7ca48cb7f..a2c6ba036 100644 --- a/tools/test_dispenser_parity.py +++ b/tools/test_dispenser_parity.py @@ -17,7 +17,9 @@ import random import subprocess try: from . import block_update_harness as h, lab, test_rust_parity as base + from .integration_env import run_game except ImportError: + from integration_env import run_game import block_update_harness as h import lab import test_rust_parity as base @@ -349,7 +351,8 @@ def voice(line): def run(command, **kwargs): - done = subprocess.run(command, capture_output=True, text=True, **kwargs) + runner = run_game if str(command[0]).endswith('/horizon-client') else subprocess.run + done = runner(command, capture_output=True, text=True, **kwargs) if done.returncode: print((done.stdout + done.stderr)[-4000:]) raise SystemExit(f'{command[0]} failed') diff --git a/tools/test_entity_fluid_parity.py b/tools/test_entity_fluid_parity.py index b37a3e11d..f8cbf918d 100644 --- a/tools/test_entity_fluid_parity.py +++ b/tools/test_entity_fluid_parity.py @@ -29,6 +29,15 @@ def corpus(): if v[k] is not None:v[k]=[bits(n) for n in v[k]] return v def row(ops,player=False,order=(0,1,2)):return dict(ops=ops,player=player,order=order) + # Dropped items: the 0.25-wide box is deflated by Entity before scanning. + # Cover surface grazing, buoyancy depth, cell boundaries and repeated pushes. + for x in [.5, 1.0, 15.99]: + for y in [0, .1, .7, 8/9-.1, 8/9-.001, 8/9, 1]: + for flow in [(0,0,0),(1,0,0),(-1,0,1),(0,-1,0)]: + update=op(bounds=[x-.124,y+.001,.376,x+.124,y+.249,.624], + base_y=y,eye=y+.2125,block=[int(x),int(y),0], + default=cell(flow=flow)) + yield row([update,op(mode='apply'),update,op(mode='apply')]) values=[-float('inf'),-1,-.0,0,.1,.39999998,.4,.40000004,8/9,1,2,float('inf'),float('nan')] for kind in range(5): for height in values: diff --git a/tools/test_friends.py b/tools/test_friends.py index cc5d15b92..fd3d626a9 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -15,8 +15,9 @@ is off: nothing leaves the machine. python3 tools/test_friends.py --client target/fast/horizon-client --relay target/fast/horizon-relay -`--server-thread` runs the host's world on its integrated server's own -thread (the window is a client of it, as Open to LAN publishes it). +The host runs on its integrated server thread by default (the window is a +client of it). `--in-frame` compares the fallback; `--server-thread` is accepted +for compatibility. `--role host|guest` runs one side only (two machines, e.g. over a tailnet): the host prints the code, the guest takes it with `--code` (`--relay-url` @@ -36,8 +37,10 @@ import urllib.request try: from . import lab + from .integration_env import game_environment, require_server_reports except ImportError: import lab + from integration_env import game_environment, require_server_reports ROOT = Path(__file__).resolve().parents[1] @@ -84,7 +87,7 @@ class Game: prefix = [] extra = [] # The host's world on its server thread (`--server-thread`), else in the window. - server_thread = False + server_thread = True def __init__(self, client, resources, work, name, env): # Either way explicitly, whatever the game's default. @@ -96,7 +99,8 @@ class Game: self.process = subprocess.Popen(Game.prefix + [ str(client), '--resources', str(resources), '--render-distance', '2', '--test-terrain', '--control-socket', str(self.endpoint), '--timeout-seconds', '600', - ] + Game.extra, cwd=self.home, env=lab.game_env(HORIZON_HOME=self.home, **env), + ] + Game.extra, cwd=self.home, + env={**game_environment({**os.environ, **env}, self.home), 'HORIZON_HOME': str(self.home)}, stdout=self.log, stderr=subprocess.STDOUT) wait_for(self.endpoint, 'screen', lambda v: v['screen'] == 'title', 120, f'{name} title') @@ -149,10 +153,11 @@ def play_together(host, guest, name, round_index): before = guest_pos(host, name) guest('look 0 0') guest('key w down') - time.sleep(1.5) - guest('key w up') - host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, - 20, 'guest movement on the host') + try: + host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, + 20, 'guest movement on the host') + finally: + guest('key w up') # The host moves; the guest sees the host's player there. hp = host('status')['player']['position'] target = [hp[0] + 3.0, hp[1], hp[2] + 1.0] @@ -179,10 +184,11 @@ def play_together(host, guest, name, round_index): guest.wait('status', lambda v: v['target']['pos'] == block, 10, 'the guest aiming at the block') # Held for a few ticks, as a player clicks (creative breaks at once). guest('mouse left down') - time.sleep(0.25) - guest('mouse left up') - host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, - 'the guest breaking the block, on the host') + try: + host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, + 'the guest breaking the block, on the host') + finally: + guest('mouse left up') guest.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, 'the broken block on the guest') @@ -250,7 +256,7 @@ def full(args, work): join(guest, code, 'Guest') play_together(host, guest, 'Guest', 1) assert host('friends status')['direct'] == 1, host('friends status') - print('code alone: chat, movement and blocks both ways, no server involved') + print('code alone: chat, movement and blocks both ways, no relay involved') leave(host, guest, 'Guest') host('friends stop') assert host('friends status')['code'] is None @@ -316,8 +322,8 @@ def one_side(args, work): if args.role == 'host': code = host_world(game) print(f'CODE {code}', flush=True) - game.wait('lan status', lambda v: v['guests'], args.wait, 'a guest') - game.wait('lan status', lambda v: not v['guests'], args.wait, 'the guest leaving') + game.wait('lan status', lambda v: any(g['name'] == 'Remote' for g in v['guests']), args.wait, 'a guest') + game.wait('lan status', lambda v: all(g['name'] != 'Remote' for g in v['guests']), args.wait, 'the guest leaving') print(f'host: {game("friends status")}') else: join(game, args.code, 'Remote') @@ -347,16 +353,25 @@ def main(): parser.add_argument('--hold', type=float, default=0, help='guest: stay this many seconds before leaving') parser.add_argument('--baseline', action='store_true', help='first run the same checks over plain LAN') parser.add_argument('--offscreen', action='store_true', help='run the games without a window') - parser.add_argument('--server-thread', action='store_true', help="the host's world on its server thread") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') parser.add_argument('--xvfb', action='store_true', help='run the games under xvfb-run (headless Linux)') args = parser.parse_args() Game.prefix = ['xvfb-run', '-a'] if args.xvfb else [] Game.extra = ['--offscreen'] if args.offscreen else [] Game.server_thread = args.server_thread args.client, args.resources = args.client.resolve(), args.resources.resolve() + try: + require_server_reports(args.resources) + except ValueError as error: + parser.error(str(error)) # Short: Unix socket paths are limited to about 100 bytes. with tempfile.TemporaryDirectory(prefix='hzf-', dir='/tmp') as directory: work = Path(directory) + print(f'Friends host mode: {"server-thread" if Game.server_thread else "in-frame"}') if args.role: return one_side(args, work) assert args.relay, 'give --relay (the relay binary, run locally for the relay half)' diff --git a/tools/test_friends_integration_parity.py b/tools/test_friends_integration_parity.py new file mode 100644 index 000000000..c97787803 --- /dev/null +++ b/tools/test_friends_integration_parity.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +"""Real clients over LAN, direct invitations and a local relay, with a server-thread host. + +Registered with parity.py so changes to the drivers and the game binary select +this integration coverage in CI as well as the deterministic library probes. +""" +import json +from pathlib import Path +import subprocess +import sys + +import lab +import test_friends +from integration_env import suite_lock + + +if __name__ == '__main__': + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '-p', 'horizon-relay', '--bin', 'horizon-client', '--bin', 'horizon-ctl', + '--bin', 'horizon-relay'], cwd=lab.ROOT, check=True) + metadata = json.loads(subprocess.check_output( + ['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=lab.ROOT, text=True)) + bins = Path(metadata['target_directory']) / 'fast' + sys.argv = [sys.argv[0], '--client', str(bins / 'horizon-client'), + '--relay', str(bins / 'horizon-relay'), '--baseline', + *(['--offscreen'] if sys.platform == 'darwin' else [])] + with suite_lock(): + # The wrapper only selects binaries; test_friends isolates each game + # through integration_env and lab.game_env. + test_friends.main() diff --git a/tools/test_lan_integration_parity.py b/tools/test_lan_integration_parity.py new file mode 100644 index 000000000..773a7cd82 --- /dev/null +++ b/tools/test_lan_integration_parity.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +"""Register the real-client LAN suite with parity.py's traced harness selection. + +The assertions live in lan_e2e; this is integration coverage, alongside the +fast vanilla differential probes. The host uses the normal server thread. +Linux runners need a display (for example xvfb-run -a). +""" +import lan_e2e +from integration_env import suite_lock + + +if __name__ == '__main__': + with suite_lock(): + lan_e2e.main() diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py index 985b87a35..6574af76e 100644 --- a/tools/test_locator_bar_parity.py +++ b/tools/test_locator_bar_parity.py @@ -23,15 +23,14 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, wait_ticks except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, wait_ticks NAME = 'locator-bar-parity' PROPERTIES = { @@ -82,7 +81,7 @@ SCRIPT = [ ('creative', [], ['cmd Bob gamemode creative', 'cmd Bob tp @s 6.5 100 0.5']), ('bob-leaves', [], ['quit Bob']), ] -STEP_SECONDS = 2.0 +STEP_TICKS = 40 # Vanilla's server moves a player who just joined on their own first ticks (a tiny step and back), which tracks # them where they spawned; Horizon does not simulate its guests. These steps compare what the bar shows at # their end (Bob has moved by then) rather than every packet. @@ -147,6 +146,47 @@ def server_dir(directory, world=None): return port +class Client: + """A LocatorBarClient process driven by a script on its stdin. A step ends by the server's clock, not the wall's: + every script line has run (`sync`), the server has ticked `ticks` more times, and each client holds what the + server sent until then (a last `sync`). A server that stalls under load still gets all its ticks in the step, + where a fixed sleep filed a stalled server's packets under the next step.""" + + def __init__(self, command, port, out, log): + self.log = log + self.process = subprocess.Popen([*map(str, command), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True) + + def tell(self, line): + self.process.stdin.write(line + '\n') + self.process.stdin.flush() + + def sync(self, names): + """Every line told so far has run for these joined players, and they have received what the server sent + before.""" + for name in names: + self.tell(f'sync {name}') + for name in names: + while (line := self.process.stdout.readline()) != f'synced {name}\n': + if not line: + raise AssertionError(f'the client exited (see {self.log.name})') + self.log.write(line) + + def wait(self, server, names, ticks): + self.sync(names) + wait_ticks(server, ticks) + self.sync(names) + + def end(self): + self.tell('end') + self.log.write(self.process.communicate(timeout=60)[0]) + + def kill(self): + if self.process.poll() is None: + self.process.kill() + + def generate_world(server_command, build): """The flat world both servers load, made once by vanilla: players appear at its spawn itself (respawn_radius 0), on the ground at 0 -60 0, and the chunks around it are saved.""" @@ -176,28 +216,26 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + client = Client(client_command, port, out, log) + joined = [] try: for step, console, actions in SCRIPT: - client.stdin.write(f'step {step}\n') - client.stdin.flush() + client.tell(f'step {step}') for command in console: server.console(command) for action in actions: - client.stdin.write(action + '\n') - client.stdin.flush() - if action.startswith('join'): + client.tell(action) + verb, *rest = action.split() + if verb == 'join': # Joining takes the world's first chunks: wait for the server to place the player. - server.wait_for(rf'{action.split()[1]} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - client.stdin.write('end\n') - client.stdin.flush() - client.wait(timeout=60) + server.wait_for(rf'{rest[0]} joined the game', timeout=120) + joined.append(rest[0]) + elif verb == 'quit': + joined.remove(rest[0]) + client.wait(server, joined, STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): @@ -234,10 +272,11 @@ def sides(name): def one_player(name, script, shown, check, scope, step_seconds=4.0): """A harness of one player, Alice: on each server she joins, then runs `script`, a list of (step, client - actions) `step_seconds` apart. The lines `shown(transcript)` keeps must match vanilla's exactly, and + actions) that each last `step_seconds` of the server's time (20 ticks a second). The lines `shown(transcript)` keeps must match vanilla's exactly, and `check(vanilla's shown lines, vanilla's transcript)` returns why vanilla's run is no proof (the script did not run), or None.""" lock, build, vanilla_server, horizon_server, client = sides(name) + ticks = round(step_seconds * 20) def run(label, server_command, world): directory = build / label @@ -248,27 +287,20 @@ def one_player(name, script, shown, check, scope, step_seconds=4.0): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - process = subprocess.Popen([*map(str, client), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, - stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, text=True) - - def tell(line): - process.stdin.write(line + '\n') - process.stdin.flush() + session = Client(client, port, out, log) try: for line in ['players on', 'state on', 'step joins', 'join Alice']: - tell(line) + session.tell(line) server.wait_for(r'Alice joined the game', timeout=120) - time.sleep(step_seconds) + session.wait(server, ['Alice'], ticks) for step, actions in script: - tell(f'step {step}') + session.tell(f'step {step}') for action in actions: - tell(action) - time.sleep(step_seconds) - tell('end') - process.wait(timeout=60) + session.tell(action) + session.wait(server, ['Alice'], ticks) + session.end() finally: - if process.poll() is None: - process.kill() + session.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py index d03838bf3..8096efd80 100644 --- a/tools/test_online_mode_parity.py +++ b/tools/test_online_mode_parity.py @@ -50,11 +50,13 @@ import urllib.parse try: from . import lab, oracle_harness as oh, test_rust_parity as base from .test_dedicated_server_parity import Server, free_port + from .integration_env import run_game except ImportError: import lab import oracle_harness as oh import test_rust_parity as base from test_dedicated_server_parity import Server, free_port + from integration_env import run_game NAME = 'online-mode-parity' PLAYER = 'Tester' @@ -185,7 +187,7 @@ def run_client(binary, build, port, label, token, discovery): if token: command += ['--session-file', session_file(directory, token)] with (build / f'client-{label}.log').open('w') as log: - subprocess.run([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, + run_game([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) got = json.loads(report.read_text()) got['session file left'] = (directory / 'session.json').exists() diff --git a/tools/test_pack_screen_parity.py b/tools/test_pack_screen_parity.py index 1f3f03ede..77249ec5e 100644 --- a/tools/test_pack_screen_parity.py +++ b/tools/test_pack_screen_parity.py @@ -147,7 +147,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaPackScreenOracle'))], 'compile-java') run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaPackScreenOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', lab.RESOURCES / 'assets'], 'vanilla') lib.cargo_example('horizon-client', 'pack_screen_fixture', lib.RESOURCES, inputs, build / 'rust.jsonl') vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()] rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()] diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py index b1efc4378..ea026a509 100644 --- a/tools/test_server_dimension_players_parity.py +++ b/tools/test_server_dimension_players_parity.py @@ -16,17 +16,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-dimension-players-parity' NETHER, END, OVERWORLD = 'minecraft:the_nether', 'minecraft:the_end', 'minecraft:overworld' @@ -41,8 +40,14 @@ SCRIPT = [ # Through an End portal (Entity.handlePortal), and back by command. ('bob-portal', ['cmd Bob setblock 2 101 3 minecraft:end_portal', 'cmd Bob tp @s 2.5 101 3.5']), ('bob-portal-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), + # Sent far into the Nether, then teleported within it before the far chunks load: a portal there + # still takes him (the abandoned arrival does not hold him). + ('bob-retarget', [f'cmd Bob execute in {NETHER} run tp @s 8192.5 100 0.5', 'cmd Bob tp @s 0.5 100 0.5']), + ('bob-retarget-portal', ['cmd Bob setblock 0 101 3 minecraft:end_portal', 'cmd Bob tp @s 0.5 101 3.5']), + ('bob-retarget-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), ] -STEP_SECONDS = 5.0 +PLAYERS = ('Alice', 'Bob') +STEP_TICKS = 100 def run_side(label, server_command, client_command, build, world): @@ -54,38 +59,30 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: - tell('players on') - tell('step joins') - for name, x in (('Alice', 0.5), ('Bob', 2.5)): - tell(f'join {name}') + client.tell('players on') + client.tell('step joins') + for name, x in zip(PLAYERS, (0.5, 2.5)): + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - tell(f'fly {name} on') - tell(f'cmd {name} tp @s {x} 100 0.5') - time.sleep(STEP_SECONDS) + client.tell(f'fly {name} on') + client.tell(f'cmd {name} tp @s {x} 100 0.5') + client.wait(server, PLAYERS, STEP_TICKS) for step, actions in SCRIPT: - tell(f'step {step}') + client.tell(f'step {step}') for action in actions: - tell(action) + client.tell(action) # Standing still, a client still sends its position every 20 ticks # (LocalPlayer.sendPosition): the server then tracks to it what it has sent the # chunks of since (ChunkMap.move). - time.sleep(STEP_SECONDS / 2) - tell('still Alice') - tell('still Bob') - time.sleep(STEP_SECONDS / 2) - tell('end') - client.wait(timeout=60) + client.wait(server, PLAYERS, STEP_TICKS // 2) + for name in PLAYERS: + client.tell(f'still {name}') + client.wait(server, PLAYERS, STEP_TICKS // 2) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py index d7fbaeba1..66b75946e 100644 --- a/tools/test_server_knockback_parity.py +++ b/tools/test_server_knockback_parity.py @@ -18,6 +18,11 @@ players made of vanilla's protocol code, joins them both and runs one script on travelled a tick (the mob's hit, then ServerPlayer's travel, then ServerEntity.sendChanges). It is night, so that no zombie burns (a burning mob is in its hurt cooldown). +The script waits on the server, not on the wall: `ticks N` is N ticks of its game clock (with a `sync` round trip +before and after, so each client holds what the server sent), `tickstep` is one `/tick step` that has run, `frozen` +a frozen game that has stopped, and `hit` a hit that has landed (a frozen server still ticks its players, so a hit +lands in Alice's next tick). A server that stalls under load gets the same ticks as an idle one. + Each case is compared on its own. KNOWN lists the cases Horizon still gets wrong and why; one that matches again is reported, and should leave the list. """ @@ -32,15 +37,16 @@ import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from .test_locator_bar_parity import generate_world, ops_json except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from test_locator_bar_parity import generate_world, ops_json NAME = 'server-knockback-parity' +PLAYERS = ('Alice', 'Bob') PROPERTIES = { 'online-mode': 'false', 'white-list': 'false', @@ -82,18 +88,17 @@ def mob_case(kind, weapon=SWORD, sprint=False, crit=False, air=False): f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true'] lines = ['cmd Alice kill @e[type=!player]', 'cmd Alice gamemode creative', 'cmd Bob gamemode creative', f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Alice tp Bob 2.5 -60 12.5', - *stand('Alice', A, -90), 'sleep 1.2'] + *stand('Alice', A, -90), 'ticks 24'] # In the air: frozen before its first tick, so it has not landed. - lines += ['cmd Alice tick freeze', *summon] if air else [*summon, 'sleep 1.5', 'cmd Alice tick freeze'] - lines += ['sleep 0.3', f'cmd Alice data get entity {mob} Pos'] + lines += ['cmd Alice tick freeze', 'frozen', *summon] if air else [*summon, 'ticks 30', 'cmd Alice tick freeze', 'frozen'] + lines += [f'cmd Alice data get entity {mob} Pos'] if sprint: lines.append('sprint Alice on') if crit: lines += falling(0.8) - lines += ['sleep 0.2', f'attack Alice {kind}', 'sleep 0.2', f'cmd Alice data get entity {mob} Motion'] + lines += [f'hit {kind}', f'cmd Alice data get entity {mob} Motion'] for _ in range(20): - lines += ['cmd Alice tick step 1', 'sleep 0.25', f'cmd Alice data get entity {mob} Pos', - f'cmd Alice data get entity {mob} Motion'] + lines += ['tickstep', f'cmd Alice data get entity {mob} Pos', f'cmd Alice data get entity {mob} Motion'] lines += ['cmd Alice tick unfreeze', 'cmd Alice kill @e[type=!player]'] if sprint: lines.append('sprint Alice off') @@ -114,7 +119,7 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if shield: # A shield blocks from five ticks after it is raised. lines += ['cmd Bob item replace entity @s weapon.mainhand with minecraft:shield', 'use Bob'] - lines += ['sleep 1.5', *stand('Bob', V, 90, ticks=1)] + lines += ['ticks 30', *stand('Bob', V, 90, ticks=1)] if sprint: lines.append('sprint Alice on') if crit: @@ -124,10 +129,12 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if cooldown: # A swing at the air first: the hit is weak, and the stronger one four ticks later lands inside Bob's hurt # cooldown (LivingEntity.hurtServer: it hurts by the difference, with no knockback and no motion packet). - lines += ['sleep 0.2', 'punch Alice', 'attack Alice Bob'] - lines += ['sleep 0.2', 'attack Alice Bob', 'sleep 0.3'] + lines += ['ticks 4', 'punch Alice', 'attack Alice Bob'] + # The gap between those two hits is an upper bound on the server's ticks, so a stalled server (which gets + # fewer in a wall's 0.2 s) still lands the second inside the cooldown; the rest is to have the server's ticks. + lines += ['sleep 0.2' if cooldown else 'ticks 4', 'attack Alice Bob', 'ticks 6'] if twice: - lines += [*stand('Bob', V, 90, ticks=20), 'sleep 1.5', 'attack Alice Bob', 'sleep 0.3'] + lines += [*stand('Bob', V, 90, ticks=20), 'ticks 30', 'attack Alice Bob', 'ticks 6'] if sprint: lines.append('sprint Alice off') lines += stand('Alice', A, -90) @@ -144,7 +151,7 @@ def mob_hits_case(kind): hit = ['mark Bob', f'cmd Alice summon minecraft:{kind} {V[0] + 1} {V[1]} {V[2]} {{Rotation:[90f,0f]}}', f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true', 'await Bob', f'cmd Alice kill {mob}'] return ['cmd Bob clear @s', 'cmd Bob effect give @s minecraft:resistance 1000 4 true', 'cmd Alice gamemode creative', - *stand('Bob', V, 90), *hit, 'sleep 2', *stand('Bob', V, 90), *hit, 'sleep 1', + *stand('Bob', V, 90), *hit, 'ticks 40', *stand('Bob', V, 90), *hit, 'ticks 20', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamemode survival'] @@ -173,7 +180,20 @@ CASES = { } SETUP = ['cmd Alice gamerule spawn_mobs false', 'cmd Alice gamerule spawn_monsters false', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamerule advance_time false', 'cmd Alice time set midnight', - f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'sleep 2'] + f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'ticks 40'] + + +def server_data(server, selector, path, timeout=120): + """An entity's data, asked from the console (its reply stays in the server's log, out of the clients').""" + deadline = time.time() + timeout + start = len(server.lines) + server.console(f'data get entity {selector} {path}') + while time.time() < deadline: + for line in server.lines[start:]: + if 'has the following entity data' in line: + return line.split('data: ', 1)[-1] + time.sleep(0.02) + raise AssertionError(f'{server.log_path.name}: no entity data in {timeout} s') def server_dir(directory, world): @@ -201,29 +221,72 @@ def run_side(label, server_command, client_command, build, world): server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) + + def sync(): + """Every script line sent so far has run, and each client holds what its server sent before.""" + for name in PLAYERS: + client.stdin.write(f'sync {name}\n') + client.stdin.flush() + for name in PLAYERS: + while (reply := client.stdout.readline()) != f'synced {name}\n': + if not reply: + raise AssertionError(f'{label}: the client exited (see {build}/{label}-client.log)') + log.write(reply) def send(line): - if line.startswith('sleep '): + """A script line for the client, or one of ours: the waits are on the server's game clock, not the + wall's, so a server that stalls under load still gets the ticks each case needs.""" + word = line.split()[0] + if word == 'sleep': time.sleep(float(line.split()[1])) + elif word == 'ticks': + sync() + wait_ticks(server, int(line.split()[1])) + sync() + elif word == 'frozen': + # The tick in flight when ticking was frozen has finished: the clock reads the same twice. + sync() + while game_time(server) != game_time(server): + pass + elif word == 'hit': + # Alice hits the mob. A frozen server still ticks its players, and the hit lands in Alice's + # next tick, not when the packet arrives: the mob's motion says when it has. + sync() + mob = f'@e[type=minecraft:{line.split()[1]},limit=1]' + before = server_data(server, mob, 'Motion') + client.stdin.write(f'attack Alice {line.split()[1]}\n') + client.stdin.flush() + while server_data(server, mob, 'Motion') == before: + time.sleep(0.05) + sync() + elif word == 'tickstep': + # `/tick step 1` answers at once and the tick runs after: the clock says when it has. + sync() + before = game_time(server) + client.stdin.write('cmd Alice tick step 1\n') + client.stdin.flush() + while game_time(server) == before: + time.sleep(0.05) + sync() else: client.stdin.write(line + '\n') client.stdin.flush() try: - for name in ('Alice', 'Bob'): + for name in PLAYERS: send(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(2) + wait_ticks(server, 40) for line in SETUP: send(line) for case, lines in CASES.items(): send(f'step {case}') for line in lines: send(line) - time.sleep(0.5) + send('ticks 10') send('end') - client.wait(timeout=60) + log.write(client.communicate(timeout=60)[0]) finally: if client.poll() is None: client.kill() diff --git a/tools/test_structure_blocks_parity.py b/tools/test_structure_blocks_parity.py index 39ccb4e49..fc4151f8d 100644 --- a/tools/test_structure_blocks_parity.py +++ b/tools/test_structure_blocks_parity.py @@ -55,6 +55,12 @@ KNOWN = { "Better Dungeons' own structure types (spec-betterdungeons §5, §6; OPEN-B14, B15) are not " 'implemented yet', }, + 'ctov': { + r'^ctov:': "Lithostitched's random is not known (spec-lithostitched OPEN-L6): per-block road and palette " + 'choices match by share, not by block; and decoration (grass, trees) differs where the village ' + 'changed the terrain', + r'^minecraft:village_plains$': 'decoration (grass, trees) differs where the village changed the terrain', + }, } diff --git a/tools/test_tab_list_parity.py b/tools/test_tab_list_parity.py index 4075859e7..3d7c84d62 100644 --- a/tools/test_tab_list_parity.py +++ b/tools/test_tab_list_parity.py @@ -240,7 +240,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaTabListOracle', 'VanillaSkinImageOracle'))], 'compile-java') run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTabListOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', resources / 'assets'], 'vanilla') run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe', '--', 'tab_list_fixture', resources, inputs, build / 'rust.jsonl'], 'rust') images = build / 'skins.txt'; images.write_text(''.join(i + '\n' for i in skin_images(args.images))) diff --git a/website/docs/index.md b/website/docs/index.md index 24f969840..5a64a4a8a 100644 --- a/website/docs/index.md +++ b/website/docs/index.md @@ -7,7 +7,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. You install it with a - **A new game program, not a mod.** Horizon is written from scratch in Rust. It reads the same worlds, plays by the same rules and generates the same terrain as the Java game. - **Checked against vanilla.** {{HARNESSES}} automated tests ("harnesses") feed the same inputs to Horizon and to the real game, then compare the results. Today every subsystem matches in every harness that compares it. That is {{PERCENT}} of what the harnesses compare, which is not proof that nothing else differs. The [status table](/#parity) lists what is covered. - **Light and fast.** It starts quickly, uses little memory and draws efficiently. See [Performance](/docs/performance) for what is measured and what is not. -- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as zoom, a minimap and dynamic lights, an invite code to play your world with friends, and a server you can run without Java. +- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as dynamic lights, official mods such as zoom and a minimap, an invite code to play your world with friends, and a server you can run without Java. ## What Horizon is not diff --git a/website/docs/mods.md b/website/docs/mods.md index 405c62976..34330835d 100644 --- a/website/docs/mods.md +++ b/website/docs/mods.md @@ -32,7 +32,7 @@ cd my-mod cargo horizon-mod build ``` -The [Mod API](/docs/api/mods) lists what a mod can do today and what comes next, and its [reference](/docs/api/mods-reference) every function. Java mod jars don't run in Horizon: their code calls and patches Minecraft's Java classes, and Horizon has none. What carries over is the data and assets inside a jar ([modpacks](/docs/modpacks)). +`cargo horizon-mod test` runs the mod's test scripts (`tests/*.toml`: ticks, commands and the player's position in, chat and HUD lines checked) with no game open. The [Mod API](/docs/api/mods) lists what a mod can do today and what comes next, and its [reference](/docs/api/mods-reference) every function. Java mod jars don't run in Horizon: their code calls and patches Minecraft's Java classes, and Horizon has none. What carries over is the data and assets inside a jar ([modpacks](/docs/modpacks)). ## Finding resource packs and modpacks diff --git a/website/docs/settings.md b/website/docs/settings.md index 29eb0a760..1e36bee11 100644 --- a/website/docs/settings.md +++ b/website/docs/settings.md @@ -63,7 +63,7 @@ Horizon plays with PlayStation (DualShock 4 and DualSense), Xbox (360, One and S ## Extras -**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, zoom, a minimap, an FPS counter, a keystroke display, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. One more is **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. +**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. The FPS counter, the keystroke display, zoom and the minimap are official mods now, in **Options, Mods**: if you had one on, the game installed it for you on its first start after the update, with your settings. One more is **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. ## Where your settings are stored