diff --git a/.gitattributes b/.gitattributes index 13584e4d9..358aeae7a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -3,3 +3,4 @@ docs/launcher-commands.md text eol=lf docs/horizon-ctl-commands.md text eol=lf website/src/tokens.css text eol=lf +docs/api/*-reference.md text eol=lf diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6b0fb2e0f..4cba851fa 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -367,10 +367,15 @@ jobs: TAG: ${{ needs.decide.outputs.tag }} run: | signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig) - # The release and the latest at once: there is one channel (docs/release-flow.md). + # The release and the latest at once: there is one channel (docs/release-flow.md). Each archive gets a + # label (file#label), which GitHub's page shows instead of the file name, so nobody takes the game's + # files for the download (#1647). Launchers, servers and install.sh match the name, which stays. gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \ - --notes-file notes/body.md --latest dist/horizon-linux-x86_64.tar.gz \ - dist/horizon-windows-x64.zip dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz \ + --notes-file notes/body.md --latest \ + "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs: Linux (horizon-linux-x86_64.tar.gz)" \ + "dist/horizon-windows-x64.zip#Game files the launcher installs: Windows (horizon-windows-x64.zip)" \ + "dist/horizon-macos-arm64.zip#Game files the launcher installs: macOS (horizon-macos-arm64.zip)" \ + "dist/horizon-server-linux-x86_64.tar.gz#Dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \ dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json - name: Dry run, the release that would be published if: needs.decide.outputs.dry_run == 'true' diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index af44d89f8..5191ea1f7 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -40,6 +40,15 @@ probe against Horizon, and compares their outputs. There are about 290 of them. Never commit game files, decompiled source or prepared resources (`.local/`): `tools/check_public_tree.py` rejects them (`git config core.hooksPath .githooks` runs it before every commit). +## Only original code + +Horizon's code is written from Minecraft 26.3 itself and from public documentation, never from another mod, loader +or renderer. Don't read, copy, translate or paraphrase the source of Iris, OptiFine, Sodium or any other project, +and don't send code an AI tool wrote from it. Their user documentation and file formats are fine to read, and their +packs and mods are fine to run and observe. Shader packs were removed on 24 October 2026 (#1561) because their code +had been written from another project's source; they come back only as a clean-room rewrite from a written +description of the pack format. + ## Before asking for review Run the self-check and paste the block it prints into your pull request: diff --git a/Cargo.lock b/Cargo.lock index 46aa212a1..2d09d2d0e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -155,7 +155,7 @@ dependencies = [ "objc2-foundation 0.3.2", "parking_lot", "percent-encoding", - "windows-sys 0.59.0", + "windows-sys 0.60.2", "wl-clipboard-rs", "x11rb", ] @@ -1281,6 +1281,7 @@ dependencies = [ "rustix 1.1.5", "serde", "serde_json", + "sha1", "sha2", "symphonia", "ureq", @@ -1317,7 +1318,7 @@ dependencies = [ "serde", "serde_json", "sha2", - "socket2", + "socket2 0.5.10", "spake2", ] @@ -1333,8 +1334,10 @@ name = "horizon-mods" version = "0.1.0" dependencies = [ "log", + "minisign-verify", "serde", "serde_json", + "sha2", "toml", "wasmtime", "wit-component 0.239.0", @@ -1380,6 +1383,7 @@ dependencies = [ "getrandom 0.3.4", "horizon-core", "horizon-world", + "ipconfig", "serde_json", "sha1", "sha2", @@ -1665,6 +1669,19 @@ dependencies = [ "generic-array", ] +[[package]] +name = "ipconfig" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222" +dependencies = [ + "socket2 0.6.5", + "widestring", + "windows-registry", + "windows-result 0.4.1", + "windows-sys 0.61.2", +] + [[package]] name = "itertools" version = "0.14.0" @@ -1909,6 +1926,12 @@ dependencies = [ "libc", ] +[[package]] +name = "minisign-verify" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "871285dc19d8d0ebe0eef3d0e99a205f2a71363b122632cbbfa4a6c370a960ce" + [[package]] name = "miniz_oxide" version = "0.8.9" @@ -3159,6 +3182,16 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "socket2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + [[package]] name = "spake2" version = "0.4.0" @@ -4316,6 +4349,12 @@ dependencies = [ "web-sys", ] +[[package]] +name = "widestring" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471" + [[package]] name = "winapi-util" version = "0.1.11" @@ -4448,6 +4487,17 @@ dependencies = [ "windows-link", ] +[[package]] +name = "windows-registry" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" +dependencies = [ + "windows-link", + "windows-result 0.4.1", + "windows-strings", +] + [[package]] name = "windows-result" version = "0.1.2" diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md index 88d3197af..63a1f7da3 100644 --- a/THIRD_PARTY_NOTICES.md +++ b/THIRD_PARTY_NOTICES.md @@ -1,35 +1,5 @@ # Third-party notices -## CullLeaves - -The optional leaf and mangrove-root face-culling behavior is adapted from -[CullLeaves](https://github.com/TeamMidnightDust/CullLeaves) by MidnightDust. -Its MIT license is reproduced below. - -```text -MIT License - -Copyright (c) 2020 MidnightDust - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -``` - ## wgpu-hal `third_party/wgpu-hal` is [wgpu-hal](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs diff --git a/crates/horizon-bench/src/hardware.rs b/crates/horizon-bench/src/hardware.rs index 17e460bed..440c834d8 100644 --- a/crates/horizon-bench/src/hardware.rs +++ b/crates/horizon-bench/src/hardware.rs @@ -1,8 +1,7 @@ //! The machine a report was measured on. CPU, RAM and OS are detected here; the GPU and the display //! come from the program that rendered (the game knows its adapter, the launcher its window). -use std::process::Command; - +use horizon_telemetry::system::command_output as output; use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] @@ -173,12 +172,6 @@ pub fn cpu_seconds(pid: u32) -> Option { Some(ticks / 100.0) } -fn output(program: &str, args: &[&str]) -> Option { - let out = Command::new(program).args(args).output().ok()?; - let text = String::from_utf8(out.stdout).ok()?.trim().to_owned(); - (out.status.success() && !text.is_empty()).then_some(text) -} - #[cfg(target_os = "macos")] fn os_version() -> Option { output("sw_vers", &["-productVersion"]) diff --git a/crates/horizon-bench/src/lib.rs b/crates/horizon-bench/src/lib.rs index bdc885af1..ae70977bd 100644 --- a/crates/horizon-bench/src/lib.rs +++ b/crates/horizon-bench/src/lib.rs @@ -245,13 +245,19 @@ pub struct Report { impl Report { /// An empty report for this machine, created now. pub fn new(kind: Kind, app: App) -> Report { + Self::with_hardware(kind, app, Hardware::detect()) + } + + /// Starts a report using supplied hardware, without running system probes. + /// Interactive apps can collect the remaining machine details after their first frame. + pub fn with_hardware(kind: Kind, app: App, hardware: Hardware) -> Report { Report { format: FORMAT.to_owned(), version: VERSION, kind, created: utc_now(), app, - hardware: Hardware::detect(), + hardware, conditions: Conditions::default(), metrics: BTreeMap::new(), frames: Vec::new(), diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index 80bc03344..ea5859c23 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -29,6 +29,8 @@ bytemuck = { version = "1.24", features = ["derive"] } glam = "0.30" png = "0.18" sha2 = "0.10.9" +# Server resource packs are checked and cached by their SHA-1, as vanilla does. +sha1 = "0.10" serde = { version = "1", features = ["derive"] } serde_json = { version = "1.0.151", features = ["raw_value"] } # hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature, diff --git a/crates/horizon-client/examples/probe/pack_screen_fixture.rs b/crates/horizon-client/examples/probe/pack_screen_fixture.rs index 881570990..5d84ce0a6 100644 --- a/crates/horizon-client/examples/probe/pack_screen_fixture.rs +++ b/crates/horizon-client/examples/probe/pack_screen_fixture.rs @@ -5,7 +5,7 @@ //! //! usage: pack_screen_fixture RESOURCES CASES OUTPUT use horizon_client::{ - hud::HudAtlas, + hud::{HudAtlas, PACK_ICON_SIZE}, lang, pack_screen::{Compat, PackInfo, PackScreen, Source}, packs::{self, Position}, @@ -13,7 +13,7 @@ use horizon_client::{ text::Text, }; use serde_json::{Value, json}; -use std::{fmt::Write as _, fs, path::PathBuf}; +use std::{fmt::Write as _, fs, path::PathBuf, sync::Arc}; /// Styled runs: [text, rgb or null, bold, italic, underlined, strikethrough, obfuscated]. pub fn runs(t: &Text) -> Value { @@ -105,7 +105,9 @@ pub fn main() -> horizon_client::Result<()> { Some("unknown") => Compat::Unknown, _ => Compat::Compatible, }, - icon: p["icon"].as_bool().unwrap_or(false), + icon: p["icon"].as_bool().unwrap_or(false).then(|| { + Arc::from(vec![0; (PACK_ICON_SIZE * PACK_ICON_SIZE * 4) as usize]) + }), required: p["required"].as_bool().unwrap_or(false), position: if p["position"] == "top" { Position::Top diff --git a/crates/horizon-client/examples/probe/section_mesh_fixture.rs b/crates/horizon-client/examples/probe/section_mesh_fixture.rs index 98a4fdc34..e212a5268 100644 --- a/crates/horizon-client/examples/probe/section_mesh_fixture.rs +++ b/crates/horizon-client/examples/probe/section_mesh_fixture.rs @@ -136,7 +136,6 @@ fn scene( blend_radius, smooth_lighting, cutout_leaves, - cull_leaves: false, }; let section_y = int(&row["section_y"])?; let started = Instant::now(); diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs index cfca854dc..3ff2cfdd6 100644 --- a/crates/horizon-client/src/collisions.rs +++ b/crates/horizon-client/src/collisions.rs @@ -133,6 +133,30 @@ impl> EntityMovementWorld for EntityCo border.collision_shape().map(Some).map_err(io::Error::other) } } +impl EntityCollisions<'_, SceneCollisions<'_, '_>> { + /// `SceneCollisions::resolve` that also stops at the entity boxes. + pub fn resolve( + &mut self, + bounds: Aabb, + movement: Vec3, + max_step: f32, + on_ground: bool, + ) -> Result { + let context = self.blocks.context(bounds); + Ok(resolve_world_movement( + self, + MovementRequest { + entity: EntityIdentity(0), + context, + bounds, + movement, + max_step, + on_ground, + candidate_budget: 1_000_000, + }, + )?) + } +} impl SceneCollisions<'_, '_> { /// Position contexts permit geometric movement probes without inventing a /// player, inventory, effects or fluid-standing behavior; a lava walker diff --git a/crates/horizon-client/src/confirm_screen.rs b/crates/horizon-client/src/confirm_screen.rs new file mode 100644 index 000000000..3b4f7e7aa --- /dev/null +++ b/crates/horizon-client/src/confirm_screen.rs @@ -0,0 +1,75 @@ +//! `ConfirmScreen`: a title, a message wrapped to `width - 50` (15 lines at +//! most) and two 150-wide buttons 4 apart and 16 below it, the whole column +//! centred; Escape answers no. +use crate::{ + font::Font, + hud::{HudAtlas, HudBatch}, + text::Text, + ui, +}; + +pub struct Confirm { + /// Each line and where it is drawn. + pub lines: Vec<(Text, f32, f32)>, + /// The yes and no buttons' corners. + pub buttons: [(f32, f32); 2], +} +impl Confirm { + pub fn new(font: &Font, (w, h): (f32, f32), title: &Text, message: &Text) -> Self { + let message: Vec = font + .split_lines(message, w - 50.0) + .into_iter() + .map(|(line, _)| line) + .take(15) + .collect(); + let tw = font.width_text(title); + let mw = message + .iter() + .map(|l| font.width_text(l)) + .fold(0.0, f32::max); + let mh = 9.0 * message.len() as f32; + let col = tw.max(mw).max(304.0); + let total = 9.0 + 8.0 + mh + 8.0 + 36.0; + let (lx, ly) = (((w - col) / 2.0).trunc(), ((h - total) / 2.0).trunc()); + let cell = |cw: f32| lx + ((col - cw) / 2.0).trunc(); + let mid = cell(mw) + (mw / 2.0).trunc(); + let mut lines = vec![(title.clone(), cell(tw), ly)]; + for (i, line) in message.into_iter().enumerate() { + let x = mid - (font.width_text(&line) / 2.0).trunc(); + lines.push((line, x, ly + 17.0 + 9.0 * i as f32)); + } + let (bx, by) = (cell(304.0), ly + 9.0 + 8.0 + mh + 8.0 + 16.0); + Self { + lines, + buttons: [(bx, by), (bx + 154.0, by)], + } + } + /// The answer a click at `cursor` gives: true for yes, false for no. + pub fn answer_at(&self, cursor: (f32, f32)) -> Option { + let [yes, no] = self.buttons; + let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0); + if on(yes) { + Some(true) + } else if on(no) { + Some(false) + } else { + None + } + } + /// The lines and the buttons (yes first), over whatever is behind. + pub fn draw( + &self, + batch: &mut HudBatch, + atlas: &HudAtlas, + cursor: (f32, f32), + labels: [&Text; 2], + ) { + for (line, x, y) in &self.lines { + batch.text_styled(atlas, line, *x, *y, u32::MAX, true); + } + for ((bx, by), label) in self.buttons.into_iter().zip(labels) { + let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); + ui::button(batch, atlas, bx, by, 150.0, 20.0, label, true, hover); + } + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 15aabd222..352e1e30e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -13,6 +13,7 @@ mod block_entity_anims; mod block_entity_ticks; mod block_items; mod blockctl; +mod boat_passengers; mod boats; mod books; mod bossbars; @@ -137,6 +138,7 @@ mod scoreboard; mod screens; mod sculk; mod sculk_fixture; +mod server_packs; mod server_travel; mod shader_packs; mod shield; @@ -1127,6 +1129,8 @@ struct Game<'a> { pending_entry: Option, world_loader: Option, pending_pack_reload: bool, + /// A server's resource packs (game/server_packs.rs). + server_packs: server_packs::ServerPackState, world_renderer_ready: bool, collision: &'a BlockCollisionRegistry<'a>, motion: &'a MotionResources, @@ -4411,7 +4415,7 @@ impl Game<'_> { self.resolve_arrivals(); }); } - horizon_client::spans::time("tick_lan", || self.tick_lan()); + horizon_client::spans::time("tick_lan", || self.tick_lan(false)); self.tick_friends(); horizon_client::spans::time("tick_hand", || self.tick_hand()); horizon_client::spans::time("tick_sleep", || self.tick_sleep()); @@ -4772,7 +4776,14 @@ impl Game<'_> { hud_layout::paint(batch, &self.gui.atlas, &draws); } fn hud(&mut self, size: [u32; 2]) -> HudBatch { - let mut batch = self.hud_layers(size); + // The pack prompt replaces the connecting screen (setScreen), but + // in game it opens over the world. + let mut batch = if self.server_packs.prompt.is_some() && self.player.is_none() { + HudBatch::new(size) + } else { + self.hud_layers(size) + }; + self.draw_pack_prompt(&mut batch); // Gui.extractRenderState: the debug overlay comes after the screen // and the toasts, so it is over everything, menus included. self.draw_debug_overlay(&mut batch, size); @@ -9081,21 +9092,11 @@ impl Game<'_> { // Options.biomeBlendRadius, ambientOcclusion and cutoutLeaves: // LevelExtractor.allChanged when they change. let (s, st) = (&self.settings, &self.streaming); - let remesh = ( - s.biome_blend, - s.smooth_lighting, - s.cutout_leaves, - s.horizon.cull_leaves, - ) != ( - st.biome_blend, - st.smooth_lighting, - st.cutout_leaves, - st.cull_leaves, - ); + let remesh = (s.biome_blend, s.smooth_lighting, s.cutout_leaves) + != (st.biome_blend, st.smooth_lighting, st.cutout_leaves); self.streaming.biome_blend = self.settings.biome_blend; self.streaming.smooth_lighting = self.settings.smooth_lighting; self.streaming.cutout_leaves = self.settings.cutout_leaves; - self.streaming.cull_leaves = self.settings.horizon.cull_leaves; if remesh { self.all_sections_changed(); } @@ -11002,6 +11003,13 @@ impl ApplicationHandler for Game<'_> { self.advancements_scroll(scaled(raw_x) as f32, d); } } + WindowEvent::MouseInput { state, button, .. } + if self.server_packs.prompt.is_some() => + { + if state == ElementState::Pressed && button == MouseButton::Left { + self.pack_prompt_click()?; + } + } WindowEvent::MouseInput { .. } if self.screen == Screen::Win => {} WindowEvent::MouseInput { state, button, .. } if self.screen == Screen::Options => { if self.options_waiting_for_key() && state == ElementState::Pressed { @@ -11201,6 +11209,14 @@ impl ApplicationHandler for Game<'_> { _ => {} } } + // ConfirmScreen.keyPressed: Escape answers no. + WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => { + if event.state == ElementState::Pressed + && event.physical_key == PhysicalKey::Code(KeyCode::Escape) + { + self.answer_pack_prompt(false)?; + } + } WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Chat && self.title.is_none() => { @@ -11579,6 +11595,7 @@ impl ApplicationHandler for Game<'_> { event_loop.exit(); return; } + self.tick_server_packs(); self.poll_control(event_loop); if self.pending_save.is_some() { return; @@ -11673,6 +11690,7 @@ impl<'a> Game<'a> { pending_entry: None, world_loader: None, pending_pack_reload: false, + server_packs: Default::default(), world_renderer_ready: false, collision: res.collision(), motion: res.motion(), @@ -13262,7 +13280,7 @@ pub fn run() -> Result<()> { return run_loading(options, early_settings, vanilla_root, None, started); } let mut pack_error = None; - options.resources = packs::startup_root(&vanilla_root, &early_settings.resource_packs) + options.resources = packs::startup_root(&vanilla_root, &early_settings.resource_packs, &[]) .unwrap_or_else(|e| { log::warn!("Horizon: resource packs not applied: {e}"); pack_error = Some(e.to_string()); diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 0eb215aa9..f6b68aa74 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -472,6 +472,8 @@ impl Game<'_> { "sprinting": self.keys.contains(&KeyCode::ControlLeft), "health": p.health.health(), "absorption": p.health.absorption(), + // The hurt animation's ticks left (the camera's hurt tilt). + "hurt_time": p.health.hurt_animation_time, "air": p.air, "food": p.health.food.food, "saturation": p.health.food.saturation, diff --git a/crates/horizon-client/src/game/boat_passengers.rs b/crates/horizon-client/src/game/boat_passengers.rs new file mode 100644 index 000000000..96686f69b --- /dev/null +++ b/crates/horizon-client/src/game/boat_passengers.rs @@ -0,0 +1,453 @@ +//! Boats and the entities around them: what a boat runs into +//! (`AbstractBoat.canVehicleCollide`), the pushes between a boat and what +//! touches it (`AbstractBoat.push`, `LivingEntity.pushEntities`), the mobs +//! it picks up (the end of `AbstractBoat.tick`), where they sit +//! (`positionRider`, `clampRotation`) and how they get out. +//! Saving them under the boat's `Passengers` lives in `persist.rs`. +use super::{Game, boats::Boat, lan_mobs::guest_bounds}; +use horizon_client::{ + camera::wrap_degrees, + mobs::{Mob, Species, Who, drops::is_animal, equine, riders}, + scoreboard::pushable_by, +}; +use horizon_core::geometry::{Aabb, Vec3}; + +/// `Entity.boardingCooldown` once a mob leaves its boat. +const BOARDING_COOLDOWN: i32 = 60; +/// `Player.DEFAULT_VEHICLE_ATTACHMENT`: how far below the seat a player's +/// feet are. +const PLAYER_RIDING_OFFSET: f64 = 0.6; + +/// `Entity.isVehicle`: a player or a mob rides it. +fn carries(m: &Mob) -> bool { + m.rider.is_some() || m.extra.rider.is_some() +} +/// `isPushable`, as `pushableBy` and `canVehicleCollide` ask it: +/// `Mob::pushable` plus the shulkers it leaves out (they take no push, but +/// count), less a ridden horse (`AbstractHorse.isPushable`). +fn pushable(m: &Mob) -> bool { + !m.removed + && (m.pushable() || m.species() == Species::Shulker && m.alive()) + && !(equine::is_equine(m.species()) && carries(m)) +} +/// Whether `Entity.push` moves the mob: it is pushable and carries no one. +fn moved_by_push(m: &Mob) -> bool { + !m.removed && m.pushable() && !carries(m) +} +/// `Entity.push(Entity)`: the push `other` gets from `this` (which takes the +/// opposite one), or None when they stand on nearly the same spot. +pub(super) fn push_impulse(this: Vec3, other: Vec3) -> Option { + let (mut xa, mut za) = (other.x - this.x, other.z - this.z); + let mut dd = xa.abs().max(za.abs()); + if dd < f64::from(0.01_f32) { + return None; + } + dd = dd.sqrt(); + xa /= dd; + za /= dd; + let pow = (1.0 / dd).min(1.0); + let k = f64::from(0.05_f32); + Some(Vec3::new(xa * pow * k, 0.0, za * pow * k)) +} +/// `AbstractBoat.push`: another boat is pushed while it is lower than this +/// boat's top, anything else while its feet are no higher than the boat's. +pub(super) fn boat_pushes(boat: Aabb, other: Aabb, other_is_boat: bool) -> bool { + if other_is_boat { + other.min_position().y < boat.max_position().y + } else { + other.min_position().y <= boat.min_position().y + } +} + +impl Game<'_> { + /// The players in boat `id`: the window's player (or the server player + /// acting as it) and the server's other players. + pub(super) fn boat_players(&self, id: u32) -> usize { + let guests = self.lan.as_ref().map_or(0, |h| { + h.hub + .guests + .iter() + .filter(|g| Some(g.conn) != self.lan_acting && g.vehicle == Some(id)) + .count() + }); + usize::from(self.riding == Some(id)) + guests + } + /// The mobs in boat `id`, in their seat order after the players + /// (`Entity.addPassenger` puts a player first). + pub(super) fn boat_mobs(&self, id: u32) -> Vec { + (0..self.mobs.len()) + .filter(|&j| { + let m = &self.mobs[j]; + m.extra.mount == Some(id) && !m.removed && m.alive() + }) + .collect() + } + /// `getPassengers().size()` of boat `id`. + pub(super) fn boat_passengers(&self, id: u32) -> usize { + self.boat_players(id) + self.boat_mobs(id).len() + } + /// `AbstractBoat.canAddPassenger`: a seat is free and the boat is not + /// under water. + pub(super) fn boat_has_room(&self, i: usize) -> bool { + let b = &self.boats[i]; + self.boat_passengers(b.id) < b.max_passengers() && !b.under_water() + } + /// Where the player in boat `i` sits: in the middle alone, in front of a + /// mob. + pub(super) fn player_boat_seat(&self, i: usize) -> Vec3 { + let b = &self.boats[i]; + let count = self.boat_players(b.id).max(1) + self.boat_mobs(b.id).len(); + b.seat(0, count, false, PLAYER_RIDING_OFFSET, false) + } + /// `getRootVehicle` of mob `j`: the mob or boat at the bottom of what it + /// rides, None when it rides nothing. + fn mob_root_vehicle(&self, mut j: usize) -> Option { + let mut root = None; + for _ in 0..8 { + let Some(v) = self.mobs[j].extra.mount else { + break; + }; + root = Some(v); + match self.mobs.iter().position(|m| m.id == v) { + Some(k) => j = k, + None => break, + } + } + root + } + /// The players outside boat `id` that push and block it (living, not + /// spectators), with the window player's team. + fn players_outside(&self, id: u32) -> Vec<(Aabb, bool)> { + let mut out = Vec::new(); + if let Some(p) = self.player.as_ref() + && self.riding != Some(id) + && !self.spectator() + && !p.health.dead_or_dying() + { + out.push((p.bounds(), true)); + } + if let Some(host) = self.lan.as_ref() { + for g in host.hub.guests.iter().filter(|g| { + Some(g.conn) != self.lan_acting + && host.hub.here(g) + && g.loaded + && !g.dead + && !g.spectator() + && g.vehicle != Some(id) + }) { + out.push((guest_bounds(g), false)); + } + } + out + } + /// `getEntityCollisions` of boat `id` within `area`, with + /// `AbstractBoat.canVehicleCollide`: the other boats, minecarts, + /// shulkers and pushable mobs and players, but not its own passengers. + pub(super) fn boat_obstacles(&self, id: u32, area: Aabb) -> Vec { + let mut out: Vec = (0..self.mobs.len()) + .filter(|&j| { + let m = &self.mobs[j]; + pushable(m) + && m.bounds().intersects(area) + && (m.extra.mount.is_none() || self.mob_root_vehicle(j) != Some(id)) + }) + .map(|j| self.mobs[j].bounds()) + .collect(); + out.extend( + self.boats + .iter() + .filter(|b| b.id != id) + .map(Boat::bounds) + .chain(self.carts.iter().map(|c| c.bounds())) + .chain(self.players_outside(id).into_iter().map(|(bb, _)| bb)) + .filter(|bb| bb.intersects(area)), + ); + out + } + /// What boat `b` may run into this tick. + pub(super) fn boat_move_obstacles(&self, b: &Boat) -> Vec { + let reach = b.velocity.length() + 1.0; + self.boat_obstacles(b.id, b.bounds().inflate(Vec3::new(reach, reach, reach))) + } + /// `noEntityCollision(boat, box)` for a new boat (`BoatItem.use`). + pub(super) fn boat_entity_collision(&self, bb: Aabb) -> bool { + // EntityGetter.getEntityCollisions: the box grown by 1e-7. + let area = bb.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7)); + !self.boat_obstacles(u32::MAX, area).is_empty() + } + + /// The end of `AbstractBoat.tick` on the server for boat `i`: each + /// entity it touches gets in (a mob, while no player steers) or is + /// pushed apart from it, and `LivingEntity.pushEntities` of each mob and + /// player touching it pushes the two apart once more. Only the window's + /// own player is moved here: a server's players are pushed by their + /// clients, which tick the boats near them (`remote_pushes`). + pub(super) fn boat_contacts(&mut self, i: usize) { + let (id, bb, max) = { + let b = &self.boats[i]; + (b.id, b.bounds(), b.max_passengers()) + }; + let area = bb.inflate(Vec3::new( + f64::from(0.2_f32), + f64::from(-0.01_f32), + f64::from(0.2_f32), + )); + let mut count = self.boat_passengers(id); + // getControllingPassenger is a player: one rides it (players sit first). + let pick_up = self.boat_players(id) == 0; + // canAddPassenger, which startRiding asks after the checks below. + let room = !self.boats[i].under_water(); + // (mob, touched by the boat's sweep, its own pushEntities reaches the boat) + let teams = self.mob_teams(); + let mobs: Vec<(usize, bool, bool)> = (0..self.mobs.len()) + .filter_map(|j| { + let m = &self.mobs[j]; + if !pushable(m) || m.extra.mount.is_some() && self.mob_root_vehicle(j) == Some(id) { + return None; + } + let mb = m.bounds(); + let team = teams.of(Who::Mob(m.id)); + let touched = mb.intersects(area) && pushable_by(None, team, true); + // Bats push nothing (Bat.pushEntities). + let pushes = m.species() != Species::Bat + && mb.intersects(bb) + && pushable_by(team, None, true); + (touched || pushes).then_some((j, touched, pushes)) + }) + .collect(); + let player_team = teams.of(Who::Player); + let players: Vec<(Aabb, bool, bool, bool)> = self + .players_outside(id) + .into_iter() + .map(|(pb, own)| { + let team = if own { player_team } else { None }; + ( + pb, + own, + pb.intersects(area) && pushable_by(None, team, true), + pb.intersects(bb) && pushable_by(team, None, true), + ) + }) + .collect(); + drop(teams); + for (j, touched, pushes) in mobs { + if touched { + let m = &self.mobs[j]; + let boards = pick_up + && count < max + && m.extra.mount.is_none() + && m.width() < super::boats::WIDTH as f32 + && !self + .res + .mob_data() + .entity_has("minecraft:cannot_be_pushed_onto_boats", &m.kind.id); + if boards { + // startRiding fails quietly (no push) while the mob's + // boarding cooldown runs (Entity.canRide) or the boat + // is under water. + if room && m.extra.boarding_cooldown <= 0 { + let m = &mut self.mobs[j]; + m.extra.mount = Some(id); + m.extra.passenger = true; + m.ai.nav.stop(); + let mob = m.id; + count += 1; + // Mob.startRiding drops its lead. + self.break_leash(mob, true, false); + } + continue; + } + self.boat_push_mob(i, j, count); + } + if pushes { + self.boat_push_mob(i, j, count); + } + } + for (pb, own, touched, pushes) in players { + let Some(v) = push_impulse(self.boats[i].position, pb.center()) + .filter(|_| boat_pushes(bb, pb, false)) + else { + continue; + }; + for _ in 0..usize::from(touched) + usize::from(pushes) { + if count == 0 { + let b = &mut self.boats[i]; + b.velocity = b.velocity.subtract(v); + } + if own && let Some(p) = self.player.as_mut() { + p.velocity = p.velocity.add_vector(v); + } + } + } + for k in 0..self.boats.len() { + let ob = self.boats[k].bounds(); + if k == i || !ob.intersects(area) || !boat_pushes(bb, ob, true) { + continue; + } + let Some(v) = push_impulse(self.boats[i].position, self.boats[k].position) else { + continue; + }; + if count == 0 { + self.boats[i].velocity = self.boats[i].velocity.subtract(v); + } + if self.boat_passengers(self.boats[k].id) == 0 { + self.boats[k].velocity = self.boats[k].velocity.add_vector(v); + } + } + let guest_carts = self.guest_vehicles(); + for c in 0..self.carts.len() { + let cb = self.carts[c].bounds(); + if !cb.intersects(area) || !boat_pushes(bb, cb, false) { + continue; + } + let Some(v) = push_impulse(self.boats[i].position, self.carts[c].position) else { + continue; + }; + if count == 0 { + self.boats[i].velocity = self.boats[i].velocity.subtract(v); + } + let cid = self.carts[c].id; + let ridden = self.riding == Some(cid) + || guest_carts.contains(&cid) + || self.mobs.iter().any(|m| m.extra.mount == Some(cid)); + if !ridden { + self.carts[c].velocity = self.carts[c].velocity.add_vector(v); + } + } + } + /// `AbstractBoat.push(mob)` from boat `i`, which has `count` passengers. + fn boat_push_mob(&mut self, i: usize, j: usize, count: usize) { + let (b, m) = (&self.boats[i], &self.mobs[j]); + if !boat_pushes(b.bounds(), m.bounds(), false) { + return; + } + let Some(v) = push_impulse(b.position, m.position) else { + return; + }; + if count == 0 { + let b = &mut self.boats[i]; + b.velocity = b.velocity.subtract(v); + } + let m = &mut self.mobs[j]; + if moved_by_push(m) { + m.velocity = m.velocity.add_vector(v); + m.needs_sync = true; + } + } + + /// `positionRider` and `clampRotation` for the mobs in boats: each sits + /// in its seat facing the way the boat does, an animal in a full boat + /// sideways, its head kept within its reach of its body. + pub(super) fn seat_boat_mobs(&mut self) { + for i in 0..self.boats.len() { + let id = self.boats[i].id; + let mobs = self.boat_mobs(id); + if mobs.is_empty() { + continue; + } + let players = self.boat_players(id); + let count = players + mobs.len(); + let b = &self.boats[i]; + let full = count == b.max_passengers(); + let delta = b.delta_rotation; + let seats: Vec<_> = mobs + .iter() + .enumerate() + .map(|(n, &j)| { + let m = &self.mobs[j]; + let animal = is_animal(m.species()); + // Another player, on a server's client. + let offset = if &*m.kind.id == "minecraft:player" { + PLAYER_RIDING_OFFSET + } else { + riders::vehicle_attachment(m) + }; + let index = players + n; + // calculatePassengerBodyYRot. + let turn = match (animal && full, m.id.is_multiple_of(2)) { + (false, _) => 0.0, + (true, true) => 90.0, + (true, false) => 270.0, + }; + let turns = !self + .res + .mob_data() + .entity_has("minecraft:can_turn_in_boats", &m.kind.id); + ( + j, + b.seat(index, count, animal, offset, false), + b.seat(index, count, animal, offset, true), + turns.then_some((b.yaw + turn, b.previous_yaw + turn)), + ) + }) + .collect(); + for (j, at, previous, facing) in seats { + let m = &mut self.mobs[j]; + m.position = at; + m.previous = previous; + m.velocity = Vec3::ZERO; + m.fall_distance = 0.0; + m.on_ground = false; + m.extra.passenger = true; + m.ai.nav.stop(); + let Some((body, previous_body)) = facing else { + continue; + }; + m.head_yaw += delta; + m.body_yaw = body; + m.previous_body_yaw = previous_body; + m.yaw = body; + m.previous_yaw = previous_body; + // Mob.clampHeadRotationToBody. + let limit = m.kind.max_head_y_rot; + let d = wrap_degrees(body - m.head_yaw); + m.head_yaw += d - d.clamp(-limit, limit); + } + } + } + /// `ejectPassengers` for the mobs in boat `i`: each gets out where + /// `getDismountLocationForPassenger` puts it (beside the boat when it + /// broke: `LivingEntity.dismountVehicle`) and can't board for a while. + pub(super) fn eject_boat_mobs(&mut self, i: usize, broken: bool) { + let b = &self.boats[i]; + let (id, y) = (b.id, b.position.y); + for j in self.boat_mobs(id) { + let m = &self.mobs[j]; + let at = if broken { + Vec3::new(m.position.x, m.position.y.max(y), m.position.z) + } else { + self.boat_dismount_target(i, f64::from(m.width()), m.yaw) + }; + let m = &mut self.mobs[j]; + m.extra.mount = None; + m.extra.passenger = false; + m.extra.boarding_cooldown = BOARDING_COOLDOWN; + m.position = at; + m.previous = at; + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn push_is_capped_and_scaled() { + // One block apart on x: the full 0.05 along x. + let v = push_impulse(Vec3::ZERO, Vec3::new(1.0, 0.0, 0.0)).unwrap(); + assert!((v.x - f64::from(0.05_f32)).abs() < 1e-12 && v.z == 0.0); + // Almost on the same spot: no push. + assert!(push_impulse(Vec3::ZERO, Vec3::new(0.005, 0.0, 0.0)).is_none()); + } + + #[test] + fn boats_push_by_height() { + let boat = Aabb::new(Vec3::new(0.0, 64.0, 0.0), Vec3::new(1.0, 64.5625, 1.0)); + let at = |y: f64| Aabb::new(Vec3::new(0.0, y, 0.0), Vec3::new(1.0, y + 1.0, 1.0)); + assert!(boat_pushes(boat, at(64.0), false)); + assert!(!boat_pushes(boat, at(64.1), false)); + assert!(boat_pushes(boat, at(64.5), true)); + assert!(!boat_pushes(boat, at(64.5625), true)); + } +} diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs index bc9afd18b..df7158d9a 100644 --- a/crates/horizon-client/src/game/boats.rs +++ b/crates/horizon-client/src/game/boats.rs @@ -5,10 +5,10 @@ use super::{Game, Keys, entity_culling::at, view_vector}; use horizon_client::{ blocks::Fluid, - collisions::SceneCollisions, + collisions::{EntityCollisions, SceneCollisions}, items::ItemStack, mesher::Vertex, - mobs::{Part, anim::Poses}, + mobs::{Part, anim::Poses, riders}, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -54,10 +54,8 @@ pub(super) struct Boat { } /// `ChestBoat.CONTAINER_SIZE`. pub(super) const CHEST_SLOTS: usize = 27; -const WIDTH: f64 = 1.375; +pub(super) const WIDTH: f64 = 1.375; const HEIGHT: f64 = 0.5625; -/// Player.DEFAULT_VEHICLE_ATTACHMENT minus the boat's passenger attachment. -pub(super) const SEAT: f64 = 0.1875 - 0.6; impl Boat { pub fn new(id: u32, wood: Arc, position: Vec3, yaw: f32) -> Self { Self { @@ -98,6 +96,54 @@ impl Boat { Vec3::new(p.x + w, p.y + HEIGHT, p.z + w), ) } + /// `isUnderWater`; it stands in for `canAddPassenger`'s + /// `isEyeInFluid(WATER)` too. + pub fn under_water(&self) -> bool { + matches!(self.status, Status::UnderWater | Status::UnderFlowingWater) + } + /// `getMaxPassengers`: two, one beside a chest. + pub fn max_passengers(&self) -> usize { + if self.chest { 1 } else { 2 } + } + /// `rideHeight`: a third of a boat's height, 8/9 of a raft's. + fn ride_height(&self) -> f64 { + let height = HEIGHT as f32; + f64::from(if &*self.wood == "bamboo" { + height * 0.888_888_9 + } else { + height / 3.0 + }) + } + /// Where the passenger at `index` of `count` stands, at the boat's current + /// (or, with `previous`, last) place: `getPassengerAttachmentPoint` + /// turned with the boat, less the passenger's `rider_offset`. + pub fn seat( + &self, + index: usize, + count: usize, + animal: bool, + rider_offset: f64, + previous: bool, + ) -> Vec3 { + let mut z = if self.chest { 0.15f32 } else { 0.0 }; + if count > 1 { + z = if index == 0 { 0.2 } else { -0.6 }; + if animal { + z += 0.2; + } + } + let (at, yaw) = if previous { + (self.previous, self.previous_yaw) + } else { + (self.position, self.yaw) + }; + riders::seat( + [0.0, self.ride_height(), f64::from(z)], + rider_offset, + at, + yaw, + ) + } /// `getRowingTime`. pub fn rowing_time(&self, side: usize, a: f32) -> f32 { if self.paddling[side] { @@ -320,6 +366,7 @@ impl Game<'_> { let mut vspeed = -0.04; let mut buoyancy = 0.0; let inv_friction: f32; + let obstacles = self.boat_move_obstacles(&b); let mut scene = SceneCollisions { world: &self.world, binding: self.collision, @@ -401,6 +448,11 @@ impl Game<'_> { b.paddling = [right && !left || up, left && !right || up]; } // Entity.move: collisions zero the blocked components. + let mut scene = EntityCollisions { + blocks: scene, + entities: &obstacles, + border: None, + }; if let Ok(moved) = scene.resolve(b.bounds(), b.velocity, 0.0, b.on_ground) { b.position = Vec3::new( b.position.x + moved.x, @@ -477,6 +529,19 @@ impl Game<'_> { i += 1; } } + // The rest of AbstractBoat.tick on the server, for every boat: the + // passengers of one under water too long get out, and it picks up or + // pushes what it touches. + for i in 0..self.boats.len() { + let p = self.boats[i].position; + if !ticking(p.x.floor() as i32, p.z.floor() as i32) { + continue; + } + if self.boats[i].out_of_control >= 60.0 { + self.eject_boat_mobs(i, false); + } + self.boat_contacts(i); + } } /// `LavaFluid.entityInside` (`lavaHurt`) from the two /// `applyEffectsFromBlocks` calls in `AbstractBoat.tick`: twice 40 @@ -540,13 +605,14 @@ impl Game<'_> { self.yaw += b.delta_rotation; let delta = (self.yaw - b.yaw + 180.0).rem_euclid(360.0) - 180.0; self.yaw += delta.clamp(-105.0, 105.0) - delta; + self.boats[i] = b; + let seat = self.player_boat_seat(i); if let Some(p) = self.player.as_mut() { self.previous_position = p.position; - p.position = Vec3::new(b.position.x, b.position.y + SEAT, b.position.z); + p.position = seat; p.velocity = Vec3::ZERO; p.fall_distance = 0.0; } - self.boats[i] = b; if self.boat_lava_tick(i) { self.riding = None; } @@ -556,9 +622,18 @@ impl Game<'_> { /// floor there, else on top of the boat. pub(super) fn dismount(&mut self, i: usize) { self.riding = None; + let target = self.boat_dismount_target(i, 0.6, self.yaw); + if let Some(p) = self.player.as_mut() { + p.position = target; + p.velocity = Vec3::ZERO; + } + } + /// `getDismountLocationForPassenger` for a passenger `width` wide + /// facing `yaw`. + pub(super) fn boat_dismount_target(&self, i: usize, width: f64, yaw: f32) -> Vec3 { let b = &self.boats[i]; - let r = self.yaw.to_radians(); - let distance = (WIDTH * std::f64::consts::SQRT_2 + 0.6 + 1.0e-5) / 2.0; + let r = yaw.to_radians(); + let distance = (WIDTH * std::f64::consts::SQRT_2 + width + 1.0e-5) / 2.0; let (s, c) = (-(r.sin()) as f64, r.cos() as f64); let m = s.abs().max(c.abs()); let (x, z) = ( @@ -569,17 +644,13 @@ impl Game<'_> { let (bx, by, bz) = (x.floor() as i32, top.floor() as i32, z.floor() as i32); let below = self.res.facts().get(self.world.block(bx, by - 1, bz)); let here = self.res.facts().get(self.world.block(bx, by, bz)); - let target = if below.fluid != Fluid::Water + if below.fluid != Fluid::Water && !here.full_collision && (below.full_collision || below.legacy_solid) { Vec3::new(x, f64::from(by), z) } else { Vec3::new(b.position.x, top, b.position.z) - }; - if let Some(p) = self.player.as_mut() { - p.position = target; - p.velocity = Vec3::ZERO; } } /// `BoatItem.use`: aim at a block or the water surface. @@ -656,7 +727,7 @@ impl Game<'_> { binding: self.collision, subject: None, }; - if !scene.unobstructed(inner).unwrap_or(false) { + if !scene.unobstructed(inner).unwrap_or(false) || self.boat_entity_collision(bb) { return false; } self.next_entity += 1; @@ -711,7 +782,7 @@ impl Game<'_> { return false; } // ChestBoat.interact: sneaking (or a full seat) opens the chest. - if self.boats[i].chest && (sneaking || self.riding.is_some()) { + if self.boats[i].chest && (sneaking || self.riding.is_some() || !self.boat_has_room(i)) { let b = &self.boats[i]; let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, b.id as i32); self.world.block_entities.insert( @@ -728,6 +799,7 @@ impl Game<'_> { || self.boats[i].out_of_control >= 60.0 || self.riding.is_some() || self.ridden_by_guest(self.boats[i].id) + || !self.boat_has_room(i) { return false; } @@ -758,6 +830,7 @@ impl Game<'_> { b.damage += damage * 10.0; let destroyed = creative || b.damage > 40.0; if destroyed { + self.eject_boat_mobs(i, true); let b = self.boats.remove(i); let at = [b.position.x, b.position.y, b.position.z]; if !creative && self.ui.rules.bool("entity_drops") { diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index a94f3f01b..e0ad706de 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -82,8 +82,10 @@ impl Game<'_> { } return true; } - // Screens with a text box take every key press first - // (EditBox.keyPressed); releases still reach KeyboardHandler. + // Vanilla types into a focused EditBox through charTyped, which no + // debug key can swallow. Here the character comes with the key press, + // so a screen with a focused text box takes every press first; + // releases still reach KeyboardHandler. let typing = matches!( self.screen, Screen::Chat | Screen::Options | Screen::WorldOptions | Screen::CommandBlock @@ -91,7 +93,11 @@ impl Game<'_> { || self.book.is_some() || (self.screen == Screen::Creative && self.creative_screen.tab().search) || self.recipe_search_focused() - || self.station_typing(); + || self.station_typing() + || self + .title + .as_mut() + .is_some_and(|t| t.focused_field().is_some()); // Container screens use Escape, the inventory key and the hotbar and // drop keys first; any other screen closes on Escape. let screen_key = match self.screen { diff --git a/crates/horizon-client/src/game/game_rules_screen.rs b/crates/horizon-client/src/game/game_rules_screen.rs index d99a7ab5b..d925c5081 100644 --- a/crates/horizon-client/src/game/game_rules_screen.rs +++ b/crates/horizon-client/src/game/game_rules_screen.rs @@ -3,6 +3,7 @@ //! box each, and Done sending the changed ones (ServerboundSetGameRulePacket). //! Leaving with changes asks first (ConfirmScreen). use horizon_client::{ + confirm_screen::Confirm, font::Font, gamerules::{self, GameRules, RULES, Rule, Value}, hud::{HudAtlas, HudBatch}, @@ -66,9 +67,6 @@ fn parse(r: &Rule, s: &str) -> Option { .flatten() .filter(|v| (r.min..=r.max).contains(v)) } -fn widest(font: &Font, lines: &[Text]) -> f32 { - lines.iter().map(|l| font.width_text(l)).fold(0.0, f32::max) -} fn lines(font: &Font, t: &Text, width: f32) -> Vec { font.split_lines(t, width) .into_iter() @@ -95,38 +93,11 @@ fn yellow() -> u32 { named_color("yellow").unwrap_or(0xFFFF55) } -/// ConfirmScreen: the title, the message (at most `width - 50` wide), and -/// Yes / No 16 below, 4 apart, all centred. -struct Confirm { - lines: Vec<(Text, f32, f32)>, - buttons: [(f32, f32); 2], -} -impl Confirm { - fn new(font: &Font, (w, h): (f32, f32)) -> Self { - let title = Text::translate("editGamerule.inGame.discardChanges.title", &[]); - let message = Text::translate("editGamerule.inGame.discardChanges.message", &[]); - let message: Vec = lines(font, &message, w - 50.0) - .into_iter() - .take(15) - .collect(); - let (tw, mw) = (font.width_text(&title), widest(font, &message)); - let mh = 9.0 * message.len() as f32; - let col = tw.max(mw).max(304.0); - let total = 9.0 + 8.0 + mh + 8.0 + 36.0; - let (lx, ly) = (((w - col) / 2.0).trunc(), ((h - total) / 2.0).trunc()); - let cell = |cw: f32| lx + ((col - cw) / 2.0).trunc(); - let mid = cell(mw) + (mw / 2.0).trunc(); - let mut out = vec![(title, cell(tw), ly)]; - for (i, line) in message.into_iter().enumerate() { - let x = mid - (font.width_text(&line) / 2.0).trunc(); - out.push((line, x, ly + 17.0 + 9.0 * i as f32)); - } - let (bx, by) = (cell(304.0), ly + 9.0 + 8.0 + mh + 8.0 + 16.0); - Self { - lines: out, - buttons: [(bx, by), (bx + 154.0, by)], - } - } +/// ConfirmScreen "Game Rule Changes". +fn confirm(font: &Font, size: (f32, f32)) -> Confirm { + let title = Text::translate("editGamerule.inGame.discardChanges.title", &[]); + let message = Text::translate("editGamerule.inGame.discardChanges.message", &[]); + Confirm::new(font, size, &title, &message) } impl RulesScreen { @@ -301,13 +272,10 @@ impl RulesScreen { let (w, h) = size; let on = |x: f32, y: f32, bw: f32, bh: f32| ui::hovered(cursor, x, y, bw, bh); if self.confirm { - let c = Confirm::new(&atlas.font, size); - let [(yx, yy), (nx, ny)] = c.buttons; - if on(yx, yy, 150.0, 20.0) { - return Some(Exit::Discard); - } - if on(nx, ny, 150.0, 20.0) { - self.confirm = false; + match confirm(&atlas.font, size).answer_at(cursor) { + Some(true) => return Some(Exit::Discard), + Some(false) => self.confirm = false, + None => {} } return None; } @@ -367,7 +335,7 @@ impl RulesScreen { let (w, h) = size; let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0); if self.confirm { - return Confirm::new(&atlas.font, size).buttons.into_iter().any(on); + return confirm(&atlas.font, size).answer_at(cursor).is_some(); } let [done, cancel] = footer(w, h); if (on(done) && !self.invalid()) || on(cancel) { @@ -384,15 +352,11 @@ impl RulesScreen { let (w, h) = (batch.width, batch.height); ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true); if self.confirm { - let c = Confirm::new(&atlas.font, (w, h)); - for (line, x, y) in &c.lines { - batch.text_styled(atlas, line, *x, *y, u32::MAX, true); - } - for ((bx, by), key) in c.buttons.into_iter().zip(["gui.yes", "gui.no"]) { - let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); - let label = Text::translate(key, &[]); - ui::button(batch, atlas, bx, by, 150.0, 20.0, &label, true, hover); - } + let labels = [ + Text::translate("gui.yes", &[]), + Text::translate("gui.no", &[]), + ]; + confirm(&atlas.font, (w, h)).draw(batch, atlas, cursor, [&labels[0], &labels[1]]); return; } let rows = self.rows(); diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 8bf72abee..8460f54e6 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -834,8 +834,11 @@ impl Game<'_> { self.lan_object_states(host_entity, hub, out); } - /// Run the hub for this tick and apply what the guests did. - pub(super) fn tick_lan(&mut self) { + /// Run the hub for this tick and apply what the guests did. While the + /// single player game is `paused` only the connections run + /// (`IntegratedServer.tickPaused`): `ServerGamePacketListenerImpl.tick` + /// skips `tickPlayer`, so no player's air, hunger or damage moves on. + pub(super) fn tick_lan(&mut self, paused: bool) { let Some(mut host) = self.lan.take() else { return; }; @@ -1000,7 +1003,9 @@ impl Game<'_> { host.states = states; } self.lan_flush_effects(&mut host); - self.tick_guests(&mut host); + if !paused { + self.tick_guests(&mut host); + } self.lan_living_flags(&mut host); self.tick_server_travel(&mut host); self.lan_swings(&mut host); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 5bee2af96..58ed97c2f 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1277,10 +1277,24 @@ impl Game<'_> { id: i32, location: Option<[f64; 3]>, ) -> Option<([f64; 3], [f64; 3])> { + let eye = { + let g = &host.hub.guests[gi]; + [g.position[0], g.position[1] + g.eye_height(), g.position[2]] + }; let object = || { let (lo, hi, origin) = self.object_target(id)?; let middle = [0, 1, 2].map(|k| (lo[k] + hi[k]) / 2.0); let Some(l) = location else { + // A boat's mobs sit over its middle: aim low at its near + // side, so the ray meets the boat before them (the server + // attacks the entity it is sent). + let carries = u32::try_from(id).is_ok_and(|v| { + self.boats.iter().any(|b| b.id == v) && !self.boat_mobs(v).is_empty() + }); + if carries { + let near = |k: usize| eye[k].clamp(lo[k] + 0.01, hi[k] - 0.01); + return Some([near(0), lo[1] + 0.05, near(2)]); + } return Some(middle); }; let point = [0, 1, 2].map(|k| origin[k] + l[k]); @@ -1311,7 +1325,6 @@ impl Game<'_> { } }; let g = &mut host.hub.guests[gi]; - let eye = [g.position[0], g.position[1] + g.eye_height(), g.position[2]]; let d = [centre[0] - eye[0], centre[1] - eye[1], centre[2] - eye[2]]; let horizontal = (d[0] * d[0] + d[2] * d[2]).sqrt(); g.yaw = (-d[0].atan2(d[2])).to_degrees() as f32; diff --git a/crates/horizon-client/src/game/lan_vehicles.rs b/crates/horizon-client/src/game/lan_vehicles.rs index 71e9936a5..f16a1e37d 100644 --- a/crates/horizon-client/src/game/lan_vehicles.rs +++ b/crates/horizon-client/src/game/lan_vehicles.rs @@ -9,7 +9,7 @@ //! here with the rider's input (`ServerPlayer.getLastClientMoveIntent`). //! Sneaking gets out (`Player.rideTick`: `wantsToStopRiding`), and the client //! is teleported where the player lands (`ServerPlayer.dismountTo`). -use super::{Game, Keys, boats::SEAT, lan::LanHost}; +use super::{Game, Keys, lan::LanHost, minecarts::SEAT}; use horizon_client::collisions::SceneCollisions; use horizon_core::geometry::{Aabb, Vec3}; use horizon_protocol::{ @@ -120,8 +120,8 @@ impl Game<'_> { game.dismount(i); return None; } - let p = game.boats[i].position; - return Some([p.x, p.y + SEAT, p.z]); + let p = game.player_boat_seat(i); + return Some([p.x, p.y, p.z]); } // The minecart moves with the rider's input, and lets it out when // it sneaks or the cart breaks. An animal takes the rider's input @@ -161,19 +161,19 @@ impl Game<'_> { let at = self .boats .iter() - .find(|b| b.id == vehicle) - .map(|b| b.position) + .position(|b| b.id == vehicle) + .map(|i| (self.boats[i].position, self.player_boat_seat(i))) .or_else(|| { self.carts .iter() .find(|c| c.id == vehicle) - .map(|c| c.position) + .map(|c| (c.position, c.position.add_vector(Vec3::new(0.0, SEAT, 0.0)))) }); - if let Some(p) = at { + if let Some((p, seat)) = at { let g = &mut host.hub.guests[gi]; g.vehicle_good = Some([p.x, p.y, p.z]); g.previous_position = g.position; - g.position = [p.x, p.y + SEAT, p.z]; + g.position = [seat.x, seat.y, seat.z]; g.on_ground = false; return; } @@ -289,10 +289,11 @@ impl Game<'_> { b.previous_yaw = b.yaw; b.yaw = p.yaw; b.on_ground = p.on_ground; + let seat = self.player_boat_seat(i); let g = &mut host.hub.guests[gi]; g.vehicle_good = Some([target.x, target.y, target.z]); g.previous_position = g.position; - g.position = [target.x, target.y + SEAT, target.z]; + g.position = [seat.x, seat.y, seat.z]; } /// `handlePaddleBoat`: the paddles of the boat the player drives. diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 895cda08c..114ee928f 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -296,7 +296,7 @@ impl Game<'_> { self.update_dedicated_streaming(); self.update_world(); result = if paused { - self.tick_lan(); + self.tick_lan(true); Ok(()) } else if k == 0 { self.tick() diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 0b58e4f88..6b8b51dde 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -95,7 +95,7 @@ fn display_offset(kind: CartKind) -> f64 { if kind == CartKind::Hopper { 1.0 } else { 6.0 } } /// The minecart's passenger attachment minus Player.DEFAULT_VEHICLE_ATTACHMENT. -const SEAT: f64 = 0.1875 - 0.6; +pub(super) const SEAT: f64 = 0.1875 - 0.6; /// The placeholder container key under which an open cart's items live. pub(super) const CART_KEY_Y: i32 = -100_000; diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ae2de00e6..7629a5d25 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -4,7 +4,7 @@ use super::Game; use horizon_client::{ hud::HudAtlas, lang, - pack_screen::{Compat, PackInfo, Source as PackSource}, + pack_screen::{self, Compat, PackInfo, Source as PackSource}, packs::{self, Pack, Position}, text::{Style, Text}, }; @@ -34,10 +34,16 @@ pub fn open_folder(dir: &Path) { log::warn!("Horizon: could not open {}: {e}", dir.display()); } } -/// The resource root to load from, given the vanilla root and the selection. -pub fn startup_root(vanilla: &Path, selected: &[String]) -> std::io::Result { +/// The resource root to load from, given the vanilla root, the selection and +/// a server's packs, which go on top (`Pack.Position.TOP`, fixed). +pub fn startup_root( + vanilla: &Path, + selected: &[String], + server: &[Pack], +) -> std::io::Result { let all = packs::discover(vanilla, &packs_dir()); - let enabled = packs::enabled(&all, selected); + let mut enabled = packs::enabled(&all, selected); + enabled.extend_from_slice(server); packs::resource_root(vanilla, &enabled, &cache_dir()) } fn info(p: &Pack) -> PackInfo { @@ -53,14 +59,15 @@ fn info(p: &Pack) -> PackInfo { PackSource::Default }, compat: p.compatibility, - icon: p.icon, + icon: p.icon_png().as_deref().and_then(pack_screen::load_icon), required: false, position: Position::Top, fixed: false, } } -/// The vanilla pack: required, at the bottom (`BuiltInPackSource`). -fn vanilla_info() -> PackInfo { +/// The vanilla pack: required, at the bottom (`BuiltInPackSource`), with the +/// client JAR's `pack.png` that the prepared resources hold. +fn vanilla_info(vanilla: &Path) -> PackInfo { PackInfo { id: "vanilla".into(), title: Text::translate("resourcePack.vanilla.name", &[]), @@ -68,7 +75,10 @@ fn vanilla_info() -> PackInfo { description_style: Style::default(), source: PackSource::BuiltIn, compat: Compat::Compatible, - icon: true, + icon: std::fs::read(vanilla.join("pack.png")) + .ok() + .as_deref() + .and_then(pack_screen::load_icon), required: true, position: Position::Bottom, fixed: false, @@ -80,7 +90,7 @@ pub(super) fn pack_infos(vanilla: &Path) -> Vec { .iter() .map(info) .collect(); - infos.push(vanilla_info()); + infos.push(vanilla_info(vanilla)); infos } impl Game<'_> { @@ -113,14 +123,7 @@ impl Game<'_> { self.pending_pack_reload = true; return; } - let vanilla = self.vanilla_root(); - if self.ui.vanilla_root.as_os_str().is_empty() { - self.ui.vanilla_root = vanilla.clone(); - } - let result = startup_root(&vanilla, &self.settings.resource_packs) - .map_err(Into::into) - .and_then(|root| self.reload_resources(&root)); - if let Err(e) = result { + if let Err(e) = self.reload_selected_packs() { log::warn!("Horizon: resource reload failed: {e}"); if self.screen != super::Screen::Options { self.open_options_at( @@ -131,6 +134,16 @@ impl Game<'_> { self.ui.options.resource_error = Some(e.to_string()); } } + /// Reload from the selected packs and the server's. + pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> { + let vanilla = self.vanilla_root(); + if self.ui.vanilla_root.as_os_str().is_empty() { + self.ui.vanilla_root = vanilla.clone(); + } + let server = &self.server_packs.active; + let root = startup_root(&vanilla, &self.settings.resource_packs, server)?; + self.reload_resources(&root) + } fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> { let render = std::sync::Arc::new(self.pack.assets.reload(root)?); let mut atlas = HudAtlas::build_over(root, &self.vanilla_root())?; diff --git a/crates/horizon-client/src/game/passengers.rs b/crates/horizon-client/src/game/passengers.rs index 4e6ba339d..b20c1560b 100644 --- a/crates/horizon-client/src/game/passengers.rs +++ b/crates/horizon-client/src/game/passengers.rs @@ -38,9 +38,16 @@ impl Game<'_> { m.extra.rider = Some(rider); } } - /// Riders sit on their vehicles (`Entity.positionRider`), and let go when - /// the vehicle dies or is gone. + /// Riders sit on their vehicles (`Entity.positionRider`), mobs or boats, + /// and let go when the vehicle dies or is gone. pub(super) fn sync_riders(&mut self) { + // Entity.baseTick. + for m in &mut self.mobs { + if m.extra.boarding_cooldown > 0 { + m.extra.boarding_cooldown -= 1; + } + } + let boats: std::collections::HashSet = self.boats.iter().map(|b| b.id).collect(); let index: HashMap = self .mobs .iter() @@ -54,9 +61,10 @@ impl Game<'_> { }; let valid = self.mobs[i].alive() && !self.mobs[i].removed - && index - .get(&v) - .is_some_and(|&j| self.mobs[j].alive() && !self.mobs[j].removed); + && (boats.contains(&v) + || index + .get(&v) + .is_some_and(|&j| self.mobs[j].alive() && !self.mobs[j].removed)); if valid { riding.insert(v, self.mobs[i].id); } else { @@ -68,6 +76,19 @@ impl Game<'_> { for m in &mut self.mobs { m.extra.rider = riding.get(&m.id).copied(); } + self.position_riders(); + } + /// `Entity.positionRider` for every mob passenger: in its boat, then on + /// its mob. A server's client places them itself too, as the server sends + /// no passenger's position. + pub(super) fn position_riders(&mut self) { + self.seat_boat_mobs(); + let index: HashMap = self + .mobs + .iter() + .enumerate() + .map(|(i, m)| (m.id, i)) + .collect(); // Riders of riders settle over a few passes. for _ in 0..3 { for i in 0..self.mobs.len() { diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs index eb30ab5ed..ad9d7fe7e 100644 --- a/crates/horizon-client/src/game/persist.rs +++ b/crates/horizon-client/src/game/persist.rs @@ -243,6 +243,8 @@ impl Game<'_> { .is_some_and(|(wood, chest)| self.boat_models.has(wood, chest)) => { if let Some((position, velocity, yaw)) = entity_nbt::boat_from_nbt(&tag) { + let mut tag = tag; + let riders = self.take_mob_passengers(&mut tag); self.next_entity += 1; let id = self.next_entity; let (wood, chest) = @@ -263,6 +265,9 @@ impl Game<'_> { b.velocity = velocity; self.remember(id, uuid, tag); self.boats.push(b); + for rider in riders { + self.load_mob(rider, Some(id)); + } } } k if super::minecarts::CartKind::from_id(k).is_some() => { @@ -341,25 +346,10 @@ impl Game<'_> { // Structure entities placed with finalizeEntities. let mut tag = tag; let mut finalize = false; - let mut riders = Vec::new(); - let mut unknown = Vec::new(); if let Tag::Compound(c) = &mut tag { finalize = c.remove(&"horizon:finalize".into()).is_some(); - if let Some(Tag::List(list)) = c.remove(&"Passengers".into()) { - for p in list { - let known = - entity_nbt::kind(&p).is_some_and(|k| self.res.mob_types().contains_key(&k)); - if known { - riders.push(p); - } else { - unknown.push(p); - } - } - } - if !unknown.is_empty() { - c.insert("Passengers".into(), Tag::List(unknown)); - } } + let riders = self.take_mob_passengers(&mut tag); let mut m = entity_nbt::mob_from_nbt(&tag, self.res.mob_types(), self.next_entity)?; m.extra.mount = mount; m.extra.passenger = mount.is_some(); @@ -401,6 +391,49 @@ impl Game<'_> { } Some(id) } + /// The mobs under an entity's `Passengers`, taken out of it; the + /// passengers Horizon doesn't simulate stay. + fn take_mob_passengers(&self, tag: &mut Tag) -> Vec { + let mut riders = Vec::new(); + if let Tag::Compound(c) = tag + && let Some(Tag::List(list)) = c.remove(&"Passengers".into()) + { + let mut unknown = Vec::new(); + for p in list { + let known = + entity_nbt::kind(&p).is_some_and(|k| self.res.mob_types().contains_key(&k)); + if known { + riders.push(p); + } else { + unknown.push(p); + } + } + if !unknown.is_empty() { + c.insert("Passengers".into(), Tag::List(unknown)); + } + } + riders + } + /// The mobs riding entity `id` under `tag`'s `Passengers`, after the + /// passengers it kept from loading. + fn put_mob_passengers(&mut self, tag: &mut Tag, id: u32) { + let riders: Vec = (0..self.mobs.len()) + .filter(|&j| self.mobs[j].extra.mount == Some(id) && self.mobs[j].alive()) + .collect(); + let riders: Vec = riders.into_iter().map(|j| self.mob_tree_nbt(j)).collect(); + if let Tag::Compound(c) = tag { + let mut list = match c.get(&"Passengers".into()) { + Some(Tag::List(l)) => l.clone(), + _ => Vec::new(), + }; + list.extend(riders); + if list.is_empty() { + c.remove(&"Passengers".into()); + } else { + c.insert("Passengers".into(), Tag::List(list)); + } + } + } /// An entity of a type Horizon does not simulate, kept as its compound. fn load_other(&mut self, tag: Tag, kind: &str) -> Option { let position = entity_nbt::position(&tag)?; @@ -476,22 +509,7 @@ impl Game<'_> { let uuid = self.uuid_for(id); let mut tag = entity_nbt::mob_to_nbt(&self.mobs[i], uuid, self.persist.raw.get(&id)); self.write_leash(&mut tag, i); - let riders: Vec = (0..self.mobs.len()) - .filter(|&j| self.mobs[j].extra.mount == Some(id) && self.mobs[j].alive()) - .collect(); - let riders: Vec = riders.into_iter().map(|j| self.mob_tree_nbt(j)).collect(); - if let Tag::Compound(c) = &mut tag { - let mut list = match c.get(&"Passengers".into()) { - Some(Tag::List(l)) => l.clone(), - _ => Vec::new(), - }; - list.extend(riders); - if list.is_empty() { - c.remove(&"Passengers".into()); - } else { - c.insert("Passengers".into(), Tag::List(list)); - } - } + self.put_mob_passengers(&mut tag, id); tag } /// Forget an entity that left the world (its UUID and loaded compound). @@ -569,10 +587,15 @@ impl Game<'_> { let mut out: HashMap<(i32, i32), Vec> = keys.iter().map(|k| (*k, Vec::new())).collect(); let player_uuid = self.level.player_uuid; - // A rider is saved inside its root vehicle, in the root's chunk. + // A rider is saved inside its root vehicle, in the root's chunk; a + // boat's passengers inside the boat. let mobs: Vec = (0..self.mobs.len()) .filter(|&i| { self.mob_root(i) == i + && self.mobs[i] + .extra + .mount + .is_none_or(|v| self.boats.iter().all(|b| b.id != v)) && keys.contains(&chunk_of(self.mobs[i].position)) && self.mobs[i].alive() }) @@ -650,25 +673,29 @@ impl Game<'_> { .push(with_raw(tag, raw.as_ref())); } } - for b in &self.boats { - if keys.contains(&chunk_of(b.position)) { - let uuid = self - .persist - .uuids - .get(&b.id) - .copied() - .unwrap_or_else(random_uuid); - let tag = entity_nbt::boat_to_nbt( - &b.entity_type(), - b.position, - b.velocity, - b.yaw, - uuid, - self.persist.raw.get(&b.id), - b.chest.then_some(&b.items[..]), - ); - out.entry(chunk_of(b.position)).or_default().push(tag); - } + let boats: Vec = (0..self.boats.len()) + .filter(|&i| keys.contains(&chunk_of(self.boats[i].position))) + .collect(); + for i in boats { + let b = &self.boats[i]; + let (id, at) = (b.id, b.position); + let uuid = self + .persist + .uuids + .get(&id) + .copied() + .unwrap_or_else(random_uuid); + let mut tag = entity_nbt::boat_to_nbt( + &b.entity_type(), + b.position, + b.velocity, + b.yaw, + uuid, + self.persist.raw.get(&id), + b.chest.then_some(&b.items[..]), + ); + self.put_mob_passengers(&mut tag, id); + out.entry(chunk_of(at)).or_default().push(tag); } if let Some(d) = &self.dragon && keys.contains(&chunk_of(d.position)) @@ -833,9 +860,16 @@ impl Game<'_> { } keep }); - // Riders leave with their root vehicle. + // Riders leave with their root vehicle, a boat's with the boat. let leaving: HashSet = (0..self.mobs.len()) - .filter(|&i| gone(self.mobs[self.mob_root(i)].position)) + .filter(|&i| { + let r = self.mob_root(i); + match self.mobs[r].extra.mount { + Some(v) if removed.contains(&v) => true, + Some(v) if self.boats.iter().any(|b| b.id == v) => false, + _ => gone(self.mobs[r].position), + } + }) .map(|i| self.mobs[i].id) .collect(); self.mobs.retain(|m| { diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index da0def0fb..23135f16f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -140,9 +140,13 @@ pub(super) struct Remote { stepped: HashMap, /// `LivingEntity.lerpHeadTo`: the head yaw and the ticks left to reach it. head_lerps: HashMap, - /// Item entities waiting for their item data. - pending_items: HashMap, + /// Item entities waiting for their item data: where they are and their + /// motion. + pending_items: HashMap, health: (f32, i32, f32), + /// `LocalPlayer.flashOnSetHealth`: set by the first health the server + /// sends; from then on a drop starts the hurt animation. + flash_on_set_health: bool, game_mode: i32, pub chat: Vec<(String, Instant)>, /// Lines received since joining, for the control socket's events. @@ -305,6 +309,16 @@ impl Game<'_> { // A signed-in account always plays under its own name. let auth = horizon_client::auth::current(); let name = auth.as_ref().map_or(name, |a| a.name.as_str()); + let user = auth.as_ref().map_or_else( + || { + ( + name.to_owned(), + horizon_protocol::crypto::offline_uuid(name), + ) + }, + |a| (a.name.clone(), a.uuid), + ); + self.server_packs_connect(local.is_none().then_some(address), user); let session = match local { Some(pipe) => Session::connect_local(pipe, name, view, lang.clone()), None => { @@ -401,6 +415,7 @@ impl Game<'_> { head_lerps: HashMap::new(), pending_items: HashMap::new(), health: (20.0, 20, 5.0), + flash_on_set_health: false, game_mode: 0, chat: Vec::new(), chat_received: 0, @@ -453,6 +468,7 @@ impl Game<'_> { if let Some(mut r) = self.remote.take() { r.session.disconnect(); } + self.server_packs_disconnect(); // Single player's server thread saves the world before the title shows. let single_player = match self.integrated.take() { Some(server) => { @@ -827,6 +843,8 @@ impl Game<'_> { } } Event::Reconfigured(registries) => self.set_registries(registries), + Event::PackPush(p) => self.handle_pack_push(p), + Event::PackPop(id) => self.handle_pack_pop(id), Event::DecodeError(e) => { if let Some(r) = self.remote.as_mut() { r.decode_errors += 1; @@ -1369,7 +1387,7 @@ impl Game<'_> { } if let Some(r) = self.remote.as_mut() { if kind == "minecraft:item" { - r.pending_items.insert(id, position); + r.pending_items.insert(id, (position, Vec3::ZERO)); } r.entities.insert( id, @@ -1448,6 +1466,23 @@ impl Game<'_> { m.on_ground = on_ground; return; } + if let Some(p) = r.pending_items.get_mut(&id) { + p.0 = position; + } + // ItemEntity and FallingBlockEntity keep Entity's NO_OP + // InterpolationHandler: moveOrInterpolateTo puts them there at + // once, and their own tick moves them on between the server's + // updates (`tick_remote_entities`). + let at = Vec3::new(position[0], position[1], position[2]); + if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) { + d.position = at; + d.on_ground = on_ground; + return; + } + if let Some(f) = self.falling.iter_mut().find(|f| f.id == id as u32) { + f.position = at; + return; + } // AbstractInterpolationHandler.interpolateTo: without a rotation, // the one it was heading for. let rotation = rotation.or_else(|| r.lerps.get(&id).and_then(|l| l.rotation)); @@ -1459,9 +1494,6 @@ impl Game<'_> { steps: 3, }, ); - if let Some(p) = r.pending_items.get_mut(&id) { - *p = position; - } } self.turn_remote_object(id, rotation.map(|(yaw, _)| yaw), on_ground); self.turn_remote_projectile(id, rotation); @@ -1794,6 +1826,8 @@ impl Game<'_> { } } self.spawn_entity(p.id, &kind, p.position, rotation); + // Entity.recreateFromPacket: setDeltaMovement(packet.getMovement()). + self.remote_motion(p.id, p.velocity); if !self.spawn_remote_object(p.id, &kind, p.position, rotation[0], p.data) { self.spawn_remote_projectile( p.id, @@ -2112,17 +2146,29 @@ impl Game<'_> { pl.velocity = Vec3::new(p.velocity[0], p.velocity[1], p.velocity[2]); } } + // The same packet for another entity: Entity.lerpMotion. + C::SetEntityMotion(p) => self.remote_motion(p.id, p.velocity), // ClientPacketListener.handleDamageEvent: LivingEntity.handleDamageEvent // jolts the walk animation and restarts the hurt flash. Its hurt // sound comes as a sound from Horizon's host, which plays it itself. + // This player's own hurt tilt and flash come from the server too + // (sent to the player itself): its own moves never hurt it. C::DamageEvent(p) => { - if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { + if let Some(pl) = self.player.as_mut() { + pl.health.animate_hurt(); + } + } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { m.limb_speed = 1.5; m.hurt_time = 10; } } C::HurtAnimation(p) => { - if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { + if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) { + if let Some(pl) = self.player.as_mut() { + pl.health.animate_hurt(); + } + } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) { m.hurt_time = 10; } } @@ -2188,9 +2234,14 @@ impl Game<'_> { self.remote_world_options_difficulty(self.ui.difficulty, p.locked); } C::GameRuleValues(p) => self.remote_world_options_rules(p.entries), + // ClientPacketListener.handleSetHealth: LocalPlayer.hurtTo. C::SetHealth(p) => { - if let Some(r) = self.remote.as_mut() { + let flash = self.remote.as_mut().is_some_and(|r| { r.health = (p.health, p.food, p.saturation); + std::mem::replace(&mut r.flash_on_set_health, true) + }); + if flash && let Some(pl) = self.player.as_mut() { + pl.health.flash_health_change(p.health); } self.apply_remote_health(); if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { @@ -2920,7 +2971,9 @@ impl Game<'_> { item.stack = stack; return; } - let Some(p) = position else { return }; + let Some((p, velocity)) = position else { + return; + }; let at = Vec3::new(p[0], p[1], p[2]); let bob_offset = self.world.random.next_float() * std::f32::consts::PI * 2.0; self.dropped.push(ItemEntity { @@ -2931,7 +2984,7 @@ impl Game<'_> { stack, position: at, previous: at, - velocity: Vec3::ZERO, + velocity, on_ground: false, age: 0, pickup_delay: 0, @@ -2939,6 +2992,23 @@ impl Game<'_> { ticks: 0, }); } + /// `Entity.lerpMotion` (and `recreateFromPacket`'s motion) for the + /// entities whose own tick moves them on a client: dropped items and + /// falling blocks. + fn remote_motion(&mut self, id: i32, velocity: [f64; 3]) { + let v = Vec3::new(velocity[0], velocity[1], velocity[2]); + if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) { + d.velocity = v; + } else if let Some(f) = self.falling.iter_mut().find(|f| f.id == id as u32) { + f.velocity = v; + } else if let Some(p) = self + .remote + .as_mut() + .and_then(|r| r.pending_items.get_mut(&id)) + { + p.1 = v; + } + } fn apply_remote_health(&mut self) { let Some((health, food, saturation)) = self.remote.as_ref().map(|r| r.health) else { return; @@ -3136,6 +3206,9 @@ impl Game<'_> { | u8::from(keys.sprint) << 6; // A passenger moves with its vehicle (Entity.rideTick), not by itself. let riding = self.screen != Screen::Dead && self.remote_ride(keys); + // The server sends no passenger's position: they sit where their + // vehicles are now. + self.position_riders(); let Some(player) = self.player.as_mut() else { return Ok(()); }; @@ -3163,6 +3236,7 @@ impl Game<'_> { ); player.velocity = Vec3::ZERO; } else if !dead && !riding { + player.client_side = true; player.velocity = player.velocity.add_vector(pushed); MotionWorld { entities: &entity_collisions, @@ -3206,7 +3280,7 @@ impl Game<'_> { _ => {} } } - // The server owns health and hunger: undo local food/fall changes. + // The server owns health and hunger. self.apply_remote_health(); self.tick_avatar(before, false); // The player's own model (third person, the inventory's preview). @@ -3246,9 +3320,10 @@ impl Game<'_> { player.flying_speed = a.flying_speed; } /// The local player's share of every touching entity's - /// `LivingEntity.pushEntities`: on a client `EntitySelector.pushableBy` - /// lets entities push only the local player, so the server never sends - /// these pushes. `doPush(player)` is `player.push(entity)`. + /// `LivingEntity.pushEntities`, and of the boats' pushes: on a client + /// `EntitySelector.pushableBy` lets entities push only the local player, + /// so the server never sends these pushes. `doPush(player)` is + /// `player.push(entity)`. fn remote_pushes(&self) -> Vec3 { let (Some(p), Some(r)) = (self.player.as_ref(), self.remote.as_ref()) else { return Vec3::ZERO; @@ -3307,11 +3382,51 @@ impl Game<'_> { za *= f64::from(0.05_f32); push = Vec3::new(push.x - xa, push.y, push.z - za); } + // AbstractBoat.push(player) from the boat's own tick (its box grown + // by 0.2 sideways) and from the player's pushEntities (its box). + let player_team = teams.of(Who::Player); + let area = Vec3::new(f64::from(0.2_f32), f64::from(-0.01_f32), f64::from(0.2_f32)); + for b in self.boats.iter().filter(|b| self.riding != Some(b.id)) { + let bb = b.bounds(); + let times = usize::from( + bounds.intersects(bb.inflate(area)) + && horizon_client::scoreboard::pushable_by(None, player_team, true), + ) + usize::from( + bounds.intersects(bb) + && horizon_client::scoreboard::pushable_by(player_team, None, true), + ); + if times > 0 + && super::boat_passengers::boat_pushes(bb, bounds, false) + && let Some(v) = super::boat_passengers::push_impulse(b.position, p.position) + { + push = push.add_vector(v.scale(times as f64)); + } + } push } /// ClientLevel.tickEntities; a frozen level only ticks the players /// (`TickRateManager.isEntityFrozen`). fn tick_remote_entities(&mut self, running: bool) { + // EntityFluidInteraction.update for the entities this window only displays: the + // server never sends the fluid contact, and the renderers read it (cod, salmon and + // tropical fish lie on their side without `in_water`, #1591). + // A frozen level ticks only the players, as below. + let fluids: Vec<_> = { + let w = self.mob_world_base(&[]); + let players = self.remote.as_ref().map(|r| &r.level_players); + self.mobs + .iter() + .map(|m| { + (running || players.is_some_and(|p| p.contains_key(&(m.id as i32)))) + .then(|| w.fluids(m.bounds(), m.eye_y())) + }) + .collect() + }; + for (m, fluids) in self.mobs.iter_mut().zip(fluids) { + if let Some(fluids) = fluids { + m.fluids = fluids; + } + } let Some(r) = self.remote.as_mut() else { return; }; @@ -3414,20 +3529,12 @@ impl Game<'_> { l.steps -= 1; } } + // ItemEntity.tick runs on a client too: gravity, collisions and + // friction move the item between the server's updates (every 20 + // 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.previous = d.position; - d.age += 1; - if let Some(l) = lerps.get_mut(&(d.id as i32)) - && l.steps > 0 - { - let n = f64::from(l.steps); - d.position = Vec3::new( - d.position.x + (l.target[0] - d.position.x) / n, - d.position.y + (l.target[1] - d.position.y) / n, - d.position.z + (l.target[2] - d.position.z) / n, - ); - l.steps -= 1; - } + d.tick(world, facts, collision, false); } head_lerps.retain(|_, (_, steps)| *steps > 0); for (item, ticks, at, eye, pitch, yaw) in using { diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 58f82e3a9..33c69728b 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -2,7 +2,7 @@ //! end crystals on a server's client (`ClientPacketListener.handleAddEntity` //! and `handleSetEntityData`): the server simulates them, the client draws //! them where it says and interpolates their moves. -use super::{FallingBlock, Game}; +use super::{FallStep, FallingBlock, Game}; use horizon_client::projectiles::{Projectile, ProjectileKind}; use horizon_core::{geometry::Vec3, position::BlockPos}; use horizon_protocol::entity_data::Value; @@ -185,11 +185,17 @@ impl Game<'_> { t.previous = t.position; t.position = step(t.id, t.position); } - for f in &mut self.falling { - f.previous = f.position; - f.age += 1; - f.position = step(f.id, f.position); + // FallingBlockEntity.tick runs on a client too: the block falls by + // itself between the server's updates (every 20 ticks), then waits + // where it lands for the server to place it and remove it. + let mut falling = std::mem::take(&mut self.falling); + for f in &mut falling { + if let Ok(FallStep::Landed(_)) = self.fall_step(f, false) { + // Block.updateEntityMovementAfterFallOn, then the air drag. + f.velocity = Vec3::new(f.velocity.x * 0.98, 0.0, f.velocity.z * 0.98); + } } + self.falling = falling; for p in &mut self.creatures.projectiles { p.previous = p.position; p.age += 1; diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs index 027983145..cf1b2d683 100644 --- a/crates/horizon-client/src/game/remote_vehicles.rs +++ b/crates/horizon-client/src/game/remote_vehicles.rs @@ -88,8 +88,10 @@ impl Game<'_> { for m in &mut self.mobs { if m.extra.mount == Some(vehicle_id) && !passengers.contains(&(m.id as i32)) { m.extra.mount = None; + m.extra.passenger = false; } else if passengers.contains(&(m.id as i32)) { m.extra.mount = Some(vehicle_id); + m.extra.passenger = true; } } if passengers.contains(&me) { @@ -129,17 +131,20 @@ impl Game<'_> { self.yaw += b.delta_rotation; let delta = (self.yaw - b.yaw + 180.0).rem_euclid(360.0) - 180.0; self.yaw += delta.clamp(-105.0, 105.0) - delta; - let seat = b.position; self.boats[i] = b; - Some(seat) + // In front of a mob that shares the boat. + Some(self.player_boat_seat(i)) } else { // A minecart: the server moves it, the rider sits in it. - self.carts.iter().find(|c| c.id == id).map(|c| c.position) + self.carts.iter().find(|c| c.id == id).map(|c| { + c.position + .add_vector(Vec3::new(0.0, super::minecarts::SEAT, 0.0)) + }) }; if let Some(p) = self.player.as_mut() { self.previous_position = p.position; if let Some(v) = seat { - p.position = Vec3::new(v.x, v.y + super::boats::SEAT, v.z); + p.position = v; } p.velocity = Vec3::ZERO; p.fall_distance = 0.0; diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs new file mode 100644 index 000000000..6c891a831 --- /dev/null +++ b/crates/horizon-client/src/game/server_packs.rs @@ -0,0 +1,316 @@ +//! A server's resource packs bound to the game (`ClientCommonPacketListenerImpl. +//! handleResourcePackPush` and `handleResourcePackPop`, its `PackConfirmScreen`, +//! and `DownloadedPackSource` as `Minecraft` drives it): the prompt, the +//! server list's setting, downloads into `downloads/`, and a resource reload +//! with the server's packs on top of the player's own. +use super::Game; +use horizon_client::{ + Result, + confirm_screen::Confirm, + hud::{HudAtlas, HudBatch}, + multiplayer, packs, + scoreboard::{comp_text, tag_to_json}, + server_packs::{Prompt, ServerPacks, action, download, parse_sha1, valid_url}, + text::{Text, named_color}, + ui, +}; +use horizon_protocol::{packets::configuration::ResourcePackPush, servers}; +use std::path::PathBuf; + +/// `ClientCommonPacketListenerImpl.PackConfirmScreen`: the packs it asks +/// about, whether the last one is required, and the server's message. +pub(super) struct PackPrompt { + requests: Vec<(u128, String, String)>, + required: bool, + prompt: Option, +} +impl PackPrompt { + fn texts(&self) -> (Text, Text, [Text; 2]) { + let t = |key: &str| Text::translate(key, &[]); + let (title, line2) = if self.required { + let yellow = named_color("yellow").unwrap_or(0xFFFF55); + ( + t("multiplayer.requiredTexturePrompt.line1"), + t("multiplayer.requiredTexturePrompt.line2") + .with_color(yellow) + .bold(), + ) + } else { + ( + t("multiplayer.texturePrompt.line1"), + t("multiplayer.texturePrompt.line2"), + ) + }; + // preparePackPrompt. + let message = match &self.prompt { + Some(prompt) => Text::translate( + "multiplayer.texturePrompt.serverPrompt", + &[line2, prompt.clone()], + ), + None => line2, + }; + let buttons = if self.required { + [t("gui.proceed"), t("menu.disconnect")] + } else { + [t("gui.yes"), t("gui.no")] + }; + (title, message, buttons) + } + fn layout(&self, atlas: &HudAtlas, size: (f32, f32)) -> Confirm { + let (title, message, _) = self.texts(); + Confirm::new(&atlas.font, size, &title, &message) + } +} + +/// The game's `DownloadedPackSource`. +#[derive(Default)] +pub(super) struct ServerPackState { + packs: ServerPacks, + /// `downloads/` in the game folder, opened at the first download. + queue: Option, + pub(super) prompt: Option, + /// The server list entry the setting is saved to (none: a direct join). + address: Option, + /// The account the downloads are made for (the download headers). + user: (String, u128), + /// The packs loaded on top of the player's own, bottom first. + pub(super) active: Vec, +} + +fn saves() -> PathBuf { + std::env::current_dir().unwrap_or_default().join("saves") +} + +impl Game<'_> { + /// `ConnectScreen`: the server's setting decides what its packs do + /// (`configureForServerControl`); single player's own server takes them + /// all, quietly (`configureForLocalWorld`). + pub(super) fn server_packs_connect(&mut self, address: Option<&str>, user: (String, u128)) { + let state = &mut self.server_packs; + state.user = user; + state.prompt = None; + let Some(address) = address else { + state.address = None; + state.packs.local_world(); + return; + }; + let file = multiplayer::servers_file(&saves()); + let entry = servers::load(&file).into_iter().find(|s| s.ip == address); + let setting = entry.as_ref().and_then(|e| e.accept_textures); + state.address = entry.map(|e| e.ip); + state.packs.connect(Prompt::for_server(setting)); + } + /// `Minecraft.clearDownloadedResourcePacks`: every server pack goes at once. + pub(super) fn server_packs_disconnect(&mut self) { + self.server_packs.prompt = None; + self.server_packs.packs.disconnect(); + self.tick_server_packs(); + } + + /// `handleResourcePackPush`. + pub(super) fn handle_pack_push(&mut self, p: ResourcePackPush) { + if !valid_url(&p.url) { + self.send_pack_status(p.id, action::INVALID_URL); + return; + } + let setting = self.server_setting(); + let prompt = Prompt::for_server(setting); + if prompt != Prompt::Pending && (!p.required || prompt != Prompt::Declined) { + self.server_packs + .packs + .push(p.id, &p.url, parse_sha1(&p.hash)); + return; + } + // addOrUpdatePackPrompt: one prompt for every pack pushed before it is answered. + let text = p.prompt.as_ref().map(|t| comp_text(&tag_to_json(t))); + let state = &mut self.server_packs; + let open = state.prompt.get_or_insert(PackPrompt { + requests: Vec::new(), + required: p.required, + prompt: None, + }); + open.requests.push((p.id, p.url, p.hash)); + open.required = p.required; + open.prompt = text; + self.capture(false); + } + /// `handleResourcePackPop`: one pack, or all of them. + pub(super) fn handle_pack_pop(&mut self, id: Option) { + match id { + Some(id) => self.server_packs.packs.pop(id), + None => self.server_packs.packs.pop_all(), + } + } + /// The joined server's entry in the server list: its `acceptTextures`. + fn server_setting(&self) -> Option { + let address = self.server_packs.address.as_deref()?; + servers::load(&multiplayer::servers_file(&saves())) + .into_iter() + .find(|s| s.ip == address)? + .accept_textures + } + fn send_pack_status(&self, id: u128, status: i32) { + if let Some(r) = &self.remote { + r.session.send_pack_status(id, status); + } + } + + /// The prompt's answer (`PackConfirmScreen`'s callback): the server's + /// setting follows it, declining a required pack disconnects, and every + /// pack it asked about is pushed. + pub(super) fn answer_pack_prompt(&mut self, yes: bool) -> Result<()> { + let Some(prompt) = self.server_packs.prompt.take() else { + return Ok(()); + }; + if self.player.is_some() && self.screen == super::Screen::Playing { + self.capture(true); + } + let setting = if yes { + self.server_packs.packs.allow(); + Some(true) + } else { + self.server_packs.packs.reject(); + if prompt.required { + let reason = Text::translate("multiplayer.requiredTexturePrompt.disconnect", &[]); + return self.leave_server(Some(reason.plain())); + } + Some(false) + }; + for (id, url, hash) in prompt.requests { + self.server_packs.packs.push(id, &url, parse_sha1(&hash)); + } + // ServerList.saveSingleServer. + if let Some(address) = &self.server_packs.address { + let file = multiplayer::servers_file(&saves()); + let mut list = servers::load(&file); + for entry in list.iter_mut().filter(|s| &s.ip == address) { + entry.accept_textures = setting; + } + if let Err(e) = servers::save(&file, &list) { + log::warn!("Horizon: could not save {}: {e}", file.display()); + } + } + Ok(()) + } + + /// Runs what the packs need (`createUpdateScheduler`): the downloads + /// that finished, the ones to start, a resource reload when the active + /// packs change, and the statuses for the server. + pub(super) fn tick_server_packs(&mut self) { + // A reload waits for the world's resources (`reload_packs`). + if self.rest_loader.is_some() || self.world_loader.is_some() { + return; + } + let finished = self + .server_packs + .queue + .as_ref() + .map(download::Queue::finished) + .unwrap_or_default(); + for batch in finished { + self.server_packs.packs.downloaded(batch); + } + while self.server_packs.packs.wants_tick() { + let tick = self.server_packs.packs.tick(); + if !tick.download.is_empty() { + self.start_pack_downloads(tick.download); + } + if let Some(mut load) = tick.reload { + while let Some(recovery) = { + let ok = self.reload_server_packs(&load); + self.server_packs.packs.reloaded(ok) + } { + load = recovery; + } + } + } + for (id, status) in self.server_packs.packs.take_replies() { + self.send_pack_status(id, status); + } + } + fn start_pack_downloads(&mut self, requests: Vec) { + let state = &mut self.server_packs; + if state.queue.is_none() { + let dir = std::env::current_dir() + .unwrap_or_default() + .join("downloads"); + match download::Queue::open(dir) { + Ok(queue) => state.queue = Some(queue), + Err(e) => { + log::error!("Horizon: failed to open the download queue: {e}"); + let failed = requests.iter().map(|r| r.id).collect(); + state.packs.downloaded(horizon_client::server_packs::Batch { + downloaded: Vec::new(), + failed, + }); + return; + } + } + } + let headers = download::headers(&state.user.0, state.user.1); + if let Some(queue) = &state.queue { + queue.download(requests, headers); + } + } + /// `DownloadedPackSource.startReload`: the packs on top of the player's + /// own, then `Minecraft.reloadResourcePacks`. False when a pack has no + /// readable `pack.mcmeta` or the reload failed. + fn reload_server_packs(&mut self, load: &[(u128, PathBuf)]) -> bool { + let packs: Option> = load + .iter() + .map(|(id, path)| packs::server_pack(*id, path)) + .collect(); + let Some(packs) = packs else { + log::warn!("Horizon: invalid pack metadata in a server pack, ignoring all"); + return false; + }; + self.server_packs.active = packs; + match self.reload_selected_packs() { + Ok(()) => true, + Err(e) => { + log::warn!("Horizon: server resource pack reload failed: {e}"); + false + } + } + } + + pub(super) fn draw_pack_prompt(&self, batch: &mut HudBatch) { + let Some(prompt) = &self.server_packs.prompt else { + return; + }; + let atlas = &self.gui.atlas; + let (w, h) = (batch.width, batch.height); + if self.player.is_none() { + // In place of the connecting screen, on its background. + batch.fill( + atlas, + 0.0, + 0.0, + w, + h, + horizon_client::hud::rgba(20, 20, 20, 255), + ); + } + ui::menu_background(batch, atlas, 0.0, 0.0, w, h, self.player.is_some()); + let (_, _, [yes, no]) = prompt.texts(); + prompt + .layout(atlas, (w, h)) + .draw(batch, atlas, self.cursor, [&yes, &no]); + } + /// A left click on the prompt: its answer when it hit a button. + pub(super) fn pack_prompt_click(&mut self) -> Result<()> { + let Some(prompt) = &self.server_packs.prompt else { + return Ok(()); + }; + let answer = prompt + .layout(&self.gui.atlas, self.gui_size()) + .answer_at(self.cursor); + match answer { + Some(yes) => { + self.audio.play_button_click(); + self.answer_pack_prompt(yes) + } + None => Ok(()), + } + } +} diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index e6cb6b04f..96af99bbc 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -219,12 +219,11 @@ pub(super) fn spawn_loader( .name("resource-loader".into()) .spawn(move || { let mut pack_error = None; - let root = packs::startup_root(&vanilla_root, &settings.resource_packs).unwrap_or_else( - |error| { + let root = packs::startup_root(&vanilla_root, &settings.resource_packs, &[]) + .unwrap_or_else(|error| { pack_error = Some(error.to_string()); vanilla_root.clone() - }, - ); + }); let root = mods::content_root(&root, &settings.mods.enabled, &dev_mods); let result = load_resources( root, diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs index ecbee08a8..bd9ae7caa 100644 --- a/crates/horizon-client/src/game/world_loading.rs +++ b/crates/horizon-client/src/game/world_loading.rs @@ -245,7 +245,6 @@ pub(super) fn make_streaming( streaming.biome_blend = settings.biome_blend; streaming.smooth_lighting = settings.smooth_lighting; streaming.cutout_leaves = settings.cutout_leaves; - streaming.cull_leaves = settings.horizon.cull_leaves; streaming.biome_zoom = BiomeZoom::new(obfuscate_seed(seed)); streaming.sky_light = dim != Dim::Nether; streaming.nether_shading = dim == Dim::Nether; diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs index 9eb79a477..3cf1402d2 100644 --- a/crates/horizon-client/src/graphics.rs +++ b/crates/horizon-client/src/graphics.rs @@ -227,8 +227,6 @@ pub struct Graphics { pub far_detail: FarDetail, /// Skip sections hidden behind closed ones (vanilla's occlusion graph). pub cave_culling: bool, - /// Hide shared leaf and mangrove-root faces, reducing foliage density. - pub cull_leaves: bool, /// Skip drawing entities hidden behind opaque terrain. pub entity_culling: bool, /// Meshed sections uploaded per frame; 0 uploads all that are ready. @@ -262,7 +260,6 @@ impl Default for Graphics { lod_distance: 0, far_detail: FarDetail::Full, cave_culling: true, - cull_leaves: false, entity_culling: false, chunk_updates: 0, upload_budget_kib: 0, @@ -308,7 +305,6 @@ impl Graphics { "lodDistance" => g.lod_distance = number(g.lod_distance).min(1024), "farDetail" => g.far_detail = FarDetail::parse(value), "caveCulling" => g.cave_culling = flag(g.cave_culling), - "cullLeaves" => g.cull_leaves = flag(g.cull_leaves), "entityCulling" => g.entity_culling = flag(g.entity_culling), "chunkUpdates" => g.chunk_updates = number(g.chunk_updates).min(512), "uploadBudgetKiB" => g.upload_budget_kib = number(g.upload_budget_kib).min(65536), @@ -343,12 +339,11 @@ impl Graphics { } pub fn serialize(&self) -> String { format!( - "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\ncullLeaves:{}\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:{}\n", self.preset.name(), self.lod_distance, self.far_detail.name(), bool_text(self.cave_culling), - bool_text(self.cull_leaves), bool_text(self.entity_culling), self.chunk_updates, self.upload_budget_kib, @@ -448,7 +443,6 @@ mod tests { lod_distance: 256, far_detail: FarDetail::Reduced, cave_culling: false, - cull_leaves: true, entity_culling: true, chunk_updates: 12, upload_budget_kib: 4096, @@ -475,7 +469,7 @@ mod tests { Graphics::default() ); assert_eq!( - Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:maybe\nentityCulling:maybe\n"), + Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\n"), Graphics::default() ); } diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs index d9ea62c72..ba99f89a8 100644 --- a/crates/horizon-client/src/graphics_ui.rs +++ b/crates/horizon-client/src/graphics_ui.rs @@ -24,7 +24,6 @@ pub enum H { LodDistance, FarDetail, CaveCulling, - CullLeaves, EntityCulling, ChunkUpdates, UploadBudget, @@ -138,11 +137,6 @@ pub fn rows(level: Level) -> Vec { Saves, "Skips terrain hidden behind closed sections. Off costs a lot.", ), - h( - H::CullLeaves, - None, - "Hides shared leaf and mangrove root faces; foliage can look less dense.", - ), h( H::EntityCulling, None, @@ -343,7 +337,6 @@ impl H { }, H::FarDetail => labelled("Far Detail", g.far_detail.label()), H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)), - H::CullLeaves => labelled("Cull Leaves", on_off(g.cull_leaves)), H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)), H::ChunkUpdates => match g.chunk_updates { 0 => labelled("Chunk Updates", "Unlimited"), @@ -418,7 +411,6 @@ impl H { g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back) } H::CaveCulling => g.cave_culling = !g.cave_culling, - H::CullLeaves => g.cull_leaves = !g.cull_leaves, H::EntityCulling => g.entity_culling = !g.entity_culling, H::Sky => g.sky = !g.sky, H::Fog => g.fog = !g.fog, @@ -455,7 +447,6 @@ impl Item { let g = &s.horizon; Some(match self { Item::Horizon(H::CaveCulling) => g.cave_culling, - Item::Horizon(H::CullLeaves) => g.cull_leaves, Item::Horizon(H::EntityCulling) => g.entity_culling, Item::Horizon(H::Sky) => g.sky, Item::Horizon(H::Fog) => g.fog, @@ -1003,48 +994,6 @@ mod tests { assert_eq!(s.horizon.upload_budget_kib, 0); } - #[test] - fn cull_leaves_is_opt_in_and_toggles_from_advanced_graphics() { - let mut s = Settings::default(); - let item = Item::Horizon(H::CullLeaves); - assert_eq!(item.switch(&s), Some(false)); - assert_eq!(item.label(&s).plain(), "Cull Leaves: Off"); - for enabled in [false, true] { - s.horizon.cull_leaves = enabled; - for preset in Preset::ALL { - crate::graphics::apply_preset(preset, &mut s); - assert_eq!(s.horizon.cull_leaves, enabled); - } - } - - let mut ui = GraphicsUi::default(); - let size = (480.0, 4000.0); - let (widgets, _, _) = ui.layout(Level::Advanced, size.0, size.1); - let switch = widgets - .iter() - .find(|w| matches!(w.target, Target::Item(i) if i == item)) - .unwrap(); - let point = (switch.x + 1.0, switch.y + 1.0); - for enabled in [false, true] { - s.horizon.preset = Preset::Balanced; - assert_eq!( - ui.click( - Level::Advanced, - &mut s, - point, - size, - [854, 480], - false, - false - ), - vec![Action::ButtonClick, Action::Changed] - ); - assert_eq!(item.switch(&s), Some(enabled)); - assert_eq!(s.horizon.preset, Preset::Custom); - } - assert_eq!(item.label(&s).plain(), "Cull Leaves: On"); - } - #[test] fn entity_culling_is_opt_in_and_toggles_from_advanced_graphics() { let mut s = Settings::default(); diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs index 9d53869ec..da40f41fc 100644 --- a/crates/horizon-client/src/health.rs +++ b/crates/horizon-client/src/health.rs @@ -253,6 +253,22 @@ impl PlayerHealth { self.hurt_animation_time -= 1; } } + /// `LivingEntity.animateHurt` / `handleDamageEvent` on a client: the hurt + /// tilt and red flash restart. + pub fn animate_hurt(&mut self) { + self.hurt.hurt_duration = 10; + self.hurt.hurt_time = 10; + self.hurt_animation_time = 10; + } + /// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current + /// health starts the hurt animation. + pub fn flash_health_change(&mut self, health: f32) { + let damage = self.health() - health; + if damage > 0.0 { + self.hurt.last_hurt = damage; + self.animate_hurt(); + } + } } impl PlayerMotion { pub fn hurt( @@ -274,6 +290,9 @@ impl PlayerMotion { amount: f32, blocking: Option, ) -> Result { + if self.client_side { + return Ok(BlockOutcome::default()); + } let source = resources .damage .source::<()>(source, None, None, None) diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index cc922752e..89d1b1c3c 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -81,6 +81,12 @@ pub const MINIMAP_SPRITE: &str = "horizon/minimap"; pub const SKIN_SLOTS: usize = 32; /// Reused by the visible rows of the classic world selector. pub const WORLD_ICON_SLOTS: usize = 32; +/// Atlas slots for the pack icons on the pack screen, one per icon drawn +/// (`PackSelectionScreen.loadPackIcon` registers a texture per pack): two lists +/// of 36-pixel rows at GUI scale 2 on a 4K screen still fit. +pub const PACK_ICON_SLOTS: usize = 64; +/// A pack icon slot's side: vanilla's own icons are 128x128. +pub const PACK_ICON_SIZE: u32 = 128; /// Atlas slots for armour trim textures made at run time (`trims`), each the /// size of the largest trim texture. pub const TRIM_SLOTS: usize = 32; @@ -252,7 +258,7 @@ impl HudAtlas { ) } /// Empty slots written at run time: map textures (game/maps.rs), the - /// minimap, downloaded skins, world icons and the on-screen keyboard's text. + /// minimap, downloaded skins, world and pack icons and the on-screen keyboard's text. fn slots(images: &mut Vec, trim: (u32, u32)) { for i in 0..MAP_SLOTS { images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); @@ -284,6 +290,15 @@ impl HudAtlas { vec![0; 64 * 64 * 4], )); } + let side = PACK_ICON_SIZE as usize; + for i in 0..PACK_ICON_SLOTS { + images.push(( + format!("horizon/pack-icon{i}"), + PACK_ICON_SIZE, + PACK_ICON_SIZE, + vec![0; side * side * 4], + )); + } // The on-screen keyboard's text and corner masks (ui_theme), rasterized at run time. images.push(( "horizon/ui-text".into(), diff --git a/crates/horizon-client/src/hunger.rs b/crates/horizon-client/src/hunger.rs index 0d9fb02e0..15eac144f 100644 --- a/crates/horizon-client/src/hunger.rs +++ b/crates/horizon-client/src/hunger.rs @@ -55,6 +55,9 @@ impl PlayerMotion { Ok(()) } pub fn food_tick(&mut self, resources: &HealthResources, rules: HealthRules) -> Result<()> { + if self.client_side { + return Ok(()); + } let h = &mut self.health; let mut world = TickWorld { resources, diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 3c741e963..229f176f9 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -41,6 +41,7 @@ pub mod command; pub mod command_block; pub mod command_storage; pub mod component; +pub mod confirm_screen; pub mod container_screen; pub mod containers; pub mod control; @@ -157,6 +158,7 @@ pub mod screen_effects; pub mod screen_layout; pub mod sculk; pub use horizon_server_files as server; +pub mod server_packs; pub mod settings; pub mod shadows; pub mod signs; diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index a9e9f6823..59140866a 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -230,8 +230,6 @@ fn visibility(pad: &Padded, info: &[Info]) -> u64 { result } #[cfg(test)] -mod leaf_culling_tests; -#[cfg(test)] mod particle_tests; #[cfg(test)] mod visibility_tests; @@ -277,7 +275,6 @@ struct Info { overlay: bool, /// `LeavesBlock`: with opaque leaves the faces between two leaf blocks are skipped. leaves: bool, - mangrove_roots: bool, blocks_flow: bool, ice: bool, sturdy: u8, @@ -440,7 +437,6 @@ impl MeshTables { legacy_solid: s.legacy_solid, overlay: s.has_class("HalfTransparentBlock") || s.has_class("LeavesBlock"), leaves: s.has_class("LeavesBlock"), - mangrove_roots: s.has_class("MangroveRootsBlock"), blocks_flow: assets.blocks_fluid_flow.contains(&*s.name), ice: s.has_class("IceBlock"), sturdy: s.sturdy_full, @@ -692,8 +688,6 @@ pub struct Mesher<'a> { pub smooth_lighting: bool, /// The `cutoutLeaves` option (fancy graphics); off makes leaves opaque. pub cutout_leaves: bool, - /// Cull shared leaf and mangrove-root faces, including transparent leaves. - pub cull_leaves: bool, } impl Mesher<'_> { /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1). @@ -773,12 +767,9 @@ impl Mesher<'_> { let [dx, dy, dz] = d.normal(); let neighbor = pad.blocks[pi(x + dx, y + dy, z + dz)]; let other = &info[neighbor as usize]; - // Adapted from CullLeaves (MIT); see THIRD_PARTY_NOTICES.md. - let shared_foliage = (state.leaves - && other.leaves - && (!self.cutout_leaves || self.cull_leaves)) - || (self.cull_leaves && state.mangrove_roots && other.mangrove_roots); - visible[d as usize] = !shared_foliage + // LeavesBlock.skipRendering with opaque leaves. + let opaque_leaves = !self.cutout_leaves && state.leaves && other.leaves; + visible[d as usize] = !opaque_leaves && self .visibility .should_render_face( diff --git a/crates/horizon-client/src/mesher/leaf_culling_tests.rs b/crates/horizon-client/src/mesher/leaf_culling_tests.rs deleted file mode 100644 index 679b19090..000000000 --- a/crates/horizon-client/src/mesher/leaf_culling_tests.rs +++ /dev/null @@ -1,126 +0,0 @@ -use super::*; -use horizon_assets::model::Direction as ModelDirection; - -#[test] -fn leaf_culling_removes_only_internal_leaf_and_root_faces() { - let root = - std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3"); - if !root.join("horizon-resources.json").exists() { - return; - } - let assets = Assets::load(&root).unwrap(); - let render = assets.reload(&root).unwrap(); - let facts = BlockFacts::load(&root, assets.registry).unwrap(); - let visibility = crate::models::load_visibility(&root, assets.registry).unwrap(); - let tables = MeshTables::new(&assets, &render, &facts, visibility.clone()).unwrap(); - let biomes = Biomes::load(&root).unwrap(); - let state = |name| assets.registry.default_state(name).unwrap().0; - let oak = state("minecraft:oak_leaves"); - let birch = state("minecraft:birch_leaves"); - let roots = state("minecraft:mangrove_roots"); - let stone = state("minecraft:stone"); - let mesh = |blocks: &[([i32; 3], u32)], cull_leaves, cutout_leaves| { - let mut center = Chunk::empty(0, 0); - let mut east = Chunk::empty(1, 0); - for &([x, y, z], state) in blocks { - let chunk = if x < 16 { &mut center } else { &mut east }; - chunk.set(x, y, z, state); - } - let mut region = [[None; 3]; 3]; - region[1][1] = Some(¢er); - region[1][2] = Some(&east); - Mesher { - nether_shading: false, - assets: &assets, - render: &render, - tables: &tables, - biomes: &biomes, - visibility: visibility.clone(), - zoom: BiomeZoom::new(0), - blend_radius: 0, - smooth_lighting: false, - cutout_leaves, - cull_leaves, - } - .tesselate(®ion, (0 - MIN_Y) / 16) - .solid - }; - - // Native leaves can contain unculled interior geometry as well as their - // outer faces. Select the touching cull group from the actual baked model, - // preserving every other quad and its full vertex attributes. - let without_face = |at: [i32; 3], id, direction| { - let vertices = mesh(&[(at, id)], false, true); - let models = render - .model_catalog - .collect(BlockStateId(id), BlockPos::new(at[0], at[1], at[2])) - .unwrap(); - let faces: Vec<_> = models.iter().flat_map(|(_, model)| &model.faces).collect(); - assert_eq!(vertices.len(), faces.len() * 4); - let retained: Vec<_> = vertices - .as_chunks::<4>() - .0 - .iter() - .zip(faces) - .filter(|(_, face)| face.quad.cull != Some(direction)) - .flat_map(|(quad, _)| quad.iter().copied()) - .collect(); - assert!(retained.len() < vertices.len(), "fixture has a cull group"); - retained - }; - - // Same-species leaves, mixed leaves and roots hide only their touching - // model groups. Disabling the option restores the isolated models. - for (a, b) in [(oak, oak), (oak, birch), (roots, roots)] { - let blocks = [([7, 7, 7], a), ([8, 7, 7], b)]; - let off = mesh(&blocks, false, true); - let on = mesh(&blocks, true, true); - assert_eq!( - off.len(), - mesh(&[blocks[0]], false, true).len() + mesh(&[blocks[1]], false, true).len() - ); - let mut retained = without_face(blocks[0].0, a, ModelDirection::East); - retained.extend(without_face(blocks[1].0, b, ModelDirection::West)); - assert_eq!( - bytemuck::cast_slice::<_, u8>(&on), - bytemuck::cast_slice::<_, u8>(&retained) - ); - } - - // Roots do not join leaves into a single culling group. Ordinary opaque - // neighbors also keep their existing occlusion behavior. - for (a, b) in [(oak, roots), (roots, oak), (oak, stone)] { - let blocks = [([7, 7, 7], a), ([8, 7, 7], b)]; - let off = mesh(&blocks, false, true); - let on = mesh(&blocks, true, true); - assert_eq!( - bytemuck::cast_slice::<_, u8>(&on), - bytemuck::cast_slice::<_, u8>(&off) - ); - } - - // Opaque leaves already hide internal leaf faces independently of this - // option, and a leaf beside air retains its complete baked model. - let pair = [([7, 7, 7], oak), ([8, 7, 7], birch)]; - assert_eq!( - mesh(&pair, false, false).len(), - mesh(&pair, true, false).len() - ); - let isolated = [([7, 7, 7], oak)]; - assert_eq!( - bytemuck::cast_slice::<_, u8>(&mesh(&isolated, false, true)), - bytemuck::cast_slice::<_, u8>(&mesh(&isolated, true, true)) - ); - - // The padding read must also remove the center chunk's internal face - // against a different leaf species in the neighboring chunk. - let boundary = [([15, 7, 7], oak), ([16, 7, 7], birch)]; - assert_eq!( - mesh(&boundary, false, true).len(), - mesh(&[boundary[0]], false, true).len() - ); - assert_eq!( - bytemuck::cast_slice::<_, u8>(&mesh(&boundary, true, true)), - bytemuck::cast_slice::<_, u8>(&without_face(boundary[0].0, oak, ModelDirection::East)) - ); -} diff --git a/crates/horizon-client/src/mesher/visibility_tests.rs b/crates/horizon-client/src/mesher/visibility_tests.rs index 32eb4800c..ad76d48f9 100644 --- a/crates/horizon-client/src/mesher/visibility_tests.rs +++ b/crates/horizon-client/src/mesher/visibility_tests.rs @@ -87,7 +87,6 @@ fn info(solid: bool) -> Info { legacy_solid: false, overlay: false, leaves: false, - mangrove_roots: false, blocks_flow: false, ice: false, sturdy: 0, diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 47bd8a73e..4e3879fe5 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -736,9 +736,13 @@ pub struct Extra { /// The sniffer's and the ghastling's brain. pub animal_brain: Option>, pub axolotl: axolotl::Animation, - /// The mob this one rides, and the mob riding it (`getVehicle`, `getFirstPassenger`). + /// The mob or boat this one rides, and the mob riding it (`getVehicle`, + /// `getFirstPassenger`). pub mount: Option, pub rider: Option, + /// `Entity.boardingCooldown`: ticks after leaving a boat before a boat + /// can pick this mob up again. + pub boarding_cooldown: i32, /// A chicken carrying a zombie (`IsChickenJockey`). pub jockey: bool, /// A skeleton horse waiting to spring its trap, and how long it has waited. diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs index 3ebcc71f5..e5ccfd283 100644 --- a/crates/horizon-client/src/mobs/drops.rs +++ b/crates/horizon-client/src/mobs/drops.rs @@ -96,7 +96,8 @@ fn xp_reward(m: &Mob) -> i32 { _ => 0, } } -fn is_animal(s: Species) -> bool { +/// The mobs that extend `Animal`. +pub fn is_animal(s: Species) -> bool { use Species as S; matches!( s, diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index 0a626b1e7..5da5d8e79 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -300,6 +300,10 @@ pub struct PlayerMotion { /// it travels on the server: `isLocalInstanceAuthoritative` is false, so /// its moves check no fall damage. pub server_copy: bool, + /// A client's copy of its own player (`Level.isClientSide`): only the + /// server hurts it (`Entity.hurt` does nothing on a client) and ticks its + /// food (`ServerPlayer.tick`). Its hurt animation comes from the server. + pub client_side: bool, /// `Entity.applyEffectsFromBlocks` runs after travel (always in the game; /// differential fixtures turn it off where their reference does). pub block_effects: bool, @@ -465,6 +469,7 @@ impl PlayerMotion { freeze_immune: false, old_position: position, server_copy: false, + client_side: false, block_effects: true, powder_snow_entered: Vec::new(), hurt_log: Vec::new(), @@ -2860,6 +2865,58 @@ mod tests { } } } + /// A client's own fall (multiplayer, a LAN guest, single player on its + /// server thread) plays its landing but never hurts it: only the server + /// does (`Entity.hurt` on a client), so a server that cancels fall damage + /// leaves the screen still. + #[test] + fn a_clients_own_fall_does_not_hurt_it() { + let root = 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 = Assets::load(&root).unwrap(); + let render = assets.reload(&root).unwrap(); + let binding = crate::collisions::load(&root, assets.registry).unwrap(); + let resources = MotionResources::load(&root, &assets).unwrap(); + for client_side in [false, true] { + let mut scene = World::test_scene(&assets, &render, 2).unwrap(); + let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 20.0, 20.5)).unwrap(); + player.client_side = client_side; + player.fall_distance = 30.0; + let mut w = MotionWorld { + entities: &[], + player: &mut player, + scene: &mut scene, + assets: &assets, + collision_binding: &binding, + resources: &resources, + }; + w.move_self(Vec3::new(0.0, -30.0, 0.0)).unwrap(); + assert!(w.player.ground.on_ground); + assert_eq!(w.player.fall_distance, 0.0); + // LivingEntity.causeFallDamage's sounds play on both sides. + assert!(w.player.events.iter().any(|e| matches!( + e, + MotionEvent::Fall(crate::landing::FallEvent::Sound { + sound: crate::landing::SceneSound::BigFall, + .. + }) + ))); + let hurt = w.player.health.health() < 20.0; + assert_eq!(hurt, !client_side); + assert_eq!(w.player.health.hurt_animation_time > 0, !client_side); + // The server's health then starts the client's hurt animation. + if client_side { + w.player.health.flash_health_change(20.0); + assert_eq!(w.player.health.hurt_animation_time, 0); + w.player.health.flash_health_change(12.0); + assert_eq!(w.player.health.hurt_animation_time, 10); + } + } + } #[test] fn a_riptide_spin_lies_flat_and_ends_on_the_first_entity_it_touches() { let root = Path::new(env!("CARGO_MANIFEST_DIR")) diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index 179685dee..07d8552ff 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -67,6 +67,9 @@ pub enum Screen { name: String, address: String, focus: u8, + /// Server Resource Packs (`acceptTextures`): Enabled, Disabled, or + /// none for Prompt. + packs: Option, }, Direct { address: String, @@ -224,6 +227,19 @@ fn entry_address(servers: &[ServerEntry], lan: &Scanner, index: usize) -> Option } } +/// The Server Resource Packs button's label: `CommonComponents.optionNameValue`. +fn pack_setting_label(packs: Option) -> String { + let (key, fallback) = match packs { + Some(true) => ("manageServer.resourcePack.enabled", "Enabled"), + Some(false) => ("manageServer.resourcePack.disabled", "Disabled"), + None => ("manageServer.resourcePack.prompt", "Prompt"), + }; + let name = crate::lang::get_or("manageServer.resourcePack", "Server Resource Packs"); + crate::lang::get_or("options.generic_value", "%s: %s") + .replacen("%s", &name, 1) + .replacen("%s", &crate::lang::get_or(key, fallback), 1) +} + /// JoinMultiplayerScreen's `HeaderAndFooterLayout(33, 60)`. const HEADER: f32 = 33.0; const FOOTER: f32 = 60.0; @@ -461,7 +477,16 @@ impl Screen { ), ] } - Self::Edit { address, .. } => vec![ + Self::Edit { address, packs, .. } => vec![ + // ManageServerScreen's CycleButton, above Done. + b( + w / 2.0 - 100.0, + h / 4.0 + 72.0, + 200.0, + &pack_setting_label(*packs), + true, + 60, + ), b( w / 2.0 - 100.0, h / 4.0 + 96.0 + 18.0, @@ -847,6 +872,7 @@ impl Screen { name, address, focus, + .. } => { centered( batch, @@ -996,6 +1022,7 @@ impl Screen { name: "Minecraft Server".into(), address: String::new(), focus: 1, + packs: None, } } ( @@ -1011,6 +1038,7 @@ impl Screen { name: s.name, address: s.ip, focus: 0, + packs: s.accept_textures, }; } } @@ -1125,21 +1153,32 @@ impl Screen { *selected = Some(index); } } + // CycleButton: Enabled, Disabled, Prompt, and round again. + (Self::Edit { packs, .. }, Some(60)) => { + *packs = match *packs { + Some(true) => Some(false), + Some(false) => None, + None => Some(true), + } + } ( Self::Edit { index, name, address, + packs, .. }, Some(50), ) => { let mut list = servers::load(&servers_file(saves)); - let entry = ServerEntry::new(name.trim(), address.trim()); + let mut entry = ServerEntry::new(name.trim(), address.trim()); + entry.accept_textures = *packs; match index.and_then(|i| list.get_mut(i)) { Some(e) => { e.name = entry.name; e.ip = entry.ip; + e.accept_textures = entry.accept_textures; } None => list.push(entry), } @@ -1637,4 +1676,57 @@ mod tests { assert_eq!(names(), ["Keep"]); let _ = std::fs::remove_dir_all(&dir); } + + #[test] + fn edit_cycles_and_saves_the_server_resource_pack_setting() { + let dir = std::env::temp_dir().join(format!("horizon-mp-packs-{}", std::process::id())); + let saves = dir.join("saves"); + std::fs::create_dir_all(&saves).unwrap(); + let file = servers_file(&saves); + let mut entry = ServerEntry::new("Packs", "127.0.0.1:4"); + entry.accept_textures = Some(false); + servers::save(&file, &[entry]).unwrap(); + let size = (427.0, 240.0); + let mut screen = Screen::list(&saves); + if let Screen::List { selected, .. } = &mut screen { + *selected = Some(0); + } + screen.click(Some(43), 0.0, 0.0, size, &saves); + let cycle = |screen: &Screen| { + screen + .buttons(size.0, size.1) + .into_iter() + .find(|b| b.5 == 60) + .map(|b| (b.0, b.1, b.2, b.3)) + }; + // ManageServerScreen: 200 wide at height / 4 + 72, the saved value first. + assert_eq!( + cycle(&screen), + Some(( + 113.5, + 132.0, + 200.0, + "Server Resource Packs: Disabled".into() + )) + ); + // Disabled, Prompt, Enabled: Cancel keeps what was saved. + screen.click(Some(60), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt"); + screen.click(Some(51), 0.0, 0.0, size, &saves); + assert_eq!(servers::load(&file)[0].accept_textures, Some(false)); + // Done saves it. + if let Screen::List { selected, .. } = &mut screen { + *selected = Some(0); + } + screen.click(Some(43), 0.0, 0.0, size, &saves); + screen.click(Some(60), 0.0, 0.0, size, &saves); + screen.click(Some(60), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Enabled"); + screen.click(Some(50), 0.0, 0.0, size, &saves); + assert_eq!(servers::load(&file)[0].accept_textures, Some(true)); + // A new server asks. + screen.click(Some(42), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt"); + let _ = std::fs::remove_dir_all(&dir); + } } diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs index 74f1b0b6d..9cce9e1c6 100644 --- a/crates/horizon-client/src/net.rs +++ b/crates/horizon-client/src/net.rs @@ -20,6 +20,7 @@ use horizon_protocol::{ use std::{ sync::{ Arc, Mutex, + atomic::{AtomicBool, Ordering}, mpsc::{Receiver, Sender, channel}, }, thread::JoinHandle, @@ -43,6 +44,10 @@ pub enum Event { DecodeError(String), /// The server sent us back to configuration and finished it again. Reconfigured(Arc), + /// ClientboundResourcePackPushPacket, in configuration or in play. + PackPush(cfg::ResourcePackPush), + /// ClientboundResourcePackPopPacket: one pack, or every pack. + PackPop(Option), /// The connection ended. `from_server`: the server gave the reason (or /// the connection was refused for good), rather than the connection /// failing (auto-reconnect retries only failures and shutdowns). @@ -55,6 +60,9 @@ pub enum Event { pub struct Session { events: Receiver, writer: Arc>>, + /// The connection is in configuration (else in play). Changed only + /// with `writer` locked, as the packet that switches is sent. + configuring: Arc, thread: Option>, pub address: String, pub name: String, @@ -92,8 +100,10 @@ impl Session { ) -> Self { let (send, events) = channel(); let writer = Arc::new(Mutex::new(None)); + let configuring = Arc::new(AtomicBool::new(true)); let counters = Arc::new(Mutex::new(None)); let (thread_writer, thread_counters) = (writer.clone(), counters.clone()); + let thread_configuring = configuring.clone(); let (address_owned, name_owned) = (address.to_owned(), name.to_owned()); let thread = std::thread::Builder::new() .name("horizon-net".into()) @@ -107,6 +117,7 @@ impl Session { &lang, &send, &thread_writer, + &thread_configuring, &thread_counters, ); let from_server = result.is_ok(); @@ -124,6 +135,7 @@ impl Session { Self { events, writer, + configuring, thread, address: address.to_owned(), name: name.to_owned(), @@ -135,7 +147,12 @@ impl Session { pub fn poll(&self) -> Vec { self.events.try_iter().collect() } - /// Send a play packet; silently dropped once the connection is gone. + /// Send a play packet; silently dropped once the connection is gone, + /// and while the server has the connection back in configuration (a + /// proxy switching servers). Vanilla's `handleConfigurationStart` clears + /// the level before it acknowledges, so no play packet follows the + /// acknowledgement; one that did would reach the server as a + /// configuration packet, and Velocity drops such a client. pub fn send(&self, packet: play::Serverbound) { if self.debug && !matches!( @@ -147,12 +164,31 @@ impl Session { { eprintln!("[net] -> {packet:?}"); } - if let Some(w) = self.writer.lock().unwrap().as_mut() + let mut writer = self.writer.lock().unwrap(); + if self.configuring.load(Ordering::Relaxed) { + return; + } + if let Some(w) = writer.as_mut() && w.send(&packet.encode()).is_err() { w.shutdown(); } } + /// ServerboundResourcePackPacket, in whichever phase the connection is. + pub fn send_pack_status(&self, id: u128, action: i32) { + let status = cfg::ResourcePackResponse { id, action }; + let mut writer = self.writer.lock().unwrap(); + let body = if self.configuring.load(Ordering::Relaxed) { + cfg::Serverbound::ResourcePack(status).encode() + } else { + play::Serverbound::ResourcePack(status).encode() + }; + if let Some(w) = writer.as_mut() + && w.send(&body).is_err() + { + w.shutdown(); + } + } pub fn disconnect(&mut self) { if let Some(w) = self.writer.lock().unwrap().take() { w.shutdown(); @@ -253,6 +289,7 @@ fn run( lang: &Language, send: &Sender, shared_writer: &Mutex>, + configuring: &AtomicBool, shared_counters: &Mutex>>, ) -> Result { let (host, port, mut c) = if let Some(pipe) = local { @@ -268,8 +305,13 @@ fn run( target } }; - let c = - Connection::connect(&host, port, Duration::from_secs(10)).map_err(|e| e.to_string())?; + let c = if address.starts_with(FRIEND) { + // The friends relay supplies a concrete endpoint, not a Minecraft hostname. + Connection::connect(&host, port, Duration::from_secs(10)) + } else { + Connection::connect_server(&host, port, Duration::from_secs(10)) + } + .map_err(|e| e.to_string())?; (host, port, c) }; *shared_counters.lock().unwrap() = Some(c.reader.counters.clone()); @@ -377,18 +419,19 @@ fn run( .map_err(e)?; let (mut reader, writer) = c.split(); *shared_writer.lock().unwrap() = Some(writer); - let registries = configure(&mut reader, shared_writer, lang, send)?; + let registries = configure(&mut reader, shared_writer, configuring, lang, send)?; let _ = send.send(Event::Joined { registries: Arc::new(registries), uuid: profile.uuid, name: profile.name, }); - receive_play(&mut reader, shared_writer, lang, send) + receive_play(&mut reader, shared_writer, configuring, lang, send) } fn receive_play( reader: &mut ConnReader, shared_writer: &Mutex>, + configuring: &AtomicBool, lang: &Language, send: &Sender, ) -> Result { @@ -416,15 +459,17 @@ fn receive_play( play::Clientbound::KeepAlive(k) => reply(play::Serverbound::KeepAlive(k)), play::Clientbound::BundleDelimiter(_) => {} play::Clientbound::ResourcePackPush(p) => { - // Declined: Horizon has no server resource packs. - reply(play::Serverbound::ResourcePack(cfg::ResourcePackResponse { - id: p.id, - action: 1, - })); + let _ = send.send(Event::PackPush(p)); + } + play::Clientbound::ResourcePackPop(p) => { + let _ = send.send(Event::PackPop(p.id)); } play::Clientbound::StartConfiguration(_) => { - reply(play::Serverbound::ConfigurationAcknowledged(Empty)); - let registries = configure(reader, shared_writer, lang, send)?; + if let Some(w) = shared_writer.lock().unwrap().as_mut() { + let _ = w.send(&play::Serverbound::ConfigurationAcknowledged(Empty).encode()); + configuring.store(true, Ordering::Relaxed); + } + let registries = configure(reader, shared_writer, configuring, lang, send)?; let _ = send.send(Event::Reconfigured(Arc::new(registries))); } play::Clientbound::Disconnect(d) => return Ok(plain(&d.reason, lang)), @@ -445,6 +490,7 @@ fn receive_play( fn configure( reader: &mut ConnReader, writer: &Mutex>, + configuring: &AtomicBool, lang: &Language, send: &Sender, ) -> Result { @@ -471,11 +517,12 @@ fn configure( cfg::Clientbound::CodeOfConduct(_) => { reply(cfg::Serverbound::AcceptCodeOfConduct(Empty))? } + // The game answers: it may prompt the player first. cfg::Clientbound::ResourcePackPush(p) => { - reply(cfg::Serverbound::ResourcePack(cfg::ResourcePackResponse { - id: p.id, - action: 1, - }))? + let _ = send.send(Event::PackPush(p)); + } + cfg::Clientbound::ResourcePackPop(p) => { + let _ = send.send(Event::PackPop(p.id)); } cfg::Clientbound::CookieRequest(q) => { reply(cfg::Serverbound::CookieResponse(cfg::CookieResponse { @@ -485,7 +532,11 @@ fn configure( } cfg::Clientbound::Disconnect(d) => return Err(plain(&d.reason, lang)), cfg::Clientbound::FinishConfiguration(_) => { - reply(cfg::Serverbound::FinishConfiguration(Empty))?; + let mut w = writer.lock().unwrap(); + let w = w.as_mut().ok_or("Disconnected")?; + w.send(&cfg::Serverbound::FinishConfiguration(Empty).encode()) + .map_err(|e| e.to_string())?; + configuring.store(false, Ordering::Relaxed); return Ok(registries); } _ => {} @@ -559,7 +610,7 @@ pub fn load_language(resources: &std::path::Path) -> Language { pub fn ping(address: &str, timeout: Duration) -> Result<(serde_json::Value, u128), String> { use horizon_protocol::packets::status; let (host, port) = parse_address(address).ok_or("Invalid address")?; - let mut c = Connection::connect(&host, port, timeout).map_err(|e| e.to_string())?; + let mut c = Connection::connect_server(&host, port, timeout).map_err(|e| e.to_string())?; c.reader .set_read_timeout(Some(timeout)) .map_err(|e| e.to_string())?; @@ -602,7 +653,13 @@ mod tests { let (send, events) = channel(); let thread_writer = writer.clone(); let thread = std::thread::spawn(move || { - receive_play(&mut reader, &thread_writer, &Language::new(), &send) + receive_play( + &mut reader, + &thread_writer, + &AtomicBool::new(false), + &Language::new(), + &send, + ) }); let mut server = Connection::local(server); let teleport = play::Clientbound::PlayerPosition(play::PlayerPosition { @@ -638,6 +695,60 @@ mod tests { assert!(thread.join().unwrap().is_err()); } + #[test] + fn play_packets_wait_out_a_reconfiguration() { + let (client, server) = horizon_protocol::connection::Pipe::pair(); + let (mut reader, writer) = Connection::local(client).split(); + let (send, events) = channel(); + let session = Session { + events, + writer: Arc::new(Mutex::new(Some(writer))), + configuring: Arc::new(AtomicBool::new(false)), + thread: None, + address: "local".into(), + name: "Player".into(), + counters: Arc::new(Mutex::new(None)), + debug: false, + }; + let (thread_writer, thread_configuring) = + (session.writer.clone(), session.configuring.clone()); + let thread = std::thread::spawn(move || { + receive_play( + &mut reader, + &thread_writer, + &thread_configuring, + &Language::new(), + &send, + ) + }); + let mut server = Connection::local(server); + let tick_end = play::Serverbound::ClientTickEnd(Empty); + server + .send(&play::Clientbound::StartConfiguration(Empty).encode()) + .unwrap(); + let (id, body) = server.recv().unwrap(); + assert_eq!( + play::Serverbound::decode(id, &body).unwrap(), + play::Serverbound::ConfigurationAcknowledged(Empty) + ); + // The game thread still ticks the old level: nothing of it goes out. + session.send(tick_end.clone()); + server + .send(&cfg::Clientbound::FinishConfiguration(Empty).encode()) + .unwrap(); + let (id, body) = server.recv().unwrap(); + assert_eq!( + cfg::Serverbound::decode(id, &body).unwrap(), + cfg::Serverbound::FinishConfiguration(Empty) + ); + // Back in play, the game's packets flow again. + session.send(tick_end.clone()); + let (id, body) = server.recv().unwrap(); + assert_eq!(play::Serverbound::decode(id, &body).unwrap(), tick_end); + drop(session); + assert!(thread.join().unwrap().is_err()); + } + #[test] fn server_brand_payload_is_decoded_and_invalid_or_unrelated_payloads_are_ignored() { let (send, events) = channel(); diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 352ebf26e..99a83072f 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -2079,7 +2079,9 @@ impl OptionsUi { let blink = self.pack_focus.elapsed().as_millis() as u64; let m = crate::screen_draw::Measure(&atlas.font); let mouse = (cursor.0.floor() as i32, cursor.1.floor() as i32); - let draws = self.packs(atlas, (w, h)).draw(&m, mouse, blink); + let packs = self.packs(atlas, (w, h)); + let mut draws = packs.draw(&m, mouse, blink); + packs.bind_icons(&mut draws, atlas, &mut batch.patches); crate::screen_draw::paint(batch, atlas, &draws); return; } diff --git a/crates/horizon-client/src/pack_screen.rs b/crates/horizon-client/src/pack_screen.rs index 934ecaf95..2929fd663 100644 --- a/crates/horizon-client/src/pack_screen.rs +++ b/crates/horizon-client/src/pack_screen.rs @@ -6,10 +6,13 @@ //! [`PackScreen::draw`] gives the screen's GUI calls. The game shows it; //! tools/test_pack_screen_parity.py compares it with vanilla. use crate::{ + font::Patch, + hud::{HudAtlas, PACK_ICON_SIZE, PACK_ICON_SLOTS}, packs::{Position, Selectable, SelectionModel}, screen_draw::{self as d, Draw, Measure, TextField}, text::{Style, Text}, }; +use std::{collections::HashMap, sync::Arc}; /// `PackCompatibility`. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -50,8 +53,8 @@ pub struct PackInfo { pub description_style: Style, pub source: Source, pub compat: Compat, - /// Whether the pack has a `pack.png`. - pub icon: bool, + /// The pack's `pack.png` ([`load_icon`]); none draws `unknown_pack`. + pub icon: Option>, pub required: bool, pub position: Position, pub fixed: bool, @@ -90,6 +93,27 @@ impl PackInfo { (t, Style::color(d::GRAY)) } } +/// A `pack.png` as the pack screen draws it: RGBA, stretched to a +/// `PACK_ICON_SIZE` square by nearest texels, as vanilla's icon texture is +/// sampled into its 32x32 square. None when it does not decode, where +/// `loadPackIcon` falls back to `unknown_pack`. +pub fn load_icon(png: &[u8]) -> Option> { + let (w, h, rgba) = crate::hud::decode_bytes(png).ok()?; + if w == 0 || h == 0 { + return None; + } + let size = u64::from(PACK_ICON_SIZE); + let mut out = Vec::with_capacity((size * size * 4) as usize); + for y in 0..size { + let sy = ((2 * y + 1) * u64::from(h) / (2 * size)) as usize; + for x in 0..size { + let sx = ((2 * x + 1) * u64::from(w) / (2 * size)) as usize; + let at = (sy * w as usize + sx) * 4; + out.extend_from_slice(&rgba[at..at + 4]); + } + } + Some(out.into()) +} /// `PackSelectionScreen.loadPackIcon`'s texture for a pack with an icon. pub fn icon_texture(id: &str) -> String { let sanitized: String = id @@ -306,6 +330,8 @@ pub struct PackScreen { confirm: Option, /// The selection changed since the screen opened. pub changed: bool, + /// The packs' icons by their [`icon_texture`]. + icons: HashMap>, } fn tr(key: &str) -> Text { @@ -329,11 +355,16 @@ impl PackScreen { italic: Some(true), ..Style::default() })); + let icons = packs + .iter() + .filter_map(|p| Some((icon_texture(&p.id), p.icon.clone()?))) + .collect(); let mut s = Self { width, height, in_world, packs, + icons, model, search, focus: Focus::None, @@ -760,6 +791,35 @@ impl PackScreen { pub fn commit(&self) -> Vec { self.model.commit() } + /// Points the icon blits of `draws` at the atlas's pack icon slots and + /// writes the icons into them, one slot per icon drawn (vanilla registers a + /// texture per pack). Icons past the last slot keep `unknown_pack`. + pub fn bind_icons(&self, draws: &mut [Draw], atlas: &HudAtlas, patches: &mut Vec) { + let mut slots = 0..PACK_ICON_SLOTS; + for draw in draws { + let Draw::Blit { texture, .. } = draw else { + continue; + }; + let Some(icon) = self.icons.get(texture.as_str()) else { + continue; + }; + let Some(slot) = slots.next() else { + return; + }; + let sprite = format!("horizon/pack-icon{slot}"); + let Some(rect) = atlas.sprites.get(&sprite) else { + return; + }; + patches.push(Patch { + x: (rect.u0 * atlas.width as f32).round() as u32, + y: (rect.v0 * atlas.height as f32).round() as u32, + width: PACK_ICON_SIZE, + height: PACK_ICON_SIZE, + rgba: icon.to_vec(), + }); + *texture = sprite; + } + } /// The shown screen's calls (`Screen.extractRenderState`); `blink_ms` /// is the time since the search box took the focus. @@ -891,7 +951,7 @@ impl PackScreen { -8978432, ); } - let icon = if p.icon { + let icon = if p.icon.is_some() { icon_texture(id) } else { "textures/misc/unknown_pack.png".into() @@ -979,6 +1039,106 @@ impl PackScreen { } } +#[cfg(test)] +mod icon_tests { + use super::*; + + fn png(w: u32, h: u32, rgba: &[u8]) -> Vec { + let mut out = Vec::new(); + let mut encoder = png::Encoder::new(&mut out, w, h); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + encoder + .write_header() + .unwrap() + .write_image_data(rgba) + .unwrap(); + out + } + fn pack(id: &str, icon: Option>) -> PackInfo { + PackInfo { + id: id.into(), + title: Text::literal(id), + description: Text::literal(""), + description_style: Style::default(), + source: Source::BuiltIn, + compat: Compat::Compatible, + icon, + required: false, + position: Position::Top, + fixed: false, + } + } + + /// Any size stretches over the whole square, nearest texels, as the + /// icon texture is sampled into its 32x32 blit. + #[test] + fn icons_stretch_to_the_slot_by_nearest_texels() { + let (red, blue) = ([255, 0, 0, 255], [0, 0, 255, 128]); + let icon = load_icon(&png(2, 1, &[red, blue].concat())).unwrap(); + let side = PACK_ICON_SIZE as usize; + assert_eq!(icon.len(), side * side * 4); + let at = |x: usize, y: usize| &icon[(y * side + x) * 4..][..4]; + assert_eq!((at(0, 0), at(side / 2 - 1, side - 1)), (&red[..], &red[..])); + assert_eq!( + (at(side / 2, 0), at(side - 1, side - 1)), + (&blue[..], &blue[..]) + ); + assert!(load_icon(b"not a png").is_none()); + } + + /// Programmer Art and High Contrast draw their own `pack.png`; a pack + /// without one keeps `unknown_pack`. + #[test] + fn drawn_icons_take_atlas_slots() { + let atlas = + crate::hud::HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")) + .unwrap(); + let m = Measure(&atlas.font); + let dirt = load_icon(&png(1, 1, &[134, 96, 67, 255])).unwrap(); + let contrast = load_icon(&png(1, 1, &[0, 0, 0, 255])).unwrap(); + let packs = vec![ + pack("programmer_art", Some(dirt.clone())), + pack("high_contrast", Some(contrast.clone())), + pack("file/Iconless", None), + ]; + let screen = PackScreen::new(&m, 480, 320, false, packs, &[]); + let mut draws = screen.draw(&m, (0, 0), 0); + let mut patches = Vec::new(); + screen.bind_icons(&mut draws, &atlas, &mut patches); + let icons: Vec<&str> = draws + .iter() + .filter_map(|d| match d { + Draw::Blit { texture, .. } if texture.contains("pack") => Some(texture.as_str()), + _ => None, + }) + .collect(); + // The list shows them sorted by id. + assert_eq!( + icons, + [ + "textures/misc/unknown_pack.png", + "horizon/pack-icon0", + "horizon/pack-icon1" + ] + ); + assert_eq!(patches.len(), 2); + for (i, (patch, icon)) in patches.iter().zip([&contrast, &dirt]).enumerate() { + let rect = atlas.sprites[&format!("horizon/pack-icon{i}")]; + assert_eq!( + (patch.x, patch.y, patch.width, patch.height), + ( + (rect.u0 * atlas.width as f32).round() as u32, + (rect.v0 * atlas.height as f32).round() as u32, + PACK_ICON_SIZE, + PACK_ICON_SIZE + ) + ); + assert_eq!(&patch.rgba[..], &icon[..]); + } + } +} + #[cfg(test)] mod click_sound_tests { use super::*; diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 5daaaacad..5b4d11e82 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -34,8 +34,6 @@ pub struct Pack { pub description_style: Style, pub compatible: bool, pub compatibility: crate::pack_screen::Compat, - /// The pack has a `pack.png`. - pub icon: bool, /// Overlay directories active for this game version, in `pack.mcmeta` order. pub overlays: Vec, /// `filter.block` entries (namespace and path patterns) hiding resources @@ -260,6 +258,15 @@ fn filter_of(meta: &serde_json::Value) -> Vec { }) .collect() } +impl Pack { + /// The pack's `pack.png` (`PackResources.getRootResource`), for its icon. + pub fn icon_png(&self) -> Option> { + match &self.source { + Source::Dir(d) => fs::read(d.join("pack.png")).ok(), + Source::Zip(z) => Zip::open(z).ok()?.read("pack.png").ok(), + } + } +} fn read_meta(source: &Source) -> Option { let bytes = match source { Source::Dir(d) => fs::read(d.join("pack.mcmeta")).ok()?, @@ -270,10 +277,6 @@ fn read_meta(source: &Source) -> Option { fn pack(id: String, title: Text, source: Source) -> Option { let meta = read_meta(&source)?; let (raw_description, description_style) = component_root(&meta["pack"]["description"]); - let icon = match &source { - Source::Dir(d) => d.join("pack.png").is_file(), - Source::Zip(z) => Zip::open(z).is_ok_and(|z| z.read("pack.png").is_ok()), - }; Some(Pack { id, title, @@ -282,7 +285,6 @@ fn pack(id: String, title: Text, source: Source) -> Option { description_style, compatible: compatible(&meta), compatibility: compatibility(&meta), - icon, overlays: overlays_of(&meta), filter: filter_of(&meta), source, @@ -629,6 +631,17 @@ fn merge(kind: Merge, layers: &[Vec]) -> Option> { }; serde_json::to_vec(&out).ok() } +/// `DownloadedPackSource.loadRequestedPacks`: a server's downloaded pack, +/// "World Specific Resources"; None when its `pack.mcmeta` can't be read. Its +/// id names the file, which is named after its hash. +pub fn server_pack(id: u128, path: &Path) -> Option { + let file = path.file_name()?.to_string_lossy(); + pack( + format!("server/{id:032x}/{file}"), + Text::translate("resourcePack.server.name", &[]), + Source::Zip(path.to_path_buf()), + ) +} /// The packs to apply for an options.txt `resourcePacks` list (bottom first). pub fn enabled(all: &[Pack], ids: &[String]) -> Vec { ids.iter() @@ -983,6 +996,45 @@ mod tests { let _ = fs::remove_dir_all(base); } #[test] + fn built_in_and_folder_packs_give_their_pack_png() { + use std::io::Write as _; + let base = std::env::temp_dir().join(format!("horizon-pack-icons-{}", std::process::id())); + let _ = fs::remove_dir_all(&base); + let meta = br#"{"pack":{"description":"d","pack_format":97}}"#; + let built_in = base.join("vanilla/assets/minecraft/resourcepacks"); + fs::create_dir_all(&built_in).unwrap(); + let mut zip = + zip::ZipWriter::new(fs::File::create(built_in.join("programmer_art.zip")).unwrap()); + for (name, data) in [("pack.mcmeta", &meta[..]), ("pack.png", b"dirt")] { + zip.start_file(name, zip::write::SimpleFileOptions::default()) + .unwrap(); + zip.write_all(data).unwrap(); + } + zip.finish().unwrap(); + for (name, icon) in [("Iconless", None), ("Mine", Some(&b"mine"[..]))] { + let dir = base.join("packs").join(name); + fs::create_dir_all(&dir).unwrap(); + fs::write(dir.join("pack.mcmeta"), meta).unwrap(); + if let Some(icon) = icon { + fs::write(dir.join("pack.png"), icon).unwrap(); + } + } + let packs = discover(&base.join("vanilla"), &base.join("packs")); + let icons: Vec<_> = packs + .iter() + .map(|p| (p.id.as_str(), p.icon_png())) + .collect(); + assert_eq!( + icons, + [ + ("programmer_art", Some(b"dirt".to_vec())), + ("file/Iconless", None), + ("file/Mine", Some(b"mine".to_vec())), + ] + ); + let _ = fs::remove_dir_all(base); + } + #[test] fn overlays_and_filters() { let v = |s: &str| serde_json::from_str::(s).unwrap(); let meta = v(r#"{"overlays":{"entries":[ diff --git a/crates/horizon-client/src/server_packs.rs b/crates/horizon-client/src/server_packs.rs new file mode 100644 index 000000000..8e11217b5 --- /dev/null +++ b/crates/horizon-client/src/server_packs.rs @@ -0,0 +1,618 @@ +//! Server resource packs (`ServerPackManager`, `DownloadedPackSource`): the +//! packs a server pushes, the player's answer to its prompt, their downloads, +//! their activation on top of the player's own packs, and the status each one +//! reports back to the server. The game drives it: it shows the prompt, +//! starts the downloads [`ServerPacks::tick`] asks for and reloads the +//! resources with [`ServerPacks::active`] when it asks for a reload. +pub mod download; + +use std::path::PathBuf; + +/// `ServerboundResourcePackPacket.Action`, by its protocol number. +pub mod action { + pub const SUCCESSFULLY_LOADED: i32 = 0; + pub const DECLINED: i32 = 1; + pub const FAILED_DOWNLOAD: i32 = 2; + pub const ACCEPTED: i32 = 3; + pub const DOWNLOADED: i32 = 4; + pub const INVALID_URL: i32 = 5; + pub const FAILED_RELOAD: i32 = 6; + pub const DISCARDED: i32 = 7; +} + +/// `ServerPackManager.PackPromptStatus`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Prompt { + Pending, + Allowed, + Declined, +} +impl Prompt { + /// `ConnectScreen.convertPackStatus`: a server list entry's setting + /// (servers.dat `acceptTextures`; none is Prompt). + pub fn for_server(accept_textures: Option) -> Self { + match accept_textures { + Some(true) => Self::Allowed, + Some(false) => Self::Declined, + None => Self::Pending, + } + } +} + +/// `ClientCommonPacketListenerImpl.parseResourcePackUrl`: only http and https. +pub fn valid_url(url: &str) -> bool { + url.split_once(':').is_some_and(|(scheme, _)| { + scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https") + }) +} + +/// `DownloadedPackSource.tryParseSha1Hash`: 40 hex digits, else no check. +pub fn parse_sha1(hash: &str) -> Option { + (hash.len() == 40 && hash.bytes().all(|b| b.is_ascii_hexdigit())) + .then(|| hash.to_ascii_lowercase()) +} + +/// One pack to download (`DownloadQueue.DownloadRequest`). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Request { + pub id: u128, + pub url: String, + pub sha1: Option, +} + +/// `DownloadQueue.BatchResult`: the file each downloaded pack is in, and the +/// packs that failed. +#[derive(Debug, Default)] +pub struct Batch { + pub downloaded: Vec<(u128, PathBuf)>, + pub failed: Vec, +} + +/// What the game has to do after a [`ServerPacks::tick`]. +#[derive(Debug, Default, PartialEq)] +pub struct Tick { + /// Download these, then hand the result to [`ServerPacks::downloaded`]. + pub download: Vec, + /// Reload the resources with these packs on top, bottom first + /// (`PackReloadConfig.scheduleReload`), then call [`ServerPacks::reloaded`]. + pub reload: Option>, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Download { + Requested, + Pending, + Done, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Activation { + Inactive, + Pending, + Active, +} +/// `ServerPackManager.RemovalReason`, with the status it reports. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Removal { + DownloadFailed, + ActivationFailed, + Declined, + Discarded, + ServerRemoved, + ServerReplaced, +} +impl Removal { + fn reply(self) -> Option { + match self { + Self::DownloadFailed => Some(action::FAILED_DOWNLOAD), + Self::ActivationFailed => Some(action::FAILED_RELOAD), + Self::Declined => Some(action::DECLINED), + Self::Discarded => Some(action::DISCARDED), + Self::ServerRemoved | Self::ServerReplaced => None, + } + } +} + +/// `ServerPackManager.ServerPackData`. +#[derive(Debug)] +struct Pack { + id: u128, + url: String, + sha1: Option, + path: Option, + removal: Option, + download: Download, + activation: Activation, + accepted: bool, +} +impl Pack { + fn remove(&mut self, reason: Removal) { + self.removal.get_or_insert(reason); + } + fn removed(&self) -> bool { + self.removal.is_some() + } +} + +/// The reload in progress: the packs it loads and unloads (the callbacks +/// `triggerReloadIfNeeded` gives `scheduleReload`). +#[derive(Debug)] +struct Reload { + load: Vec, + unload: Vec, + /// It reloads what was active before a failed one (`isRecovery`). + recovery: bool, +} + +/// `ServerPackManager` with the feedback `DownloadedPackSource` gives it. +#[derive(Debug)] +pub struct ServerPacks { + packs: Vec, + prompt: Prompt, + reload: Option, + /// `registerForUpdate`: something changed, [`Self::tick`] again. + update: bool, + /// Report to the server (`configureForServerControl`); otherwise the + /// statuses are only logged, as for a local world. + reporting: bool, + replies: Vec<(u128, i32)>, +} +impl Default for ServerPacks { + fn default() -> Self { + Self { + packs: Vec::new(), + prompt: Prompt::Pending, + reload: None, + update: false, + reporting: false, + replies: Vec::new(), + } + } +} +impl ServerPacks { + fn report(&mut self, id: u128, status: i32) { + log::debug!("Horizon: server pack {id:032x} changed status to {status}"); + if self.reporting { + self.replies.push((id, status)); + } + } + /// The statuses to send the server, oldest first. + pub fn take_replies(&mut self) -> Vec<(u128, i32)> { + std::mem::take(&mut self.replies) + } + /// Whether [`Self::tick`] has something to do. + pub fn wants_tick(&self) -> bool { + self.update + } + + /// `DownloadedPackSource.configureForServerControl`. + pub fn connect(&mut self, prompt: Prompt) { + self.reporting = true; + match prompt { + Prompt::Allowed => self.allow(), + Prompt::Declined => self.reject(), + Prompt::Pending => self.prompt = Prompt::Pending, + } + } + /// `DownloadedPackSource.configureForLocalWorld`: single player's own + /// server; its packs are taken, and nothing is reported. + pub fn local_world(&mut self) { + self.reporting = false; + self.allow(); + } + /// `DownloadedPackSource.cleanupAfterDisconnect`: every pack goes, and + /// the next server starts from its own setting. + pub fn disconnect(&mut self) { + self.pop_all(); + self.reporting = false; + self.replies.clear(); + self.prompt = Prompt::Pending; + } + + pub fn push(&mut self, id: u128, url: &str, sha1: Option) { + if self.prompt == Prompt::Declined { + self.report(id, action::DECLINED); + return; + } + for pack in self.packs.iter_mut().filter(|p| p.id == id) { + pack.remove(Removal::ServerReplaced); + } + self.packs.push(Pack { + id, + url: url.to_owned(), + sha1, + path: None, + removal: None, + download: Download::Requested, + activation: Activation::Inactive, + accepted: false, + }); + if self.prompt == Prompt::Allowed { + self.accept(self.packs.len() - 1); + } + self.update = true; + } + fn accept(&mut self, i: usize) { + self.packs[i].accepted = true; + let id = self.packs[i].id; + self.report(id, action::ACCEPTED); + } + pub fn pop(&mut self, id: u128) { + if let Some(pack) = self.packs.iter_mut().find(|p| !p.removed() && p.id == id) { + pack.remove(Removal::ServerRemoved); + self.update = true; + } + } + pub fn pop_all(&mut self) { + for pack in &mut self.packs { + pack.remove(Removal::ServerRemoved); + } + self.update = true; + } + /// `allowServerPacks`: the prompt said yes (or the server is Enabled). + pub fn allow(&mut self) { + self.prompt = Prompt::Allowed; + for i in 0..self.packs.len() { + if !self.packs[i].accepted && !self.packs[i].removed() { + self.accept(i); + } + } + self.update = true; + } + /// `rejectServerPacks`: the prompt said no (or the server is Disabled). + pub fn reject(&mut self) { + self.prompt = Prompt::Declined; + for pack in self.packs.iter_mut().filter(|p| !p.accepted) { + pack.remove(Removal::Declined); + } + self.update = true; + } + + /// `ServerPackManager.tick`: start the downloads the accepted packs + /// need; once none is left, reload if the active packs should change; + /// then forget the packs that are gone, reporting why. + pub fn tick(&mut self) -> Tick { + self.update = false; + let mut out = Tick::default(); + let mut downloading = false; + for pack in self.packs.iter_mut().filter(|p| !p.removed() && p.accepted) { + downloading |= pack.download != Download::Done; + if pack.download == Download::Requested { + pack.download = Download::Pending; + out.download.push(Request { + id: pack.id, + url: pack.url.clone(), + sha1: pack.sha1.clone(), + }); + } + } + if !downloading { + out.reload = self.reload_if_needed(); + } + let mut gone = Vec::new(); + self.packs.retain(|p| { + let keep = p.activation != Activation::Inactive || p.removal.is_none(); + if !keep && let Some(reply) = p.removal.and_then(Removal::reply) { + gone.push((p.id, reply)); + } + keep + }); + for (id, reply) in gone { + self.report(id, reply); + } + out + } + fn reload_if_needed(&mut self) -> Option> { + if self.reload.is_some() + || self + .packs + .iter() + .any(|p| p.activation == Activation::Pending) + { + return None; + } + let mut changed = false; + let (mut load, mut unload) = (Vec::new(), Vec::new()); + for pack in &self.packs { + let wanted = pack.accepted && pack.download == Download::Done && !pack.removed(); + match pack.activation { + Activation::Inactive if wanted => { + load.push(pack.id); + changed = true; + } + Activation::Active if wanted => load.push(pack.id), + Activation::Active => { + unload.push(pack.id); + changed = true; + } + _ => {} + } + } + if !changed { + return None; + } + for pack in &mut self.packs { + let loading = load.contains(&pack.id) && pack.activation != Activation::Active; + if loading || unload.contains(&pack.id) { + pack.activation = Activation::Pending; + } + } + let paths = self.paths(&load); + self.reload = Some(Reload { + load, + unload, + recovery: false, + }); + Some(paths) + } + /// The packs to load (`PackReloadConfig.Callbacks.packsToLoad`), bottom first. + fn paths(&self, ids: &[u128]) -> Vec<(u128, PathBuf)> { + ids.iter() + .filter_map(|id| { + let pack = self + .packs + .iter() + .find(|p| p.id == *id && p.path.is_some())?; + Some((*id, pack.path.clone()?)) + }) + .collect() + } + + /// `ServerPackManager.onDownload`. + pub fn downloaded(&mut self, batch: Batch) { + if !batch.failed.is_empty() { + for pack in self + .packs + .iter_mut() + .filter(|p| p.activation != Activation::Active) + { + pack.remove(if batch.failed.contains(&pack.id) { + Removal::DownloadFailed + } else { + Removal::Discarded + }); + } + } + let mut done = Vec::new(); + for (id, path) in batch.downloaded { + if let Some(pack) = self + .packs + .iter_mut() + .find(|p| p.id == id && p.download == Download::Pending) + { + pack.download = Download::Done; + pack.path = Some(path); + if !pack.removed() { + done.push(id); + } + } + } + for id in done { + self.report(id, action::DOWNLOADED); + } + self.update = true; + } + + /// The reload [`Tick::reload`] asked for finished (`Callbacks.onSuccess`), + /// or its packs could not be loaded (`onFailure`). After a first failure + /// the packs that were active are loaded again: the packs to reload with + /// are returned, and this is called again with that reload's outcome. + pub fn reloaded(&mut self, ok: bool) -> Option> { + let mut reload = self.reload.take()?; + self.update = true; + if ok { + let mut applied = Vec::new(); + for pack in &mut self.packs { + if reload.load.contains(&pack.id) { + pack.activation = Activation::Active; + if pack.removal.is_none() { + applied.push(pack.id); + } + } else if reload.unload.contains(&pack.id) { + pack.activation = Activation::Inactive; + } + } + for id in applied { + self.report(id, action::SUCCESSFULLY_LOADED); + } + return None; + } + if reload.recovery { + // onFailure(true): nothing of the server's is loaded. + for pack in &mut self.packs { + if pack.activation == Activation::Pending { + pack.activation = Activation::Inactive; + } + } + return None; + } + reload.load.clear(); + for pack in &mut self.packs { + match pack.activation { + Activation::Inactive => pack.remove(Removal::Discarded), + Activation::Pending => { + pack.activation = Activation::Inactive; + pack.remove(Removal::ActivationFailed); + } + Activation::Active => reload.load.push(pack.id), + } + } + reload.recovery = true; + let paths = self.paths(&reload.load); + self.reload = Some(reload); + Some(paths) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use action::*; + + fn ok(id: u128) -> Batch { + Batch { + downloaded: vec![(id, PathBuf::from(format!("/p/{id}")))], + failed: vec![], + } + } + /// Runs the updates as `createUpdateScheduler` does, downloading and + /// reloading with `download` and `reload` as the game would. + fn settle( + sp: &mut ServerPacks, + download: &mut dyn FnMut(&[Request]) -> Batch, + reload: &mut dyn FnMut(&[(u128, PathBuf)]) -> bool, + ) { + let mut rounds = 0; + while sp.wants_tick() { + rounds += 1; + assert!(rounds < 50); + let t = sp.tick(); + if !t.download.is_empty() { + let batch = download(&t.download); + sp.downloaded(batch); + } + if let Some(mut packs) = t.reload { + while let Some(back) = sp.reloaded(reload(&packs)) { + packs = back; + } + } + } + } + + #[test] + fn an_enabled_server_s_pack_is_accepted_downloaded_and_loaded() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + let mut loaded = Vec::new(); + settle(&mut sp, &mut |r| ok(r[0].id), &mut |p| { + loaded = p.to_vec(); + true + }); + assert_eq!( + sp.take_replies(), + [(1, ACCEPTED), (1, DOWNLOADED), (1, SUCCESSFULLY_LOADED)] + ); + assert_eq!(loaded, [(1, PathBuf::from("/p/1"))]); + } + + #[test] + fn the_prompt_holds_packs_until_answered() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Pending); + sp.push(1, "http://a/p.zip", None); + settle(&mut sp, &mut |_| unreachable!(), &mut |_| unreachable!()); + assert!(sp.take_replies().is_empty()); + sp.reject(); + settle(&mut sp, &mut |_| unreachable!(), &mut |_| unreachable!()); + assert_eq!(sp.take_replies(), [(1, DECLINED)]); + // Declined: later pushes are declined at once. + sp.push(2, "http://a/q.zip", None); + assert_eq!(sp.take_replies(), [(2, DECLINED)]); + } + + #[test] + fn a_failed_download_discards_the_rest_of_the_batch() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + sp.push(2, "http://a/dead.zip", None); + settle( + &mut sp, + &mut |_| Batch { + downloaded: vec![(1, PathBuf::from("/p/1"))], + failed: vec![2], + }, + &mut |_| unreachable!(), + ); + assert_eq!( + sp.take_replies(), + [ + (1, ACCEPTED), + (2, ACCEPTED), + (1, DISCARDED), + (2, FAILED_DOWNLOAD) + ] + ); + } + + #[test] + fn a_pack_that_does_not_load_fails_its_reload() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + let mut reloads = Vec::new(); + settle(&mut sp, &mut |r| ok(r[0].id), &mut |p| { + reloads.push(p.to_vec()); + reloads.len() > 1 + }); + assert_eq!( + sp.take_replies(), + [(1, ACCEPTED), (1, DOWNLOADED), (1, FAILED_RELOAD)] + ); + // The recovery reload has none of the server's packs. + assert_eq!(reloads[1], []); + } + + #[test] + fn popping_and_disconnecting_unload_the_packs() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + sp.push(2, "http://a/q.zip", None); + let last = std::cell::RefCell::new(Vec::new()); + let mut reload = |p: &[(u128, PathBuf)]| { + *last.borrow_mut() = p.to_vec(); + true + }; + settle( + &mut sp, + &mut |r| Batch { + downloaded: r + .iter() + .map(|q| (q.id, PathBuf::from(format!("/p/{}", q.id)))) + .collect(), + failed: vec![], + }, + &mut reload, + ); + sp.take_replies(); + sp.pop(1); + settle(&mut sp, &mut |_| unreachable!(), &mut reload); + // Callbacks.onSuccess reports every pack the reload loaded, again. + assert_eq!(sp.take_replies(), [(2, SUCCESSFULLY_LOADED)]); + assert_eq!(*last.borrow(), [(2, PathBuf::from("/p/2"))]); + sp.disconnect(); + settle(&mut sp, &mut |_| unreachable!(), &mut reload); + assert!(last.borrow().is_empty()); + assert!(sp.packs.is_empty()); + } + + #[test] + fn a_pushed_id_replaces_its_pack() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/old.zip", None); + sp.push(1, "http://a/new.zip", None); + let mut urls = Vec::new(); + settle( + &mut sp, + &mut |r| { + urls.extend(r.iter().map(|q| q.url.clone())); + ok(1) + }, + &mut |_| true, + ); + assert_eq!(urls, ["http://a/new.zip"]); + } + + #[test] + fn urls_and_hashes_are_read_as_vanilla_reads_them() { + assert!(valid_url("https://example.com/p.zip")); + assert!(valid_url("HTTP://example.com/p.zip")); + assert!(!valid_url("ftp://example.com/p.zip")); + assert!(!valid_url("example.com/p.zip")); + let sha1 = "0123456789ABCDEF0123456789abcdef01234567"; + assert_eq!(parse_sha1(sha1), Some(sha1.to_ascii_lowercase())); + assert_eq!(parse_sha1("abc"), None); + } +} diff --git a/crates/horizon-client/src/server_packs/download.rs b/crates/horizon-client/src/server_packs/download.rs new file mode 100644 index 000000000..595612df8 --- /dev/null +++ b/crates/horizon-client/src/server_packs/download.rs @@ -0,0 +1,482 @@ +//! Server pack downloads into the game directory's `downloads/` cache, as +//! vanilla keeps it (`DownloadQueue`, `HttpUtil.downloadFile`, +//! `DownloadCacheCleaner`): `downloads//`, one +//! batch at a time on a thread of its own, every download logged in +//! `downloads/log.json`, and the cache cut to its 20 newest files on start. +use super::{Batch, Request}; +use sha1::{Digest, Sha1}; +use std::{ + fs, + io::{self, Read, Write}, + path::{Path, PathBuf}, + sync::mpsc::{Receiver, Sender, channel}, + time::SystemTime, +}; + +/// `DownloadedPackSource`'s MAX_PACK_SIZE_BYTES (250 MiB). +pub const MAX_SIZE: u64 = 262_144_000; +/// `DownloadQueue.MAX_KEPT_PACKS`. +const MAX_KEPT: usize = 20; + +/// `createDownloadHeaders`: who is downloading, with which game. +pub fn headers(name: &str, uuid: u128) -> Vec<(&'static str, String)> { + use horizon_core::version::{RESOURCE_PACK_FORMAT, VANILLA_VERSION, VERSION_ID}; + vec![ + ("X-Minecraft-Username", name.to_owned()), + ("X-Minecraft-UUID", format!("{uuid:032x}")), + ("X-Minecraft-Version", VANILLA_VERSION.to_owned()), + ("X-Minecraft-Version-ID", VERSION_ID.to_owned()), + ( + "X-Minecraft-Pack-Format", + format!("{}.{}", RESOURCE_PACK_FORMAT.0, RESOURCE_PACK_FORMAT.1), + ), + ("User-Agent", format!("Minecraft Java/{VANILLA_VERSION}")), + ] +} + +type Job = (Vec, Vec<(&'static str, String)>); + +/// `DownloadQueue`: batches download in order, on one thread. +pub struct Queue { + jobs: Sender, + done: Receiver, +} +impl Queue { + pub fn open(dir: PathBuf) -> io::Result { + fs::create_dir_all(&dir)?; + vacuum(&dir, MAX_KEPT); + let (jobs, todo) = channel::(); + let (finished, done) = channel(); + std::thread::Builder::new() + .name("download-queue".into()) + .spawn(move || { + for (requests, headers) in todo { + if finished.send(run(&dir, &requests, &headers)).is_err() { + break; + } + } + })?; + Ok(Self { jobs, done }) + } + pub fn download(&self, requests: Vec, headers: Vec<(&'static str, String)>) { + let _ = self.jobs.send((requests, headers)); + } + /// The batches finished since the last call. + pub fn finished(&self) -> Vec { + self.done.try_iter().collect() + } +} + +/// `DownloadQueue.runDownload`: each pack into `//`, logged. +fn run(dir: &Path, requests: &[Request], headers: &[(&'static str, String)]) -> Batch { + let mut batch = Batch::default(); + for request in requests { + let id = horizon_protocol::crypto::uuid_string(request.id); + let result = download_file(&dir.join(&id), request, headers, MAX_SIZE); + // DownloadQueue.LogEntry, its fields in the codec's order. + let mut entry = vec![ + ("id", serde_json::Value::from(id)), + ("url", request.url.as_str().into()), + ( + "time", + chrono::Utc::now() + .to_rfc3339_opts(chrono::SecondsFormat::AutoSi, true) + .into(), + ), + ]; + if let Some(sha1) = &request.sha1 { + entry.push(("hash", sha1.as_str().into())); + } + entry.push(match &result { + Ok(path) => match fs::metadata(path) { + Ok(meta) => { + let name = path.strip_prefix(dir).unwrap_or(path); + let name = name.to_string_lossy().replace('\\', "/"); + ( + "file", + serde_json::json!({"name": name, "size": meta.len()}), + ) + } + Err(_) => ("error", "no_access".into()), + }, + Err(e) => { + log::error!("Horizon: failed to download {}: {e}", request.url); + ("error", "download_failed".into()) + } + }); + if let Err(e) = append_log(&dir.join("log.json"), &entry) { + log::error!("Horizon: failed to log download of {}: {e}", request.url); + } + match result { + Ok(path) => batch.downloaded.push((request.id, path)), + Err(_) => batch.failed.push(request.id), + } + } + batch +} + +/// `JsonEventLog.write`: one JSON object a line, as Gson writes it (with +/// its HTML escaping). +fn append_log(path: &Path, entry: &[(&str, serde_json::Value)]) -> io::Result<()> { + let fields: Vec = entry + .iter() + .map(|(k, v)| format!("{}:{v}", serde_json::Value::from(*k))) + .collect(); + let mut line = String::new(); + for c in format!("{{{}}}", fields.join(",")).chars() { + match c { + '<' | '>' | '&' | '=' | '\'' => line.push_str(&format!("\\u{:04x}", c as u32)), + c => line.push(c), + } + } + line.push('\n'); + fs::OpenOptions::new() + .create(true) + .append(true) + .open(path)? + .write_all(line.as_bytes()) +} + +fn sha1_of(path: &Path) -> io::Result { + let mut hasher = Sha1::new(); + io::copy(&mut fs::File::open(path)?, &mut hasher)?; + Ok(hex(&hasher.finalize())) +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +/// `checkExistingFile`: the file is there with that hash. +fn matches(path: &Path, sha1: &str) -> bool { + path.exists() && sha1_of(path).is_ok_and(|actual| actual == sha1) +} +/// `updateModificationTime`: used now, so the cleaner keeps it longest. +fn touch(path: &Path) { + let _ = fs::File::options() + .append(true) + .open(path) + .and_then(|f| f.set_modified(SystemTime::now())); +} + +/// `HttpUtil.downloadFile`: into `/`. With a hash the cached file +/// is used when it matches, and a download that does not is an error; +/// without one the file is named after the hash of what came. +pub fn download_file( + dir: &Path, + request: &Request, + headers: &[(&'static str, String)], + max_size: u64, +) -> Result { + let target = request.sha1.as_ref().map(|sha1| dir.join(sha1)); + if let (Some(target), Some(sha1)) = (&target, &request.sha1) { + if matches(target, sha1) { + log::info!("Horizon: returning cached file since actual hash matches requested"); + touch(target); + return Ok(target.clone()); + } + if target.exists() { + log::warn!( + "Horizon: existing file {} not found or had mismatched hash", + target.display() + ); + } + fs::remove_file(target) + .or_else(|e| { + if e.kind() == io::ErrorKind::NotFound { + Ok(()) + } else { + Err(e) + } + }) + .map_err(|e| format!("Failed to remove existing file {}: {e}", target.display()))?; + } + let mut call = ureq::AgentBuilder::new().build().get(&request.url); + for (name, value) in headers { + call = call.set(name, value); + } + let response = call.call().map_err(|e| e.to_string())?; + let size = response + .header("Content-Length") + .and_then(|v| v.trim().parse::().ok()); + fs::create_dir_all(dir).map_err(|e| e.to_string())?; + if let Some(size) = size + && size > max_size + { + return Err(format!( + "Filesize is bigger than maximum allowed (file is {size}, limit is {max_size})" + )); + } + let mut input = response.into_reader(); + match (&target, &request.sha1) { + (Some(target), Some(sha1)) => { + let actual = save_hashed(&mut input, target, max_size).map_err(|e| e.to_string())?; + if &actual != sha1 { + return Err(format!( + "Hash of downloaded file ({actual}) did not match requested ({sha1})" + )); + } + Ok(target.clone()) + } + _ => { + let tmp = dir.join(format!("download{:016x}.tmp", rand_suffix())); + let result = save_hashed(&mut input, &tmp, max_size).and_then(|actual| { + let path = dir.join(&actual); + if matches(&path, &actual) { + touch(&path); + } else { + fs::rename(&tmp, &path)?; + } + Ok(path) + }); + let _ = fs::remove_file(&tmp); + result.map_err(|e| e.to_string()) + } + } +} +fn rand_suffix() -> u64 { + use std::hash::{BuildHasher, RandomState}; + RandomState::new().hash_one(std::time::Instant::now()) +} +/// `downloadAndHash`: write what comes, at most `max_size` bytes. +fn save_hashed(input: &mut dyn Read, path: &Path, max_size: u64) -> io::Result { + let mut out = fs::File::create(path)?; + let mut hasher = Sha1::new(); + let mut buffer = [0u8; 8196]; + let mut read_so_far = 0u64; + loop { + let n = input.read(&mut buffer)?; + if n == 0 { + break; + } + read_so_far += n as u64; + if read_so_far > max_size { + return Err(io::Error::other(format!( + "Filesize was bigger than maximum allowed (got >= {read_so_far}, limit was {max_size})" + ))); + } + out.write_all(&buffer[..n])?; + hasher.update(&buffer[..n]); + } + Ok(hex(&hasher.finalize())) +} + +/// `DownloadCacheCleaner.vacuumCacheDir`: keep the `max_files` files most +/// worth keeping (in the pack folders: the newest, and one per pack before a +/// second of any), then drop the folders left empty. +pub fn vacuum(dir: &Path, max_files: usize) { + let mut files = Vec::new(); + let mut stack = vec![dir.to_path_buf()]; + while let Some(d) = stack.pop() { + let Ok(entries) = fs::read_dir(&d) else { + continue; + }; + for e in entries.flatten() { + let path = e.path(); + let Ok(meta) = e.metadata() else { continue }; + if meta.is_dir() { + stack.push(path); + } else if meta.is_file() && path.parent() != Some(dir) { + let time = meta.modified().unwrap_or(SystemTime::UNIX_EPOCH); + files.push((path, time)); + } + } + } + let Some(remove) = files.len().checked_sub(max_files).filter(|n| *n > 0) else { + return; + }; + // Newest first, then each file's rank in its folder (0 for a folder's + // newest), reversed, and stably sorted by rank, highest first. + files.sort_by_key(|f| std::cmp::Reverse(f.1)); + let mut counts = std::collections::HashMap::::new(); + let mut ranked: Vec<(PathBuf, usize)> = files + .into_iter() + .map(|(path, _)| { + let count = counts + .entry(path.parent().unwrap_or(dir).to_path_buf()) + .or_default(); + let rank = *count; + *count += 1; + (path, rank) + }) + .collect(); + ranked.reverse(); + ranked.sort_by_key(|f| std::cmp::Reverse(f.1)); + let mut emptied = std::collections::HashSet::new(); + for (path, rank) in ranked.into_iter().take(remove) { + match fs::remove_file(&path) { + Ok(()) if rank == 0 => { + emptied.insert(path.parent().unwrap_or(dir).to_path_buf()); + } + Ok(()) => {} + Err(e) => log::warn!( + "Horizon: failed to delete cache file {}: {e}", + path.display() + ), + } + } + emptied.remove(dir); + for d in emptied { + let _ = fs::remove_dir(d); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::net::TcpListener; + + /// A one-shot HTTP server answering `status` with `body`; the request it got. + fn serve(status: &str, body: Vec) -> (String, std::thread::JoinHandle) { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let url = format!("http://{}/pack.zip", listener.local_addr().unwrap()); + let status = status.to_owned(); + let handle = std::thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + let mut request = Vec::new(); + let mut buf = [0u8; 1024]; + while !request.ends_with(b"\r\n\r\n") { + let n = stream.read(&mut buf).unwrap(); + request.extend_from_slice(&buf[..n]); + } + let head = format!( + "HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", + body.len() + ); + stream.write_all(head.as_bytes()).unwrap(); + stream.write_all(&body).unwrap(); + String::from_utf8_lossy(&request).into_owned() + }); + (url, handle) + } + fn sha1(bytes: &[u8]) -> String { + hex(&Sha1::digest(bytes)) + } + fn scratch() -> PathBuf { + let dir = std::env::temp_dir().join(format!("horizon-packs-{:016x}", rand_suffix())); + fs::create_dir_all(&dir).unwrap(); + dir + } + + #[test] + fn a_pack_lands_under_its_hash_and_is_reused_from_the_cache() { + let dir = scratch(); + let body = b"PK pack".to_vec(); + let (url, server) = serve("200 OK", body.clone()); + let request = Request { + id: 7, + url, + sha1: Some(sha1(&body)), + }; + let path = download_file(&dir, &request, &headers("Alex", 0xab), MAX_SIZE).unwrap(); + assert_eq!(path, dir.join(sha1(&body))); + assert_eq!(fs::read(&path).unwrap(), body); + let sent = server.join().unwrap(); + assert!(sent.contains("X-Minecraft-Username: Alex"), "{sent}"); + assert!(sent.contains("X-Minecraft-Pack-Format: 97.1"), "{sent}"); + // Cached: no server this time. + let cached = Request { + url: "http://127.0.0.1:9/gone.zip".into(), + ..request + }; + assert_eq!(download_file(&dir, &cached, &[], MAX_SIZE).unwrap(), path); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn a_wrong_hash_a_dead_url_and_a_large_pack_fail() { + let dir = scratch(); + let (url, server) = serve("200 OK", b"other bytes".to_vec()); + let wrong = Request { + id: 1, + url, + sha1: Some("0".repeat(40)), + }; + let err = download_file(&dir, &wrong, &[], MAX_SIZE).unwrap_err(); + assert!(err.contains("did not match requested"), "{err}"); + server.join().unwrap(); + let dead = Request { + id: 2, + url: "http://127.0.0.1:9/pack.zip".into(), + sha1: None, + }; + assert!(download_file(&dir.join("dead"), &dead, &[], MAX_SIZE).is_err()); + assert!(!dir.join("dead").exists()); + let (url, server) = serve("200 OK", vec![0; 100]); + let large = Request { + id: 3, + url, + sha1: None, + }; + let err = download_file(&dir, &large, &[], 10).unwrap_err(); + assert!(err.contains("bigger than maximum"), "{err}"); + let _ = server.join(); + let (url, server) = serve("404 Not Found", Vec::new()); + let missing = Request { + id: 4, + url, + sha1: None, + }; + assert!(download_file(&dir, &missing, &[], MAX_SIZE).is_err()); + server.join().unwrap(); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn the_queue_logs_each_download() { + let dir = scratch(); + let (url, server) = serve("200 OK", b"zip".to_vec()); + let queue = Queue::open(dir.clone()).unwrap(); + let id = 0x5b2c_7a4e_1f3d_4c8b_9a6e_2d4f_8b1c_3e5a; + queue.download( + vec![Request { + id, + url, + sha1: None, + }], + Vec::new(), + ); + let batch = loop { + if let Some(b) = queue.finished().pop() { + break b; + } + std::thread::sleep(std::time::Duration::from_millis(10)); + }; + server.join().unwrap(); + let file = dir + .join("5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a") + .join(sha1(b"zip")); + assert_eq!(batch.downloaded, [(id, file)]); + let log = fs::read_to_string(dir.join("log.json")).unwrap(); + let entry: serde_json::Value = serde_json::from_str(log.trim()).unwrap(); + assert_eq!(entry["id"], "5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a"); + assert_eq!(entry["file"]["size"], 3); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn the_cleaner_keeps_the_newest_file_of_each_pack_longest() { + let dir = scratch(); + let at = |secs| SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(secs); + for (pack, file, time) in [ + ("a", "1", 10), + ("a", "2", 20), + ("a", "3", 30), + ("b", "1", 5), + ] { + fs::create_dir_all(dir.join(pack)).unwrap(); + let path = dir.join(pack).join(file); + fs::write(&path, b"x").unwrap(); + fs::File::options() + .append(true) + .open(&path) + .unwrap() + .set_modified(at(time)) + .unwrap(); + } + fs::write(dir.join("log.json"), b"").unwrap(); + vacuum(&dir, 2); + assert!(dir.join("a/3").exists() && dir.join("b/1").exists()); + assert!(!dir.join("a/1").exists() && !dir.join("a/2").exists()); + assert!(dir.join("log.json").exists()); + fs::remove_dir_all(dir).unwrap(); + } +} diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 15ed1674e..4cad224fd 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -153,7 +153,6 @@ struct MeshSettings { blend_radius: i32, smooth_lighting: bool, cutout_leaves: bool, - cull_leaves: bool, } enum Job { Generate(i32, i32), @@ -258,7 +257,6 @@ pub struct Streaming { /// The `ao` and `cutoutLeaves` options. pub smooth_lighting: bool, pub cutout_leaves: bool, - pub cull_leaves: bool, /// Incremental relighting of block edits on lit chunks (see `light::relight`). light_tables: Arc, /// Applied edits by sequence, replayed onto light jobs snapshotted before them. @@ -500,7 +498,6 @@ impl Streaming { blend_radius: settings.blend_radius, smooth_lighting: settings.smooth_lighting, cutout_leaves: settings.cutout_leaves, - cull_leaves: settings.cull_leaves, assets: &context.assets, render: &context.render, tables: &context.tables, @@ -556,7 +553,6 @@ impl Streaming { biome_blend: 2, smooth_lighting: true, cutout_leaves: true, - cull_leaves: false, light_tables, light_log: Vec::new(), light_edit_sequence: 0, @@ -1177,7 +1173,6 @@ impl Streaming { blend_radius: self.biome_blend, smooth_lighting: self.smooth_lighting, cutout_leaves: self.cutout_leaves, - cull_leaves: self.cull_leaves, }, ), ); diff --git a/crates/horizon-client/tests/streaming_meshes.rs b/crates/horizon-client/tests/streaming_meshes.rs index f0b6fb038..00c233277 100644 --- a/crates/horizon-client/tests/streaming_meshes.rs +++ b/crates/horizon-client/tests/streaming_meshes.rs @@ -215,7 +215,6 @@ fn relit_columns_keep_every_mesh_current() { blend_radius: 2, smooth_lighting: true, cutout_leaves: true, - cull_leaves: false, assets: &context.assets, render: &context.render, tables: &context.tables, diff --git a/crates/horizon-core/src/noise/perlin.rs b/crates/horizon-core/src/noise/perlin.rs index ddcccfe9f..130238c41 100644 --- a/crates/horizon-core/src/noise/perlin.rs +++ b/crates/horizon-core/src/noise/perlin.rs @@ -148,10 +148,11 @@ impl PerlinNoise { y_scale: f64, amplitude: f32, ) -> Result<(), DensityError> { - self.add_volume(buffer, volume, xz_scale, y_scale, amplitude, None) + self.add_volume::(buffer, volume, xz_scale, y_scale, amplitude, None) } - fn add_volume( + /// `BATCH` = false evaluates one Y at a time: the reference the batched loop is tested against. + fn add_volume( &self, buffer: &mut [f32], volume: DensityVolume, @@ -207,7 +208,10 @@ impl PerlinNoise { let mut previous_y = i32::MIN; let mut xz_dots = [0.0_f32; 8]; let mut y_gradients = [0.0_f32; 8]; - for (sample, out) in ys.iter().zip(&mut buffer[index..index + size_y]) { + let column = &mut buffer[index..index + size_y]; + let mut y = 0; + while y < size_y { + let sample = &ys[y]; if previous_y != sample.cell { let gradients = self.gradients_at(p, q, sample.cell, cell_z); for i in 0..8 { @@ -217,11 +221,31 @@ impl PerlinNoise { } previous_y = sample.cell; } + // Four Ys in one cell share the corners: side by side, LLVM computes them + // as vectors. Cell boundaries and the column's tail go one at a time. + if BATCH + && y + 4 <= size_y + && ys[y + 1..y + 4].iter().all(|s| s.cell == sample.cell) + { + add_four( + &mut column[y..y + 4], + &ys[y..y + 4], + xz_dots, + y_gradients, + fade_x, + fade_z, + amplitude, + ); + y += 4; + continue; + } + let out = &mut column[y]; let dy = sample.offset; let values = std::array::from_fn(|i| { xz_dots[i] + y_gradients[i] * (dy - ((i >> 1) & 1) as f32) }); *out += amplitude * lerp3([fade_x, sample.fade, fade_z], values); + y += 1; } index += size_y; } @@ -293,7 +317,7 @@ impl SmearedPerlinNoise { y_scale: f64, amplitude: f32, ) -> Result<(), DensityError> { - self.base.add_volume( + self.base.add_volume::( buffer, volume, xz_scale, @@ -312,3 +336,97 @@ fn compute_fudge_y(input_y: f64, relative_y: f64, scale: f64) -> f64 { }; f64::from(floor_i32(limited_y / scale + f64::from(1e-7_f32))) * scale } + +/// Adds four Y samples of one cell, laid out lane by lane so LLVM vectorizes them (no intrinsics, +/// no target feature). Each lane does the one-at-a-time loop's operations in the same order. +#[inline] +fn add_four( + out: &mut [f32], + ys: &[YSample], + dots: [f32; 8], + gradients: [f32; 8], + fade_x: f32, + fade_z: f32, + amplitude: f32, +) { + let dy: [f32; 4] = std::array::from_fn(|lane| ys[lane].offset); + let fy: [f32; 4] = std::array::from_fn(|lane| ys[lane].fade); + let values: [[f32; 4]; 8] = std::array::from_fn(|i| { + std::array::from_fn(|lane| dots[i] + gradients[i] * (dy[lane] - ((i >> 1) & 1) as f32)) + }); + for lane in 0..4 { + out[lane] += amplitude * lerp3([fade_x, fy[lane], fade_z], values.map(|v| v[lane])); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::random::LegacyRandom; + + #[test] + fn batched_volume_is_bit_identical() { + let scales = [ + 0.0, + -0.0, + 0.001, + -0.001, + 0.125, + -0.5, + 1.0, + 4.0, + 1e100, + f64::INFINITY, + f64::NEG_INFINITY, + f64::NAN, + ]; + let amplitudes = [ + 0.0, + -0.0, + 1.0, + -1.0, + f32::INFINITY, + f32::NEG_INFINITY, + f32::NAN, + f32::from_bits(1), + ]; + for seed in [0, -1, 1234, i64::MIN] { + let noise = PerlinNoise::new(&mut LegacyRandom::new(seed)); + for height in [1, 2, 3, 4, 5, 7, 8, 9, 31, 64, 65, 97] { + for (case, &scale) in scales.iter().enumerate() { + let minimum = [ + [-17, -64, 49], + [i32::MAX, i32::MIN, -16777216], + [16777216, 33554431, -33554432], + ][case % 3]; + let volume = DensityVolume::new( + [2, height, 2], + minimum, + [4, if case % 3 == 0 { i32::MAX } else { 1 }, 16], + ) + .unwrap(); + for fudge in [None, Some(0.125), Some(-0.25), Some(0.0), Some(f64::NAN)] { + let initial = [0.0, -0.0, 1.5, f32::from_bits(1)]; + let mut a: Vec<_> = + (0..volume.size() + 3).map(|i| initial[i % 4]).collect(); + let mut b = a.clone(); + let amplitude = amplitudes[case % amplitudes.len()]; + noise + .add_volume::(&mut a, volume, scale, scale, amplitude, fudge) + .unwrap(); + noise + .add_volume::(&mut b, volume, scale, scale, amplitude, fudge) + .unwrap(); + for (i, (a, b)) in a.iter().zip(&b).enumerate() { + assert_eq!( + a.to_bits(), + b.to_bits(), + "seed={seed} height={height} scale={scale} fudge={fudge:?} index={i}" + ); + } + } + } + } + } + } +} diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 972389a82..9f00a12b1 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -14,19 +14,24 @@ interface log { warn, error, } + /// One line in the game's log as `[mod ] message`, at that level. write: func(level: level, message: string); } /// Capability `game-read`: the local player and the world clock. interface game { record player { + /// Feet position, in blocks. x: f64, y: f64, z: f64, /// Degrees, as F3 shows them. yaw: f32, + /// Degrees: -90 looks straight up, 90 straight down. pitch: f32, + /// Hit points as vanilla counts them: 20 is full health without effects. health: f32, + /// 0 to 20, as the hunger bar. food: u32, /// `minecraft:overworld`, `minecraft:the_nether`, ... dimension: string, @@ -39,6 +44,7 @@ interface game { } /// None on the title screen. get-player: func() -> option; + /// None on the title screen. get-clock: func() -> option; } @@ -58,11 +64,14 @@ interface hud { bottom-right, } record line { + /// Plain text, up to 256 characters. text: string, /// 0xRRGGBB. color: u32, } + /// Replaces the mod's panel: up to 16 lines in that corner of the screen. set-panel: func(corner: corner, lines: list); + /// Removes the mod's panel. clear: func(); } @@ -92,10 +101,13 @@ interface events { } /// Once, after loading. An error keeps the mod off and is shown. init: func() -> result; + /// Each game tick while in a world, with the game's tick counter. tick: func(tick: u64); + /// Each rendered frame, with the seconds since the last one. frame: func(seconds: f32); /// `/name args`: ok(some(text)) is shown as feedback, err(text) in red. command: func(name: string, args: string) -> result, string>; + /// Each chat line the player receives, as plain text. chat: func(text: string); } diff --git a/crates/horizon-mods/Cargo.toml b/crates/horizon-mods/Cargo.toml index 013d38a99..840fc28c5 100644 --- a/crates/horizon-mods/Cargo.toml +++ b/crates/horizon-mods/Cargo.toml @@ -17,6 +17,9 @@ wasmtime = { version = "36.0.18", default-features = false, features = ["runtime # Turns a mod's core module into a component (cargo horizon-mod build, the tests). wit-component = { version = "0.239", optional = true } wit-parser = { version = "0.239", 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 } [features] # Loads and runs mods (the game's `mods` feature); without it only manifests, @@ -24,11 +27,18 @@ wit-parser = { version = "0.239", optional = true } # game's tests and probes) skip wasmtime and cranelift. runtime = ["dep:wasmtime"] 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"] # Runs real mods: `cargo test -p horizon-mods --features runtime,pack`. [[test]] name = "sandbox" required-features = ["runtime", "pack"] +# docs/api/mods-reference.md from the WIT contract (HORIZON_WRITE_DOCS=1 rewrites it). +[[test]] +name = "api_reference" +required-features = ["pack"] + [lints] workspace = true diff --git a/crates/horizon-mods/src/index.rs b/crates/horizon-mods/src/index.rs new file mode 100644 index 000000000..73af7b46d --- /dev/null +++ b/crates/horizon-mods/src/index.rs @@ -0,0 +1,538 @@ +//! The mod registry's index, `index.json` (docs/api/mod-index.md): every +//! reviewed mod and modpack, its versions, the file of each with its size, +//! SHA-256 and minisign signature, and the files taken down. The launcher +//! reads it to browse and install, the website to show it, and the +//! registry's CI writes it. +//! +//! [`check_file`] is what a file must pass before it is installed: its size +//! and hash are the ones the index lists, its signature verifies against the +//! project's pinned key, and what its own manifest says matches the entry. +use crate::{ + Capability, Package, Side, + modpack::{self, Modpack}, +}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use std::{io::Read, path::Path}; + +/// The index format this build reads and writes. A reader refuses a newer +/// one rather than misread it. +pub const SCHEMA: u32 = 1; +/// The biggest file the registry takes (a `.hmod` with content, a `.hpack`). +pub const MAX_FILE: u64 = 64 << 20; +/// Where files may be downloaded from: the registry's release assets. +pub const FILE_HOST: &str = "https://github.com/ludovic111/horizon-mods/releases/download/"; + +#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] +pub struct Index { + pub schema: u32, + /// When CI built it, RFC 3339. + #[serde(default)] + pub generated: String, + #[serde(default)] + pub projects: Vec, + #[serde(default)] + pub revoked: Vec, +} + +/// What a project is. New kinds (data packs, worlds, themes) can be added +/// without a new schema: a reader keeps a kind it doesn't know as +/// [`Kind::Other`] and doesn't offer it. +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(from = "String", into = "String")] +pub enum Kind { + /// A `.hmod`. + Mod, + /// A `.hpack`: registry mods played together as a profile. + 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. + Shader, + Other(String), +} + +impl Kind { + pub fn name(&self) -> &str { + match self { + Kind::Mod => "mod", + Kind::Modpack => "modpack", + Kind::ResourcePack => "resourcepack", + Kind::Shader => "shader", + Kind::Other(name) => name, + } + } + + /// The extension of its files; None for a kind this build doesn't know. + pub fn extension(&self) -> Option<&'static str> { + match self { + Kind::Mod => Some("hmod"), + Kind::Modpack => Some("hpack"), + Kind::ResourcePack | Kind::Shader => Some("zip"), + Kind::Other(_) => None, + } + } +} + +impl From for Kind { + fn from(name: String) -> Kind { + match name.as_str() { + "mod" => Kind::Mod, + "modpack" => Kind::Modpack, + "resourcepack" => Kind::ResourcePack, + "shader" => Kind::Shader, + _ => Kind::Other(name), + } + } +} + +impl From for String { + fn from(kind: Kind) -> String { + kind.name().to_owned() + } +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct Project { + /// The manifest's id, `[a-z0-9_]{1,64}`: unique across the index. + pub id: String, + pub kind: Kind, + pub name: String, + /// One line for lists. + pub summary: String, + /// Markdown, for the project's page. + #[serde(default)] + pub description: String, + #[serde(default)] + pub authors: Vec, + /// The GitHub logins allowed to publish its updates. + #[serde(default)] + pub owners: Vec, + /// An SPDX expression. + pub license: String, + /// Where its source code is, `https://`. + pub source: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub icon: Option, + /// The author's minisign public key: every version must be signed with + /// it. None: unsigned (the SHA-256 still pins the reviewed file). + #[serde(default, skip_serializing_if = "Option::is_none")] + pub key: Option, + /// Newest first. + pub versions: Vec, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct Version { + pub version: String, + /// The day it was published, `YYYY-MM-DD`. + #[serde(default)] + pub published: String, + #[serde(default, skip_serializing_if = "String::is_empty")] + pub changelog: String, + /// A mod's API line (`0.1`), from its manifest; a modpack's format (`1`). + pub api: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub side: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub capabilities: Vec, + /// The Minecraft version it is for. + pub game: String, + /// A modpack's mods, as its manifest lists them. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub requires: Vec, + pub file: File, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub struct Requirement { + pub id: String, + pub version: String, + pub sha256: String, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct File { + pub name: String, + pub url: String, + pub size: u64, + /// Lowercase hex. + pub sha256: String, + /// The `.minisig` file's text. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub signature: Option, +} + +/// A file taken down: by hash, or every version of `id` when `sha256` is +/// None. The launcher refuses to install it and turns installed copies off. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct Revoked { + pub id: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub sha256: Option, + pub reason: String, + #[serde(default)] + pub date: String, +} + +/// How far a checked file is trusted. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Trust { + /// Signed with the project's pinned key. + Verified, + /// The project has no key: only the hash pins it. + Unsigned, +} + +impl Index { + /// Parses and checks an index (see [`Index::check`]). + pub fn parse(text: &str) -> Result { + Self::parse_with(text, false) + } + + /// [`Index::parse`] for a local test registry, whose files may be + /// `file://` paths (trying a registry out before it is published). + pub fn parse_local(text: &str) -> Result { + Self::parse_with(text, true) + } + + fn parse_with(text: &str, local_files: bool) -> Result { + #[derive(Deserialize)] + struct Head { + schema: u32, + } + let head: Head = serde_json::from_str(text).map_err(|e| format!("not a mod index: {e}"))?; + if head.schema > SCHEMA { + return Err(format!( + "the mod index is schema {}; this build reads {SCHEMA}: update Horizon", + head.schema + )); + } + let index: Index = serde_json::from_str(text).map_err(|e| format!("mod index: {e}"))?; + index.check_with(local_files)?; + Ok(index) + } + + /// Every rule a reader relies on: unique valid ids, at least one + /// version each, plain file names with the kind's extension, `https` + /// URLs, hex hashes, keys and signatures that decode, and each + /// modpack's mods present in the index with the same hash. + pub fn check(&self) -> Result<(), String> { + self.check_with(false) + } + + fn check_with(&self, local_files: bool) -> Result<(), String> { + for (i, p) in self.projects.iter().enumerate() { + let at = |e: String| format!("{}: {e}", p.id); + if !valid_id(&p.id) { + return Err(format!("project id {:?} is not [a-z0-9_]{{1,64}}", p.id)); + } + if self.projects[..i].iter().any(|q| q.id == p.id) { + return Err(at("listed twice".into())); + } + if p.name.trim().is_empty() || p.license.trim().is_empty() { + return Err(at("needs a name and a licence".into())); + } + https(&p.source).map_err(at)?; + if let Some(icon) = &p.icon { + https(icon).map_err(at)?; + } + if let Some(key) = &p.key { + minisign_verify::PublicKey::from_base64(key.trim()) + .map_err(|e| at(format!("key: {e}")))?; + } + if p.versions.is_empty() { + return Err(at("has no version".into())); + } + for (j, v) in p.versions.iter().enumerate() { + let at = |e: String| format!("{} {}: {e}", p.id, v.version); + if v.version.trim().is_empty() + || p.versions[..j].iter().any(|w| w.version == v.version) + { + return Err(at("empty or repeated version".into())); + } + let f = &v.file; + let extension_ok = p + .kind + .extension() + .is_none_or(|e| f.name.ends_with(&format!(".{e}"))); + if !plain_name(&f.name) || !extension_ok { + return Err(at(format!( + "{:?} is not a plain file name for a {}", + f.name, + p.kind.name() + ))); + } + if !(local_files && f.url.starts_with("file:///")) { + https(&f.url).map_err(at)?; + } + hex64(&f.sha256).map_err(at)?; + if f.size == 0 || f.size > MAX_FILE { + return Err(at(format!( + "size {} is not 1 byte to {} MiB", + f.size, + MAX_FILE >> 20 + ))); + } + match (&p.key, &f.signature) { + (Some(_), None) => { + return Err(at("unsigned, but the project has a key".into())); + } + (None, Some(_)) => return Err(at("signed, but the project has no key".into())), + (Some(_), Some(sig)) => { + minisign_verify::Signature::decode(sig) + .map_err(|e| at(format!("signature: {e}")))?; + } + (None, None) => {} + } + for r in &v.requires { + let found = self + .project(&r.id) + .and_then(|q| q.versions.iter().find(|w| w.version == r.version)); + match found { + Some(w) if w.file.sha256 == r.sha256 => {} + Some(_) => { + return Err(at(format!( + "{} {}: another file than the index's", + r.id, r.version + ))); + } + None => { + return Err(at(format!( + "needs {} {}, which is not in the index", + r.id, r.version + ))); + } + } + } + } + } + for r in &self.revoked { + if let Some(h) = &r.sha256 { + hex64(h).map_err(|e| format!("revoked {}: {e}", r.id))?; + } + } + Ok(()) + } + + pub fn project(&self, id: &str) -> Option<&Project> { + self.projects.iter().find(|p| p.id == id) + } + + /// Why the file of `id` with this hash was taken down, if it was. + pub fn revoked(&self, id: &str, sha256: &str) -> Option<&Revoked> { + self.revoked.iter().find(|r| { + r.id == id + && r.sha256 + .as_ref() + .is_none_or(|h| h.eq_ignore_ascii_case(sha256)) + }) + } +} + +/// `[a-z0-9_]{1,64}`, the manifests' id rule. +pub fn valid_id(id: &str) -> bool { + (1..=64).contains(&id.len()) + && id + .bytes() + .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_') +} + +fn https(url: &str) -> Result<(), String> { + match url.strip_prefix("https://") { + Some(rest) if !rest.is_empty() && !url.chars().any(char::is_whitespace) => Ok(()), + _ => Err(format!("{url:?} is not an https:// address")), + } +} + +fn hex64(h: &str) -> Result<(), String> { + if h.len() == 64 + && h.bytes() + .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) + { + Ok(()) + } else { + Err(format!("{h:?} is not a lowercase hex SHA-256")) + } +} + +/// One plain file name: no folder, no hidden file, nothing a file system +/// reads as something else. +fn plain_name(name: &str) -> bool { + !name.is_empty() + && name.len() <= 128 + && !name.starts_with('.') + && name + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b"._-+".contains(&b)) +} + +/// The SHA-256 of a file, lowercase hex. +pub fn sha256_file(path: &Path) -> Result { + let mut file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; + let mut hasher = Sha256::new(); + let mut buf = vec![0u8; 1 << 16]; + loop { + let n = file.read(&mut buf).map_err(|e| e.to_string())?; + if n == 0 { + break; + } + hasher.update(&buf[..n]); + } + Ok(hex(&hasher.finalize())) +} + +pub fn sha256(bytes: &[u8]) -> String { + hex(&Sha256::digest(bytes)) +} + +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} + +/// Checks a minisign signature (`.minisig` text) of `path` against `key`. +pub fn verify_signature(key: &str, signature: &str, path: &Path) -> Result<(), String> { + let key = + minisign_verify::PublicKey::from_base64(key.trim()).map_err(|e| format!("key: {e}"))?; + let sig = + minisign_verify::Signature::decode(signature).map_err(|e| format!("signature: {e}"))?; + let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; + let mut verifier = key + .verify_stream(&sig) + .map_err(|e| format!("signature: {e}"))?; + let mut reader = std::io::BufReader::new(file); + let mut buf = vec![0u8; 1 << 16]; + loop { + let n = reader.read(&mut buf).map_err(|e| e.to_string())?; + if n == 0 { + break; + } + verifier.update(&buf[..n]); + } + verifier + .finalize() + .map_err(|_| "the signature doesn't match the project's key".to_string()) +} + +/// Checks the file at `path` against its entry before it is installed: +/// size, SHA-256, revocation, signature, and that its manifest says what the +/// index says (id, version, API, side, capabilities; a modpack's mods). +pub fn check_file( + index: &Index, + project: &Project, + version: &Version, + path: &Path, +) -> Result { + let size = std::fs::metadata(path) + .map_err(|e| format!("{}: {e}", path.display()))? + .len(); + if size != version.file.size { + return Err(format!( + "{} bytes, the index lists {}", + size, version.file.size + )); + } + let hash = sha256_file(path)?; + if hash != version.file.sha256 { + return Err("its SHA-256 isn't the one the index lists: nothing was installed".into()); + } + if let Some(r) = index.revoked(&project.id, &hash) { + return Err(format!("{} was taken down: {}", project.name, r.reason)); + } + let trust = match (&project.key, &version.file.signature) { + (Some(key), Some(sig)) => { + verify_signature(key, sig, path)?; + Trust::Verified + } + (None, None) => Trust::Unsigned, + _ => return Err("its signature and the project's key don't go together".into()), + }; + match project.kind { + Kind::Mod => { + let m = Package::read(path)?.manifest; + crate::Content::read(path, &m)?; + let mut caps = m.capabilities.clone(); + caps.sort(); + let mut listed = version.capabilities.clone(); + listed.sort(); + let differs = m.id != project.id + || m.version != version.version + || m.api != version.api + || Some(m.side) != version.side + || caps != listed; + if differs { + return Err(format!( + "its horizon-mod.toml ({} {}, API {}, {:?}, {}) isn't what the index lists", + m.id, + m.version, + m.api, + m.side, + names(&caps) + )); + } + } + Kind::ResourcePack => check_resource_pack(path)?, + Kind::Shader | Kind::Other(_) => { + return Err(format!( + "this Horizon can't install a {} yet", + project.kind.name() + )); + } + Kind::Modpack => { + let pack = Modpack::read(path)?; + let m = &pack.manifest; + let mods: Vec = m.mods.iter().map(modpack::PackMod::requirement).collect(); + if m.id != project.id + || m.version != version.version + || m.format.to_string() != version.api + || m.game != version.game + || mods != version.requires + { + return Err(format!( + "its {} isn't what the index lists", + modpack::MANIFEST + )); + } + } + } + Ok(trust) +} + +/// A resource pack: a zip with `pack.mcmeta` at its root holding a `pack` +/// object, and only plain paths. +fn check_resource_pack(path: &Path) -> Result<(), String> { + let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; + let mut zip = zip::ZipArchive::new(file).map_err(|e| e.to_string())?; + for i in 0..zip.len() { + let name = zip + .by_index_raw(i) + .map_err(|e| e.to_string())? + .name() + .to_owned(); + if name.starts_with('/') || name.split('/').any(|part| part == "..") || name.contains('\\') + { + return Err(format!("{name:?} is not a plain path")); + } + } + let mut meta = String::new(); + zip.by_name("pack.mcmeta") + .map_err(|_| "pack.mcmeta: missing".to_string())? + .take(1 << 20) + .read_to_string(&mut meta) + .map_err(|e| format!("pack.mcmeta: {e}"))?; + let json: serde_json::Value = + serde_json::from_str(&meta).map_err(|e| format!("pack.mcmeta: {e}"))?; + if !json["pack"].is_object() { + return Err("pack.mcmeta: no \"pack\" object".into()); + } + Ok(()) +} + +fn names(caps: &[Capability]) -> String { + let names: Vec = caps.iter().map(ToString::to_string).collect(); + format!("[{}]", names.join(", ")) +} + +#[cfg(test)] +mod tests; diff --git a/crates/horizon-mods/src/index/tests.rs b/crates/horizon-mods/src/index/tests.rs new file mode 100644 index 000000000..b6d7f5bfb --- /dev/null +++ b/crates/horizon-mods/src/index/tests.rs @@ -0,0 +1,162 @@ +//! 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. +use super::*; +use std::path::PathBuf; + +const OTHER_KEY: &str = "RWSe8ZD+cTOAqNd/jnXTmDtoKp0c0HxkGMrBBWcWQeEkPmcHB+XkaE9S"; + +fn fixtures() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/index") +} + +fn sample() -> Index { + Index::parse(&std::fs::read_to_string(fixtures().join("index-v1.json")).unwrap()).unwrap() +} + +fn check(index: &Index, id: &str, file: &Path) -> Result { + let p = index.project(id).unwrap(); + check_file(index, p, &p.versions[0], file) +} + +#[test] +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())); + let hud = index.project("coords_hud").unwrap(); + assert_eq!( + hud.versions[0].capabilities, + [Capability::GameRead, Capability::Hud, Capability::Chat] + ); + // What CI writes reads back the same. + let again = Index::parse(&serde_json::to_string(&index).unwrap()).unwrap(); + assert_eq!(again, index); +} + +#[test] +fn files_pass_against_their_entries() { + let index = sample(); + let hmod = fixtures().join("coords_hud-0.1.0.hmod"); + 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 world = index.project("skyblock_start").unwrap(); + let e = check_file(&index, world, &world.versions[0], &hpack).unwrap_err(); + assert!(e.contains("bytes"), "{e}"); +} + +#[test] +fn a_changed_file_key_or_manifest_is_refused() { + let index = sample(); + let dir = std::env::temp_dir().join(format!("horizon-index-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let hmod = fixtures().join("coords_hud-0.1.0.hmod"); + let mut bytes = std::fs::read(&hmod).unwrap(); + let last = bytes.len() - 1; + bytes[last] ^= 1; + let tampered = dir.join("coords_hud-0.1.0.hmod"); + std::fs::write(&tampered, &bytes).unwrap(); + let e = check(&index, "coords_hud", &tampered).unwrap_err(); + assert!(e.contains("SHA-256"), "{e}"); + + let mut other_key = index.clone(); + other_key.projects[0].key = Some(OTHER_KEY.into()); + let e = check(&other_key, "coords_hud", &hmod).unwrap_err(); + assert!(e.contains("key"), "{e}"); + + let mut more_caps = index.clone(); + more_caps.projects[0].versions[0].capabilities.pop(); + let e = check(&more_caps, "coords_hud", &hmod).unwrap_err(); + assert!(e.contains("isn't what the index lists"), "{e}"); + + let mut revoked = index.clone(); + revoked.revoked.push(Revoked { + id: "coords_hud".into(), + sha256: None, + reason: "Test.".into(), + date: String::new(), + }); + let e = check(&revoked, "coords_hud", &hmod).unwrap_err(); + assert!(e.contains("taken down: Test."), "{e}"); + std::fs::remove_dir_all(&dir).unwrap(); +} + +#[test] +fn revocations_match_by_hash_or_by_id() { + let index = sample(); + let ones = "1".repeat(64); + assert!(index.revoked("bad_mod", &ones).is_some()); + assert!(index.revoked("bad_mod", &"2".repeat(64)).is_none()); + assert!(index.revoked("coords_hud", &ones).is_none()); +} + +#[test] +fn refuses_broken_indexes() { + let text = std::fs::read_to_string(fixtures().join("index-v1.json")).unwrap(); + let newer = text.replacen("\"schema\": 1", "\"schema\": 2", 1); + assert!(Index::parse(&newer).unwrap_err().contains("schema 2")); + let broken = |edit: &dyn Fn(&mut Index)| { + let mut index = sample(); + edit(&mut index); + index.check().unwrap_err() + }; + let e = broken(&|i| { + let twin = i.projects[0].clone(); + i.projects.push(twin) + }); + assert!(e.contains("listed twice"), "{e}"); + let e = broken(&|i| i.projects[0].versions[0].file.url = "http://example.org/x.hmod".into()); + assert!(e.contains("https"), "{e}"); + // A local test registry may list files on disk; the published one may not. + let local = text.replace( + "https://github.com/ludovic111/horizon-mods/releases/download/coords_hud-0.1.0/", + "file:///tmp/", + ); + assert!(Index::parse(&local).unwrap_err().contains("https")); + assert!(Index::parse_local(&local).is_ok()); + let e = broken(&|i| i.projects[0].versions[0].file.name = "../coords_hud.hmod".into()); + assert!(e.contains("plain file name"), "{e}"); + let e = broken(&|i| i.projects[0].versions[0].file.name = "coords_hud.zip".into()); + assert!(e.contains("plain file name"), "{e}"); + let e = broken(&|i| i.projects[0].versions[0].file.signature = None); + assert!(e.contains("unsigned"), "{e}"); + let e = broken(&|i| i.projects[0].key = Some("not a key".into())); + assert!(e.contains("key"), "{e}"); + let e = broken(&|i| i.projects[1].versions[0].requires[0].version = "9.9".into()); + assert!(e.contains("not in the index"), "{e}"); + let e = broken(&|i| i.projects[1].versions[0].requires[0].sha256 = "2".repeat(64)); + assert!(e.contains("another file"), "{e}"); + let e = broken(&|i| i.projects[0].id = "Coords".into()); + assert!(e.contains("is not"), "{e}"); +} + +#[test] +fn resource_packs_need_a_pack_mcmeta() { + use std::io::Write; + let dir = std::env::temp_dir().join(format!("horizon-index-rp-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let pack = |files: &[(&str, &str)]| { + let path = dir.join("look.zip"); + let mut zip = zip::ZipWriter::new(std::fs::File::create(&path).unwrap()); + for (name, text) in files { + zip.start_file(*name, zip::write::SimpleFileOptions::default()) + .unwrap(); + zip.write_all(text.as_bytes()).unwrap(); + } + zip.finish().unwrap(); + path + }; + let meta = r#"{"pack": {"description": "Look", "min_format": 75, "max_format": 75}}"#; + assert_eq!(check_resource_pack(&pack(&[("pack.mcmeta", meta)])), Ok(())); + let e = check_resource_pack(&pack(&[("assets/x.png", "")])).unwrap_err(); + assert!(e.contains("missing"), "{e}"); + let e = check_resource_pack(&pack(&[("pack.mcmeta", "{}")])).unwrap_err(); + assert!(e.contains("\"pack\""), "{e}"); + let e = check_resource_pack(&pack(&[("pack.mcmeta", meta), ("../x", "")])).unwrap_err(); + assert!(e.contains("plain path"), "{e}"); + std::fs::remove_dir_all(&dir).unwrap(); +} diff --git a/crates/horizon-mods/src/lib.rs b/crates/horizon-mods/src/lib.rs index 5060bf747..17a6c5aa0 100644 --- a/crates/horizon-mods/src/lib.rs +++ b/crates/horizon-mods/src/lib.rs @@ -6,7 +6,10 @@ //! 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 content; +#[cfg(feature = "index")] +pub mod index; pub mod manifest; +pub mod modpack; #[cfg(feature = "runtime")] mod runtime; diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs index a71210883..3a93b2512 100644 --- a/crates/horizon-mods/src/manifest.rs +++ b/crates/horizon-mods/src/manifest.rs @@ -1,5 +1,5 @@ //! `horizon-mod.toml`, a mod's manifest, and the `.hmod` file around it. -use serde::Deserialize; +use serde::{Deserialize, Serialize}; use std::{ fmt, io::Read, @@ -20,6 +20,9 @@ pub const APIS: [&str; 2] = [API, "0.2"]; /// 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"]; +/// A mod's data (capability `storage`), in `horizon-mods/` beside the mods +/// (`find` never mistakes it for a mod: it has no manifest). +pub const STORAGE_DIR: &str = ".horizon-mod-data"; /// The biggest `mod.wasm` a mod may ship. const MAX_WASM: u64 = 32 << 20; @@ -48,7 +51,7 @@ pub struct Manifest { pub namespaces: Vec, } -#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq)] +#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq)] #[serde(rename_all = "lowercase")] pub enum Side { /// Runs in the player's game only (HUD, keys, chat commands). @@ -62,7 +65,7 @@ pub enum Side { /// What a mod may do beyond writing its log. Each is a WIT interface the /// component imports; the player sees them before turning the mod on. -#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)] #[serde(rename_all = "kebab-case")] pub enum Capability { GameRead, diff --git a/crates/horizon-mods/src/modpack.rs b/crates/horizon-mods/src/modpack.rs new file mode 100644 index 000000000..83c9eef5c --- /dev/null +++ b/crates/horizon-mods/src/modpack.rs @@ -0,0 +1,299 @@ +//! `.hpack`, a Horizon modpack (docs/api/mod-index.md): registry mods +//! played together as a profile. A zip holding `horizon-modpack.toml`, which +//! names each mod by id, version and SHA-256 (the files themselves come from +//! the registry), and optionally `overrides/`: settings and resource packs +//! copied into the profile's game folder. +use crate::manifest::STORAGE_DIR; +use serde::Deserialize; +use std::{ + io::Read, + path::{Path, PathBuf}, +}; + +/// The manifest's file name in a `.hpack`. +pub const MANIFEST: &str = "horizon-modpack.toml"; +/// The manifest formats this build reads. +pub const FORMAT: u32 = 1; +const OVERRIDES: &str = "overrides/"; +/// Bytes per override file and in all, unpacked. +const MAX_OVERRIDE: u64 = 64 << 20; +const MAX_OVERRIDES: u64 = 256 << 20; +/// The settings files an override may replace. +const SETTINGS: [&str; 3] = ["options.txt", "horizon-graphics.txt", "horizon-extras.txt"]; + +#[derive(Clone, Debug, Deserialize, PartialEq)] +#[serde(deny_unknown_fields)] +pub struct Manifest { + pub format: u32, + /// `[a-z0-9_]{1,64}`: its profile's folder. + pub id: String, + pub name: String, + pub version: String, + #[serde(default)] + pub description: String, + #[serde(default)] + pub authors: Vec, + /// The Minecraft version it is for. + pub game: String, + #[serde(default)] + pub mods: Vec, +} + +#[derive(Clone, Debug, Deserialize, PartialEq)] +#[serde(deny_unknown_fields)] +pub struct PackMod { + pub id: String, + pub version: String, + pub sha256: String, + /// Turned on in the profile (`horizon-mods.txt`). + #[serde(default = "on")] + pub on: bool, +} + +fn on() -> bool { + true +} + +#[cfg(feature = "index")] +impl PackMod { + pub fn requirement(&self) -> crate::index::Requirement { + crate::index::Requirement { + id: self.id.clone(), + version: self.version.clone(), + sha256: self.sha256.clone(), + } + } +} + +impl Manifest { + pub fn parse(text: &str) -> Result { + let m: Manifest = toml::from_str(text).map_err(|e| format!("{MANIFEST}: {e}"))?; + if m.format != FORMAT { + return Err(format!( + "{MANIFEST}: format {}; this Horizon reads {FORMAT}", + m.format + )); + } + let id_ok = |id: &str| { + (1..=64).contains(&id.len()) + && id + .bytes() + .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_') + }; + if !id_ok(&m.id) { + return Err(format!( + "{MANIFEST}: id {:?} is not [a-z0-9_]{{1,64}}", + m.id + )); + } + for (i, pm) in m.mods.iter().enumerate() { + let hex = pm.sha256.len() == 64 + && pm + .sha256 + .bytes() + .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)); + if !id_ok(&pm.id) || !hex || pm.version.is_empty() { + return Err(format!( + "{MANIFEST}: mod {:?} needs an id, a version and a lowercase hex sha256", + pm.id + )); + } + if m.mods[..i].iter().any(|other| other.id == pm.id) { + return Err(format!("{MANIFEST}: mod {} is listed twice", pm.id)); + } + } + Ok(m) + } +} + +/// A `.hpack` as read from disk: its manifest and its override files, by +/// path under `overrides/`. +#[derive(Debug)] +pub struct Modpack { + pub manifest: Manifest, + pub overrides: Vec, +} + +impl Modpack { + pub fn read(path: &Path) -> Result { + let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; + let mut zip = zip::ZipArchive::new(file).map_err(|e| e.to_string())?; + let mut text = String::new(); + zip.by_name(MANIFEST) + .map_err(|_| format!("{MANIFEST}: missing"))? + .take(1 << 20) + .read_to_string(&mut text) + .map_err(|e| format!("{MANIFEST}: {e}"))?; + let manifest = Manifest::parse(&text)?; + let (mut overrides, mut total) = (Vec::new(), 0u64); + for i in 0..zip.len() { + let entry = zip.by_index_raw(i).map_err(|e| e.to_string())?; + let name = entry.name(); + if name == MANIFEST || entry.is_dir() { + continue; + } + let Some(rest) = name.strip_prefix(OVERRIDES) else { + return Err(format!( + "{name}: a modpack holds only {MANIFEST} and overrides/" + )); + }; + check_override(rest, &manifest)?; + if entry.size() > MAX_OVERRIDE { + return Err(format!("{name} is over {} MiB", MAX_OVERRIDE >> 20)); + } + total += entry.size(); + overrides.push(rest.to_owned()); + } + if total > MAX_OVERRIDES { + return Err(format!("overrides are over {} MiB", MAX_OVERRIDES >> 20)); + } + overrides.sort(); + Ok(Modpack { + manifest, + overrides, + }) + } + + /// Writes the overrides of the pack at `path` into the game folder + /// `home`, each checked again. + pub fn extract_overrides(path: &Path, home: &Path) -> Result, String> { + let pack = Modpack::read(path)?; + let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?; + let mut zip = zip::ZipArchive::new(file).map_err(|e| e.to_string())?; + let mut written = Vec::new(); + for name in &pack.overrides { + let mut entry = zip + .by_name(&format!("{OVERRIDES}{name}")) + .map_err(|e| format!("{name}: {e}"))?; + let target = home.join(name); + if let Some(dir) = target.parent() { + std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?; + } + let mut out = + std::fs::File::create(&target).map_err(|e| format!("{}: {e}", target.display()))?; + std::io::copy(&mut (&mut entry).take(MAX_OVERRIDE), &mut out) + .map_err(|e| format!("{}: {e}", target.display()))?; + written.push(target); + } + Ok(written) + } +} + +/// An override's path under `overrides/`: a settings file, a resource pack +/// zip, or the stored settings of one of the pack's mods. Plain parts only. +fn check_override(path: &str, manifest: &Manifest) -> Result<(), String> { + let bad = || { + format!( + "overrides/{path}: only {}, resourcepacks/.zip and horizon-mods/{STORAGE_DIR}// may be overridden", + SETTINGS.join(", ") + ) + }; + let parts: Vec<&str> = path.split('/').collect(); + let plain = |p: &&str| { + !p.is_empty() + && !p.starts_with('.') + && p.bytes() + .all(|b| b.is_ascii_alphanumeric() || b"._-+ ".contains(&b)) + }; + let ok = match parts.as_slice() { + [file] => SETTINGS.contains(file), + ["resourcepacks", name] => plain(name) && name.ends_with(".zip"), + ["horizon-mods", dir, id, rest @ ..] => { + *dir == STORAGE_DIR + && manifest.mods.iter().any(|m| m.id == *id) + && !rest.is_empty() + && rest.iter().all(plain) + } + _ => false, + }; + if ok { Ok(()) } else { Err(bad()) } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Write; + + const PACK: &str = r#" +format = 1 +id = "cozy" +name = "Cozy" +version = "1.0.0" +game = "26.3" +[[mods]] +id = "coords_hud" +version = "0.1.0" +sha256 = "0000000000000000000000000000000000000000000000000000000000000000" +"#; + + fn write_pack(dir: &Path, manifest: &str, files: &[(&str, &[u8])]) -> PathBuf { + let path = dir.join("cozy.hpack"); + let mut zip = zip::ZipWriter::new(std::fs::File::create(&path).unwrap()); + let options = zip::write::SimpleFileOptions::default(); + zip.start_file(MANIFEST, options).unwrap(); + zip.write_all(manifest.as_bytes()).unwrap(); + for (name, bytes) in files { + zip.start_file(*name, options).unwrap(); + zip.write_all(bytes).unwrap(); + } + zip.finish().unwrap(); + path + } + + fn scratch(name: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("horizon-hpack-{name}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + dir + } + + #[test] + fn reads_a_pack_and_writes_its_overrides() { + let dir = scratch("read"); + let storage = format!("overrides/horizon-mods/{STORAGE_DIR}/coords_hud/corner.txt"); + let path = write_pack( + &dir, + PACK, + &[ + ("overrides/options.txt", b"renderDistance:8\n"), + ("overrides/resourcepacks/Cozy Look.zip", b"zip"), + (&storage, b"top-left"), + ], + ); + let pack = Modpack::read(&path).unwrap(); + assert_eq!(pack.manifest.mods[0].id, "coords_hud"); + assert!(pack.manifest.mods[0].on); + assert_eq!(pack.overrides.len(), 3); + let home = dir.join("home"); + Modpack::extract_overrides(&path, &home).unwrap(); + let options = std::fs::read_to_string(home.join("options.txt")).unwrap(); + assert_eq!(options, "renderDistance:8\n"); + let corner = home.join(format!("horizon-mods/{STORAGE_DIR}/coords_hud/corner.txt")); + assert!(corner.is_file()); + std::fs::remove_dir_all(&dir).unwrap(); + } + + #[test] + fn refuses_what_a_pack_may_not_hold() { + let dir = scratch("refuse"); + for name in [ + "mods/evil.jar", + "overrides/../../.bashrc", + "overrides/horizon-mods/evil.hmod", + "overrides/resourcepacks/../options.txt", + "overrides/servers.dat", + "overrides/horizon-mods/.horizon-mod-data/other_mod/x", + "overrides/resourcepacks/.hidden.zip", + ] { + let path = write_pack(&dir, PACK, &[(name, b"x")]); + assert!(Modpack::read(&path).is_err(), "{name} was accepted"); + } + let twice = format!("{PACK}{}", &PACK[PACK.find("[[mods]]").unwrap()..]); + assert!(Manifest::parse(&twice).unwrap_err().contains("twice")); + let newer = PACK.replace("format = 1", "format = 2"); + assert!(Manifest::parse(&newer).unwrap_err().contains("format 2")); + let short = PACK.replace("0000000000000000", "00"); + assert!(Manifest::parse(&short).is_err()); + std::fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs index 9dd2eb54e..52da641b4 100644 --- a/crates/horizon-mods/src/runtime.rs +++ b/crates/horizon-mods/src/runtime.rs @@ -49,9 +49,6 @@ const STORAGE_MAX_KEYS: usize = 64; /// a cheap-in-fuel loop replacing one key with large payloads needs its own /// cap, separate from the on-disk quota it would otherwise stay under. const STORAGE_WRITE_BUDGET: u64 = 1 << 20; -/// A mod's data, beside its `horizon-mods` folder (`find`'s `path.parent()` -/// never has a manifest there, so `find` never mistakes it for a mod). -const STORAGE_DIR: &str = ".horizon-mod-data"; /// What mods may read of the game, copied once per tick by the game. #[derive(Clone, Debug, Default)] @@ -237,7 +234,7 @@ impl Mods { let data_dir = path .parent() .unwrap_or(Path::new(".")) - .join(STORAGE_DIR) + .join(crate::manifest::STORAGE_DIR) .join(&m.id); let state = State { name: m.name.clone(), diff --git a/crates/horizon-mods/tests/api_reference.rs b/crates/horizon-mods/tests/api_reference.rs new file mode 100644 index 000000000..5e6a0a069 --- /dev/null +++ b/crates/horizon-mods/tests/api_reference.rs @@ -0,0 +1,304 @@ +//! docs/api/mods-reference.md, generated from the WIT contract and the manifest's capabilities, and a test that +//! fails when it is out of date. Update it with: +//! `HORIZON_WRITE_DOCS=1 cargo test -p horizon-mods --features pack --test api_reference`. +use horizon_mods::manifest::{APIS, Capability}; +use std::{fmt::Write, path::Path}; +use wit_parser::{Docs, Function, Handle, Resolve, Type, TypeDefKind, WorldItem}; + +const WIT: &str = "crates/horizon-mod-sdk/wit/horizon.wit"; +const DOC: &str = "docs/api/mods-reference.md"; + +fn root() -> &'static Path { + Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../..")) +} + +/// A doc comment on one line, for a table cell. +fn cell(docs: &Docs) -> String { + let text = docs.contents.as_deref().unwrap_or("").trim(); + text.split_whitespace() + .collect::>() + .join(" ") + .replace('|', "\\|") +} + +/// A type as WIT spells it. +fn ty(resolve: &Resolve, t: &Type) -> String { + let id = match t { + Type::Bool => return "bool".into(), + Type::U8 => return "u8".into(), + Type::U16 => return "u16".into(), + Type::U32 => return "u32".into(), + Type::U64 => return "u64".into(), + Type::S8 => return "s8".into(), + Type::S16 => return "s16".into(), + Type::S32 => return "s32".into(), + Type::S64 => return "s64".into(), + Type::F32 => return "f32".into(), + Type::F64 => return "f64".into(), + Type::Char => return "char".into(), + Type::String => return "string".into(), + Type::ErrorContext => return "error-context".into(), + Type::Id(id) => *id, + }; + match &resolve.types[id].name { + Some(name) => name.clone(), + None => definition(resolve, &resolve.types[id].kind), + } +} + +/// What an anonymous type, or the right-hand side of a `type` alias, spells. +fn definition(resolve: &Resolve, kind: &TypeDefKind) -> String { + let of = |t: &Option| t.as_ref().map_or("_".into(), |t| ty(resolve, t)); + match kind { + TypeDefKind::Option(t) => format!("option<{}>", ty(resolve, t)), + TypeDefKind::List(t) => format!("list<{}>", ty(resolve, t)), + TypeDefKind::FixedSizeList(t, n) => format!("list<{}, {n}>", ty(resolve, t)), + TypeDefKind::Result(r) => match (&r.ok, &r.err) { + (None, None) => "result".into(), + (ok, None) => format!("result<{}>", of(ok)), + (ok, err) => format!("result<{}, {}>", of(ok), of(err)), + }, + TypeDefKind::Tuple(t) => { + let items: Vec<_> = t.types.iter().map(|t| ty(resolve, t)).collect(); + format!("tuple<{}>", items.join(", ")) + } + TypeDefKind::Future(t) => t + .as_ref() + .map_or("future".into(), |t| format!("future<{}>", ty(resolve, t))), + TypeDefKind::Stream(t) => t + .as_ref() + .map_or("stream".into(), |t| format!("stream<{}>", ty(resolve, t))), + TypeDefKind::Handle(Handle::Own(t)) => ty(resolve, &Type::Id(*t)), + TypeDefKind::Handle(Handle::Borrow(t)) => format!("borrow<{}>", ty(resolve, &Type::Id(*t))), + TypeDefKind::Type(t) => ty(resolve, t), + other => panic!( + "{WIT}: an anonymous {} the reference can't spell", + other.as_str() + ), + } +} + +fn signature(resolve: &Resolve, f: &Function) -> String { + let params: Vec<_> = f + .params + .iter() + .map(|(name, t)| format!("{name}: {}", ty(resolve, t))) + .collect(); + let result = f + .result + .as_ref() + .map_or(String::new(), |t| format!(" -> {}", ty(resolve, t))); + format!("func({}){result}", params.join(", ")) +} + +/// Who may use an interface: the capability that grants it, or what it is. +fn access(interface: &str, exported: bool) -> String { + if exported { + return "exported by the mod: the game calls it".into(); + } + if interface == "log" { + return "always granted".into(); + } + match Capability::ALL.iter().find(|c| c.interface() == interface) { + Some(c) => format!("capability `{c}`"), + None => "not granted by any capability".into(), + } +} + +fn markdown() -> String { + let mut resolve = Resolve::new(); + let package = resolve + .push_file(root().join(WIT)) + .expect("the WIT contract parses"); + let package = &resolve.packages[package]; + let name = &package.name; + let mut out = String::new(); + let w = &mut out; + writeln!(w, "").unwrap(); + writeln!(w, "# Mod API reference\n").unwrap(); + writeln!( + w, + "The contract between Horizon and its mods: the WIT package `{name}`, 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: {}.\n", + APIS.map(|a| format!("`{a}`")).join(", ") + ) + .unwrap(); + + writeln!(w, "## Capabilities\n").unwrap(); + writeln!( + w, + "| In `capabilities` | Grants | The player reads \"May …\" |\n| --- | --- | --- |" + ) + .unwrap(); + for c in Capability::ALL { + let grants = if package.interfaces.contains_key(c.interface()) { + format!("[`{0}`](#{0})", c.interface()) + } else { + "data files (`assets/`, `data/`), no interface".into() + }; + writeln!(w, "| `{c}` | {grants} | {} |", c.describe()).unwrap(); + } + + let mut exported = Vec::new(); + for (world_name, &world) in &package.worlds { + let world = &resolve.worlds[world]; + let prefix = format!("{}:{}/", name.namespace, name.name); + let names = |keys: Vec<&wit_parser::WorldKey>| { + keys.into_iter() + .map(|key| { + let full = resolve.name_world_key(key); + let short = full.trim_start_matches(&prefix); + format!("`{}`", short.split('@').next().unwrap_or(short)) + }) + .collect::>() + .join(", ") + }; + writeln!(w, "\n## World `{world_name}`\n").unwrap(); + if world.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&world.docs)).unwrap(); + } + writeln!( + w, + "- Imports (what the game offers): {}", + names(world.imports.keys().collect()) + ) + .unwrap(); + writeln!( + w, + "- Exports (what the mod provides): {}", + names(world.exports.keys().collect()) + ) + .unwrap(); + for item in world.exports.values() { + if let WorldItem::Interface { id, .. } = item { + exported.push(*id); + } + } + } + + for (interface_name, &id) in &package.interfaces { + let interface = &resolve.interfaces[id]; + writeln!(w, "\n## `{interface_name}`\n").unwrap(); + writeln!( + w, + "Access: {}.\n", + access(interface_name, exported.contains(&id)) + ) + .unwrap(); + if interface.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&interface.docs)).unwrap(); + } + for (type_name, &type_id) in &interface.types { + let def = &resolve.types[type_id]; + writeln!(w, "### {} `{type_name}`\n", def.kind.as_str()).unwrap(); + if def.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&def.docs)).unwrap(); + } + match &def.kind { + TypeDefKind::Record(r) => { + writeln!(w, "| Field | Type | |\n| --- | --- | --- |").unwrap(); + for f in &r.fields { + writeln!( + w, + "| `{}` | `{}` | {} |", + f.name, + ty(&resolve, &f.ty), + cell(&f.docs) + ) + .unwrap(); + } + } + TypeDefKind::Enum(e) => { + writeln!(w, "| Case | |\n| --- | --- |").unwrap(); + for c in &e.cases { + writeln!(w, "| `{}` | {} |", c.name, cell(&c.docs)).unwrap(); + } + } + TypeDefKind::Variant(v) => { + writeln!(w, "| Case | Payload | |\n| --- | --- | --- |").unwrap(); + for c in &v.cases { + let payload = + c.ty.as_ref() + .map_or(String::new(), |t| format!("`{}`", ty(&resolve, t))); + writeln!(w, "| `{}` | {payload} | {} |", c.name, cell(&c.docs)).unwrap(); + } + } + TypeDefKind::Flags(f) => { + writeln!(w, "| Flag | |\n| --- | --- |").unwrap(); + for flag in &f.flags { + writeln!(w, "| `{}` | {} |", flag.name, cell(&flag.docs)).unwrap(); + } + } + TypeDefKind::Resource => { + writeln!(w, "A resource: the game owns it, the mod holds a handle.").unwrap() + } + kind => writeln!(w, "`type {type_name} = {}`", definition(&resolve, kind)).unwrap(), + } + writeln!(w).unwrap(); + } + if !interface.functions.is_empty() { + writeln!( + w, + "| Function | Signature | What it does |\n| --- | --- | --- |" + ) + .unwrap(); + for (fn_name, f) in &interface.functions { + writeln!( + w, + "| `{fn_name}` | `{}` | {} |", + signature(&resolve, f), + cell(&f.docs) + ) + .unwrap(); + } + } + } + out +} + +#[test] +fn the_mod_api_reference_is_up_to_date() { + let path = root().join(DOC); + let want = markdown(); + if std::env::var_os("HORIZON_WRITE_DOCS").is_some() { + std::fs::write(&path, &want).unwrap(); + } + let have = std::fs::read_to_string(&path) + .unwrap_or_default() + .replace("\r\n", "\n"); + assert!( + have == want, + "{DOC} is out of date: HORIZON_WRITE_DOCS=1 cargo test -p horizon-mods --features pack --test api_reference" + ); +} + +#[test] +fn every_function_is_documented() { + let mut resolve = Resolve::new(); + resolve.push_file(root().join(WIT)).unwrap(); + for (_, interface) in resolve.interfaces.iter() { + for (name, f) in &interface.functions { + assert!( + f.docs.contents.is_some(), + "{WIT}: `{name}` needs a doc comment: the reference shows it to mod authors" + ); + } + } +} + +#[test] +fn every_capability_with_an_interface_is_in_the_contract() { + let mut resolve = Resolve::new(); + let package = resolve.push_file(root().join(WIT)).unwrap(); + let interfaces = &resolve.packages[package].interfaces; + for c in Capability::ALL { + if c != Capability::Registries { + assert!( + interfaces.contains_key(c.interface()), + "capability {c} grants `{}`, missing from {WIT}", + c.interface() + ); + } + } +} diff --git a/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod b/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod new file mode 100644 index 000000000..1a4a5ba35 Binary files /dev/null and b/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod differ diff --git a/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod.minisig b/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod.minisig new file mode 100644 index 000000000..5f9b17534 --- /dev/null +++ b/crates/horizon-mods/tests/index/coords_hud-0.1.0.hmod.minisig @@ -0,0 +1,4 @@ +untrusted comment: signature from minisign secret key +RUTVtuGb/GRXcIa5yCyCHFGFt55tj3T/FLUDv3ecNLVNNiQqQu7xyBrfc3wsvMHmudsEq6yr+QF21XN3+hnr/Ged3ULr5rv3zgE= +trusted comment: coords_hud 0.1.0 +IESQkJdTzLOvWegcGFxOMrQbnwJp2OKSSxoCKAxdfwyRb+9atdF+Q5/OpbdYurMnrNN1X1ybb43AszPVecdiCw== diff --git a/crates/horizon-mods/tests/index/cozy-1.0.0.hpack b/crates/horizon-mods/tests/index/cozy-1.0.0.hpack new file mode 100644 index 000000000..b25663480 Binary files /dev/null and b/crates/horizon-mods/tests/index/cozy-1.0.0.hpack differ diff --git a/crates/horizon-mods/tests/index/index-v1.json b/crates/horizon-mods/tests/index/index-v1.json new file mode 100644 index 000000000..215c94667 --- /dev/null +++ b/crates/horizon-mods/tests/index/index-v1.json @@ -0,0 +1,109 @@ +{ + "schema": 1, + "generated": "2026-10-24T18:00:00Z", + "projects": [ + { + "id": "coords_hud", + "kind": "mod", + "name": "Coordinates HUD", + "summary": "Your coordinates, facing and the time of day in a corner of the screen.", + "description": "`/where` puts them in chat, `/coords` hides or shows the panel.", + "authors": [ + "Horizon" + ], + "owners": [ + "ludovic111" + ], + "license": "MIT", + "source": "https://github.com/ludovic111/horizon/tree/main/crates/horizon-mod-sdk/examples/coords-hud", + "icon": "https://ludovic111.github.io/horizon-mods/icons/coords_hud.png", + "key": "RWTVtuGb/GRXcBf3Re5hzM07EzoStr2sLTJjghJia0xX15ULoZRFFZDb", + "versions": [ + { + "version": "0.1.0", + "published": "2026-10-24", + "api": "0.1", + "side": "client", + "capabilities": [ + "game-read", + "hud", + "chat" + ], + "game": "26.3", + "file": { + "name": "coords_hud-0.1.0.hmod", + "url": "https://github.com/ludovic111/horizon-mods/releases/download/coords_hud-0.1.0/coords_hud-0.1.0.hmod", + "size": 438, + "sha256": "e1135345692f6dd8fd4c51920151944b82333e17049c9bb7d756f27b8deefc53", + "signature": "untrusted comment: signature from minisign secret key\nRUTVtuGb/GRXcIa5yCyCHFGFt55tj3T/FLUDv3ecNLVNNiQqQu7xyBrfc3wsvMHmudsEq6yr+QF21XN3+hnr/Ged3ULr5rv3zgE=\ntrusted comment: coords_hud 0.1.0\nIESQkJdTzLOvWegcGFxOMrQbnwJp2OKSSxoCKAxdfwyRb+9atdF+Q5/OpbdYurMnrNN1X1ybb43AszPVecdiCw==\n" + } + } + ] + }, + { + "id": "cozy", + "kind": "modpack", + "name": "Cozy", + "summary": "Coordinates and a calm render distance.", + "authors": [ + "Horizon" + ], + "owners": [ + "ludovic111" + ], + "license": "MIT", + "source": "https://github.com/ludovic111/horizon-mods", + "versions": [ + { + "version": "1.0.0", + "published": "2026-10-24", + "api": "1", + "game": "26.3", + "requires": [ + { + "id": "coords_hud", + "version": "0.1.0", + "sha256": "e1135345692f6dd8fd4c51920151944b82333e17049c9bb7d756f27b8deefc53" + } + ], + "file": { + "name": "cozy-1.0.0.hpack", + "url": "https://github.com/ludovic111/horizon-mods/releases/download/cozy-1.0.0/cozy-1.0.0.hpack", + "size": 471, + "sha256": "241ac840f9c5ea3f6252d849da10c90d36cb1da4d6cd8d1d268c2760a353cd65" + } + } + ] + }, + { + "id": "skyblock_start", + "kind": "world", + "name": "Skyblock start", + "summary": "A kind this reader doesn't know yet: kept, not offered.", + "license": "CC0-1.0", + "source": "https://example.org/skyblock", + "future_field": true, + "versions": [ + { + "version": "1", + "api": "1", + "game": "26.3", + "file": { + "name": "skyblock.hworld", + "url": "https://example.org/skyblock.hworld", + "size": 1, + "sha256": "0000000000000000000000000000000000000000000000000000000000000000" + } + } + ] + } + ], + "revoked": [ + { + "id": "bad_mod", + "sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "reason": "Sent chat messages it didn't declare.", + "date": "2026-10-24" + } + ] +} diff --git a/crates/horizon-mods/tests/index/test.pub b/crates/horizon-mods/tests/index/test.pub new file mode 100644 index 000000000..5cb41bd62 --- /dev/null +++ b/crates/horizon-mods/tests/index/test.pub @@ -0,0 +1,2 @@ +untrusted comment: minisign public key 705764FC9BE1B6D5 +RWTVtuGb/GRXcBf3Re5hzM07EzoStr2sLTJjghJia0xX15ULoZRFFZDb diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index 03b5d7dc9..42c0483b4 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -814,7 +814,7 @@ pub fn carry( if kind == "structure" { let path = rel.trim_start_matches("worldgen/structure/"); let structure = format!("{ns}:{}", path.trim_end_matches(".json")); - changed |= crate::worldgen::disables(&structure, &mut v); + changed |= crate::legacy_structure_mods::yung::disables(&structure, &mut v); changed |= crate::worldgen::add_piece_counts(&structure, &mut v, &piece_counts); } @@ -829,9 +829,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::worldgen::modifier(&v, loaded, types)) - { + if let Some((kind, mut added)) = modifier.and_then(|v| { + crate::legacy_structure_mods::lithostitched::modifier(&v, loaded, types) + }) { crate::processors::carry( kind, &mut added, @@ -910,7 +910,7 @@ pub fn carry( } // Entries the mod adds to other structure sets in Java code, for the // structures it has. - for (file, set, entries) in crate::worldgen::code_set_entries(id) { + for (file, set, entries) in crate::legacy_structure_mods::ctov::code_set_entries(id) { let entries: Vec = entries .into_iter() .filter(|(s, _)| { diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs new file mode 100644 index 000000000..af46174ae --- /dev/null +++ b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs @@ -0,0 +1,179 @@ +//! Choice Theorem's Overhauled Village: the entries it adds to other +//! structure sets in Java code, and its `modular_compat` processor. +use crate::processors::{ProcessorData, referenced}; +use serde_json::Value; +use std::collections::{BTreeMap, BTreeSet}; + +/// ChoiceTheorem's Overhauled Village's villages and outposts, which it adds +/// to vanilla's `villages` and `pillager_outposts` sets in Java code +/// (`CTOV.registerstructure`, through lithostitched), with its default +/// config: every village type in three sizes, weighted 10, 4 and 1, and +/// every outpost weighted 1. Vanilla's own entries stay (weight 1 each). +const CTOV_VILLAGES: [&str; 21] = [ + "beach", + "christmas", + "desert", + "desert_oasis", + "dark_forest", + "jungle", + "jungle_tree", + "mesa", + "mesa_fortified", + "mountain", + "mountain_alpine", + "mushroom", + "plains", + "plains_fortified", + "savanna", + "savanna_na", + "snowy_igloo", + "swamp", + "swamp_fortified", + "taiga", + "taiga_fortified", +]; +const CTOV_OUTPOSTS: [&str; 11] = [ + "beach", + "dark_forest", + "desert", + "jungle", + "badlands", + "mountain", + "plains", + "savanna", + "snowy", + "swamp", + "taiga", +]; + +/// The entries a mod adds to other structure sets in Java code, as its +/// default config has them: (file name, set, `[(structure, weight)]`). +/// Lithostitched appends them in the order of a hash map of every modifier +/// in the pack, which carry cannot know; they are written in the order the +/// mod registers them. Each set picks by weight, so how often each starts +/// is the same. +pub(crate) fn code_set_entries( + mod_id: &str, +) -> Vec<(&'static str, &'static str, Vec<(String, u32)>)> { + match mod_id { + "ctov" => { + let outposts = CTOV_OUTPOSTS + .iter() + .map(|v| (format!("ctov:pillager_outpost_{v}"), 1)) + .collect(); + let villages = [("small", 10), ("medium", 4), ("large", 1)] + .into_iter() + .flat_map(|(size, weight)| { + CTOV_VILLAGES + .iter() + .map(move |v| (format!("ctov:{size}/village_{v}"), weight)) + }) + .collect(); + vec![ + ("pillager_outposts", "minecraft:pillager_outposts", outposts), + ("villages", "minecraft:villages", villages), + ] + } + _ => Vec::new(), + } +} + +/// Choice Theorem's Overhauled Village's processor that runs the list +/// `reference` when mod `modid` is loaded (ModularCompatProcessor). +const MODULAR_COMPAT: &str = "ctov:modular_compat"; + +/// Notes which mods its compat processors name are `loaded`. +pub(crate) fn mark_loaded(data: &mut ProcessorData, loaded: &dyn Fn(&str) -> bool) { + fn walk(v: &Value, out: &mut BTreeSet) { + match v { + Value::Object(o) => { + if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT) { + if let Some(id) = o.get("modid").and_then(Value::as_str) { + out.insert(id.to_owned()); + } + } + o.values().for_each(|v| walk(v, out)); + } + Value::Array(a) => a.iter().for_each(|v| walk(v, out)), + _ => {} + } + } + let mut named = BTreeSet::new(); + data.lists.values().for_each(|l| walk(l, &mut named)); + data.compat_loaded = named.into_iter().filter(|m| loaded(m)).collect(); +} + +/// A `ctov:modular_compat` processor in a list being carried, at `depth` +/// (see [`super::lithostitched`]'s references): counted in `carried`, and +/// the processors of the list it names when its mod is loaded, else none. +/// `None` for any other processor, or past the depth limit. +pub(super) fn modular_compat( + p: &Value, + data: &ProcessorData, + carried: &mut BTreeMap, + depth: usize, +) -> Option> { + if p["processor_type"] != MODULAR_COMPAT || depth >= 8 { + return None; + } + *carried.entry(MODULAR_COMPAT.into()).or_default() += 1; + let loaded = p["modid"] + .as_str() + .is_some_and(|m| data.compat_loaded.contains(m)); + Some( + loaded + .then(|| referenced(&p["reference"], data)) + .flatten() + .unwrap_or_default(), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::processors::carry; + use serde_json::json; + + #[test] + fn ctov_joins_vanillas_villages_and_outposts() { + let sets = code_set_entries("ctov"); + let (file, set, outposts) = &sets[0]; + assert_eq!( + (*file, *set), + ("pillager_outposts", "minecraft:pillager_outposts") + ); + assert_eq!(outposts.len(), 11); + assert!(outposts.iter().all(|(_, w)| *w == 1)); + let (_, set, villages) = &sets[1]; + assert_eq!(*set, "minecraft:villages"); + assert_eq!(villages.len(), 63); + assert_eq!(villages[0], ("ctov:small/village_beach".into(), 10)); + assert_eq!(villages[21], ("ctov:medium/village_beach".into(), 4)); + assert_eq!( + villages[62], + ("ctov:large/village_taiga_fortified".into(), 1) + ); + assert!(code_set_entries("mvs").is_empty()); + } + + #[test] + fn modular_compat_runs_its_list_only_with_its_mod() { + let mut data = ProcessorData::default(); + let swap = json!({"processor_type": "minecraft:rule", "rules": []}); + data.lists + .insert("v:house_ns".into(), json!({"processors": [swap.clone()]})); + let compat = |m: &str| json!({"processor_type": "ctov:modular_compat", "modid": m, "reference": "v:house_ns"}); + let gravity = json!({"processor_type": "minecraft:gravity"}); + data.lists.insert( + "v:house".into(), + json!({"processors": [compat("ns"), compat("absent"), gravity.clone()]}), + ); + data.mark_loaded(&|m| m == "ns"); + assert_eq!(data.compat_loaded, BTreeSet::from(["ns".to_owned()])); + let mut v = json!({"processors": [compat("ns"), compat("absent"), gravity.clone()]}); + let mut carried = BTreeMap::new(); + assert!(carry("processor_list", &mut v, &data, &mut carried)); + assert_eq!(v, json!({"processors": [swap, gravity]})); + assert_eq!(carried["ctov:modular_compat"], 2); + } +} diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs b/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs new file mode 100644 index 000000000..54415a76a --- /dev/null +++ b/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs @@ -0,0 +1,503 @@ +//! 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 new file mode 100644 index 000000000..49db376bc --- /dev/null +++ b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs @@ -0,0 +1,32 @@ +//! The conversion of three families of structure mods' data, kept apart from +//! the general conversion code (`worldgen`, `processors`, `carry`): +//! +//! - [`yung`]: YUNG's API and the mods built on it (Better Dungeons, Desert +//! Temples, Jungle Temples, Witch Huts, Ocean Monuments, Strongholds, +//! Fortresses, Mineshafts), written under `horizon:yungsapi` and the other +//! keys `horizon_world::worldgen::structure::yung` reads. +//! - [`lithostitched`]: Lithostitched's jigsaw, worldgen modifiers and +//! processors. +//! - [`ctov`]: Choice Theorem's Overhauled Village's code-registered set +//! entries and its modular compat processor. +//! +//! 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. +pub(crate) mod ctov; +pub(crate) mod lithostitched; +pub(crate) mod yung; + +#[cfg(test)] +fn data() -> crate::processors::ProcessorData { + let mut d = crate::processors::ProcessorData::default(); + d.spawners.insert( + "repurposed_structures:dungeons/badlands".into(), + vec![ + ("minecraft:husk".into(), 10.), + ("minecraft:cave_spider".into(), 3.), + ], + ); + d.replace_vanilla.insert(("mvs".into(), "village".into())); + d +} diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/yung.rs b/crates/horizon-port-pack/src/legacy_structure_mods/yung.rs new file mode 100644 index 000000000..26dd25923 --- /dev/null +++ b/crates/horizon-port-pack/src/legacy_structure_mods/yung.rs @@ -0,0 +1,1055 @@ +//! YUNG's API and the mods built on it: structures, placements, pool +//! elements and processors. +use crate::worldgen::{ENHANCED_TERRAIN, HORIZON_ENHANCED_TERRAIN, moogs_terrain, placement_rules}; +use serde_json::{Value, json}; +use std::collections::BTreeMap; + +/// YUNG's placements: vanilla's random spread with an enhanced exclusion +/// zone (several sets), plus, for the temples, no start near an ocean or a +/// river, and for strongholds, starts only in odd rings around the origin. +const YUNG_SPREADS: [&str; 4] = [ + "yungsapi:enhanced_random_spread", + "betterdeserttemples:desert_temple", + "betterjungletemples:jungle_temple", + "betterstrongholds:stronghold", +]; +/// YUNG's structures and the vanilla structure type each one's mod turns +/// off (its DisableVanilla*Mixin, on by default in each mod's config). +const YUNG_REPLACES: [(&str, &str); 7] = [ + ( + "betterdeserttemples:desert_temple", + "minecraft:desert_pyramid", + ), + ( + "betterjungletemples:jungle_temple", + "minecraft:jungle_temple", + ), + ("betterwitchhuts:witch_hut", "minecraft:swamp_hut"), + ( + "betteroceanmonuments:ocean_monument", + "minecraft:ocean_monument", + ), + ("betterstrongholds:stronghold", "minecraft:stronghold"), + ("betterfortresses:fortress", "minecraft:fortress"), + ("bettermineshafts:mineshaft_", "minecraft:mineshaft"), +]; + +/// A `structure` or `structure_set` file of YUNG's types as vanilla's: its +/// jigsaw, and its placements. `None` for any other file. +pub(crate) fn upgrade( + kind: &str, + v: &mut Value, + set_tags: &BTreeMap>, + lost: &mut BTreeMap, +) -> Option { + match kind { + "structure" => match v["type"].as_str() { + // Better Dungeons' small Nether dungeon is YUNG's jigsaw behind a + // config switch that ships on. + Some("yungsapi:yung_jigsaw" | "betterdungeons:small_nether_dungeon") => { + yung_structure(v, lost); + Some(true) + } + _ => None, + }, + "structure_set" => match v["placement"]["type"].as_str() { + Some(t) if YUNG_SPREADS.contains(&t) => { + let t = t.to_owned(); + yung_placement(&t, &mut v["placement"], set_tags, lost); + Some(true) + } + _ => None, + }, + _ => None, + } +} + +/// A pool element of YUNG's type as vanilla's; whether it was one. +pub(crate) fn upgrade_pool_element( + element: &mut Value, + lost: &mut BTreeMap, +) -> bool { + if element["element_type"] != "yungsapi:yung_single_element" { + return false; + } + yung_element(element, lost); + true +} + +/// YUNG's API's jigsaw as vanilla's, laid out by its own assembler in the +/// game (`horizon:yungsapi`, `horizon_world::worldgen::structure::yung`): +/// the heights pieces stay within move under the key, its terrain +/// adaptation under `horizon:enhanced_terrain_adaptation`. A start offset in +/// the chunk is lost. +fn yung_structure(v: &mut Value, lost: &mut BTreeMap) { + let Some(o) = v.as_object_mut() else { + return; + }; + o.insert("type".into(), "minecraft:jigsaw".into()); + let mut rules = serde_json::Map::new(); + for key in ["min_y", "max_y"] { + if let Some(y) = o.remove(key) { + rules.insert(key.into(), y); + } + } + // YungJigsawStructure's adaptation (NONE by default): every piece's + // junctions, and the start's box grown by its radius. + let own = o.remove(ENHANCED_TERRAIN); + let mut kernel = yung_terrain(own.as_ref().unwrap_or(&Value::Null), lost); + kernel["rigid_junctions"] = true.into(); + kernel["inflate"] = true.into(); + o.insert(HORIZON_ENHANCED_TERRAIN.into(), kernel); + for key in ["x_offset_in_chunk", "z_offset_in_chunk"] { + if o.remove(key).is_some_and(|n| n != 0) { + *lost.entry(key.into()).or_default() += 1; + } + } + o.insert("horizon:yungsapi".into(), rules.into()); +} + +/// YUNG's single pool element as vanilla's, its rules under +/// `horizon:yungsapi`: name and `max_count`, depth range, priority, +/// `ignore_bounds`, its condition, dead-end pool and modifiers; its terrain +/// adaptation under `horizon:enhanced_terrain_adaptation`. +fn yung_element(element: &mut Value, lost: &mut BTreeMap) { + let Some(o) = element.as_object_mut() else { + return; + }; + o.insert( + "element_type".into(), + "minecraft:single_pool_element".into(), + ); + let mut rules = serde_json::Map::new(); + for (from, to) in [ + ("name", "name"), + ("max_count", "max_count"), + ("min_required_depth", "min_depth"), + ("max_possible_depth", "max_depth"), + ("is_priority", "priority"), + ("ignore_bounds", "ignore_bounds"), + ] { + if let Some(x) = o.remove(from) { + rules.insert(to.into(), x); + } + } + if let Some(c) = o.remove("condition") { + rules.insert("condition".into(), yung_condition(&c, lost)); + } + // A piece's own adaptation, NONE included, replaces its structure's. + if let Some(a) = o.remove(ENHANCED_TERRAIN) { + o.insert(HORIZON_ENHANCED_TERRAIN.into(), yung_terrain(&a, lost)); + } + if let Some(pool) = o.remove("deadend_pool").filter(Value::is_string) { + rules.insert("deadend_pool".into(), pool); + } + let modifiers: Vec = o + .remove("modifiers") + .and_then(|m| m.as_array().cloned()) + .unwrap_or_default() + .iter() + .filter_map(|m| yung_modifier(m, lost)) + .collect(); + if !modifiers.is_empty() { + rules.insert("modifiers".into(), modifiers.into()); + } + o.insert("horizon:yungsapi".into(), rules.into()); +} + +/// One of YUNG's structure modifiers in the game's terms: its condition and +/// its transform and delay_generation actions, on the piece itself (`self`, +/// the API's only target). Another target loses the modifier, another action +/// just that action. +fn yung_modifier(m: &Value, lost: &mut BTreeMap) -> Option { + let target = m["target_selector"]["type"].as_str().unwrap_or_default(); + if target != "yungsapi:self" { + *lost + .entry(format!("yungsapi modifier target {target}")) + .or_default() += 1; + return None; + } + let mut actions = Vec::new(); + for a in m["actions"].as_array().into_iter().flatten() { + let int = |k: &str| a[k].as_i64().unwrap_or(0); + match a["type"].as_str().unwrap_or_default() { + "yungsapi:transform" => actions.push(serde_json::json!({"type": "transform", + "output": a["output"].clone(), + "offset": [int("x_offset"), int("y_offset"), int("z_offset")]})), + "yungsapi:delay_generation" => { + actions.push(serde_json::json!({"type": "delay_generation"})) + } + other => { + *lost + .entry(format!("yungsapi modifier action {other}")) + .or_default() += 1 + } + } + } + let condition = match m.get("condition") { + Some(c) => yung_condition(c, lost), + None => serde_json::json!({"type": "true"}), + }; + Some(serde_json::json!({"condition": condition, "actions": actions})) +} + +/// YUNG's API's terrain adaptation as the game's kernel: its two presets +/// spelled out, NONE (also the default) as size 0. An aquifer override +/// (none of ATM10's) is lost. +fn yung_terrain(a: &Value, lost: &mut BTreeMap) -> Value { + let kernel = |size: i32, distance: i32, top: &str, bottom: &str| { + serde_json::json!({"kernel_size": size, "kernel_distance": distance, + "top": top, "bottom": bottom}) + }; + match a["type"].as_str() { + Some("yungsapi:carved_top_no_beard_large") => kernel(24, 16, "carve", "none"), + Some("yungsapi:carved_top_no_beard_small") => kernel(12, 6, "carve", "none"), + Some("yungsapi:custom") => { + let mut out = serde_json::Map::new(); + for key in [ + "kernel_size", + "kernel_distance", + "top", + "bottom", + "bottom_offset", + "padding", + ] { + if let Some(x) = a.get(key) { + out.insert(key.into(), x.clone()); + } + } + if a.get("aquifer_override") + .is_some_and(|x| x["type"] != "yungsapi:none") + { + *lost.entry("yungsapi aquifer_override".into()).or_default() += 1; + } + moogs_terrain(&out.into(), lost).unwrap_or_else(|| kernel(0, 0, "none", "none")) + } + None | Some("yungsapi:none") => kernel(0, 0, "none", "none"), + Some(other) => { + *lost + .entry(format!("yungsapi terrain adaptation {other}")) + .or_default() += 1; + kernel(0, 0, "none", "none") + } + } +} + +/// One of YUNG's structure conditions in the game's terms. `mod_loaded` +/// holds for Minecraft alone: a mod that needs code is not ported, and the +/// pieces it guards would place its blocks. A condition the game does not +/// have does not hold, and is counted. +fn yung_condition(c: &Value, lost: &mut BTreeMap) -> Value { + let t = c["type"].as_str().unwrap_or_default(); + let list = |lost: &mut BTreeMap| -> Value { + let all = c["conditions"].as_array().into_iter().flatten(); + all.map(|x| yung_condition(x, lost)) + .collect::>() + .into() + }; + let opt = |k: &str| c.get(k).cloned().unwrap_or(Value::Null); + match t.trim_start_matches("yungsapi:") { + "always_true" => serde_json::json!({"type": "true"}), + "not" => { + serde_json::json!({"type": "not", "condition": yung_condition(&c["condition"], lost)}) + } + "all_of" => serde_json::json!({"type": "all_of", "conditions": list(lost)}), + "any_of" => serde_json::json!({"type": "any_of", "conditions": list(lost)}), + "depth" => serde_json::json!({"type": "depth", + "min_depth": opt("min_required_depth"), "max_depth": opt("max_possible_depth")}), + "altitude" => serde_json::json!({"type": "altitude", + "bottom": opt("bottom_cutoff_y"), "top": opt("top_cutoff_y")}), + "random_chance" => serde_json::json!({"type": "random_chance", "chance": opt("chance")}), + "rotation" => serde_json::json!({"type": "rotation", "rotations": opt("rotations")}), + "piece_in_horizontal_direction" => { + // "yungsapi:all" (or no list) matches any piece. + let pieces: Vec = c["pieces"].as_array().cloned().unwrap_or_default(); + let any = pieces.is_empty() || pieces.iter().any(|p| p == "yungsapi:all"); + serde_json::json!({"type": "piece_in_horizontal_direction", + "pieces": if any { Vec::new() } else { pieces }, + "range": opt("range"), "rotation": opt("rotation")}) + } + // The game reads "yungsapi:all" (or no list) as any piece. + "piece_in_range" => serde_json::json!({"type": "piece_in_range", + "pieces": c.get("pieces").cloned().unwrap_or_else(|| Vec::::new().into()), + "horizontal_range": opt("horizontal_range"), "above_range": opt("above_range"), + "below_range": opt("below_range")}), + "mod_loaded" if c["modid"] == "minecraft" => serde_json::json!({"type": "true"}), + "mod_loaded" => serde_json::json!({"type": "false"}), + _ => { + *lost.entry(format!("yungsapi condition {t}")).or_default() += 1; + serde_json::json!({"type": "false"}) + } + } +} + +/// One of YUNG's placements as vanilla's random spread with `horizon:` keys: +/// the enhanced exclusion zone as `horizon:exclusion_zone`; the temples' +/// ocean and river search (findBiomeHorizontal around the chunk's middle +/// block at y 120, 48 blocks, every 2 quarts) as `horizon:avoid_biomes`; the +/// strongholds' rings as `horizon:ring_sections`. +fn yung_placement( + t: &str, + p: &mut Value, + set_tags: &BTreeMap>, + lost: &mut BTreeMap, +) { + placement_rules(p, set_tags, lost); + p["type"] = "minecraft:random_spread".into(); + let Some(o) = p.as_object_mut() else { + return; + }; + match t { + "betterdeserttemples:desert_temple" | "betterjungletemples:jungle_temple" => { + o.insert( + "horizon:avoid_biomes".into(), + serde_json::json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"], + "radius": 48, "step": 2, "y": 120}), + ); + } + "betterstrongholds:stronghold" => { + let mut rings = serde_json::Map::new(); + for (from, to) in [ + ("chunk_distance_to_first_ring", "distance_to_first_ring"), + ("ring_chunk_thickness", "thickness"), + ("max_ring_section", "max_section"), + ] { + if let Some(n) = o.remove(from) { + rings.insert(to.into(), n); + } + } + o.insert("horizon:ring_sections".into(), rings.into()); + } + _ => {} + } +} + +/// Marks a YUNG's structure that the game can start (its type is vanilla's +/// after the upgrade) with the vanilla type its mod turns off, under +/// `horizon:disables`. One the game cannot start leaves the vanilla +/// structure in place, so the world keeps one of the two. +pub(crate) fn disables(id: &str, v: &mut Value) -> bool { + let Some((_, vanilla)) = YUNG_REPLACES.iter().find(|(s, _)| id.starts_with(s)) else { + return false; + }; + if !v["type"] + .as_str() + .is_some_and(|t| t.starts_with("minecraft:")) + { + return false; + } + v["horizon:disables"] = serde_json::json!([vanilla]); + true +} + +/// The game's type for the YUNG's processors that place blocks past their +/// template, which keep their fields (`horizon-world`'s `pillars.rs`). +pub(crate) fn pillar_type(kind: &str) -> Option<&'static str> { + Some(match kind { + "betterfortresses:pillar_processor" | "betterjungletemples:pillar_processor" => { + "horizon:yung_pillar" + } + _ => return None, + }) +} + +/// The data form of one of YUNG's processors: the processors to put in its +/// place, or `None` when it has none (or is not YUNG's). +pub(crate) fn processor(kind: &str, p: &Value) -> Option> { + let (ns, _) = kind.split_once(':')?; + Some(match kind { + // Better Fortresses' stair supports get the blocks its Java code + // names. + "betterfortresses:stair_pillar_processor" => { + vec![json!({"processor_type": "horizon:stair_pillar", + "blocks": {"minecraft:stone_brick_stairs": "minecraft:red_nether_brick_stairs", + "minecraft:purpur_stairs": "minecraft:red_nether_bricks"}, + "front": "minecraft:red_nether_brick_stairs", + "pillar": "minecraft:red_nether_bricks"})] + } + _ if ns == "betterdeserttemples" + && let Some(processor) = desert_temple(kind) => + { + vec![processor] + } + "betterdungeons:small_dungeon_chest_processor" => { + // Its config's defaults: one chest at least, two at most, a + // fifth of the others kept until then; ChestBlock covers both. + vec![json!({"processor_type": "horizon:count_cap", + "blocks": ["minecraft:chest", "minecraft:trapped_chest"], + "min": 1, "max": 2, "chance": 0.2f32 as f64, + "replacement": block("minecraft:cave_air")})] + } + "betterwitchhuts:leg_processor" => vec![yung_leg( + "minecraft:brown_stained_glass", + json!({"id": "minecraft:oak_log", "properties": {"axis": "y"}}), + false, + )], + "betterwitchhuts:fence_leg_processor" => vec![yung_leg( + "minecraft:crimson_fence", + block("minecraft:oak_fence"), + true, + )], + _ if ns == "betteroceanmonuments" => ocean_monument(kind)?, + _ if ns == "betterdungeons" || ns == "betterdeserttemples" => vec![yung_spawner(kind, p)?], + _ => return None, + }) +} + +/// YUNG's leg processors (Better Ocean Monuments, Better Witch Huts): a +/// placeholder block becomes `state` and a column of it runs down through +/// air and fluids: the game's `horizon:yung_pillar` with fixed states, and +/// the placeholder's properties kept for the fence legs. +fn yung_leg(target: &str, state: Value, keep_properties: bool) -> Value { + let fixed = json!({"entries": [], "defaultBlockState": state}); + json!({"processor_type": "horizon:yung_pillar", "target_block": block(target), + "target_block_output": fixed, "pillar_states": fixed, + "keep_properties": keep_properties}) +} + +/// Better Ocean Monuments' processors (no fields; what they do is in their +/// Java code): placeholder blocks as vanilla's `rule` or the game's +/// `horizon:pick` (a new `nextFloat` for each chance, as the mod draws), +/// and its sea-level ones as the game's `horizon:flood_air`, +/// `horizon:waterlog` and `horizon:keep_world_block`. +fn ocean_monument(kind: &str) -> Option> { + let rule = |rules: &[(&str, Value)]| { + let rules: Vec = rules + .iter() + .map(|(from, to)| { + json!({"input_predicate": {"predicate_type": "minecraft:block_match", "block": from}, + "location_predicate": {"predicate_type": "minecraft:always_true"}, + "output_state": to}) + }) + .collect(); + json!({"processor_type": "minecraft:rule", "rules": rules}) + }; + let state = |id: &str, props: Value| json!({"id": id, "properties": props}); + let pick = |from: &str, picks: Vec<(f32, Value)>, default: Value, keep: bool| { + let picks: Vec = picks + .into_iter() + .map(|(below, state)| json!({"below": below as f64, "state": state})) + .collect(); + json!({"processor_type": "horizon:pick", "block": from, "picks": picks, + "default": {"state": default}, "redraw": true, "keep_properties": keep}) + }; + let slabs = |from: &str, slab: &str, otherwise: &str| { + let wet = |t: &str| state(slab, json!({"type": t, "waterlogged": "true"})); + pick( + from, + vec![(0.4, wet("top")), (0.8, wet("bottom"))], + block(otherwise), + false, + ) + }; + // Exposed below 0.1, else weathered below a new 0.3, else oxidized, + // with the placeholder's properties for the stairs and slabs. + let copper = |kind: &str| { + let id = |age: &str| block(&format!("minecraft:{age}{kind}")); + pick( + &format!("minecraft:oxidized_{kind}"), + vec![(0.1, id("exposed_")), (0.3, id("weathered_"))], + id("oxidized_"), + true, + ) + }; + Some(match kind.strip_prefix("betteroceanmonuments:")? { + "random_prismarine_slab_decoration_processor" => vec![slabs( + "minecraft:lime_concrete", + "minecraft:prismarine_slab", + "minecraft:air", + )], + "random_dark_prismarine_slab_decoration_processor" => vec![slabs( + "minecraft:blue_concrete", + "minecraft:dark_prismarine_slab", + "minecraft:water", + )], + "sand_gravel_processor" => { + vec![rule(&[( + "minecraft:yellow_stained_glass", + block("minecraft:gravel"), + )])] + } + "random_oxidization_processor" => [ + "copper", + "cut_copper", + "cut_copper_stairs", + "cut_copper_slab", + ] + .into_iter() + .map(copper) + .collect(), + "structure_void_processor" => vec![json!({"processor_type": "horizon:keep_world_block", + "blocks": ["minecraft:purpur_slab", "minecraft:brown_wool"]})], + "air_processor" => vec![json!({"processor_type": "horizon:flood_air"})], + "waterlog_processor" => vec![json!({"processor_type": "horizon:waterlog"})], + "seagrass_processor" => vec![rule(&[ + ( + "minecraft:red_sandstone_slab", + state("minecraft:tall_seagrass", json!({"half": "lower"})), + ), + ( + "minecraft:end_stone_brick_slab", + state("minecraft:tall_seagrass", json!({"half": "upper"})), + ), + ("minecraft:brick_slab", block("minecraft:seagrass")), + ])], + "random_sponge_processor" => vec![pick( + "minecraft:orange_stained_glass", + vec![(0.75, block("minecraft:wet_sponge"))], + block("minecraft:water"), + false, + )], + "leg_processor" => vec![yung_leg( + "minecraft:blue_stained_glass", + block("minecraft:prismarine_bricks"), + false, + )], + _ => return None, + }) +} + +/// A block state as 26.3 writes it. +fn block(id: &str) -> Value { + json!({"id": id}) +} + +/// Better Desert Temples' placeholder blocks (glass, concrete and wool in +/// the templates) as the mod's processors turn them: the fixed ones as +/// vanilla's `rule`, the random ones as the game's `horizon:pick`, with the +/// mod's bounds on one `nextFloat` (YUNG's BlockStateRandomizer adds its +/// chances up in floats). The ones that read or change the world around +/// (pillars, Diorite's waterlogging) stay dropped. +fn desert_temple(kind: &str) -> Option { + let swap = |from: &str, to: &str| { + json!({"processor_type": "minecraft:rule", "rules": [{ + "input_predicate": {"predicate_type": "minecraft:block_match", "block": from}, + "location_predicate": {"predicate_type": "minecraft:always_true"}, + "output_state": block(to)}]}) + }; + let pick = |from: &str, picks: Vec, default: Value| json!({"processor_type": "horizon:pick", "block": from, "picks": picks, "default": default}); + // YUNG's BlockStateRandomizer: an entry wins below the sum of the + // chances so far, summed as floats. + let randomizer = |entries: &[(f32, &str)]| { + let mut bottom = 0f32; + entries + .iter() + .map(|(chance, id)| { + bottom += chance; + json!({"below": bottom as f64, "state": block(id)}) + }) + .collect::>() + }; + let at = |below: f32, id: &str| json!({"below": below as f64, "state": block(id)}); + // Sandstone stairs, upside down, facing Plane.HORIZONTAL.getRandomDirection. + let stairs = || { + let states: Vec = ["north", "east", "south", "west"] + .iter() + .map(|facing| { + json!({"id": "minecraft:sandstone_stairs", "properties": { + "facing": facing, "half": "top", "shape": "straight", "waterlogged": "false"}}) + }) + .collect(); + json!({"states": states}) + }; + Some(match kind.strip_prefix("betterdeserttemples:")? { + "blue_concrete_processor" => swap("minecraft:blue_concrete", "minecraft:blue_terracotta"), + "yellow_concrete_processor" => { + swap("minecraft:yellow_concrete", "minecraft:yellow_terracotta") + } + "red_wool_processor" => swap("minecraft:red_wool", "minecraft:tnt"), + "white_stained_glass_processor" => pick( + "minecraft:white_stained_glass", + randomizer(&[(0.4, "minecraft:cobweb")]), + json!({"state": block("minecraft:air")}), + ), + "polished_diorite_processor" => pick( + "minecraft:polished_diorite", + randomizer(&[(0.6, "minecraft:cut_sandstone")]), + json!({"state": block("minecraft:sandstone")}), + ), + "orange_stained_glass_processor" => { + let mut sus = at(0.01, "minecraft:suspicious_sand"); + sus["nbt"] = json!({"LootTable": "minecraft:archaeology/desert_pyramid"}); + let mut stairs = stairs(); + stairs["below"] = (0.45f32 as f64).into(); + pick( + "minecraft:orange_stained_glass", + vec![ + sus, + at(0.1, "minecraft:sand"), + at(0.2, "minecraft:sandstone"), + stairs, + ], + json!({"state": block("minecraft:cut_sandstone")}), + ) + } + "red_stained_glass_processor" => pick( + "minecraft:red_stained_glass", + vec![at(0.3, "minecraft:sand"), at(0.75, "minecraft:sandstone")], + stairs(), + ), + "pot_processor" => { + // Four sherds, one float each; the pot back to its default state. + let values: Vec = [ + (0.05f32, "archer"), + (0.1, "miner"), + (0.15, "prize"), + (0.2, "skull"), + ] + .iter() + .map(|(below, sherd)| { + json!({"below": *below as f64, "value": format!("minecraft:{sherd}_pottery_sherd")}) + }) + .collect(); + pick( + "minecraft:decorated_pot", + Vec::new(), + json!({"state": block("minecraft:decorated_pot"), "lists": [{ + "key": "sherds", "count": 4, "values": values, "default": "minecraft:brick"}]}), + ) + } + _ => return None, + }) +} + +/// An item as 26.3 saves it. +fn item(id: &str) -> Value { + json!({"id": format!("minecraft:{id}"), "count": 1}) +} + +/// YUNG's processors that make a spawner of a fixed mob (YUNG's API's +/// `MobSpawnerData`), as vanilla's `rule`: every `input` block becomes a +/// spawner with that NBT. +fn yung_spawner(kind: &str, p: &Value) -> Option { + const SPAWNER: &str = "minecraft:spawner"; + // (input block, mob, fields other than the defaults, whether the mob is + // also the only potential, its equipment) + let (input, mob, fields, potential, equipment): (_, _, &[(&str, i64)], _, _) = match kind { + "betterdungeons:mob_spawner_processor" => { + (SPAWNER, p["spawner_mob"].as_str()?, &[], true, None) + } + "betterdungeons:zombie_mob_spawner_processor" => ( + SPAWNER, + "minecraft:zombie", + &[("MaxNearbyEntities", 8)], + true, + None, + ), + "betterdungeons:skeleton_mob_spawner_processor" => ( + SPAWNER, + "minecraft:skeleton", + &[ + ("RequiredPlayerRange", 18), + ("MaxNearbyEntities", 8), + ("MaxSpawnDelay", 650), + ], + true, + None, + ), + "betterdungeons:small_nether_dungeon_mob_spawner_processor" => { + let mob = p["spawner_mob"].as_str()?; + // Wither skeletons get netherite armor that never drops and a + // stone sword (with the mod's default config, they and blazes + // keep their loot). + let armor = (mob == "minecraft:wither_skeleton").then(|| { + json!({ + "equipment": { + "feet": item("netherite_boots"), + "legs": item("netherite_leggings"), + "chest": item("netherite_chestplate"), + "head": item("netherite_helmet"), + "mainhand": item("stone_sword"), + }, + "drop_chances": {"feet": 0.0, "legs": 0.0, "chest": 0.0, "head": 0.0}, + }) + }); + (SPAWNER, mob, &[], true, armor) + } + "betterdungeons:zombie_tombstone_spawner_processor" => ( + "minecraft:black_stained_glass", + "minecraft:skeleton", + &[], + false, + Some(json!({"equipment": {"mainhand": item("iron_sword")}})), + ), + "betterdeserttemples:gravel_processor" => ( + "minecraft:gravel", + "minecraft:husk", + &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], + false, + None, + ), + // An empty hand list in 1.21.1: the skeletons spawn without a bow, + // since a spawn entry with more than its id is not finalized. + "betterdeserttemples:bone_block_processor" => ( + "minecraft:bone_block", + "minecraft:skeleton", + &[("RequiredPlayerRange", 32)], + false, + Some(json!({"equipment": {}})), + ), + "betterdeserttemples:infested_cracked_stone_bricks_processor" => ( + "minecraft:infested_cracked_stone_bricks", + "minecraft:silverfish", + &[("RequiredPlayerRange", 24)], + false, + None, + ), + // 1.21.1 ignores the items' old `Count` and `tag` (the shield's + // pattern, the boots' dye): plain items. + "betterdeserttemples:yellow_wool_processor" => ( + "minecraft:yellow_wool", + "minecraft:husk", + &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], + false, + Some(json!({"equipment": { + "mainhand": item("golden_sword"), + "offhand": item("shield"), + "feet": item("leather_boots"), + "legs": item("leather_leggings"), + "chest": item("golden_chestplate"), + "head": item("chainmail_helmet"), + }})), + ), + _ => return None, + }; + let mut entity = json!({"id": mob}); + if let Some(Value::Object(extra)) = equipment { + entity.as_object_mut()?.extend(extra); + } + let potentials = match potential { + true => json!([{"data": {"entity": entity.clone()}, "weight": 1}]), + false => json!([]), + }; + let mut nbt = json!({ + "Delay": 20, "MinSpawnDelay": 200, "MaxSpawnDelay": 800, "SpawnCount": 4, + "MaxNearbyEntities": 6, "RequiredPlayerRange": 16, "SpawnRange": 4, + "SpawnData": {"entity": entity}, + "SpawnPotentials": potentials, + }); + for (key, value) in fields { + nbt[*key] = (*value).into(); + } + Some(json!({ + "processor_type": "minecraft:rule", + "rules": [{ + "input_predicate": {"predicate_type": "minecraft:block_match", "block": input}, + "location_predicate": {"predicate_type": "minecraft:always_true"}, + "output_state": {"Name": SPAWNER}, + "block_entity_modifier": {"type": "minecraft:append_static", "data": nbt}, + }], + })) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::legacy_structure_mods::data; + use crate::processors::{ProcessorData, carry}; + use crate::worldgen::{Upgrade, upgrade}; + + const NO_TAGS: BTreeMap> = BTreeMap::new(); + + #[test] + fn yungs_jigsaws_keep_their_rules() { + let mut report = Upgrade::default(); + let mut s = json!({"type": "yungsapi:yung_jigsaw", "start_pool": "y:start", "size": 20, + "max_y": 60, "x_offset_in_chunk": 0, "max_distance_from_center": 80, + "enhanced_terrain_adaptation": {"type": "yungsapi:custom", "kernel_size": 24, + "kernel_distance": 24, "top": "carve", "bottom": "none"}}); + assert!(upgrade("structure", &mut s, &mut report, &NO_TAGS)); + assert_eq!(s["type"], "minecraft:jigsaw"); + assert_eq!(s["horizon:yungsapi"], json!({"max_y": 60})); + assert_eq!( + s["horizon:enhanced_terrain_adaptation"], + json!({"kernel_size": 24, "kernel_distance": 24, "top": "carve", "bottom": "none", + "rigid_junctions": true, "inflate": true}) + ); + for gone in ["max_y", "x_offset_in_chunk", "enhanced_terrain_adaptation"] { + assert!(s.get(gone).is_none(), "{gone}"); + } + // Better Dungeons' small Nether dungeon is the same jigsaw. + let mut nether = json!({"type": "betterdungeons:small_nether_dungeon", + "start_pool": "betterdungeons:small_nether_dungeon", "size": 10, + "start_jigsaw_name": "betterdungeons:small_nether_dungeon_anchor", + "max_distance_from_center": 80, "liquid_settings": "ignore_waterlogging"}); + assert!(upgrade("structure", &mut nether, &mut report, &NO_TAGS)); + assert_eq!(nether["type"], "minecraft:jigsaw"); + assert_eq!(nether["horizon:yungsapi"], json!({})); + assert_eq!( + nether["horizon:enhanced_terrain_adaptation"], + json!({"kernel_size": 0, "kernel_distance": 0, "top": "none", "bottom": "none", + "rigid_junctions": true, "inflate": true}) + ); + assert_eq!( + nether["start_jigsaw_name"], + "betterdungeons:small_nether_dungeon_anchor" + ); + assert!(report.unsupported.is_empty()); + let mut pool = json!({"elements": [{"weight": 3, "element": { + "element_type": "yungsapi:yung_single_element", "location": "y:room", + "processors": "minecraft:empty", "projection": "rigid", + "name": "room", "max_count": 2, "min_required_depth": 1, "is_priority": true, + "ignore_bounds": false, "deadend_pool": "y:end", + "modifiers": [ + {"condition": {"type": "yungsapi:piece_in_range", "pieces": ["y:pillar"], + "above_range": 40}, + "target_selector": {"type": "yungsapi:self"}, + "actions": [{"type": "yungsapi:transform", "output": ["y:covered"], "x_offset": -1}, + {"type": "yungsapi:delay_generation"}, {"type": "yungsapi:spin"}]}, + {"condition": {"type": "yungsapi:always_true"}, + "target_selector": {"type": "yungsapi:all"}, "actions": []}], + "enhanced_terrain_adaptation": {"type": "yungsapi:carved_top_no_beard_small"}, + "condition": {"type": "yungsapi:all_of", "conditions": [ + {"type": "yungsapi:piece_in_horizontal_direction", "pieces": ["yungsapi:all"], + "range": 5, "rotation": "none"}, + {"type": "yungsapi:not", "condition": {"type": "yungsapi:mod_loaded", "modid": "create"}}, + {"type": "yungsapi:biome", "biomes": []}]}}}]}); + assert!(upgrade("template_pool", &mut pool, &mut report, &NO_TAGS)); + let e = &pool["elements"][0]["element"]; + assert_eq!(e["element_type"], "minecraft:single_pool_element"); + assert_eq!(e["location"], "y:room"); + assert_eq!( + e["horizon:yungsapi"], + json!({"name": "room", "max_count": 2, "min_depth": 1, "priority": true, + "ignore_bounds": false, "condition": {"type": "all_of", "conditions": [ + {"type": "piece_in_horizontal_direction", "pieces": [], "range": 5, "rotation": "none"}, + {"type": "not", "condition": {"type": "false"}}, + {"type": "false"}]}, + "deadend_pool": "y:end", + "modifiers": [{"condition": {"type": "piece_in_range", "pieces": ["y:pillar"], + "horizontal_range": null, "above_range": 40, "below_range": null}, + "actions": [{"type": "transform", "output": ["y:covered"], "offset": [-1, 0, 0]}, + {"type": "delay_generation"}]}]}) + ); + assert!(e.get("deadend_pool").is_none() && e.get("modifiers").is_none()); + assert_eq!( + e["horizon:enhanced_terrain_adaptation"], + json!({"kernel_size": 12, "kernel_distance": 6, "top": "carve", "bottom": "none"}) + ); + assert_eq!( + report.rules_lost, + BTreeMap::from([ + ("yungsapi condition yungsapi:biome".into(), 1), + ("yungsapi modifier action yungsapi:spin".into(), 1), + ("yungsapi modifier target yungsapi:all".into(), 1), + ]) + ); + assert!(report.unsupported.is_empty()); + } + + #[test] + fn yungs_placements_keep_their_rules() { + let tags = BTreeMap::from([( + "bf:avoid".to_owned(), + vec!["minecraft:nether_complexes".to_owned()], + )]); + let mut report = Upgrade::default(); + let mut fortress = json!({"placement": {"type": "yungsapi:enhanced_random_spread", + "salt": 1, "spacing": 30, "separation": 20, + "enhanced_exclusion_zone": {"other_set": "#bf:avoid", "chunk_count": 10}}}); + assert!(upgrade("structure_set", &mut fortress, &mut report, &tags)); + assert_eq!( + fortress["placement"], + json!({"type": "minecraft:random_spread", "salt": 1, "spacing": 30, "separation": 20, + "horizon:exclusion_zone": {"other_sets": ["minecraft:nether_complexes"], "chunk_count": 10}}) + ); + let mut temple = json!({"placement": {"type": "betterdeserttemples:desert_temple", + "salt": 2, "spacing": 30, "separation": 20, + "exclusion_zone": {"other_set": "minecraft:villages", "chunk_count": 6}}}); + assert!(upgrade("structure_set", &mut temple, &mut report, &tags)); + assert_eq!(temple["placement"]["type"], "minecraft:random_spread"); + assert_eq!(temple["placement"]["exclusion_zone"]["chunk_count"], 6); + assert_eq!( + temple["placement"]["horizon:avoid_biomes"], + json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"], + "radius": 48, "step": 2, "y": 120}) + ); + let mut stronghold = json!({"placement": {"type": "betterstrongholds:stronghold", + "salt": 3, "spacing": 85, "separation": 50, + "chunk_distance_to_first_ring": 80, "ring_chunk_thickness": 96}}); + assert!(upgrade( + "structure_set", + &mut stronghold, + &mut report, + &tags + )); + assert_eq!( + stronghold["placement"], + json!({"type": "minecraft:random_spread", "salt": 3, "spacing": 85, "separation": 50, + "horizon:ring_sections": {"distance_to_first_ring": 80, "thickness": 96}}) + ); + assert_eq!(report.mapped, 3); + assert!(report.unsupported.is_empty()); + // The vanilla counterpart is turned off only for a structure the game starts. + let mut ported = json!({"type": "minecraft:jigsaw"}); + assert!(disables("betterstrongholds:stronghold", &mut ported)); + assert_eq!(ported["horizon:disables"], json!(["minecraft:stronghold"])); + let mut java = json!({"type": "bettermineshafts:mineshaft"}); + assert!(!disables("bettermineshafts:mineshaft_oak", &mut java)); + let mut circle = json!({"type": "minecraft:jigsaw"}); + assert!(!disables("betterwitchhuts:witch_circle", &mut circle)); + } + + #[test] + fn yungs_spawners_become_rules() { + let mut pool = json!({"elements": [{"element": {"processors": {"processors": [ + {"processor_type": "betterdungeons:skeleton_mob_spawner_processor"}, + {"processor_type": "betterdeserttemples:bone_block_processor"}, + {"processor_type": "betterdungeons:small_nether_dungeon_mob_spawner_processor", + "spawner_mob": "minecraft:wither_skeleton"}, + {"processor_type": "betterdungeons:candle_processor"}]}}}]}); + let mut carried = BTreeMap::new(); + assert!(carry("template_pool", &mut pool, &data(), &mut carried)); + let p = &pool["elements"][0]["element"]["processors"]["processors"]; + let rule = |i: usize| &p[i]["rules"][0]; + assert_eq!(rule(0)["input_predicate"]["block"], "minecraft:spawner"); + assert_eq!( + rule(0)["output_state"], + json!({"Name": "minecraft:spawner"}) + ); + let nbt = &rule(0)["block_entity_modifier"]["data"]; + assert_eq!( + ( + nbt["RequiredPlayerRange"].clone(), + nbt["MaxNearbyEntities"].clone() + ), + (json!(18), json!(8)) + ); + assert_eq!(nbt["MaxSpawnDelay"], 650); + assert_eq!( + nbt["SpawnPotentials"], + json!([{"data": {"entity": {"id": "minecraft:skeleton"}}, "weight": 1}]) + ); + // Bone blocks become bowless skeleton spawners with no potentials. + let bone = &rule(1)["block_entity_modifier"]["data"]; + assert_eq!(rule(1)["input_predicate"]["block"], "minecraft:bone_block"); + assert_eq!( + bone["SpawnData"], + json!({"entity": {"id": "minecraft:skeleton", "equipment": {}}}) + ); + assert_eq!(bone["SpawnPotentials"], json!([])); + let wither = &rule(2)["block_entity_modifier"]["data"]["SpawnData"]["entity"]; + assert_eq!( + wither["equipment"]["head"]["id"], + "minecraft:netherite_helmet" + ); + assert_eq!(wither["drop_chances"]["feet"], 0.0); + assert_eq!(p[3]["processor_type"], "betterdungeons:candle_processor"); + assert_eq!(carried.values().sum::(), 3); + } + + #[test] + fn desert_temple_placeholders_become_rules_and_picks() { + let mut list = json!({"processors": [ + {"processor_type": "betterdeserttemples:red_wool_processor"}, + {"processor_type": "betterdeserttemples:white_stained_glass_processor"}, + {"processor_type": "betterdeserttemples:orange_stained_glass_processor"}, + {"processor_type": "betterdeserttemples:pot_processor"}, + {"processor_type": "betterdeserttemples:quartz_pillar_processor"}]}); + 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]["rules"][0]["output_state"], + json!({"id": "minecraft:tnt"}) + ); + assert_eq!(p[1]["processor_type"], "horizon:pick"); + assert_eq!(p[1]["picks"][0]["below"], 0.4f32 as f64); + assert_eq!(p[1]["default"]["state"]["id"], "minecraft:air"); + let glass = &p[2]["picks"]; + assert_eq!(glass[0]["state"]["id"], "minecraft:suspicious_sand"); + assert_eq!( + glass[0]["nbt"]["LootTable"], + "minecraft:archaeology/desert_pyramid" + ); + assert_eq!(glass[3]["states"].as_array().unwrap().len(), 4); + assert_eq!(glass[3]["below"], 0.45f32 as f64); + assert_eq!(p[3]["default"]["lists"][0]["count"], 4); + // The pillar reads the world below: still Java, still dropped later. + assert_eq!( + p[4]["processor_type"], + "betterdeserttemples:quartz_pillar_processor" + ); + assert_eq!(carried.values().sum::(), 4); + } + + #[test] + fn small_dungeon_chests_are_capped() { + let mut list = json!({"processors": [ + {"processor_type": "betterdungeons:small_dungeon_chest_processor"}]}); + let mut carried = BTreeMap::new(); + assert!(carry("processor_list", &mut list, &data(), &mut carried)); + let cap = &list["processors"][0]; + assert_eq!(cap["processor_type"], "horizon:count_cap"); + assert_eq!( + (cap["min"].as_u64(), cap["max"].as_u64()), + (Some(1), Some(2)) + ); + assert_eq!(cap["replacement"], json!({"id": "minecraft:cave_air"})); + } + + #[test] + fn ocean_monuments_become_the_games() { + let names = [ + "random_prismarine_slab_decoration_processor", + "random_dark_prismarine_slab_decoration_processor", + "sand_gravel_processor", + "random_oxidization_processor", + "structure_void_processor", + "air_processor", + "waterlog_processor", + "seagrass_processor", + "random_sponge_processor", + "leg_processor", + ]; + let processors: Vec = names + .iter() + .map(|n| json!({"processor_type": format!("betteroceanmonuments:{n}")})) + .chain([json!({"processor_type": "betterwitchhuts:fence_leg_processor"})]) + .collect(); + let mut list = json!({"processors": processors}); + let mut carried = BTreeMap::new(); + assert!(carry( + "processor_list", + &mut list, + &ProcessorData::default(), + &mut carried + )); + let p = list["processors"].as_array().unwrap(); + let types: Vec<&str> = p + .iter() + .map(|p| p["processor_type"].as_str().unwrap()) + .collect(); + let mut want = vec!["horizon:pick", "horizon:pick", "minecraft:rule"]; + want.extend(["horizon:pick"; 4]); + want.extend([ + "horizon:keep_world_block", + "horizon:flood_air", + "horizon:waterlog", + "minecraft:rule", + "horizon:pick", + "horizon:yung_pillar", + "horizon:yung_pillar", + ]); + assert_eq!(types, want); + assert_eq!(carried.values().sum::(), 11); + // Copper stairs keep their properties, each chance on a new float. + let stairs = &p[5]; + assert_eq!(stairs["block"], "minecraft:oxidized_cut_copper_stairs"); + assert_eq!( + stairs["picks"][1]["state"]["id"], + "minecraft:weathered_cut_copper_stairs" + ); + assert_eq!( + (stairs["redraw"].clone(), stairs["keep_properties"].clone()), + (json!(true), json!(true)) + ); + assert_eq!(p[0]["picks"][0]["state"]["properties"]["type"], "top"); + assert_eq!(p[1]["default"]["state"]["id"], "minecraft:water"); + assert_eq!( + p[12]["target_block_output"]["defaultBlockState"]["id"], + "minecraft:prismarine_bricks" + ); + assert_eq!(p[13]["keep_properties"], true); + } +} diff --git a/crates/horizon-port-pack/src/lib.rs b/crates/horizon-port-pack/src/lib.rs index f729b6c52..950413341 100644 --- a/crates/horizon-port-pack/src/lib.rs +++ b/crates/horizon-port-pack/src/lib.rs @@ -13,6 +13,7 @@ pub mod fetch; pub mod import; pub mod inventory; pub mod jar; +pub(crate) mod legacy_structure_mods; pub mod modrinth; pub mod oracle; pub mod pipeline; diff --git a/crates/horizon-port-pack/src/processors.rs b/crates/horizon-port-pack/src/processors.rs index e6c0fe7d8..f182bee7b 100644 --- a/crates/horizon-port-pack/src/processors.rs +++ b/crates/horizon-port-pack/src/processors.rs @@ -5,27 +5,18 @@ //! processors pick a mob from a weighted list for each spawner. They become //! `horizon:spawner_mobs` (`horizon_world::worldgen::structure::processor`), //! with Repurposed's `rs_spawners` list written in. -//! - YUNG's Better Dungeons and Better Desert Temples turn a spawner or a -//! placeholder block into a spawner of a fixed mob. That is vanilla's `rule` -//! processor with an `append_static` block entity. //! - Moog's vanilla loot swap only acts when its mod's "replace vanilla" //! preset is on; one that ships off is a no-op and is taken out. -//! - Lithostitched's `reference` runs other processor lists in turn: their -//! processors are written in its place (Choice Theorem's Overhauled -//! Villages builds most of its lists so). Its `apply_random` and -//! `condition` become the game's `horizon:apply_random` and -//! `horizon:condition`, with the lists inside them carried the same way, -//! and its `set_block` (simple or weighted states) `horizon:set_block`. //! - Repurposed Structures' mineshaft sky view becomes the game's //! `horizon:mineshaft_sky_view`. -//! - Choice Theorem's Overhauled Village's `modular_compat` runs another -//! list only when the mod it names is loaded: that list is written in its -//! place when the mod is ported along, and it is taken out (a no-op, as in -//! the mod) when it is not. +//! +//! The processors of YUNG's mods, Lithostitched and Choice Theorem's Overhauled +//! Village are carried by `legacy_structure_mods`, 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, yung}; use serde_json::{Value, json}; use std::{ collections::{BTreeMap, BTreeSet}, @@ -48,30 +39,10 @@ pub struct ProcessorData { pub compat_loaded: BTreeSet, } -/// Choice Theorem's Overhauled Village's processor that runs the list -/// `reference` when mod `modid` is loaded (ModularCompatProcessor). -const MODULAR_COMPAT: &str = "ctov:modular_compat"; - impl ProcessorData { /// Notes which mods its compat processors name are `loaded`. pub fn mark_loaded(&mut self, loaded: &dyn Fn(&str) -> bool) { - fn walk(v: &Value, out: &mut BTreeSet) { - match v { - Value::Object(o) => { - if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT) { - if let Some(id) = o.get("modid").and_then(Value::as_str) { - out.insert(id.to_owned()); - } - } - o.values().for_each(|v| walk(v, out)); - } - Value::Array(a) => a.iter().for_each(|v| walk(v, out)), - _ => {} - } - } - let mut named = BTreeSet::new(); - self.lists.values().for_each(|l| walk(l, &mut named)); - self.compat_loaded = named.into_iter().filter(|m| loaded(m)).collect(); + ctov::mark_loaded(self, loaded); } pub fn read(zip: &mut zip::ZipArchive) -> Self { @@ -187,7 +158,7 @@ pub fn carry( /// The processors of one list carried: references written in, then each /// one with a data form replaced by it. Whether anything changed. -fn carry_all( +pub(crate) fn carry_all( list: Vec, data: &ProcessorData, carried: &mut BTreeMap, @@ -202,18 +173,18 @@ fn carry_at( carried: &mut BTreeMap, depth: usize, ) -> (Vec, bool) { - let (expanded, mut changed) = references(list, data, carried, 0); + let (expanded, mut changed) = lithostitched::expand_references(list, data, carried); let mut out = Vec::with_capacity(expanded.len()); for p in expanded { let kind = p["processor_type"].as_str().unwrap_or_default().to_owned(); - let replacement = match kind.as_str() { - "lithostitched:apply_random" => apply_random(&p, data, carried).map(|p| vec![p]), - "lithostitched:condition" => condition(&p, data, carried).map(|p| vec![p]), - _ => match pillar_type(&kind) { + // Lithostitched's and YUNG's processors are carried apart from this + // code (`legacy_structure_mods`). + let replacement = lithostitched::processor(&kind, &p, data, carried).or_else(|| { + match pillar_type(&kind).or_else(|| yung::pillar_type(&kind)) { Some(to) => Some(vec![pillar(&p, to, data, carried, depth)]), - None => as_data(&kind, &p, data), - }, - }; + None => as_data(&kind, &p, data).or_else(|| yung::processor(&kind, &p)), + } + }); match replacement { Some(replacement) => { *carried.entry(kind).or_default() += 1; @@ -237,10 +208,6 @@ fn pillar_type(kind: &str) -> Option<&'static str> { "repurposed_structures:close_off_fluid_sources_processor" | "moogs_structures:close_off_fluid_sources_processor" => "horizon:close_off_fluid_sources", "repurposed_structures:close_off_air_sources_processor" => "horizon:close_off_air_sources", - "betterfortresses:pillar_processor" | "betterjungletemples:pillar_processor" => { - "horizon:yung_pillar" - } - "betterfortresses:stair_pillar_processor" => "horizon:stair_pillar", _ => return None, }) } @@ -248,8 +215,7 @@ fn pillar_type(kind: &str) -> Option<&'static str> { /// A pillar processor as the game's `to`. Its `pillar_processor_list` /// (which runs on each block of the column; Repurposed's often names the /// list it is in) is written in, carried; the pillars inside that copy lose -/// theirs, as a column's blocks are never the mods' triggers. Better -/// Fortresses' stair supports get the blocks its Java code names. +/// theirs, as a column's blocks are never the mods' triggers. fn pillar( p: &Value, to: &str, @@ -257,13 +223,6 @@ fn pillar( carried: &mut BTreeMap, depth: usize, ) -> Value { - if to == "horizon:stair_pillar" { - return json!({"processor_type": to, - "blocks": {"minecraft:stone_brick_stairs": "minecraft:red_nether_brick_stairs", - "minecraft:purpur_stairs": "minecraft:red_nether_bricks"}, - "front": "minecraft:red_nether_brick_stairs", - "pillar": "minecraft:red_nether_bricks"}); - } let mut out = p.clone(); out["processor_type"] = to.into(); let Some(o) = out.as_object_mut() else { @@ -284,108 +243,6 @@ fn pillar( out } -/// 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) -} - /// Repurposed Structures' rule tests and the game's types that run them /// (`horizon_world::worldgen`'s `rule_test` and `structure::processor`). const RULE_TESTS: [(&str, &str); 3] = [ @@ -429,48 +286,9 @@ pub fn rule_tests(kind: &str, v: &mut Value, carried: &mut BTreeMap, - 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 p["processor_type"] == MODULAR_COMPAT && depth < 8 { - *carried.entry(MODULAR_COMPAT.into()).or_default() += 1; - changed = true; - let loaded = p["modid"] - .as_str() - .is_some_and(|m| data.compat_loaded.contains(m)); - if let Some(inner) = loaded.then(|| referenced(&p["reference"], data)).flatten() { - 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) -} - /// The processors of the lists a reference names: an id, an inline list, or /// a list of either. -fn referenced(lists: &Value, data: &ProcessorData) -> Option> { +pub(crate) fn referenced(lists: &Value, data: &ProcessorData) -> Option> { let one = |l: &Value| -> Option> { let mut list = match l { Value::String(id) if !id.starts_with('#') => { @@ -497,7 +315,7 @@ fn referenced(lists: &Value, data: &ProcessorData) -> Option> { /// The data form of a Java processor: the processors to put in its place /// (none for a no-op), or `None` when it has none. fn as_data(kind: &str, p: &Value, data: &ProcessorData) -> Option> { - let (ns, _) = kind.split_once(':')?; + kind.split_once(':')?; Some(match kind { // Its structure voids keep the world's block, as vanilla's // block_ignore does (the templates hold them; vanilla places them). @@ -593,171 +411,6 @@ fn as_data(kind: &str, p: &Value, data: &ProcessorData) -> Option> { |s| config(s.get("ominous") == Some(&"true")), )] } - _ if ns == "betterdeserttemples" - && let Some(processor) = desert_temple(kind) => - { - vec![processor] - } - "lithostitched:block_swap" => { - // The same map; the game's swap keeps the properties both have. - p["blocks"].as_object()?; - 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"); - } - vec![out] - } - "betterdungeons:small_dungeon_chest_processor" => { - // Its config's defaults: one chest at least, two at most, a - // fifth of the others kept until then; ChestBlock covers both. - vec![json!({"processor_type": "horizon:count_cap", - "blocks": ["minecraft:chest", "minecraft:trapped_chest"], - "min": 1, "max": 2, "chance": 0.2f32 as f64, - "replacement": block("minecraft:cave_air")})] - } - "betterwitchhuts:leg_processor" => vec![yung_leg( - "minecraft:brown_stained_glass", - json!({"id": "minecraft:oak_log", "properties": {"axis": "y"}}), - false, - )], - "betterwitchhuts:fence_leg_processor" => vec![yung_leg( - "minecraft:crimson_fence", - block("minecraft:oak_fence"), - true, - )], - _ if ns == "betteroceanmonuments" => ocean_monument(kind)?, - _ if ns == "betterdungeons" || ns == "betterdeserttemples" => vec![yung_spawner(kind, p)?], - _ => return None, - }) -} - -/// YUNG's leg processors (Better Ocean Monuments, Better Witch Huts): a -/// placeholder block becomes `state` and a column of it runs down through -/// air and fluids: the game's `horizon:yung_pillar` with fixed states, and -/// the placeholder's properties kept for the fence legs. -fn yung_leg(target: &str, state: Value, keep_properties: bool) -> Value { - let fixed = json!({"entries": [], "defaultBlockState": state}); - json!({"processor_type": "horizon:yung_pillar", "target_block": block(target), - "target_block_output": fixed, "pillar_states": fixed, - "keep_properties": keep_properties}) -} - -/// Better Ocean Monuments' processors (no fields; what they do is in their -/// Java code): placeholder blocks as vanilla's `rule` or the game's -/// `horizon:pick` (a new `nextFloat` for each chance, as the mod draws), -/// and its sea-level ones as the game's `horizon:flood_air`, -/// `horizon:waterlog` and `horizon:keep_world_block`. -fn ocean_monument(kind: &str) -> Option> { - let rule = |rules: &[(&str, Value)]| { - let rules: Vec = rules - .iter() - .map(|(from, to)| { - json!({"input_predicate": {"predicate_type": "minecraft:block_match", "block": from}, - "location_predicate": {"predicate_type": "minecraft:always_true"}, - "output_state": to}) - }) - .collect(); - json!({"processor_type": "minecraft:rule", "rules": rules}) - }; - let state = |id: &str, props: Value| json!({"id": id, "properties": props}); - let pick = |from: &str, picks: Vec<(f32, Value)>, default: Value, keep: bool| { - let picks: Vec = picks - .into_iter() - .map(|(below, state)| json!({"below": below as f64, "state": state})) - .collect(); - json!({"processor_type": "horizon:pick", "block": from, "picks": picks, - "default": {"state": default}, "redraw": true, "keep_properties": keep}) - }; - let slabs = |from: &str, slab: &str, otherwise: &str| { - let wet = |t: &str| state(slab, json!({"type": t, "waterlogged": "true"})); - pick( - from, - vec![(0.4, wet("top")), (0.8, wet("bottom"))], - block(otherwise), - false, - ) - }; - // Exposed below 0.1, else weathered below a new 0.3, else oxidized, - // with the placeholder's properties for the stairs and slabs. - let copper = |kind: &str| { - let id = |age: &str| block(&format!("minecraft:{age}{kind}")); - pick( - &format!("minecraft:oxidized_{kind}"), - vec![(0.1, id("exposed_")), (0.3, id("weathered_"))], - id("oxidized_"), - true, - ) - }; - Some(match kind.strip_prefix("betteroceanmonuments:")? { - "random_prismarine_slab_decoration_processor" => vec![slabs( - "minecraft:lime_concrete", - "minecraft:prismarine_slab", - "minecraft:air", - )], - "random_dark_prismarine_slab_decoration_processor" => vec![slabs( - "minecraft:blue_concrete", - "minecraft:dark_prismarine_slab", - "minecraft:water", - )], - "sand_gravel_processor" => { - vec![rule(&[( - "minecraft:yellow_stained_glass", - block("minecraft:gravel"), - )])] - } - "random_oxidization_processor" => [ - "copper", - "cut_copper", - "cut_copper_stairs", - "cut_copper_slab", - ] - .into_iter() - .map(copper) - .collect(), - "structure_void_processor" => vec![json!({"processor_type": "horizon:keep_world_block", - "blocks": ["minecraft:purpur_slab", "minecraft:brown_wool"]})], - "air_processor" => vec![json!({"processor_type": "horizon:flood_air"})], - "waterlog_processor" => vec![json!({"processor_type": "horizon:waterlog"})], - "seagrass_processor" => vec![rule(&[ - ( - "minecraft:red_sandstone_slab", - state("minecraft:tall_seagrass", json!({"half": "lower"})), - ), - ( - "minecraft:end_stone_brick_slab", - state("minecraft:tall_seagrass", json!({"half": "upper"})), - ), - ("minecraft:brick_slab", block("minecraft:seagrass")), - ])], - "random_sponge_processor" => vec![pick( - "minecraft:orange_stained_glass", - vec![(0.75, block("minecraft:wet_sponge"))], - block("minecraft:water"), - false, - )], - "leg_processor" => vec![yung_leg( - "minecraft:blue_stained_glass", - block("minecraft:prismarine_bricks"), - false, - )], _ => return None, }) } @@ -885,110 +538,6 @@ pub fn upgrade_trial_spawner(config: &mut Value) -> bool { changed } -/// A block state as 26.3 writes it. -fn block(id: &str) -> Value { - json!({"id": id}) -} - -/// Better Desert Temples' placeholder blocks (glass, concrete and wool in -/// the templates) as the mod's processors turn them: the fixed ones as -/// vanilla's `rule`, the random ones as the game's `horizon:pick`, with the -/// mod's bounds on one `nextFloat` (YUNG's BlockStateRandomizer adds its -/// chances up in floats). The ones that read or change the world around -/// (pillars, Diorite's waterlogging) stay dropped. -fn desert_temple(kind: &str) -> Option { - let swap = |from: &str, to: &str| { - json!({"processor_type": "minecraft:rule", "rules": [{ - "input_predicate": {"predicate_type": "minecraft:block_match", "block": from}, - "location_predicate": {"predicate_type": "minecraft:always_true"}, - "output_state": block(to)}]}) - }; - let pick = |from: &str, picks: Vec, default: Value| json!({"processor_type": "horizon:pick", "block": from, "picks": picks, "default": default}); - // YUNG's BlockStateRandomizer: an entry wins below the sum of the - // chances so far, summed as floats. - let randomizer = |entries: &[(f32, &str)]| { - let mut bottom = 0f32; - entries - .iter() - .map(|(chance, id)| { - bottom += chance; - json!({"below": bottom as f64, "state": block(id)}) - }) - .collect::>() - }; - let at = |below: f32, id: &str| json!({"below": below as f64, "state": block(id)}); - // Sandstone stairs, upside down, facing Plane.HORIZONTAL.getRandomDirection. - let stairs = || { - let states: Vec = ["north", "east", "south", "west"] - .iter() - .map(|facing| { - json!({"id": "minecraft:sandstone_stairs", "properties": { - "facing": facing, "half": "top", "shape": "straight", "waterlogged": "false"}}) - }) - .collect(); - json!({"states": states}) - }; - Some(match kind.strip_prefix("betterdeserttemples:")? { - "blue_concrete_processor" => swap("minecraft:blue_concrete", "minecraft:blue_terracotta"), - "yellow_concrete_processor" => { - swap("minecraft:yellow_concrete", "minecraft:yellow_terracotta") - } - "red_wool_processor" => swap("minecraft:red_wool", "minecraft:tnt"), - "white_stained_glass_processor" => pick( - "minecraft:white_stained_glass", - randomizer(&[(0.4, "minecraft:cobweb")]), - json!({"state": block("minecraft:air")}), - ), - "polished_diorite_processor" => pick( - "minecraft:polished_diorite", - randomizer(&[(0.6, "minecraft:cut_sandstone")]), - json!({"state": block("minecraft:sandstone")}), - ), - "orange_stained_glass_processor" => { - let mut sus = at(0.01, "minecraft:suspicious_sand"); - sus["nbt"] = json!({"LootTable": "minecraft:archaeology/desert_pyramid"}); - let mut stairs = stairs(); - stairs["below"] = (0.45f32 as f64).into(); - pick( - "minecraft:orange_stained_glass", - vec![ - sus, - at(0.1, "minecraft:sand"), - at(0.2, "minecraft:sandstone"), - stairs, - ], - json!({"state": block("minecraft:cut_sandstone")}), - ) - } - "red_stained_glass_processor" => pick( - "minecraft:red_stained_glass", - vec![at(0.3, "minecraft:sand"), at(0.75, "minecraft:sandstone")], - stairs(), - ), - "pot_processor" => { - // Four sherds, one float each; the pot back to its default state. - let values: Vec = [ - (0.05f32, "archer"), - (0.1, "miner"), - (0.15, "prize"), - (0.2, "skull"), - ] - .iter() - .map(|(below, sherd)| { - json!({"below": *below as f64, "value": format!("minecraft:{sherd}_pottery_sherd")}) - }) - .collect(); - pick( - "minecraft:decorated_pot", - Vec::new(), - json!({"state": block("minecraft:decorated_pot"), "lists": [{ - "key": "sherds", "count": 4, "values": values, "default": "minecraft:brick"}]}), - ) - } - _ => return None, - }) -} - /// [`as_data`]'s `horizon:spawner_mobs` for the mods' spawner randomizing /// processors, whose fields have the same names and defaults. fn spawner_mobs(p: &Value, mobs: Vec, rules: Option) -> Value { @@ -1046,135 +595,6 @@ fn repurposed_light(p: &Value) -> Option> { Some(Some(rules)) } -/// An item as 26.3 saves it. -fn item(id: &str) -> Value { - json!({"id": format!("minecraft:{id}"), "count": 1}) -} - -/// YUNG's processors that make a spawner of a fixed mob (YUNG's API's -/// `MobSpawnerData`), as vanilla's `rule`: every `input` block becomes a -/// spawner with that NBT. -fn yung_spawner(kind: &str, p: &Value) -> Option { - const SPAWNER: &str = "minecraft:spawner"; - // (input block, mob, fields other than the defaults, whether the mob is - // also the only potential, its equipment) - let (input, mob, fields, potential, equipment): (_, _, &[(&str, i64)], _, _) = match kind { - "betterdungeons:mob_spawner_processor" => { - (SPAWNER, p["spawner_mob"].as_str()?, &[], true, None) - } - "betterdungeons:zombie_mob_spawner_processor" => ( - SPAWNER, - "minecraft:zombie", - &[("MaxNearbyEntities", 8)], - true, - None, - ), - "betterdungeons:skeleton_mob_spawner_processor" => ( - SPAWNER, - "minecraft:skeleton", - &[ - ("RequiredPlayerRange", 18), - ("MaxNearbyEntities", 8), - ("MaxSpawnDelay", 650), - ], - true, - None, - ), - "betterdungeons:small_nether_dungeon_mob_spawner_processor" => { - let mob = p["spawner_mob"].as_str()?; - // Wither skeletons get netherite armor that never drops and a - // stone sword (with the mod's default config, they and blazes - // keep their loot). - let armor = (mob == "minecraft:wither_skeleton").then(|| { - json!({ - "equipment": { - "feet": item("netherite_boots"), - "legs": item("netherite_leggings"), - "chest": item("netherite_chestplate"), - "head": item("netherite_helmet"), - "mainhand": item("stone_sword"), - }, - "drop_chances": {"feet": 0.0, "legs": 0.0, "chest": 0.0, "head": 0.0}, - }) - }); - (SPAWNER, mob, &[], true, armor) - } - "betterdungeons:zombie_tombstone_spawner_processor" => ( - "minecraft:black_stained_glass", - "minecraft:skeleton", - &[], - false, - Some(json!({"equipment": {"mainhand": item("iron_sword")}})), - ), - "betterdeserttemples:gravel_processor" => ( - "minecraft:gravel", - "minecraft:husk", - &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], - false, - None, - ), - // An empty hand list in 1.21.1: the skeletons spawn without a bow, - // since a spawn entry with more than its id is not finalized. - "betterdeserttemples:bone_block_processor" => ( - "minecraft:bone_block", - "minecraft:skeleton", - &[("RequiredPlayerRange", 32)], - false, - Some(json!({"equipment": {}})), - ), - "betterdeserttemples:infested_cracked_stone_bricks_processor" => ( - "minecraft:infested_cracked_stone_bricks", - "minecraft:silverfish", - &[("RequiredPlayerRange", 24)], - false, - None, - ), - // 1.21.1 ignores the items' old `Count` and `tag` (the shield's - // pattern, the boots' dye): plain items. - "betterdeserttemples:yellow_wool_processor" => ( - "minecraft:yellow_wool", - "minecraft:husk", - &[("MaxNearbyEntities", 8), ("RequiredPlayerRange", 24)], - false, - Some(json!({"equipment": { - "mainhand": item("golden_sword"), - "offhand": item("shield"), - "feet": item("leather_boots"), - "legs": item("leather_leggings"), - "chest": item("golden_chestplate"), - "head": item("chainmail_helmet"), - }})), - ), - _ => return None, - }; - let mut entity = json!({"id": mob}); - if let Some(Value::Object(extra)) = equipment { - entity.as_object_mut()?.extend(extra); - } - let potentials = match potential { - true => json!([{"data": {"entity": entity.clone()}, "weight": 1}]), - false => json!([]), - }; - let mut nbt = json!({ - "Delay": 20, "MinSpawnDelay": 200, "MaxSpawnDelay": 800, "SpawnCount": 4, - "MaxNearbyEntities": 6, "RequiredPlayerRange": 16, "SpawnRange": 4, - "SpawnData": {"entity": entity}, - "SpawnPotentials": potentials, - }); - for (key, value) in fields { - nbt[*key] = (*value).into(); - } - Some(json!({ - "processor_type": "minecraft:rule", - "rules": [{ - "input_predicate": {"predicate_type": "minecraft:block_match", "block": input}, - "location_predicate": {"predicate_type": "minecraft:always_true"}, - "output_state": {"Name": SPAWNER}, - "block_entity_modifier": {"type": "minecraft:append_static", "data": nbt}, - }], - })) -} - #[cfg(test)] mod tests { use super::*; @@ -1246,54 +666,6 @@ mod tests { ); } - #[test] - fn yungs_spawners_become_rules() { - let mut pool = json!({"elements": [{"element": {"processors": {"processors": [ - {"processor_type": "betterdungeons:skeleton_mob_spawner_processor"}, - {"processor_type": "betterdeserttemples:bone_block_processor"}, - {"processor_type": "betterdungeons:small_nether_dungeon_mob_spawner_processor", - "spawner_mob": "minecraft:wither_skeleton"}, - {"processor_type": "betterdungeons:candle_processor"}]}}}]}); - let mut carried = BTreeMap::new(); - assert!(carry("template_pool", &mut pool, &data(), &mut carried)); - let p = &pool["elements"][0]["element"]["processors"]["processors"]; - let rule = |i: usize| &p[i]["rules"][0]; - assert_eq!(rule(0)["input_predicate"]["block"], "minecraft:spawner"); - assert_eq!( - rule(0)["output_state"], - json!({"Name": "minecraft:spawner"}) - ); - let nbt = &rule(0)["block_entity_modifier"]["data"]; - assert_eq!( - ( - nbt["RequiredPlayerRange"].clone(), - nbt["MaxNearbyEntities"].clone() - ), - (json!(18), json!(8)) - ); - assert_eq!(nbt["MaxSpawnDelay"], 650); - assert_eq!( - nbt["SpawnPotentials"], - json!([{"data": {"entity": {"id": "minecraft:skeleton"}}, "weight": 1}]) - ); - // Bone blocks become bowless skeleton spawners with no potentials. - let bone = &rule(1)["block_entity_modifier"]["data"]; - assert_eq!(rule(1)["input_predicate"]["block"], "minecraft:bone_block"); - assert_eq!( - bone["SpawnData"], - json!({"entity": {"id": "minecraft:skeleton", "equipment": {}}}) - ); - assert_eq!(bone["SpawnPotentials"], json!([])); - let wither = &rule(2)["block_entity_modifier"]["data"]["SpawnData"]["entity"]; - assert_eq!( - wither["equipment"]["head"]["id"], - "minecraft:netherite_helmet" - ); - assert_eq!(wither["drop_chances"]["feet"], 0.0); - assert_eq!(p[3]["processor_type"], "betterdungeons:candle_processor"); - assert_eq!(carried.values().sum::(), 3); - } - #[test] fn trial_spawners_and_vaults_drop_their_saved_state() { let mut list = json!({"processors": [ @@ -1355,41 +727,6 @@ mod tests { assert!(!upgrade_trial_spawner(&mut config)); } - #[test] - fn desert_temple_placeholders_become_rules_and_picks() { - let mut list = json!({"processors": [ - {"processor_type": "betterdeserttemples:red_wool_processor"}, - {"processor_type": "betterdeserttemples:white_stained_glass_processor"}, - {"processor_type": "betterdeserttemples:orange_stained_glass_processor"}, - {"processor_type": "betterdeserttemples:pot_processor"}, - {"processor_type": "betterdeserttemples:quartz_pillar_processor"}]}); - 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]["rules"][0]["output_state"], - json!({"id": "minecraft:tnt"}) - ); - assert_eq!(p[1]["processor_type"], "horizon:pick"); - assert_eq!(p[1]["picks"][0]["below"], 0.4f32 as f64); - assert_eq!(p[1]["default"]["state"]["id"], "minecraft:air"); - let glass = &p[2]["picks"]; - assert_eq!(glass[0]["state"]["id"], "minecraft:suspicious_sand"); - assert_eq!( - glass[0]["nbt"]["LootTable"], - "minecraft:archaeology/desert_pyramid" - ); - assert_eq!(glass[3]["states"].as_array().unwrap().len(), 4); - assert_eq!(glass[3]["below"], 0.45f32 as f64); - assert_eq!(p[3]["default"]["lists"][0]["count"], 4); - // The pillar reads the world below: still Java, still dropped later. - assert_eq!( - p[4]["processor_type"], - "betterdeserttemples:quartz_pillar_processor" - ); - assert_eq!(carried.values().sum::(), 4); - } - #[test] fn repurposed_waterlogging_follows_the_world() { let mut list = json!({"processors": [{"processor_type": @@ -1409,143 +746,6 @@ mod tests { ); } - #[test] - fn small_dungeon_chests_are_capped() { - let mut list = json!({"processors": [ - {"processor_type": "betterdungeons:small_dungeon_chest_processor"}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data(), &mut carried)); - let cap = &list["processors"][0]; - assert_eq!(cap["processor_type"], "horizon:count_cap"); - assert_eq!( - (cap["min"].as_u64(), cap["max"].as_u64()), - (Some(1), Some(2)) - ); - assert_eq!(cap["replacement"], json!({"id": "minecraft:cave_air"})); - } - - #[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 modular_compat_runs_its_list_only_with_its_mod() { - let mut data = ProcessorData::default(); - let swap = json!({"processor_type": "minecraft:rule", "rules": []}); - data.lists - .insert("v:house_ns".into(), json!({"processors": [swap.clone()]})); - let compat = |m: &str| json!({"processor_type": "ctov:modular_compat", "modid": m, "reference": "v:house_ns"}); - let gravity = json!({"processor_type": "minecraft:gravity"}); - data.lists.insert( - "v:house".into(), - json!({"processors": [compat("ns"), compat("absent"), gravity.clone()]}), - ); - data.mark_loaded(&|m| m == "ns"); - assert_eq!(data.compat_loaded, BTreeSet::from(["ns".to_owned()])); - let mut v = json!({"processors": [compat("ns"), compat("absent"), gravity.clone()]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut v, &data, &mut carried)); - assert_eq!(v, json!({"processors": [swap, gravity]})); - assert_eq!(carried["ctov:modular_compat"], 2); - } - - #[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); - } - #[test] fn repurposed_rule_tests_become_the_games() { let rule = |input: Value, position: Value| { @@ -1600,71 +800,6 @@ mod tests { )); } - #[test] - fn ocean_monuments_become_the_games() { - let names = [ - "random_prismarine_slab_decoration_processor", - "random_dark_prismarine_slab_decoration_processor", - "sand_gravel_processor", - "random_oxidization_processor", - "structure_void_processor", - "air_processor", - "waterlog_processor", - "seagrass_processor", - "random_sponge_processor", - "leg_processor", - ]; - let processors: Vec = names - .iter() - .map(|n| json!({"processor_type": format!("betteroceanmonuments:{n}")})) - .chain([json!({"processor_type": "betterwitchhuts:fence_leg_processor"})]) - .collect(); - let mut list = json!({"processors": processors}); - let mut carried = BTreeMap::new(); - assert!(carry( - "processor_list", - &mut list, - &ProcessorData::default(), - &mut carried - )); - let p = list["processors"].as_array().unwrap(); - let types: Vec<&str> = p - .iter() - .map(|p| p["processor_type"].as_str().unwrap()) - .collect(); - let mut want = vec!["horizon:pick", "horizon:pick", "minecraft:rule"]; - want.extend(["horizon:pick"; 4]); - want.extend([ - "horizon:keep_world_block", - "horizon:flood_air", - "horizon:waterlog", - "minecraft:rule", - "horizon:pick", - "horizon:yung_pillar", - "horizon:yung_pillar", - ]); - assert_eq!(types, want); - assert_eq!(carried.values().sum::(), 11); - // Copper stairs keep their properties, each chance on a new float. - let stairs = &p[5]; - assert_eq!(stairs["block"], "minecraft:oxidized_cut_copper_stairs"); - assert_eq!( - stairs["picks"][1]["state"]["id"], - "minecraft:weathered_cut_copper_stairs" - ); - assert_eq!( - (stairs["redraw"].clone(), stairs["keep_properties"].clone()), - (json!(true), json!(true)) - ); - assert_eq!(p[0]["picks"][0]["state"]["properties"]["type"], "top"); - assert_eq!(p[1]["default"]["state"]["id"], "minecraft:water"); - assert_eq!( - p[12]["target_block_output"]["defaultBlockState"]["id"], - "minecraft:prismarine_bricks" - ); - assert_eq!(p[13]["keep_properties"], true); - } - #[test] fn repurposed_structure_voids_keep_the_world() { let mut list = json!({"processors": [ diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index 91b659217..1070b2aad 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -13,6 +13,11 @@ //! by name. Each rewrite is counted in the carry report, and every type left //! as it is is listed, so the coverage report can say what generates and how //! closely. +//! +//! YUNG's, 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}; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet}, @@ -21,8 +26,7 @@ use std::{ }; /// Structure types that are vanilla's jigsaw with extra start rules. -const JIGSAWS: [&str; 3] = [ - "lithostitched:jigsaw", +const JIGSAWS: [&str; 2] = [ "moogs_structures:moogs_structures_generic_jigsaw_structure", "repurposed_structures:generic_jigsaw_structure", ]; @@ -57,35 +61,6 @@ const SPREADS: [&str; 2] = [ "moogs_structures:advanced_random_spread", "repurposed_structures:advanced_random_spread", ]; -/// YUNG's placements: vanilla's random spread with an enhanced exclusion -/// zone (several sets), plus, for the temples, no start near an ocean or a -/// river, and for strongholds, starts only in odd rings around the origin. -const YUNG_SPREADS: [&str; 4] = [ - "yungsapi:enhanced_random_spread", - "betterdeserttemples:desert_temple", - "betterjungletemples:jungle_temple", - "betterstrongholds:stronghold", -]; -/// YUNG's structures and the vanilla structure type each one's mod turns -/// off (its DisableVanilla*Mixin, on by default in each mod's config). -const YUNG_REPLACES: [(&str, &str); 7] = [ - ( - "betterdeserttemples:desert_temple", - "minecraft:desert_pyramid", - ), - ( - "betterjungletemples:jungle_temple", - "minecraft:jungle_temple", - ), - ("betterwitchhuts:witch_hut", "minecraft:swamp_hut"), - ( - "betteroceanmonuments:ocean_monument", - "minecraft:ocean_monument", - ), - ("betterstrongholds:stronghold", "minecraft:stronghold"), - ("betterfortresses:fortress", "minecraft:fortress"), - ("bettermineshafts:mineshaft_", "minecraft:mineshaft"), -]; /// Mo' Structures' placement (`mostructures:type`) takes its spacing and /// separation from the mod's config, not its files: the defaults it writes /// (MoStructuresConfig), by config key, as (spacing, separation). @@ -130,8 +105,8 @@ const LAYOUT_RULES: [&str; 4] = [ ]; /// The libraries' terrain kernel field, the game's /// `horizon:enhanced_terrain_adaptation` (docs/mods.md). -const ENHANCED_TERRAIN: &str = "enhanced_terrain_adaptation"; -const HORIZON_ENHANCED_TERRAIN: &str = "horizon:enhanced_terrain_adaptation"; +pub(crate) const ENHANCED_TERRAIN: &str = "enhanced_terrain_adaptation"; +pub(crate) const HORIZON_ENHANCED_TERRAIN: &str = "horizon:enhanced_terrain_adaptation"; /// Fields of older versions the mods' codecs no longer read: their own /// structures ignore them, and so does carry. Repurposed's jungle fortress /// and End stronghold still write `vertical_distance_from_start_piece`. @@ -181,195 +156,6 @@ pub struct Upgrade { /// `data//worldgen//horizon_added/.json`. pub const ADDED: &str = "horizon_added"; -/// 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 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 -} - -/// ChoiceTheorem's Overhauled Village's villages and outposts, which it adds -/// to vanilla's `villages` and `pillager_outposts` sets in Java code -/// (`CTOV.registerstructure`, through lithostitched), with its default -/// config: every village type in three sizes, weighted 10, 4 and 1, and -/// every outpost weighted 1. Vanilla's own entries stay (weight 1 each). -const CTOV_VILLAGES: [&str; 21] = [ - "beach", - "christmas", - "desert", - "desert_oasis", - "dark_forest", - "jungle", - "jungle_tree", - "mesa", - "mesa_fortified", - "mountain", - "mountain_alpine", - "mushroom", - "plains", - "plains_fortified", - "savanna", - "savanna_na", - "snowy_igloo", - "swamp", - "swamp_fortified", - "taiga", - "taiga_fortified", -]; -const CTOV_OUTPOSTS: [&str; 11] = [ - "beach", - "dark_forest", - "desert", - "jungle", - "badlands", - "mountain", - "plains", - "savanna", - "snowy", - "swamp", - "taiga", -]; - -/// The entries a mod adds to other structure sets in Java code, as its -/// default config has them: (file name, set, `[(structure, weight)]`). -/// Lithostitched appends them in the order of a hash map of every modifier -/// in the pack, which carry cannot know; they are written in the order the -/// mod registers them. Each set picks by weight, so how often each starts -/// is the same. -pub fn code_set_entries(mod_id: &str) -> Vec<(&'static str, &'static str, Vec<(String, u32)>)> { - match mod_id { - "ctov" => { - let outposts = CTOV_OUTPOSTS - .iter() - .map(|v| (format!("ctov:pillager_outpost_{v}"), 1)) - .collect(); - let villages = [("small", 10), ("medium", 4), ("large", 1)] - .into_iter() - .flat_map(|(size, weight)| { - CTOV_VILLAGES - .iter() - .map(move |v| (format!("ctov:{size}/village_{v}"), weight)) - }) - .collect(); - vec![ - ("pillager_outposts", "minecraft:pillager_outposts", outposts), - ("villages", "minecraft:villages", villages), - ] - } - _ => Vec::new(), - } -} - /// Rewrites one `data//worldgen//...` file in place; whether it /// changed. /// `set_tags` are the mod's structure set tags, expanded @@ -474,15 +260,16 @@ fn upgrade_types( set_tags: &BTreeMap>, ) -> bool { let lost = &mut report.rules_lost; + // YUNG's and Lithostitched's types are converted apart from this code. + if let Some(changed) = + yung::upgrade(kind, v, set_tags, lost).or_else(|| lithostitched::upgrade(kind, v, lost)) + { + report.mapped += usize::from(changed); + return changed; + } let mut unsupported = |t: &str| *report.unsupported.entry(t.to_owned()).or_default() += 1; let changed = match kind { "structure" => match v["type"].as_str() { - // Better Dungeons' small Nether dungeon is YUNG's jigsaw behind a - // config switch that ships on. - Some("yungsapi:yung_jigsaw" | "betterdungeons:small_nether_dungeon") => { - yung_structure(v, lost); - true - } Some(t) if JIGSAWS.contains(&t) || NETHER_JIGSAWS.contains(&t) @@ -591,11 +378,6 @@ fn upgrade_types( true } Some("mostructures:type") => mo_placement(&mut v["placement"], lost), - Some(t) if YUNG_SPREADS.contains(&t) => { - let t = t.to_owned(); - yung_placement(&t, &mut v["placement"], set_tags, lost); - true - } Some(t) if !t.starts_with("minecraft:") => { unsupported(t); false @@ -615,6 +397,10 @@ fn upgrade_types( } } for element in elements { + if yung::upgrade_pool_element(element, lost) { + changed = true; + continue; + } let Some(t) = element["element_type"].as_str() else { continue; }; @@ -629,9 +415,6 @@ fn upgrade_types( } element["element_type"] = (*to).into(); changed = true; - } else if t == "yungsapi:yung_single_element" { - yung_element(element, lost); - changed = true; } else if t == "formations:single_pool_element" { // Vanilla's element with its own ground level (1 when // missing, as its codec reads it). @@ -653,167 +436,10 @@ fn upgrade_types( changed } -/// YUNG's API's jigsaw as vanilla's, laid out by its own assembler in the -/// game (`horizon:yungsapi`, `horizon_world::worldgen::structure::yung`): -/// the heights pieces stay within move under the key, its terrain -/// adaptation under `horizon:enhanced_terrain_adaptation`. A start offset in -/// the chunk is lost. -fn yung_structure(v: &mut Value, lost: &mut BTreeMap) { - let Some(o) = v.as_object_mut() else { - return; - }; - o.insert("type".into(), "minecraft:jigsaw".into()); - let mut rules = serde_json::Map::new(); - for key in ["min_y", "max_y"] { - if let Some(y) = o.remove(key) { - rules.insert(key.into(), y); - } - } - // YungJigsawStructure's adaptation (NONE by default): every piece's - // junctions, and the start's box grown by its radius. - let own = o.remove(ENHANCED_TERRAIN); - let mut kernel = yung_terrain(own.as_ref().unwrap_or(&Value::Null), lost); - kernel["rigid_junctions"] = true.into(); - kernel["inflate"] = true.into(); - o.insert(HORIZON_ENHANCED_TERRAIN.into(), kernel); - for key in ["x_offset_in_chunk", "z_offset_in_chunk"] { - if o.remove(key).is_some_and(|n| n != 0) { - *lost.entry(key.into()).or_default() += 1; - } - } - o.insert("horizon:yungsapi".into(), rules.into()); -} - -/// YUNG's single pool element as vanilla's, its rules under -/// `horizon:yungsapi`: name and `max_count`, depth range, priority, -/// `ignore_bounds`, its condition, dead-end pool and modifiers; its terrain -/// adaptation under `horizon:enhanced_terrain_adaptation`. -fn yung_element(element: &mut Value, lost: &mut BTreeMap) { - let Some(o) = element.as_object_mut() else { - return; - }; - o.insert( - "element_type".into(), - "minecraft:single_pool_element".into(), - ); - let mut rules = serde_json::Map::new(); - for (from, to) in [ - ("name", "name"), - ("max_count", "max_count"), - ("min_required_depth", "min_depth"), - ("max_possible_depth", "max_depth"), - ("is_priority", "priority"), - ("ignore_bounds", "ignore_bounds"), - ] { - if let Some(x) = o.remove(from) { - rules.insert(to.into(), x); - } - } - if let Some(c) = o.remove("condition") { - rules.insert("condition".into(), yung_condition(&c, lost)); - } - // A piece's own adaptation, NONE included, replaces its structure's. - if let Some(a) = o.remove(ENHANCED_TERRAIN) { - o.insert(HORIZON_ENHANCED_TERRAIN.into(), yung_terrain(&a, lost)); - } - if let Some(pool) = o.remove("deadend_pool").filter(Value::is_string) { - rules.insert("deadend_pool".into(), pool); - } - let modifiers: Vec = o - .remove("modifiers") - .and_then(|m| m.as_array().cloned()) - .unwrap_or_default() - .iter() - .filter_map(|m| yung_modifier(m, lost)) - .collect(); - if !modifiers.is_empty() { - rules.insert("modifiers".into(), modifiers.into()); - } - o.insert("horizon:yungsapi".into(), rules.into()); -} - -/// One of YUNG's structure modifiers in the game's terms: its condition and -/// its transform and delay_generation actions, on the piece itself (`self`, -/// the API's only target). Another target loses the modifier, another action -/// just that action. -fn yung_modifier(m: &Value, lost: &mut BTreeMap) -> Option { - let target = m["target_selector"]["type"].as_str().unwrap_or_default(); - if target != "yungsapi:self" { - *lost - .entry(format!("yungsapi modifier target {target}")) - .or_default() += 1; - return None; - } - let mut actions = Vec::new(); - for a in m["actions"].as_array().into_iter().flatten() { - let int = |k: &str| a[k].as_i64().unwrap_or(0); - match a["type"].as_str().unwrap_or_default() { - "yungsapi:transform" => actions.push(serde_json::json!({"type": "transform", - "output": a["output"].clone(), - "offset": [int("x_offset"), int("y_offset"), int("z_offset")]})), - "yungsapi:delay_generation" => { - actions.push(serde_json::json!({"type": "delay_generation"})) - } - other => { - *lost - .entry(format!("yungsapi modifier action {other}")) - .or_default() += 1 - } - } - } - let condition = match m.get("condition") { - Some(c) => yung_condition(c, lost), - None => serde_json::json!({"type": "true"}), - }; - Some(serde_json::json!({"condition": condition, "actions": actions})) -} - -/// YUNG's API's terrain adaptation as the game's kernel: its two presets -/// spelled out, NONE (also the default) as size 0. An aquifer override -/// (none of ATM10's) is lost. -fn yung_terrain(a: &Value, lost: &mut BTreeMap) -> Value { - let kernel = |size: i32, distance: i32, top: &str, bottom: &str| { - serde_json::json!({"kernel_size": size, "kernel_distance": distance, - "top": top, "bottom": bottom}) - }; - match a["type"].as_str() { - Some("yungsapi:carved_top_no_beard_large") => kernel(24, 16, "carve", "none"), - Some("yungsapi:carved_top_no_beard_small") => kernel(12, 6, "carve", "none"), - Some("yungsapi:custom") => { - let mut out = serde_json::Map::new(); - for key in [ - "kernel_size", - "kernel_distance", - "top", - "bottom", - "bottom_offset", - "padding", - ] { - if let Some(x) = a.get(key) { - out.insert(key.into(), x.clone()); - } - } - if a.get("aquifer_override") - .is_some_and(|x| x["type"] != "yungsapi:none") - { - *lost.entry("yungsapi aquifer_override".into()).or_default() += 1; - } - moogs_terrain(&out.into(), lost).unwrap_or_else(|| kernel(0, 0, "none", "none")) - } - None | Some("yungsapi:none") => kernel(0, 0, "none", "none"), - Some(other) => { - *lost - .entry(format!("yungsapi terrain adaptation {other}")) - .or_default() += 1; - kernel(0, 0, "none", "none") - } - } -} - /// MoogsStructureLib's terrain adaptation: already the game's shape (with /// its band), when it has the fields the game needs (else it is lost, as /// the library's codec would refuse it). -fn moogs_terrain(a: &Value, lost: &mut BTreeMap) -> Option { +pub(crate) fn moogs_terrain(a: &Value, lost: &mut BTreeMap) -> Option { let ok = ["kernel_size", "kernel_distance"] .iter() .all(|k| a[k].is_u64()) @@ -824,58 +450,15 @@ fn moogs_terrain(a: &Value, lost: &mut BTreeMap) -> Option ok.then(|| a.clone()) } -/// One of YUNG's structure conditions in the game's terms. `mod_loaded` -/// holds for Minecraft alone: a mod that needs code is not ported, and the -/// pieces it guards would place its blocks. A condition the game does not -/// have does not hold, and is counted. -fn yung_condition(c: &Value, lost: &mut BTreeMap) -> Value { - let t = c["type"].as_str().unwrap_or_default(); - let list = |lost: &mut BTreeMap| -> Value { - let all = c["conditions"].as_array().into_iter().flatten(); - all.map(|x| yung_condition(x, lost)) - .collect::>() - .into() - }; - let opt = |k: &str| c.get(k).cloned().unwrap_or(Value::Null); - match t.trim_start_matches("yungsapi:") { - "always_true" => serde_json::json!({"type": "true"}), - "not" => { - serde_json::json!({"type": "not", "condition": yung_condition(&c["condition"], lost)}) - } - "all_of" => serde_json::json!({"type": "all_of", "conditions": list(lost)}), - "any_of" => serde_json::json!({"type": "any_of", "conditions": list(lost)}), - "depth" => serde_json::json!({"type": "depth", - "min_depth": opt("min_required_depth"), "max_depth": opt("max_possible_depth")}), - "altitude" => serde_json::json!({"type": "altitude", - "bottom": opt("bottom_cutoff_y"), "top": opt("top_cutoff_y")}), - "random_chance" => serde_json::json!({"type": "random_chance", "chance": opt("chance")}), - "rotation" => serde_json::json!({"type": "rotation", "rotations": opt("rotations")}), - "piece_in_horizontal_direction" => { - // "yungsapi:all" (or no list) matches any piece. - let pieces: Vec = c["pieces"].as_array().cloned().unwrap_or_default(); - let any = pieces.is_empty() || pieces.iter().any(|p| p == "yungsapi:all"); - serde_json::json!({"type": "piece_in_horizontal_direction", - "pieces": if any { Vec::new() } else { pieces }, - "range": opt("range"), "rotation": opt("rotation")}) - } - // The game reads "yungsapi:all" (or no list) as any piece. - "piece_in_range" => serde_json::json!({"type": "piece_in_range", - "pieces": c.get("pieces").cloned().unwrap_or_else(|| Vec::::new().into()), - "horizontal_range": opt("horizontal_range"), "above_range": opt("above_range"), - "below_range": opt("below_range")}), - "mod_loaded" if c["modid"] == "minecraft" => serde_json::json!({"type": "true"}), - "mod_loaded" => serde_json::json!({"type": "false"}), - _ => { - *lost.entry(format!("yungsapi condition {t}")).or_default() += 1; - serde_json::json!({"type": "false"}) - } - } -} - /// Moves a Repurposed Structures or Moog's jigsaw's start rules under /// `horizon:start_checks`, and counts the layout rules it loses. `liquid` is /// the block its no-start-in-liquid rule reads. -fn start_checks(v: &mut Value, liquid: &str, lost: &mut BTreeMap, limited: bool) { +pub(crate) fn start_checks( + v: &mut Value, + liquid: &str, + lost: &mut BTreeMap, + limited: bool, +) { let Some(o) = v.as_object_mut() else { return; }; @@ -1043,7 +626,7 @@ fn moogs_spacing(p: &mut Value, lost: &mut BTreeMap) { /// An advanced random spread's minimum distance from the world origin and /// its super exclusion zone (sets named by a tag) under `horizon:` keys. -fn placement_rules( +pub(crate) fn placement_rules( p: &mut Value, set_tags: &BTreeMap>, lost: &mut BTreeMap, @@ -1115,65 +698,6 @@ fn mo_placement(p: &mut Value, lost: &mut BTreeMap) -> bool { true } -/// One of YUNG's placements as vanilla's random spread with `horizon:` keys: -/// the enhanced exclusion zone as `horizon:exclusion_zone`; the temples' -/// ocean and river search (findBiomeHorizontal around the chunk's middle -/// block at y 120, 48 blocks, every 2 quarts) as `horizon:avoid_biomes`; the -/// strongholds' rings as `horizon:ring_sections`. -fn yung_placement( - t: &str, - p: &mut Value, - set_tags: &BTreeMap>, - lost: &mut BTreeMap, -) { - placement_rules(p, set_tags, lost); - p["type"] = "minecraft:random_spread".into(); - let Some(o) = p.as_object_mut() else { - return; - }; - match t { - "betterdeserttemples:desert_temple" | "betterjungletemples:jungle_temple" => { - o.insert( - "horizon:avoid_biomes".into(), - serde_json::json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"], - "radius": 48, "step": 2, "y": 120}), - ); - } - "betterstrongholds:stronghold" => { - let mut rings = serde_json::Map::new(); - for (from, to) in [ - ("chunk_distance_to_first_ring", "distance_to_first_ring"), - ("ring_chunk_thickness", "thickness"), - ("max_ring_section", "max_section"), - ] { - if let Some(n) = o.remove(from) { - rings.insert(to.into(), n); - } - } - o.insert("horizon:ring_sections".into(), rings.into()); - } - _ => {} - } -} - -/// Marks a YUNG's structure that the game can start (its type is vanilla's -/// after the upgrade) with the vanilla type its mod turns off, under -/// `horizon:disables`. One the game cannot start leaves the vanilla -/// structure in place, so the world keeps one of the two. -pub fn disables(id: &str, v: &mut Value) -> bool { - let Some((_, vanilla)) = YUNG_REPLACES.iter().find(|(s, _)| id.starts_with(s)) else { - return false; - }; - if !v["type"] - .as_str() - .is_some_and(|t| t.starts_with("minecraft:")) - { - return false; - } - v["horizon:disables"] = serde_json::json!([vanilla]); - true -} - /// The mod's structure set tags (`data//tags/worldgen/structure_set/`), /// by tag id, with the tags they include expanded. Optional entries /// (`{"id": ..., "required": false}`) count as their id. @@ -1590,94 +1114,6 @@ mod tests { assert_eq!(report.rules_lost["super_exclusion_zone"], 1); } - #[test] - fn yungs_jigsaws_keep_their_rules() { - let mut report = Upgrade::default(); - let mut s = json!({"type": "yungsapi:yung_jigsaw", "start_pool": "y:start", "size": 20, - "max_y": 60, "x_offset_in_chunk": 0, "max_distance_from_center": 80, - "enhanced_terrain_adaptation": {"type": "yungsapi:custom", "kernel_size": 24, - "kernel_distance": 24, "top": "carve", "bottom": "none"}}); - assert!(upgrade("structure", &mut s, &mut report, &NO_TAGS)); - assert_eq!(s["type"], "minecraft:jigsaw"); - assert_eq!(s["horizon:yungsapi"], json!({"max_y": 60})); - assert_eq!( - s["horizon:enhanced_terrain_adaptation"], - json!({"kernel_size": 24, "kernel_distance": 24, "top": "carve", "bottom": "none", - "rigid_junctions": true, "inflate": true}) - ); - for gone in ["max_y", "x_offset_in_chunk", "enhanced_terrain_adaptation"] { - assert!(s.get(gone).is_none(), "{gone}"); - } - // Better Dungeons' small Nether dungeon is the same jigsaw. - let mut nether = json!({"type": "betterdungeons:small_nether_dungeon", - "start_pool": "betterdungeons:small_nether_dungeon", "size": 10, - "start_jigsaw_name": "betterdungeons:small_nether_dungeon_anchor", - "max_distance_from_center": 80, "liquid_settings": "ignore_waterlogging"}); - assert!(upgrade("structure", &mut nether, &mut report, &NO_TAGS)); - assert_eq!(nether["type"], "minecraft:jigsaw"); - assert_eq!(nether["horizon:yungsapi"], json!({})); - assert_eq!( - nether["horizon:enhanced_terrain_adaptation"], - json!({"kernel_size": 0, "kernel_distance": 0, "top": "none", "bottom": "none", - "rigid_junctions": true, "inflate": true}) - ); - assert_eq!( - nether["start_jigsaw_name"], - "betterdungeons:small_nether_dungeon_anchor" - ); - assert!(report.unsupported.is_empty()); - let mut pool = json!({"elements": [{"weight": 3, "element": { - "element_type": "yungsapi:yung_single_element", "location": "y:room", - "processors": "minecraft:empty", "projection": "rigid", - "name": "room", "max_count": 2, "min_required_depth": 1, "is_priority": true, - "ignore_bounds": false, "deadend_pool": "y:end", - "modifiers": [ - {"condition": {"type": "yungsapi:piece_in_range", "pieces": ["y:pillar"], - "above_range": 40}, - "target_selector": {"type": "yungsapi:self"}, - "actions": [{"type": "yungsapi:transform", "output": ["y:covered"], "x_offset": -1}, - {"type": "yungsapi:delay_generation"}, {"type": "yungsapi:spin"}]}, - {"condition": {"type": "yungsapi:always_true"}, - "target_selector": {"type": "yungsapi:all"}, "actions": []}], - "enhanced_terrain_adaptation": {"type": "yungsapi:carved_top_no_beard_small"}, - "condition": {"type": "yungsapi:all_of", "conditions": [ - {"type": "yungsapi:piece_in_horizontal_direction", "pieces": ["yungsapi:all"], - "range": 5, "rotation": "none"}, - {"type": "yungsapi:not", "condition": {"type": "yungsapi:mod_loaded", "modid": "create"}}, - {"type": "yungsapi:biome", "biomes": []}]}}}]}); - assert!(upgrade("template_pool", &mut pool, &mut report, &NO_TAGS)); - let e = &pool["elements"][0]["element"]; - assert_eq!(e["element_type"], "minecraft:single_pool_element"); - assert_eq!(e["location"], "y:room"); - assert_eq!( - e["horizon:yungsapi"], - json!({"name": "room", "max_count": 2, "min_depth": 1, "priority": true, - "ignore_bounds": false, "condition": {"type": "all_of", "conditions": [ - {"type": "piece_in_horizontal_direction", "pieces": [], "range": 5, "rotation": "none"}, - {"type": "not", "condition": {"type": "false"}}, - {"type": "false"}]}, - "deadend_pool": "y:end", - "modifiers": [{"condition": {"type": "piece_in_range", "pieces": ["y:pillar"], - "horizontal_range": null, "above_range": 40, "below_range": null}, - "actions": [{"type": "transform", "output": ["y:covered"], "offset": [-1, 0, 0]}, - {"type": "delay_generation"}]}]}) - ); - assert!(e.get("deadend_pool").is_none() && e.get("modifiers").is_none()); - assert_eq!( - e["horizon:enhanced_terrain_adaptation"], - json!({"kernel_size": 12, "kernel_distance": 6, "top": "carve", "bottom": "none"}) - ); - assert_eq!( - report.rules_lost, - BTreeMap::from([ - ("yungsapi condition yungsapi:biome".into(), 1), - ("yungsapi modifier action yungsapi:spin".into(), 1), - ("yungsapi modifier target yungsapi:all".into(), 1), - ]) - ); - assert!(report.unsupported.is_empty()); - } - #[test] fn drops_processors_written_in_java() { let mut report = Upgrade::default(); @@ -1722,59 +1158,6 @@ mod tests { ); } - #[test] - fn yungs_placements_keep_their_rules() { - let tags = BTreeMap::from([( - "bf:avoid".to_owned(), - vec!["minecraft:nether_complexes".to_owned()], - )]); - let mut report = Upgrade::default(); - let mut fortress = json!({"placement": {"type": "yungsapi:enhanced_random_spread", - "salt": 1, "spacing": 30, "separation": 20, - "enhanced_exclusion_zone": {"other_set": "#bf:avoid", "chunk_count": 10}}}); - assert!(upgrade("structure_set", &mut fortress, &mut report, &tags)); - assert_eq!( - fortress["placement"], - json!({"type": "minecraft:random_spread", "salt": 1, "spacing": 30, "separation": 20, - "horizon:exclusion_zone": {"other_sets": ["minecraft:nether_complexes"], "chunk_count": 10}}) - ); - let mut temple = json!({"placement": {"type": "betterdeserttemples:desert_temple", - "salt": 2, "spacing": 30, "separation": 20, - "exclusion_zone": {"other_set": "minecraft:villages", "chunk_count": 6}}}); - assert!(upgrade("structure_set", &mut temple, &mut report, &tags)); - assert_eq!(temple["placement"]["type"], "minecraft:random_spread"); - assert_eq!(temple["placement"]["exclusion_zone"]["chunk_count"], 6); - assert_eq!( - temple["placement"]["horizon:avoid_biomes"], - json!({"biomes": ["#minecraft:is_river", "#minecraft:is_ocean"], - "radius": 48, "step": 2, "y": 120}) - ); - let mut stronghold = json!({"placement": {"type": "betterstrongholds:stronghold", - "salt": 3, "spacing": 85, "separation": 50, - "chunk_distance_to_first_ring": 80, "ring_chunk_thickness": 96}}); - assert!(upgrade( - "structure_set", - &mut stronghold, - &mut report, - &tags - )); - assert_eq!( - stronghold["placement"], - json!({"type": "minecraft:random_spread", "salt": 3, "spacing": 85, "separation": 50, - "horizon:ring_sections": {"distance_to_first_ring": 80, "thickness": 96}}) - ); - assert_eq!(report.mapped, 3); - assert!(report.unsupported.is_empty()); - // The vanilla counterpart is turned off only for a structure the game starts. - let mut ported = json!({"type": "minecraft:jigsaw"}); - assert!(disables("betterstrongholds:stronghold", &mut ported)); - assert_eq!(ported["horizon:disables"], json!(["minecraft:stronghold"])); - let mut java = json!({"type": "bettermineshafts:mineshaft"}); - assert!(!disables("bettermineshafts:mineshaft_oak", &mut java)); - let mut circle = json!({"type": "minecraft:jigsaw"}); - assert!(!disables("betterwitchhuts:witch_circle", &mut circle)); - } - #[test] fn piece_limited_jigsaws_keep_their_layout() { let mut report = Upgrade::default(); @@ -1886,88 +1269,6 @@ mod tests { assert_eq!(report.mapped, 0); } - #[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 ctov_joins_vanillas_villages_and_outposts() { - let sets = code_set_entries("ctov"); - let (file, set, outposts) = &sets[0]; - assert_eq!( - (*file, *set), - ("pillager_outposts", "minecraft:pillager_outposts") - ); - assert_eq!(outposts.len(), 11); - assert!(outposts.iter().all(|(_, w)| *w == 1)); - let (_, set, villages) = &sets[1]; - assert_eq!(*set, "minecraft:villages"); - assert_eq!(villages.len(), 63); - assert_eq!(villages[0], ("ctov:small/village_beach".into(), 10)); - assert_eq!(villages[21], ("ctov:medium/village_beach".into(), 4)); - assert_eq!( - villages[62], - ("ctov:large/village_taiga_fortified".into(), 1) - ); - assert!(code_set_entries("mvs").is_empty()); - } - #[test] fn convention_tags_include_theirs() { let conventions = BTreeMap::from([ diff --git a/crates/horizon-prepare/src/java.rs b/crates/horizon-prepare/src/java.rs index a159fb055..b4023b7d1 100644 --- a/crates/horizon-prepare/src/java.rs +++ b/crates/horizon-prepare/src/java.rs @@ -1,6 +1,7 @@ //! The JDK that compiles and runs the vanilla exporters. They call Mojang's own code, so they //! stay Java; everything around them is here. +use std::ffi::OsStr; use std::fs; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; @@ -13,6 +14,20 @@ pub struct Jdk { const TIMEOUT: Duration = Duration::from_secs(3600); +/// Exporters and JDK probes write to pipes or log files: on Windows they open no terminal. +fn command(program: impl AsRef) -> Command { + let command = Command::new(program); + #[cfg(windows)] + let command = { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + let mut command = command; + command.creation_flags(CREATE_NO_WINDOW); + command + }; + command +} + fn executable(dir: &Path, name: &str) -> PathBuf { dir.join(if cfg!(windows) { format!("{name}.exe") @@ -29,7 +44,7 @@ fn on_path(name: &str) -> Option { /// The major version `javac -version` reports ("javac 25.0.1" → 25; "javac 1.8.0" → 8). fn javac_major(javac: &Path) -> Result { - let output = Command::new(javac) + let output = command(javac) .arg("-version") .stdin(Stdio::null()) .output() @@ -183,7 +198,7 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result { candidates.push((javac, java, "PATH")); } if cfg!(target_os = "macos") { - if let Ok(out) = Command::new("/usr/libexec/java_home") + if let Ok(out) = command("/usr/libexec/java_home") .args(["-v", &major.to_string()]) .stderr(Stdio::null()) .output() @@ -260,7 +275,7 @@ impl Jdk { /// `javac --release -proc:none` with Python's `subprocess.run(..., check=True, /// stdout=log, stderr=STDOUT, timeout=3600)`. pub fn javac(&self, major: i64, args: &[String], log: &fs::File) -> Result<(), String> { - let mut command = Command::new(&self.javac); + let mut command = command(&self.javac); command .args(["--release", &major.to_string(), "-proc:none"]) .args(args); @@ -268,7 +283,7 @@ impl Jdk { } pub fn java(&self, args: &[String], cwd: Option<&Path>, log: &fs::File) -> Result<(), String> { - let mut command = Command::new(&self.java); + let mut command = command(&self.java); command.args(args); if let Some(dir) = cwd { command.current_dir(dir); diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 24f163a9b..c7e443c7d 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -17,7 +17,7 @@ pub mod pyjson; mod sounds; mod survival; -pub use sounds::{fonts, packs, panorama, sounds, BUILT_IN_PACKS}; +pub use sounds::{fonts, languages, packs, panorama, sounds, BUILT_IN_PACKS}; use pyjson::Value; use sha2::Digest; @@ -676,13 +676,15 @@ fn steps( } // The playable client needs every client asset (textures, models, fonts, GUI) - // and every data-pack resource (worldgen, recipes, loot tables, tags). + // and every data-pack resource (worldgen, recipes, loot tables, tags), and + // the vanilla pack's icon (`pack.png`) for the pack screen. (run.log)("Copying the client's assets and data"); let mut count = 0usize; let mut client = open_zip(&run.client)?; let version = pyjson::loads(&zip_text(&mut client, "version.json")?)?; for name in zip_names(&client) { - if !(name.starts_with("assets/") || name.starts_with("data/")) || name.ends_with('/') { + let wanted = name.starts_with("assets/") || name.starts_with("data/") || name == "pack.png"; + if !wanted || name.ends_with('/') { continue; } let relative = member_path(&name, "Invalid resource path")?; diff --git a/crates/horizon-prepare/src/main.rs b/crates/horizon-prepare/src/main.rs index 395821283..db64ca19d 100644 --- a/crates/horizon-prepare/src/main.rs +++ b/crates/horizon-prepare/src/main.rs @@ -20,6 +20,7 @@ Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [- horizon-prepare panorama [--minecraft-dir PATH] [--root PATH] horizon-prepare fonts [--minecraft-dir PATH] [--root PATH] horizon-prepare packs [--minecraft-dir PATH] [--root PATH] + horizon-prepare languages [--minecraft-dir PATH] [--root PATH] --prepare Import the pinned game files from your own copy first --server-jar PATH The pinned server jar you downloaded yourself @@ -36,7 +37,8 @@ The resources go to /.local/horizon-client/; pass that to horizon horizon-prepare panorama repairs the classic menu background in existing resources without Java. horizon-prepare fonts adds the GNU Unifont glyphs (characters the bitmap fonts lack) the same way. horizon-prepare packs adds the built-in Programmer Art and High Contrast resource packs the same way. -Full preparation also imports all three after extracting the client JAR's placeholders. +horizon-prepare languages adds the bundled languages and the language list the JAR lacks the same way. +Full preparation also imports all four after extracting the client JAR's placeholders. horizon-prepare sounds copies the pinned version's sounds (about 380 MB) from the official launcher's asset store into the same folder, checking every file. It is optional: without it the @@ -68,8 +70,12 @@ fn main() -> ExitCode { }; let mut root = None; let mut args = std::env::args_os().skip(1).peekable(); - let assets = - args.next_if(|a| matches!(a.to_str(), Some("sounds" | "panorama" | "fonts" | "packs"))); + let assets = args.next_if(|a| { + matches!( + a.to_str(), + Some("sounds" | "panorama" | "fonts" | "packs" | "languages") + ) + }); while let Some(arg) = args.next() { let text = arg.to_string_lossy().into_owned(); let (flag, inline) = match text.split_once('=') { @@ -138,6 +144,9 @@ fn main() -> ExitCode { Some("packs") => { horizon_prepare::packs(&options.root, options.minecraft_dir.as_deref(), &log) } + Some("languages") => { + horizon_prepare::languages(&options.root, options.minecraft_dir.as_deref(), &log) + } _ => horizon_prepare::prepare(&options, &log), }; match result { diff --git a/crates/horizon-prepare/src/sounds.rs b/crates/horizon-prepare/src/sounds.rs index 120d75a1a..15d4a7a08 100644 --- a/crates/horizon-prepare/src/sounds.rs +++ b/crates/horizon-prepare/src/sounds.rs @@ -112,6 +112,20 @@ pub fn fonts(root: &Path, minecraft: Option<&Path>, log: Log) -> Result.json` the strings each one draws (#1272). +/// Also usable on already-prepared resources without Java. +pub fn languages(root: &Path, minecraft: Option<&Path>, log: Log) -> Result { + copy_assets(root, minecraft, log, is_language, "Language", &LANGUAGES) +} + +const LANGUAGES: [&str; 1] = ["pack.mcmeta"]; + +fn is_language(name: &str) -> bool { + name == "pack.mcmeta" || name.starts_with("minecraft/lang/") +} + /// Full preparation can run from cached JARs without an official launcher install. pub(crate) fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) { if let Err(error) = panorama(root, minecraft, log) { @@ -129,6 +143,11 @@ pub(crate) fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) { "Programmer Art and High Contrast not imported: {error}; run horizon-prepare packs later" )); } + if let Err(error) = languages(root, minecraft, log) { + log(&format!( + "Languages not imported: {error}; run horizon-prepare languages later" + )); + } } const PANORAMA: [&str; 7] = [ @@ -278,6 +297,15 @@ mod tests { } fn with_panorama(name: &str, panorama: &[&'static str]) -> Fixture { + Self::with_extras(name, panorama, &[]) + } + + /// The same store with extra index entries, for the files the index alone holds. + fn with_extras( + name: &str, + panorama: &[&'static str], + extras: &[(&'static str, &'static [u8])], + ) -> Fixture { let dir = std::env::temp_dir().join(format!( "horizon-prepare-sounds-{name}-{}", std::process::id() @@ -302,6 +330,9 @@ mod tests { // Distinct object bytes let the test catch swapped faces too. objects.push((name, name.as_bytes().to_vec())); } + for &(name, data) in extras { + objects.push((name, data.to_vec())); + } let mut index = String::from("{\"objects\": {"); for (i, (name, data)) in objects.iter().enumerate() { let hash = sha1_hex(data); @@ -391,6 +422,32 @@ mod tests { f.run().unwrap(); } + #[test] + fn languages_come_from_the_asset_store() { + // The client JAR carries `en_us` alone, so every other language and the list in + // `pack.mcmeta` come from the index (#1272). + let f = Fixture::with_extras( + "languages", + &[], + &[("pack.mcmeta", b"{\"language\": {\"fr_fr\": {}}}")], + ); + let lines = std::cell::RefCell::new(Vec::new()); + let target = languages(&f.root, Some(&f.minecraft), &|l| { + lines.borrow_mut().push(l.to_string()) + }) + .unwrap(); + assert!(fs::read(target.join("assets/pack.mcmeta")) + .unwrap() + .starts_with(b"{\"language\"")); + assert_eq!( + fs::read(target.join("assets/minecraft/lang/fr_fr.json")).unwrap(), + b"{}" + ); + // Each entry point copies its own set: the sounds stay where they belong. + assert!(!target.join("assets/minecraft/sounds.json").exists()); + assert_eq!(*lines.borrow(), ["Language assets ready: 2 files, 0.0 MB"]); + } + /// #1076: the launcher holds an index Mojang republished under the same id, so its SHA-1 /// is not the one in the version JSON. A known one is used quietly, an unknown one with a /// line in the log; the sounds come through either way. @@ -539,7 +596,10 @@ mod tests { lines[1..], [ "Font assets ready: 2 files, 0.0 MB", - "Built-in pack assets ready: 2 files, 0.0 MB" + "Built-in pack assets ready: 2 files, 0.0 MB", + // This store has no `pack.mcmeta`, so the languages report it. + "Languages not imported: pack.mcmeta is missing from the asset index; \ + run horizon-prepare languages later" ] ), _ => { @@ -549,9 +609,14 @@ mod tests { && lines[2].ends_with("; run horizon-prepare packs later"), "{lines:?}" ); + assert!( + lines[3].starts_with("Languages not imported: ") + && lines[3].ends_with("; run horizon-prepare languages later"), + "{lines:?}" + ); } } - assert_eq!(lines.len(), 3); + assert_eq!(lines.len(), 4); for name in PANORAMA { assert_eq!(fs::read(target.join(name)).unwrap(), b"jar placeholder"); } diff --git a/crates/horizon-protocol/Cargo.toml b/crates/horizon-protocol/Cargo.toml index 71b93a1fe..90a85cbf5 100644 --- a/crates/horizon-protocol/Cargo.toml +++ b/crates/horizon-protocol/Cargo.toml @@ -17,6 +17,10 @@ sha1 = "0.10" # Secure chat: SHA256withRSA message signatures. sha2 = "0.10" +# The name servers of Windows' network adapters, for Minecraft SRV redirects. +[target.'cfg(windows)'.dependencies] +ipconfig = "0.3.4" + # Its own name, not `probe`: Cargo copies every crate's examples into one target//examples. [[example]] name = "protocol_probe" diff --git a/crates/horizon-protocol/src/connection.rs b/crates/horizon-protocol/src/connection.rs index 8f7ae28cc..e89ce5de1 100644 --- a/crates/horizon-protocol/src/connection.rs +++ b/crates/horizon-protocol/src/connection.rs @@ -191,6 +191,19 @@ impl Connection { .to_socket_addrs() .map_err(|e| Error::new(format!("Unknown host {host}: {e}")))? .collect(); + Self::connect_addresses(host, addrs, timeout) + } + /// Minecraft's SRV redirect applies to the socket destination only. Callers + /// keep the player's original host and port in the protocol handshake. + pub fn connect_server(host: &str, port: u16, timeout: Duration) -> Result { + let addrs = crate::resolver::resolve(host, port)?; + Self::connect_addresses(host, addrs, timeout) + } + fn connect_addresses( + host: &str, + addrs: Vec, + timeout: Duration, + ) -> Result { let mut last = Error::new(format!("Unknown host {host}")); for addr in addrs { match TcpStream::connect_timeout(&addr, timeout) { diff --git a/crates/horizon-protocol/src/lib.rs b/crates/horizon-protocol/src/lib.rs index 855df6a5a..f0bea2ca2 100644 --- a/crates/horizon-protocol/src/lib.rs +++ b/crates/horizon-protocol/src/lib.rs @@ -12,6 +12,7 @@ pub mod ids; pub mod item; pub mod packets; pub mod registry; +mod resolver; pub mod rsa; pub mod secure_chat; pub mod servers; diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 206ed9aff..42e3ba686 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -13,8 +13,8 @@ use crate::{ packets::{ Empty, configuration::{ - ClientInformation, CustomPayload, Disconnect, KeepAlive, Ping, ResourcePackPush, - ResourcePackResponse, UpdateTags, + ClientInformation, CustomPayload, Disconnect, KeepAlive, Ping, ResourcePackPop, + ResourcePackPush, ResourcePackResponse, UpdateTags, }, login::Property, }, @@ -1640,6 +1640,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { RemoveEntities(RemoveEntities) = REMOVE_ENTITIES, RemoveMobEffect(RemoveMobEffect) = REMOVE_MOB_EFFECT, ResetScore(ResetScore) = RESET_SCORE, + ResourcePackPop(ResourcePackPop) = RESOURCE_PACK_POP, ResourcePackPush(ResourcePackPush) = RESOURCE_PACK_PUSH, Respawn(Respawn) = RESPAWN, RotateHead(RotateHead) = ROTATE_HEAD, diff --git a/crates/horizon-protocol/src/resolver.rs b/crates/horizon-protocol/src/resolver.rs new file mode 100644 index 000000000..6cd2eca57 --- /dev/null +++ b/crates/horizon-protocol/src/resolver.rs @@ -0,0 +1,145 @@ +//! Minecraft server DNS redirects (`ServerRedirectHandler` / `ServerNameResolver`). +//! Port 25565 asks for `_minecraft._tcp.`'s SRV record; no record or a +//! failed query leaves the original address in use. The protocol handshake +//! still uses that original address. +use crate::{Error, Result}; +use std::net::{IpAddr, SocketAddr, ToSocketAddrs}; + +mod dns; + +pub(crate) fn resolve(host: &str, port: u16) -> Result> { + resolve_with(host, port, srv_redirect, |host, port| { + (host, port) + .to_socket_addrs() + .map(|addrs| addrs.collect()) + .map_err(|e| Error::new(format!("Unknown host {host}: {e}"))) + }) +} + +fn resolve_with( + host: &str, + port: u16, + srv: impl FnOnce(&str) -> Option<(String, u16)>, + addresses: impl FnOnce(&str, u16) -> Result>, +) -> Result> { + // Vanilla also asks for `_minecraft._tcp.127.0.0.1`, which never has a + // record: IP literals and localhost skip the query. + if port == 25565 + && host.parse::().is_err() + && host != "localhost" + && let Some((target, target_port)) = + srv(&format!("_minecraft._tcp.{}.", host.trim_end_matches('.'))) + { + // No second SRV lookup at the target, and no fallback to the original + // host when the target is unknown. + return addresses(&target, target_port); + } + addresses(host, port) +} + +fn srv_redirect(name: &str) -> Option<(String, u16)> { + dns::query_srv(name, &dns::system_name_servers(), dns::SERVER_TIMEOUT) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn redirects_default_port_even_when_the_original_host_has_no_addresses() { + let result = resolve_with( + "play.example.org", + 25565, + |name| { + assert_eq!(name, "_minecraft._tcp.play.example.org."); + Some(("backend.example.org.".into(), 25570)) + }, + |host, port| { + assert_eq!((host, port), ("backend.example.org.", 25570)); + Ok(vec!["127.0.0.1:25570".parse().unwrap()]) + }, + ) + .unwrap(); + assert_eq!( + result, + vec!["127.0.0.1:25570".parse::().unwrap()] + ); + } + + #[test] + fn no_record_or_lookup_failure_keeps_the_original_address() { + resolve_with( + "play.example.org", + 25565, + |_| None, + |host, port| { + assert_eq!((host, port), ("play.example.org", 25565)); + Ok(vec![]) + }, + ) + .unwrap(); + } + + #[test] + fn explicit_nondefault_ports_and_ip_literals_do_not_query_srv() { + for (host, port) in [ + ("play.example.org", 25570), + ("127.0.0.1", 25565), + ("::1", 25565), + ("localhost", 25565), + ] { + resolve_with( + host, + port, + |_| panic!("unexpected SRV query"), + |actual, actual_port| { + assert_eq!((actual, actual_port), (host, port)); + Ok(vec![]) + }, + ) + .unwrap(); + } + } + + #[test] + fn fully_qualified_host_does_not_get_a_second_trailing_dot() { + resolve_with( + "play.example.org.", + 25565, + |name| { + assert_eq!(name, "_minecraft._tcp.play.example.org."); + None + }, + |_, _| Ok(vec![]), + ) + .unwrap(); + } + + #[test] + fn unknown_redirect_target_does_not_fall_back_to_the_original() { + let result = resolve_with( + "play.example.org", + 25565, + |_| Some(("missing.example.org.".into(), 25570)), + |host, _| { + assert_eq!(host, "missing.example.org."); + Err(Error::new("unknown redirected host")) + }, + ); + assert_eq!(result.unwrap_err().to_string(), "unknown redirected host"); + } + + #[test] + fn literal_address_can_connect_without_dns() { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + let connection = crate::connection::Connection::connect_server( + "127.0.0.1", + address.port(), + std::time::Duration::from_secs(1), + ) + .unwrap(); + let (accepted, _) = listener.accept().unwrap(); + drop((connection, accepted)); + } +} diff --git a/crates/horizon-protocol/src/resolver/dns.rs b/crates/horizon-protocol/src/resolver/dns.rs new file mode 100644 index 000000000..a91156a77 --- /dev/null +++ b/crates/horizon-protocol/src/resolver/dns.rs @@ -0,0 +1,339 @@ +//! The SRV question as JNDI's DNS client asks it: the system's name servers in +//! turn, one UDP try of 1 s (`com.sun.jndi.dns.timeout.retries` = 1), TCP when +//! the reply is truncated, and the answer's first SRV record. By hand, so the +//! game needs no async runtime or resolver library for one question. +use std::{ + io::{Read, Write}, + net::{SocketAddr, TcpStream, UdpSocket}, + time::Duration, +}; + +const TYPE_SRV: u16 = 33; +/// JNDI's `com.sun.jndi.dns.timeout.initial`, per name server. +pub(super) const SERVER_TIMEOUT: Duration = Duration::from_secs(1); + +/// JNDI reads them from resolv.conf on Unix and from the network adapters on +/// Windows. +#[cfg(unix)] +pub(super) fn system_name_servers() -> Vec { + std::fs::read_to_string("/etc/resolv.conf") + .map_or_else(|_| Vec::new(), |conf| name_servers(&conf)) +} + +#[cfg(windows)] +pub(super) fn system_name_servers() -> Vec { + let mut servers = Vec::new(); + for adapter in ipconfig::get_adapters().unwrap_or_default() { + if adapter.oper_status() != ipconfig::OperStatus::IfOperStatusUp { + continue; + } + for &ip in adapter.dns_servers() { + let server = SocketAddr::new(ip, 53); + if !servers.contains(&server) { + servers.push(server); + } + } + } + servers +} + +#[cfg(not(any(unix, windows)))] +pub(super) fn system_name_servers() -> Vec { + Vec::new() +} + +/// `nameserver` lines of resolv.conf, in order. +#[cfg(any(unix, test))] +fn name_servers(conf: &str) -> Vec { + conf.lines() + .filter_map(|line| line.strip_prefix("nameserver")) + .filter_map(|rest| rest.split_whitespace().next()) + .filter_map(|ip| ip.split('%').next()?.parse::().ok()) + .map(|ip| SocketAddr::new(ip, 53)) + .collect() +} + +enum Reply { + /// The server answered: the first SRV record, if any. + Answer(Option<(String, u16)>), + Truncated, + /// No reply, a server failure or a malformed reply: ask the next server. + Unusable, +} + +pub(super) fn query_srv( + name: &str, + servers: &[SocketAddr], + timeout: Duration, +) -> Option<(String, u16)> { + let mut id = [0; 2]; + getrandom::fill(&mut id).ok()?; + let id = u16::from_be_bytes(id); + let query = encode_query(id, name)?; + for &server in servers { + let reply = match ask_udp(server, &query, timeout).map(|reply| parse_reply(id, &reply)) { + Some(Reply::Truncated) => ask_tcp(server, &query, timeout) + .map_or(Reply::Unusable, |reply| parse_reply(id, &reply)), + reply => reply.unwrap_or(Reply::Unusable), + }; + if let Reply::Answer(srv) = reply { + return srv; + } + } + None +} + +fn ask_udp(server: SocketAddr, query: &[u8], timeout: Duration) -> Option> { + let local: SocketAddr = if server.is_ipv4() { + ([0, 0, 0, 0], 0).into() + } else { + ([0u16; 8], 0).into() + }; + let socket = UdpSocket::bind(local).ok()?; + socket.set_read_timeout(Some(timeout)).ok()?; + socket.connect(server).ok()?; + socket.send(query).ok()?; + let mut buf = vec![0; 512]; + let len = socket.recv(&mut buf).ok()?; + buf.truncate(len); + Some(buf) +} + +fn ask_tcp(server: SocketAddr, query: &[u8], timeout: Duration) -> Option> { + let mut stream = TcpStream::connect_timeout(&server, timeout).ok()?; + stream.set_read_timeout(Some(timeout)).ok()?; + let mut framed = (query.len() as u16).to_be_bytes().to_vec(); + framed.extend_from_slice(query); + stream.write_all(&framed).ok()?; + let mut len = [0; 2]; + stream.read_exact(&mut len).ok()?; + let mut buf = vec![0; u16::from_be_bytes(len) as usize]; + stream.read_exact(&mut buf).ok()?; + Some(buf) +} + +/// A recursive SRV question (RFC 1035 §4.1) for an absolute name. +fn encode_query(id: u16, name: &str) -> Option> { + let mut msg = Vec::with_capacity(18 + name.len()); + msg.extend_from_slice(&id.to_be_bytes()); + msg.extend_from_slice(&[0x01, 0x00, 0, 1, 0, 0, 0, 0, 0, 0]); // RD; one question + for label in name.trim_end_matches('.').split('.') { + if label.is_empty() || label.len() > 63 { + return None; + } + msg.push(label.len() as u8); + msg.extend_from_slice(label.as_bytes()); + } + msg.push(0); + if msg.len() - 12 > 255 { + return None; + } + msg.extend_from_slice(&TYPE_SRV.to_be_bytes()); + msg.extend_from_slice(&1u16.to_be_bytes()); // IN + Some(msg) +} + +fn parse_reply(id: u16, msg: &[u8]) -> Reply { + parse_answer(id, msg).unwrap_or(Reply::Unusable) +} + +fn parse_answer(id: u16, msg: &[u8]) -> Option { + let u16_at = |at: usize| Some(u16::from_be_bytes([*msg.get(at)?, *msg.get(at + 1)?])); + let flags = u16_at(2)?; + if u16_at(0)? != id || flags & 0x8000 == 0 { + return None; + } + if flags & 0x0200 != 0 { + return Some(Reply::Truncated); + } + match flags & 0xf { + 0 => {} + 3 => return Some(Reply::Answer(None)), // NXDOMAIN + _ => return None, + } + let mut at = 12; + for _ in 0..u16_at(4)? { + at = read_name(msg, at)?.1 + 4; + } + for _ in 0..u16_at(6)? { + at = read_name(msg, at)?.1; + let (kind, len) = (u16_at(at)?, u16_at(at + 8)? as usize); + let data = at + 10; + msg.get(data..data + len)?; + if kind == TYPE_SRV && len >= 7 { + let (target, _) = read_name(msg, data + 6)?; + return Some(Reply::Answer(Some((target, u16_at(data + 4)?)))); + } + at = data + len; + } + Some(Reply::Answer(None)) +} + +/// The name at `at`, absolute (`a.b.`), and where the record continues. +fn read_name(msg: &[u8], mut at: usize) -> Option<(String, usize)> { + let mut name = String::new(); + let mut end = None; + // Pointers must go backwards; the bound ends a loop of labels and pointers. + for _ in 0..128 { + let len = *msg.get(at)? as usize; + match len { + 0 => { + if name.is_empty() { + name.push('.'); + } + return Some((name, end.unwrap_or(at + 1))); + } + 0xc0.. => { + let target = (len & 0x3f) << 8 | *msg.get(at + 1)? as usize; + if target >= at { + return None; + } + end.get_or_insert(at + 2); + at = target; + } + 1..=63 => { + let label = msg.get(at + 1..at + 1 + len)?; + name.push_str(std::str::from_utf8(label).ok()?); + name.push('.'); + at += 1 + len; + } + _ => return None, + } + } + None +} + +#[cfg(test)] +mod tests { + use super::*; + + const NAME: &str = "_minecraft._tcp.play.example.org."; + + /// The reply a server gives to `query`: its question, then a CNAME and the + /// SRV records, each owner name compressed to the question's name. + fn reply(query: &[u8], rcode: u8, records: &[(u16, &str)]) -> Vec { + let mut msg = query.to_vec(); + msg[2] |= 0x80; + msg[3] = 0x80 | rcode; + let answers = records.len() as u16 + u16::from(!records.is_empty()); + msg[6..8].copy_from_slice(&answers.to_be_bytes()); + if !records.is_empty() { + // CNAME first: the parser must step over records of other types. + msg.extend_from_slice(&[0xc0, 12, 0, 5, 0, 1, 0, 0, 0, 60, 0, 2, 0xc0, 12]); + } + for &(port, target) in records { + let mut rdata = vec![0, 1, 0, 1]; + rdata.extend_from_slice(&port.to_be_bytes()); + for label in target.trim_end_matches('.').split('.') { + rdata.push(label.len() as u8); + rdata.extend_from_slice(label.as_bytes()); + } + rdata.push(0); + msg.extend_from_slice(&[0xc0, 12, 0, 33, 0, 1, 0, 0, 0, 60]); + msg.extend_from_slice(&(rdata.len() as u16).to_be_bytes()); + msg.extend_from_slice(&rdata); + } + msg + } + + fn answer(msg: &[u8]) -> Option> { + match parse_reply(7, msg) { + Reply::Answer(srv) => Some(srv), + _ => None, + } + } + + #[test] + fn query_is_a_recursive_srv_question() { + let query = encode_query(0x1234, NAME).unwrap(); + let mut expected = vec![0x12, 0x34, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0]; + expected.extend_from_slice(b"\x0a_minecraft\x04_tcp\x04play\x07example\x03org\x00"); + expected.extend_from_slice(&[0, 33, 0, 1]); + assert_eq!(query, expected); + assert!(encode_query(1, "a..b.").is_none()); + assert!(encode_query(1, &format!("{}.org.", "a".repeat(64))).is_none()); + } + + #[test] + fn first_srv_record_of_the_answer_wins() { + let query = encode_query(7, NAME).unwrap(); + let msg = reply( + &query, + 0, + &[(25570, "a.example.org."), (25571, "b.example.org.")], + ); + assert_eq!(answer(&msg), Some(Some(("a.example.org.".into(), 25570)))); + } + + #[test] + fn empty_answer_and_nxdomain_mean_no_redirect() { + let query = encode_query(7, NAME).unwrap(); + assert_eq!(answer(&reply(&query, 0, &[])), Some(None)); + assert_eq!(answer(&reply(&query, 3, &[])), Some(None)); + } + + #[test] + fn server_failures_and_bad_replies_ask_the_next_server() { + let query = encode_query(7, NAME).unwrap(); + let good = reply(&query, 0, &[(25570, "a.example.org.")]); + assert!(matches!( + parse_reply(7, &reply(&query, 2, &[])), + Reply::Unusable + )); + assert!(matches!(parse_reply(8, &good), Reply::Unusable)); // another id + assert!(matches!(parse_reply(7, &query), Reply::Unusable)); // not a response + for cut in 0..good.len() { + assert!(matches!(parse_reply(7, &good[..cut]), Reply::Unusable)); + } + let mut forward = good.clone(); + let at = query.len(); // the first answer's owner pointer + assert_eq!(forward[at..at + 2], [0xc0, 12]); + forward[at + 1] = 0xff; // a pointer forwards + assert!(matches!(parse_reply(7, &forward), Reply::Unusable)); + let mut truncated = good; + truncated[2] |= 0x02; + assert!(matches!(parse_reply(7, &truncated), Reply::Truncated)); + } + + #[test] + fn resolv_conf_name_servers_in_order() { + let conf = "# generated\nsearch lan\nnameserver 192.168.1.1\nnameserver fe80::1%en0\n\ + nameserver ::1 \nnameserver bogus\noptions ndots:1\n"; + let servers: Vec = name_servers(conf).iter().map(|s| s.to_string()).collect(); + assert_eq!(servers, ["192.168.1.1:53", "[fe80::1]:53", "[::1]:53"]); + } + + /// A local name server: a silent one first, then one that answers truncated + /// over UDP and in full over TCP, like a real server with a big answer. + #[test] + fn asks_each_server_in_turn_and_retries_truncated_replies_over_tcp() { + let silent = UdpSocket::bind("127.0.0.1:0").unwrap(); + let (udp, tcp) = loop { + let udp = UdpSocket::bind("127.0.0.1:0").unwrap(); + if let Ok(tcp) = std::net::TcpListener::bind(udp.local_addr().unwrap()) { + break (udp, tcp); + } + }; + let servers = [silent.local_addr().unwrap(), udp.local_addr().unwrap()]; + let server = std::thread::spawn(move || { + let mut buf = [0; 512]; + let (len, from) = udp.recv_from(&mut buf).unwrap(); + let mut truncated = reply(&buf[..len], 0, &[]); + truncated[2] |= 0x02; + udp.send_to(&truncated, from).unwrap(); + let (mut stream, _) = tcp.accept().unwrap(); + let mut len = [0; 2]; + stream.read_exact(&mut len).unwrap(); + let mut query = vec![0; u16::from_be_bytes(len) as usize]; + stream.read_exact(&mut query).unwrap(); + let full = reply(&query, 0, &[(25570, "backend.example.org.")]); + stream + .write_all(&(full.len() as u16).to_be_bytes()) + .unwrap(); + stream.write_all(&full).unwrap(); + }); + let srv = query_srv(NAME, &servers, Duration::from_millis(200)); + server.join().unwrap(); + assert_eq!(srv, Some(("backend.example.org.".into(), 25570))); + } +} diff --git a/crates/horizon-server/src/api.rs b/crates/horizon-server/src/api.rs index c9e553fab..7d0ca8918 100644 --- a/crates/horizon-server/src/api.rs +++ b/crates/horizon-server/src/api.rs @@ -2,17 +2,7 @@ //! `.horizon/api.json` that only the server's own user can read. The CLI manages a running server through //! it; the web panel and the MCP server will too. //! -//! - `GET /api/v1/status`: the supervisor's state, the game's status (TPS, MSPT, players), RAM and CPU. -//! - `GET /api/v1/logs?since=N`: the log lines after the Nth. -//! - `POST /api/v1/command {"line": "..."}`: a console command; the lines it logged. -//! - `POST /api/v1/stop`, `POST /api/v1/restart`. -//! - `GET /api/v1/metrics?since=T`: the samples taken after T (seconds since 1970), up to 10 minutes. -//! - `GET /api/v1/backups`; `POST /api/v1/backups {"name": "..."}` backs up now; `POST /api/v1/restore -//! {"name": "..."}` restarts the game with that backup's world. -//! - `POST /api/v1/update {"tag": "...", "timeout": seconds}`: restarts the game on that installed release, -//! and goes back to the one in use if it isn't up within the timeout; without a tag, downloads the newest -//! release first (update.rs). `GET /api/v1/status` says how it went (`update`). -//! - `POST /api/v1/panel/login`: a one-time login link for the web panel (with the token only). +//! Its routes are [`ROUTES`], listed in docs/api/server-reference.md. use crate::{ backup, @@ -41,6 +31,102 @@ const LOG_LINES: usize = 2000; /// The samples kept for the panel's graphs: 10 minutes, one a second. const METRICS: usize = 600; +/// One endpoint of the control API: what the reference (docs/api/server-reference.md) says about it. +#[cfg_attr( + not(test), + expect(dead_code, reason = "only the reference reads all of it") +)] +pub struct Route { + pub method: &'static str, + pub path: &'static str, + /// The JSON body or query it takes, "" for none. + pub takes: &'static str, + /// The JSON it answers with. + pub answers: &'static str, + pub what: &'static str, +} + +/// Every endpoint `start` and [`route`] answer; a test checks the two agree. +pub const ROUTES: [Route; 11] = [ + Route { + method: "GET", + path: "/api/v1/status", + takes: "", + answers: "`phase`, `version`, `pid`, `uptime_seconds`, `engine_pid`, `engine_uptime_seconds`, `crashes`, `last_crash`, `sample` (TPS, MSPT, players, RAM, CPU), `update`", + what: "How the server does", + }, + Route { + method: "GET", + path: "/api/v1/metrics", + takes: "`?since=T` (seconds since 1970)", + answers: "`{\"samples\": [...]}`: one a second, the last 10 minutes", + what: "The samples taken after T, for graphs", + }, + Route { + method: "GET", + path: "/api/v1/logs", + takes: "`?since=N`", + answers: "`{\"next\": N, \"lines\": [...]}`", + what: "The log lines after the Nth (the last 2000 are kept)", + }, + Route { + method: "POST", + path: "/api/v1/command", + takes: "`{\"line\": \"\"}`", + answers: "the lines the command logged", + what: "Run a console command on the running game", + }, + Route { + method: "POST", + path: "/api/v1/stop", + takes: "", + answers: "`{\"ok\": true}`", + what: "Stop the game and the supervisor", + }, + Route { + method: "POST", + path: "/api/v1/restart", + takes: "", + answers: "`{\"ok\": true}`", + what: "Restart the game", + }, + Route { + method: "GET", + path: "/api/v1/backups", + takes: "", + answers: "`{\"backups\": [{\"name\", \"bytes\"}]}`", + what: "List the backups", + }, + Route { + method: "POST", + path: "/api/v1/backups", + takes: "`{\"name\": \"...\"}` (optional)", + answers: "`{\"name\": \"\"}`", + what: "Back up now (a running game saves first and stays up)", + }, + Route { + method: "POST", + path: "/api/v1/restore", + takes: "`{\"name\": \"\"}`", + answers: "`{\"name\": \"\"}`", + what: "Restart the game with that backup's world (the current one is kept in backups/)", + }, + Route { + method: "POST", + path: "/api/v1/update", + takes: "`{\"tag\": \"...\", \"timeout\": seconds}` (both optional)", + answers: "`{\"ok\": true}`; `status` says how it went (`update`)", + what: "Restart on that installed release, or download the newest first; goes back if the game isn't up within the timeout", + }, + Route { + method: "POST", + path: "/api/v1/panel/login", + takes: "", + answers: "`{\"url\": \"...\"}`", + what: "A one-time login link for the web panel (with the token only, not from the panel)", + }, +]; + /// What the supervisor is doing. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Phase { @@ -488,12 +574,7 @@ pub fn route(shared: &Arc, request: &Request) -> Response { Err(e) => Response::error(409, &e), } } - ( - _, - "/api/v1/status" | "/api/v1/logs" | "/api/v1/command" | "/api/v1/stop" - | "/api/v1/restart" | "/api/v1/backups" | "/api/v1/restore" | "/api/v1/metrics" - | "/api/v1/update", - ) => Response::error(405, "wrong method"), + (_, path) if ROUTES.iter().any(|r| r.path == path) => Response::error(405, "wrong method"), _ => Response::error(404, "no such endpoint"), } } diff --git a/crates/horizon-server/src/config.rs b/crates/horizon-server/src/config.rs index 0a66b6fdf..32e2be79b 100644 --- a/crates/horizon-server/src/config.rs +++ b/crates/horizon-server/src/config.rs @@ -19,22 +19,22 @@ pub const TEMPLATE: &str = r##"# Horizon server settings (docs/server.md). The s # every start: edit this file, not that one. [server] -motd = "A Minecraft Server" -port = 25565 +motd = "A Minecraft Server" # the line under the server's name in the server list +port = 25565 # the port players connect to bind = "" # listen on every address, or only on this one (server-ip) -max_players = 20 +max_players = 20 # how many players can be online at once online_mode = true # check players' Minecraft accounts (false: anyone joins under any name) whitelist = true # only whitelisted players and operators can join enforce_whitelist = false # kick online players taken off the whitelist -view_distance = 10 -simulation_distance = 10 +view_distance = 10 # chunks sent around each player +simulation_distance = 10 # chunks around each player where mobs, crops and redstone tick [world] name = "world" # the world folder seed = "" # empty: a random seed on the first start game_mode = "survival" # survival, creative, adventure or spectator difficulty = "easy" # peaceful, easy, normal or hard -hardcore = false +hardcore = false # one life: a player who dies becomes a spectator # Any other server.properties key, spelled as vanilla spells it, for example: # spawn-protection = 16 @@ -43,7 +43,7 @@ hardcore = false [engine] path = "" # the game program; empty: the one installed beside horizon-server resources = "" # the prepared game files; empty: resources/ here, else the usual places -restart_on_crash = true +restart_on_crash = true # start the game again when it crashes [backups] every = "6h" # automatic backups while the server runs: 30m, 6h, 1d...; "0" turns them off @@ -58,7 +58,7 @@ allow_public = false # true lets bind be any address; never put the pane "##; /// Each typed setting: its section, its name, and the vanilla key it writes. -const TYPED: [(&str, &str, &str); 14] = [ +pub(crate) const TYPED: [(&str, &str, &str); 14] = [ ("server", "motd", "motd"), ("server", "port", "server-port"), ("server", "bind", "server-ip"), diff --git a/crates/horizon-server/src/engine.rs b/crates/horizon-server/src/engine.rs index 051ae77f0..fd7c86321 100644 --- a/crates/horizon-server/src/engine.rs +++ b/crates/horizon-server/src/engine.rs @@ -68,7 +68,8 @@ pub fn program_in( /// system can't load the program, as on a Linux without the ALSA and udev libraries the full game links /// (the server build doesn't). The reason, with what to install. pub fn check_starts(program: &Path) -> Result<(), String> { - let output = Command::new(program) + let mut command = crate::process::command(program); + let output = command .arg("--help") .stdin(Stdio::null()) .stdout(Stdio::null()) @@ -176,7 +177,8 @@ pub fn spawn(program: &Path, resources: &Path, dir: &Path) -> std::io::Result) -> Command { + let command = Command::new(program); + #[cfg(windows)] + let command = { + use std::os::windows::process::CommandExt; + use windows_sys::Win32::System::{Console::GetConsoleWindow, Threading::CREATE_NO_WINDOW}; + let mut command = command; + // SAFETY: no arguments; it returns this process's console window or null. + if unsafe { GetConsoleWindow() }.is_null() { + command.creation_flags(CREATE_NO_WINDOW); + } + command + }; + command +} diff --git a/crates/horizon-server/src/reference.rs b/crates/horizon-server/src/reference.rs new file mode 100644 index 000000000..e8297565a --- /dev/null +++ b/crates/horizon-server/src/reference.rs @@ -0,0 +1,190 @@ +//! docs/api/server-reference.md: `horizon-server`'s commands, every `server.toml` key and the control API's +//! endpoints, generated from the source, and the tests that fail when it is out of date. Update it with: +//! `HORIZON_WRITE_DOCS=1 cargo test -p horizon-server reference`. + +use crate::{api::ROUTES, config}; +use std::fmt::Write; + +const DOC: &str = "docs/api/server-reference.md"; + +/// One `key = value # what it means` line of the template, under its `[section]`. +struct Key { + section: String, + name: String, + default: String, + what: String, +} + +/// The template's sections, each with the comment lines above it, and its keys, in order. +fn template() -> (Vec<(String, String)>, Vec) { + let (mut sections, mut keys, mut notes) = (Vec::new(), Vec::new(), Vec::<&str>::new()); + for line in config::TEMPLATE.lines().map(str::trim) { + if let Some(note) = line.strip_prefix('#') { + notes.push(note.trim()); + } else if let Some(section) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) { + sections.push((section.to_owned(), notes.join(" "))); + notes.clear(); + } else if let Some((name, rest)) = line.split_once(" = ") { + let (default, what) = rest.split_once(" # ").unwrap_or((rest, "")); + keys.push(Key { + section: sections.last().map(|(s, _)| s.clone()).unwrap_or_default(), + name: name.trim().to_owned(), + default: default.trim().to_owned(), + what: what.trim().to_owned(), + }); + } + } + (sections, keys) +} + +pub fn markdown() -> String { + let mut out = String::new(); + let w = &mut out; + let _ = writeln!( + w, + "" + ); + let _ = writeln!(w, "# Server reference\n"); + let _ = writeln!( + w, + "Everything `horizon-server` offers a host or a tool: its commands, every `server.toml` key and the \ + control API. How to host: [hosting.md](../hosting.md); the design: [server.md](../server.md); \ + stability and versions: [stability.md](stability.md).\n" + ); + + let _ = writeln!(w, "## Commands\n\n`horizon-server help` prints:\n"); + let _ = writeln!(w, "```text\n{}```\n", crate::HELP); + + let _ = writeln!(w, "## `server.toml`\n"); + let (sections, keys) = template(); + let _ = writeln!( + w, + "{} Unknown keys are refused. `horizon-server init` writes this file with these defaults; \ + `horizon-server config set SECTION.KEY=VALUE` changes it.\n", + sections[0].1 + ); + for (i, (section, note)) in sections.iter().enumerate() { + let _ = writeln!(w, "### `[{section}]`\n"); + if i > 0 && !note.is_empty() { + let _ = writeln!(w, "{note}\n"); + } + let rows: Vec<&Key> = keys.iter().filter(|k| &k.section == section).collect(); + if rows.is_empty() { + continue; + } + let _ = writeln!( + w, + "| Key | Default | In `server.properties` | What it does |\n| --- | --- | --- | --- |" + ); + for k in rows { + let vanilla = config::TYPED + .iter() + .find(|(s, n, _)| s == section && *n == k.name) + .map_or(String::new(), |(_, _, v)| format!("`{v}`")); + let _ = writeln!( + w, + "| `{}` | `{}` | {vanilla} | {} |", + k.name, k.default, k.what + ); + } + let _ = writeln!(w); + } + + let _ = writeln!(w, "## Control API (`/api/v1`)\n"); + let _ = writeln!( + w, + "HTTP and JSON on 127.0.0.1. A running server writes its address and a random token to \ + `.horizon/api.json`, readable only by its own user; every request sends \ + `Authorization: Bearer ` and a `Host` that is that address. Errors answer \ + `{{\"error\": \"...\"}}` with 400, 401, 403, 404, 405 or 409. The web panel uses the same \ + routes with its session.\n" + ); + let _ = writeln!( + w, + "| Method | Path | Takes | Answers | What it does |\n| --- | --- | --- | --- | --- |" + ); + for r in &ROUTES { + let takes = if r.takes.is_empty() { + "nothing" + } else { + r.takes + }; + let _ = writeln!( + w, + "| `{}` | `{}` | {takes} | {} | {} |", + r.method, r.path, r.answers, r.what + ); + } + out +} + +#[test] +fn the_server_reference_is_up_to_date() { + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../..") + .join(DOC); + let want = markdown(); + if std::env::var_os("HORIZON_WRITE_DOCS").is_some() { + std::fs::write(&path, &want).unwrap(); + } + let have = std::fs::read_to_string(&path) + .unwrap_or_default() + .replace("\r\n", "\n"); + assert!( + have == want, + "{DOC} is out of date: HORIZON_WRITE_DOCS=1 cargo test -p horizon-server reference" + ); +} + +/// The template, which the reference lists, holds every key `Config` reads and no other. +#[test] +fn the_reference_lists_every_setting() { + let config = toml::Value::try_from(config::Config::default()).unwrap(); + let mut listed: Vec = template() + .1 + .iter() + .map(|k| format!("{}.{}", k.section, k.name)) + .collect(); + let mut read: Vec = config + .as_table() + .unwrap() + .iter() + .filter_map(|(section, keys)| Some((section, keys.as_table()?))) + .flat_map(|(section, keys)| keys.keys().map(move |k| format!("{section}.{k}"))) + .collect(); + listed.sort(); + read.sort(); + assert_eq!(listed, read); + for key in template().1 { + assert!( + !key.what.is_empty(), + "{}.{} needs a `# what it does` comment in config::TEMPLATE", + key.section, + key.name + ); + } +} + +/// `ROUTES` holds exactly the endpoints the API's code answers. +#[test] +fn the_routes_table_matches_the_code() { + let source = include_str!("api.rs"); + let mut answered: Vec<(String, String)> = Vec::new(); + for method in ["GET", "POST"] { + let open = format!("(\"{method}\", \"/api/v1/"); + for (at, _) in source.match_indices(&open) { + let rest = &source[at + open.len()..]; + let path = &rest[..rest.find('"').unwrap()]; + if rest[path.len()..].starts_with("\")") { + answered.push((method.into(), format!("/api/v1/{path}"))); + } + } + } + let mut listed: Vec<(String, String)> = ROUTES + .iter() + .map(|r| (r.method.into(), r.path.into())) + .collect(); + answered.sort(); + listed.sort(); + assert_eq!(answered, listed); +} diff --git a/crates/horizon-server/src/service.rs b/crates/horizon-server/src/service.rs index 6e6d59f23..96b9f218f 100644 --- a/crates/horizon-server/src/service.rs +++ b/crates/horizon-server/src/service.rs @@ -178,7 +178,7 @@ fn systemd_path(service: &str, system: bool) -> Result { } fn run(program: &str, args: &[&str]) -> Result<(), String> { - let status = Command::new(program) + let status = crate::process::command(program) .args(args) .status() .map_err(|e| format!("{program}: {e}"))?; @@ -191,7 +191,7 @@ fn run(program: &str, args: &[&str]) -> Result<(), String> { /// A step that may fail harmlessly (stopping what isn't running): its output would only alarm. fn quiet(program: &str, args: &[&str]) { - let _ = Command::new(program) + let _ = crate::process::command(program) .args(args) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) diff --git a/crates/horizon-server/src/update.rs b/crates/horizon-server/src/update.rs index cbcfe637e..8c87c66bc 100644 --- a/crates/horizon-server/src/update.rs +++ b/crates/horizon-server/src/update.rs @@ -10,7 +10,6 @@ use serde_json::{Value, json}; use std::{ io::Read, path::{Path, PathBuf}, - process::Command, time::{Duration, Instant}, }; @@ -206,7 +205,7 @@ fn point(link: &Path, target: &Path) -> std::io::Result<()> { if link.exists() || link.symlink_metadata().is_ok() { std::fs::remove_dir(link)?; } - let status = Command::new("cmd") + let status = crate::process::command("cmd") .arg("/C") .arg("mklink") .arg("/J") @@ -474,7 +473,7 @@ pub fn unpack(install: &Install, archive: &Path, tag: &str) -> Result Option { - let out = std::process::Command::new(program) - .args(args) - .output() - .ok()?; +/// What `program args` prints, trimmed, when it succeeds and prints something. On Windows the +/// program opens no console window: a GUI launcher or a game started without one would flash a +/// terminal for every probe. +pub fn command_output(program: &str, args: &[&str]) -> Option { + let mut command = std::process::Command::new(program); + command.args(args); + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + command.creation_flags(CREATE_NO_WINDOW); + } + let out = command.output().ok()?; let text = String::from_utf8_lossy(&out.stdout).trim().to_owned(); (out.status.success() && !text.is_empty()).then_some(text) } diff --git a/crates/horizon-world/src/chunk.rs b/crates/horizon-world/src/chunk.rs index fdbefe259..74a2011db 100644 --- a/crates/horizon-world/src/chunk.rs +++ b/crates/horizon-world/src/chunk.rs @@ -318,23 +318,6 @@ impl ChunkData { )?)) } - pub fn load_block_section<'r>( - &self, - block: BlockPos, - registry: &'r BlockRegistry, - ) -> io::Result>> { - let Some(index) = self.section_index(block)? else { - return Ok(None); - }; - let Tag::List(sections) = self.root.tag.get("sections").unwrap() else { - unreachable!() - }; - sections[index] - .get("block_states") - .map(|tag| BlockSection::from_nbt(tag, registry)) - .transpose() - } - /// Storage-only mutation. The caller must arrange simulation-derived updates /// before treating this as a gameplay block placement. pub fn set_block_data(&mut self, block: BlockPos, state: BlockState) -> io::Result { diff --git a/docs/README.md b/docs/README.md index 26502148e..1450ba388 100644 --- a/docs/README.md +++ b/docs/README.md @@ -13,13 +13,14 @@ To play, use [the launcher](../launcher/README.md); the project site is [playhor - [Graphics](graphics.md): the Simple and Advanced graphics settings, the graphics benchmark and what it measured. - [Benchmark](benchmark.md): Horizon against vanilla 26.3 and vanilla with performance mods, on the same machine, world, path and settings: what is measured, how it is kept fair, how to reproduce it. - [Extras](extras.md): optional zoom, minimap, FPS and keystroke overlays and auto-reconnect, all off by default. -- [Mods](mods.md): Horizon's own mod system (Rust, sandboxed WebAssembly), how to make and install mods, and [what carries over from Java mods](research/java-mod-compat.md). +- [Mods](mods.md): Horizon's own mod system (Rust, sandboxed WebAssembly), how to make and install mods. - [Modpacks](modpacks.md): porting whole packs (ATM10 and smaller): import, inventory, carry-over, an agent per mod with a harness against the Java original, coverage, and how "10x" is measured. - [Launcher](../launcher/README.md): installs, updates and starts builds; its CLI and MCP server; releasing it. - [Versioning](versioning.md): how releases are numbered from 0.2 (`v0.2.x`, `launcher@0.2.x`), how installs from before 0.2 get there, and the steps for the day 0.2 ships. - [Resource packs](resource-packs.md): everything a 26.3 resource pack can change, whether Horizon honours it, and the proof. - [Opt-in data collection](telemetry.md): the consent, exactly what is sent, how it is stored and sent. - [Benchmark report format](benchmark-report.md): the versioned JSON every benchmark writes (game, launcher, `tools/perf_bench.py`), the local log and, with consent, the upload. +- [Horizon APIs](api/README.md): every surface other programs build on (mods, shaders, agent control, servers, the launcher, data formats), each with its guide, generated reference, stability and changelog, and the [stability and versioning policy](api/stability.md). - Menus: every screen is vanilla's (title, world list, create world, multiplayer, options, pause). Horizon's own settings hang off vanilla's Options the way mods add theirs: **Horizon Settings...** and **Mods...** in the last two slots of the Options grid (Horizon Settings opens Graphics, Advanced Graphics, Controller Settings, Extras and Mods, each a vanilla options list), with Horizon Graphics and Advanced Graphics also at the top of Video Settings and Controller Settings at the bottom of Controls. The title screen's and pause menu's Friends buttons open Join a Friend and Play with Friends ([play-with-friends.md](play-with-friends.md)). ## Parity diff --git a/docs/api/README.md b/docs/api/README.md new file mode 100644 index 000000000..ad49ff609 --- /dev/null +++ b/docs/api/README.md @@ -0,0 +1,55 @@ +# Horizon APIs + +Horizon has six surfaces that other programs and people build on. Each one has an **API** (the contract: what you +may call, read or write, and what Horizon promises about it) and an **SDK** (the tools that help you use it). This +section has one page per surface, plus the rules every surface follows: +[stability and versioning](stability.md). + +| Surface | For | API today | Stability | Reference | +| --- | --- | --- | --- | --- | +| [Mods](mods.md) | mod authors | WIT `horizon:mods@0.1.0`, manifest `api` 0.1 (code) and 0.2 (content) | preview | [mods-reference.md](mods-reference.md) (generated) | +| [Shaders](shaders.md) | shader authors | none yet: packs were removed on 2026-10-24 | planned | none | +| [Agent control](agent-control.md) | agents, scripts, tests | `horizon-ctl`, its MCP server, the game's control socket | preview | [horizon-ctl-commands.md](../horizon-ctl-commands.md) (generated) | +| [Servers](server.md) | hosts, panels, bots | `horizon-server` commands, `server.toml`, control API `/api/v1` | stable | [server-reference.md](server-reference.md) (generated) | +| [Launcher](launcher.md) | players' agents, pack makers | `horizon-launcher` commands and its MCP server | preview | [launcher-commands.md](../launcher-commands.md) (generated) | +| [Data formats](data-formats.md) | tools that read Horizon's files | benchmark reports, telemetry, settings files, signed checksums | stable or preview, per format | on that page | + +## How these APIs are designed + +- **From the people who use them.** Each API starts from what a mod author, a pack author, a server host or an agent + needs to do, written down as tasks ("a host backs up the world from a script"), and from how Horizon is built: + Rust, wgpu, WebAssembly components and a server thread that runs every world. A function exists because a task + needs it. +- **Our own design.** Horizon's APIs are not modelled on any other project's. Contributors may know other mod + loaders, renderers and server platforms exist, but their source and API references are never read, copied or + paraphrased here, and our names, shapes and docs are not taken from theirs. Vanilla Minecraft 26.3 is the reference for game + concepts: ids, commands, `server.properties`, data packs and resource packs. +- **Safe by default.** Mods run in a sandbox and can only use the capabilities their manifest declares; the control + sockets listen on this computer only, behind a token; nothing here is on by default where it would change vanilla's + look or behaviour. +- **Free when unused.** An API nobody uses costs nothing per tick or per frame: no engine, no thread, no allocation. +- **One contract for every mode.** In-frame single player, the server thread, LAN and the dedicated server run the + same gameplay code ([AGENTS.md](../../AGENTS.md)), so a server-side API serves all of them. + +## References are generated + +A reference page is written by code from the source it describes, and a test fails when the two differ: + +| Page | Generated from | Update it with | +| --- | --- | --- | +| [mods-reference.md](mods-reference.md) | `crates/horizon-mod-sdk/wit/horizon.wit`, the manifest's capabilities | `HORIZON_WRITE_DOCS=1 cargo test -p horizon-mods --features pack --test api_reference` | +| [server-reference.md](server-reference.md) | `horizon-server`'s help, `config::TEMPLATE`, `api::ROUTES` | `HORIZON_WRITE_DOCS=1 cargo test -p horizon-server reference` | +| [horizon-ctl-commands.md](../horizon-ctl-commands.md) | the command table in `crates/horizon-client/src/bin/horizon-ctl/commands.rs` | `horizon-ctl help --markdown > docs/horizon-ctl-commands.md` | +| [launcher-commands.md](../launcher-commands.md) | `launcher/src/cli.rs` | `HORIZON_WRITE_DOCS=1 cargo test --manifest-path launcher/Cargo.toml the_launcher_reference` | + +So a pull request that changes an API also changes its reference, and the reviewer sees the API's diff in the +reference's diff. The guides (overview, how-to, examples) are written by hand. + +## Each surface's page + +Every page has the same parts: **Overview** (what you can build), **Guide** (where to start), **Reference**, +**Examples**, **Stability** (the level of each part, per [stability.md](stability.md)), **Changelog** and +**Not there yet** (what is planned, so nobody builds on a guess). + +The website's summary for players and authors is [playhorizon.dev/docs/apis](https://playhorizon.dev/docs/apis) +(`website/docs/apis.md`). diff --git a/docs/api/agent-control.md b/docs/api/agent-control.md new file mode 100644 index 000000000..593447dde --- /dev/null +++ b/docs/api/agent-control.md @@ -0,0 +1,55 @@ +# Agent control API + +How a program drives a running game: an AI agent through MCP, a script through `horizon-ctl`, a test through the +control socket. Design and inventory: [agent-control.md](../agent-control.md); for players: +[playhorizon.dev/docs/agents](https://playhorizon.dev/docs/agents). + +## Overview + +The game listens on a local control socket (a Unix socket, or localhost TCP with a token on Windows), takes one +command per text line and answers one JSON line. `horizon-ctl` wraps it: it starts the game, sends commands and +serves the same commands as MCP tools. The launcher's MCP server offers them too, as `game_`. + +| | Count | +| --- | --- | +| `horizon-ctl` commands | 96, in 8 groups (session, observe, move and look, act, screens and chat, multiplayer, world and cheats, scripting and benchmarks) | +| MCP tools | 88 (8 commands are CLI only) | +| Destructive commands (need `--confirm`) | 3 | +| Command names the game's socket answers | about 160, test hooks included (`horizon-ctl help --game`) | + +## Guide + +1. Build `horizon-ctl` (`cargo build --profile fast -p horizon-client`), then + `horizon-ctl --socket $PWD/ctl.sock launch --world W --creative --wait --resources `. +2. `horizon-ctl --socket … state`, `keys`, `turn`, `command`, `screenshot`, `quit`. +3. For an agent: `horizon-ctl mcp`, or the launcher's `horizon-launcher mcp` with `agent-config` to connect a client + ([launcher-commands.md](../launcher-commands.md)). + +## Reference + +[horizon-ctl-commands.md](../horizon-ctl-commands.md), generated from the command table in +`crates/horizon-client/src/bin/horizon-ctl/commands.rs`: every command, its MCP tool and its arguments. + +## Examples + +- `tools/agent_control_e2e.py`: starts a game and drives it end to end through `horizon-ctl` and MCP. +- `tools/lan_e2e.py`: two games over LAN, both driven through their sockets. + +## Stability + +Preview ([stability.md](stability.md)). The commands in `horizon-ctl`'s table and their MCP tool names are what the +API offers; the other commands the game's socket answers are test hooks and experimental. + +## Not there yet + +- **A version.** A `hello` command that answers the protocol version, the game's release and the features it has; + MCP `serverInfo` carries the same version; `horizon-ctl` refuses a game whose major it doesn't speak. +- **Reply schemas.** Each command's reply described in the table (fields, types, units), so the reference documents + replies as well as arguments and MCP tools declare an output schema. +- **Events as a stream.** `events --since` polls today; a subscription that pushes events as they happen. +- **Test hooks apart.** The hooks only harnesses use move under their own prefix, out of the agent's tool list. +- **Compatibility tests.** A transcript per protocol version: commands and the reply keys each must keep. + +## Changelog + +- Unversioned so far: the command table and the generated reference are the contract. diff --git a/docs/api/data-formats.md b/docs/api/data-formats.md new file mode 100644 index 000000000..3127248a1 --- /dev/null +++ b/docs/api/data-formats.md @@ -0,0 +1,40 @@ +# Data formats + +The files Horizon writes that other tools may read: benchmark reports, telemetry, settings, mods, release checksums +and worlds. Each entry names its version field, its documentation and its level ([stability.md](stability.md)). + +## Overview + +| Format | Where | Version | Level | Documented in | +| --- | --- | --- | --- | --- | +| Benchmark report | the benchmark's output, the local log, uploads | `"format": "horizon-benchmark-report"`, `"version": 1` | stable | [benchmark-report.md](../benchmark-report.md) | +| Telemetry batch | `POST /v1/batch` from the launcher | `"schema": 1` | stable | [telemetry.md](../telemetry.md) | +| Telemetry consent | `telemetry/consent.json` in the game folder | `"version": 2` | stable | [telemetry.md](../telemetry.md) | +| Mod package | `.hmod`: a zip with `horizon-mod.toml`, `mod.wasm`, `assets/`, `data/` | the manifest's `api` | preview | [mods.md](../mods.md#the-manifest), [mods-reference.md](mods-reference.md) | +| Mods turned on | `horizon-mods.txt` | none | preview | [mods.md](../mods.md#playing-with-mods) | +| Horizon settings | `horizon-graphics.txt`, `horizon-extras.txt` (`key:value`, as `options.txt`) | none: unknown keys fall back to defaults | preview | [graphics.md](../graphics.md), [extras.md](../extras.md#options-storage) | +| Server settings | `server.toml` | its keys | stable | [server-reference.md](server-reference.md) | +| Control endpoints | the game's socket file (TCP form), `.horizon/api.json` | none | preview | [agent-control.md](agent-control.md), [server-reference.md](server-reference.md) | +| Release checksums | `SHA256SUMS`, `SHA256SUMS.sig` on releases since signing began (#1011) | the signed text names the tag | stable | [security.md](../security.md) | +| Worlds | the world folder | vanilla 26.3's (`DataVersion`) | vanilla's | [world-data.md](../world-data.md) | + +Worlds are vanilla's format, so any tool that reads a 26.3 world reads a Horizon world; Horizon adds itself to +`level.dat`'s `ServerBrands` as vanilla's server does. + +## Rules for every format + +- A reader ignores fields it doesn't know, and refuses a version newer than it knows with a clear message. +- An optional field may be added in the same version; renaming, removing or changing the meaning of a field makes the + next version, and Horizon's own readers keep reading the older ones for the deprecation window. +- Each versioned format has a sample file of every version its reader accepts, read by a test. + +## Not there yet + +- Versions for the settings files and the control endpoint files (a `version` line or field). +- Sample files and reader tests for every versioned format. +- A generated schema for the benchmark report and the telemetry batch from their Rust types, checked by a test like + the references. + +## Changelog + +- Benchmark report version 1; telemetry schema 1, consent version 2. diff --git a/docs/api/launcher.md b/docs/api/launcher.md new file mode 100644 index 000000000..8b100d972 --- /dev/null +++ b/docs/api/launcher.md @@ -0,0 +1,57 @@ +# Launcher API + +What a player's agent, a script or a pack maker can do with `horizon-launcher`: install and run versions, manage +accounts, settings, mods, modpacks and hosted servers, from a terminal or over MCP. The launcher itself: +[launcher/README.md](../../launcher/README.md). + +## Overview + +Every page of the launcher has a command, and every command but three has an MCP tool with the same arguments; a tool +runs the command with `--json`. Tools that change the player's things for good need `confirm: true`; with No AI on, +the MCP server is off. + +| | Count | +| --- | --- | +| Commands | 46: versions, installs, play, the server, notes, links, accounts, settings, logs, updates, data collection, modpacks, mods, hosted servers, MCP, benchmark | +| MCP tools | 43, plus the game's tools as `game_` ([agent-control.md](agent-control.md)) | +| Modpack formats it imports | 3: a Modrinth `.mrpack`, a CurseForge zip, an instance folder | + +## Guide + +1. `horizon-launcher versions`, `horizon-launcher install latest`, `horizon-launcher play`. +2. Modpacks: `horizon-launcher modpack import `, then `modpack port` and `modpack play` + ([modpacks.md](../modpacks.md)). +3. For an agent: `horizon-launcher agent-config` prints how to connect a client to `horizon-launcher mcp`. + +## Reference + +[launcher-commands.md](../launcher-commands.md), generated from `launcher/src/cli.rs`: every command, its arguments +and its MCP tool. + +## Examples + +```sh +horizon-launcher versions --installed --json +horizon-launcher mods search minimap --kind mod --json +horizon-launcher servers create --name "Weekend" --player Alex --json +``` + +## Stability + +Preview ([stability.md](stability.md)): command names, arguments and MCP tool names are the contract; `--json` +output shapes are not yet described in the reference. + +## Not there yet + +- **A Horizon modpack manifest.** A pack made for Horizon (not a port of a Java pack) needs its own file: the pack's + id, name and version; the Horizon API lines and the release line it needs; its `.hmod` mods (id, version, SHA-256, + where to download it, client, server or both); resource packs; default settings; and whether it has a server side. + One manifest serves the launcher, `horizon-server` (a server installs the server side of the same pack) and the mod + browser. Designed from what a pack maker does, versioned per [stability.md](stability.md), with a schema test. +- **JSON output schemas** for every command, in the generated reference, so MCP tools declare their output. +- **A version** in MCP `serverInfo` and `--json` output, as for agent control. +- **Compatibility tests**: golden `--json` output per command. + +## Changelog + +- Unversioned so far: the command table and the generated reference are the contract. diff --git a/docs/api/mod-index.md b/docs/api/mod-index.md new file mode 100644 index 000000000..959b969fb --- /dev/null +++ b/docs/api/mod-index.md @@ -0,0 +1,95 @@ +# 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 +[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 +`crates/horizon-mods/tests/index/index-v1.json`, read by the tests with the files it lists. + +Level: preview ([stability.md](stability.md)). Schema 1. + +## `index.json` + +```json +{ + "schema": 1, + "generated": "2026-10-24T18:00:00Z", + "projects": [{ + "id": "coords_hud", "kind": "mod", "name": "Coordinates HUD", "summary": "One line.", + "description": "Markdown.", "authors": ["Horizon"], "owners": ["ludovic111"], + "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", + "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" } + }] + }], + "revoked": [{ "id": "bad_mod", "sha256": "1111...", "reason": "Sent chat messages it didn't declare.", "date": "2026-10-24" }] +} +``` + +| Field | Meaning | +| --- | --- | +| `schema` | 1. A reader refuses a higher number with "update Horizon" rather than misread it. | +| `projects[].id` | `[a-z0-9_]{1,64}`, unique; a mod's is its manifest's `id`. | +| `kind` | `mod`, `modpack`, `resourcepack`, `shader` (Horizon's own shader packs, not Iris or OptiFine packs). Other kinds (data packs, worlds, themes) may come without a new schema: a reader keeps a kind it doesn't know and doesn't offer it. | +| `summary`, `description` | One line for lists; Markdown for the project's page. | +| `owners` | GitHub logins allowed to publish updates. | +| `license`, `source` | An SPDX expression and an `https://` address of the source code: both required. | +| `icon` | `https://`, optional. | +| `key` | The author's [minisign](https://jedisct1.github.io/minisign/) public key. When set, every version must be signed with it; an update signed with another key is refused. Absent: the project is unsigned and the launcher says so. | +| `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. | +| `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. | +| `revoked` | Files taken down: one file by `sha256`, or every version of `id` without it. The launcher refuses to install them and turns installed copies off with the reason. | + +Readers ignore fields they don't know, so an optional field can be added to schema 1. Renaming or removing a field, or +changing what one means, makes schema 2. + +## Before a file is installed + +`index::check_file` runs on the downloaded file, before it reaches the game folder: + +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 + 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`. +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. + +## `.hpack` + +A zip holding `horizon-modpack.toml` and, optionally, `overrides/`. The mods are not inside: the launcher downloads +each from the index and checks it as above. + +```toml +format = 1 +id = "cozy" # [a-z0-9_]{1,64}: the profile's folder +name = "Cozy" +version = "1.0.0" +description = "Coordinates and a calm render distance." +authors = ["Horizon"] +game = "26.3" + +[[mods]] +id = "coords_hud" +version = "0.1.0" +sha256 = "e1135345692f6dd8fd4c51920151944b82333e17049c9bb7d756f27b8deefc53" +on = true # optional, default true: turned on in the profile's horizon-mods.txt +``` + +Unknown keys are refused. `overrides/` may hold only `options.txt`, `horizon-graphics.txt`, `horizon-extras.txt`, +`resourcepacks/.zip` and `horizon-mods/.horizon-mod-data//...` (a mod's own saved settings, +capability `storage`), each at most 64 MiB and 256 MiB in all; anything else refuses the pack. The launcher copies +them into the profile's game folder. + +## Changelog + +- 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 new file mode 100644 index 000000000..ca2fe9d7a --- /dev/null +++ b/docs/api/mods-reference.md @@ -0,0 +1,141 @@ + +# 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`. + +## Capabilities + +| In `capabilities` | Grants | The player reads "May …" | +| --- | --- | --- | +| `game-read` | [`game`](#game) | see your position, health and the time | +| `chat` | [`chat`](#chat) | show you chat messages | +| `hud` | [`hud`](#hud) | draw text on your screen | +| `storage` | [`storage`](#storage) | save its own settings to disk | +| `registries` | data files (`assets/`, `data/`), no interface | add blocks and items to your worlds | + +## World `horizon-mod` + +- Imports (what the game offers): `log`, `game`, `chat`, `hud`, `storage` +- Exports (what the mod provides): `events` + +## `log` + +Access: always granted. + +The mod's log, in the game's log under the mod's id. Always granted. + +### enum `level` + +| Case | | +| --- | --- | +| `debug` | | +| `info` | | +| `warn` | | +| `error` | | + +| Function | Signature | What it does | +| --- | --- | --- | +| `write` | `func(level: level, message: string)` | One line in the game's log as `[mod ] message`, at that level. | + +## `game` + +Access: capability `game-read`. + +Capability `game-read`: the local player and the world clock. + +### record `player` + +| Field | Type | | +| --- | --- | --- | +| `x` | `f64` | Feet position, in blocks. | +| `y` | `f64` | | +| `z` | `f64` | | +| `yaw` | `f32` | Degrees, as F3 shows them. | +| `pitch` | `f32` | Degrees: -90 looks straight up, 90 straight down. | +| `health` | `f32` | Hit points as vanilla counts them: 20 is full health without effects. | +| `food` | `u32` | 0 to 20, as the hunger bar. | +| `dimension` | `string` | `minecraft:overworld`, `minecraft:the_nether`, ... | + +### record `clock` + +| Field | Type | | +| --- | --- | --- | +| `game-time` | `u64` | Ticks since the world was created. | +| `day-time` | `u64` | 24000 ticks per day; 0 is 6:00 on the first day. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `get-player` | `func() -> option` | None on the title screen. | +| `get-clock` | `func() -> option` | None on the title screen. | + +## `chat` + +Access: capability `chat`. + +Capability `chat`: messages only the local player sees. + +| Function | Signature | What it does | +| --- | --- | --- | +| `show` | `func(text: string)` | Shown in chat after the mod's name, like a system message. | + +## `hud` + +Access: capability `hud`. + +Capability `hud`: one panel of text lines per mod, drawn by the game every frame until the mod changes or clears it (no call per frame). + +### enum `corner` + +| Case | | +| --- | --- | +| `top-left` | | +| `top-right` | | +| `bottom-left` | | +| `bottom-right` | | + +### record `line` + +| Field | Type | | +| --- | --- | --- | +| `text` | `string` | Plain text, up to 256 characters. | +| `color` | `u32` | 0xRRGGBB. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `set-panel` | `func(corner: corner, lines: list)` | Replaces the mod's panel: up to 16 lines in that corner of the screen. | +| `clear` | `func()` | Removes the mod's panel. | + +## `storage` + +Access: capability `storage`. + +Capability `storage`: a per-mod folder of small key/value files, quota'd (docs/mods.md). Keys are `[a-z0-9_.-]{1,64}`, one path segment. + +| Function | Signature | What it does | +| --- | --- | --- | +| `get` | `func(key: string) -> option>` | None if `key` has never been `set`, or the key is not well-formed. | +| `set` | `func(key: string, value: list) -> result<_, string>` | Errs on a malformed key or over quota (bytes for the whole mod). | +| `delete` | `func(key: string)` | No error if `key` was already absent. | + +## `events` + +Access: exported by the mod: the game calls it. + +What the game calls. Only the hooks `init` asks for are ever called. + +### record `registration` + +| Field | Type | | +| --- | --- | --- | +| `commands` | `list` | Chat commands, without the slash. A name vanilla already uses is refused (vanilla's command runs). | +| `tick` | `bool` | Call `tick` every game tick (20 per second while playing). | +| `frame` | `bool` | Call `frame` every rendered frame. Budget: 0.1 ms. | +| `chat` | `bool` | Call `chat` for each chat line the player receives. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `init` | `func() -> result` | Once, after loading. An error keeps the mod off and is shown. | +| `tick` | `func(tick: u64)` | Each game tick while in a world, with the game's tick counter. | +| `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. | diff --git a/docs/api/mods.md b/docs/api/mods.md new file mode 100644 index 000000000..bec03e84e --- /dev/null +++ b/docs/api/mods.md @@ -0,0 +1,99 @@ +# Mod API + +Mods are Rust crates compiled to sandboxed WebAssembly components. They run in the player's game and, once server +mods land, wherever a world is simulated. Design and the runtime: [mods.md](../mods.md). + +## Overview + +A mod today can read the local player and the world clock, show chat lines only that player sees, draw a text panel +on the HUD, keep small files of its own, register chat commands, and run on every tick, frame or chat line it asks +for. A content mod adds blocks and items from JSON in its `.hmod`, copying vanilla templates, plus tags, recipes, +loot, models, textures and structures in its own namespaces. Every capability is declared in the manifest, shown to +the player before the mod is turned on, and checked against the component's real imports. + +| | 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`, `build`, `run` | +| Example mods | `coords-hud` (code), `ruby-content` (content) | + +## Guide + +1. `rustup target add wasm32-unknown-unknown`, `cargo install --git https://github.com/ludovic111/horizon + cargo-horizon-mod`, then `cargo horizon-mod new my-mod` ([Making a mod](../mods.md#making-a-mod)). +2. Implement `Mod` for your type, list the capabilities you import in `horizon-mod.toml` + ([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). + +## Reference + +[mods-reference.md](mods-reference.md), generated from `crates/horizon-mod-sdk/wit/horizon.wit`: every capability, +interface, type, function and hook, with the limits the guide lists (16 HUD lines of 256 characters, 8 chat lines per +call, 4 MiB of storage, fuel per call). + +## Examples + +- `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-mods/tests/guest`: a mod that misbehaves on command (spins, panics, grows its memory), for the + sandbox tests. + +## Ways in + +One API (the WIT world) and one sandbox (WebAssembly), whatever the mod is written in. Every way in produces a +component for the same world, checked against the same capabilities and given the same limits; there is no second +scripting runtime in the game. + +| Way in | For | Status | Template and example | +| --- | --- | --- | --- | +| Rust | most mods; the fastest | first-class: the SDK, `cargo horizon-mod` | `cargo horizon-mod new`, `coords-hud` | +| Lua scripts | people who don't want a compiler | planned: a script mod whose code is a `.lua` file, run by Horizon's own interpreter mod | planned, with the same example as Rust | +| C, C++, Zig | authors of those languages | to evaluate: bindings generated from the WIT, built without WASI | one each if it passes | +| Go (TinyGo), AssemblyScript, JavaScript / TypeScript | authors of those languages | to evaluate: each needs its toolchain to emit a component without WASI imports, or an interpreter mod as for Lua | one each if it passes | + +- **Scripts run inside the sandbox.** The Lua interpreter is itself a WebAssembly mod, built in Rust with the SDK and + shipped by Horizon. A script mod's manifest names the interpreter and its own capabilities; the game links the + interpreter with only those, so a script can do exactly what a compiled mod with the same manifest can. +- **Hot reload.** The game keeps the interpreter compiled and loads the script into a fresh instance when the file + changes, without restarting the game; what it saved with `storage` survives, as for dev mods. +- **Measured, not guessed.** Each way in is listed with its measured cost on the same tick-heavy example (time and + fuel per tick, memory, load time) against Rust, and a language is supported only with a template, an example and a + test that builds and loads it in CI. + +## 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. + +## 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. +- **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. +- **Entities**: query and change entities near a position; spawn from a mod's own entity types (data first). +- **Block entities and menus**: ticking machines with slots and their screens. +- **Screens and UI**: widgets built from vanilla's, a screen the mod owns, a settings page under Options > Mods. +- **Networking**: a channel between a mod's two halves, client and server, typed by the mod's own WIT. +- **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. + +## Changelog + +- API 0.2 (content): data-driven blocks and items, tags, `horizon:add_to`, terrain adaptation. +- API 0.1.0: `log`, `game`, `chat`, `hud`, `storage`; `init`, `tick`, `frame`, `command`, `chat`. diff --git a/docs/api/server-reference.md b/docs/api/server-reference.md new file mode 100644 index 000000000..93fb9c7fe --- /dev/null +++ b/docs/api/server-reference.md @@ -0,0 +1,137 @@ + +# Server reference + +Everything `horizon-server` offers a host or a tool: its commands, every `server.toml` key and the control API. How to host: [hosting.md](../hosting.md); the design: [server.md](../server.md); stability and versions: [stability.md](stability.md). + +## Commands + +`horizon-server help` prints: + +```text +horizon-server: host a Horizon (Minecraft Java Edition 26.3) server + +Usage: horizon-server [--dir DIR] + + init Set up a server here: the EULA, the world, the port, who may join (asks, or takes flags: + --eula --world NAME --seed SEED --port N --whitelist/--no-whitelist --player NAME... --op NAME + --offline --yes) + run Run the server in the foreground; type console commands, Ctrl-C stops it cleanly. It + restarts the game if it crashes. + start Run the server in the background (its output goes to logs/supervisor.log) + stop, restart + status [--json] + Up or not, TPS, MSPT, players, RAM and CPU + cmd COMMAND... + Run a console command on the running server and print what it answers + logs [-f] [-n N] + The last N lines of the log (default 50); -f follows it + backup [NAME] + Zip the world and the settings into backups/ (a running server saves first and stays up) + backups [--json] + List the backups + restore BACKUP [--yes] + Put a backup's world in place (the current one is kept in backups/); a running + server restarts with it + service install|uninstall|print [--system] + Start the server at boot or login: a systemd unit on Linux (--system: for every user, + with sudo), a launchd agent on macOS, a task at logon on Windows + panel A one-time login link for the web panel ([panel] in server.toml; 127.0.0.1:8130 by + default) + update [--check [--json]] [--version TAG] [--timeout SECONDS] + Install the newest release (checked against GitHub's SHA-256), back up the world and + restart on it; goes back by itself if the game isn't up within the timeout (300 s). + --archive FILE --version NAME installs an archive you have + rollback Back to the release used before the update + config [--json] + The settings in server.toml + config set KEY=VALUE... [--json] + Change settings (for example world.difficulty=hard server.max_players=10), checked first; + a running server takes the difficulty, default game mode and whitelist at once, the rest + at its next start + import FILE Write server.toml from a vanilla server.properties + op NAME, deop NAME + whitelist on|off|list, whitelist add|remove NAME + Who may join (on the running server, or in the files when it is stopped) + + --dir DIR The server folder (default: the current folder) + +Settings live in server.toml; the server writes server.properties from it before every start. +``` + +## `server.toml` + +Horizon server settings (docs/server.md). The server writes them into server.properties before every start: edit this file, not that one. Unknown keys are refused. `horizon-server init` writes this file with these defaults; `horizon-server config set SECTION.KEY=VALUE` changes it. + +### `[server]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `motd` | `"A Minecraft Server"` | `motd` | the line under the server's name in the server list | +| `port` | `25565` | `server-port` | the port players connect to | +| `bind` | `""` | `server-ip` | listen on every address, or only on this one (server-ip) | +| `max_players` | `20` | `max-players` | how many players can be online at once | +| `online_mode` | `true` | `online-mode` | check players' Minecraft accounts (false: anyone joins under any name) | +| `whitelist` | `true` | `white-list` | only whitelisted players and operators can join | +| `enforce_whitelist` | `false` | `enforce-whitelist` | kick online players taken off the whitelist | +| `view_distance` | `10` | `view-distance` | chunks sent around each player | +| `simulation_distance` | `10` | `simulation-distance` | chunks around each player where mobs, crops and redstone tick | + +### `[world]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `name` | `"world"` | `level-name` | the world folder | +| `seed` | `""` | `level-seed` | empty: a random seed on the first start | +| `game_mode` | `"survival"` | `gamemode` | survival, creative, adventure or spectator | +| `difficulty` | `"easy"` | `difficulty` | peaceful, easy, normal or hard | +| `hardcore` | `false` | `hardcore` | one life: a player who dies becomes a spectator | + +### `[properties]` + +Any other server.properties key, spelled as vanilla spells it, for example: spawn-protection = 16 + +### `[engine]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `path` | `""` | | the game program; empty: the one installed beside horizon-server | +| `resources` | `""` | | the prepared game files; empty: resources/ here, else the usual places | +| `restart_on_crash` | `true` | | start the game again when it crashes | + +### `[backups]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `every` | `"6h"` | | automatic backups while the server runs: 30m, 6h, 1d...; "0" turns them off | +| `keep` | `12` | | automatic backups kept (backups made by hand are never deleted) | + +### `[updates]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `keep` | `1` | | other releases kept by updates, besides the one in use and the one rollback goes to | + +### `[panel]` + +| Key | Default | In `server.properties` | What it does | +| --- | --- | --- | --- | +| `bind` | `"127.0.0.1:8130"` | | the web panel: this computer only, or a tailnet address (100.x); "" turns it off | +| `allow_public` | `false` | | true lets bind be any address; never put the panel on the open internet | + +## Control API (`/api/v1`) + +HTTP and JSON on 127.0.0.1. A running server writes its address and a random token to `.horizon/api.json`, readable only by its own user; every request sends `Authorization: Bearer ` and a `Host` that is that address. Errors answer `{"error": "..."}` with 400, 401, 403, 404, 405 or 409. The web panel uses the same routes with its session. + +| Method | Path | Takes | Answers | What it does | +| --- | --- | --- | --- | --- | +| `GET` | `/api/v1/status` | nothing | `phase`, `version`, `pid`, `uptime_seconds`, `engine_pid`, `engine_uptime_seconds`, `crashes`, `last_crash`, `sample` (TPS, MSPT, players, RAM, CPU), `update` | How the server does | +| `GET` | `/api/v1/metrics` | `?since=T` (seconds since 1970) | `{"samples": [...]}`: one a second, the last 10 minutes | The samples taken after T, for graphs | +| `GET` | `/api/v1/logs` | `?since=N` | `{"next": N, "lines": [...]}` | The log lines after the Nth (the last 2000 are kept) | +| `POST` | `/api/v1/command` | `{"line": ""}` | the lines the command logged | Run a console command on the running game | +| `POST` | `/api/v1/stop` | nothing | `{"ok": true}` | Stop the game and the supervisor | +| `POST` | `/api/v1/restart` | nothing | `{"ok": true}` | Restart the game | +| `GET` | `/api/v1/backups` | nothing | `{"backups": [{"name", "bytes"}]}` | List the backups | +| `POST` | `/api/v1/backups` | `{"name": "..."}` (optional) | `{"name": ""}` | Back up now (a running game saves first and stays up) | +| `POST` | `/api/v1/restore` | `{"name": ""}` | `{"name": ""}` | Restart the game with that backup's world (the current one is kept in backups/) | +| `POST` | `/api/v1/update` | `{"tag": "...", "timeout": seconds}` (both optional) | `{"ok": true}`; `status` says how it went (`update`) | Restart on that installed release, or download the newest first; goes back if the game isn't up within the timeout | +| `POST` | `/api/v1/panel/login` | nothing | `{"url": "..."}` | A one-time login link for the web panel (with the token only, not from the panel) | diff --git a/docs/api/server.md b/docs/api/server.md new file mode 100644 index 000000000..81f54c6fe --- /dev/null +++ b/docs/api/server.md @@ -0,0 +1,60 @@ +# Server API + +What a host, a panel or a bot can do with a Horizon server: the `horizon-server` commands, `server.toml` and the +control API. How to host: [hosting.md](../hosting.md); the design: [server.md](../server.md). + +## Overview + +`horizon-server` sets up a server folder, runs the game as a dedicated server under a supervisor (restarts on a crash, +backups on a schedule, updates with a rollback), and lets other programs manage it through a local HTTP API with a +token. The web panel uses that API. + +| | Count | +| --- | --- | +| Commands | 22 (`init`, `run`, `start`, `stop`, `restart`, `status`, `cmd`, `logs`, `backup`, `backups`, `restore`, `service`, `panel`, `update`, `rollback`, `config`, `config set`, `import`, `op`, `deop`, `whitelist`, `version`) | +| `server.toml` keys | 22 in 6 sections, plus `[properties]` for any other vanilla key | +| Control API endpoints | 11 under `/api/v1` | + +## Guide + +1. `horizon-server init` in an empty folder, then `horizon-server start` ([hosting.md](../hosting.md)). +2. From a script: `horizon-server status --json`, `horizon-server cmd say hi`, `horizon-server backup`. +3. From a program: read `.horizon/api.json` (address and token), then `GET /api/v1/status` with + `Authorization: Bearer `. + +## Reference + +[server-reference.md](server-reference.md), generated from `horizon-server`'s source: the help text, every +`server.toml` key with its default and the `server.properties` key it writes, and every endpoint. + +## Examples + +```sh +token=$(jq -r .token .horizon/api.json); address=$(jq -r .address .horizon/api.json) +curl -s -H "Authorization: Bearer $token" "http://$address/api/v1/status" +curl -s -H "Authorization: Bearer $token" -d '{"line": "list"}' "http://$address/api/v1/command" +``` + +## Stability + +Stable ([stability.md](stability.md)): the commands, `server.toml`'s keys and `/api/v1`. A new key or endpoint is an +addition; a change to one starts `/api/v2`, served beside `/api/v1`. + +## Not there yet + +- **Players**: list with ping and position, kick, ban and pardon, op and deop, the whitelist, as endpoints (today only + through `cmd` and the files). +- **Console stream**: the log as a stream (server-sent events) rather than `logs?since=N` polling; chat, joins, leaves, + deaths and crashes as typed events. +- **Metrics**: a plain-text metrics endpoint any monitoring tool can scrape (TPS, MSPT percentiles, players, chunks, + entities, RAM, CPU), from the samples `status` already takes. +- **Backups**: delete and download one; restore a single dimension. +- **Server mods**: list, turn on and off, and their settings, once the mod API runs on the server + ([mods.md](mods.md)). +- **An MCP server** for the same endpoints, so a host's agent manages the server as it manages the game. +- **Compatibility tests**: golden replies per endpoint, and a `server.toml` from each release line. + +## Changelog + +- `api::ROUTES` lists the endpoints; the reference is generated from it. +- `/api/v1`: status, metrics, logs, command, stop, restart, backups, restore, update, panel login. diff --git a/docs/api/shaders.md b/docs/api/shaders.md new file mode 100644 index 000000000..10d1ae3de --- /dev/null +++ b/docs/api/shaders.md @@ -0,0 +1,54 @@ +# Shader API + +Horizon has no shader packs today: the earlier implementation was removed on 2026-10-24. Two things will replace it, +designed separately: a **Horizon shader API**, described here, and a clean-room loader for the existing pack format +(its own spec; it is not part of this API). Both sit on the same renderer hooks, agreed between the two. + +## Overview: what a shader author will be able to do + +Write WGSL against documented stages of Horizon's renderer, with typed inputs, options the player can change, a +reload as soon as a file is saved and an overlay that shows what each pass costs and draws. The renderer keeps +everything that makes it fast (culling, batching, LOD, the mesher); a pack changes how surfaces and light look, not +how the world is fed to the GPU. + +## The design + +- **A pack** is a folder or a zip with `horizon-shaders.toml` (id, name, version, the `api` line, the stages it + uses, its options) and WGSL files. No preprocessor and no other shading language: WGSL is what wgpu validates and + compiles for Vulkan, Metal and DirectX 12. +- **Stages, not pipelines.** A stage is a function with a fixed signature that the renderer calls inside its own pass, + for example a terrain material (`fn material(input: TerrainInput) -> Surface`), the lighting of the visible + surfaces, the sky, an optional shadow pass, and a chain of full-screen post passes ending in the frame. A pack + that leaves a stage out gets vanilla's look for it. +- **Typed inputs.** Each stage receives structs (the frame: time, camera, sun and moon, weather, fog; the surface: + position, normal, block and its light) whose WGSL is generated from the Rust types the renderer uploads. The + generated reference lists every field with its unit and range, and a test fails when it drifts. +- **Options are WGSL `override` constants.** The manifest declares each option (on/off, a number in a range, a choice) + with its default; the game shows them on the pack's settings screen and sets them when it builds the pipeline. No + text substitution, and every option combination is validated the same way. +- **Hot reload.** The game watches the pack's folder. A saved file is validated with naga and the stage rebuilt; on an + error the last good version keeps drawing and the error, with its file and line, is shown in the overlay. +- **Debug overlay.** GPU time per stage and pass (timestamp queries), the targets each pass writes (show any of them + full-screen), the pack's options and its compile errors. +- **Budgets.** A pack declares the targets and passes it needs; the renderer refuses more than its limits, and the + benchmark ([benchmark-report.md](../benchmark-report.md)) records the pack and its cost, so "fast" stays measured. +- **Off by default.** Without a pack the renderer is vanilla's look, and no pack code runs. + +## Guide, reference and examples + +None yet. When the first stage lands: a guide here, a generated reference (`shaders-reference.md`) and an example pack +in the repository that the renderer's tests load. + +## Stability + +Not started. The first stages will be experimental (opt-in), then preview once a reference, an example and a test +pack exist ([stability.md](stability.md)). + +## Not there yet + +Everything on this page. 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. + +## Changelog + +- 2026-10-24: the earlier shader pack code was removed; this API is designed from scratch. diff --git a/docs/api/stability.md b/docs/api/stability.md new file mode 100644 index 000000000..2d4476fc7 --- /dev/null +++ b/docs/api/stability.md @@ -0,0 +1,103 @@ +# API stability and versioning + +The rules every Horizon API follows ([the APIs](README.md)): how each one is versioned, what the stability levels +promise, how something is deprecated and removed, and the tests that keep old mods, scripts and tools working. + +## Versions + +- **Each API has its own version**, separate from the game's release (`v0.2.14`, [versioning.md](../versioning.md)) + and from Minecraft's. A game release says which API versions it serves. +- **Semantic versioning**, `MAJOR.MINOR.PATCH`. A **line** is what stays compatible: `0.1`, `0.2`, … before 1.0, + then `1`, `2`, …. + - Before 1.0: an addition makes the next patch (`0.1.0` → `0.1.1`); a breaking change starts the next line + (`0.2.0`). + - From 1.0: an addition makes the next minor (`1.0` → `1.1`); a breaking change starts the next major (`2.0`). +- **Where the version lives:** + +| API | The version | A user names the line they need | +| --- | --- | --- | +| Mods | the WIT package (`horizon:mods@0.1.0`) | `api = "0.1"` in `horizon-mod.toml` | +| Agent control | the control protocol's version (planned: a `hello` reply and MCP `serverInfo`) | `horizon-ctl --api 1` (planned) | +| Server control API | the path (`/api/v1/`) | the path | +| `server.toml` | the file's keys; a key is never renamed in place | nothing: old files keep loading | +| Launcher commands | the command names and their `--json` output | nothing | +| Data formats | a `version` or `schema` field in the file | the reader rejects versions newer than it knows | + +## 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. + +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. + +## Stability levels + +Every part of an API has one level, shown in its reference and its surface page. + +| | Experimental | Preview | Stable | +| --- | --- | --- | --- | +| Who may use it | opt-in only (a flag or a manifest field naming it); never in a release default | anyone; marked "preview" where players see it (a mod's row on the Mods page) | anyone | +| May change | in any release, without notice | only at a new line, after a deprecation | only at a new major, after a deprecation | +| Deprecation window | none | at least 30 days, with one release line serving old and new | at least 180 days, with the old major served beside the new one | +| Needs | a design note | a generated reference, a guide section, an example, compatibility tests | the same, plus one line of real use without a break | + +- **Promotion.** Experimental → preview when it has what the table asks. Preview → stable when real users (a published + mod, a host's script, an agent's tool) used it for a whole line and nothing broke. The maintainers' orchestrator + proposes the promotion with the evidence (the compatibility tests, the complete docs, that line of use) and Ludovic + approves it. +- **Horizon-only by design.** An API is stable only for what Horizon itself does; a vanilla concept it exposes (a block + id, a command, a `server.properties` key) changes when vanilla changes it, with a version port + ([version-ports.md](../version-ports.md)), and the changelog says so. + +## Deprecation and removal + +1. The pull request that deprecates marks it where it is defined (a `/// Deprecated: use X; goes in 0.3.` doc comment, + WIT's `@deprecated`, a `deprecated` field in a tool's schema) and adds the replacement in the same release. +2. The reference shows it as deprecated, and the surface page's changelog says what replaces it and when it goes. +3. Using it logs one warning per mod, session or client, naming the replacement; it keeps working. +4. It is removed only after the window, and only at the next line (preview) or major (stable). +5. A line or major that is no longer served is refused with a clear message (`needs API 0.1; this Horizon serves 0.3 + and 0.4`), never loaded half-way. + +## Compatibility tests + +Every preview and stable API has tests that run old users against the current code, in CI: + +| API | The test | +| --- | --- | +| Mods | a test mod per served line, built from source against that line's WIT and SDK, loaded by today's runtime with expected output (`crates/horizon-mods/tests/`); a line is served as long as its test mod passes | +| Agent control | a transcript per protocol version: commands and the reply keys each must have | +| Server | `api::ROUTES` against `route()` (generated reference); a `server.toml` from each release line parses to the same settings; golden replies per endpoint | +| Launcher | the generated reference; golden `--json` output per command | +| Data formats | a sample file of every version a reader accepts, read by today's reader | + +The generated references are the API's own diff: a pull request that changes an API changes its reference, and the +reviewer applies the rules above to that diff. + +## Changelog + +Each surface page ends with a changelog: one line per change, newest first, with the API version and the pull request. +Deprecations and breaking changes are in bold. The release notes of the game release that ships a change link it. + +## Today + +| Part | Level | Version | +| --- | --- | --- | +| Mod API: `log`, `game`, `chat`, `hud`, `storage`, `events` | preview | 0.1.0 | +| 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 | +| 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 | | +| `horizon-ctl` commands and MCP tools | preview | none yet (unversioned) | +| The game's own control-socket commands outside `horizon-ctl`'s table (test hooks) | experimental | | +| `horizon-server` commands, `server.toml` | stable | `horizon-server --version` | +| Server control API | stable | `/api/v1` | +| `horizon-launcher` commands and MCP tools | preview | none yet (unversioned) | +| Benchmark report | stable | `"version": 1` | +| Telemetry batch and consent | stable | `"schema": 1`, consent `2` | +| `horizon-graphics.txt`, `horizon-extras.txt`, `horizon-mods.txt` | preview | none | +| `SHA256SUMS` and `SHA256SUMS.sig` | stable | | diff --git a/docs/architecture.md b/docs/architecture.md index 29e98f2e6..f95073e57 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -41,7 +41,7 @@ file selects ~103. | 24 | Container menus and inventory (61) | `L/menu.rs`, `L/container_screen.rs`, `L/containers.rs`, `L/creative.rs`; game.rs `fn menu_ops`, `fn click_inventory` | menu_click, container_screen, creative, lan_e2e containers clicks | | 25 | Workstations (60) | `L/stations.rs`, `G/stations.rs`, `L/enchant.rs`, `L/brewing.rs` | enchanting, screen_layout, lan_e2e brewing loom stonecutter grindstone anvil smithing | | 26 | Crafting and the recipe book (59) | `L/crafting.rs`, `L/recipe_book.rs`, `L/recipe_book_screen.rs`, `G/recipe_book.rs`, `G/machines.rs`, `G/machines/crafter.rs` | recipe, recipe_book, recipe_book_view, place_recipe, ghost_recipe, crafter | -| 27 | Vehicles and mounts (54) | `G/boats.rs`, `G/minecarts.rs`, `G/mounts.rs`, `G/mount_menu.rs`, `G/llamas.rs`, `G/passengers.rs` | server_entities, lan_e2e boats minecarts riding mounts | +| 27 | Vehicles and mounts (54) | `G/boats.rs`, `G/boat_passengers.rs`, `G/minecarts.rs`, `G/mounts.rs`, `G/mount_menu.rs`, `G/llamas.rs`, `G/passengers.rs` | server_entities, lan_e2e boats minecarts riding mounts | | 28 | Villagers, trading, raids (50) | `L/mobs/villager*.rs`, `L/merchant.rs`, `G/trading.rs`, `G/villagers.rs`, `L/raid.rs`, `G/raids.rs`, `L/gossip.rs` | trading, raid, mob_ai | | 29 | Title, worlds, startup (49) | `L/title.rs` + `L/title/`, `G/startup_menu.rs`, `L/title_edition.rs` | world_options; `cargo test -p horizon-client --lib title` | | 30 | Dedicated server, horizon-server (48) | `G/dedicated.rs`, `G/dedicated/status.rs`, `crates/horizon-server/`, `crates/horizon-server-files/` | dedicated_server, server_files, user_cache, online_mode, server_ops_feedback | diff --git a/docs/how-horizon-is-built.md b/docs/how-horizon-is-built.md new file mode 100644 index 000000000..784abfc88 --- /dev/null +++ b/docs/how-horizon-is-built.md @@ -0,0 +1,41 @@ +# How Horizon is built + +Who writes Horizon, how changes are checked, and why it is safe to run. You can check every claim on this page in the repository, and anything not done yet is marked as not done. + +This page is also on the website: [playhorizon.dev/docs/how-horizon-is-built](https://playhorizon.dev/docs/how-horizon-is-built). The longer version, with what is still missing, is [Security](security.md). + +## Who builds it + +Horizon is Ludovic Marie's project: he decides what it does and what ships. **Most of the code is written by AI agents**: Claude sessions that Ludovic runs, and contributors' own AI tools. Some contributors write their code by hand. + +Agents say what they are. A pull request opened by one of Ludovic's agents starts with "Opened by Ludovic's AI agent (Claude), not by Ludovic himself.", its comments start with "🤖 Agent:", and its commits name the agent in a `Co-Authored-By` line. + +## How changes are checked + +Not every line is read by a person. Instead, every change is checked against the real game, automatically: + +- **Harnesses.** A harness is a test that gives the same inputs to Horizon and to the real Minecraft 26.3, then compares the results. There are 326 of them (25 October 2026), from world generation to mobs, redstone and commands. The [status table](https://playhorizon.dev/#parity) shows what they cover. Passing them all does not prove that nothing else differs. +- **Checks on every pull request.** `verify` runs on GitHub's machines for every pull request and every change to main: formatting, lints with warnings treated as errors, the tests, and the check that no Minecraft files are committed. Main takes no change without it. `parity` runs the harnesses a change can affect, on a machine that holds a copy of Minecraft. For a pull request from a fork, it runs once a maintainer has read the change. +- **Outside contributions are checked again.** Before a contributor's pull request merges, Ludovic's agents compare what it claims with vanilla's own code, review it line by line, rewrite the weak parts, and test it in single player, on a LAN and on a dedicated server where those apply. +- **Releases are tested first.** A release is published only after its smoke test passes (the game starts and draws a world) and while no issue is labelled `release-blocker`. + +## Why it's safe to run + +- **Open source.** All of the code is public on [GitHub](https://github.com/ludovic111/horizon), under the MIT licence. +- **Built from the public code.** Releases are built by GitHub Actions, the build service of GitHub, from the public source. Linux and Windows are built on GitHub's machines, and macOS on Ludovic's Mac mini, which runs GitHub Actions jobs. Every build log is [public](https://github.com/ludovic111/horizon/actions/workflows/release.yml). +- **Signed checksums.** Every release has a `SHA256SUMS` file, a fingerprint of each download, and `SHA256SUMS.sig`, a signature of that list made with Horizon's release key, which only release builds from main can use. The launcher and `horizon-server update` check both before they install anything, and refuse a file that does not match. The very first server install with `install.sh` checks the fingerprint but not the signature. +- **Not yet signed by Apple or Microsoft.** The macOS app is not notarized by Apple, because it is not signed with a paid Apple developer account, so macOS asks you to confirm the first time ([Install](https://playhorizon.dev/docs/install#download-the-launcher) shows how). The Windows programs are not code-signed either, so Windows may warn you too. +- **Mods run in a sandbox.** Horizon mods are WebAssembly programs with no access to your files, the network or other programs. A mod lists what it needs, you see that list before you turn it on, and it can do nothing else. See [Mods](mods.md). +- **Nothing collected unless you say yes.** Data collection is off until you turn it on, with four separate switches. The one exception is an anonymous "I'm playing" ping for the launcher's player count, which holds nothing about you. See [Opt-in data collection](telemetry.md). + +## What it doesn't contain + +- **No Minecraft files.** Horizon contains no Minecraft code, assets or data, and never downloads them. The launcher builds the game files on your computer from your own copy of Minecraft: Java Edition 26.3. A check that runs on every pull request (`tools/check_public_tree.py`) keeps game files and decompiled code out of the repository and its history. +- **No code from other mods.** Since 24 October 2026, Horizon's code may only be written from Minecraft 26.3 itself and public documentation, never from another mod, loader or renderer ([the rule](../CONTRIBUTING.md#only-original-code)). That day shader packs were removed ([#1561](https://github.com/ludovic111/horizon/pull/1561)), after a developer of Iris showed that our shader pack code had been written from Iris's source. They are being written again from a description of the pack format only. + +## Check it yourself + +- **Read the code and its checks.** [The source](https://github.com/ludovic111/horizon), [the checks on every pull request](https://github.com/ludovic111/horizon/actions/workflows/ci.yml) and [the release builds](https://github.com/ludovic111/horizon/actions/workflows/release.yml). +- **Compare the fingerprints.** Put a release's files and its `SHA256SUMS` in one folder and run `sha256sum -c SHA256SUMS --ignore-missing` (on macOS `shasum -a 256 -c SHA256SUMS --ignore-missing`, on Windows `Get-FileHash ` in PowerShell). Each file should say `OK`. +- **Check the signature.** Download a whole release into a folder, then from a clone of the repository run `cargo run -p horizon-release-sign -- verify --tag `. The public key is in `crates/horizon-release-sign/release-keys.txt`. +- **Build it yourself.** The README explains how to [build from source](../README.md#build-from-source). diff --git a/docs/mod-browser.md b/docs/mod-browser.md index 96edc7bbd..7a000cb6c 100644 --- a/docs/mod-browser.md +++ b/docs/mod-browser.md @@ -6,7 +6,7 @@ packs, see how well each one runs before installing it, and install it with its ## What it offers -Horizon doesn't run Java code ([research/java-mod-compat.md](research/java-mod-compat.md)). It ports what a Java mod +Horizon doesn't run Java code ([mods.md](mods.md)). It ports what a Java mod carries as data (blocks, items, recipes, loot tables, tags, worldgen, textures, names) with `horizon-port-pack`, and says before install which of the mod's features that leaves out. Horizon `.hmod` mods aren't on Modrinth or CurseForge yet (Modrinth has no `horizon` loader). diff --git a/docs/modpacks.md b/docs/modpacks.md index c0a77b2cb..13ad619ed 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -7,9 +7,8 @@ pipeline, not a list of hand ports. It takes a pack as players download it and p Horizon mods. The pipeline is AI agents in dependency order, each port checked against the original mod running in a dev-only Java instance. -This page is the design. It builds on [mods.md](mods.md) (the mod API, WASM in wasmtime) and -[research/java-mod-compat.md](research/java-mod-compat.md) (why Java jars and Mixins cannot -run in Horizon, so we port instead). The ATM10 inventory behind the numbers below is +This page is the design. It builds on [mods.md](mods.md) (the mod API, WASM in wasmtime, and +why Java jars cannot run in Horizon, so we port instead). The ATM10 inventory behind the numbers below is [modpacks/atm10-mods.csv](modpacks/atm10-mods.csv). ## In one picture @@ -141,12 +140,13 @@ derivative work. These rules are part of the pipeline, not advice to users: has given written permission, recorded in the index entry. The tooling refuses to package anything else. No-derivatives and non-commercial licences (14 in ATM10) are never published. For them, even a local port gets a warning that the licence may not allow it. -4. **Mod code never enters this repository.** Mod jars, decompiled sources, Java oracle builds +4. **Mod code never enters this repository, and nobody reads it.** Mod jars, Java oracle builds with mod code, and ports of mods we have no permission to publish all live outside the repo: in the user's pipeline work directory, or for our own development in - `~/code/horizon-parity/modports/` (dev-only, never pushed). Ports are written from - observed behaviour and the harness, with decompiled code as a local reference only. The - repository holds the pipeline, the API, metadata (ids, names, versions, licences, counts) + `~/code/horizon-parity/modports/` (dev-only, never pushed). A mod's code is never + decompiled, read, quoted or paraphrased, by people or agents. Ports are written only from + the mod's observed behaviour (the oracle and the harness), its own data files and its + public documentation. The repository holds the pipeline, the API, metadata (ids, names, versions, licences, counts) and test fixtures we write ourselves. 5. **Contacting authors or publishing any port is Ludovic's call.** Agents ask first. @@ -177,7 +177,7 @@ frame, chat and command hooks. Server mods do not run yet. What a content pack n | Entities: types, attributes, AI goals and brains, spawning | — | deep (87) | 0.5 | `entity` interface, AI in the mod with vanilla goals reusable | | Custom renderers and animated models (block-entity, entity, item; GeckoLib's format) | — | deep | 0.5 | data models (Bedrock geometry + animations), plus a budgeted draw-list interface for the rest | | Dimensions: dimension types, levels, chunk generators | — | about 10 (Twilight Forest, Aether, Ad Astra, Undergarden, ...) | 0.5 | JSON part with worldgen; custom generators as mod code | -| New hooks into vanilla behaviour (what Mixins do) | — | deep | as asked | each becomes a named hook, added for everyone ([java-mod-compat.md](research/java-mod-compat.md#3-a-porting-guide-outline)) | +| New hooks into vanilla behaviour (what Mixins do) | — | deep | as asked | each becomes a named hook, added for everyone | | Client interfaces: `keys`, `target`, `inventory-read`, `ui`, `render`, `world-read` | planned | client tier (38) | 0.2–0.4 | as in [mods.md](mods.md#planned-interfaces) | Two rules from mods.md stay: **the sandbox** (no files, sockets or processes; memory cap; fuel @@ -711,16 +711,16 @@ For tiers logic, machines and deep, in dependency order, as many agents at once budget allows: - **Input:** the inventory record, the carried-over data, the oracle's exports and traces, the - harness, the Horizon mod API docs, the ports of its dependencies, and the mod's decompiled - code as a local reference (dev-only, in the work directory). + harness, the Horizon mod API docs, the ports of its dependencies, and the mod's public + documentation. Never its code: the agent doesn't decompile, read or quote it. - **Output:** a Rust crate in `mods//port/` built with `cargo horizon-mod build`, and its `.hmod`. - **Loop:** write → build → run the harness → read the differences → fix, until the harness passes or the agent reports what blocks it. Usually that is an API gap, which becomes an issue against the mod API ("needs a scheduled-tick hook"), the way version ports turn differences into work items. -- **Rules:** the agent writes the port from observed behaviour and the harness, not by - transliterating decompiled Java; ports follow the mod's licence ([Licences](#licences)). +- **Rules:** the agent writes the port from observed behaviour, the harness and the mod's + own data files only; ports follow the mod's licence ([Licences](#licences)). Players without an AI agent get the carry-over tiers. A port the licence lets us publish can be downloaded instead of regenerated. diff --git a/docs/mods.md b/docs/mods.md index d8ea925b3..6f3216d38 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -3,8 +3,9 @@ Horizon gets its own mod system, written in Rust and run in a sandbox, plus two ways to bring over what Java players use: native Horizon ports of popular mods and the data-driven parts of packs and mods. Fabric and NeoForge jars do -**not** run as they are: [research/java-mod-compat.md](research/java-mod-compat.md) -explains why and what we do instead. +**not** run as they are: 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.md](modpacks.md)). Mods are **off and absent by default**. A fresh install has no `horizon-mods` folder, loads no runtime and plays exactly like vanilla 26.3. @@ -18,7 +19,8 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new / build / run` | | 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 | -| `.hmod` index, signing, server mods, registries | this page, [Roadmap](#roadmap) | planned | +| Registry index (`index.json`, `.hpack`), signatures | `horizon_mods::index`, [api/mod-index.md](api/mod-index.md) | schema 1; launcher and website next | +| Server mods, registries | this page, [Roadmap](#roadmap) | planned | ## Design goals @@ -102,7 +104,7 @@ name (the mod reads it as `args`; API 0.1 has no way to declare argument types). ### Planned interfaces Each is a new capability, added in a 0.x minor version so older mods keep -loading. Ordered by what the first native ports need ([research](research/java-mod-compat.md#port-first)): +loading. Ordered by what the first native ports need: | Interface | For | Notes | |---|---|---| diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index 1b00080e7..f9f222071 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -32,6 +32,10 @@ Passes are shared between worktrees. A harness's key depends only on the content Every runner on the machine shares `PARITY_MACHINE_JOBS` slots (default: half the CPU threads), so several agents' runs together can't overload it. Parallel harnesses are also admitted by memory: each harness's recorded peak is reserved, within three quarters of the memory available at the start, and a harness starts only if the memory free at that moment still leaves 2 GB. `-j` caps the count here (default: `PARITY_LOCAL_JOBS`, else 3 while other machines help or a third of the CPU threads alone, within `$FLEET_LOAD_JOBS`). +### Harnesses that start the game + +The game logs into `HORIZON_HOME` and falls back to the player's own game folder when it is unset, so a harness that starts the game, `horizon-ctl`, the launcher or the dedicated server builds the environment with `lab.game_env(**extra)`: no audio, and fresh scratch folders for `HORIZON_HOME`, `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and `XDG_CONFIG_HOME`, removed when the harness exits (a folder you pass, or that the environment already has, is kept). The runner also gives each harness its own `HORIZON_HOME` under `.local/parity-runner/game-home/`. `tests/test_game_home.py` fails for a script in `tools/` that starts the game without it. + ### Other machines Harnesses can also run on the Mac mini and the ThinkPad (`tools/parity_hosts.json` describes them; its `default` list is empty, so pass `--hosts macmini,thinkpad` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 3 and only those under 800 MB. Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here. diff --git a/docs/performance/java-perf-mods.md b/docs/performance/java-perf-mods.md deleted file mode 100644 index 0ded82048..000000000 --- a/docs/performance/java-perf-mods.md +++ /dev/null @@ -1,130 +0,0 @@ -# Java performance mods: which of their techniques apply to Horizon - -A survey of the techniques used by eight Java Edition performance mods. Asked for in #991, from famescare on Discord. For each technique it gives the vanilla cost it targets, whether Horizon already avoids that cost, and whether it is worth measuring here. - -**Rules.** Techniques only, taken from each mod's public description, documentation and changelogs (linked below). No mod code was read or copied. Several of these mods are LGPL-3.0, and Horizon's code stays its own. Anything Horizon adopts is reimplemented against vanilla 26.3's behaviour. It keeps parity, so the harnesses stay unchanged, and it needs before/after numbers like any other perf PR (`docs/benchmark.md`, `docs/profiling.md`). - -**Why many don't apply.** A large share of these techniques work around costs of the JVM, OpenGL or GLFW rather than costs of the game's rules. Examples are object headers and duplicate objects, boxing, lambdas and Streams, garbage collection, JNI upcalls, immediate-mode GL draws and GL error checks. Horizon is Rust on wgpu and winit, so it never pays those costs. The techniques that do carry over remove work the game's rules don't need: sleeping block entities, skipped searches, and cheaper geometry tests. - -Verdicts: -- **has**: Horizon already avoids the cost, by its design or with a merged change. -- **n/a**: the cost comes from the JVM, OpenGL or GLFW, and Horizon doesn't have it. -- **later**: missing, and worth measuring. These are listed in "Worth measuring" below and in the LATER list. -- **no**: missing, but it would change vanilla's behaviour or look, or the gain here is too small to pay for itself. - -## Lithium (server and shared game logic) - -Source: [Lithium's mixin configuration](https://github.com/CaffeineMC/lithium/blob/develop/lithium-fabric-mixin-config.md). Lithium keeps vanilla's behaviour, which is the same rule Horizon follows. - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| Hopper caching, inventory change listeners and hopper sleeping | Every hopper looks up its source and target containers and tries a transfer every tick, even when nothing can move | `game/machines.rs` ticks every hopper on each tick. It checks the block's name and cooldown, then runs the transfer attempt. Nothing is cached or put to sleep | **later** | -| Block entity sleeping (furnaces, brewing stands, campfires, crafters, shulker boxes, sculk) | Idle block entities still tick | `game/block_entity_ticks.rs` ticks every ticker each tick, as vanilla does | **later** | -| Entity collisions: faster block access, chunk caching, the supporting block first | Collision scans read blocks through generic level lookups | Collision scans already run over Horizon's own section arrays (`horizon-world` `block_collision_scan`). A counting cursor that does fewer lookups is open as #659 | **has** (more in #659) | -| Specialised cuboid and empty `VoxelShape`s, precomputed shape arrays | Generic voxel shape intersection and merging | `horizon-core::geometry` has its own immutable shapes and box lists (`docs/collision-geometry.md`) | **has** | -| POI search and portal search | POI lookups go through vanilla's stream-heavy search | Section-indexed POIs (`poi_sections.rs`), searched in vanilla's order | **has** | -| Pathfinding: cached node types per block | Node evaluation reads the same blocks over and over | Not measured. Mob pathfinding costs haven't been profiled against vanilla yet | **later** (profile first) | -| Explosions: one access per block on a ray, skip air, skip exposure work | Each ray step reads the block and the fluid again | `game/explosion.rs` follows vanilla's loop. It hasn't been profiled, and TNT chains are the case to measure | **later** (profile first) | -| Random ticks: roll the chance early, fast block search | Sections with nothing that ticks randomly are still walked | Sections with nothing random-tickable are skipped (`docs/random-tick-eligibility-benchmark.md`) | **has** | -| Tick scheduler: faster collections, packed scheduled ticks | Boxed `ScheduledTick` objects in hash sets | Horizon's own tick heap and index (`horizon-core::ticks`, `docs/scheduled-ticks.md`) | **has** | -| Collections and allocation (fastutil maps, cached `values()`, fewer `BlockPos`, no Streams) | JVM allocation, boxing, GC | Rust value types, no GC | **n/a** | -| Math inlining, a smaller sine table | JIT inlining limits | Compiled and inlined by rustc. Horizon keeps vanilla's `Mth.sin` table where results depend on it | **n/a** | -| Chunk access without debug locks or bounds validation | `PalettedContainer`'s thread-check lock | Horizon doesn't have that lock (`docs/performance/paletted-container-access-results.md`) | **n/a** | -| Palette replacement and compaction | Hash palette resizing on the JVM | Horizon's own paletted containers (`horizon-core::paletted`) | **has** | -| Game event dispatchers made only for sections with a listener | Every section holds a dispatcher | Not checked. This is small next to the items above | **no** (until a profile shows it) | -| Item entity merging grouped by item type (experimental) | Each item entity checks every nearby item to merge with | Not present. It matters only with thousands of dropped items (see #996: fresh worlds drop about twice as many items as vanilla) | **later**, after #996 | -| World border cache, redstone wire double reads, fluid flow reads, framed-map scans | Small repeated reads | Each is minor. Fix them where a profile points at them | **no** | - -## FerriteCore (memory) - -Source: [FerriteCore's summary of its changes](https://github.com/malte0811/FerriteCore/blob/main/summary.md). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| One `FastMap` of neighbour states per block instead of a table per state | About 600 MB of per-state neighbour tables in large packs | Block states are numeric ids with flat tables, with no object per state | **n/a** | -| Compact property storage per state | A per-state `ImmutableMap` | Same as above | **n/a** | -| Cached multipart predicates, shared multipart models | Hundreds of thousands of model and predicate objects | Models are baked once into a shared library (`docs/shared-model-library-benchmark.md`) | **has** | -| Deduplicated baked-quad vertex arrays | Identical `int[]` per quad | Section meshes are built per section from the shared baked models, and no per-quad arrays are kept | **has** | -| Deduplicated shape caches | Duplicate cached `VoxelShape`s per state | One table of distinct shapes, indexed per state (`horizon-world` `CachedCollisionRegistry`) | **has** | -| String deduplication in model locations | Duplicate `String`s from the constructor's round-trips | No `ModelResourceLocation` objects, so the round-trip doesn't exist | **n/a** | -| Partly loaded chunk NBT kept between loading steps | The whole tag is kept | Chunks are decoded into Horizon's own structures | **n/a** | - -Horizon's process memory is tracked against vanilla in [comparison benchmarks](../benchmark.md). - -## ImmediatelyFast (client draw submission) - -Source: [ImmediatelyFast on Modrinth](https://modrinth.com/mod/immediatelyfast). Its gains show only when the CPU is the bottleneck. - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| A batching buffer for immediate-mode draws (entities, block entities, particles, text, GUI) | Many small draw calls and uploads | The HUD is one atlas and one batch of quads (`hud.rs`). Entities are grouped by material (`gfx/entity_batch.rs`). Terrain uses indirect multi-draws (`gfx.rs`, `gfx/flat.rs`) | **has** | -| HUD batching, fewer GUI draw calls | One draw per GUI element | Same batch (`hud.rs`) | **has** | -| Fast text lookup, a bigger font atlas | Per-character lookups, atlas thrash with large fonts | Glyphs live in maps in `font.rs`, drawn into the same HUD atlas | **has** | -| One texture for all map item textures | One texture per visible map | Not measured. It matters only with walls of maps in item frames | **later** (with a map-wall scene) | -| Cached closed-chest geometry | Re-tessellating chests each frame | Merged in #728 (Online5277) | **has** | -| Buffered sign text instead of redrawing it each frame | Text redrawn every frame | Sign text is recorded as text calls in the batch. Not measured with sign-heavy scenes | **later** (with a sign-heavy scene) | -| Fewer framebuffer switches | GL state changes between render types | wgpu render passes are fixed by Horizon's pipeline | **n/a** | -| GL error checking off | `glGetError` overhead | No GL. Release builds run without wgpu's backend validation and, outside DirectX 12, without its indirect-draw validation (`gfx.rs` `instance_descriptor`) | **n/a** | - -## Gnetum (HUD rendering) - -Source: [Gnetum on Modrinth](https://modrinth.com/mod/gnetum). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| Draw the HUD into an offscreen buffer in several passes, one pass per frame, and show the last complete buffer | The HUD is redrawn every frame | Horizon redraws its one HUD batch every frame | **no**. The HUD would then update at a lower rate than vanilla's, which changes what players see. Horizon's HUD is already one batch. | -| Adaptive distribution and a separate HUD FPS cap | Same | Same | **no**, for the same reason | - -## ScalableLux (lighting, from Starlight) - -Source: [ScalableLux on Modrinth](https://modrinth.com/mod/scalablelux). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| Starlight's light engine: per-section light arrays and direct propagation queues | Vanilla's light engine is a bottleneck in fast chunk generation | Horizon has its own engine with vanilla's rules (`light.rs`). New chunks are lit on the streaming worker pool, and edits are relit incrementally (`relight_block`). See `docs/performance/lighting-worker-results.md` | **has** | -| Parallel light updates | One light thread | Chunk lighting already runs on several workers during streaming | **has**. Measure the light share of fresh-chunk generation before doing more. | - -## Structure Layout Optimizer (jigsaw structures) - -Source: [Structure Layout Optimizer on Modrinth](https://modrinth.com/mod/structure-layout-optimizer). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| An octree of piece boxes instead of a `VoxelShape` for free space | Voxel shape boolean ops slow down as pieces add up | Free space is a container box minus a list of placed boxes (`worldgen/structure/jigsaw.rs` `Free`). That avoids the voxel shapes, but the scan is linear per test | **has**. An octree pays only for structures with hundreds of pieces. | -| Skip jigsaw blocks that face the structure boundary or another piece | Every parent jigsaw is matched against every child | Not present | **later** (time trial chambers and ancient cities first) | -| Skip pool elements already found not to fit at this spot | Weighted pools repeat an element once per weight point, and it is re-tested each time | Not present. Only the variant that keeps the result identical applies (no deduplication of the list, which changes layouts) | **later** | -| Cull positions outside the chunk before processors run | Whole templates are processed and then mostly discarded | Not checked | **later** (same measurement) | -| Palette-based template storage | Templates keep every block and NBT object | Templates are Horizon's own structures. Memory isn't measured | **no** (until memory shows it) | - -## AsyncParticles (particles) - -Source: [AsyncParticles on Modrinth](https://modrinth.com/mod/asyncparticles). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| Particle culling | Off-screen particles are built anyway | Vanilla already skips quad particles whose position is outside the frustum (`QuadParticleGroup.extractRenderState`, `Frustum.pointInFrustum`). Horizon builds every particle's quad (`particles.rs` `render`). This is a parity gap as well as a cost | **later** (vanilla's frustum point test) | -| Vertex transformation on the GPU | Every particle's quad is built on the CPU and uploaded every frame | Same in Horizon (`particles.rs` `render`). Instancing would upload one record per particle | **later** (measure with 10k+ particles) | -| Particle ticks on another thread | Particle ticks on the client thread | Horizon ticks particles on the game thread | **no**. Vanilla's particle ticks read the level, and racing them against block changes risks parity. Revisit only if a profile shows particle ticks are big. | -| Asynchronous light cache for particles | A light lookup per particle per frame | `particles.rs` looks light up per particle | **later**, with the item above | -| Texture animation one frame late | Animated textures tick on the client tick | Not adopted | **no**, because it changes timing | - -## Ixeris (input and the render thread) - -Source: [Ixeris on Modrinth](https://modrinth.com/project/p8RJPJIC). - -| Technique | Vanilla cost | Horizon | Verdict | -| --- | --- | --- | --- | -| Event polling on the main thread, rendering on its own thread | GLFW event polling and JNI upcalls take time from rendering | winit, without JNI. Input and rendering share the event loop (`game.rs`, `ApplicationHandler`) | **n/a** for the JNI part | -| Buffered raw input (`GetRawInputBuffer`) | One `GetRawInputData` call per event. An 8000 Hz mouse costs a lot on Windows | winit reads `WM_INPUT` one message at a time | **later**. Measure on Windows with a high-polling-rate mouse before changing it. | -| Cached GLFW state | Round trips to the main thread | No GLFW | **n/a** | -| A frame limiter that sleeps, then spins | Imprecise sleeps | Horizon has its own limiter | **no** (no reported problem) | - -## Worth measuring - -Each of these needs a profile or a benchmark first. They are ordered by the expected gain. They are in the LATER list in `~/code/horizon-parity/FEATURES.md`, not filed as issues: - -1. Hopper and block-entity sleeping, with vanilla-identical results (Lithium). Benchmark: a hopper and furnace array. -2. Particles: vanilla's frustum point test (a parity fix too), then GPU-built quads (AsyncParticles). Benchmark: 1,000+ campfires. -3. Jigsaw placement: skip blocked connectors and already-failed elements without changing the layout (Structure Layout Optimizer). Benchmark: trial chambers and ancient cities in fresh worlds, `docs/generation-scan-benchmark.md`. -4. Windows raw input in batches for high-polling-rate mice (Ixeris). Benchmark: an 8000 Hz mouse on Windows. -5. Profile before choosing a technique: mob pathfinding, TNT explosions, item merging after #996, map walls and sign-heavy scenes. diff --git a/docs/release-flow.md b/docs/release-flow.md index 758f254ee..4fb0209d9 100644 --- a/docs/release-flow.md +++ b/docs/release-flow.md @@ -312,6 +312,15 @@ and by hand; pushes to `launcher` and `launcher-*` branches only build. - Published with `--latest=false`: the repository's latest release stays a game release. Notes list the pull requests under New and Fixed; Kira posts launcher releases without pinging. +Making a launcher release GitHub's latest instead would break servers: every `horizon-server` already installed, +`install.sh` and `install.ps1` ask for `releases/latest` and expect the game's archives there, and a server that +can't update can't fetch the fix either. So the game release stays the latest, and it sends people to the launcher +(#1647): its notes open with a "Want to play? Download the Horizon launcher" block (`PLAYERS` in +`tools/release_train.py`: raw HTML, which GitHub shows and launchers' notes skip; the site's Releases page leaves +it out too), and its archives carry labels ("Game files the +launcher installs: Linux (…)") that GitHub shows in place of the file names. Everything that downloads matches +the asset's name, which is unchanged. + Starting by hand, pausing and rolling back work as for the game (`gh workflow run launcher …`, `RELEASES_PAUSED`, `gh release edit launcher@X.Y.Z --draft`). Launchers older than the withdrawn release then see the previous one as the newest; launchers that already updated keep running. diff --git a/docs/research/java-mod-compat.md b/docs/research/java-mod-compat.md deleted file mode 100644 index 1a5f96f8f..000000000 --- a/docs/research/java-mod-compat.md +++ /dev/null @@ -1,181 +0,0 @@ -# Java mods and Horizon: what can carry over - -Players ask "will my mods work?". Short answer: **Fabric and NeoForge jars -will not run in Horizon as they are**, and no bridge we could build would -change that for more than a handful of mods. What carries over is the -*content* (data packs, resource packs, the data and assets inside mod jars) -and the *ideas* (native Horizon ports of the mods people use most, written -with [Horizon's own mod system](../mods.md)). This page is the reasoning. - -## How Java mods work - -### Fabric - -- **Fabric Loader** finds jars in `mods/`, reads `fabric.mod.json` - (entrypoints, dependencies, mixin configs, access wideners), and starts the - game through a class loader that can rewrite classes as they load. -- **Mixin** (SpongePowered) is how nearly every mod changes the game: a mixin - class names a Minecraft class (`net.minecraft.client.gui.hud.InGameHud`) and - injects code at points inside its methods (`@Inject(method = "render", at = - @At("TAIL"))`, `@Redirect`, `@ModifyVariable`, `@Overwrite`...). The bytecode - of the vanilla class is rewritten at load time. Access wideners make private - fields and methods public for the same purpose. -- **Fabric API** is a set of modules that give mods events and registries - instead of raw mixins: `fabric-lifecycle-events` (`ClientTickEvents`, - `ServerTickEvents`), `fabric-rendering` (`HudRenderCallback`, - `WorldRenderEvents`), `fabric-command-api`, `fabric-key-binding-api`, - `fabric-networking-api` (custom payloads), `fabric-registry-sync`, - `fabric-resource-loader`, `fabric-screen-api`, `fabric-item-group`, - `fabric-events-interaction` and about forty more. **Fabric API itself is - implemented with mixins** into the same vanilla classes. -- Mods mix the two freely: a mod using Fabric API events still calls - `MinecraftClient.getInstance().player.getBlockPos()`, - `world.getBlockState(pos)`, `DrawContext.drawText(...)`: direct calls into - vanilla's classes, by their mapped names. - -### NeoForge (and Forge) - -- An event bus (`NeoForge.EVENT_BUS`, mod buses) with hundreds of events, - `DeferredRegister` for registries, data attachments and capabilities, - networking payloads, config specs. NeoForge patches vanilla's source - directly (binary patches) to fire its events. -- Mods also use mixins and access transformers, and call vanilla classes - directly, as on Fabric. - -### Data and assets in a jar - -Besides code, a mod jar carries the same folders as packs: -`assets//` (models, blockstates, textures, sounds, language files, -shaders) and `data//` (recipes, loot tables, tags, advancements, -predicates, functions, worldgen: biomes, features, structures). These are -**vanilla formats**, read by vanilla's own code. - -## Why a Java bridge cannot run them - -Horizon is a reimplementation in Rust: there are no `net.minecraft` classes -at runtime, no `InGameHud`, no `ClientPlayerEntity`, no bytecode to rewrite. - -1. **Mixins have nothing to bind to.** A mixin is a patch against a specific - method's bytecode. Without vanilla's classes there is no method, no - injection point and no local variable to modify. This is not a missing - feature we could add: it is the mechanism itself. -2. **Fabric API is mixins too.** A shim Fabric API would have to be - re-implemented from scratch as Java classes calling into Horizon. That part - alone is possible for the event modules. -3. **Mods call vanilla directly.** Even "pure Fabric API" mods use vanilla's - classes for everything else: the player, the world, the block states, the - renderer, the text drawing. Running them means providing Java classes with - vanilla's names and behaviour, backed by Horizon's state: in effect a - second Minecraft, in Java, on top of Horizon. Thousands of classes, in the - mapped names of every mapping set (Yarn, Mojang, intermediary), version by - version. -4. **The JVM itself** would ship with every install (a trimmed JRE is still - 40-60 MB, the full one 150+ MB), start in a second or more, hold a few - hundred MB of heap before any mod loads, and bring garbage-collector pauses - back into the frame: the costs Horizon exists to remove. JNI calls cost - tens to hundreds of nanoseconds each and every one crosses with copies. -5. **No sandbox.** Java mods are fully trusted native-speed code with file - and network access. Horizon's mods are sandboxed and their permissions are - shown; a Java bridge would be the one hole in that. - -**What a bridge could support**, if we ever built one: a stable subset of -Fabric API events (client and server tick, HUD render callback, client -commands, key bindings, custom payloads), with a tiny "vanilla view" API -(player position, held item, chat), for mods written only against that -subset. Surveying the most-downloaded Fabric mods, nearly none qualify: the -popular ones are popular precisely because they reach into rendering, the -world or the UI. The cost (a JVM in the game, a second API surface to keep -stable) is far above the benefit. **We do not build it.** If that changes, -the bridge would sit on top of the WIT API like any other mod runtime, so the -sandbox would still hold. - -## What we do instead - -### 1. Data-driven content (packs and the data in mod jars) - -Horizon already reads vanilla resource packs and data packs (functions, -function tags, predicates today). Extending data-pack coverage to recipes, -loot tables, tags, advancements and worldgen JSON brings most "content" -packs over with no mod code at all, and it is vanilla behaviour, so the parity -harnesses check it. - -For **Fabric/NeoForge jars**, the launcher can offer "import the data": read -`data/` and `assets/` from the jar and load them as a data pack plus a -resource pack. What works: new recipes, loot changes, tags, advancements, -functions, worldgen tweaks that only use vanilla blocks, retextures, language -files. What does not: anything referring to a block, item or entity the jar -registers in Java code (the ids do not exist); the import skips those files and -lists them. With Horizon's planned `registries` interface, a native port can -register those ids and reuse the jar's JSON models, textures, recipes and loot -as they are. - -### 2. Native Horizon ports of popular mods - -Horizon itself covers the performance mods: Sodium, Lithium, FerriteCore, -ModernFix, EntityCulling and ImmediatelyFast exist because vanilla Java is -slow, and Horizon's renderer and simulation are the replacement (see -[benchmark](../benchmark.md)). Zoom (OK Zoomer, Zoomify), FPS and keystroke -overlays, a minimap and auto-reconnect are already built in as -[extras](../extras.md). - -#### Port first - -Ranked by players reached per unit of API work. Each needs the planned -interfaces listed in [mods.md](../mods.md#planned-interfaces). - -| Mod (Java) | What it does | Horizon port | Needs | -|---|---|---|---| -| **Mod Menu** | list mods, open their settings | built in: Options > Mods (done), settings pages next | `ui` | -| **AppleSkin** | food saturation and exhaustion on the HUD and tooltips | SDK mod | `inventory-read`, `ui` | -| **Jade / WTHIT** | what the crosshair points at: block, entity, harvest tool, container contents | SDK mod | `target`, `ui` | -| **JEI / EMI / REI** | browse items, recipes and uses | SDK mod (or built in: Horizon already has the recipe book's data) | `recipes`, `inventory-read`, `ui` | -| **Xaero's Minimap / JourneyMap** | minimap, world map, waypoints | the minimap is an extra; a world map and waypoints as an SDK mod | `world-read`, `render`, `storage` | -| **Litematica** | schematic overlay to build from | SDK mod | `world-read`, `render`, `storage`, `ui` | -| **Mouse Tweaks / Inventory Profiles Next** | drag and sort inventory | built in or SDK mod | `inventory-read` + a sanctioned click API | -| **Continuity / CIT** | connected and custom item textures | built into the renderer (pack formats) | none: resource-pack features | -| **Distant Horizons** | low-detail far terrain | a Horizon renderer feature, not a mod | none | -| **Shader packs** | shaders | removed for now; a clean-room Horizon renderer feature, later | none | -| **Simple Voice Chat** | proximity voice | server + client mod | `server`, `net`, audio (later) | - -### 3. A porting guide (outline) - -To be written as `docs/porting-from-fabric.md` once API 0.2 lands: - -1. **Separate logic from glue.** Most of a mod is plain logic (maths, - formatting, data structures): port it to Rust once, unit-test it on the - host. -2. **Map events.** - - | Fabric | Horizon | - |---|---| - | `ClientModInitializer.onInitializeClient` | `Mod::init`, returning a `Registration` | - | `ClientTickEvents.END_CLIENT_TICK` | `Registration::on_tick`, `Mod::tick` | - | `HudRenderCallback` | `hud::set_panel` when the content changes (retained), or `on_frame` | - | `ClientCommandRegistrationCallback` | `Registration::command`, `Mod::command` | - | `ClientReceiveMessageEvents` | `Registration::on_chat`, `Mod::chat` | - | `KeyBindingHelper.registerKeyBinding` | `keys` (planned) | - | `Registry.register(Registries.ITEM, ...)` | `registries` (planned) with JSON in `data/` | - | `ServerPlayNetworking` payloads | `net` (planned) | - | config libraries (Cloth Config, YACL) | `storage` + a `ui` settings page (planned) | - -3. **Replace mixins with hooks.** For each mixin, write down what it observes - or changes. If a WIT hook covers it, use the hook. If not, open an issue - asking for the hook ("I need X before/after Y"): hooks are added to the API - for everyone instead of each mod patching the game. -4. **Declare capabilities** in `horizon-mod.toml`, the least the mod needs. -5. **Reuse assets**: textures, models, language files and recipes move as - they are into the `.hmod`'s `assets/` and `data/` (with `registries`). -6. **Test** with `cargo horizon-mod run` and hot reload; add unit tests for the - logic; publish with a signed `.hmod`. - -## Sources - -- Fabric documentation (`docs.fabricmc.net`): mod structure, Mixin - introduction, Fabric API modules and events. -- SpongePowered Mixin wiki: injection points and how class transformation - works. -- NeoForge documentation (`docs.neoforged.net`): events, registries, - networking. -- Modrinth's most-downloaded Fabric mods, for the porting list. -- Horizon's Fabric benchmark instrumentation (`mods/horizon/src/bench/`) remains - a developer tool for Java comparisons. The parity oracles live in `mods/horizon/src/test/`. diff --git a/docs/resource-packs.md b/docs/resource-packs.md index d53b2a13d..783c381dd 100644 --- a/docs/resource-packs.md +++ b/docs/resource-packs.md @@ -33,6 +33,7 @@ harness named checks that loader against vanilla). | Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) | | Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) | | Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` | +| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works, no download toasts | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server | | Other namespaces | `assets//` | works | `test_resource_pack_parity` | | Block states: variants, multipart, weights, rotations, uvlock | `blockstates/` | works | `test_blockstate_model_parity`, `test_model_choice_parity`, `test_blockstate_transform_parity` | | Block models: parents, elements, rotations, faces, cullface, tint, shade, light emission, ambient occlusion | `models/block/` | works | `test_model_resolution_parity`, `test_model_baking_parity`, `test_section_mesh_parity` | @@ -74,7 +75,7 @@ harness named checks that loader against vanilla). | Core shaders | `shaders/core/`, `shaders/include/` | **no** | Horizon draws with WGSL; a pack's GLSL core shaders aren't run | | GPU warn list, regional compliance | `gpu_warnlist.json`, `regional_compliancies.json` | n/a | OpenGL driver warnings and play-time notices for some regions; not used | -Summary: 44 rows; 31 work, 3 partly, 8 don't (interpolated animation, TrueType fonts, credits and end poem, +Summary: 45 rows; 32 work, 3 partly, 8 don't (interpolated animation, TrueType fonts, credits and end poem, villager hats, trims on worn armour, locator bar styles, post effects, core shaders), 2 don't apply. Except the shaders, the missing pieces are missing vanilla features too, and each vanilla parity fix covers the pack case as well. @@ -83,6 +84,7 @@ shaders, the missing pieces are missing vanilla features too, and each vanilla p | Gap | Size | Where | | --- | --- | --- | | Animation `interpolate` | small | fix PR (`gfx.rs` `animate_sprites`) | +| Server pack download toasts (`download.pack.*`) | small | `game/server_packs.rs` | | GUI scaling `width`/`height`, `stretch_inner`, `tile`, `stretch` | small | next fix PR (`ui.rs`) | | Villager hats | small | [#334](https://github.com/ludovic111/horizon/issues/334) | | `blur`/`clamp` from packs | small | [#335](https://github.com/ludovic111/horizon/issues/335) | diff --git a/launcher/README.md b/launcher/README.md index cf968f93c..1c0ea5522 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -97,6 +97,10 @@ page `servers.json` (the list), `servers//` (the servers created there) an Long pages, dialogs, the server console and data previews have a visible scrollbar when their content overflows. Drag the thumb or click the track to navigate without a mouse wheel. +Pages and Home's landscape fill the window as it resizes. Windows uses a matching title +bar with native dragging, resizing, Snap, +minimize, maximize/restore and close; macOS and Linux keep their system title bars. + ## Updates The launcher looks for a newer Horizon release when it starts and every 30 minutes while it @@ -127,7 +131,12 @@ and `horizon-launcher-windows-x64.zip`, never marked latest. The version is buil ## Command line -The same binary is a command-line tool; without a subcommand it opens the window. +The same binary is a command-line tool; without a subcommand it opens the window. On Windows it +is a windowed program, so a desktop start opens no terminal; a subcommand writes to the terminal +it was typed in, or to the pipes and files it was given (MCP keeps its stdio). Interactive `cmd` +and PowerShell don't wait for a windowed program: they show the prompt again before its output +and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code use +`start /wait horizon-launcher …` or `Start-Process -Wait`, or read its output through a pipe. horizon-launcher versions [--installed] releases on GitHub, or what is installed (* = selected) horizon-launcher install @@ -250,14 +259,20 @@ Each session writes its own measurements to `benchmarks/launcher-
) -> Stateful
{ b.opacity(theme::DISABLED).cursor_default().tab_stop(false) } @@ -1313,11 +1354,11 @@ fn megabytes(bytes: u64) -> String { // ----- Pages ------------------------------------------------------------------------------------- impl Launcher { - /// The top bar: the mark and the name over the sidebar, the pages with their icons, then - /// the account playing and the Settings button. + /// The top bar: the mark and the name over the sidebar (in the title bar on Windows), the + /// pages with their icons, then the account playing and the Settings button. fn topbar(&mut self, cx: &mut Context) -> Div { let t = self.theme; - let mut nav = div().flex().h_full().gap(px(2.)); + let mut nav = div().flex().flex_none().h_full().gap(px(2.)); for (page, label, icon) in Page::ALL { if page == Page::Settings { continue; @@ -1372,6 +1413,8 @@ impl Launcher { let account = keyboard(div().id("account"), &t) .relative() .flex() + .min_w_0() + .max_w(px(180.)) .items_center() .gap(px(10.)) .h(px(40.)) @@ -1395,8 +1438,10 @@ impl Launcher { div() .flex() .flex_col() + .min_w_0() .child( blocks::pixel(14., FontWeight::MEDIUM) + .truncate() .text_color(t.ink) .child(name), ) @@ -1448,25 +1493,29 @@ impl Launcher { .bg(t.side) .border_b_2() .border_color(t.outline) - .child( - div() - .flex() - .flex_none() - .items_center() - .gap(px(10.)) - .w(px(theme::SIDEBAR - 18.)) - .child(mark(24., &t)) - .child( - blocks::pixel(20., FontWeight::SEMIBOLD) - .text_color(t.ink) - .child("HORIZON"), - ), - ) + // Where the title bar is drawn here (Windows), it carries the mark and the name. + .when(!titlebar::DRAWN, |bar| { + bar.child( + div() + .flex() + .flex_none() + .items_center() + .gap(px(10.)) + .w(px(theme::SIDEBAR - 18.)) + .child(mark(24., &t)) + .child( + blocks::pixel(20., FontWeight::SEMIBOLD) + .text_color(t.ink) + .child("HORIZON"), + ), + ) + }) .child(nav) .child( div() .ml_auto() .flex() + .flex_none() .items_center() .gap(px(8.)) .child(account) @@ -1835,7 +1884,7 @@ impl Launcher { wrap } - fn play_page(&mut self, cx: &mut Context) -> Div { + fn play_page(&mut self, banner_width: f32, cx: &mut Context) -> Div { let t = self.theme; let Some(tag) = self.selected().cloned() else { // No hero without a version: the page starts below the top bar like the others. @@ -1994,7 +2043,7 @@ impl Launcher { // The banner: Horizon's landscape (`art.rs`) under a veil of the page colour, the hero and // the Play row over it. It reaches the content's edges and the top bar. - let scene = self.art.scene(t.dark, self.scale); + let (scene, scene_width) = self.art.scene(t.dark, self.scale, banner_width); let veil = |angle: f32, from: f32, to: f32, at: f32| { div() .absolute() @@ -2007,15 +2056,14 @@ impl Launcher { gpui::linear_color_stop(t.page.opacity(to), at), )) }; - let (w, h) = art::SCENE_SIZE; let banner = div() .relative() .flex() .flex_col() .justify_end() .min_h(px(340.)) - .mx(px(-32.)) - .px(px(32.)) + .mx(px(-theme::PAGE_GUTTER)) + .px(px(theme::PAGE_GUTTER)) .pb(px(28.)) .gap(px(24.)) .overflow_hidden() @@ -2027,8 +2075,8 @@ impl Launcher { .absolute() .bottom_0() .left_0() - .w(px(w as f32 * art::SCENE_TEXEL)) - .h(px(h as f32 * art::SCENE_TEXEL)), + .w(px(scene_width)) + .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)), ) .child(veil(90., 0.82, 0., 0.62)) .child(veil(180., 0., 0.75, 1.)) @@ -2901,7 +2949,7 @@ impl Launcher { )) } Load::Ready(r) if r.is_empty() => return page.child(centered("No releases yet.", &t)), - Load::Ready(r) => r.clone(), + Load::Ready(r) => r, }; // A hundred releases: only the rows near the screen are drawn. let keep = |i: usize| { @@ -2909,6 +2957,7 @@ impl Launcher { self.installing.as_ref().is_some_and(|(t, _)| t == tag) || self.install_error.as_ref().is_some_and(|(t, _)| t == tag) || self.confirm_remove.as_ref() == Some(tag) + || self.removing.as_ref() == Some(tag) }; let list = self.long_list.clone().column( &self.content_scroll.handle, @@ -2945,6 +2994,15 @@ impl Launcher { .child(format!("{:.0}%", p * 100.)), ) .into_any_element() + } else if self.removing.as_ref() == Some(&tag) { + div() + .flex() + .items_center() + .gap(px(10.)) + .w(px(180.)) + .child(progress_bar(None, &t)) + .child(text(theme::MICRO).text_color(t.muted).child("Removing…")) + .into_any_element() } else if installed { let confirming = self.confirm_remove.as_ref() == Some(&tag); let (t1, t2) = (tag.clone(), tag.clone()); @@ -3138,7 +3196,7 @@ impl Launcher { ), ) } - Load::Ready(r) => r.clone(), + Load::Ready(r) => r, }; let list = self.long_list.clone().column( &self.content_scroll.handle, @@ -3251,21 +3309,23 @@ impl Render for Launcher { self.friend_focused = self.friend_focus.is_focused(window); self.mods.note_focus(window); self.args_focused = self.args_focus.is_focused(window); + let size = window.viewport_size(); + let banner_width = f32::from(size.width) - theme::SIDEBAR - scrollbar::GUTTER; let content = match self.page { - Page::Play => self.play_page(cx), + Page::Play => self.play_page(banner_width, cx), Page::Versions => self.versions_page(cx), Page::Mods => self.mods_page(cx), Page::Servers => self.servers_page(cx), Page::Notes => self.notes_page(cx), Page::Settings => self.settings_page(cx), }; + self.art.free_replaced(window); // The new page fades in and rises a few pixels. let content = div() .relative() .w_full() // Let the page shrink inside the padded flex row so long notices can wrap. .min_w_0() - .max_w(px(1152.)) .child(content) .with_animation( ElementId::named_usize("page", self.switches), @@ -3277,7 +3337,6 @@ impl Render for Launcher { if self.opening.is_none() && window.focused(cx).is_none() { window.focus(&self.root_focus); } - let size = window.viewport_size(); let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor()); let topbar = self.topbar(cx); let sidebar = self.sidebar(cx); @@ -3333,7 +3392,9 @@ impl Render for Launcher { .child( div() .flex() - .px(px(32.)) + .w_full() + .min_w_0() + .px(px(theme::PAGE_GUTTER)) .pt(px(if self.page == Page::Play { 0. } else { @@ -3411,7 +3472,13 @@ impl Render for Launcher { }), ); } - root + div() + .flex() + .flex_col() + .size_full() + .bg(t.side) + .children(titlebar::render(&t, window)) + .child(root.flex_1().min_h_0()) } } @@ -3497,6 +3564,10 @@ fn menus() -> Vec { } fn main() { + if let Err(error) = console::attach_for_cli() { + eprintln!("Could not restore the launcher's terminal streams: {error}"); + std::process::exit(1); + } perf::process_started(); backend::exe_path(); if let Some(code) = cli::run() { @@ -3533,10 +3604,7 @@ fn main() { WindowOptions { window_bounds: Some(WindowBounds::Windowed(bounds)), window_min_size: Some(size(px(960.), px(600.))), - titlebar: Some(TitlebarOptions { - title: Some("Horizon".into()), - ..Default::default() - }), + titlebar: Some(titlebar::options()), app_id: Some("horizon-launcher".into()), ..Default::default() }, @@ -3563,6 +3631,20 @@ mod tests { assert!(hit.iter().any(|b| b.action().partial_eq(&CloseWindow))); } + #[test] + fn the_selection_survives_a_removal_or_moves_to_the_newest_left() { + let left = ["v0.2.49".to_string(), "v0.2.48".to_string()]; + let pick = + |saved: Option<&str>| super::selection_after_removal(&left, saved.map(String::from)); + assert_eq!(pick(Some("v0.2.48")).as_deref(), Some("v0.2.48")); + assert_eq!(pick(Some("v0.2.47")).as_deref(), Some("v0.2.49")); + assert_eq!(pick(None).as_deref(), Some("v0.2.49")); + assert_eq!( + super::selection_after_removal(&[], Some("v0.2.47".into())), + None + ); + } + #[test] fn the_app_menu_has_quit() { let menus = super::menus(); diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs index ccd0b3a4e..6346f8a0b 100644 --- a/launcher/src/modpacks_page.rs +++ b/launcher/src/modpacks_page.rs @@ -50,6 +50,7 @@ impl Launcher { self.pack_busy = false; match result { Ok(pack) => { + self.mods.report_list.reset(); self.pack_open = Some(pack.slug.clone()); self.packs.retain(|p| p.slug != pack.slug); self.packs.push(*pack); @@ -127,6 +128,7 @@ impl Launcher { /// Reads the imported packs, once (the sidebar and the Modpacks tab both show them). pub(super) fn load_packs(&mut self) { if self.packs_loaded.is_none() { + self.mods.report_list.reset(); self.packs = modpacks::list(); if self.pack_open.is_none() { self.pack_open = self.packs.first().map(|p| p.slug.clone()); @@ -193,6 +195,7 @@ impl Launcher { button(format!("open-{slug}"), "Open", Kind::Ghost, &t) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.pack_open = Some(slug.clone()); + this.mods.report_list.reset(); cx.notify(); })) .into_any_element() @@ -317,6 +320,7 @@ impl Launcher { Ok(()) => { this.packs.retain(|p| p.slug != slug); this.pack_open = this.packs.first().map(|p| p.slug.clone()); + this.mods.report_list.reset(); } Err(e) => this.pack_error = Some(e), } @@ -354,12 +358,13 @@ impl Launcher { move |value, _, cx| { let _ = this.update(cx, |this, cx| { this.pack_filter = value; + this.mods.report_list.reset(); cx.notify(); }); } }); - let mut list = div().flex().flex_col(); - for (i, r) in rows.iter().enumerate() { + let row = |i: usize| { + let r = rows[i]; let color = match r.status { Status::Ported => t.success, Status::Partial => t.accent, @@ -372,7 +377,7 @@ impl Launcher { format!("{} ({})", r.name, r.key) }; let detail = format!("{} · {} · {}: {}", r.class, r.tier, r.license, r.reason); - list = list.child(index_row( + index_row( i + 1, name, Some(detail.into_any_element()), @@ -383,8 +388,15 @@ impl Launcher { .into_any_element(), ), &t, - )); - } + ) + }; + let list = self.mods.report_list.column( + &self.content_scroll.handle, + rows.len(), + 8., + |_| false, + row, + ); Some( div() .flex() diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs index 00162f930..86e5e2e48 100644 --- a/launcher/src/mods_page.rs +++ b/launcher/src/mods_page.rs @@ -54,6 +54,9 @@ pub(super) struct Mods { searching: bool, searched: bool, results: Vec, + results_list: cull::Cull, + installed_list: cull::Cull, + pub(super) report_list: cull::Cull, more: bool, error: Option, installed: Vec, @@ -72,6 +75,12 @@ pub(super) struct Mods { } impl Mods { + pub(super) fn reset_lists(&self) { + self.results_list.reset(); + self.installed_list.reset(); + self.report_list.reset(); + } + /// Whether the Modpacks tab is open (the sidebar marks the pack shown there). pub(super) fn on_modpacks(&self) -> bool { self.kind == PackKind::Modpack @@ -94,6 +103,9 @@ impl Mods { searching: false, searched: false, results: Vec::new(), + results_list: cull::Cull::default(), + installed_list: cull::Cull::default(), + report_list: cull::Cull::default(), more: false, error: None, installed: Vec::new(), @@ -158,6 +170,7 @@ impl Launcher { self.go(Page::Mods); if slug.is_some() { self.pack_open = slug; + self.mods.report_list.reset(); } if self.mods.kind != PackKind::Modpack { self.mods.kind = PackKind::Modpack; @@ -203,6 +216,7 @@ impl Launcher { m.busy = None; m.message = Some(result); m.installed = installed::Installed::load(&backend::game_home()).entries; + m.installed_list.reset(); if modpack { // The Modpacks page reads its list again. self.packs_loaded = None; @@ -249,6 +263,8 @@ impl Launcher { if offset == 0 { m.results.clear(); m.more = false; + m.results_list.reset(); + m.installed_list.reset(); } let query = Query { everything: m.everything, @@ -295,8 +311,18 @@ impl Launcher { .ok_or_else(|| format!("{} isn't set up.", p.source.label())) .and_then(|source| { java::check_project(&home, &*source, &p, everything, &|_| {}) - }) - .map(|(_, c)| Box::new(c)); + }); + // The project's page, if open, shows the verdict beside its version. + if let Ok((version, check)) = &result { + let key = (p.source, p.id.clone()); + let _ = + tx.send(Event::Loaded(super::mods_project::Loaded::Checked( + key, + version.id.clone(), + check.verdict, + ))); + } + let result = result.map(|(_, check)| Box::new(check)); let _ = tx.send(Event::Checked((p.source, p.id), result)); } }); @@ -608,8 +634,8 @@ impl Launcher { return None; } let busy = self.mods.busy.is_some(); - let mut list = div().flex().flex_col(); - for (i, e) in entries.into_iter().enumerate() { + let row = |i: usize| { + let e = entries[i]; let key = (e.source, e.project.clone()); let mut right = div().flex().items_center().gap(px(8.)); if let Some(number) = self.mods.updates.get(&key) { @@ -654,6 +680,7 @@ impl Launcher { installed::remove(&home, &id).map(|e| format!("Removed {}.", e.title)), ); this.mods.installed = installed::Installed::load(&home).entries; + this.mods.installed_list.reset(); this.mods.confirm_remove = None; } else { this.mods.confirm_remove = Some(id.clone()); @@ -689,14 +716,21 @@ impl Launcher { .font_family(theme::MONO) .child(format!("checked: {}", short_sum(&e.checksum))), ); - list = list.child(index_row( + index_row( i + 1, e.title.clone(), Some(detail.into_any_element()), Some(right.into_any_element()), &t, - )); - } + ) + }; + let list = self.mods.installed_list.column( + &self.content_scroll.handle, + entries.len(), + 8., + |index| self.mods.confirm_remove.as_ref() == Some(&entries[index].project), + row, + ); Some( div() .flex() @@ -709,8 +743,6 @@ impl Launcher { fn mods_results(&mut self, cx: &mut Context) -> Div { let t = self.theme; - let found = self.mods.results.clone(); - let icons: Vec = found.iter().map(|p| self.mods_icon(p, 56.)).collect(); let m = &self.mods; if let Some(e) = &m.error { return div().child(notice(e.clone(), &t)); @@ -725,10 +757,15 @@ impl Launcher { }; return centered(line, &t); } - let busy = m.busy.as_ref().map(|b| b.0.as_str()); - let mut icons = icons.into_iter(); - let mut list = div().flex().flex_col(); - for (i, p) in m.results.iter().enumerate() { + let result_count = m.results.len(); + let rows = m.results_list.clone(); + let scroll = self.content_scroll.handle.clone(); + let row = |i: usize| { + let project = self.mods.results[i].clone(); + let icon = self.mods_icon(&project, 56.); + let p = &project; + let m = &self.mods; + let busy = m.busy.as_ref().map(|b| b.0.as_str()); let support = m.support(p); let checking = p.kind == PackKind::Mod && matches!( @@ -813,21 +850,23 @@ impl Launcher { .items_center() .gap(px(12.)) .cursor_pointer() - .child(icons.next().expect("one icon per result")) + .child(icon) .child(div().hover(|s| s.underline()).child(p.title.clone())) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.mods_open(open.clone()); cx.notify(); })); - list = list.child(index_row( + index_row( i + 1, name, Some(detail.into_any_element()), Some(right.into_any_element()), &t, - )); - } + ) + }; + let list = rows.column(&scroll, result_count, 8., |_| false, row); let mut out = div().flex().flex_col().child(list); + let m = &self.mods; if m.more { let mut more = button("mods-more", "More", Kind::Ghost, &t); if m.searching { diff --git a/launcher/src/mods_project.rs b/launcher/src/mods_project.rs index c66cf174a..ad75f58cd 100644 --- a/launcher/src/mods_project.rs +++ b/launcher/src/mods_project.rs @@ -19,6 +19,7 @@ use horizon_launcher::browser::{ }; use std::collections::{HashMap, HashSet}; use std::path::PathBuf; +use std::sync::Arc; /// A project page's tabs. #[derive(Clone, Copy, PartialEq, Eq)] @@ -38,8 +39,17 @@ const TABS: [(Tab, &str); 3] = [ pub(super) struct Opened { pub(super) project: Project, tab: Tab, - details: Option>, - versions: Option, String>>, + details: Option, String>>, + versions: Option, String>>, + version_list: cull::Cull, + checked_versions: HashMap, +} + +/// Cached verdicts are read with the version request, never while drawing a frame. +#[derive(Clone)] +pub(super) struct ProjectVersion { + version: Version, + verdict: Option, } /// The project page, filters and images' share of the Mods page's state. @@ -58,7 +68,12 @@ pub(super) struct Browse { /// What the background sends this module. pub(super) enum Loaded { Details((SourceId, String), Result), - Versions((SourceId, String), Result, String>), + Versions((SourceId, String), Result, String>), + Checked( + (SourceId, String), + String, + horizon_port_pack::check::Verdict, + ), Image((String, u32), Option), Tags((SourceId, PackKind), Result), } @@ -77,12 +92,20 @@ impl Launcher { match loaded { Loaded::Details(key, d) => { if let Some(o) = open(b, &key) { - o.details = Some(d); + o.details = Some(d.map(Arc::new)); } } Loaded::Versions(key, v) => { if let Some(o) = open(b, &key) { - o.versions = Some(v); + o.versions = Some(v.map(Arc::from)); + o.apply_checks(); + o.version_list.reset(); + } + } + Loaded::Checked(key, version, verdict) => { + if let Some(o) = open(b, &key) { + o.checked_versions.insert(version, verdict); + o.apply_checks(); } } Loaded::Image(key, path) => { @@ -106,7 +129,21 @@ impl Launcher { }; let d = source.details(&p); let _ = tx.send(Event::Loaded(Loaded::Details(key.clone(), d))); - let v = source.versions(&p); + let v = source.versions(&p).map(|versions| { + let home = backend::game_home(); + versions + .into_iter() + .map(|version| { + let verdict = version.file().and_then(|file| { + (p.kind == PackKind::Mod) + .then(|| java::cached(&home, file)) + .flatten() + .map(|check| check.verdict) + }); + ProjectVersion { version, verdict } + }) + .collect() + }); let _ = tx.send(Event::Loaded(Loaded::Versions(key, v))); }); self.mods.browse.open = Some(Opened { @@ -114,6 +151,8 @@ impl Launcher { tab: Tab::Description, details: None, versions: None, + version_list: cull::Cull::default(), + checked_versions: HashMap::new(), }); } @@ -361,6 +400,7 @@ impl Launcher { )); let details = o.details.clone(); let versions = o.versions.clone(); + let version_list = o.version_list.clone(); let mut meta = vec![format!("{} downloads", thousands(p.downloads))]; if let Some(Ok(d)) = &details { meta.push(format!("{} followers", thousands(d.followers))); @@ -551,9 +591,13 @@ impl Launcher { Tab::Versions => match &versions { None => centered("Loading…", &t), Some(Err(e)) => notice(e.clone(), &t), - Some(Ok(list)) => { - let mut rows = div().flex().flex_col(); - for (i, v) in list.iter().take(50).enumerate() { + Some(Ok(list)) => version_list.column( + &self.content_scroll.handle, + list.len().min(50), + 8., + |_| false, + |i| { + let v = &list[i].version; let file = v.file(); let mut detail = vec![ v.published.get(..10).unwrap_or_default().to_string(), @@ -570,27 +614,33 @@ impl Launcher { if let Some(f) = file { detail.push(format!("{} · {:.1} MB", f.name, f.size as f64 / 1e6)); } - let checked = file.and_then(|f| { - (p.kind == PackKind::Mod) - .then(|| java::cached(&backend::game_home(), f)) - .flatten() - }); - rows = rows.child(index_row( + index_row( i + 1, v.number.clone(), Some(detail.join(" · ").into_any_element()), - checked.map(|c| { - caps(c.verdict.label()) - .text_color(t.muted) - .into_any_element() + list[i].verdict.as_ref().map(|verdict| { + caps(verdict.label()).text_color(t.muted).into_any_element() }), &t, - )); - } - rows - } + ) + }, + ), }, }; Some(page.child(body)) } } + +impl Opened { + /// A check can finish before or after the version request; retain either event order. + fn apply_checks(&mut self) { + let Some(Ok(versions)) = &mut self.versions else { + return; + }; + for row in Arc::make_mut(versions) { + if let Some(verdict) = self.checked_versions.get(&row.version.id) { + row.verdict = Some(*verdict); + } + } + } +} diff --git a/launcher/src/perf.rs b/launcher/src/perf.rs index f46393542..c5c78c136 100644 --- a/launcher/src/perf.rs +++ b/launcher/src/perf.rs @@ -9,10 +9,11 @@ use std::collections::BTreeMap; use std::path::PathBuf; +use std::sync::mpsc::{self, Receiver, TryRecvError}; use std::sync::OnceLock; use std::time::{Duration, Instant}; -use horizon_bench::{App, Frames, Kind, Report}; +use horizon_bench::{App, Frames, Hardware, Kind, Report}; /// The first thing `main` does; every start time counts from here. pub fn process_started() -> Instant { @@ -35,14 +36,36 @@ pub struct Perf { dirty: bool, /// Off for the windows `horizon-launcher benchmark` starts: they report to it instead. log: bool, + /// Machine probes run after the first frame, never while opening the window. + hardware: Option>, +} + +#[derive(Debug)] +struct Machine { + hardware: Hardware, + power: Option, + load_average: Option, +} + +impl Machine { + fn detect() -> Self { + Self { + hardware: Hardware::detect(), + power: horizon_bench::power_source().map(str::to_owned), + load_average: horizon_bench::load_average(), + } + } } impl Perf { pub fn new(scenario: &str) -> Perf { - let mut report = Report::new(Kind::Launcher, app()); + let hardware = Hardware { + os: std::env::consts::OS.to_owned(), + arch: std::env::consts::ARCH.to_owned(), + ..Hardware::default() + }; + let mut report = Report::with_hardware(Kind::Launcher, app(), hardware); report.conditions.scenario = Some(scenario.to_owned()); - report.conditions.power = horizon_bench::power_source().map(str::to_owned); - report.conditions.load_avg_1m = horizon_bench::load_average(); let path = crate::backend::data_dir().join("benchmarks").join(format!( "launcher-{}-{scenario}.json", report @@ -61,6 +84,7 @@ impl Perf { saved: Instant::now(), dirty: false, log: true, + hardware: None, }; if let Some(bytes) = binary_bytes() { perf.record("launcher.binary_bytes", bytes); @@ -89,6 +113,12 @@ impl Perf { if first { self.first_frame = Some(now); self.record_since("launcher.start_ms", process_started()); + let (sender, receiver) = mpsc::channel(); + self.hardware = Some(receiver); + std::thread::spawn(move || { + // The window may close before the optional report details finish. + let _ = sender.send(Machine::detect()); + }); } else if let Some(gap) = self.last_frame.map(|t| now - t).filter(|g| *g < IDLE_GAP) { self.ui_frames.push(gap.as_secs_f32() * 1000.0); } @@ -102,6 +132,7 @@ impl Perf { /// Samples memory and writes the report when something changed, at most every few seconds. pub fn tick(&mut self) { + self.poll_hardware(); if self.saved.elapsed() < Duration::from_secs(5) { return; } @@ -118,6 +149,7 @@ impl Perf { } pub fn report(&mut self) -> &Report { + self.poll_hardware(); for (name, values) in &self.values { self.report.metric(name, values); } @@ -128,6 +160,24 @@ impl Perf { &self.report } + /// Takes the machine's details into the report once their thread has them. + fn poll_hardware(&mut self) { + let Some(receiver) = &self.hardware else { + return; + }; + match receiver.try_recv() { + Ok(machine) => { + self.report.hardware = machine.hardware; + self.report.conditions.power = machine.power; + self.report.conditions.load_avg_1m = machine.load_average; + self.hardware = None; + self.dirty = true; + } + Err(TryRecvError::Empty) => {} + Err(TryRecvError::Disconnected) => self.hardware = None, + } + } + pub fn save(&mut self) { self.dirty = false; if !self.log { @@ -381,6 +431,41 @@ fn binary_bytes() -> Option { mod tests { use super::*; + #[test] + fn performance_tracking_starts_without_hardware_probes() { + let mut perf = Perf::new("test"); + perf.keep_local_log(false); + assert!(perf.hardware.is_none()); + assert_eq!(perf.report.hardware.os, std::env::consts::OS); + assert!(perf.report.hardware.cpu.is_none()); + assert!(perf.report.conditions.power.is_none()); + } + + #[test] + fn background_hardware_details_preserve_recorded_metrics() { + let mut perf = Perf::new("test"); + perf.keep_local_log(false); + perf.record("launcher.start_ms", 125.); + let (sender, receiver) = mpsc::channel(); + perf.hardware = Some(receiver); + assert_eq!(perf.report().metrics["launcher.start_ms"].mean, 125.); + sender + .send(Machine { + hardware: Hardware { + cpu: Some("Detected CPU".into()), + ..Hardware::default() + }, + power: Some("ac".into()), + load_average: Some(0.5), + }) + .unwrap(); + let report = perf.report(); + assert_eq!(report.hardware.cpu.as_deref(), Some("Detected CPU")); + assert_eq!(report.conditions.power.as_deref(), Some("ac")); + assert_eq!(report.metrics["launcher.start_ms"].mean, 125.); + assert!(perf.hardware.is_none()); + } + #[test] fn the_first_frame_is_the_start_and_close_frames_are_ui_frames() { let mut perf = Perf::new("test"); diff --git a/launcher/src/process.rs b/launcher/src/process.rs new file mode 100644 index 000000000..5fa5902b1 --- /dev/null +++ b/launcher/src/process.rs @@ -0,0 +1,21 @@ +//! The programs the launcher runs in the background: on Windows they open no console window +//! (the launcher has none to share), and keep the streams their caller gives them. +use std::ffi::OsStr; +use std::process::Command; + +pub fn command(program: impl AsRef) -> Command { + let mut command = Command::new(program); + hide_console(&mut command); + command +} + +/// [`command`] for a `Command` made elsewhere. +pub fn hide_console(command: &mut Command) -> &mut Command { + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + command.creation_flags(CREATE_NO_WINDOW); + } + command +} diff --git a/launcher/src/scrollbar.rs b/launcher/src/scrollbar.rs index 757d3525e..723c98cca 100644 --- a/launcher/src/scrollbar.rs +++ b/launcher/src/scrollbar.rs @@ -6,6 +6,9 @@ use gpui::{ }; use std::{cell::Cell, rc::Rc}; +/// Space reserved beside scroll content for the track and its padding. +pub const GUTTER: f32 = 16.; + #[derive(Clone, Default)] pub(crate) struct Scrollbar { pub handle: ScrollHandle, @@ -60,7 +63,7 @@ impl Scrollbar { .child( content .track_scroll(&self.handle) - .mr(px(16.)) + .mr(px(GUTTER)) // Nested scroll areas must not also move the page behind them. .on_scroll_wheel(|_, _, cx| cx.stop_propagation()), ) diff --git a/launcher/src/servers.rs b/launcher/src/servers.rs index 49ef05d66..264ccb149 100644 --- a/launcher/src/servers.rs +++ b/launcher/src/servers.rs @@ -245,7 +245,7 @@ fn point(link: &Path, target: &Path) -> std::io::Result<()> { #[cfg(windows)] { let _ = fs::remove_dir(link); - let status = Command::new("cmd") + let status = crate::process::command("cmd") .args(["/C", "mklink", "/J"]) .arg(link) .arg(target) @@ -266,10 +266,8 @@ pub fn command(dir: &Path, args: &[&str]) -> Result { let program = program().ok_or( "The server programs aren't set up yet: create a server, or press Prepare on its page.", )?; - let mut cmd = Command::new(program); + let mut cmd = crate::process::command(program); cmd.arg("--dir").arg(dir).args(args); - #[cfg(windows)] - std::os::windows::process::CommandExt::creation_flags(&mut cmd, 0x0800_0000); // CREATE_NO_WINDOW Ok(cmd) } @@ -752,7 +750,7 @@ pub fn lan_address() -> Option { pub fn service_installed(dir: &Path) -> bool { if cfg!(windows) { let name = format!("horizon-server-{}", service_suffix(dir)); - return Command::new("schtasks") + return crate::process::command("schtasks") .args(["/Query", "/TN", &name]) .stdout(Stdio::null()) .stderr(Stdio::null()) diff --git a/launcher/src/sources.rs b/launcher/src/sources.rs index 864e6bc73..b27b8417b 100644 --- a/launcher/src/sources.rs +++ b/launcher/src/sources.rs @@ -488,7 +488,7 @@ fn make_link(target: &Path, link: &Path) -> std::io::Result<()> { arg.push("\""); arg }; - let status = std::process::Command::new("cmd") + let status = crate::process::command("cmd") .args(["/C", "mklink", "/J"]) .raw_arg(quoted(link)) .raw_arg(quoted(target)) diff --git a/launcher/src/tailscale.rs b/launcher/src/tailscale.rs index 683ff0aab..b0c20d3bc 100644 --- a/launcher/src/tailscale.rs +++ b/launcher/src/tailscale.rs @@ -126,13 +126,8 @@ pub fn status_of(cli: Option) -> State { let Some(cli) = cli else { return State::Missing; }; - let mut command = Command::new(&cli); + let mut command = crate::process::command(&cli); command.args(["status", "--json"]); - #[cfg(windows)] - { - use std::os::windows::process::CommandExt; - command.creation_flags(0x0800_0000); // CREATE_NO_WINDOW - } let out = match command.output() { Ok(out) => out, Err(e) => return State::Off(e.to_string()), diff --git a/launcher/src/theme.rs b/launcher/src/theme.rs index 6425232c5..60b796709 100644 --- a/launcher/src/theme.rs +++ b/launcher/src/theme.rs @@ -24,6 +24,7 @@ pub const CONTROL: f32 = 34.; /// The top bar, and the sidebar of instances and servers. pub const TOPBAR: f32 = 56.; pub const SIDEBAR: f32 = 248.; +pub const PAGE_GUTTER: f32 = 32.; /// Motion: short and eased out, never bouncy. pub const QUICK: Duration = tokens::QUICK.duration(); diff --git a/launcher/src/titlebar.rs b/launcher/src/titlebar.rs new file mode 100644 index 000000000..3c2a78ea4 --- /dev/null +++ b/launcher/src/titlebar.rs @@ -0,0 +1,156 @@ +//! Custom Windows chrome. Other platforms keep their native window decorations. +use crate::theme::Theme; +use gpui::{Div, TitlebarOptions, Window}; + +/// Whether the launcher draws its own title bar (`render`) rather than the system. +pub const DRAWN: bool = cfg!(target_os = "windows"); + +pub fn options() -> TitlebarOptions { + TitlebarOptions { + title: Some("Horizon".into()), + appears_transparent: DRAWN, + ..Default::default() + } +} + +#[cfg(not(target_os = "windows"))] +pub fn render(_theme: &Theme, _window: &Window) -> Option
{ + None +} + +#[cfg(target_os = "windows")] +mod windows { + use super::*; + use crate::{blocks, mark}; + use gpui::{div, prelude::*, px, FontWeight, Stateful, WindowControlArea}; + + const HEIGHT: f32 = 32.; + const BUTTON_WIDTH: f32 = 46.; + const RESIZE_INSET: f32 = 5.; + + #[derive(Clone, Copy)] + enum Control { + Minimize, + Maximize, + Close, + } + + impl Control { + fn area(self) -> WindowControlArea { + match self { + Self::Minimize => WindowControlArea::Min, + Self::Maximize => WindowControlArea::Max, + Self::Close => WindowControlArea::Close, + } + } + + fn name(self) -> &'static str { + match self { + Self::Minimize => "window-minimize", + Self::Maximize => "window-maximize", + Self::Close => "window-close", + } + } + } + + fn control_icon(control: Control, maximized: bool, theme: &Theme) -> Div { + let square = || { + div() + .absolute() + .size(px(10.)) + .border_1() + .border_color(theme.ink_soft) + }; + let icon = div().relative().size(px(14.)); + match control { + Control::Minimize => icon.child( + div() + .absolute() + .left(px(2.)) + .top(px(7.)) + .w(px(10.)) + .h(px(1.)) + .bg(theme.ink_soft), + ), + Control::Maximize if maximized => icon + .child( + div() + .absolute() + .left(px(4.)) + .top_0() + .size(px(10.)) + .border_t_1() + .border_r_1() + .border_color(theme.ink_soft), + ) + .child(square().left(px(1.)).top(px(3.))), + Control::Maximize => icon.child(square().left(px(2.)).top(px(2.))), + Control::Close => { + let hover_color = theme.page; + icon.child( + blocks::icon("close", 14., theme.ink_soft) + .group_hover("window-close", move |style| style.text_color(hover_color)), + ) + } + } + } + + fn control_button(control: Control, theme: &Theme, maximized: bool) -> Stateful
{ + let theme = *theme; + div() + .id(control.name()) + .group(control.name()) + .flex() + .flex_none() + .items_center() + .justify_center() + .w(px(BUTTON_WIDTH)) + .h_full() + .text_color(theme.ink_soft) + // GPUI maps these to native non-client hit tests, retaining Snap Layouts, + // Alt+Space and close handling. Click callbacks would run the action twice. + .window_control_area(control.area()) + .hover(move |style| match control { + Control::Close => style.bg(theme.danger).text_color(theme.page), + _ => style.bg(theme.raised), + }) + .child(control_icon(control, maximized, &theme)) + } + + pub fn render(theme: &Theme, window: &Window) -> Option
{ + let drag = div() + .id("window-drag") + .flex() + .flex_1() + .h_full() + .items_center() + .gap(px(8.)) + .px(px(12.)) + .window_control_area(WindowControlArea::Drag) + .child(mark(16., theme)) + .child(blocks::pixel(13., FontWeight::MEDIUM).child("Horizon")); + Some( + div() + .flex() + .flex_none() + .items_center() + .h(px(HEIGHT)) + // Control hit tests run before native edge resizing in GPUI 0.2.2. + .when(!window.is_maximized(), |bar| { + bar.pt(px(RESIZE_INSET)).px(px(RESIZE_INSET)) + }) + .bg(theme.side) + .text_color(theme.muted) + .border_b_1() + .border_color(theme.outline) + .child(drag) + .children( + [Control::Minimize, Control::Maximize, Control::Close] + .map(|control| control_button(control, theme, window.is_maximized())), + ), + ) + } +} + +#[cfg(target_os = "windows")] +pub use windows::render; diff --git a/launcher/tests/hidden_processes.rs b/launcher/tests/hidden_processes.rs new file mode 100644 index 000000000..c7da90ea9 --- /dev/null +++ b/launcher/tests/hidden_processes.rs @@ -0,0 +1,116 @@ +//! Windows background processes must keep logs, input and exit status without a console. +#![cfg(windows)] + +mod support; +use horizon_launcher::{ + backend::{self, Job, Msg}, + process, +}; +use std::{fs, path::Path, sync::mpsc, time::Duration}; +use support::console_probe as probe; + +fn logged_child(fail: bool) -> (Vec, Result<(), String>) { + let (sender, receiver) = mpsc::channel(); + let mut command = std::process::Command::new(probe()); + if fail { + command.arg("--fail"); + } + let mut child = backend::spawn(Job::Prepare, command, sender).unwrap(); + child.send("input reaches the child"); + let mut lines = Vec::new(); + loop { + match receiver.recv_timeout(Duration::from_secs(10)).unwrap() { + Msg::Line(Job::Prepare, line) => lines.push(line), + Msg::Exit(Job::Prepare, result) => return (lines, result), + _ => panic!("unexpected job message"), + } + } +} + +#[test] +fn hidden_children_keep_stdout_stderr_stdin_and_success() { + let (lines, result) = logged_child(false); + assert!(result.is_ok(), "{result:?}"); + for expected in [ + "console_window_visible=false", + "stdout is captured", + "stderr is captured", + "stdin=input reaches the child", + ] { + assert!( + lines.iter().any(|line| line == expected), + "missing {expected}: {lines:?}" + ); + } +} + +#[test] +fn hidden_children_report_failure_and_keep_their_logs() { + let (lines, result) = logged_child(true); + assert!(result.unwrap_err().contains('7')); + assert!(lines.iter().any(|line| line == "stderr is captured")); +} + +#[test] +fn exporters_write_to_their_log_file_without_a_console() { + let root = probe().parent().unwrap(); + let path = root.join("exporter.log"); + let log = fs::File::create(&path).unwrap(); + let jdk = horizon_prepare::java::Jdk { + java: probe().into(), + javac: probe().into(), + }; + jdk.java(&[], Some(root), &log).unwrap(); + let output = fs::read_to_string(path).unwrap(); + for expected in [ + "console_window_visible=false", + "stdout is captured", + "stderr is captured", + ] { + assert!(output.contains(expected), "missing {expected}: {output}"); + } +} + +#[test] +fn cli_keeps_redirected_stdout_and_stderr() { + let executable = env!("CARGO_BIN_EXE_horizon-launcher"); + let version = process::command(executable) + .arg("--version") + .output() + .unwrap(); + assert!(version.status.success()); + assert!(String::from_utf8_lossy(&version.stdout).starts_with("horizon-launcher ")); + let invalid = process::command(executable) + .arg("--unknown-option") + .output() + .unwrap(); + assert!(!invalid.status.success()); + assert!(String::from_utf8_lossy(&invalid.stderr).contains("--unknown-option")); +} + +#[test] +fn mcp_keeps_its_stdio_transport() { + let executable = Path::new(env!("CARGO_BIN_EXE_horizon-launcher")); + assert!(horizon_launcher::agents::self_test(executable).unwrap() > 0); +} + +#[test] +fn desktop_executable_uses_the_windows_gui_subsystem() { + const PE_HEADER_POINTER: usize = 0x3c; + const PE_OPTIONAL_HEADER_OFFSET: usize = 24; + const SUBSYSTEM_OFFSET: usize = 68; + const WINDOWS_GUI_SUBSYSTEM: u16 = 2; + + let executable = fs::read(env!("CARGO_BIN_EXE_horizon-launcher")).unwrap(); + let header = u32::from_le_bytes( + executable[PE_HEADER_POINTER..PE_HEADER_POINTER + 4] + .try_into() + .unwrap(), + ) as usize; + assert_eq!(&executable[header..header + 4], b"PE\0\0"); + let subsystem = header + PE_OPTIONAL_HEADER_OFFSET + SUBSYSTEM_OFFSET; + assert_eq!( + u16::from_le_bytes(executable[subsystem..subsystem + 2].try_into().unwrap()), + WINDOWS_GUI_SUBSYSTEM + ); +} diff --git a/launcher/tests/startup.rs b/launcher/tests/startup.rs new file mode 100644 index 000000000..776d8ef15 --- /dev/null +++ b/launcher/tests/startup.rs @@ -0,0 +1,88 @@ +//! Full launcher startup against instrumented Windows hardware probes. +#![cfg(windows)] + +mod support; +use std::{ + fs, + path::{Path, PathBuf}, + process::{Child, Output, Stdio}, + time::{Duration, Instant}, +}; + +fn fixture() -> PathBuf { + let root = std::env::temp_dir().join(format!("horizon-startup-{}", std::process::id())); + for folder in ["game/telemetry", "launcher", "data", "config", "probes"] { + fs::create_dir_all(root.join(folder)).unwrap(); + } + fs::write(root.join("launcher/settings.json"), r#"{"skip_opening":true,"install_new_versions":false,"desktop_entry":false,"ping_notice_seen":true}"#).unwrap(); + let consent = serde_json::json!({"version":horizon_telemetry::CONSENT_VERSION,"choices":{}}); + fs::write( + root.join("game/telemetry/consent.json"), + consent.to_string(), + ) + .unwrap(); + fs::copy(support::console_probe(), root.join("probes/powershell.exe")).unwrap(); + root +} + +fn launch(root: &Path) -> Child { + let inherited_path = std::env::var_os("PATH").unwrap(); + let paths = std::iter::once(root.join("probes")).chain(std::env::split_paths(&inherited_path)); + horizon_launcher::process::command(env!("CARGO_BIN_EXE_horizon-launcher")) + .current_dir(root) + .env("PATH", std::env::join_paths(paths).unwrap()) + .env("HORIZON_HOME", root.join("game")) + .env("HORIZON_LAUNCHER_HOME", root.join("launcher")) + .env("XDG_DATA_HOME", root.join("data")) + .env("XDG_CONFIG_HOME", root.join("config")) + .env("HORIZON_LAUNCHER_NO_SELF_UPDATE", "1") + .env("HORIZON_NO_AUDIO", "1") + .env("HORIZON_TELEMETRY_URL", "off") + .env("HORIZON_STARTUP_PROBE_LOG", root.join("probes.log")) + .env("HORIZON_LAUNCHER_BENCH", root.join("timing.json")) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap() +} + +fn wait_for_exit(mut child: Child, root: &Path) -> Output { + let deadline = Instant::now() + Duration::from_secs(30); + while child.try_wait().unwrap().is_none() { + if Instant::now() >= deadline { + child.kill().unwrap(); + child.wait().unwrap(); + panic!("launcher startup timed out: {}", root.display()); + } + std::thread::sleep(Duration::from_millis(20)); + } + child.wait_with_output().unwrap() +} + +#[test] +#[ignore = "requires an interactive Windows desktop and graphics adapter"] +fn hardware_probes_run_hidden_after_the_first_frame() { + let root = fixture(); + let output = wait_for_exit(launch(&root), &root); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + let timing: serde_json::Value = + serde_json::from_slice(&fs::read(root.join("timing.json")).unwrap()).unwrap(); + let first_frame = timing["first_frame_epoch_ms"].as_f64().unwrap().floor(); + let probes = fs::read_to_string(root.join("probes.log")).unwrap(); + // Rust resolves cmd.exe to the system directory, so instrument the seven PowerShell + // probes, which exercise both shared helpers (the cmd probes use those same helpers). + const POWERSHELL_PROBES: usize = 7; + assert_eq!(probes.lines().count(), POWERSHELL_PROBES, "{probes}"); + for probe in probes.lines() { + let fields: Vec<_> = probe.split('|').collect(); + assert!( + fields[0].parse::().unwrap() >= first_frame, + "probe blocked startup: {probe}" + ); + assert_eq!(fields[1], "false", "probe opened a terminal: {probe}"); + } +} diff --git a/launcher/tests/support/console_probe.rs b/launcher/tests/support/console_probe.rs new file mode 100644 index 000000000..1ff16a10b --- /dev/null +++ b/launcher/tests/support/console_probe.rs @@ -0,0 +1,73 @@ +//! A real Windows console program used to check hidden children and their streams. +use std::ffi::c_void; +use std::io; + +fn hardware_probe(visible: bool) -> bool { + let Some(path) = std::env::var_os("HORIZON_STARTUP_PROBE_LOG") else { + return false; + }; + use std::io::Write; + let arguments = std::env::args().skip(1).collect::>().join(" "); + let program = std::env::current_exe().unwrap(); + let timestamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis(); + let mut log = std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(path) + .unwrap(); + writeln!( + log, + "{timestamp}|{visible}|{}", + program.file_name().unwrap().to_string_lossy() + ) + .unwrap(); + // Slow probes make a synchronous startup regression visible without relying on WMI speed. + std::thread::sleep(std::time::Duration::from_millis(100)); + let responses = [ + ("TotalPhysicalMemory", "17179869184"), + ("NumberOfCores", "8"), + ("MaxClockSpeed", "3600"), + ("BatteryStatus", "2"), + ("Win32_Battery", "0"), + ]; + let response = responses + .iter() + .find_map(|&(query, response)| arguments.contains(query).then_some(response)) + .unwrap_or("Microsoft Windows [Version 10.0.26100]"); + println!("{response}"); + true +} + +#[link(name = "kernel32")] +extern "system" { + fn GetConsoleWindow() -> *mut c_void; +} + +#[link(name = "user32")] +extern "system" { + fn IsWindowVisible(window: *mut c_void) -> i32; +} + +fn main() { + // A console connection can exist without a terminal window, including in ConPTY. + // SAFETY: The opaque window handle comes from Windows and is only queried, never changed. + let visible = unsafe { + let window = GetConsoleWindow(); + !window.is_null() && IsWindowVisible(window) != 0 + }; + if hardware_probe(visible) { + return; + } + println!("console_window_visible={visible}"); + println!("stdout is captured"); + eprintln!("stderr is captured"); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + println!("stdin={}", input.trim()); + if std::env::args().any(|argument| argument == "--fail") { + std::process::exit(7); + } +} diff --git a/launcher/tests/support/mod.rs b/launcher/tests/support/mod.rs new file mode 100644 index 000000000..b5a72d115 --- /dev/null +++ b/launcher/tests/support/mod.rs @@ -0,0 +1,29 @@ +use horizon_launcher::process; +use std::{ + fs, + path::{Path, PathBuf}, + sync::OnceLock, +}; + +pub fn console_probe() -> &'static Path { + static PROBE: OnceLock = OnceLock::new(); + PROBE.get_or_init(|| { + let root = + std::env::temp_dir().join(format!("horizon-console-probe-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + let executable = root.join("console-probe.exe"); + let source = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/support/console_probe.rs"); + let output = process::command("rustc") + .arg(source) + .arg("-o") + .arg(&executable) + .output() + .unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + executable + }) +} diff --git a/tests/test_game_home.py b/tests/test_game_home.py new file mode 100644 index 000000000..b4d9e017f --- /dev/null +++ b/tests/test_game_home.py @@ -0,0 +1,102 @@ +"""A tool or harness that starts the game must not write into a real player's folders. + +The game logs into HORIZON_HOME and falls back to the player's own game folder when it is unset, so every +spawn goes through lab.game_env, which sets fresh scratch folders. This test fails for a script in tools/ +that starts the game (or horizon-ctl, the launcher or the dedicated server) without it.""" + +import ast +import os +from pathlib import Path +import tempfile +import unittest +from unittest import mock + +from tools import lab + +TOOLS = Path(lab.ROOT) / "tools" + +# Strings that mean "this script starts the game": a binary a harness runs, or the audio switch every game run sets. +SPAWN_MARKERS = { + "HORIZON_NO_AUDIO", "horizon-ctl", "horizon-ctl.exe", "horizon-server", "horizon-server.exe", + "horizon-client.exe", "release/horizon-client", "fast/horizon-client", "debug/horizon-client", +} + +# Scripts that mention those strings without starting a game themselves, and why. +EXEMPT = { + "lab.py": "defines game_env", + "parity.py": "runs the harnesses and gives each its own HORIZON_HOME", + "package_native_client.py": "packs the binaries into an archive", + "build_release.py": "builds and packs the release", + "release_train.py": "release bookkeeping", + "pr_ready.py": "runs cargo checks and parity.py", + "port_harness.py": "ports Java code, starts no game", +} + + +def constants(tree): + """Every string in a script that is a whole literal or a keyword name (docstrings are longer text).""" + for node in ast.walk(tree): + if isinstance(node, ast.Constant) and isinstance(node.value, str): + yield node.value + elif isinstance(node, ast.keyword) and node.arg: + yield node.arg + + +def uses_game_env(tree): + """The script calls lab.game_env, or starts its servers through test_dedicated_server_parity.Server, which does.""" + return any(isinstance(node, ast.Attribute) and node.attr == "game_env" + or isinstance(node, ast.Name) and node.id == "game_env" + or isinstance(node, ast.ImportFrom) and (node.module or "").endswith("test_dedicated_server_parity") + for node in ast.walk(tree)) + + +def sets_audio_by_hand(tree): + return "HORIZON_NO_AUDIO" in set(constants(tree)) + + +class GameEnvTests(unittest.TestCase): + def test_gives_every_game_scratch_folders(self): + with mock.patch.dict(os.environ, {}, clear=False): + for key in ("HORIZON_HOME", "HORIZON_LAUNCHER_HOME", "XDG_DATA_HOME", "XDG_CONFIG_HOME"): + os.environ.pop(key, None) + first, second = lab.game_env(), lab.game_env() + self.assertEqual(first["HORIZON_NO_AUDIO"], "1") + self.assertEqual(first["HORIZON_LAUNCHER_NO_SELF_UPDATE"], "1") + for key in ("HORIZON_HOME", "HORIZON_LAUNCHER_HOME", "XDG_DATA_HOME", "XDG_CONFIG_HOME"): + self.assertTrue(Path(first[key]).is_dir(), key) + self.assertNotEqual(first[key], second[key], key) + + def test_keeps_the_callers_folders(self): + with tempfile.TemporaryDirectory() as temp: + env = lab.game_env({"PATH": "x", "HORIZON_HOME": "/from/base"}, HORIZON_LAUNCHER_HOME=Path(temp), A=1) + self.assertEqual(env["HORIZON_HOME"], "/from/base") + self.assertEqual(env["HORIZON_LAUNCHER_HOME"], temp) + self.assertEqual((env["PATH"], env["A"]), ("x", "1")) + + def test_does_not_touch_the_process_environment(self): + before = dict(os.environ) + lab.game_env() + self.assertEqual(dict(os.environ), before) + + +class SpawnerTests(unittest.TestCase): + def test_every_script_that_starts_the_game_uses_game_env(self): + offenders = [] + for path in sorted(TOOLS.rglob("*.py")): + if path.name in EXEMPT: + continue + tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path)) + if SPAWN_MARKERS & set(constants(tree)) and not uses_game_env(tree): + offenders.append(str(path.relative_to(lab.ROOT))) + self.assertEqual(offenders, [], "these start the game without lab.game_env (HORIZON_HOME falls back to a " + "real player's folder); use it, or list the script in EXEMPT") + + def test_nobody_sets_the_audio_switch_by_hand(self): + offenders = [str(path.relative_to(lab.ROOT)) for path in sorted(TOOLS.rglob("*.py")) + if path.name not in EXEMPT + and sets_audio_by_hand(ast.parse(path.read_text(encoding="utf-8"), filename=str(path)))] + self.assertEqual(offenders, [], "set it through lab.game_env, which also gives the game scratch folders") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index eac664c89..d10fde854 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -283,3 +283,20 @@ class OracleReuseTests(unittest.TestCase): if __name__ == "__main__": unittest.main() + + +class LargeOutputTests(unittest.TestCase): + def test_a_pass_clears_only_its_own_directory(self): + with tempfile.TemporaryDirectory() as tmp: + local, state = Path(tmp) / ".local", Path(tmp) / "state" + own, shared = local / "decorated-region-parity", local / "chunk-generation-parity" + for directory in (own, shared): + directory.mkdir(parents=True) + (directory / "dump.txt").write_bytes(b"x" * 16) + trace = {"commands": [["java", "-d", str(shared / "classes")], ["probe", str(own / "dump.txt")]]} + with mock.patch.multiple(parity, LOCAL=local, STATE_DIR=state, LARGE_OUTPUT=8): + parity.outputs_listing("decorated_region", fresh=True) + parity.clear_large_outputs("decorated_region", trace) + self.assertFalse((own / "dump.txt").exists()) + # chunk_generation may still be writing there. + self.assertTrue((shared / "dump.txt").exists()) diff --git a/tests/test_release_train.py b/tests/test_release_train.py index dde734c7d..56064fa42 100644 --- a/tests/test_release_train.py +++ b/tests/test_release_train.py @@ -106,16 +106,18 @@ class ReleaseTrainTests(unittest.TestCase): def test_the_first_release_of_0_2_says_what_changed(self): title, body = train.notes("game", "v0.2.0", [pr(1)], [], previous="v2026.10.21") self.assertTrue(title.startswith("Horizon 0.2.0: "), title) + body = body.removeprefix(train.PLAYERS + "\n\n") self.assertTrue(body.startswith("Horizon is numbered from now on: this is Horizon 0.2.0, the release after 2026.10.21.")) self.assertIn("`horizon-server update --version v0.2.0`", body) title, body = train.notes("launcher", "launcher@0.2.0", [], [], previous="launcher-v0.17.0") self.assertEqual(title, "Horizon launcher 0.2.0") self.assertIn("the release after launcher 0.17.0", body) self.assertIn("Rebuilt from the latest main.", body) - self.assertTrue(train.notes("game", "v0.3.0", [pr(1)], [], previous="v0.2.14")[1].startswith("The first release of Horizon 0.3.")) + body = train.notes("game", "v0.3.0", [pr(1)], [], previous="v0.2.14")[1] + self.assertTrue(body.startswith(train.PLAYERS + "\n\nThe first release of Horizon 0.3.")) for version, previous in [("v0.2.1", "v0.2.0"), ("v0.3.0-rc.1", "v0.2.9"), ("v2026.10.23", "v2026.10.21")]: body = train.notes("game", version, [pr(1)], [], previous=previous)[1] - self.assertTrue(body.startswith("### Fixed"), (version, body)) + self.assertTrue(body.startswith(train.PLAYERS + "\n\n### Fixed"), (version, body)) def test_decision(self): minute = dt.timedelta(minutes=1) @@ -201,6 +203,18 @@ class ReleaseTrainTests(unittest.TestCase): self.assertEqual(title, "Horizon launcher 0.2.0") self.assertIn("### Fixed\n- Launcher: say the self-update succeeded (#3)", body) self.assertNotIn("Known issues", body) + self.assertNotIn(train.PLAYERS, body) + self.assertIn("Your launcher updates itself.", body) + + def test_a_game_release_opens_with_the_way_to_the_launcher(self): + # GitHub's latest is a game release: whoever lands on it is sent to the launcher first (#1647). + _, body = train.notes("game", "v0.2.50", [pr(1)], ["- Sound cuts out after an hour."]) + self.assertTrue(body.startswith('

Want to play? Download the Horizon launcher')) + self.assertIn('href="https://github.com/ludovic111/horizon/releases?q=launcher&expanded=true"', body) + self.assertNotIn("\n", train.PLAYERS, "one line: one HTML block, which ends at the blank line after it") + self.assertEqual(body.count("playhorizon.dev"), 1, "said once, at the top") + _, body = train.notes("game", "v0.2.51", [], []) + self.assertTrue(body.startswith(train.PLAYERS + "\n\nRebuilt from the latest main.")) def test_known_issues_are_the_bullets_of_the_file(self): with tempfile.TemporaryDirectory() as temp: diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 3fcf39553..7f0c52bce 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -67,17 +67,20 @@ class Failed(Exception): pass -def game_env(screen): +def game_env(screen, home=None): + """The environment of a game: lab.game_env with HORIZON_HOME `home` (a scratch folder when None), no live-count + ping, and on Linux the virtual screen `screen`.""" + extra = {'HORIZON_TELEMETRY_URL': 'off'} # no live-count ping from test games + if home is not None: + extra['HORIZON_HOME'] = home if sys.platform == 'darwin': - return dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') - env = dict(os.environ, VSCREEN=screen) + 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 env.pop('DISPLAY', None) for match in re.finditer(r'(\w+)=(\S+)', text.split('unset')[0]): env[match.group(1)] = match.group(2) - env['HORIZON_NO_AUDIO'] = '1' - env['HORIZON_TELEMETRY_URL'] = 'off' # no live-count ping from test games if LAVAPIPE.exists(): env['VK_ICD_FILENAMES'] = str(LAVAPIPE) return env @@ -632,7 +635,7 @@ def scratch(mode, resources): (work / '.local/horizon-client').mkdir() os.symlink(resources, work / '.local/horizon-client' / lab.VERSION) # horizon-ctl reads No AI in the game home: this one, not the player's. - env = dict(game_env(os.environ.get('VSCREEN', 'agent-control')), HORIZON_HOME=str(work)) + env = game_env(os.environ.get('VSCREEN', 'agent-control'), home=work) return work, env diff --git a/tools/baseline_loader_profile.rs b/tools/baseline_loader_profile.rs deleted file mode 100644 index f966301b8..000000000 --- a/tools/baseline_loader_profile.rs +++ /dev/null @@ -1,23 +0,0 @@ -//! Historical baseline comparator for PR #607; one normal independent loading sequence. -use horizon_client::{assets::Assets, blocks::BlockFacts}; -use horizon_world::level::Behaviours; -use std::{path::Path, time::Instant}; - -fn main() -> Result<(), Box> { - let mut args = std::env::args().skip(1); - let root = args.next().ok_or("expected prepared resource directory")?; - if args.next().as_deref() != Some("baseline") { - return Err("expected baseline".into()); - } - let root = Path::new(&root); - let total = Instant::now(); - let assets = Assets::load(root)?; - let started = Instant::now(); - let facts = BlockFacts::load(root, assets.registry)?; - let behaviours = Behaviours::load(assets.registry, root)?; - println!("phase_ms={:.3}", started.elapsed().as_secs_f64() * 1000.0); - println!("total_ms={:.3}", total.elapsed().as_secs_f64() * 1000.0); - println!("states={}", facts.states.len()); - std::hint::black_box((facts, behaviours)); - Ok(()) -} diff --git a/tools/graphics_bench.py b/tools/graphics_bench.py index 0e42e94d5..f19165f62 100644 --- a/tools/graphics_bench.py +++ b/tools/graphics_bench.py @@ -53,15 +53,14 @@ guiScale:0 def vscreen_env(): out = subprocess.run(["vscreen", "env"], cwd=ROOT, capture_output=True, text=True, check=True) - env = dict(os.environ) + env = lab.game_env() for part in out.stdout.replace(";", " ").split(): if "=" in part and not part.startswith("export"): k, v = part.split("=", 1) env[k] = v env.pop("DISPLAY", None) - # Benchmark games never play sound on the machine's speakers. - env["HORIZON_NO_AUDIO"] = "1" - # Nor reach the telemetry server (docs/telemetry.md). + # lab.game_env: no sound on the machine's speakers, and scratch folders instead of the player's. + # Benchmark games do not reach the telemetry server (docs/telemetry.md). env["HORIZON_TELEMETRY_URL"] = "off" return env diff --git a/tools/lab.py b/tools/lab.py index a62a38f59..b7cc2f795 100644 --- a/tools/lab.py +++ b/tools/lab.py @@ -5,6 +5,7 @@ generated files stay in .local/. Also the small helpers the harnesses share (free ports, offline UUIDs, VarInts, float bits).""" import argparse +import atexit from collections import Counter import hashlib import json @@ -54,6 +55,38 @@ def cargo_target(): return ROOT / os.environ.get("CARGO_TARGET_DIR", "target") +_SCRATCH_DIRS = [] + + +def _scratch_dir(prefix): + path = tempfile.mkdtemp(prefix=prefix) + _SCRATCH_DIRS.append(path) + return path + + +@atexit.register +def _remove_scratch_dirs(): + for path in _SCRATCH_DIRS: + shutil.rmtree(path, ignore_errors=True) + + +def game_env(base=None, **extra): + """The environment for every run of the game, the launcher or horizon-ctl from a tool or a harness: no audio, + and fresh scratch folders for the game's home (logs, saves, options), the launcher's home and the XDG folders, + so a run never writes into a real player's folders (the game falls back to them when HORIZON_HOME is unset). + A folder the caller already has in `base` (default os.environ) or passes in `extra` is kept. The scratch folders + are removed when this process exits.""" + env = dict(os.environ if base is None else base) + env.update({key: str(value) for key, value in extra.items()}) + env["HORIZON_NO_AUDIO"] = "1" + env["HORIZON_LAUNCHER_NO_SELF_UPDATE"] = "1" + for key, prefix in (("HORIZON_HOME", "horizon-home-"), ("HORIZON_LAUNCHER_HOME", "horizon-launcher-home-"), + ("XDG_DATA_HOME", "horizon-xdg-data-"), ("XDG_CONFIG_HOME", "horizon-xdg-config-")): + if not env.get(key): + env[key] = _scratch_dir(prefix) + return env + + def write_json(path, data): path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8") diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 3ece4b448..80cd434c8 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -228,6 +228,9 @@ address. The script then checks, from both sides, what a guest's game used to ge - villagers: the guest sees each villager's and zombie villager's type, profession and level as the host has them, and an unemployed villager that takes a composter becomes a farmer on the guest too (the guest used to draw every villager as an unemployed plains one). +- falling: an item and a falling block the host summons high up fall smoothly on the guest, a + little further every tick between the server's updates (every 20 ticks), as their own + client tick moves them (they used to hang, then jump down once a second, #1568). Each check is reported on its own (a failing one doesn't stop the others) and the screenshots of both sides go to --out (host-*.png, guest-*.png). @@ -275,8 +278,7 @@ class Game: (self.work / '.local/horizon-client').mkdir(parents=True) 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')) - env['HORIZON_HOME'] = str(self.work / 'home') + env = game_env(os.environ.get('VSCREEN', 'lan-e2e'), home=self.work / 'home') self.d = Cli(ctl, self.socket, self.work, env) self.d.name = name @@ -5496,5 +5498,46 @@ CHECKS += ['villagers'] CHECK_FNS.update(villagers=check_villagers) +def check_falling(host, guest, out): + """ItemEntity and FallingBlockEntity tick on a client too (gravity, collisions, drag), and their + position packets snap them (Entity's NO_OP InterpolationHandler). The server sends an item's + and a falling block's position every 20 ticks, so between two updates the guest's own tick is + what moves them: sampled every 2 ticks over the first 16, both are lower nearly every time.""" + x, y, z = (int(v // 1) for v in pos_of(guest)) + top = y + 30 + tag = 'falling_e2e' + host('command', command=f'fill {x + 2} {y} {z - 1} {x + 4} {top + 2} {z + 1} minecraft:air') + host('command', command=f'summon minecraft:item {x + 3.5} {top} {z + 0.5} ' + f'{{Tags:["{tag}"],Item:{{id:"minecraft:diamond",count:1}},PickupDelay:32767}}') + host('command', command=f'summon minecraft:falling_block {x + 2.5} {top} {z - 0.5} ' + f'{{Tags:["{tag}"],BlockState:{{Name:"minecraft:sand"}},DropItem:0b}}') + heights = {'item': [], 'falling block': []} + try: + for _ in range(8): + items = [e['pos'][1] for e in guest.raw('entities', 48, 'minecraft:item')['entities'] + if abs(e['pos'][0] - x - 3.5) < 0.5 and abs(e['pos'][2] - z - 0.5) < 0.5] + blocks = [o['position'][1] for o in guest('status')['projectiles'] + if o.get('kind') == 'minecraft:falling_block' + and abs(o['position'][0] - x - 2.5) < 0.5 and abs(o['position'][2] - z + 0.5) < 0.5] + heights['item'].append(items[0] if items else None) + heights['falling block'].append(blocks[0] if blocks else None) + guest.wait(2) + guest.shot(out, 'falling') + finally: + host('command', command=f'kill @e[tag={tag}]') + host('command', command=f'fill {x + 2} {y} {z - 1} {x + 4} {top + 2} {z + 1} minecraft:air') + for name, ys in heights.items(): + seen = [h for h in ys if h is not None] + assert len(seen) >= 6, f'the guest saw the {name} {len(seen)} times of 8: {heights}' + drops = sum(b < a for a, b in zip(seen, seen[1:])) + # A tick or two can pass between two samples with no move; never most of them. + assert drops >= len(seen) - 2, f'the {name} fell in {drops} of {len(seen) - 1} samples: {heights}' + return heights + + +CHECKS += ['falling'] +CHECK_FNS.update(falling=check_falling) + + if __name__ == '__main__': main() diff --git a/tools/launcher_mcp_e2e.py b/tools/launcher_mcp_e2e.py index 0b827d288..748acafc2 100644 --- a/tools/launcher_mcp_e2e.py +++ b/tools/launcher_mcp_e2e.py @@ -167,8 +167,7 @@ def main(): os.symlink(bins / name, version / name) os.symlink(resources, version / '.local/horizon-client' / lab.VERSION) (version / '.installed').write_text('') - env = dict(os.environ, HORIZON_LAUNCHER_HOME=str(work / 'launcher'), HORIZON_HOME=str(work / 'home'), - HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') + env = lab.game_env(HORIZON_LAUNCHER_HOME=work / 'launcher', HORIZON_HOME=work / 'home', HORIZON_TELEMETRY_URL='off') m = Mcp(Path(args.launcher).resolve(), env) try: summary = scenario(m, out) diff --git a/tools/mod_browser_harness.py b/tools/mod_browser_harness.py index 4531570bc..cf33d85de 100755 --- a/tools/mod_browser_harness.py +++ b/tools/mod_browser_harness.py @@ -33,6 +33,11 @@ import tempfile import time from pathlib import Path +try: + from . import lab +except ImportError: + import lab + ROOT = Path(__file__).resolve().parents[1] @@ -154,8 +159,7 @@ def main(): args = ap.parse_args() home = Path(tempfile.mkdtemp(prefix="horizon-mod-browser-")) - env = dict(os.environ, HORIZON_HOME=str(home), HORIZON_NO_AUDIO="1", HORIZON_NO_HEARTBEAT="1", - HORIZON_CONTROL=str(home / "ctl.sock")) + env = lab.game_env(HORIZON_HOME=home, HORIZON_NO_HEARTBEAT="1", HORIZON_CONTROL=home / "ctl.sock") launcher = [args.launcher] game = Game(str(Path(args.bin) / "horizon-ctl"), str(Path(args.bin) / "horizon-client"), args.resources, home, env) diff --git a/tools/parity.py b/tools/parity.py index 4ed75f5ef..503a5f3bf 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -39,6 +39,7 @@ import json import os from pathlib import Path, PurePosixPath import re +import shutil import socket import subprocess import sys @@ -679,7 +680,10 @@ def clear_large_outputs(name, trace): top = path.relative_to(local).parts[0] except (ValueError, IndexError): continue - if top not in OWN_DIRECTORIES: + # Only the harness's own directory: another harness running beside it may be writing + # large files in a directory this one merely read (decorated_region compiles its oracle + # into chunk-generation-parity while chunk_generation writes its dumps there). + if top not in OWN_DIRECTORIES and top.startswith(name.replace("_", "-")): directories.add(local / top) for directory in directories: for file in (directory.rglob("*") if directory.is_dir() else []): @@ -809,6 +813,12 @@ class LocalExecutor: trace.unlink(missing_ok=True) log = (STATE_DIR / "logs" / f"{name}.log").open("w") environment = run_environment(reuse) + # A game the harness starts logs into HORIZON_HOME, which is a real player's folder when it is unset + # (lab.game_env keeps this one). + game_home = STATE_DIR / "game-home" / name + shutil.rmtree(game_home, ignore_errors=True) + game_home.mkdir(parents=True) + environment.setdefault("HORIZON_HOME", str(game_home)) environment["PARITY_SHIM_OUTPUTS"] = str(outputs_listing(name, fresh=True)) environment.pop("PARITY_SHARD", None) if shard: diff --git a/tools/perf_bench.py b/tools/perf_bench.py index 21aa99f85..a403e9b83 100644 --- a/tools/perf_bench.py +++ b/tools/perf_bench.py @@ -400,7 +400,7 @@ def run_horizon(args, distance): for carry in dev_mods(args): command += ["--dev-mod", str(carry)] # Benchmark runs stay out of the live count and send nothing (docs/telemetry.md). - env = dict(os.environ, HORIZON_NO_AUDIO="1", HORIZON_TELEMETRY_URL="off") + env = lab.game_env(HORIZON_TELEMETRY_URL="off") if args.warm: # A first start to the title screen builds what later starts reuse (the content-mod # root, the block behaviour snapshot). It is not measured: players see it once. diff --git a/tools/release_train.py b/tools/release_train.py index 6ec2739d9..48d4d46cf 100644 --- a/tools/release_train.py +++ b/tools/release_train.py @@ -74,12 +74,17 @@ LAUNCHER_PATHS = [ ] LAUNCHER_IGNORED = ["launcher/links.json", "launcher/docs/", "launcher/tests/"] -FOOTER = { - "game": "Install or update it from the Horizon launcher: it installs new versions by itself. " - "New here? Get the launcher at https://playhorizon.dev. You need your own copy of Minecraft: Java Edition.", - "launcher": "Your launcher updates itself. New here? Download the archive for your system below, extract it, " - "and run `horizon-launcher`. Website: https://playhorizon.dev", -} +# A game release is GitHub's latest (servers and install.sh follow it), so it is the first release people land on: +# its notes open with the way to the launcher (#1647). Raw HTML on one line, which GitHub shows and every launcher's +# notes view and one-line summary skip (pulldown-cmark's HTML events), so launchers never tell players to get +# themselves. The site's Releases page leaves it out too. +PLAYERS = ('

Want to play? Download the Horizon launcher, not the files ' + 'below

It installs this version and keeps it up to date. It is also on GitHub: the launcher releases. You need your ' + "own copy of Minecraft: Java Edition. The files below are what the launcher installs, and the dedicated " + "server for people who host one.

") +LAUNCHER_FOOTER = ("Your launcher updates itself. New here? Download the archive for your system below, extract it, " + "and run `horizon-launcher`. Website: https://playhorizon.dev") DISCLAIMER = "Not an official Minecraft product. Not approved by or associated with Mojang or Microsoft." # An open issue with this label holds every game release (docs/release-flow.md). Only people who can triage the # repository can add it, and the issue's text is never read: its author could edit it afterwards. @@ -374,7 +379,9 @@ def notes(kind, version, prs, issues, previous=None): else: title = f"Horizon launcher {version.removeprefix(OLD_LAUNCHER_PREFIX).removeprefix(LAUNCHER_PREFIX)}" intro = line_intro(kind, version, previous) - parts = [intro] if intro else [] + parts = [PLAYERS] if kind == "game" else [] + if intro: + parts.append(intro) if not shown: parts.append("Rebuilt from the latest main.") if new: @@ -386,7 +393,8 @@ def notes(kind, version, prs, issues, previous=None): contributors = sorted({pr["author"] for pr in shown if pr["author"] and pr["author"] != REPO.split("/")[0]}) if contributors: parts.append("Thanks to " + ", ".join(f"@{name}" for name in contributors) + ".") - parts.append(FOOTER[kind]) + if kind == "launcher": + parts.append(LAUNCHER_FOOTER) parts.append(DISCLAIMER) return title, "\n\n".join(parts) + "\n" diff --git a/tools/server_bench.py b/tools/server_bench.py index 3b97d4624..5ba2c7157 100755 --- a/tools/server_bench.py +++ b/tools/server_bench.py @@ -120,7 +120,7 @@ class Server: self.process = subprocess.Popen([str(c) for c in command], cwd=directory, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding='utf-8', errors='replace', - env=dict(os.environ, HORIZON_NO_AUDIO='1')) + env=lab.game_env()) threading.Thread(target=self._read, daemon=True).start() def _read(self): diff --git a/tools/server_pack_e2e.py b/tools/server_pack_e2e.py new file mode 100644 index 000000000..160083d5e --- /dev/null +++ b/tools/server_pack_e2e.py @@ -0,0 +1,515 @@ +#!/usr/bin/env python3 +"""Server resource packs end to end: a real Horizon client joins a real dedicated server (vanilla 26.3's, or +Horizon's with --horizon-server BIN) that offers a test pack from a local HTTP server, through tools/net_capture.py, +which records the statuses the client sends back. + +The pack is built here: dirt recoloured blue, and three lang strings (dirt's name, the pause menu's "Back to Game", +the server list's "Join Server"). Each scenario sets the server list entry's Server Resource Packs setting in +servers.dat, joins, answers the prompt the way a player would (horizon-ctl clicks its buttons), and checks the +statuses against what vanilla's client sends (ServerPackManager): + +- required, Prompt, Disconnect: no status, the disconnected screen says "This server requires a custom resource + pack", the setting stays Prompt; +- required, Prompt, Proceed: ACCEPTED, DOWNLOADED, SUCCESSFULLY_LOADED; the setting becomes Enabled, the file is in + downloads/ under its SHA-1 with a log.json entry, the HTTP request carries vanilla's X-Minecraft-* headers, the + blue dirt is on screen (screenshot) and the pause menu says the pack's "Back to Game"; after leaving, the server + list says "Join Server" again (the pack is gone); +- required, Enabled: no prompt, the same three statuses, and no second download (the cache); +- required with a wrong SHA-1: ACCEPTED, FAILED_DOWNLOAD, and the player still joins; +- optional, Prompt, No: DECLINED, joins, the setting becomes Disabled; then joining again sends DECLINED without + asking; then Prompt and Yes: the pack (no hash given) is downloaded and loaded; +- optional on a dead URL: ACCEPTED, FAILED_DOWNLOAD, joins. + + python3 tools/server_pack_e2e.py # vanilla's server + python3 tools/server_pack_e2e.py --horizon-server target/release/horizon-client + +Every game and server here runs in fresh temporary folders (HORIZON_HOME, HORIZON_LAUNCHER_HOME, XDG_*), with no +audio and no self-update. Needs .local (the vanilla jars and prepared resources) and a built horizon-client and +horizon-ctl (--bin DIR, default target/fast). +""" +import argparse +import hashlib +import http.server +import json +import os +from pathlib import Path +import shutil +import socket +import struct +import subprocess +import sys +import tempfile +import threading +import time +import zipfile +import zlib + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import lab # noqa: E402 +import net_capture # noqa: E402 +import test_rust_parity as base # noqa: E402 +from test_dedicated_server_parity import Server, free_port # noqa: E402 + +# ServerboundResourcePackPacket.Action, by ordinal. +ACTIONS = ['successfully_loaded', 'declined', 'failed_download', 'accepted', 'downloaded', 'invalid_url', + 'failed_reload', 'discarded'] +LOADED = ['accepted', 'downloaded', 'successfully_loaded'] +FAILED = ['accepted', 'failed_download'] +REQUIRED_REASON = 'This server requires a custom resource pack' +PLAYER = 'Steve' +PROPERTIES = { + 'online-mode': 'false', 'white-list': 'false', 'level-seed': '12345', 'level-type': 'minecraft\\:flat', + 'generate-structures': 'false', 'view-distance': '3', 'simulation-distance': '3', 'spawn-protection': '0', + 'pause-when-empty-seconds': '-1', 'gamemode': 'creative', +} + + +class Failed(Exception): + pass + + +def check(condition, what): + if not condition: + raise Failed(what) + print(f' ok: {what}') + + +# The pack. + +def png(width, height, pixel): + rows = b''.join(b'\0' + b''.join(bytes(pixel(x, y)) for x in range(width)) for y in range(height)) + + def chunk(kind, data): + return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data)) + header = struct.pack('>IIBBBBB', width, height, 8, 6, 0, 0, 0) + return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', header) + chunk(b'IDAT', zlib.compress(rows)) + chunk(b'IEND', b'') + + +def build_pack(path): + """The test pack, byte for byte the same every time (fixed dates), and its SHA-1.""" + def blue(x, y): + return (40, 90, 230, 255) if (x // 4 + y // 4) % 2 else (20, 50, 170, 255) + files = { + 'pack.mcmeta': json.dumps({'pack': {'description': 'Horizon server pack test', + 'min_format': 97, 'max_format': 97}}).encode(), + 'assets/minecraft/textures/block/dirt.png': png(16, 16, blue), + 'assets/minecraft/lang/en_us.json': json.dumps({ + 'block.minecraft.dirt': 'Blue Test Dirt', + 'menu.returnToGame': 'Back to Game (server pack)', + 'selectServer.select': 'Join Server (server pack)', + }).encode(), + } + with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as z: + for name, data in files.items(): + z.writestr(zipfile.ZipInfo(name, (2026, 1, 1, 0, 0, 0)), data) + return hashlib.sha1(path.read_bytes()).hexdigest() + + +def decode_png(data): + """RGB(A) pixels of an 8-bit PNG: (width, height, rows of (r, g, b)).""" + pos, idat, width = 8, b'', 0 + while pos < len(data): + length, kind = struct.unpack('>I4s', data[pos:pos + 8]) + body = data[pos + 8:pos + 8 + length] + if kind == b'IHDR': + width, height, depth, colour = struct.unpack('>IIBB', body[:10]) + assert depth == 8 and colour in (2, 6), (depth, colour) + channels = 4 if colour == 6 else 3 + elif kind == b'IDAT': + idat += body + pos += 12 + length + raw, stride, rows, previous = zlib.decompress(idat), width * channels, [], bytearray(width * channels) + for y in range(height): + kind, line = raw[y * (stride + 1)], bytearray(raw[y * (stride + 1) + 1:(y + 1) * (stride + 1)]) + for i in range(stride): + left = line[i - channels] if i >= channels else 0 + up, corner = previous[i], previous[i - channels] if i >= channels else 0 + if kind == 1: + line[i] = (line[i] + left) & 255 + elif kind == 2: + line[i] = (line[i] + up) & 255 + elif kind == 3: + line[i] = (line[i] + (left + up) // 2) & 255 + elif kind == 4: + p = left + up - corner + pa, pb, pc = abs(p - left), abs(p - up), abs(p - corner) + line[i] = (line[i] + (left if pa <= pb and pa <= pc else up if pb <= pc else corner)) & 255 + rows.append([tuple(line[x * channels:x * channels + 3]) for x in range(width)]) + previous = line + return width, height, rows + + +def blue_share(path): + """How much of the picture's lower middle (the ground under a player looking down) is blue.""" + width, height, rows = decode_png(path.read_bytes()) + samples = [rows[y][x] for y in range(height // 2 + height // 8, height - height // 8, 4) + for x in range(width // 4, 3 * width // 4, 4)] + return sum(b > r + 60 and b > g + 30 for r, g, b in samples) / len(samples) + + +# The HTTP server the pack comes from. + +class Files(http.server.ThreadingHTTPServer): + def __init__(self, files): + self.files, self.requests = files, [] + + class Handler(http.server.BaseHTTPRequestHandler): + def do_GET(handler): + headers = {k: v for k, v in handler.headers.items() if k.lower().startswith(('x-minecraft', 'user-agent'))} + self.requests.append((handler.path, headers)) + data = self.files.get(handler.path) + if data is None: + handler.send_error(404) + return + handler.send_response(200) + handler.send_header('Content-Type', 'application/zip') + handler.send_header('Content-Length', str(len(data))) + handler.end_headers() + handler.wfile.write(data) + + def log_message(handler, *args): + pass + super().__init__(('127.0.0.1', 0), Handler) + threading.Thread(target=self.serve_forever, daemon=True).start() + + def url(self, path): + return f'http://127.0.0.1:{self.server_address[1]}{path}' + + +# servers.dat (NbtIo.write: uncompressed, a named root compound). + +def nbt_string(s): + data = s.encode() + return struct.pack('>H', len(data)) + data + + +def write_servers(path, ip, setting): + """One entry for ip; setting True (Enabled), False (Disabled) or None (Prompt: no acceptTextures).""" + entry = b'\x08' + nbt_string('name') + nbt_string('Pack test') + b'\x08' + nbt_string('ip') + nbt_string(ip) + if setting is not None: + entry += b'\x01' + nbt_string('acceptTextures') + bytes([int(setting)]) + root = b'\x09' + nbt_string('servers') + b'\x0a' + struct.pack('>i', 1) + entry + b'\x00' + path.write_bytes(b'\x0a' + nbt_string('') + root + b'\x00') + + +def read_setting(path): + data = path.read_bytes() + key = b'\x01' + nbt_string('acceptTextures') + at = data.find(key) + return None if at < 0 else bool(data[at + len(key)]) + + +# The game. + +class Game: + def __init__(self, bins, resources, work): + self.home = work / 'home' + for d in ('home', 'launcher', 'data', 'config'): + (work / d).mkdir(parents=True) + self.env = lab.game_env(HORIZON_HOME=self.home, HORIZON_LAUNCHER_HOME=work / 'launcher', + XDG_DATA_HOME=work / 'data', XDG_CONFIG_HOME=work / 'config', HORIZON_TELEMETRY_URL='off') + self.base = [str(bins / 'horizon-ctl'), '--socket', str(work / 'c.sock')] + self.log = work / 'c.log' + reply = self('launch', '--game', bins / 'horizon-client', '--offscreen', '--resources', resources) + self.pid = reply.get('pid') + + def __call__(self, *words, ok=True, timeout=300): + result = subprocess.run(self.base + [str(w) for w in words], cwd=self.home, env=self.env, + capture_output=True, text=True, timeout=timeout) + lines = result.stdout.strip().splitlines() + reply = json.loads(lines[-1]) if lines else {'error': result.stderr.strip()} + print(f' {" ".join(map(str, words))[:80]} -> {json.dumps(reply)[:200]}') + if ok and (result.returncode or 'error' in reply): + raise Failed(f'{" ".join(map(str, words))}: {reply}') + return reply + + def labels(self): + return [w.get('label') for w in self('ui').get('widgets', [])] + + def wait_widget(self, widget, timeout=60): + return self('wait-for', 'widget', widget, '--timeout', timeout, ok=False) + + def quit(self): + try: + self('quit', ok=False, timeout=60) + except subprocess.TimeoutExpired: + pass + if self.pid: + for _ in range(40): + try: + os.kill(self.pid, 0) + except OSError: + return + time.sleep(0.5) + os.kill(self.pid, 9) + + +def statuses(capture, conn): + """The resource pack statuses the client sent on one connection: (id, action), in order.""" + out = [] + for e in net_capture.load(capture): + if e.get('conn') == conn and e.get('dir') == 'c2s' and e.get('name') == 'resource_pack': + data = bytes.fromhex(e['data']) + out.append((data[:16].hex(), ACTIONS[data[16]])) + return out + + +def connections(capture): + return max([e['conn'] for e in net_capture.load(capture) if 'conn' in e], default=0) + + +class Run: + def __init__(self, args, out): + self.args, self.out = args, out + lock, jars, libraries = base.verify_artifacts() + deps = os.pathsep.join(map(str, [jars['server'], *libraries])) + self.vanilla = ['java', '-Xmx2g', '-cp', deps, 'net.minecraft.server.Main', 'nogui'] + self.resources = lab.LOCAL / 'horizon-client' / lab.VERSION + self.files = {} + self.http = Files(self.files) + self.sha1 = build_pack(out / 'test-pack.zip') + self.files['/test-pack.zip'] = (out / 'test-pack.zip').read_bytes() + self.files['/optional-pack.zip'] = self.files['/test-pack.zip'] + dead = free_port() # nothing listens there + self.packs = { + 'required': {'resource-pack': self.http.url('/test-pack.zip'), 'resource-pack-sha1': self.sha1, + 'require-resource-pack': 'true', 'resource-pack-id': '5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a', + 'resource-pack-prompt': '["Blue dirt for ",{"text":"this test","color":"aqua"}]'}, + 'bad-sha1': {'resource-pack': self.http.url('/test-pack.zip'), 'resource-pack-sha1': '0' * 40, + 'require-resource-pack': 'true'}, + 'optional': {'resource-pack': self.http.url('/optional-pack.zip'), 'require-resource-pack': 'false'}, + 'dead-url': {'resource-pack': f'http://127.0.0.1:{dead}/gone.zip', 'require-resource-pack': 'false'}, + } + self.results = [] + + def start_server(self, kind, work): + directory = work / f'server-{kind}' + directory.mkdir() + port = free_port() + props = dict(PROPERTIES, **self.packs[kind], **{'server-port': str(port)}) + (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), + encoding='iso-8859-1') + (directory / 'eula.txt').write_text('eula=true\n') + if self.args.horizon_server: + command = [self.args.horizon_server, '--resources', self.resources, '--dedicated', '--nogui'] + else: + command = self.vanilla + server = Server(command, directory, f'server-{kind}') + server.wait_for(r'Done \(', timeout=300) + return server, port + + def join(self, game, address, scenario): + """Connects; returns the capture's connection number.""" + game('connect', address, PLAYER) + deadline = time.time() + 30 + while connections(self.capture) <= self.conn and time.time() < deadline: + time.sleep(0.2) + self.conn = connections(self.capture) + print(f' [{scenario}] connection {self.conn}') + return self.conn + + def scenario(self, name, fn): + print(f'- {name}') + try: + fn() + self.results.append((name, 'pass', '')) + except Exception as e: # noqa: BLE001: report every scenario + print(f' FAILED: {e}') + self.results.append((name, 'FAIL', str(e)[:300])) + if self.game('state', ok=False).get('screen') not in (None, 'title'): + self.leave(self.game) + + def wait_statuses(self, conn, want, timeout=60): + deadline = time.time() + timeout + while time.time() < deadline: + got = [a for _, a in statuses(self.capture, conn)] + if len(got) >= len(want) and got[:len(want)] == want or got[:1] and got != want[:len(got)]: + break + time.sleep(0.3) + time.sleep(1.5) # nothing more comes after the last one + got = [a for _, a in statuses(self.capture, conn)] + check(got == want, f'statuses {got} == {want}') + + def leave(self, game): + game('disconnect', ok=False) + time.sleep(1) + + def run(self): + work = Path(tempfile.mkdtemp(prefix='hz-server-packs-')) + print(f'scratch: {work}') + # The servers too get scratch homes (the game sets its own below). + for var, sub in (('HORIZON_HOME', 'home'), ('HORIZON_LAUNCHER_HOME', 'launcher'), ('XDG_DATA_HOME', 'data'), + ('XDG_CONFIG_HOME', 'config')): + (work / 'servers' / sub).mkdir(parents=True) + os.environ[var] = str(work / 'servers' / sub) + os.environ.update(lab.game_env(HORIZON_TELEMETRY_URL='off')) + game = self.game = Game(Path(self.args.bin), self.resources, work / 'game') + servers_dat = game.home / 'servers.dat' + downloads = game.home / 'downloads' + try: + for kind, scenarios in self.plan(game, servers_dat, downloads): + server, port = self.start_server(kind, work) + # One capture per server: its connections are numbered from 1. + self.capture, self.conn = self.out / f'capture-{kind}.jsonl', 0 + self.capture.touch() + listen = free_port() + stop = net_capture.start_background(listen, f'127.0.0.1:{port}', self.capture) + self.address = f'127.0.0.1:{listen}' + try: + self.server = server + for name, fn in scenarios: + self.scenario(f'{kind}: {name}', fn) + finally: + stop.set() + server.stop() + shutil.copy(server.log_path, self.out / server.log_path.name) + finally: + game.quit() + if game.log.exists(): + shutil.copy(game.log, self.out / 'client.log') + if downloads.exists(): + shutil.copytree(downloads, self.out / 'downloads') + return work + + def plan(self, game, servers_dat, downloads): + sha1 = self.sha1 + + def required_disconnect(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'decline') + check(game.wait_widget('disconnect').get('ok'), 'the required prompt opened') + labels = game.labels() + check('Proceed' in labels and 'Disconnect' in labels, f'Proceed and Disconnect buttons: {labels}') + game('screenshot', self.out / 'prompt-required.png') + game('click', 'disconnect') + self.wait_statuses(conn, []) + screen = json.dumps(game('screen')) + check(REQUIRED_REASON in screen, 'the disconnected screen says "This server requires a custom resource pack"') + check(read_setting(servers_dat) is None, 'the setting stays Prompt') + check(not any(p == '/test-pack.zip' for p, _ in self.http.requests), 'nothing was downloaded') + + def required_proceed(): + conn = self.join(game, self.address, 'proceed') + check(game.wait_widget('proceed').get('ok'), 'the required prompt opened') + game('click', 'proceed') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(read_setting(servers_dat) is True, 'the setting became Enabled (acceptTextures 1)') + pack_id = self.packs['required']['resource-pack-id'] + check((downloads / pack_id / sha1).exists(), f'downloads/{pack_id}/{sha1} is cached') + log = json.loads((downloads / 'log.json').read_text().splitlines()[-1]) + check(log.get('id') == pack_id and log.get('hash') == sha1 + and log.get('file', {}).get('name') == f'{pack_id}/{sha1}', f'log.json entry {log}') + path, headers = [r for r in self.http.requests if r[0] == '/test-pack.zip'][-1] + want = {'X-Minecraft-Username': PLAYER, 'X-Minecraft-Version': lab.VERSION, + 'X-Minecraft-Version-ID': lab.VERSION, 'X-Minecraft-Pack-Format': '97.1', + 'User-Agent': f'Minecraft Java/{lab.VERSION}'} + check(all(headers.get(k) == v for k, v in want.items()) and len(headers.get('X-Minecraft-UUID', '')) == 32, + f'download headers {headers}') + self.server.console(f'execute at {PLAYER} run fill ~-6 ~-1 ~-6 ~6 ~-1 ~6 minecraft:dirt') + game('look', 0, 90) + game('wait', 40) + shot = self.out / 'applied-blue-dirt.png' + game('screenshot', shot) + share = blue_share(shot) + check(share > 0.5, f'the ground is the pack\'s blue dirt ({share:.0%} of the samples)') + game('key', 'esc', 'tap') + game('wait', 5) + labels = game.labels() + check('Back to Game (server pack)' in labels, f'the pause menu uses the pack\'s lang: {labels}') + game('key', 'esc', 'tap') + self.leave(game) + labels = game.labels() + check('Join Server' in labels and 'Join Server (server pack)' not in labels, + f'after leaving, the pack is gone: {labels}') + + def required_enabled(): + before = len(self.http.requests) + conn = self.join(game, self.address, 'enabled') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(len(self.http.requests) == before, 'no second download: the cached file is used') + game('key', 'esc', 'tap') + game('wait', 5) + check('Back to Game (server pack)' in game.labels(), 'the pack is applied without a prompt') + game('key', 'esc', 'tap') + self.leave(game) + + def bad_sha1(): + write_servers(servers_dat, self.address, True) + conn = self.join(game, self.address, 'bad-sha1') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, FAILED) + entries = [json.loads(line) for line in (downloads / 'log.json').read_text().splitlines()] + failed = [e for e in entries if e.get('hash') == '0' * 40] + check(failed and failed[-1].get('error') == 'download_failed' and 'file' not in failed[-1], + f'log.json records the failure: {failed[-1:]}') + self.leave(game) + + def optional_no(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'optional-no') + check(game.wait_widget('no').get('ok'), 'the optional prompt opened') + labels = game.labels() + check('Yes' in labels and 'No' in labels, f'Yes and No buttons: {labels}') + game('screenshot', self.out / 'prompt-optional.png') + game('click', 'no') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, ['declined']) + check(read_setting(servers_dat) is False, 'the setting became Disabled (acceptTextures 0)') + self.leave(game) + + def optional_disabled(): + conn = self.join(game, self.address, 'optional-disabled') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, ['declined']) + self.leave(game) + + def optional_yes(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'optional-yes') + check(game.wait_widget('yes').get('ok'), 'the optional prompt opened') + game('click', 'yes') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(any(r[0] == '/optional-pack.zip' for r in self.http.requests), 'downloaded without a hash') + self.leave(game) + + def dead_url(): + write_servers(servers_dat, self.address, True) + conn = self.join(game, self.address, 'dead-url') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, FAILED) + self.leave(game) + + return [ + ('required', [('Disconnect at the prompt', required_disconnect), ('Proceed', required_proceed), + ('Enabled, cached', required_enabled)]), + ('bad-sha1', [('wrong SHA-1', bad_sha1)]), + ('optional', [('No at the prompt', optional_no), ('Disabled', optional_disabled), + ('Yes at the prompt, no hash', optional_yes)]), + ('dead-url', [('dead URL', dead_url)]), + ] + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--bin', default=str(lab.cargo_target() / 'fast'), help='horizon-client and horizon-ctl') + parser.add_argument('--horizon-server', help='a horizon-client binary to run as the dedicated server') + parser.add_argument('--out', default=str(lab.LOCAL / 'server-pack-e2e')) + args = parser.parse_args() + out = Path(args.out) / ('horizon' if args.horizon_server else 'vanilla') + shutil.rmtree(out, ignore_errors=True) + out.mkdir(parents=True) + run = Run(args, out) + work = run.run() + print(f'\nserver: {"horizon" if args.horizon_server else "vanilla 26.3"}; evidence in {out}') + for name, result, detail in run.results: + print(f' {result:4} {name}' + (f': {detail}' if detail else '')) + shutil.rmtree(work, ignore_errors=True) + if any(r != 'pass' for _, r, _ in run.results): + sys.exit(1) + + +if __name__ == '__main__': + main() diff --git a/tools/test_block_removal_parity.py b/tools/test_block_removal_parity.py index 6ebbbf1d3..3185bd4bb 100755 --- a/tools/test_block_removal_parity.py +++ b/tools/test_block_removal_parity.py @@ -183,7 +183,7 @@ def main(): d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared. ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py index 9d57d3f69..877bd0b38 100644 --- a/tools/test_command_exec_parity.py +++ b/tools/test_command_exec_parity.py @@ -82,7 +82,7 @@ def main(): rust_dir = build / 'rust' shutil.rmtree(rust_dir, ignore_errors=True) rust_dir.mkdir() - env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_COMMAND_SCRIPT=str(script_path), HORIZON_COMMAND_OUTPUT=str(build / 'rust.jsonl')) + env = lab.game_env(HORIZON_COMMAND_SCRIPT=script_path, HORIZON_COMMAND_OUTPUT=build / 'rust.jsonl') run([binary, '--resources', lab.RESOURCES, '--world', 'harness', '--seed', SEED, '--radius', 4], 'rust', cwd=rust_dir, env=env) vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').open(encoding='utf-8')] diff --git a/tools/test_composter_parity.py b/tools/test_composter_parity.py index e632527ce..074b227a8 100644 --- a/tools/test_composter_parity.py +++ b/tools/test_composter_parity.py @@ -125,7 +125,7 @@ def main(): d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) rust = h.split_cases((work / 'rust.txt').read_text(), ignore) diff --git a/tools/test_crafter_parity.py b/tools/test_crafter_parity.py index 1b9564f41..b9c343d4d 100644 --- a/tools/test_crafter_parity.py +++ b/tools/test_crafter_parity.py @@ -245,7 +245,7 @@ def main(): d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) rust = h.split_cases((work / 'rust.txt').read_text(), ignore) diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index f45df9822..6a6d258d4 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -126,7 +126,7 @@ class Server: self.lines = [] self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, - encoding='utf-8', errors='replace') + encoding='utf-8', errors='replace', env=lab.game_env()) self.reader = threading.Thread(target=self._read, daemon=True) self.reader.start() @@ -352,7 +352,7 @@ def horizon_client_joins(vanilla_server, binary, world, build, reference): server = Server(vanilla_server, directory, label) try: server.wait_for(r'Done \(') - env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_NET_REPORT=str(report)) + 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, '--server', f'127.0.0.1:{port}', '--name', PLAYER]], diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py index 844322aeb..a6d1f429a 100644 --- a/tools/test_dispenser_parity.py +++ b/tools/test_dispenser_parity.py @@ -417,7 +417,7 @@ def main(): run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared. ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) diff --git a/tools/test_friends.py b/tools/test_friends.py index 8fa1a4fee..cc5d15b92 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -96,7 +96,7 @@ 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=dict(os.environ, HORIZON_HOME=str(self.home), HORIZON_NO_AUDIO='1', **env), + ] + Game.extra, cwd=self.home, env=lab.game_env(HORIZON_HOME=self.home, **env), stdout=self.log, stderr=subprocess.STDOUT) wait_for(self.endpoint, 'screen', lambda v: v['screen'] == 'title', 120, f'{name} title') diff --git a/tools/test_mace_parity.py b/tools/test_mace_parity.py index 123f19693..578e9e6ee 100644 --- a/tools/test_mace_parity.py +++ b/tools/test_mace_parity.py @@ -170,7 +170,7 @@ def main(): d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) rust = h.split_cases((work / 'rust.txt').read_text(), ignore) diff --git a/tools/test_native_client.py b/tools/test_native_client.py index 73e6f3223..552ea8c42 100644 --- a/tools/test_native_client.py +++ b/tools/test_native_client.py @@ -71,7 +71,7 @@ def main(): str(executable), '--radius', '1', '--frames', '30', '--smoke-report', str(report), '--timeout-seconds', '60'] with (root / 'startup-smoke.log').open('w') as log: - subprocess.run(command, cwd=lab.ROOT, env=environment, check=True, + subprocess.run(command, cwd=lab.ROOT, env=lab.game_env(environment), check=True, stdout=log, stderr=subprocess.STDOUT, timeout=120) result = json.loads(report.read_text()) if (result.get('error') is not None or result.get('presented_frames') != 30 diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py index d430c2a68..d03838bf3 100644 --- a/tools/test_online_mode_parity.py +++ b/tools/test_online_mode_parity.py @@ -179,7 +179,7 @@ def run_client(binary, build, port, label, token, discovery): shutil.rmtree(directory, ignore_errors=True) directory.mkdir() report = directory / 'report.json' - env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_NET_REPORT=str(report), HORIZON_API_DISCOVERY=discovery) + env = lab.game_env(HORIZON_NET_REPORT=report, HORIZON_API_DISCOVERY=discovery) command = [binary, '--resources', lab.RESOURCES, '--render-distance', 2, '--server', f'127.0.0.1:{port}', '--name', PLAYER] if token: @@ -246,7 +246,7 @@ def run_side(label, command, binary, build, services, discovery): props = dict(PROPERTIES, **{'server-port': str(port)}) (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items())) (directory / 'eula.txt').write_text('eula=true\n') - os.environ.update(HORIZON_NO_AUDIO='1', HORIZON_API_DISCOVERY=discovery) + os.environ.update(lab.game_env(HORIZON_API_DISCOVERY=discovery)) server = Server(command, directory, f'{label}-online') checks = [] starts = [] diff --git a/tools/test_save_roundtrip_parity.py b/tools/test_save_roundtrip_parity.py index bd8b07a29..732429881 100644 --- a/tools/test_save_roundtrip_parity.py +++ b/tools/test_save_roundtrip_parity.py @@ -330,7 +330,7 @@ def entity_uuid_text(i): def vscreen_env(): text = subprocess.run(['vscreen', 'env'], capture_output=True, text=True, check=True).stdout - env = dict(os.environ) + env = lab.game_env() env.pop('DISPLAY', None) for match in re.finditer(r'(\w+)=(\S+)', text.split('unset')[0]): env[match.group(1)] = match.group(2) @@ -346,7 +346,7 @@ def horizon_resave(source, destination, bin_dir): ctl = [str(bin_dir / 'horizon-ctl'), '--socket', str(socket)] extra = [] if sys.platform == 'darwin': - env = dict(os.environ, HORIZON_NO_AUDIO='1') + env = lab.game_env() extra = ['--offscreen'] else: alsa = destination / 'null-asound.conf' diff --git a/tools/test_sculk_parity.py b/tools/test_sculk_parity.py index b9c7417a5..ae2c1c6aa 100644 --- a/tools/test_sculk_parity.py +++ b/tools/test_sculk_parity.py @@ -339,7 +339,7 @@ def main(): oracle_harness.run_logged(['cargo', 'build', '--locked', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build, 'compile-rust') oracle_harness.run_logged([lab.cargo_target() / 'release/horizon-client', '--resources', resources], build, 'horizon', - env={**os.environ, 'HORIZON_SCULK_FIXTURE': f'{inputs},{build / "horizon.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_SCULK_FIXTURE=f'{inputs},{build / "horizon.txt"}')) if args.java_only: return names = {s[0] for _, s in chosen} diff --git a/tools/test_secure_chat_parity.py b/tools/test_secure_chat_parity.py index c6c76a892..b9062568a 100644 --- a/tools/test_secure_chat_parity.py +++ b/tools/test_secure_chat_parity.py @@ -264,7 +264,7 @@ def main(): oh.run_logged([*java, 'keys', build], build, 'keys') services = Services(json.loads((build / 'publickeys.json').read_text())) discovery = services.url + '/minecraft/client' - os.environ.update(HORIZON_NO_AUDIO='1', HORIZON_API_DISCOVERY=discovery) + os.environ.update(lab.game_env(HORIZON_API_DISCOVERY=discovery)) servers = { 'vanilla': ['java', '-Xmx2g', '-Duser.timezone=UTC', f'-Dminecraft.api.discovery.host={discovery}', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui'], diff --git a/tools/test_use_item_on_parity.py b/tools/test_use_item_on_parity.py index d6e5f899f..89b463116 100644 --- a/tools/test_use_item_on_parity.py +++ b/tools/test_use_item_on_parity.py @@ -375,7 +375,7 @@ def main(): d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')}) d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work, - env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'}) + env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}')) ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',) native = h.split_cases((work / 'native.txt').read_text(), ignore) rust = h.split_cases((work / 'rust.txt').read_text(), ignore) diff --git a/tools/test_world_reopen_parity.py b/tools/test_world_reopen_parity.py index 381927013..4ef9a5e87 100644 --- a/tools/test_world_reopen_parity.py +++ b/tools/test_world_reopen_parity.py @@ -24,6 +24,9 @@ import sys import tempfile from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import lab # noqa: E402 + ROOT = Path(__file__).resolve().parent.parent RESOURCES = ROOT / '.local' / 'horizon-client' / '26.3' RUN = ROOT / '.local' / 'world-reopen' @@ -32,7 +35,7 @@ CYCLES = 3 def game_env(): """macOS renders offscreen; Linux uses the virtual screen (as test_save_roundtrip_parity).""" - env = dict(os.environ, HORIZON_NO_AUDIO='1') + env = lab.game_env() if sys.platform == 'darwin': return env, ['--offscreen'] subprocess.run(['vscreen', 'up'], check=False, capture_output=True) diff --git a/tools/test_world_spawn_parity.py b/tools/test_world_spawn_parity.py index 5daa38a45..00c390005 100644 --- a/tools/test_world_spawn_parity.py +++ b/tools/test_world_spawn_parity.py @@ -140,7 +140,7 @@ def main(): # One worker thread: the chunks decorated in a fixed order (see above). vanilla_server = ['java', '-Xmx2g', '-Dmax.bg.threads=1', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui'] horizon_server = [binary, '--resources', RESOURCES, '--dedicated', '--nogui'] - os.environ['HORIZON_NO_AUDIO'] = '1' + os.environ.update(lab.game_env()) def one(seed): t0 = time.time() diff --git a/website/build.mjs b/website/build.mjs index 781e838bb..f871d5dbb 100644 --- a/website/build.mjs +++ b/website/build.mjs @@ -231,7 +231,7 @@ const siteFooter = `
diff --git a/website/docs/apis.md b/website/docs/apis.md new file mode 100644 index 000000000..f948b1d54 --- /dev/null +++ b/website/docs/apis.md @@ -0,0 +1,34 @@ +# Horizon's APIs + +Horizon is built to be built on. Mods, shaders, agents, server panels, launchers' scripts and tools all get a documented API with a version, a stability level and a reference generated from the code, so it never says something the game doesn't do. + +## What you can build on + +| Surface | For | Today | Stability | +| --- | --- | --- | --- | +| **Mods** | mod authors | Rust compiled to sandboxed WebAssembly: read the player and the clock, chat, a HUD panel, storage, commands, tick and frame hooks; data-driven blocks and items. Lua scripts, run in the same sandbox, are planned | preview | +| **Shaders** | shader authors | a new shader API in WGSL is being designed: stages with typed inputs, options, reload on save, a debug overlay | planned | +| **Agent control** | AI agents, scripts, tests | `horizon-ctl` and its MCP server: 96 commands to watch and play the game | preview | +| **Servers** | hosts, panels, bots | `horizon-server`'s commands, `server.toml` and a local HTTP control API | stable | +| **Launcher** | your agent, pack makers | `horizon-launcher`'s 46 commands and its MCP server | preview | +| **Data formats** | tools that read Horizon's files | benchmark reports, telemetry, settings, release checksums; worlds are vanilla's format | per format | + +The full pages, one per surface, are in the repository: [docs/api](https://github.com/ludovic111/horizon/tree/main/docs/api). Mods for players: [Mods](/docs/mods). Agents: [Control Horizon with your AI agent](/docs/agents). Hosting: [Host a server](/docs/hosting). + +## What the levels mean + +- **Stable**: only additions within a major version. A change that would break you comes as a new major, served beside the old one for at least 180 days. +- **Preview**: documented and tested. It may change at a new line (0.1 to 0.2), after a deprecation of at least 30 days during which old and new both work. +- **Experimental**: opt-in only, and it may change in any release. + +Every API has its own version (the mod API is `horizon:mods@0.1.0`, the server's control API is `/api/v1`), separate from the game's release number. The whole policy: [stability and versioning](https://github.com/ludovic111/horizon/blob/main/docs/api/stability.md). + +## How they are designed + +Each API starts from what its users need to do, and from how Horizon is built: Rust, wgpu, WebAssembly and a server thread that runs every world. Horizon's APIs are its own: they are not modelled on another mod loader's, renderer's or server platform's. Vanilla Minecraft 26.3 is the reference for game concepts such as ids, commands and data packs. + +They are safe by default (mods run in a sandbox with the permissions you allow; control sockets only listen on your computer, behind a token) and cost nothing when unused. + +## References that can't drift + +Each reference is written by code from the source it describes, and a test fails when the two differ: the mod API from its WIT contract, `horizon-ctl` and the launcher from their command tables, the server from its settings template and route table. A change to an API changes its reference in the same pull request. diff --git a/website/docs/how-horizon-is-built.md b/website/docs/how-horizon-is-built.md new file mode 100644 index 000000000..af9f956ba --- /dev/null +++ b/website/docs/how-horizon-is-built.md @@ -0,0 +1,39 @@ +# How Horizon is built + +Who writes Horizon, how changes are checked, and why it is safe to run. You can check every claim on this page in the repository, and anything not done yet is marked as not done. + +## Who builds it + +Horizon is Ludovic Marie's project: he decides what it does and what ships. **Most of the code is written by AI agents**: Claude sessions that Ludovic runs, and contributors' own AI tools. Some contributors write their code by hand. + +Agents say what they are. A pull request opened by one of Ludovic's agents starts with "Opened by Ludovic's AI agent (Claude), not by Ludovic himself.", its comments start with "🤖 Agent:", and its commits name the agent in a `Co-Authored-By` line. + +## How changes are checked + +Not every line is read by a person. Instead, every change is checked against the real game, automatically: + +- **Harnesses.** A harness is a test that gives the same inputs to Horizon and to the real Minecraft 26.3, then compares the results. There are 326 of them (25 October 2026), from world generation to mobs, redstone and commands. The [status table](/#parity) shows what they cover. Passing them all does not prove that nothing else differs. +- **Checks on every pull request.** `verify` runs on GitHub's machines for every pull request and every change to main: formatting, lints with warnings treated as errors, the tests, and the check that no Minecraft files are committed. Main takes no change without it. `parity` runs the harnesses a change can affect, on a machine that holds a copy of Minecraft. For a pull request from a fork, it runs once a maintainer has read the change. +- **Outside contributions are checked again.** Before a contributor's pull request merges, Ludovic's agents compare what it claims with vanilla's own code, review it line by line, rewrite the weak parts, and test it in single player, on a LAN and on a dedicated server where those apply. +- **Releases are tested first.** A release is published only after its smoke test passes (the game starts and draws a world) and while no issue is labelled `release-blocker`. + +## Why it's safe to run + +- **Open source.** All of the code is public on [GitHub](https://github.com/ludovic111/horizon), under the MIT licence. +- **Built from the public code.** Releases are built by GitHub Actions, the build service of GitHub, from the public source. Linux and Windows are built on GitHub's machines, and macOS on Ludovic's Mac mini, which runs GitHub Actions jobs. Every build log is [public](https://github.com/ludovic111/horizon/actions/workflows/release.yml). +- **Signed checksums.** Every release has a `SHA256SUMS` file, a fingerprint of each download, and `SHA256SUMS.sig`, a signature of that list made with Horizon's release key, which only release builds from main can use. The launcher and `horizon-server update` check both before they install anything, and refuse a file that does not match. The very first server install with `install.sh` checks the fingerprint but not the signature. +- **Not yet signed by Apple or Microsoft.** The macOS app is not notarized by Apple, because it is not signed with a paid Apple developer account, so macOS asks you to confirm the first time ([Install](/docs/install#download-the-launcher) shows how). The Windows programs are not code-signed either, so Windows may warn you too. +- **Mods run in a sandbox.** Horizon mods are WebAssembly programs with no access to your files, the network or other programs. A mod lists what it needs, you see that list before you turn it on, and it can do nothing else. See [Mods and data packs](/docs/mods). +- **Nothing collected unless you say yes.** Data collection is off until you turn it on, with four separate switches. The one exception is an anonymous "I'm playing" ping for the launcher's player count, which holds nothing about you. See [Privacy](/privacy). + +## What it doesn't contain + +- **No Minecraft files.** Horizon contains no Minecraft code, assets or data, and never downloads them. The launcher builds the game files on your computer from your own copy of Minecraft: Java Edition 26.3. A check that runs on every pull request (`tools/check_public_tree.py`) keeps game files and decompiled code out of the repository and its history. +- **No code from other mods.** Since 24 October 2026, Horizon's code may only be written from Minecraft 26.3 itself and public documentation, never from another mod, loader or renderer ([the rule](https://github.com/ludovic111/horizon/blob/main/CONTRIBUTING.md#only-original-code)). That day shader packs were removed ([#1561](https://github.com/ludovic111/horizon/pull/1561)), after a developer of Iris showed that our shader pack code had been written from Iris's source. They are being written again from a description of the pack format only. + +## Check it yourself + +- **Read the code and its checks.** [The source](https://github.com/ludovic111/horizon), [the checks on every pull request](https://github.com/ludovic111/horizon/actions/workflows/ci.yml) and [the release builds](https://github.com/ludovic111/horizon/actions/workflows/release.yml). +- **Compare the fingerprints.** Put a release's files and its `SHA256SUMS` in one folder and run `sha256sum -c SHA256SUMS --ignore-missing` (on macOS `shasum -a 256 -c SHA256SUMS --ignore-missing`, on Windows `Get-FileHash ` in PowerShell). Each file should say `OK`. +- **Check the signature.** Download a whole release into a folder, then from a clone of the repository run `cargo run -p horizon-release-sign -- verify --tag `. The public key is in `crates/horizon-release-sign/release-keys.txt`. +- **Build it yourself.** The README explains how to [build from source](https://github.com/ludovic111/horizon#build-from-source). diff --git a/website/docs/mods.md b/website/docs/mods.md index dff618f70..0c125cf73 100644 --- a/website/docs/mods.md +++ b/website/docs/mods.md @@ -30,7 +30,7 @@ cd my-mod cargo horizon-mod run ``` -`run` builds the mod and starts the game with it. After an edit, `cargo horizon-mod build` rebuilds it and the running game reloads it. The full guide, with the API, the manifest and the roadmap, is [docs/mods.md](https://github.com/ludovic111/horizon/blob/main/docs/mods.md). What carries over from Java mods, and why jars cannot run, is in [the Java mod notes](https://github.com/ludovic111/horizon/blob/main/docs/research/java-mod-compat.md). +`run` builds the mod and starts the game with it. After an edit, `cargo horizon-mod build` rebuilds it and the running game reloads it. The full guide, with the API, the manifest and the roadmap, is [docs/mods.md](https://github.com/ludovic111/horizon/blob/main/docs/mods.md). 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](https://github.com/ludovic111/horizon/blob/main/docs/modpacks.md)). ## Finding resource packs and modpacks diff --git a/website/docs/nav.json b/website/docs/nav.json index e44fddb26..3bc2ec8d2 100644 --- a/website/docs/nav.json +++ b/website/docs/nav.json @@ -1,7 +1,8 @@ [ - { "group": "Start here", "pages": ["index", "install"] }, + { "group": "Start here", "pages": ["index", "install", "how-horizon-is-built"] }, { "group": "Playing", "pages": ["settings", "multiplayer", "troubleshooting"] }, { "group": "Hosting", "pages": ["hosting"] }, { "group": "Going further", "pages": ["modpacks", "mods", "performance", "agents"] }, + { "group": "Build on Horizon", "pages": ["apis"] }, { "group": "Project", "pages": ["contributing", "faq"] } ] diff --git a/website/src/index.html b/website/src/index.html index 5f9bba03e..a457d7ee3 100644 --- a/website/src/index.html +++ b/website/src/index.html @@ -218,6 +218,7 @@ DiscordQuestions, bug reports and screenshots. SponsorSponsors on GitHub fund the next release. SourceIssues and pull requests are welcome. + How it's builtWho writes it, how changes are checked, why it's safe to run.

Contributors

@@ -238,7 +239,7 @@
diff --git a/website/src/releases.js b/website/src/releases.js index de59c8fef..d4932e7f7 100644 --- a/website/src/releases.js +++ b/website/src/releases.js @@ -50,8 +50,12 @@ export function sections(body) { // An item without its pull request references: "Riptide (#123, fixes #45)" -> "Riptide". export const plainItem = (item) => item.replace(/\s*\((?:#\d+|fixes #\d+|[^()]*#\d+[^()]*)\)\s*/g, " ").replace(/\s+/g, " ").trim(); +// A game release's notes open with an HTML block sending people to the launcher (PLAYERS in tools/release_train.py): +// GitHub's latest release is the game's. This site has its own download button, so it leaves the block out. +export const notesText = (body) => (body || "").replace(/^

Want to play\?[^\n]*(?:\r?\n)*/, ""); + // The notes' first sentence, for a release with no title line and no sections ("Rebuilt from the latest main."). -const firstLine = (body) => ((body || "").split(/\r?\n/).find((l) => l.trim() && !/^#/.test(l)) || "").trim().replace(/[.:]$/, ""); +const firstLine = (body) => (notesText(body).split(/\r?\n/).find((l) => l.trim() && !/^#/.test(l)) || "").trim().replace(/[.:]$/, ""); const count = (n, one, many) => `${n} ${n === 1 ? one : many}`; @@ -135,7 +139,7 @@ function releaseHtml(r, open) { ${o.text ? `

${escape(o.text)}

` : ""} ${top.length ? `
    ${top.map((t) => `
  • ${inline(t)}
  • `).join("")}
` : ""}

` : ""} -
${markdown(r.body || "") || "

No notes for this release.

"}
+
${markdown(notesText(r.body)) || "

No notes for this release.

"}
${downloads ? `

Downloads

    ${downloads}
` : ""}

This release on GitHub

diff --git a/website/src/releases.test.mjs b/website/src/releases.test.mjs new file mode 100644 index 000000000..acd1a0965 --- /dev/null +++ b/website/src/releases.test.mjs @@ -0,0 +1,13 @@ +// node --test src/: the release notes as the site shows them. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { notesText } from "./releases.js"; + +const players = '

Want to play? Download the Horizon launcher, not the files below

It installs this version.

'; + +test("the block sending people to the launcher is left out, the notes stay", () => { + assert.equal(notesText(`${players}\n\n### Fixed\n- A fix (#1)\n`), "### Fixed\n- A fix (#1)\n"); + assert.equal(notesText(`${players}\r\n\r\nRebuilt from the latest main.\r\n`), "Rebuilt from the latest main.\r\n"); + assert.equal(notesText("

Other HTML

\n\n### New\n- A thing (#2)\n"), "

Other HTML

\n\n### New\n- A thing (#2)\n"); + assert.equal(notesText(undefined), ""); +});