diff --git a/.githooks/pre-push b/.githooks/pre-push index a886ccf0c..d067dd226 100755 --- a/.githooks/pre-push +++ b/.githooks/pre-push @@ -1,2 +1,2 @@ #!/bin/sh -exec python3 tools/check_public_tree.py --history +exec python3 tools/check_public_tree.py --pre-push 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/AGENTS.md b/AGENTS.md index f6f6b463b..0656e40fc 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -45,6 +45,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se | `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) | | `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) | | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) | +| `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu | | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website | | `horizon-telemetry`, `horizon-telemetry-server`, `horizon-bench` | Opt-in data collection, its ingest server, the benchmark report format | | `horizon-dualsense`, `horizon-threads`, `horizon-release-sign`, `horizon-bots`, `xtask` | DualSense output, thread priorities, signed release checksums, load-test bots, repo tasks | diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index af44d89f8..e6e959186 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -39,6 +39,17 @@ 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). +The pre-push hook checks the full history reachable from the branches and tags being pushed. Run +`python3 tools/check_public_tree.py --history` to audit the history of all local refs. + +## 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 diff --git a/Cargo.lock b/Cargo.lock index 57006aa82..54be02330 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1315,7 +1315,7 @@ dependencies = [ "serde", "serde_json", "sha2", - "socket2", + "socket2 0.5.10", "spake2", ] @@ -1380,6 +1380,7 @@ dependencies = [ "getrandom 0.3.4", "horizon-core", "horizon-world", + "ipconfig", "serde_json", "sha1", "sha2", @@ -1433,6 +1434,13 @@ dependencies = [ "ureq", ] +[[package]] +name = "horizon-shaders" +version = "0.1.0" +dependencies = [ + "zip", +] + [[package]] name = "horizon-telemetry" version = "0.1.0" @@ -1656,6 +1664,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" @@ -3146,6 +3167,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" @@ -4302,6 +4333,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" @@ -4434,6 +4471,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/Cargo.toml b/Cargo.toml index 6271b9673..c6f2bc581 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"] -members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "xtask"] +members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "xtask"] resolver = "2" [workspace.package] diff --git a/crates/horizon-client/examples/probe/main.rs b/crates/horizon-client/examples/probe/main.rs index d110ea790..f05c2a662 100644 --- a/crates/horizon-client/examples/probe/main.rs +++ b/crates/horizon-client/examples/probe/main.rs @@ -85,6 +85,7 @@ mod sprint_probe; mod subtitle_fixture; mod tab_list_fixture; mod team_rules_fixture; +mod text_display_fixture; mod toggle_keys_probe; mod tooltip_display_fixture; mod trading_fixture; @@ -170,6 +171,7 @@ probes! { team_rules_fixture, toggle_keys_probe, tooltip_display_fixture, + text_display_fixture, trading_fixture, translucency_fixture, weather_fixture, diff --git a/crates/horizon-client/examples/probe/recipe_book_fixture.rs b/crates/horizon-client/examples/probe/recipe_book_fixture.rs index 7117d4bbe..ce2afe624 100644 --- a/crates/horizon-client/examples/probe/recipe_book_fixture.rs +++ b/crates/horizon-client/examples/probe/recipe_book_fixture.rs @@ -83,7 +83,7 @@ pub fn main() -> horizon_client::Result<()> { let mut extra = String::new(); match kind { "give" => count = book.add_recipes(&index, &list()).0, - "take" => count = book.remove_recipes(&index, &list()), + "take" => count = book.remove_recipes(&index, &list()).len(), "seen" => book.remove_highlight(op["id"].as_str().unwrap_or_default()), "set" => { let i = match op["type"].as_str().unwrap_or_default() { diff --git a/crates/horizon-client/examples/probe/text_display_fixture.rs b/crates/horizon-client/examples/probe/text_display_fixture.rs new file mode 100644 index 000000000..f1f587625 --- /dev/null +++ b/crates/horizon-client/examples/probe/text_display_fixture.rs @@ -0,0 +1,37 @@ +use horizon_client::text_display::TextDisplayData; +use horizon_protocol::{ids, packets::play::Clientbound}; +use std::{error::Error, io::Write}; + +pub fn main() -> Result<(), Box> { + let args: Vec = crate::args().collect(); + let mut out = std::fs::File::create(&args[2])?; + for line in std::fs::read_to_string(&args[1])?.lines() { + let input: serde_json::Value = serde_json::from_str(line)?; + let hex = input["wire"].as_str().unwrap(); + let bytes: Vec = (0..hex.len()) + .step_by(2) + .map(|i| u8::from_str_radix(&hex[i..i + 2], 16)) + .collect::>()?; + let Clientbound::SetEntityData(packet) = + Clientbound::decode(ids::play::clientbound::SET_ENTITY_DATA, &bytes)? + else { + unreachable!() + }; + let mut display = TextDisplayData::default(); + display.apply(&packet.values); + if let Some(angles) = input["angles"].as_array() { + let a: Vec<_> = angles.iter().map(|v| v.as_f64().unwrap() as f32).collect(); + writeln!( + out, + "{}", + serde_json::to_string(&display.matrix([a[0], a[1]], [a[2], a[3]]).to_cols_array())? + )?; + continue; + } + let mut state = serde_json::to_value(&display)?; + state["text"] = display.text.plain().into(); + state["alignment"] = format!("{:?}", display.align()).to_uppercase().into(); + writeln!(out, "{}", state)?; + } + Ok(()) +} diff --git a/crates/horizon-client/src/audio.rs b/crates/horizon-client/src/audio.rs index e59ffd867..be6628ece 100644 --- a/crates/horizon-client/src/audio.rs +++ b/crates/horizon-client/src/audio.rs @@ -161,6 +161,9 @@ pub struct Audio { /// How many times each positional sound played (the control socket's `status`), /// with or without an audio device. pub heard: std::collections::BTreeMap, + /// How many times each selection was stopped ("record *", "* minecraft:…", `*` for + /// any), with or without an audio device, as `heard`. + pub stopped: std::collections::BTreeMap, } fn decode(path: &Path) -> Option<(Vec, u32)> { use symphonia::core::{ @@ -595,6 +598,7 @@ impl Audio { source_override: None, capture: None, heard: Default::default(), + stopped: Default::default(), } } #[cfg(not(feature = "audio"))] @@ -825,6 +829,14 @@ impl Audio { /// and/or a source. pub fn stop_sounds(&mut self, event: Option<&str>, source: Option) { let event = event.map(crate::sound_events::normalize); + let selection = format!( + "{} {}", + source + .and_then(|s| crate::settings::SOUND_SOURCES.get(s)) + .map_or("*", |s| s), + event.as_deref().unwrap_or("*") + ); + *self.stopped.entry(selection).or_default() += 1; self.engine .stop_matching(event.as_deref(), source, &mut self.backend); } 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/game.rs b/crates/horizon-client/src/game.rs index c46b86032..2bc5512b7 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; @@ -153,6 +154,7 @@ mod storage; mod structures; mod subtitle_hud; mod sulfur_cubes; +mod text_displays; mod titles; mod tnt; mod totem; @@ -1421,6 +1423,8 @@ struct Game<'a> { dragon_model: Option, /// Map textures waiting for the next HUD batch to upload them. map_patches: Vec, + text_displays: std::collections::HashMap, + text_display_vertices: usize, /// Player skin downloads, and which skin each atlas skin slot holds /// (least recently shown first). skin_downloads: RefCell, @@ -4045,6 +4049,20 @@ impl Game<'_> { self.capture_loaded_world(); Ok(()) } + /// Landing rules (farmland trampling, turtle eggs) wrote or removed the block + /// raw: finish `Level.setBlock`'s neighbour updates, so a crop on trampled + /// farmland breaks. The local player's and every server player's landings. + fn landing_block_updates(&mut self, event: &horizon_client::landing::FallEvent) { + use horizon_client::landing::FallEvent; + let (position, flags) = match *event { + FallEvent::Write { + position, flags, .. + } => (position, flags as i32), + FallEvent::Destroy { position, .. } => (position, level_flags::UPDATE_ALL), + _ => return, + }; + self.with_level(|b, level, ticks| b.notify_written(level, ticks, position, flags)); + } fn tick(&mut self) -> Result<()> { self.tick_debug_keys()?; self.tick_debug_charts(); @@ -4259,23 +4277,7 @@ impl Game<'_> { }; self.audio.play(name, Some(feet), volume, pitch); } - MotionEvent::Fall(horizon_client::landing::FallEvent::Write { - position, - flags, - .. - }) => { - // Landing rules (farmland trampling, turtle eggs) wrote the block raw. - self.with_level(|b, level, ticks| { - b.notify_written(level, ticks, position, flags as i32) - }); - } - MotionEvent::Fall(horizon_client::landing::FallEvent::Destroy { - position, .. - }) => { - self.with_level(|b, level, ticks| { - b.notify_written(level, ticks, position, level_flags::UPDATE_ALL) - }); - } + MotionEvent::Fall(event) => self.landing_block_updates(&event), MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity), MotionEvent::EnterBlock { state } => self.trigger_enter_block(state), MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos), @@ -4413,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()); @@ -6771,6 +6773,7 @@ impl Game<'_> { let mut see_through = std::mem::take(&mut self.see_through_vertices); see_through.clear(); self.name_tag_geometry(camera, alpha, &mut out, &mut see_through); + self.text_display_geometry(camera, alpha, &mut out, &mut see_through); self.see_through_vertices = see_through; // Entity shadows (EntityRenderer.extractShadow). if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() { @@ -11883,6 +11886,8 @@ impl<'a> Game<'a> { breath_clouds: Vec::new(), dragon_model: prepared.dragon_model, map_patches: Vec::new(), + text_displays: Default::default(), + text_display_vertices: 0, skin_downloads: RefCell::new(horizon_client::skins::Downloader::new( std::env::current_dir() .unwrap_or_default() diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index b0f948c5d..0f76d0ca9 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -881,30 +881,40 @@ pub(super) fn adv_name(a: &adv::Advancement) -> Text { let Some(d) = &a.display else { return Text::literal(a.id.clone()); }; - let color = match d.frame { - Frame::Challenge => text::DARK_PURPLE, - _ => text::GREEN, - }; - // Advancement.decorateName: the title in the frame's colour (styles - // merged into it), a new line and the description. - let coloured = text_of(&d.title).with_color(color); - let mut component = coloured.component(); - if let Some(o) = component.as_object_mut() { - o.insert( - "extra".into(), - serde_json::json!(["\n", text_of(&d.description).component()]), - ); - } - let tooltip = coloured - .append("\n") - .append(text_of(&d.description)) - .with_component(component); + let color = frame_color(d.frame); let title = text_of(&d.title).with_style(&Style { - hover: Some(Box::new(tooltip)), + hover: Some(Box::new(decorate_name(d))), ..Style::default() }); Text::translate("chat.square_brackets", &[title]).with_color(color) } +fn frame_color(frame: Frame) -> u32 { + match frame { + Frame::Challenge => text::DARK_PURPLE, + _ => text::GREEN, + } +} +/// `Advancement.decorateName`: a copy of the title with the frame's colour +/// under its own style (mergeStyles), then a new line and the description +/// after the title's own siblings, so both inherit the title's root style. +/// Built on the title's JSON (a list as its first element with the rest as +/// siblings): a parsed Text moves a styled root's style down a level once it +/// has siblings. +fn decorate_name(d: &adv::Display) -> Text { + let mut component = match horizon_client::scoreboard::canonical_component(&d.title) { + Value::String(s) => serde_json::json!({ "text": s }), + c => c, + }; + if let Some(o) = component.as_object_mut() { + let frame = Text::empty().with_color(frame_color(d.frame)).component(); + o.entry("color").or_insert_with(|| frame["color"].clone()); + let extra = o.entry("extra").or_insert_with(|| serde_json::json!([])); + if let Some(extra) = extra.as_array_mut() { + extra.extend(["\n".into(), d.description.clone()]); + } + } + text_of(&component).with_component(component) +} impl Game<'_> { /// `AdvancementCommands.Action.GRANT` on one advancement (or one of /// its criteria): false when nothing changed. @@ -1051,17 +1061,10 @@ impl Game<'_> { } } } -/// A text component from advancement JSON (`translate` or `text`). +/// An advancement's title or description: a whole component (ComponentSerialization.CODEC), +/// with its siblings and styles, as a plugin's `{"text":"","extra":[...]}` needs. pub(super) fn text_of(v: &Value) -> Text { - if let Some(key) = v["translate"].as_str() { - Text::translate(key, &[]) - } else if let Some(s) = v["text"].as_str() { - Text::literal(s) - } else if let Some(s) = v.as_str() { - Text::literal(s) - } else { - Text::empty() - } + horizon_client::scoreboard::comp_text(v) } #[cfg(test)] @@ -1095,6 +1098,105 @@ mod tests { (seen, None) } + #[test] + fn titles_keep_their_siblings_and_styles() { + let title = text_of(&serde_json::json!({ + "text": "", + "extra": [{"text": "Quest ", "color": "gold"}, "Board"], + })); + assert_eq!(title.plain(), "Quest Board"); + assert_eq!(title.spans[0].style.color, Some(text::GOLD)); + assert_eq!(title.spans[1].style.color, None); + let vanilla = text_of(&serde_json::json!({"translate": "advancements.story.root.title"})); + assert_eq!( + vanilla, + Text::translate("advancements.story.root.title", &[]) + ); + assert_eq!( + vanilla.translation_key(), + Some("advancements.story.root.title") + ); + } + + fn announced(title: Value, description: Value) -> adv::Advancement { + adv::Advancement { + id: "quests:board".into(), + parent: None, + display: Some(adv::Display { + icon: "minecraft:book".into(), + title, + description, + frame: Frame::Task, + background: None, + show_toast: true, + announce: true, + hidden: false, + }), + criteria: Vec::new(), + requirements: Vec::new(), + rewards: adv::Rewards::default(), + } + } + /// The chat hover: the JSON a client receives, and the spans drawn here. + fn hover(a: &adv::Advancement) -> (Value, Text) { + let local = decorate_name(a.display.as_ref().unwrap()); + let sent = adv_name(a).component()["with"][0]["hover_event"]["value"].clone(); + (sent, local) + } + + #[test] + fn chat_hover_keeps_the_titles_siblings_before_the_description() { + let a = announced( + serde_json::json!({"text": "", "extra": [{"text": "Quest ", "color": "gold"}, "Board"]}), + serde_json::json!("Open the board"), + ); + let (sent, local) = hover(&a); + let sent = horizon_client::scoreboard::comp_text(&sent); + assert_eq!(sent.plain(), "Quest Board\nOpen the board"); + let colors = |t: &Text| t.spans.iter().map(|s| s.style.color).collect::>(); + let (gold, green) = (Some(text::GOLD), Some(text::GREEN)); + assert_eq!(colors(&sent), [gold, green, green, green]); + // The spans drawn here come from the same JSON a client receives. + assert_eq!(colors(&local), colors(&sent)); + } + + #[test] + fn chat_hover_description_takes_a_styled_titles_own_style() { + // mergeStyles keeps the title's gold; the description inherits it. + let object = announced( + serde_json::json!({"text": "Quest", "color": "gold", "bold": true, "extra": [" Board"]}), + serde_json::json!("Open the board"), + ); + let list = announced( + serde_json::json!([{"text": "Quest", "color": "gold", "bold": true}, " Board"]), + serde_json::json!("Open the board"), + ); + for a in [object, list] { + let (sent, local) = hover(&a); + let sent = horizon_client::scoreboard::comp_text(&sent); + assert_eq!(sent.plain(), "Quest Board\nOpen the board"); + let last = &sent.spans.last().unwrap().style; + assert_eq!((last.color, last.bold), (Some(text::GOLD), Some(true))); + assert_eq!(local.spans.last().unwrap().style, *last); + } + } + + #[test] + fn chat_hover_of_a_vanilla_advancement() { + let a = announced( + serde_json::json!({"translate": "advancements.story.root.title"}), + serde_json::json!({"translate": "advancements.story.root.description"}), + ); + assert_eq!( + hover(&a).0, + serde_json::json!({ + "translate": "advancements.story.root.title", + "color": "green", + "extra": ["\n", {"translate": "advancements.story.root.description"}], + }) + ); + } + #[test] fn toasts_slide_in_squared_and_out_after_five_seconds() { let mut toast = recipes(1); 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/commands.rs b/crates/horizon-client/src/game/commands.rs index a229cbdc9..2e551f440 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1082,6 +1082,8 @@ impl Game<'_> { self.for_player(t, |g| g.teleport_to(Target::Player, pos, rotation)); } Target::Player => { + // ServerPlayer.teleport: removeVehicle before placing the player. + self.stop_riding(); if let Some(p) = self.player.as_mut() { p.position = v; p.velocity = Vec3::new(0.0, 0.0, 0.0); diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs index 1f7504d8a..2f3792a57 100644 --- a/crates/horizon-client/src/game/commands/world_cmds.rs +++ b/crates/horizon-client/src/game/commands/world_cmds.rs @@ -59,7 +59,15 @@ impl Game<'_> { self.recipe_unlocked(&unlocked); count as i32 } else { - self.level.recipe_book.remove_recipes(index, &recipes) as i32 + let removed = self.level.recipe_book.remove_recipes(index, &recipes); + let count = removed.len() as i32; + // A network player's client drops them from its book. + if self.lan_acting.is_some() && !removed.is_empty() { + self.guest_packets.push(C::RecipeBookRemove( + horizon_protocol::packets::recipes::RecipeBookRemove { ids: removed }, + )); + } + count }; tracker.track(&h, n); } @@ -345,7 +353,26 @@ impl Game<'_> { Some(Arg::Resource(s)) => Some(s.clone()), _ => None, }; - self.audio.stop_sounds(sound.as_deref(), source); + // StopSoundCommand: each target's connection gets the packet; the + // window's own player stops its sounds. + let packet = C::StopSound(play::StopSound { + source: source.map(|s| s as i32), + sound: sound.clone(), + }); + for &t in &targets { + match t { + Target::Player if self.lan_acting.is_some() => { + self.guest_packets.push(packet.clone()); + } + Target::Player => self.audio.stop_sounds(sound.as_deref(), source), + Target::Guest(conn) => { + if let Some(host) = self.lan.as_ref() { + host.hub.send_to(conn, &packet); + } + } + _ => {} + } + } let key = match (source, &sound) { (Some(_), Some(_)) => "commands.stopsound.success.source.sound", (Some(_), None) => "commands.stopsound.success.source.any", diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 205a66074..3c80a0f32 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -226,6 +226,16 @@ impl Game<'_> { } Ok(Some(json!({ "ok": true, "cull": r.section_cull() }))) } + "section-sides" => { + let r = self.renderer.as_mut().ok_or("no renderer")?; + match words.get(1).copied() { + None => {} + Some("on") => r.set_section_sides(true), + Some("off") => r.set_section_sides(false), + Some(other) => return Err(format!("unknown section sides mode {other}").into()), + } + Ok(Some(json!({ "ok": true, "sides": r.section_sides() }))) + } "sculk" => Ok(Some(self.sculk_command(&words)?)), "status" => Ok(Some(self.control_status())), "pad" => Ok(Some(self.pad_command(&words)?)), @@ -981,6 +991,7 @@ impl Game<'_> { status["destroying"] = json!(destroying); status["physical_keys"] = json!(physical_keys); status["heard"] = json!(self.audio.heard); + status["stopped_sounds"] = json!(self.audio.stopped); // Boats, minecarts, armor stands, item frames and paintings. status["objects"] = json!(self.objects_status()); status["lightning"] = json!({"bolts": self.bolts.len(), "struck": self.lightning_seen[0], diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index ec9848919..0bb7bbe85 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -978,7 +978,9 @@ impl Game<'_> { m.ai.target = Some(target); } } - MobEvent::Projectile(p) => { + MobEvent::Projectile(mut p) => { + self.next_entity += 1; + p.id = self.next_entity; let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]); self.creatures.projectiles.push(p); self.projectile_event("minecraft:projectile_shoot", owner, at); 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..d0f16a0d6 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; @@ -1926,7 +1939,7 @@ impl Game<'_> { let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height()); let at = g.position; let sneaking = g.sneaking; - let sounds = self.as_guest(host, conn, |game| { + let events = self.as_guest(host, conn, |game| { let (rules, motion) = (game.world.health_rules, game.motion); let health = &motion.health; let Some(player) = game.player.as_mut() else { @@ -2023,20 +2036,17 @@ impl Game<'_> { // A hurt since the last tick marked the velocity (Entity.markHurt): // ServerEntity.sendChanges sends it as it is after this travel. let marked = std::mem::take(&mut player.health.sync_velocity); - let sounds = events - .into_iter() - .filter_map(|e| match e { - MotionEvent::HurtSound(sound) => Some(sound), - _ => None, - }) - .collect::>(); - (sounds, marked.then_some(player.velocity)) + (events, marked.then_some(player.velocity)) }); - let Some((sounds, marked)) = sounds else { + let Some((events, marked)) = events else { return; }; - for sound in sounds { - self.player_hurt_sound(sound, at); + for event in events { + match event { + MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at), + MotionEvent::Fall(event) => self.landing_block_updates(&event), + _ => {} + } } if let (Some(v), Some(g)) = (marked, host.hub.guest(conn)) { g.send(&C::SetEntityMotion(play::SetEntityMotion { diff --git a/crates/horizon-client/src/game/lan_trading.rs b/crates/horizon-client/src/game/lan_trading.rs index 83aafecc2..1bec9809d 100644 --- a/crates/horizon-client/src/game/lan_trading.rs +++ b/crates/horizon-client/src/game/lan_trading.rs @@ -48,10 +48,9 @@ impl Game<'_> { if let Some(id) = state.mob && state.session.villager { - // startTrading with the guest's reputation (their effects are - // not modelled on the host: no Hero of the Village). + // startTrading with the guest's reputation. The session already + // captured their Hero effect while they acted as the player. state.session.reputation = self.villager_reputation_of(id, uuid); - state.session.hero = None; state.session.update_special_prices(); } let title = self.merchant_display_name(&state); 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/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 32cffa306..2f59acabc 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. @@ -411,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, @@ -607,6 +612,21 @@ impl Game<'_> { continue; }; let value = match c { + // Read past, not decoded: the item keeps its prototype's value. + Component::Raw(_) => continue, + // Trim materials and patterns are synced registries, as enchantments are. + Component::Trim { material, pattern } => { + let (Some(material), Some(pattern)) = ( + r.registries.name("minecraft:trim_material", *material), + r.registries.name("minecraft:trim_pattern", *pattern), + ) else { + continue; + }; + Tag::compound([ + ("material", Tag::String(material.into())), + ("pattern", Tag::String(pattern.into())), + ]) + } Component::Int(v) if *kind == component::RARITY => { let rarity = ["common", "uncommon", "rare", "epic"]; Tag::String(rarity.get(*v as usize).copied().unwrap_or("common").into()) @@ -1382,7 +1402,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, @@ -1461,6 +1481,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)); @@ -1472,11 +1509,9 @@ 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.move_remote_text_display(id, position, rotation); self.turn_remote_projectile(id, rotation); } fn remove_entity(&mut self, id: i32) { @@ -1582,6 +1617,12 @@ impl Game<'_> { } } } + /// Find a game slot in the menu's complete, contiguous slot mapping. + fn menu_slot_index(menu: &str, internal: usize) -> Option { + (0..) + .map_while(|slot| Self::menu_slot(menu, slot)) + .position(|slot| slot == internal) + } /// The workstation screen of a menu type a server opens. pub(super) fn remote_station_kind(menu: &str) -> Option { use super::stations::Kind; @@ -1786,6 +1827,9 @@ impl Game<'_> { self.audio.play(&name, Some(at), p.volume, p.pitch); } } + C::StopSound(p) => self + .audio + .stop_sounds(p.sound.as_deref(), p.source.map(|s| s as usize)), C::AddEntity(p) => { let kind = self .remote @@ -1807,6 +1851,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, @@ -1817,6 +1863,7 @@ impl Game<'_> { p.data, ); } + self.move_remote_text_display(p.id, p.position, Some((rotation[0], rotation[1]))); } C::RemoveEntities(p) => { for id in p.ids { @@ -2125,17 +2172,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; } } @@ -2201,9 +2260,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() { @@ -2933,7 +2997,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 { @@ -2944,7 +3010,7 @@ impl Game<'_> { stack, position: at, previous: at, - velocity: Vec3::ZERO, + velocity, on_ground: false, age: 0, pickup_delay: 0, @@ -2952,6 +3018,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; @@ -3007,6 +3090,8 @@ impl Game<'_> { } None => { let mut player = PlayerMotion::new(self.motion, position)?; + // Player.tick derives noPhysics from the current game mode. + player.spectator = self.spectator(); player.velocity = delta; self.player = Some(player); self.pad.player_replaced(); @@ -3149,6 +3234,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(()); }; @@ -3176,6 +3264,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, @@ -3219,7 +3308,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). @@ -3259,9 +3348,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; @@ -3320,11 +3410,54 @@ 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) { + if running { + self.tick_text_displays(); + } + // 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; }; @@ -3427,20 +3560,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 { @@ -4139,11 +4264,13 @@ impl Game<'_> { return; }; let stack = self.stack_in(slot).cloned(); + // Another hotbar slot picked: LivingEntity.updatingUsingItem sees a + // different stack in the hand. The off hand keeps its item. + let in_hand = slot == self.selected || slot == super::shield::OFFHAND_SLOT; // A drawn bow, a charging crossbow, a raised shield...: held until - // the button lets go (or another slot is picked). + // the button lets go. if stack.as_ref().is_some_and(|s| self.held_until_released(s)) { - self.using = (slot == self.selected || slot == super::shield::OFFHAND_SLOT) - .then_some((slot, ticks + 1)); + self.using = in_hand.then_some((slot, ticks + 1)); return; } let consumable = stack @@ -4157,7 +4284,7 @@ impl Game<'_> { // Button release belongs to the next handleKeybinds phase, which // sends RELEASE_USE_ITEM. Do not silently clear a use begun by a // quick press/release between ticks. - if slot != self.selected { + if !in_hand { self.using = None; return; } @@ -4478,12 +4605,10 @@ impl Game<'_> { for &(slot, button, input) in ops { let slot = match slot { None => -999, - Some(internal) => { - match (0..64).find(|&s| Self::menu_slot(&menu, s) == Some(internal)) { - Some(s) => s as i16, - None => return false, - } - } + Some(internal) => match Self::menu_slot_index(&menu, internal) { + Some(s) => s as i16, + None => return false, + }, }; clicks.push((slot, button, input)); } @@ -4552,7 +4677,7 @@ impl Game<'_> { /// such slot. pub(super) fn remote_slot_click(&mut self, internal: usize, button: i8, input: i32) -> bool { let (container, menu) = self.remote_menu(); - let slot = (0..64).find(|&s| Self::menu_slot(&menu, s) == Some(internal)); + let slot = Self::menu_slot_index(&menu, internal); let Some(slot) = slot else { return false }; let carried = self.to_network(&self.carried).map(|s| Hashed::of(&s)); let state = self.remote.as_ref().map_or(0, |r| r.state_id); @@ -4987,6 +5112,8 @@ impl Game<'_> { .collect::>(), // The player's own model exists (third person and the inventory draw it). "player_model": self.player_model.is_some(), + "text_display_vertices": self.text_display_vertices, + "text_displays": self.text_displays.len(), "health": r.health.0, "food": r.health.1, "decode_errors": r.decode_errors, @@ -5411,4 +5538,28 @@ mod tests { } assert_eq!(Game::menu_slot("inventory", 46), None); } + + #[test] + fn remote_clicks_find_slots_past_the_old_large_chest_cutoff() { + for (menu, internal, index) in [ + ("minecraft:generic_9x6", 18, 63), + ("minecraft:generic_9x6", 19, 64), + ("minecraft:generic_9x6", 0, 81), + ("minecraft:generic_9x6", 8, 89), + ("minecraft:generic_9x6", 353, 53), + ("minecraft:generic_9x5", 8, 80), + ("minecraft:generic_9x4", 8, 71), + ("minecraft:generic_9x3", 8, 62), + ("inventory", 504, 45), + ] { + assert_eq!( + Game::menu_slot_index(menu, internal), + Some(index), + "{menu}, game slot {internal}" + ); + } + assert_eq!(Game::menu_slot_index("minecraft:generic_9x6", 354), None); + assert_eq!(Game::menu_slot_index("minecraft:generic_9x6", 504), None); + assert_eq!(Game::menu_slot_index("unknown", 0), None); + } } diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 4bba24946..251d277f3 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -24,7 +24,12 @@ impl Game<'_> { let at = Vec3::new(position[0], position[1], position[2]); let block = position.map(|v| v.floor() as i32); self.remove_remote_object(id); - if let Some(cart) = super::minecarts::CartKind::from_id(kind) { + if kind == "minecraft:text_display" { + self.text_displays.insert( + id as i32, + super::text_displays::RemoteTextDisplay::new(position, yaw), + ); + } else if let Some(cart) = super::minecarts::CartKind::from_id(kind) { let mut c = super::minecarts::Minecart::new(id, cart, at); c.yaw = yaw; c.previous_yaw = yaw; @@ -93,6 +98,10 @@ impl Game<'_> { /// `handleSetEntityData` for an object: what changes how it looks. pub(super) fn remote_object_data(&mut self, id: i32, values: &[(u8, i32, Value)]) { + if let Some(display) = self.text_displays.get_mut(&id) { + display.metadata(values); + return; + } let id = id as u32; for (index, _, value) in values { if self.item_frames.iter().any(|f| f.id == id) { @@ -273,6 +282,7 @@ impl Game<'_> { /// Every object a server sent (a new connection, level or dimension). pub(super) fn clear_remote_objects(&mut self) { + self.text_displays.clear(); self.carts.clear(); self.boats.clear(); self.armor_stands.clear(); @@ -281,6 +291,7 @@ impl Game<'_> { } pub(super) fn remove_remote_object(&mut self, id: u32) { + self.text_displays.remove(&(id as i32)); self.carts.retain(|c| c.id != id); self.boats.retain(|b| b.id != id); self.armor_stands.retain(|a| a.id != id); diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 58f82e3a9..bc6d0b13e 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; @@ -24,6 +24,14 @@ fn projectile_kind(kind: &str) -> Option { "minecraft:llama_spit" => ProjectileKind::LlamaSpit, "minecraft:wind_charge" => ProjectileKind::WindCharge, "minecraft:breeze_wind_charge" => ProjectileKind::BreezeWindCharge, + // Homing state stays on the server; the client interpolates its positions. + "minecraft:shulker_bullet" => ProjectileKind::ShulkerBullet { + target: horizon_client::mobs::Who::Player, + dir: None, + steps: 0, + delta: [0.0; 3], + seed: 0, + }, "minecraft:wither_skull" => ProjectileKind::WitherSkull { dangerous: false }, _ => return None, }) @@ -185,11 +193,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/render_control.rs b/crates/horizon-client/src/game/render_control.rs index 31a7a33a0..0a2f9b715 100644 --- a/crates/horizon-client/src/game/render_control.rs +++ b/crates/horizon-client/src/game/render_control.rs @@ -13,6 +13,7 @@ pub const HELP: &[&str] = &[ "signedit X Y Z [front|back] open the sign editor for the sign at X Y Z", "section-draws [flat|indirect] how terrain sections are drawn (A/B checks); replies the mode", "section-cull [on|off] occlusion culling of solid sections (A/B checks); replies the mode", + "section-sides [on|off] leave out solid quads facing away from the eye (A/B checks); replies the mode", ]; impl Game<'_> { diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs new file mode 100644 index 000000000..f6c946bcc --- /dev/null +++ b/crates/horizon-client/src/game/text_displays.rs @@ -0,0 +1,302 @@ +//! Server text displays: metadata, interpolation, billboard transforms and world text. +use super::Game; +use horizon_client::{ + hud::{HudBatch, rgba}, + mesher::Vertex, + text::Text, + text_display::{Align, TextDisplayData}, +}; +use horizon_protocol::entity_data::Value; + +pub(super) struct RemoteTextDisplay { + pub data: TextDisplayData, + from: TextDisplayData, + shown: TextDisplayData, + position: glam::DVec3, + previous: glam::DVec3, + target: glam::DVec3, + rotation: [f32; 2], + old_rotation: [f32; 2], + target_rotation: [f32; 2], + steps: i32, + age: i64, + start: i64, + duration: i32, + dirty: bool, + start_dirty: bool, + duration_dirty: bool, + initialized: bool, + /// `Display.lastProgress`: the progress the last frame drew, where a new + /// interpolation starts from. + last_progress: f32, + /// `TextDisplay.clientDisplayCache`: the split lines, until the render + /// state changes. + lines: Option, +} + +/// `TextDisplay.CachedInfo`: each line and its width, and the widest. +struct Lines { + lines: Vec<(Text, f32)>, + width: f32, +} + +/// `Display.RENDER_STATE_IDS` and `TextDisplay.TEXT_RENDER_STATE_IDS`: the +/// data a render state is built from (not the view range, size or glow). +fn renders(id: u8) -> bool { + matches!(id, 11..=16 | 18 | 19 | 23..=27) +} + +impl RemoteTextDisplay { + pub fn new(position: [f64; 3], yaw: f32) -> Self { + Self { + data: Default::default(), + from: Default::default(), + shown: Default::default(), + position: position.into(), + previous: position.into(), + target: position.into(), + rotation: [yaw, 0.0], + old_rotation: [yaw, 0.0], + target_rotation: [yaw, 0.0], + steps: 0, + age: 0, + start: 0, + duration: 0, + dirty: true, + start_dirty: false, + duration_dirty: false, + initialized: false, + last_progress: 0.0, + lines: None, + } + } + fn progress(&self, partial: f32) -> f32 { + if self.duration <= 0 { + 1.0 + } else { + (((self.age - self.start) as f32 + partial) / self.duration as f32).clamp(0.0, 1.0) + } + } + pub fn metadata(&mut self, values: &[(u8, i32, Value)]) { + self.start_dirty |= values.iter().any(|v| v.0 == 8); + self.duration_dirty |= values.iter().any(|v| v.0 == 9); + self.dirty |= values.iter().any(|v| renders(v.0)); + self.data.apply(values); + } + fn tick(&mut self) { + self.age += 1; + self.previous = self.position; + self.old_rotation = self.rotation; + if self.steps > 0 { + self.position += (self.target - self.position) / f64::from(self.steps); + for i in 0..2 { + self.rotation[i] += + angle(self.target_rotation[i] - self.rotation[i]) / self.steps as f32; + } + self.steps -= 1; + } + if self.start_dirty { + self.start = self.age + i64::from(self.data.interpolation_delay); + } + if self.duration_dirty { + self.duration = self.data.interpolation_duration; + } + if self.dirty { + self.from = if self.initialized && self.duration > 0 { + self.shown.blend(&self.from, self.last_progress) + } else { + self.data.clone() + }; + self.shown = self.data.clone(); + self.initialized = true; + self.lines = None; + } + self.dirty = false; + self.start_dirty = false; + self.duration_dirty = false; + } + fn move_to(&mut self, position: [f64; 3], rotation: Option<(f32, f32)>) { + self.target = position.into(); + if let Some((yaw, pitch)) = rotation { + self.target_rotation = [yaw, pitch]; + } + self.steps = self.data.teleport_duration.clamp(0, 59); + if self.steps == 0 { + self.position = self.target; + self.previous = self.target; + self.rotation = self.target_rotation; + self.old_rotation = self.rotation; + } + } +} +fn angle(d: f32) -> f32 { + (d + 180.0).rem_euclid(360.0) - 180.0 +} + +impl Game<'_> { + pub(super) fn move_remote_text_display( + &mut self, + id: i32, + position: [f64; 3], + rotation: Option<(f32, f32)>, + ) { + if let Some(d) = self.text_displays.get_mut(&id) { + d.move_to(position, rotation); + } + } + pub(super) fn tick_text_displays(&mut self) { + for display in self.text_displays.values_mut() { + display.tick(); + } + } + pub(super) fn text_display_geometry( + &mut self, + camera: glam::DVec3, + partial: f64, + normal: &mut Vec, + see_through: &mut Vec, + ) { + self.text_display_vertices = 0; + let atlas = &self.gui.atlas; + let front = self.camera_type == super::perspective::CameraType::ThirdPersonFront; + let angles = if front { + [self.yaw + 180.0, -self.pitch] + } else { + [self.yaw, self.pitch] + }; + for display in self.text_displays.values_mut() { + display.last_progress = display.progress(partial as f32); + let d = display.shown.blend(&display.from, display.last_progress); + let position = display.previous.lerp(display.position, partial); + let range = f64::from(d.view_range) * 64.0 * f64::from(self.settings.entity_distance); + if position.distance_squared(camera) >= range * range || d.text.is_empty() { + continue; + } + let rotation = std::array::from_fn(|i| { + display.old_rotation[i] + + angle(display.rotation[i] - display.old_rotation[i]) * partial as f32 + }); + let mut matrix = glam::Mat4::from_translation((position - camera).as_vec3()) + * d.matrix(rotation, angles) + * glam::Mat4::from_rotation_y(std::f32::consts::PI) + * glam::Mat4::from_scale(glam::Vec3::splat(-0.025)); + if !matrix.is_finite() { + continue; + } + // TextDisplayRenderer.splitLines: Font.split, no indent on wrapped lines. + let Lines { lines, width } = display.lines.get_or_insert_with(|| { + let lines: Vec<_> = atlas + .font + .split(&d.text, d.line_width as f32) + .into_iter() + .map(|line| { + let width = atlas.font.width_text(&line).ceil(); + (line, width) + }) + .collect(); + let width = lines.iter().map(|l| l.1).fold(0.0, f32::max); + Lines { lines, width } + }); + let width = *width; + let height = lines.len() as f32 * 10.0 - 1.0; + matrix *= + glam::Mat4::from_translation(glam::Vec3::new(1.0 - width / 2.0, -height, 0.0)); + let mut batch = HudBatch::new([1, 1]); + let bg = if d.flags & 4 != 0 { + self.settings.text_background(0.25) + } else { + d.background as u32 + }; + if bg != 0 { + batch.fill( + atlas, + -1.0, + -1.0, + width + 1.0, + height + 1.0, + rgba( + (bg >> 16) as u8, + (bg >> 8) as u8, + bg as u8, + (bg >> 24) as u8, + ), + ); + } + let align = d.align(); + for (i, (line, line_width)) in lines.iter().enumerate() { + let x = match align { + Align::Left => 0.0, + Align::Right => width - line_width, + Align::Center => (width - line_width) / 2.0, + }; + batch.text_styled( + atlas, + line, + x, + i as f32 * 10.0, + rgba(255, 255, 255, d.opacity as u8), + d.flags & 1 != 0, + ); + } + let world_light = self.world.light( + position.x.floor() as i32, + position.y.floor() as i32, + position.z.floor() as i32, + ); + let light = if d.brightness == -1 { + horizon_client::block_entity_render::vertex_light(world_light) + } else { + ((d.brightness as u32 >> 20 & 15) * 16) + | (((d.brightness as u32 >> 4 & 15) * 16) << 8) + }; + let through = d.flags & 2 != 0; + let out = if through { + &mut *see_through + } else { + &mut *normal + }; + for quad in batch.vertices.as_chunks::<6>().0 { + for i in [0, 1, 2, 5] { + let v = quad[i]; + let point = + matrix.transform_point3(glam::Vec3::new(v.pos[0], v.pos[1], v.depth)); + out.push(Vertex { + pos: point.to_array(), + uv: v.uv, + color: v.color, + light, + layer: if through { 2 } else { 0 }, + normal: [0; 4], + }); + } + } + self.text_display_vertices += batch.vertices.len() / 6 * 4; + self.map_patches.extend(batch.patches); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn metadata_and_position_interpolation_keep_their_separate_clocks() { + let mut d = RemoteTextDisplay::new([0.0; 3], 0.0); + d.tick(); + d.metadata(&[ + (8, 1, Value::Int(0)), + (9, 1, Value::Int(4)), + (10, 1, Value::Int(2)), + (11, 0, Value::Floats(vec![4.0, 0.0, 0.0])), + ]); + d.tick(); + assert_eq!(d.shown.blend(&d.from, d.progress(0.5)).translation[0], 0.5); + d.move_to([2.0, 0.0, 0.0], Some((90.0, 0.0))); + d.tick(); + assert_eq!(d.position.x, 1.0); + assert_eq!(d.rotation[0], 45.0); + d.tick(); + assert_eq!(d.position.x, 2.0); + assert_eq!(d.shown.blend(&d.from, d.progress(0.0)).translation[0], 2.0); + } +} diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index c369ee1c7..a848d36a5 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -6,7 +6,7 @@ use crate::{ environment::Sky, graphics::GraphicsApi, hud::{HudBatch, HudRenderer}, - mesher::{SectionMesh, TerrainVertex, Vertex}, + mesher::{SectionMesh, Sides, TerrainVertex, Vertex}, sprites::SpriteAnimation, }; use glam::{DVec3, Mat4, Vec3, Vec4}; @@ -156,9 +156,9 @@ struct SectionGpu { page: u32, start: u64, solid: u32, + /// Where the solid quads' buckets by facing side end (`mesher::Sides`). + sides: Sides, translucent: u32, - /// The solid quads by facing: back-facing groups are skipped. - faces: crate::mesher::FaceGroups, sort: translucency::SortState, sorted_indices: Option<(u32, u64)>, /// Its id for flat draws (`flat::Flat::add`), when they are on. @@ -325,6 +325,8 @@ pub struct Renderer { /// counts reach a multi-draw's entries (Vulkan, Metal). cull: Option, cull_on: bool, + /// Solid quads facing away from the eye are left out (`mesher::Sides`). + sides_on: bool, sky: wgpu::RenderPipeline, dark_disc: wgpu::RenderPipeline, lines: wgpu::RenderPipeline, @@ -2157,7 +2159,7 @@ impl Renderer { cull::Cull::new(&device, config.format.remove_srgb_suffix(), depth_test); cull.always = cull_env.as_deref() == Ok("all"); if !cull.always && adapter.get_info().backend == wgpu::Backend::Metal { - cull.min_draws = cull::TILED_MIN_DRAWS; + cull.min_sections = cull::TILED_MIN_SECTIONS; } cull }); @@ -2204,6 +2206,7 @@ impl Renderer { translucent, flat_on: flat.is_some(), cull_on: cull.is_some(), + sides_on: true, cull, flat, sky, @@ -2453,6 +2456,14 @@ impl Renderer { self.flat_on = on; Ok(()) } + /// Whether solid quads facing away from the eye are left out. + pub fn section_sides(&self) -> bool { + self.sides_on + } + /// Switches leaving out solid quads facing away, for A/B checks. + pub fn set_section_sides(&mut self, on: bool) { + self.sides_on = on; + } /// Whether solid sections are occlusion culled (`cull`). pub fn section_cull(&self) -> bool { self.cull_on @@ -2575,8 +2586,12 @@ impl Renderer { page, start, solid, + sides: if mesh.sides.quads() == solid { + mesh.sides + } else { + Sides::unsorted(solid) + }, translucent, - faces: mesh.faces, sort: translucency::SortState::new( mesh.translucent .as_chunks::<4>() @@ -3042,6 +3057,9 @@ impl Renderer { }; let camera = frame.camera; let camera_section = camera_section(camera); + // Solid quads facing away from the eye are left out: the bob moves + // the eye off `camera`, so it is found from the projection. + let eye = projection_center(view_proj).filter(|_| self.sides_on); let culling = !frame.title && frame.cave_culling; if culling { crate::spans::time("occlusion", || { @@ -3106,10 +3124,6 @@ impl Renderer { // as one list of indirect draws over the section arena. self.draws.clear(); self.draw_pages.clear(); - // The eye, camera-relative: view bobbing moves it off the camera. - let eye = (frame.bob * crate::camera::view_matrix(frame.yaw, frame.pitch)) - .inverse() - .transform_point3(Vec3::ZERO); // Occlusion culling leaves the sections its last result did not see // to phase 2, after the others, with instance counts of 0. Whether // the frame has draws enough goes by the last one's. @@ -3117,7 +3131,7 @@ impl Renderer { .cull .as_mut() .filter(|c| { - self.cull_on && !frame.title && self.multi_draw && self.section_draws >= c.min_draws + self.cull_on && !frame.title && self.multi_draw && visible.len() >= c.min_sections }) .and_then(|cull| cull.begin(&self.device).then_some(cull)); self.phase2_draws.clear(); @@ -3135,12 +3149,11 @@ impl Renderer { let start = draws.len(); let instances = u32::from(first_phase); let mut indices = 0; - // Only the solid groups that can face the eye. - s.faces.ranges(eye - Vec3::from(v.origin), |first, quads| { - let first = s.start + u64::from(first) * 4; - draws.push([quads * 6, instances, 0, first as u32, i as u32]); - pages.push((s.page, None)); + facing_runs(&s.sides, eye, v.origin, |first, quads| { indices += quads * 6; + let base = s.start as u32 + first * 4; + draws.push([quads * 6, instances, 0, base, i as u32]); + pages.push((s.page, None)); }); let runs = if first_phase { &mut self.solid_runs @@ -3178,10 +3191,10 @@ impl Renderer { for (i, v) in visible_lods.iter().enumerate() { let s = &self.lods[&v.key].mesh; let start = self.draws.len(); - s.faces.ranges(eye - Vec3::from(v.origin), |first, quads| { - let first = s.start + u64::from(first) * 4; - self.draws - .push([quads * 6, 1, 0, first as u32, (visible.len() + i) as u32]); + let instance = (visible.len() + i) as u32; + facing_runs(&s.sides, eye, v.origin, |first, quads| { + let base = s.start as u32 + first * 4; + self.draws.push([quads * 6, 1, 0, base, instance]); self.draw_pages.push((s.page, None)); }); self.solid_runs @@ -3520,7 +3533,9 @@ impl Renderer { } let flat_frame = match &mut self.flat { Some(flat) - if self.flat_on && !self.draws.is_empty() && self.draws.len() >= flat.min_draws => + if self.flat_on + && !self.draws.is_empty() + && self.drawn_sections >= flat.min_sections => { let sections = &self.sections; let lods = &self.lods; @@ -4202,6 +4217,34 @@ fn world_projection(fov_degrees: f32, aspect: f32, far: f32) -> Mat4 { Mat4::perspective_rh(fov_degrees.to_radians(), aspect, far, 0.05) } +/// Where a perspective `view_proj` sees from, in its own (camera-relative) +/// space: the point whose clip x, y and w are all 0. `None` for a +/// projection without one (orthographic). +fn projection_center(view_proj: Mat4) -> Option { + let m = view_proj.as_dmat4(); + let rows = [m.row(0), m.row(1), m.row(3)]; + let a = glam::DMat3::from_cols( + DVec3::new(rows[0].x, rows[1].x, rows[2].x), + DVec3::new(rows[0].y, rows[1].y, rows[2].y), + DVec3::new(rows[0].z, rows[1].z, rows[2].z), + ); + let det = a.determinant(); + if !det.is_normal() { + return None; + } + let b = DVec3::new(rows[0].w, rows[1].w, rows[2].w); + Some((a.inverse() * -b).as_vec3()) +} +/// Calls `draw(first, quads)` for each run of a mesh's solid quads that can +/// face `eye` (`projection_center`), the mesh at the camera-relative +/// `origin`; all of them when there is no eye. +fn facing_runs(sides: &Sides, eye: Option, origin: [f32; 3], mut draw: impl FnMut(u32, u32)) { + match eye { + Some(eye) => sides.visible((eye - Vec3::from(origin)).to_array(), draw), + None if sides.quads() > 0 => draw(0, sides.quads()), + None => {} + } +} fn frustum(m: Mat4) -> [Vec4; 6] { let r = |i| m.row(i); let planes = [ @@ -4429,6 +4472,25 @@ mod tests { assert_eq!(super::outline_width(3840), 5.0); } #[test] + fn the_projection_center_follows_the_view_bob() { + use glam::{Mat4, Vec3}; + let projection = super::world_projection(70.0, 16.0 / 9.0, 512.0); + let view = crate::camera::view_matrix(30.0, 20.0); + let eye = super::projection_center(projection * view).unwrap(); + assert!(eye.length() < 1e-5, "{eye}"); + // A pose translated by the bob: the eye is where the pose's inverse + // takes the view's origin. + let bob = Mat4::from_rotation_z(0.02) * Mat4::from_translation(Vec3::new(0.03, -0.08, 0.0)); + let expected = (bob * view).inverse().transform_point3(Vec3::ZERO); + let eye = super::projection_center(projection * bob * view).unwrap(); + assert!(eye.distance(expected) < 1e-5, "{eye} {expected}"); + assert!(expected.length() > 0.05); + assert!( + super::projection_center(Mat4::orthographic_rh(-1.0, 1.0, -1.0, 1.0, 0.0, 1.0)) + .is_none() + ); + } + #[test] fn indirect_draws_are_validated_only_in_debug_builds_and_on_directx_12() { let validated = |backends| { super::instance_descriptor(backends) diff --git a/crates/horizon-client/src/gfx/cull.rs b/crates/horizon-client/src/gfx/cull.rs index 856bd86dd..449401b96 100644 --- a/crates/horizon-client/src/gfx/cull.rs +++ b/crates/horizon-client/src/gfx/cull.rs @@ -46,13 +46,15 @@ const RETEST: u32 = 8; /// more than they save. Else one frame in `PROBE` tests every section. const MIN_SHARE: f32 = 0.1; const PROBE: u32 = 64; -/// On Metal, section draws from which a frame culls. Apple's GPUs store and -/// reload the whole frame at each of the passes the test adds, a fixed cost -/// that the sections it hides repay only at high render distances: on an M4 -/// Pro at 1080p and render distance 12 (1,000–1,600 draws) culling added -/// about 0.05 ms of GPU time while hiding 15–30% of the solid indices; at -/// 32 (drawn flat, over this many draws) it saved 0.25–1.6 ms. -pub const TILED_MIN_DRAWS: usize = 4096; +/// On Metal, sections in view from which a frame culls. Apple's GPUs store +/// and reload the whole frame at each of the passes the test adds, a fixed +/// cost that the sections it hides repay only at high render distances: on +/// an M4 Pro at 1080p and render distance 12 (1,000–1,600 draws) culling +/// added about 0.05 ms of GPU time while hiding 15–30% of the solid +/// indices; at 32 (over 4,096 draws) it saved 0.25–1.6 ms. Those draws were +/// 2.2 to 2.5 per section; a section's draw count now depends on the sides +/// it shows the eye (`mesher::Sides`), so the bar counts sections. +pub const TILED_MIN_SECTIONS: usize = 1600; /// Boxes over more than this share of the screen count as seen untested. const BIG: f32 = 0.25; /// Results read back at once, some frames late so the CPU never waits. @@ -148,8 +150,8 @@ pub struct Cull { pub hidden: ([usize; 2], f32), /// Cull every frame, whatever the hidden share (A/B checks). pub always: bool, - /// Frames with fewer section draws than this do not cull. - pub min_draws: usize, + /// Frames with fewer sections in view than this do not cull. + pub min_sections: usize, } fn buffer( @@ -348,7 +350,7 @@ impl Cull { stamp: 0, hidden: ([0; 2], 1.0), always: false, - min_draws: 0, + min_sections: 0, } } diff --git a/crates/horizon-client/src/gfx/flat.rs b/crates/horizon-client/src/gfx/flat.rs index f6823c5d8..ea6df0d5b 100644 --- a/crates/horizon-client/src/gfx/flat.rs +++ b/crates/horizon-client/src/gfx/flat.rs @@ -96,17 +96,19 @@ pub struct Flat { pub calls: Vec, pub phase1_calls: usize, pub solid_calls: usize, - /// Frames with fewer section draws keep the per-section draws. - pub min_draws: usize, + /// Frames with fewer sections in view keep the per-section draws. + pub min_sections: usize, range_align: u64, } -/// Section draws from which a frame is drawn flat. Below it the index list -/// costs the GPU more than the draw calls cost the CPU: on an M4 Pro at -/// render distance 16 (2,900 draws) the copy and the list add about 0.4 ms -/// of GPU time for 0.5–0.8 ms less CPU time; at 32 (9,300 draws) the CPU -/// saves 1.3 ms. -const MIN_DRAWS: usize = 4096; +/// Sections in view (and distant tiles) from which a frame is drawn flat. +/// Below it the index list costs the GPU more than the draw calls cost the +/// CPU: on an M4 Pro at render distance 16 (2,900 draws) the copy and the +/// list add about 0.4 ms of GPU time for 0.5–0.8 ms less CPU time; at 32 +/// (9,300 draws) the CPU saves 1.3 ms. The bar was 4,096 draws when they +/// were 2.2 to 2.5 per section; a section's draw count now depends on the +/// sides it shows the eye (`mesher::Sides`), so it counts sections. +const MIN_SECTIONS: usize = 1600; /// Whether flat draws apply: the backend emulates multi-draw, and vertex /// shaders can read storage buffers large enough for an index page. @@ -337,10 +339,10 @@ impl Flat { calls: Vec::new(), phase1_calls: 0, solid_calls: 0, - min_draws: if std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1") { + min_sections: if std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1") { 0 } else { - MIN_DRAWS + MIN_SECTIONS }, range_align: (u64::from(device.limits().min_storage_buffer_offset_alignment) / 16) .max(1), 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/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/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 256f3a5cf..440b58284 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -432,18 +432,21 @@ impl Guest { } /// The off hand slot is conventionally 40 in saves and 45 in the menu. +/// `synced_id` names an entry of a synced registry (enchantments, trim +/// materials and patterns) by its id on this connection. pub fn stack_to_network( item_id: impl Fn(&str) -> i32, - enchantment_id: impl Fn(&str) -> Option, + synced_id: impl Fn(&str, &str) -> Option, s: &Option, ) -> Option { - network_stack(&item_id, &enchantment_id, s) + network_stack(&item_id, &synced_id, s) } fn network_stack( item_id: &dyn Fn(&str) -> i32, - enchantment_id: &dyn Fn(&str) -> Option, + synced_id: &dyn Fn(&str, &str) -> Option, s: &Option, ) -> Option { + let enchantment_id = |name: &str| synced_id("minecraft:enchantment", name); let s = s.as_ref()?; let mut stack = Stack::new(item_id(&s.item), s.count as i32); if s.damage > 0 { @@ -481,6 +484,25 @@ fn network_stack( horizon_protocol::item::Component::Int(rgb), )); } + // ArmorTrim: both holders as references into the synced registries. + if let Some((material, pattern)) = &d.trim { + let id = |registry: &str, name: &str| { + if name.contains(':') { + synced_id(registry, name) + } else { + synced_id(registry, &format!("minecraft:{name}")) + } + }; + if let (Some(material), Some(pattern)) = ( + id("minecraft:trim_material", material), + id("minecraft:trim_pattern", pattern), + ) { + stack.added.push(( + horizon_protocol::item::component::TRIM, + horizon_protocol::item::Component::Trim { material, pattern }, + )); + } + } if let Some(id) = d.map_id { stack.added.push(( horizon_protocol::item::component::MAP_ID, @@ -504,7 +526,7 @@ fn network_stack( let charged = d .charged .iter() - .filter_map(|c| network_stack(item_id, enchantment_id, &Some(c.clone()))) + .filter_map(|c| network_stack(item_id, synced_id, &Some(c.clone()))) .collect(); stack.added.push(( horizon_protocol::item::component::CHARGED_PROJECTILES, @@ -545,3 +567,32 @@ fn network_stack( } Some(stack) } + +#[cfg(test)] +mod tests { + use super::*; + use horizon_protocol::item::{Component, component}; + + #[test] + fn trims_go_as_synced_registry_references() { + let mut chestplate = ItemStack::new("minecraft:diamond_chestplate", 1); + chestplate.data_mut().trim = Some(("minecraft:gold".into(), "coast".into())); + let synced_id = |registry: &str, name: &str| match (registry, name) { + ("minecraft:trim_material", "minecraft:gold") => Some(4), + ("minecraft:trim_pattern", "minecraft:coast") => Some(1), + _ => None, + }; + let stack = stack_to_network(|_| 7, synced_id, &Some(chestplate.clone())).unwrap(); + assert_eq!( + stack.component(component::TRIM), + Some(&Component::Trim { + material: 4, + pattern: 1 + }) + ); + // A name the connection's registry lacks sends no trim. + chestplate.data_mut().trim = Some(("minecraft:x".into(), "coast".into())); + let stack = stack_to_network(|_| 7, synced_id, &Some(chestplate)).unwrap(); + assert_eq!(stack.component(component::TRIM), None); + } +} diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index 4f93b6ff9..c2a395899 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -351,7 +351,7 @@ impl Hub { pub fn stack(&mut self, s: &Option) -> Option { let id = s.as_ref().map(|s| self.item_id(&s.item))?; let sync = self.sync.clone(); - stack_to_network(|_| id, |name| sync.id("minecraft:enchantment", name), s) + stack_to_network(|_| id, |registry, name| sync.id(registry, name), s) } pub fn broadcast(&self, packet: &C) { @@ -1827,7 +1827,9 @@ impl Hub { fn flush_advancements(&mut self, i: usize, show: bool) { let sync = self.sync.clone(); let g = &mut self.guests[i]; - let unlocked = std::mem::take(&mut g.recipes_unlocked); + let mut unlocked = std::mem::take(&mut g.recipes_unlocked); + // A recipe given and taken before this flush must not reappear. + unlocked.retain(|id| g.recipe_book.knows(id)); if let Some(add) = sync.advancements.recipes_added(&unlocked, &sync) { g.send(&raw(ids::RECIPE_BOOK_ADD, add)); } diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 229f176f9..7b3023629 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -177,6 +177,7 @@ pub mod tab_list; pub mod telemetry; pub mod testgen; pub mod text; +pub mod text_display; pub mod tick_chunk_membership; pub mod ticket_levels; pub mod title; diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index f8adb1f16..a429863a7 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -689,7 +689,7 @@ impl Lod { } let finer = finer.remove(&key).unwrap_or_default(); let input = snapshot.mesh_input(key, finer); - let mesh = mesher.mesh( + let mut mesh = mesher.mesh( input.key, &input.columns(), &covered, @@ -698,6 +698,7 @@ impl Lod { &input.neighbors, &input.finer, ); + mesh.sort_solid(); meshes.push((input.key, mesh)); } Done::Mesh { @@ -1727,10 +1728,6 @@ mod tests { let expected = (key.size() * key.size() - 16 * 16) as f32; assert_eq!(top_area(&mesh.solid, 70.0), expected); assert_eq!(top_area(&mesh.translucent, 80.0 - 1.0 / 9.0), expected); - assert_eq!( - mesh.faces.quads.iter().sum::() as usize, - mesh.solid.len() / 4 - ); assert!(mesh.translucent.iter().all(|v| v.light == 240)); let side = |axis: usize, plane: f32, low: f32, high: f32| { let other = if axis == 0 { 2 } else { 0 }; diff --git a/crates/horizon-client/src/lod/mesh.rs b/crates/horizon-client/src/lod/mesh.rs index 73287af50..852f45e5b 100644 --- a/crates/horizon-client/src/lod/mesh.rs +++ b/crates/horizon-client/src/lod/mesh.rs @@ -2,7 +2,7 @@ use super::{Column, Span, TileKey}; use crate::{ fast_hash::{FxHashMap, FxHashSet}, - mesher::{FaceGroups, OPAQUE_LAYER, SectionMesh, TerrainVertex}, + mesher::{OPAQUE_LAYER, SectionMesh, TerrainVertex}, streaming::WorkerContext, }; use horizon_assets::model::Direction; @@ -558,7 +558,6 @@ fn mesh_columns_with_edges( emit(&mut mesh, key, rect) } } - mesh.faces = FaceGroups::group(&mut mesh.solid); mesh } @@ -1003,7 +1002,6 @@ mod tests { } let mesh = mesh(&columns); assert_eq!(mesh.solid.len(), 6 * 4); - assert_eq!(mesh.faces.quads.iter().sum::(), 6); assert!(mesh.translucent.is_empty()); for q in mesh.solid.as_chunks::<4>().0.iter() { let center = q diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 59140866a..809bbe961 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -3,9 +3,9 @@ //! `ModelBlockRenderer`/`BlockModelLighter` (smooth light, ambient occlusion, //! cardinal shading, tint sources, block offsets; see `lighting`). Fluids //! follow `FluidRenderer` (see `fluid`). -mod facing; mod fluid; mod lighting; +mod sides; use crate::{ assets::{Assets, RenderAssets}, biome::Biomes, @@ -13,7 +13,6 @@ use crate::{ chunk::{Chunk, MIN_Y}, models::catalog::BakedFace, }; -pub use facing::{FaceGroups, GROUPS as FACE_GROUPS}; use horizon_core::{ biome::BiomeZoom, geometry::Direction, position::BlockPos, random::position_seed, }; @@ -22,6 +21,7 @@ use horizon_world::{ fluid::{FluidKind, FluidState}, registry::BlockStateId, }; +pub use sides::Sides; use std::sync::Arc; /// An entity, item and effect vertex (the entity pipelines), with a face @@ -116,8 +116,10 @@ mod vertex_tests { } pub struct SectionMesh { pub solid: Vec, - /// `solid`'s quads by the side they face (`facing`). - pub faces: FaceGroups, + /// The buckets `solid` is sorted in by the side its quads face: empty + /// until `sort_solid`, which the meshing workers call; `solid` is in + /// model order before. + pub sides: Sides, pub translucent: Vec, /// VisGraph: bit `a * 6 + b` is set when faces `a` and `b` (Direction /// order) are connected through non-opaque blocks. @@ -131,13 +133,20 @@ impl Default for SectionMesh { fn default() -> Self { Self { solid: Vec::new(), - faces: FaceGroups::default(), + sides: Sides::default(), translucent: Vec::new(), visibility: ALL_VISIBLE, block_entities: Vec::new(), } } } +impl SectionMesh { + /// Sorts the solid quads by the side they face, for the renderer to + /// leave out those facing away from the eye (`sides`). + pub fn sort_solid(&mut self) { + self.sides = sides::sort(&mut self.solid); + } +} pub const ALL_VISIBLE: u64 = (1 << 36) - 1; /// VisGraph.resolve: flood fill non-opaque cells and connect the faces each region touches. fn visibility(pad: &Padded, info: &[Info]) -> u64 { @@ -692,12 +701,6 @@ pub struct Mesher<'a> { impl Mesher<'_> { /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1). pub fn mesh(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> SectionMesh { - let mut out = self.tesselate(region, sy); - out.faces = facing::group(&mut out.solid); - out - } - /// The section's quads in model order, before `facing::group`. - pub(crate) fn tesselate(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> SectionMesh { let mut out = SectionMesh::default(); let center = region[1][1].expect("centre chunk"); let section = ¢er.sections[sy as usize]; diff --git a/crates/horizon-client/src/mesher/facing.rs b/crates/horizon-client/src/mesher/facing.rs deleted file mode 100644 index 7bafe9e82..000000000 --- a/crates/horizon-client/src/mesher/facing.rs +++ /dev/null @@ -1,267 +0,0 @@ -//! Solid quads grouped by the side they face, as Sodium's `ModelQuadFacing` -//! does. A quad in the plane `x = p` facing +X is front-facing only while the -//! eye is at `x > p`, and terrain culls back faces, so when the eye is on the -//! back side of every quad of a group the renderer skips the group's draw: -//! the GPU would have discarded all of it after shading its vertices. The -//! picture is unchanged; the vertex work for those quads is gone. -use super::TerrainVertex; -use glam::Vec3; - -/// Groups in buffer order: the negative sides, quads not in an axis plane -/// (rotated model elements, sloped fluid tops), then the positive sides. -/// With the eye outside a section on every axis, one side per axis is -/// visible, so the drawn groups form one to three runs. -pub const GROUPS: usize = 7; -const UNALIGNED: usize = 3; -/// The group of a quad facing `-axis` (0 x, 1 y, 2 z) is `NEGATIVE[axis]`, of -/// one facing `+axis` `GROUPS - 1 - NEGATIVE[axis]`. -const NEGATIVE: [usize; 3] = [0, 2, 1]; -/// How far (blocks) the eye must be behind every plane of a group before -/// the group is skipped: rounding on the GPU never makes such a quad -/// front-facing. -const MARGIN: f32 = 1.0 / 16.0; - -/// The solid quads' groups, filled by `group`. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct FaceGroups { - /// Quads per group, in buffer order. - pub quads: [u32; GROUPS], - /// Per axis group, the plane nearest the side the group faces: the - /// lowest plane of a positive group and the highest of a negative one. - planes: [f32; GROUPS], -} - -impl Default for FaceGroups { - /// Everything unaligned: always drawn. - fn default() -> Self { - Self { - quads: [0; GROUPS], - planes: [0.0; GROUPS], - } - } -} - -impl FaceGroups { - /// Group arbitrary-sized terrain quads, including distant LOD tiles. - pub fn group(solid: &mut Vec) -> Self { - group(solid) - } - - /// Whether group `g` can hold a front-facing quad for an eye at `eye`, - /// relative to the section's minimum corner. - pub fn visible(&self, g: usize, eye: Vec3) -> bool { - if g == UNALIGNED { - return true; - } - let (axis, positive) = axis(g); - if positive { - eye[axis] > self.planes[g] - MARGIN - } else { - eye[axis] < self.planes[g] + MARGIN - } - } - /// The quad ranges (first quad, quad count) to draw for an eye at `eye` - /// relative to the section's minimum corner, adjacent groups merged. - pub fn ranges(&self, eye: Vec3, mut out: impl FnMut(u32, u32)) { - let mut first = 0; - let mut run: Option<(u32, u32)> = None; - for g in 0..GROUPS { - let quads = self.quads[g]; - if quads > 0 { - if self.visible(g, eye) { - run = Some(match run { - Some((start, len)) => (start, len + quads), - None => (first, quads), - }); - } else if let Some((start, len)) = run.take() { - out(start, len); - } - } - first += quads; - } - if let Some((start, len)) = run { - out(start, len); - } - } -} - -/// The axis and sign of each axis group (`UNALIGNED`'s entry is unused). -const AXES: [(usize, bool); GROUPS] = { - let mut axes = [(0, false); GROUPS]; - let mut axis = 0; - while axis < 3 { - axes[NEGATIVE[axis]] = (axis, false); - axes[GROUPS - 1 - NEGATIVE[axis]] = (axis, true); - axis += 1; - } - axes -}; - -/// The axis and sign of axis group `g`. -fn axis(g: usize) -> (usize, bool) { - debug_assert_ne!(g, UNALIGNED); - AXES[g] -} - -/// The group of one quad, and its plane: an axis group only when all four -/// corners lie exactly in one axis plane. -fn facing(quad: &[TerrainVertex]) -> (usize, f32) { - let p = |i: usize| Vec3::from(quad[i].pos); - let normal = (p(1) - p(0)).cross(p(2) - p(0)); - for axis in 0..3 { - let [a, b] = [(axis + 1) % 3, (axis + 2) % 3]; - let plane = quad[0].pos[axis]; - if normal[axis] != 0.0 - && normal[a] == 0.0 - && normal[b] == 0.0 - && quad.iter().all(|v| v.pos[axis] == plane) - { - let negative = NEGATIVE[axis]; - let g = if normal[axis] > 0.0 { - GROUPS - 1 - negative - } else { - negative - }; - return (g, plane); - } - } - (UNALIGNED, 0.0) -} - -/// Reorder `solid` by group, keeping the order of quads within a group (so -/// coplanar quads such as a grass block's overlay still draw after their -/// base), and return the groups. -pub fn group(solid: &mut Vec) -> FaceGroups { - let mut groups = FaceGroups::default(); - for (g, plane) in groups.planes.iter_mut().enumerate() { - if g != UNALIGNED { - *plane = if axis(g).1 { f32::MAX } else { f32::MIN }; - } - } - let faces: Vec = solid - .as_chunks::<4>() - .0 - .iter() - .map(|quad| { - let (g, plane) = facing(quad); - groups.quads[g] += 1; - if g != UNALIGNED { - let nearest = &mut groups.planes[g]; - *nearest = if axis(g).1 { - nearest.min(plane) - } else { - nearest.max(plane) - }; - } - g as u8 - }) - .collect(); - if faces.windows(2).all(|w| w[0] <= w[1]) { - return groups; - } - let mut next = [0usize; GROUPS]; - let mut start = 0; - for g in 0..GROUPS { - next[g] = start; - start += groups.quads[g] as usize; - } - let mut sorted = vec![solid[0]; solid.len()]; - for (quad, &g) in solid.as_chunks::<4>().0.iter().zip(&faces) { - let at = next[g as usize] * 4; - sorted[at..at + 4].copy_from_slice(quad); - next[g as usize] += 1; - } - *solid = sorted; - groups -} - -#[cfg(test)] -mod tests { - use super::*; - - fn vertex(pos: [f32; 3], layer: u16) -> TerrainVertex { - TerrainVertex::new(pos, [0.0; 2], layer, 0, 0) - } - /// A unit quad in the plane `axis = plane`, wound to face `sign`, tagged - /// with `layer` so tests can follow it. - fn quad(axis: usize, plane: f32, sign: f32, layer: u16) -> Vec { - let corner = |u: f32, v: f32| { - let mut p = [0.0; 3]; - p[axis] = plane; - p[(axis + 1) % 3] = u; - p[(axis + 2) % 3] = v; - vertex(p, layer) - }; - let mut q = vec![ - corner(0.0, 0.0), - corner(1.0, 0.0), - corner(1.0, 1.0), - corner(0.0, 1.0), - ]; - if sign < 0.0 { - q.reverse(); - } - q - } - - #[test] - fn quads_group_by_the_side_their_winding_faces() { - for a in 0..3 { - for sign in [-1.0, 1.0] { - let q = quad(a, 4.0, sign, 0); - let (g, plane) = facing(&q); - assert_eq!(axis(g), (a, sign > 0.0), "axis {a} sign {sign}"); - assert_eq!(plane, 4.0); - let normal = (Vec3::from(q[1].pos) - Vec3::from(q[0].pos)) - .cross(Vec3::from(q[2].pos) - Vec3::from(q[0].pos)); - assert_eq!(normal[a].signum(), sign); - } - } - // A cross plant's diagonal quad faces no axis. - let diagonal = [ - [0.0, 0.0, 0.0], - [1.0, 0.0, 1.0], - [1.0, 1.0, 1.0], - [0.0, 1.0, 0.0], - ] - .map(|p| vertex(p, 0)); - assert_eq!(facing(&diagonal).0, UNALIGNED); - } - - #[test] - fn grouping_is_stable_and_skips_only_back_facing_groups() { - // +X at x = 3 and x = 7 (layers 1, 2), -X at x = 5 (3), an unaligned - // quad (4), a coplanar overlay on the x = 3 quad (5). - let diagonal = [ - [0.0, 0.0, 0.0], - [1.0, 0.0, 1.0], - [1.0, 1.0, 1.0], - [0.0, 1.0, 0.0], - ] - .map(|p| vertex(p, 4)); - let mut solid = [ - quad(0, 3.0, 1.0, 1), - quad(0, 5.0, -1.0, 3), - diagonal.to_vec(), - quad(0, 7.0, 1.0, 2), - quad(0, 3.0, 1.0, 5), - ] - .concat(); - let groups = group(&mut solid); - let layers: Vec = solid.chunks(4).map(|q| q[0].layer).collect(); - assert_eq!(layers, [3, 4, 1, 2, 5]); - let ranges = |eye: Vec3| { - let mut out = Vec::new(); - groups.ranges(eye, |first, count| out.push((first, count))); - out - }; - // Between the planes: every group can face the eye. - assert_eq!(ranges(Vec3::new(4.0, 8.0, 8.0)), [(0, 5)]); - // Beyond x = 7: the -X quad at x = 5 faces away. - assert_eq!(ranges(Vec3::new(20.0, 8.0, 8.0)), [(1, 4)]); - // Before x = 3: every +X quad faces away. - assert_eq!(ranges(Vec3::new(-10.0, 8.0, 8.0)), [(0, 2)]); - // Within the margin of the nearest plane: still drawn. - assert_eq!(ranges(Vec3::new(3.0, 8.0, 8.0)), [(0, 5)]); - } -} diff --git a/crates/horizon-client/src/mesher/sides.rs b/crates/horizon-client/src/mesher/sides.rs new file mode 100644 index 000000000..797d60127 --- /dev/null +++ b/crates/horizon-client/src/mesher/sides.rs @@ -0,0 +1,346 @@ +//! A mesh's solid quads sorted by the side they face, so that the renderer +//! can leave out the quads turned away from the eye before the GPU shades +//! their vertices. +//! +//! A quad in the plane `x = p` whose corners go counter-clockwise seen from +//! +X faces +X. From an eye at `x < p` it is seen from behind, and at +//! `x = p` edge on; the solid pipeline culls back faces, so it draws nothing +//! from there. A bucket of such quads draws nothing at all while the eye is +//! at or below the lowest of their planes, and likewise for the other five +//! axis directions. The seventh bucket holds every other quad (sloped, +//! rotated, degenerate, or whose two triangles wind opposite ways): it is +//! drawn from everywhere. +//! +//! The buckets lie one after another in the mesh, in an order chosen so that +//! the buckets an eye can see are usually one or two runs of quads: one draw +//! each. Inside a bucket quads keep their model order, so coplanar quads +//! facing one way (an overlay on its base) still draw in that order. +use super::TerrainVertex; + +/// The buckets in mesh order: +X, +Z, other, +Y, -Z, -X, -Y. Seen from +/// above (+Y, the commonest case), each pair of horizontal sides with a +/// common corner is then one run, or two. +const BUCKETS: [Bucket; 7] = [ + Bucket::Side(0, true), + Bucket::Side(2, true), + Bucket::Other, + Bucket::Side(1, true), + Bucket::Side(2, false), + Bucket::Side(0, false), + Bucket::Side(1, false), +]; +const OTHER: usize = 2; +/// How far, in blocks, the eye must be behind a bucket's planes before the +/// bucket is left out. The renderer computes both the eye and the section +/// origins in `f32`, with errors far below this. +const MARGIN: f32 = 1.0 / 16.0; + +#[derive(Clone, Copy)] +enum Bucket { + /// Quads in a plane across `axis` facing its positive (`true`) or + /// negative direction. + Side(usize, bool), + Other, +} + +/// Where each bucket of a mesh's solid quads ends, and the planes that tell +/// whether it can face the eye. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct Sides { + /// The solid quads up to the end of each bucket, in `BUCKETS` order. + ends: [u32; 7], + /// Per bucket facing a positive direction, its lowest plane; facing a + /// negative one, its highest (unused for the other bucket). + planes: [f32; 7], +} + +impl Sides { + /// `quads` solid quads in one bucket drawn from everywhere: for meshes + /// that were not sorted. + pub fn unsorted(quads: u32) -> Self { + let mut ends = [0; 7]; + ends[OTHER..].fill(quads); + Self { + ends, + planes: [0.0; 7], + } + } + + /// The number of solid quads the buckets hold. + pub fn quads(&self) -> u32 { + self.ends[6] + } + + /// Calls `draw(first, count)` for each run of quads an eye at `eye` + /// (relative to the mesh's origin) can see the front of, nearest the + /// start first. Empty buckets do not break a run. + pub fn visible(&self, eye: [f32; 3], mut draw: impl FnMut(u32, u32)) { + let mut start = 0; + let mut run: Option = None; + for (i, bucket) in BUCKETS.iter().enumerate() { + let end = self.ends[i]; + if end == start { + continue; + } + let seen = match *bucket { + Bucket::Side(axis, true) => eye[axis] > self.planes[i] - MARGIN, + Bucket::Side(axis, false) => eye[axis] < self.planes[i] + MARGIN, + Bucket::Other => true, + }; + match (seen, run) { + (true, None) => run = Some(start), + (false, Some(first)) => { + draw(first, start - first); + run = None; + } + _ => {} + } + start = end; + } + if let Some(first) = run { + draw(first, start - first); + } + } +} + +/// The bucket of a quad: the axis plane it lies in and the side its +/// triangles (corners 0, 1, 2 and 0, 2, 3, as the renderer draws them) face. +fn bucket(quad: &[TerrainVertex; 4]) -> usize { + let p = quad.map(|v| v.pos); + for axis in 0..3 { + if p.iter().any(|v| v[axis] != p[0][axis]) { + continue; + } + // The normal's component along `axis`, twice each triangle's area. + let (u, w) = ((axis + 1) % 3, (axis + 2) % 3); + let area = |a: usize, b: usize, c: usize| { + (p[b][u] - p[a][u]) * (p[c][w] - p[a][w]) - (p[b][w] - p[a][w]) * (p[c][u] - p[a][u]) + }; + let (first, second) = (area(0, 1, 2), area(0, 2, 3)); + let positive = first >= 0.0 && second >= 0.0; + let negative = first <= 0.0 && second <= 0.0; + if positive == negative { + // Opposite windings, or no area at all. + return OTHER; + } + return BUCKETS + .iter() + .position(|b| matches!(*b, Bucket::Side(a, s) if a == axis && s == positive)) + .expect("every side has a bucket"); + } + OTHER +} + +/// Reorders `solid`'s quads by bucket, keeping their order inside each. +pub fn sort(solid: &mut Vec) -> Sides { + let (quads, rest) = solid.as_chunks::<4>(); + debug_assert!(rest.is_empty(), "solid vertices come in quads"); + let buckets: Vec = quads.iter().map(|q| bucket(q) as u8).collect(); + let mut counts = [0u32; 7]; + let mut planes = [0f32; 7]; + for (quad, &b) in quads.iter().zip(&buckets) { + let b = usize::from(b); + if let Bucket::Side(axis, positive) = BUCKETS[b] { + let p = quad[0].pos[axis]; + planes[b] = match (counts[b], positive) { + (0, _) => p, + (_, true) => planes[b].min(p), + (_, false) => planes[b].max(p), + }; + } + counts[b] += 1; + } + let mut ends = [0u32; 7]; + let mut total = 0; + for (end, count) in ends.iter_mut().zip(counts) { + total += count; + *end = total; + } + if counts.iter().filter(|&&c| c > 0).count() > 1 { + let mut next: [u32; 7] = std::array::from_fn(|b| ends[b] - counts[b]); + let mut sorted = vec![quads[0]; quads.len()]; + for (quad, &b) in quads.iter().zip(&buckets) { + let slot = &mut next[usize::from(b)]; + sorted[*slot as usize] = *quad; + *slot += 1; + } + *solid = sorted.into_flattened(); + } + Sides { ends, planes } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn quad(corners: [[f32; 3]; 4], layer: u16) -> [TerrainVertex; 4] { + corners.map(|p| TerrainVertex::new(p, [0.0; 2], layer, 0, 0)) + } + + /// A unit block's six faces at `origin`, wound counter-clockwise seen + /// from outside, as block models are. + fn cube(origin: [f32; 3], layer: u16) -> Vec { + let [x, y, z] = origin; + let (a, b, c) = (x + 1.0, y + 1.0, z + 1.0); + [ + [[a, y, z], [a, b, z], [a, b, c], [a, y, c]], // +X + [[x, y, z], [x, y, c], [x, b, c], [x, b, z]], // -X + [[x, b, z], [x, b, c], [a, b, c], [a, b, z]], // +Y + [[x, y, z], [a, y, z], [a, y, c], [x, y, c]], // -Y + [[x, y, c], [a, y, c], [a, b, c], [x, b, c]], // +Z + [[x, y, z], [x, b, z], [a, b, z], [a, y, z]], // -Z + ] + .into_iter() + .flat_map(|q| quad(q, layer)) + .collect() + } + + fn runs(sides: &Sides, eye: [f32; 3]) -> Vec<(u32, u32)> { + let mut out = Vec::new(); + sides.visible(eye, |first, count| out.push((first, count))); + out + } + + /// The quads of `solid` whose triangles face `eye`, by their layer. + fn front_facing(solid: &[TerrainVertex], eye: [f32; 3]) -> Vec { + let sub = |a: [f32; 3], b: [f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; + solid + .as_chunks::<4>() + .0 + .iter() + .filter(|q| { + [[0, 1, 2], [0, 2, 3]].iter().any(|t| { + let (e1, e2) = (sub(q[t[1]].pos, q[t[0]].pos), sub(q[t[2]].pos, q[t[0]].pos)); + let n = [ + e1[1] * e2[2] - e1[2] * e2[1], + e1[2] * e2[0] - e1[0] * e2[2], + e1[0] * e2[1] - e1[1] * e2[0], + ]; + let to_eye = sub(eye, q[t[0]].pos); + n[0] * to_eye[0] + n[1] * to_eye[1] + n[2] * to_eye[2] > 0.0 + }) + }) + .map(|q| q[0].layer) + .collect() + } + + #[test] + fn cube_faces_go_to_their_buckets_in_order() { + let mut solid = cube([3.0, 4.0, 5.0], 0); + for (i, v) in solid.iter_mut().enumerate() { + v.layer = (i / 4) as u16; + } + let sides = sort(&mut solid); + assert_eq!(sides.ends, [1, 2, 2, 3, 4, 5, 6]); + let layers: Vec = solid.iter().step_by(4).map(|v| v.layer).collect(); + // +X, +Z, +Y, -Z, -X, -Y. + assert_eq!(layers, [0, 4, 2, 5, 1, 3]); + assert_eq!(sides.planes[0], 4.0); // +X at x = 4 + assert_eq!(sides.planes[5], 3.0); // -X at x = 3 + assert_eq!(sides.planes[3], 5.0); // +Y at y = 5 + } + + #[test] + fn the_drawn_runs_hold_every_quad_that_faces_the_eye() { + // Blocks across a section, with a sloped quad and a bowtie. + let mut solid = Vec::new(); + let mut layer = 0; + for origin in [ + [0.0, 0.0, 0.0], + [7.0, 3.0, 12.0], + [15.0, 15.0, 15.0], + [2.0, 9.0, 4.0], + ] { + for q in cube(origin, 0).chunks(4) { + solid.extend(q.iter().map(|v| TerrainVertex { layer, ..*v })); + layer += 1; + } + } + let slope = [ + [1.0, 1.0, 1.0], + [2.0, 1.0, 1.0], + [2.0, 2.0, 2.0], + [1.0, 2.0, 2.0], + ]; + let bowtie = [ + [5.0, 1.0, 1.0], + [5.0, 2.0, 2.0], + [5.0, 1.0, 2.0], + [5.0, 2.0, 1.0], + ]; + for corners in [slope, bowtie] { + solid.extend(quad(corners, layer)); + layer += 1; + } + let sides = sort(&mut solid); + assert_eq!(sides.quads(), u32::from(layer)); + let eyes = [-20.0f32, -0.5, 0.0, 3.5, 8.0, 15.99, 16.0, 30.0]; + for &x in &eyes { + for &y in &eyes { + for &z in &eyes { + let eye = [x, y, z]; + let mut drawn = Vec::new(); + for (first, count) in runs(&sides, eye) { + drawn.extend( + solid[first as usize * 4..(first + count) as usize * 4] + .iter() + .step_by(4) + .map(|v| v.layer), + ); + } + for layer in front_facing(&solid, eye) { + assert!(drawn.contains(&layer), "{eye:?} misses quad {layer}"); + } + } + } + } + } + + #[test] + fn runs_merge_across_hidden_and_empty_buckets() { + let mut solid = cube([0.0; 3], 0); + let sides = sort(&mut solid); + // From above, +X and +Z: +X, +Z, (no other), +Y is one run. + assert_eq!(runs(&sides, [8.0, 8.0, 8.0]), [(0, 3)]); + // From below, -X and -Z: -Z, -X, -Y. + assert_eq!(runs(&sides, [-8.0, -8.0, -8.0]), [(3, 3)]); + // From above, -X and +Z: +Z, +Y, then -X. + assert_eq!(runs(&sides, [-8.0, 8.0, 8.0]), [(1, 2), (4, 1)]); + // Inside the block every face is seen from behind. + assert!(runs(&sides, [0.5; 3]).is_empty()); + // Level with its top, the eye may see it: the margin keeps it. + assert_eq!(runs(&sides, [0.5, 1.0, 0.5]), [(2, 1)]); + } + + #[test] + fn unsorted_meshes_draw_everything() { + let sides = Sides::unsorted(9); + assert_eq!(sides.quads(), 9); + assert_eq!(runs(&sides, [-100.0; 3]), [(0, 9)]); + assert!(runs(&Sides::unsorted(0), [0.0; 3]).is_empty()); + } + + #[test] + fn one_bucket_keeps_the_mesh_as_it_is() { + let mut solid: Vec<_> = (0..3) + .flat_map(|i| { + quad( + [ + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 1.0], + [1.0, 0.0, 1.0], + ], + i, + ) + }) + .collect(); + let before = solid.clone(); + let sides = sort(&mut solid); + assert_eq!(sides.ends, [3; 7]); + assert_eq!( + solid.iter().map(|v| v.layer).collect::>(), + before.iter().map(|v| v.layer).collect::>() + ); + } +} 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/net.rs b/crates/horizon-client/src/net.rs index 3c009a1b5..9cce9e1c6 100644 --- a/crates/horizon-client/src/net.rs +++ b/crates/horizon-client/src/net.rs @@ -147,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!( @@ -159,7 +164,11 @@ 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(); @@ -296,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()); @@ -596,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())?; @@ -681,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/recipe_book.rs b/crates/horizon-client/src/recipe_book.rs index fa247a695..c18fa3e48 100644 --- a/crates/horizon-client/src/recipe_book.rs +++ b/crates/horizon-client/src/recipe_book.rs @@ -787,13 +787,15 @@ impl Settings { } (displays, added) } - /// `ServerRecipeBook.removeRecipes`: the displays removed. - pub fn remove_recipes(&mut self, index: &RecipeIndex, ids: &[String]) -> usize { - let mut displays = 0; + /// `ServerRecipeBook.removeRecipes`: the display ids removed, which its + /// `ClientboundRecipeBookRemovePacket` lists (a transmute recipe has one + /// per material count). + pub fn remove_recipes(&mut self, index: &RecipeIndex, ids: &[String]) -> Vec { + let mut displays = Vec::new(); for id in ids { if self.recipes.remove(id) { self.to_be_displayed.remove(id); - displays += index.displays(id); + displays.extend(index.display_ids(id)); } } displays diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 4cad224fd..99e8a48d6 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -504,7 +504,8 @@ impl Streaming { biomes: &context.biomes, visibility, }; - let mesh = mesher.mesh(&borrow(®ion), sy); + let mut mesh = mesher.mesh(&borrow(®ion), sy); + mesh.sort_solid(); faces = Some((context.tables.clone(), mesher.visibility)); Done::Meshed(x, sy, z, mesh, seq) } diff --git a/crates/horizon-client/src/text_display.rs b/crates/horizon-client/src/text_display.rs new file mode 100644 index 000000000..91dcabe16 --- /dev/null +++ b/crates/horizon-client/src/text_display.rs @@ -0,0 +1,169 @@ +//! Display/TextDisplay synced data (26.3), checked against vanilla accessors +//! and ClientboundSetEntityDataPacket's own stream codec. +use crate::text::Text; +use horizon_protocol::entity_data::Value; +use serde::Serialize; +use std::sync::Arc; + +/// `TextDisplay.Align`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Align { + Center, + Left, + Right, +} + +/// `Display` and `TextDisplay`'s synced data (ids 8 to 27); the default is +/// what their `defineSynchedData` starts with. +#[derive(Clone, Debug, Serialize)] +pub struct TextDisplayData { + pub interpolation_delay: i32, + pub interpolation_duration: i32, + pub teleport_duration: i32, + pub translation: [f32; 3], + pub scale: [f32; 3], + pub left_rotation: [f32; 4], + pub right_rotation: [f32; 4], + pub billboard: u8, + pub brightness: i32, + pub view_range: f32, + pub shadow_radius: f32, + pub shadow_strength: f32, + pub width: f32, + pub height: f32, + pub glow_color: i32, + /// Shared: a frame's interpolated copy of the data must not copy it. + #[serde(skip)] + pub text: Arc, + pub line_width: i32, + pub background: i32, + pub opacity: i8, + pub flags: u8, +} + +impl Default for TextDisplayData { + fn default() -> Self { + Self { + interpolation_delay: 0, + interpolation_duration: 0, + teleport_duration: 0, + translation: [0.0; 3], + scale: [1.0; 3], + left_rotation: [0.0, 0.0, 0.0, 1.0], + right_rotation: [0.0, 0.0, 0.0, 1.0], + billboard: 0, + brightness: -1, + view_range: 1.0, + shadow_radius: 0.0, + shadow_strength: 1.0, + width: 0.0, + height: 0.0, + glow_color: -1, + text: Arc::new(Text::empty()), + line_width: 200, + background: 0x4000_0000, + opacity: -1, + flags: 0, + } + } +} + +impl TextDisplayData { + /// DisplayRenderer's billboard orientation followed by Transformation's T*L*S*R. + pub fn matrix(&self, entity: [f32; 2], camera: [f32; 2]) -> glam::Mat4 { + let [yaw, pitch] = match self.billboard { + 1 => [camera[0] - 180.0, entity[1]], + 2 => [entity[0], -camera[1]], + 3 => [camera[0] - 180.0, -camera[1]], + _ => entity, + }; + let orientation = glam::Quat::from_euler( + glam::EulerRot::YXZ, + -yaw * 0.017_453_292, + pitch * 0.017_453_292, + 0.0, + ); + glam::Mat4::from_quat(orientation) + * glam::Mat4::from_translation(self.translation.into()) + * glam::Mat4::from_quat(glam::Quat::from_array(self.left_rotation)) + * glam::Mat4::from_scale(self.scale.into()) + * glam::Mat4::from_quat(glam::Quat::from_array(self.right_rotation)) + } + + pub fn blend(&self, from: &Self, t: f32) -> Self { + let mut out = self.clone(); + for i in 0..3 { + out.translation[i] = + from.translation[i] + t * (self.translation[i] - from.translation[i]); + out.scale[i] = from.scale[i] + t * (self.scale[i] - from.scale[i]); + } + out.left_rotation = glam::Quat::from_array(from.left_rotation) + .slerp(glam::Quat::from_array(self.left_rotation), t) + .to_array(); + out.right_rotation = glam::Quat::from_array(from.right_rotation) + .slerp(glam::Quat::from_array(self.right_rotation), t) + .to_array(); + let int = |a: i32, b: i32| a + (t * (b as f32 - a as f32)).floor() as i32; + out.opacity = int(i32::from(from.opacity), i32::from(self.opacity)) as i8; + out.background = (0..4).fold(0, |color, channel| { + color + | (int( + (from.background as u32 >> (channel * 8) & 255) as i32, + (self.background as u32 >> (channel * 8) & 255) as i32, + ) << (channel * 8)) + }); + out + } + /// Omitted fields retain their previous values. + pub fn apply(&mut self, values: &[(u8, i32, Value)]) { + for (id, _, value) in values { + match (id, value) { + (8, Value::Int(v)) => self.interpolation_delay = *v, + (9, Value::Int(v)) => self.interpolation_duration = *v, + (10, Value::Int(v)) => self.teleport_duration = *v, + (11, Value::Floats(v)) if v.len() == 3 => self.translation.copy_from_slice(v), + (12, Value::Floats(v)) if v.len() == 3 => self.scale.copy_from_slice(v), + (13, Value::Floats(v)) if v.len() == 4 => self.left_rotation.copy_from_slice(v), + (14, Value::Floats(v)) if v.len() == 4 => self.right_rotation.copy_from_slice(v), + (15, Value::Byte(v)) => self.billboard = *v as u8, + (16, Value::Int(v)) => self.brightness = *v, + (17, Value::Float(v)) => self.view_range = *v, + (18, Value::Float(v)) => self.shadow_radius = *v, + (19, Value::Float(v)) => self.shadow_strength = *v, + (20, Value::Float(v)) => self.width = *v, + (21, Value::Float(v)) => self.height = *v, + (22, Value::Int(v)) => self.glow_color = *v, + (23, Value::Text(v)) => self.text = Arc::new(crate::entity_nbt::name_text(v)), + (24, Value::Int(v)) => self.line_width = *v, + (25, Value::Int(v)) => self.background = *v, + (26, Value::Byte(v)) => self.opacity = *v, + (27, Value::Byte(v)) => self.flags = *v as u8, + _ => {} + } + } + } + /// `TextDisplay.getAlign`: the left flag wins over the right one. + pub fn align(&self) -> Align { + if self.flags & 8 != 0 { + Align::Left + } else if self.flags & 16 != 0 { + Align::Right + } else { + Align::Center + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn partial_updates_retain_values_and_bad_vectors_do_not_panic() { + let mut d = TextDisplayData::default(); + d.apply(&[(24, 1, Value::Int(80)), (27, 0, Value::Byte(24))]); + d.apply(&[(11, 0, Value::Floats(vec![1.0]))]); + assert_eq!(d.line_width, 80); + assert_eq!(d.align(), Align::Left); + assert_eq!(d.translation, [0.0; 3]); + } +} diff --git a/crates/horizon-client/tests/streaming_meshes.rs b/crates/horizon-client/tests/streaming_meshes.rs index 00c233277..49b90404c 100644 --- a/crates/horizon-client/tests/streaming_meshes.rs +++ b/crates/horizon-client/tests/streaming_meshes.rs @@ -221,7 +221,9 @@ fn relit_columns_keep_every_mesh_current() { biomes: &context.biomes, visibility: context.tables.visibility.clone(), }; - let fresh = mesher.mesh(&borrow(®ion), sy); + // The workers sort solid quads by side, as uploads expect. + let mut fresh = mesher.mesh(&borrow(®ion), sy); + fresh.sort_solid(); let bytes = |m: &SectionMesh| { [ bytemuck::cast_slice::<_, u8>(&m.solid).to_vec(), 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-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 b4023b7d1..d46cb9428 100644 --- a/crates/horizon-prepare/src/java.rs +++ b/crates/horizon-prepare/src/java.rs @@ -36,41 +36,82 @@ fn executable(dir: &Path, name: &str) -> PathBuf { }) } -fn on_path(name: &str) -> Option { - std::env::split_paths(&std::env::var_os("PATH")?) - .map(|dir| executable(&dir, name)) - .find(|p| p.is_file()) +/// `fs::canonicalize`, without the `\\?\` prefix it gives a Windows drive path: the +/// home goes into `JAVA_HOME` and the PATH of preparers, whose lookups don't take it. +fn real_path(path: PathBuf) -> PathBuf { + let real = fs::canonicalize(&path).unwrap_or(path); + if cfg!(windows) { + without_verbatim(real) + } else { + real + } } -/// 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(javac) +fn without_verbatim(path: PathBuf) -> PathBuf { + match path.to_str().and_then(|s| s.strip_prefix(r"\\?\")) { + Some(rest) if rest.as_bytes().get(1) == Some(&b':') => PathBuf::from(rest), + _ => path, + } +} + +/// Resolve compiler symlinks before picking its sibling runtime. The first `java` on the +/// PATH may be an older, runtime-only install; it must not be paired with a newer `javac`. +fn path_jdks(path: &OsStr) -> Vec { + std::env::split_paths(path) + .map(|dir| executable(&dir, "javac")) + .filter(|javac| javac.is_file()) + .map(real_path) + .filter_map(|javac| { + let bin = javac.parent()?; + // macOS's system tools are dispatchers, not a JDK home: JAVA_HOME=/usr + // makes them call themselves. /usr/libexec/java_home finds the actual JDK. + if bin.file_name()? != "bin" + || (cfg!(target_os = "macos") && bin == Path::new("/usr/bin")) + { + return None; + } + Some(bin.parent()?.to_path_buf()) + }) + .collect() +} + +/// The major version `javac -version` or `java -version` reports, including Java 8's `1.8`. +fn tool_major(program: &Path, name: &str) -> Result { + let output = command(program) .arg("-version") .stdin(Stdio::null()) .output() - .map_err(|e| format!("{}: {e}", javac.display()))?; + .map_err(|e| format!("{}: {e}", program.display()))?; let text = String::from_utf8_lossy(&output.stdout).into_owned() + &String::from_utf8_lossy(&output.stderr); + // macOS ships /usr/bin/java and /usr/bin/javac as placeholders. + if text.contains("Unable to locate a Java Runtime") { + return Err(format!( + "{} is macOS's placeholder (no Java installed)", + program.display() + )); + } + if !output.status.success() { + return Err(format!( + "{} -version failed ({}): {}", + program.display(), + output.status, + text.trim() + )); + } + let marker = if name == "javac" { "javac" } else { "version" }; let version = text .split_whitespace() - .skip_while(|w| *w != "javac") + .skip_while(|w| *w != marker) .nth(1) .ok_or_else(|| { - // macOS ships /usr/bin/javac as a placeholder that only says no Java is installed. - if text.contains("Unable to locate a Java Runtime") { - format!( - "{} is macOS's placeholder (no Java installed)", - javac.display() - ) - } else { - format!( - "{} -version printed no version: {}", - javac.display(), - text.trim() - ) - } + format!( + "{} -version printed no version: {}", + program.display(), + text.trim() + ) })?; - let mut parts = version.split(['.', '-', '+', '_']); + let mut parts = version.trim_matches('"').split(['.', '-', '+', '_']); let first: u32 = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0); Ok(if first == 1 { parts.next().and_then(|p| p.parse().ok()).unwrap_or(0) @@ -175,11 +216,10 @@ pub fn minecraft_runtimes(runtime: &Path) -> Vec { homes } -/// Finds a JDK with `javac` of at least `major`, the version research-lock.json pins: -/// `JAVA_HOME` when it holds one, else `javac` and `java` on the PATH (as the Python preparer -/// ran them), else, on macOS, the JDK `/usr/libexec/java_home -v ` reports, else the JDK -/// homes in `more` (the launcher's pick, Minecraft's own runtimes), else a JDK in the folders -/// installers put them in (`jdk_parents`). +/// Finds a JDK whose compiler and runtime are both at least `major`, the version +/// research-lock.json pins: `JAVA_HOME`, else JDKs on the PATH, else, on macOS, the JDK +/// `/usr/libexec/java_home -v ` reports, else the homes in `more` (the launcher's pick, +/// Minecraft's own runtimes), else the folders installers use (`jdk_parents`). pub fn find(major: i64, more: &[PathBuf]) -> Result { let need = format!( "Java {major} is needed (a JDK with javac, e.g. Eclipse Temurin {major}). \ @@ -194,8 +234,11 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result { "JAVA_HOME", )); } - if let (Some(javac), Some(java)) = (on_path("javac"), on_path("java")) { - candidates.push((javac, java, "PATH")); + if let Some(path) = std::env::var_os("PATH") { + for home in path_jdks(&path) { + let bin = home.join("bin"); + candidates.push((executable(&bin, "javac"), executable(&bin, "java"), "PATH")); + } } if cfg!(target_os = "macos") { if let Ok(out) = command("/usr/libexec/java_home") @@ -239,10 +282,19 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result { )); continue; } - match javac_major(&javac) { - Ok(found) if i64::from(found) >= major => return Ok(Jdk { javac, java }), - Ok(found) => problems.push(format!("{from} has Java {found} ({})", javac.display())), - Err(e) => problems.push(e), + let checked = [(&javac, "javac"), (&java, "java")] + .into_iter() + .try_for_each(|(program, name)| { + let found = tool_major(program, name)?; + if i64::from(found) >= major { + Ok(()) + } else { + Err(format!("{name} {found} ({})", program.display())) + } + }); + match checked { + Ok(()) => return Ok(Jdk { javac, java }), + Err(e) => problems.push(format!("{from}: {e}")), } } if problems.is_empty() { @@ -328,6 +380,22 @@ fn run(mut command: Command, log: &fs::File) -> Result<(), String> { mod tests { use super::*; + #[test] + fn verbatim_drive_paths_lose_their_prefix() { + let jdk = r"C:\Program Files\Eclipse Adoptium\jdk-25\bin\javac.exe"; + assert_eq!( + without_verbatim(PathBuf::from(format!(r"\\?\{jdk}"))), + PathBuf::from(jdk) + ); + // A UNC share keeps its verbatim form: stripping it would leave no valid path. + let unc = r"\\?\UNC\server\jdk\bin\javac.exe"; + assert_eq!(without_verbatim(PathBuf::from(unc)), PathBuf::from(unc)); + assert_eq!( + without_verbatim(PathBuf::from("/usr/lib/jvm/bin/javac")), + PathBuf::from("/usr/lib/jvm/bin/javac") + ); + } + #[test] fn installed_jdks_prefer_the_pinned_major() { let dir = std::env::temp_dir().join(format!("horizon-prepare-jdks-{}", std::process::id())); diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 30b2f1cff..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; 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-prepare/tests/java_selection.rs b/crates/horizon-prepare/tests/java_selection.rs new file mode 100644 index 000000000..ba15304e6 --- /dev/null +++ b/crates/horizon-prepare/tests/java_selection.rs @@ -0,0 +1,133 @@ +//! Each scenario runs in its own process so Java discovery sees a controlled environment. +use horizon_prepare::java; +use std::{env, fs, path::Path, process::Command}; + +const TEST: &str = "selects_a_compatible_compiler_and_runtime"; +const CHILD: &str = "HORIZON_JAVA_SELECTION_CHILD"; +const ROOT: &str = "HORIZON_JAVA_SELECTION_ROOT"; + +fn tool(bin: &Path, name: &str) -> std::path::PathBuf { + bin.join(format!("{name}{}", env::consts::EXE_SUFFIX)) +} + +#[test] +fn selects_a_compatible_compiler_and_runtime() { + if let Ok(scenario) = env::var(CHILD) { + let root = std::path::PathBuf::from(env::var_os(ROOT).unwrap()); + if scenario.ends_with("error") { + // Use a future compiler version to keep real installed JDKs out of the result. + let error = java::find(255, &[]).err().expect("accepted an old runtime"); + let runtime = if scenario == "legacy-runtime-error" { + 8 + } else { + 21 + }; + assert!(error.contains(&format!("java {runtime} (")), "{error}"); + return; + } + let jdk = java::find(25, &[]).unwrap(); + let expected = root.join(if scenario == "target-release" { + "newer" + } else { + "jdk25" + }); + for (actual, name) in [(&jdk.javac, "javac"), (&jdk.java, "java")] { + assert_eq!( + fs::canonicalize(actual).unwrap(), + fs::canonicalize(tool(&expected.join("bin"), name)).unwrap() + ); + } + assert_eq!( + fs::canonicalize(jdk.home()).unwrap(), + fs::canonicalize(expected).unwrap() + ); + let log_path = root.join(format!("{scenario}.log")); + let log = fs::File::create(&log_path).unwrap(); + jdk.java(&[], None, &log).unwrap(); + assert_eq!(fs::read_to_string(log_path).unwrap().trim(), "java 25.0.1"); + return; + } + + let root = env::temp_dir().join(format!("horizon-java-selection-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + let probe = tool(&root, "probe"); + let output = Command::new("rustc") + .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/support/java_probe.rs")) + .arg("-o") + .arg(&probe) + .output() + .unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + for (home, compiler, runtime) in [ + ("jre21", None, "21.0.1"), + ("jdk21", Some("21.0.1"), "21.0.1"), + ("jdk25", Some("25.0.1"), "25.0.1"), + ("mixed", Some("25.0.1"), "21.0.1"), + ("failing", Some("25.0.1"), "25.0.1"), + ("newer", Some("26-ea+1"), "25.0.1"), + ("future", Some("255.0.1"), "21.0.1"), + ("legacy", Some("255.0.1"), "1.8.0_442"), + ] { + let bin = root.join(home).join("bin"); + fs::create_dir_all(&bin).unwrap(); + for (name, version) in [("javac", compiler), ("java", Some(runtime))] { + if let Some(version) = version { + fs::copy(&probe, tool(&bin, name)).unwrap(); + fs::write(bin.join(format!("{name}.version")), version).unwrap(); + } + } + } + fs::write(root.join("failing/bin/java.exit"), "7").unwrap(); + let scenarios = vec![ + ("older-runtime", None, vec!["jre21", "jdk25"]), + ("older-jdk", None, vec!["jdk21", "jdk25"]), + ("incompatible-home", Some("mixed"), vec!["jdk25"]), + ("failed-runtime", Some("failing"), vec!["jdk25"]), + ("target-release", Some("newer"), vec![]), + ("runtime-error", Some("future"), vec![]), + ("legacy-runtime-error", Some("legacy"), vec![]), + ]; + #[cfg(unix)] + let scenarios = { + let mut scenarios = scenarios; + let bin = root.join("shims/bin"); + fs::create_dir_all(&bin).unwrap(); + std::os::unix::fs::symlink(tool(&root.join("jdk25/bin"), "javac"), tool(&bin, "javac")) + .unwrap(); + std::os::unix::fs::symlink(tool(&root.join("jre21/bin"), "java"), tool(&bin, "java")) + .unwrap(); + scenarios.push(("symlinked-path", None, vec!["shims"])); + scenarios + }; + for (scenario, home, path) in scenarios { + let mut child = Command::new(env::current_exe().unwrap()); + child + .args(["--exact", TEST, "--nocapture"]) + .env(CHILD, scenario) + .env(ROOT, &root) + .env( + "PATH", + env::join_paths(path.iter().map(|home| root.join(home).join("bin"))).unwrap(), + ) + .env("HOME", &root) + .env("USERPROFILE", &root) + .env("ProgramFiles", &root) + .env("ProgramW6432", &root) + .env_remove("JAVA_HOME"); + if let Some(home) = home { + child.env("JAVA_HOME", root.join(home)); + } + let output = child.output().unwrap(); + assert!( + output.status.success(), + "{scenario}:\n{}\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + } + fs::remove_dir_all(root).unwrap(); +} diff --git a/crates/horizon-prepare/tests/support/java_probe.rs b/crates/horizon-prepare/tests/support/java_probe.rs new file mode 100644 index 000000000..607c837cc --- /dev/null +++ b/crates/horizon-prepare/tests/support/java_probe.rs @@ -0,0 +1,21 @@ +//! A fake Java tool for process-level JDK selection tests; no installed Java is needed. +use std::{env, fs, process}; + +fn main() { + let executable = env::current_exe().unwrap(); + let bin = executable.parent().unwrap(); + let tool = executable.file_stem().unwrap().to_str().unwrap(); + let version = fs::read_to_string(bin.join(format!("{tool}.version"))).unwrap(); + if env::args().nth(1).as_deref() == Some("-version") { + if tool == "javac" { + println!("javac {version}"); + } else { + eprintln!("openjdk version \"{version}\""); + } + } else { + println!("{tool} {version}"); + } + if let Ok(status) = fs::read_to_string(bin.join(format!("{tool}.exit"))) { + process::exit(status.parse().unwrap()); + } +} diff --git a/crates/horizon-protocol/Cargo.toml b/crates/horizon-protocol/Cargo.toml index 71b93a1fe..4fd384807 100644 --- a/crates/horizon-protocol/Cargo.toml +++ b/crates/horizon-protocol/Cargo.toml @@ -17,10 +17,18 @@ 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" path = "examples/probe.rs" +[[example]] +name = "item_wire_probe" +path = "examples/item_wire_probe.rs" + [lints] workspace = true diff --git a/crates/horizon-protocol/examples/item_wire_probe.rs b/crates/horizon-protocol/examples/item_wire_probe.rs new file mode 100644 index 000000000..eb613b520 --- /dev/null +++ b/crates/horizon-protocol/examples/item_wire_probe.rs @@ -0,0 +1,65 @@ +//! The item wire harness's Rust side (tools/test_item_wire_parity.py): reads +//! the oracle's stacks (JSON lines with `label` and `hex`), decodes each with +//! `item::Slot` and prints, per stack, whether every byte was consumed, the +//! patch's component ids (added, then removed), which of them Horizon +//! decoded into its own lossy types (the rest it reads past keeping their +//! bytes, or decodes into ids it writes back unchanged, like trims) and +//! whether encoding the decoded stack gives the same bytes back. +//! +//! cargo run -p horizon-protocol --example item_wire_probe -- vanilla.jsonl rust.jsonl +use horizon_protocol::{ + buf::{Codec, Reader, Writer}, + item::{Component, Slot}, +}; +use serde_json::{Value, json}; +use std::io::Write; + +fn hex(s: &str) -> Option> { + (0..s.len()) + .step_by(2) + .map(|i| u8::from_str_radix(s.get(i..i + 2)?, 16).ok()) + .collect() +} + +fn main() -> Result<(), Box> { + let args: Vec = std::env::args().collect(); + let input = std::fs::read_to_string(args.get(1).ok_or("usage: item_wire_probe IN OUT")?)?; + let mut out = std::io::BufWriter::new(std::fs::File::create( + args.get(2).ok_or("usage: item_wire_probe IN OUT")?, + )?); + for line in input.lines().filter(|l| !l.trim().is_empty()) { + let v: Value = serde_json::from_str(line)?; + let label = v["label"].clone(); + let Some(bytes) = v["hex"].as_str().and_then(hex) else { + continue; + }; + let mut r = Reader::new(&bytes); + let result = match Slot::read(&mut r) { + Err(e) => json!({"label": label, "error": e.to_string()}), + Ok(stack) => { + let mut w = Writer::new(); + Slot::write(&stack, &mut w); + let (added, removed): (Vec, Vec) = + stack.as_ref().map_or_else(Default::default, |s| { + (s.added.iter().map(|(k, _)| *k).collect(), s.removed.clone()) + }); + let typed: Vec = stack + .iter() + .flat_map(|s| &s.added) + .filter(|(_, c)| !matches!(c, Component::Raw(_) | Component::Trim { .. })) + .map(|(k, _)| *k) + .collect(); + json!({ + "label": label, + "left": r.remaining(), + "added": added, + "removed": removed, + "typed": typed, + "same_bytes": w.data == bytes, + }) + } + }; + writeln!(out, "{result}")?; + } + Ok(()) +} diff --git a/crates/horizon-protocol/examples/stop_sound_probe.rs b/crates/horizon-protocol/examples/stop_sound_probe.rs new file mode 100644 index 000000000..d09478bd5 --- /dev/null +++ b/crates/horizon-protocol/examples/stop_sound_probe.rs @@ -0,0 +1,31 @@ +use horizon_protocol::{ + buf::{Codec, Reader, Writer}, + packets::play::StopSound, +}; +use std::{error::Error, io::Write}; +fn main() -> Result<(), Box> { + let args: Vec<_> = std::env::args().collect(); + let mut out = std::fs::File::create(&args[2])?; + for line in std::fs::read_to_string(&args[1])?.lines() { + let input: serde_json::Value = serde_json::from_str(line)?; + let hex = input["wire"].as_str().unwrap(); + let bytes: Vec = (0..hex.len()) + .step_by(2) + .map(|i| u8::from_str_radix(&hex[i..i + 2], 16)) + .collect::>()?; + let mut reader = Reader::new(&bytes); + let packet = StopSound::read(&mut reader)?; + assert_eq!(reader.remaining(), 0); + let mut writer = Writer::new(); + StopSound::write(&packet, &mut writer); + assert_eq!(writer.data, bytes); + writeln!( + out, + "{}", + serde_json::json!({"source":packet.source,"sound":packet.sound}) + )?; + } + assert!(StopSound::read(&mut Reader::new(&[1, 11])).is_err()); + assert!(StopSound::read(&mut Reader::new(&[3])).is_err()); + Ok(()) +} diff --git a/crates/horizon-protocol/src/connection.rs b/crates/horizon-protocol/src/connection.rs index 8f7ae28cc..80200612f 100644 --- a/crates/horizon-protocol/src/connection.rs +++ b/crates/horizon-protocol/src/connection.rs @@ -6,7 +6,7 @@ use crate::{Error, Result, buf::Reader, crypto::Cfb8, frame}; use std::{ io::{Read, Write}, - net::{Shutdown, TcpStream, ToSocketAddrs}, + net::{Shutdown, SocketAddr, TcpStream, ToSocketAddrs}, sync::{ Arc, Condvar, Mutex, atomic::{AtomicI64, Ordering}, @@ -180,6 +180,13 @@ pub struct ConnWriter { pub threshold: Option, counters: Arc, } +/// `InetAddress.getByName` under Java's default `java.net.preferIPv6Addresses=false`: IPv4 +/// addresses first, whatever order the system resolver gives (macOS lists IPv6 first). Vanilla +/// connects to that first address only; the rest stay here as fallbacks. +fn ipv4_first(mut addrs: Vec) -> Vec { + addrs.sort_by_key(SocketAddr::is_ipv6); + addrs +} /// Both halves before the split. pub struct Connection { pub reader: ConnReader, @@ -191,14 +198,27 @@ impl Connection { .to_socket_addrs() .map_err(|e| Error::new(format!("Unknown host {host}: {e}")))? .collect(); - let mut last = Error::new(format!("Unknown host {host}")); - for addr in addrs { + 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 { + // Report the first address's failure: it is the one vanilla tries, and the IPv6 + // fallbacks after it often fail only because the client has no IPv6 route. + let mut first = None; + for addr in ipv4_first(addrs) { match TcpStream::connect_timeout(&addr, timeout) { Ok(stream) => return Self::from_stream(stream), - Err(e) => last = Error::new(format!("Connection refused: {e}")), + Err(e) => { + first.get_or_insert_with(|| Error::new(format!("Connection refused: {e}"))); + } } } - Err(last) + Err(first.unwrap_or_else(|| Error::new(format!("Unknown host {host}")))) } pub fn from_stream(stream: TcpStream) -> Result { stream.set_nodelay(true)?; @@ -315,6 +335,71 @@ mod tests { use super::*; use std::net::TcpListener; + #[test] + fn ipv4_first_keeps_each_familys_order() { + let a = |s: &str| s.parse::().unwrap(); + let resolved = vec![ + a("[2001:db8::1]:25565"), + a("192.0.2.1:25565"), + a("[2001:db8::2]:25565"), + a("10.0.0.1:25565"), + ]; + assert_eq!( + ipv4_first(resolved), + [ + a("192.0.2.1:25565"), + a("10.0.0.1:25565"), + a("[2001:db8::1]:25565"), + a("[2001:db8::2]:25565"), + ] + ); + } + + fn peer(c: &Connection) -> SocketAddr { + match &c.reader.stream { + Stream::Tcp(s) => s.peer_addr().unwrap(), + Stream::Memory(_) => panic!("not a socket"), + } + } + + /// Binds `[::1]`, or `None` where the machine has no IPv6 loopback. + fn ipv6_loopback() -> Option { + let listener = TcpListener::bind("[::1]:0"); + if listener.is_err() { + eprintln!("skipped: no IPv6 loopback"); + } + listener.ok() + } + + #[test] + fn connects_to_ipv4_although_the_resolver_lists_ipv6_first() { + // Both listen, as with a server whose IPv6 address accepts and then resets. + let Some(v6_listener) = ipv6_loopback() else { + return; + }; + let v4_listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let v6 = v6_listener.local_addr().unwrap(); + let v4 = v4_listener.local_addr().unwrap(); + let c = + Connection::connect_addresses("test", vec![v6, v4], Duration::from_secs(5)).unwrap(); + assert_eq!(peer(&c), v4); + } + + #[test] + fn falls_back_to_ipv6_when_ipv4_refuses() { + let Some(v6_listener) = ipv6_loopback() else { + return; + }; + let v6 = v6_listener.local_addr().unwrap(); + let closed = TcpListener::bind("127.0.0.1:0") + .unwrap() + .local_addr() + .unwrap(); + let c = Connection::connect_addresses("test", vec![v6, closed], Duration::from_secs(5)) + .unwrap(); + assert_eq!(peer(&c), v6); + } + #[test] fn loopback_with_compression_and_encryption() { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); diff --git a/crates/horizon-protocol/src/item.rs b/crates/horizon-protocol/src/item.rs index 650fa4baa..6b6b845f8 100644 --- a/crates/horizon-protocol/src/item.rs +++ b/crates/horizon-protocol/src/item.rs @@ -2,11 +2,13 @@ //! item's registry id and a data component patch, plus the hashed form the //! client sends back in container clicks (HashedStack). use crate::{ - Error, Result, + Result, buf::{Codec, Reader, Writer}, }; use horizon_world::nbt::Tag; +mod skip; + /// minecraft:data_component_type registry ids (26.3). pub mod component { pub const CUSTOM_DATA: i32 = 0; @@ -35,6 +37,7 @@ pub mod component { pub const CHARGED_PROJECTILES: i32 = 51; pub const WRITABLE_BOOK_CONTENT: i32 = 56; pub const WRITTEN_BOOK_CONTENT: i32 = 57; + pub const TRIM: i32 = 58; } /// A written book's content (`WrittenBookContent.STREAM_CODEC`): the @@ -78,6 +81,15 @@ pub enum Component { WrittenBook(WrittenBook), /// `ChargedProjectiles`: a loaded crossbow's ammunition, as templates. Stacks(Vec), + /// `ArmorTrim` naming its material and pattern by registry id (`trim_material`, + /// `trim_pattern`); a trim with a direct holder stays [`Component::Raw`]. + Trim { + material: i32, + pattern: i32, + }, + /// A component Horizon reads past without interpreting it: its encoded + /// bytes, written back as they came. + Raw(Vec), } /// `Filterable.streamCodec`: the raw value, then an optional filtered one @@ -224,11 +236,35 @@ impl Component { hidden: (0..n).map(|_| r.varint()).collect::>()?, } } - other => return Err(Error::new(format!("unsupported item component {other}"))), + // ArmorTrim.STREAM_CODEC: two holders, each a reference's id plus + // one. A direct material or pattern has no registry name: read past. + TRIM => { + let start = r.position(); + skip::component(TRIM, r)?; + let bytes = r.since(start); + let mut ids = Reader::new(bytes); + match (ids.varint(), ids.varint()) { + (Ok(material @ 1..), Ok(pattern @ 1..)) if ids.remaining() == 0 => Self::Trim { + material: material - 1, + pattern: pattern - 1, + }, + _ => Self::Raw(bytes.to_vec()), + } + } + other => { + let start = r.position(); + skip::component(other, r)?; + Self::Raw(r.since(start).to_vec()) + } }) } fn write(&self, kind: i32, w: &mut Writer) { match self { + Self::Raw(bytes) => w.bytes(bytes), + Self::Trim { material, pattern } => { + w.varint(material + 1); + w.varint(pattern + 1); + } Self::Int(v) if kind == component::DYED_COLOR => w.i32(*v), Self::Int(v) => w.varint(*v), Self::Unit => {} @@ -582,7 +618,8 @@ mod tests { #[test] fn unknown_components_are_errors() { - let bytes = [1, 5, 1, 0, 99]; + // 122 is past DataComponents' last id (cushion_color, 121). + let bytes = [1, 5, 1, 0, 122]; assert!(Slot::read(&mut Reader::new(&bytes)).is_err()); } @@ -631,4 +668,44 @@ mod tests { [("textures".to_owned(), "x".to_owned(), None)] ); } + + #[test] + fn components_read_past_keep_their_bytes() { + // Vanilla 26.3's encoding (tools/test_item_wire_parity.py) of a chestplate's + // armour trim (decoded: both holders are references), a banner's patterns + // (one direct), a pot's sherds and a stew's effects: one server's + // inventory, recipe book and advancements had them. + for (hex, kind) in [ + ("01bd0801003a0502", 58), + ("01890b01004a02200e000b6d696e6563726166743a7801790b", 74), + ("01880301004c01f60801000001be0c0100000001d30c010000", 76), + ("01a408010037020f6412a001", 55), + ] { + let bytes: Vec = (0..hex.len()) + .step_by(2) + .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap()) + .collect(); + let mut r = Reader::new(&bytes); + let stack = Slot::read(&mut r).unwrap(); + assert_eq!(r.remaining(), 0, "component {kind}"); + let expected = |c: &Component| match kind { + 58 => { + *c == Component::Trim { + material: 4, + pattern: 1, + } + } + _ => matches!(c, Component::Raw(_)), + }; + assert!( + stack + .as_ref() + .and_then(|s| s.component(kind)) + .is_some_and(expected) + ); + let mut w = Writer::new(); + Slot::write(&stack, &mut w); + assert_eq!(w.data, bytes, "component {kind}"); + } + } } diff --git a/crates/horizon-protocol/src/item/skip.rs b/crates/horizon-protocol/src/item/skip.rs new file mode 100644 index 000000000..152d0f0f1 --- /dev/null +++ b/crates/horizon-protocol/src/item/skip.rs @@ -0,0 +1,427 @@ +//! Reading past the data components Horizon doesn't interpret: each +//! function consumes exactly what its vanilla StreamCodec writes +//! (DataComponents' `networkSynchronized` codecs; a component without one +//! goes as its persistent Codec's NBT, `ByteBufCodecs.fromCodecWithRegistries`). +//! Item data has no length prefix, so a component read short or long makes +//! everything after it unreadable. +use super::{Component, Template}; +use crate::{ + Error, Result, + buf::{Codec, Reader}, +}; + +type Read = fn(&mut Reader) -> Result<()>; + +/// DataComponents' registry order (26.3) for the ids `Component::read` +/// doesn't decode itself. +pub(super) fn component(kind: i32, r: &mut Reader) -> Result<()> { + match kind { + // Unit.STREAM_CODEC: glider, waxed. + 34 | 120 => Ok(()), + // Components without a network codec go as their NBT: intangible_projectile, + // map_decorations, debug_stick_state, recipes, lock, container_loot. + 22 | 49 | 59 | 68 | 81 | 82 => nbt(r), + // A VarInt (VAR_INT, an idMapper, a registry or holderRegistry id): damage_type, + // enchantable, additional_trade_cost, block_transformer, villager_food, dye, + // ominous_bottle_amplifier, base_color, the mob variants and colours, the pottery + // pattern and cushion_color. + 8 | 31 | 42 | 43 | 44 | 46 | 65 | 75 | 88..=108 | 110..=117 | 121 => varint(r), + // FLOAT: minimum_attack_charge, potion_duration_scale. + 7 | 54 => f32(r), + // Identifier.STREAM_CODEC: tooltip_style, note_block_sound. + 35 | 73 => ident(r), + // UseEffects: canSprint, interactVibrations, speedMultiplier. + 5 => { + r.bool()?; + r.bool()?; + f32(r) + } + // AdventureModePredicate: can_place_on, can_break. + 14 | 15 => list(r, block_predicate), + 16 => list(r, attribute_modifier), + // FoodProperties.DIRECT_STREAM_CODEC: nutrition, saturation, canAlwaysEat. + 23 => { + varint(r)?; + f32(r)?; + boolean(r) + } + // Consumable: consumeSeconds, animation, sound, hasConsumeParticles, onConsumeEffects. + 24 => { + f32(r)?; + varint(r)?; + sound(r)?; + boolean(r)?; + list(r, consume_effect) + } + // UseRemainder, SulfurCubeContent: one template. + 25 | 80 => template(r), + // UseCooldown: seconds, cooldownGroup. + 26 => { + f32(r)?; + optional(r, ident) + } + // DamageResistant, Repairable, provides_banner_patterns: a holder set. + 27 | 33 | 67 => holder_set(r), + 28 => tool(r), + // Weapon: itemDamagePerAttack, disableBlockingForSeconds. + 29 => { + varint(r)?; + f32(r) + } + 32 => equippable(r), + // DeathProtection: deathEffects. + 36 => list(r, consume_effect), + 37 => blocks_attacks(r), + // PiercingWeapon: dealsKnockback, dismounts, sound, hitSound. + 38 => { + boolean(r)?; + boolean(r)?; + optional(r, sound)?; + optional(r, sound) + } + 39 => kinetic_weapon(r), + // SwingAnimation: type, duration. + 40 | 41 => { + varint(r)?; + varint(r) + } + // BundleContents: templates. + 52 => list(r, template), + 53 => potion_contents(r), + // SuspiciousStewEffects: effect, duration. + 55 => list(r, |r| { + varint(r)?; + varint(r) + }), + // ArmorTrim: material, then Holder (assetId, description, decal). + 58 => { + trim_material(r)?; + holder(r, |r| { + ident(r)?; + nbt(r)?; + boolean(r) + }) + } + // TypedEntityData (entity_data, block_entity_data): the type id, then a compound. + 60 | 62 => { + varint(r)?; + nbt(r) + } + // CustomData: bucket_entity_data. + 61 => nbt(r), + // InstrumentComponent: Holder (soundEvent, useDuration, range, + // durabilityDamage, description). + 63 => holder(r, |r| { + sound(r)?; + f32(r)?; + f32(r)?; + varint(r)?; + nbt(r) + }), + 64 => trim_material(r), + // JukeboxPlayable: Holder (soundEvent, description, lengthInSeconds, + // comparatorOutput). + 66 => holder(r, |r| { + sound(r)?; + nbt(r)?; + f32(r)?; + varint(r) + }), + // LodestoneTracker: target (GlobalPos: dimension, BlockPos), tracked. + 69 => { + optional(r, |r| { + ident(r)?; + r.i64().map(drop) + })?; + boolean(r) + } + 70 => firework_explosion(r), + // Fireworks: flightDuration, explosions. + 71 => { + varint(r)?; + list(r, firework_explosion) + } + // BannerPatternLayers: Holder (assetId, translationKey), colour. + 74 => list(r, |r| { + holder(r, |r| { + ident(r)?; + string(r) + })?; + varint(r) + }), + // PotDecorations: back, left, right, front. + 76 => (0..4).try_for_each(|_| optional(r, template)), + // ItemContainerContents: optional templates. + 77 => list(r, |r| optional(r, template)), + // BlockItemStateProperties: a string to string map. + 78 => list(r, |r| { + string(r)?; + string(r) + }), + // Bees: Occupant (entity type and data, ticksInHive, minTicksInHive). + 79 => list(r, |r| { + varint(r)?; + nbt(r)?; + varint(r)?; + varint(r) + }), + 83 => sound(r), + // Compostable: layers. + 84 => resolvable(r, i32), + // CookingFuel (burnTime, speedMultiplier), BrewingFuel (uses, speedMultiplier). + 85 | 86 => { + resolvable(r, i32)?; + resolvable(r, f32) + } + // MobVisibility: targetingEntityTypes, visibility. + 87 => { + holder_set(r)?; + f32(r) + } + // Holder: width, height, assetId, title, author. + 109 => holder(r, |r| { + varint(r)?; + varint(r)?; + ident(r)?; + optional(r, nbt)?; + optional(r, nbt) + }), + // SignText: four messages, four optional filtered ones, colour, hasGlowingText. + 118 | 119 => { + (0..4).try_for_each(|_| nbt(r))?; + optional(r, |r| (0..4).try_for_each(|_| nbt(r)))?; + varint(r)?; + boolean(r) + } + other => Err(Error::new(format!("unsupported item component {other}"))), + } +} + +fn boolean(r: &mut Reader) -> Result<()> { + r.bool().map(drop) +} +fn varint(r: &mut Reader) -> Result<()> { + r.varint().map(drop) +} +fn f32(r: &mut Reader) -> Result<()> { + r.f32().map(drop) +} +fn i32(r: &mut Reader) -> Result<()> { + r.i32().map(drop) +} +/// ByteBufCodecs.STRING_UTF8. +fn string(r: &mut Reader) -> Result<()> { + r.string(32767).map(drop) +} +/// Identifier.STREAM_CODEC, ResourceKey.streamCodec. +fn ident(r: &mut Reader) -> Result<()> { + string(r) +} +/// A text component or compound (fromCodecWithRegistries, COMPOUND_TAG). +fn nbt(r: &mut Reader) -> Result<()> { + r.nbt().map(drop) +} +fn template(r: &mut Reader) -> Result<()> { + Template::read(r).map(drop) +} +/// ByteBufCodecs.optional: a flag, then the value. +fn optional(r: &mut Reader, value: Read) -> Result<()> { + if r.bool()? { value(r) } else { Ok(()) } +} +/// ByteBufCodecs.list and map: a VarInt count, then the elements (a map's +/// key and value each). Every element is at least a byte, so the count +/// can't pass what is left. +fn list(r: &mut Reader, element: Read) -> Result<()> { + let n = r.count(r.remaining())?; + (0..n).try_for_each(|_| element(r)) +} +/// ByteBufCodecs.holder: 0 and the value itself, or the registry id plus one. +fn holder(r: &mut Reader, direct: Read) -> Result<()> { + if r.varint()? == 0 { direct(r) } else { Ok(()) } +} +/// ByteBufCodecs.holderSet: 0 and a tag id, or the size plus one and the ids. +fn holder_set(r: &mut Reader) -> Result<()> { + match r.varint()? { + 0 => ident(r), + n => { + let n = usize::try_from(n - 1).map_err(|_| Error::new("negative holder set size"))?; + if n > r.remaining() { + return Err(Error::new("holder set past the end")); + } + (0..n).try_for_each(|_| varint(r)) + } + } +} +/// SoundEvent.STREAM_CODEC: a holder of a location and an optional fixed range. +fn sound(r: &mut Reader) -> Result<()> { + holder(r, |r| { + ident(r)?; + optional(r, f32) + }) +} +/// ResolvableInt, ResolvableFloat: Either a constant (true) or a context provider's key. +fn resolvable(r: &mut Reader, constant: Read) -> Result<()> { + if r.bool()? { constant(r) } else { ident(r) } +} +/// TrimMaterial.STREAM_CODEC: a holder of a palette id and a description. +fn trim_material(r: &mut Reader) -> Result<()> { + holder(r, |r| { + ident(r)?; + nbt(r) + }) +} +/// MobEffectInstance: the effect id, then its Details. +fn mob_effect(r: &mut Reader) -> Result<()> { + varint(r)?; + effect_details(r) +} +/// MobEffectInstance.Details: amplifier, duration, ambient, showParticles, showIcon, then the +/// hidden effect's Details, recursively. +fn effect_details(r: &mut Reader) -> Result<()> { + varint(r)?; + varint(r)?; + boolean(r)?; + boolean(r)?; + boolean(r)?; + optional(r, effect_details) +} +/// ConsumeEffect.STREAM_CODEC: the consume_effect_type id, then that type's fields. +fn consume_effect(r: &mut Reader) -> Result<()> { + match r.varint()? { + // apply_effects: effects, probability. + 0 => { + list(r, mob_effect)?; + f32(r) + } + // remove_effects: a mob effect holder set. + 1 => holder_set(r), + // clear_all_effects. + 2 => Ok(()), + // teleport_randomly: diameter, directionalParticles. + 3 => { + f32(r)?; + boolean(r) + } + // play_sound. + 4 => sound(r), + other => Err(Error::new(format!("unknown consume effect type {other}"))), + } +} +/// BlockPredicate: blocks, properties, nbt, then DataComponentMatchers (exact, partial). +fn block_predicate(r: &mut Reader) -> Result<()> { + optional(r, holder_set)?; + // StatePropertiesPredicate: PropertyMatchers, each a name and an + // Either. + optional(r, |r| { + list(r, |r| { + string(r)?; + if r.bool()? { + string(r) + } else { + optional(r, string)?; + optional(r, string) + } + }) + })?; + optional(r, nbt)?; + // DataComponentExactPredicate: TypedDataComponents, a component type id and its value. + list(r, |r| { + let kind = r.varint()?; + Component::read(kind, r).map(drop) + })?; + // DataComponentPredicate.STREAM_CODEC: an Either of a predicate type id or a component + // type id, then the predicate as NBT (fromCodecWithRegistries). + list(r, |r| { + boolean(r)?; + varint(r)?; + nbt(r) + }) +} +/// ItemAttributeModifiers.Entry: attribute, modifier (id, amount, operation), slot, display. +fn attribute_modifier(r: &mut Reader) -> Result<()> { + varint(r)?; + ident(r)?; + r.f64()?; + varint(r)?; + varint(r)?; + // Display.Type: default, hidden, or override and its text. + match r.varint()? { + 0 | 1 => Ok(()), + 2 => nbt(r), + other => Err(Error::new(format!( + "unknown attribute modifier display {other}" + ))), + } +} +/// Tool: rules (blocks, speed, correctForDrops), defaultMiningSpeed, damagePerBlock, +/// canDestroyBlocksInCreative. +fn tool(r: &mut Reader) -> Result<()> { + list(r, |r| { + holder_set(r)?; + optional(r, f32)?; + optional(r, boolean) + })?; + f32(r)?; + varint(r)?; + boolean(r) +} +/// Equippable: slot, equipSound, assetId, cameraOverlay, allowedEntities, dispensable, +/// swappable, damageOnHurt, equipOnInteract, canBeSheared, shearingSound. +fn equippable(r: &mut Reader) -> Result<()> { + varint(r)?; + sound(r)?; + optional(r, ident)?; + optional(r, ident)?; + optional(r, holder_set)?; + (0..5).try_for_each(|_| boolean(r))?; + sound(r) +} +/// BlocksAttacks: blockDelaySeconds, disableCooldownScale, damageReductions (angle, type, +/// base, factor), itemDamage (threshold, base, factor), bypassedBy, blockSound, disableSound. +fn blocks_attacks(r: &mut Reader) -> Result<()> { + f32(r)?; + f32(r)?; + list(r, |r| { + f32(r)?; + optional(r, holder_set)?; + f32(r)?; + f32(r) + })?; + (0..3).try_for_each(|_| f32(r))?; + optional(r, holder_set)?; + optional(r, sound)?; + optional(r, sound) +} +/// KineticWeapon: contactCooldownTicks, delayTicks, the dismount, knockback and damage +/// conditions (maxDurationTicks, minSpeed, minRelativeSpeed), forwardMovement, +/// damageMultiplier, sound, hitSound. +fn kinetic_weapon(r: &mut Reader) -> Result<()> { + varint(r)?; + varint(r)?; + (0..3).try_for_each(|_| { + optional(r, |r| { + varint(r)?; + f32(r)?; + f32(r) + }) + })?; + f32(r)?; + f32(r)?; + optional(r, sound)?; + optional(r, sound) +} +/// PotionContents: potion, customColor, customEffects, customName. +fn potion_contents(r: &mut Reader) -> Result<()> { + optional(r, varint)?; + optional(r, i32)?; + list(r, mob_effect)?; + optional(r, string) +} +/// FireworkExplosion: shape, colors, fadeColors, hasTrail, hasTwinkle. +fn firework_explosion(r: &mut Reader) -> Result<()> { + varint(r)?; + list(r, i32)?; + list(r, i32)?; + boolean(r)?; + boolean(r) +} 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 42e3ba686..519568282 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -1118,6 +1118,42 @@ packet!(SoundEntity { pitch: f32 => Float, seed: i64 => Long, }); + +/// ClientboundStopSoundPacket: bit 0 selects a source, bit 1 an event id. +#[derive(Clone, Debug, PartialEq)] +pub struct StopSound { + pub source: Option, + pub sound: Option, +} +impl Codec for StopSound { + fn read(r: &mut Reader) -> crate::Result { + let flags = r.u8()?; + let source = if flags & 1 != 0 { + let value = r.varint()?; + if !(0..11).contains(&value) { + return Err(crate::Error::new("invalid sound source")); + } + Some(value) + } else { + None + }; + let sound = if flags & 2 != 0 { + Some(r.string(32767)?) + } else { + None + }; + Ok(Self { source, sound }) + } + fn write(p: &Self, w: &mut Writer) { + w.u8(u8::from(p.source.is_some()) | (u8::from(p.sound.is_some()) << 1)); + if let Some(source) = p.source { + w.varint(source); + } + if let Some(sound) = &p.sound { + w.string(sound); + } + } +} /// One entry of ClientboundCommandsPacket: a literal or an argument node. #[derive(Clone, Debug, PartialEq)] pub struct CommandNode { @@ -1678,6 +1714,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { SetTitlesAnimation(TitlesAnimation) = SET_TITLES_ANIMATION, Sound(Sound) = SOUND, SoundEntity(SoundEntity) = SOUND_ENTITY, + StopSound(StopSound) = STOP_SOUND, StartConfiguration(Empty) = START_CONFIGURATION, SwingAnimation(SwingAnimation) = SWING_ANIMATION, SystemChat(SystemChat) = SYSTEM_CHAT, 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/main.rs b/crates/horizon-server/src/main.rs index c58a9a49e..f8d8c772a 100644 --- a/crates/horizon-server/src/main.rs +++ b/crates/horizon-server/src/main.rs @@ -11,6 +11,8 @@ mod init; mod lists; mod panel; mod process; +#[cfg(test)] +mod reference; mod service; mod settings; mod signals; 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-shaders/Cargo.toml b/crates/horizon-shaders/Cargo.toml new file mode 100644 index 000000000..ed3a24266 --- /dev/null +++ b/crates/horizon-shaders/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "horizon-shaders" +version = "0.1.0" +edition.workspace = true +license.workspace = true +rust-version = "1.85" +description = "Shader packs (the shaders/ folder format): reading packs, their .properties and .lang files, and later their GLSL" + +[dependencies] +zip = { version = "2", default-features = false, features = ["deflate"] } + +[lints] +workspace = true diff --git a/crates/horizon-shaders/src/discover.rs b/crates/horizon-shaders/src/discover.rs new file mode 100644 index 000000000..7d01d41b3 --- /dev/null +++ b/crates/horizon-shaders/src/discover.rs @@ -0,0 +1,82 @@ +//! The packs in the game's `shaderpacks` folder: every folder and `.zip` in it (spec 1.1). + +use std::fs; +use std::path::{Path, PathBuf}; + +use crate::Pack; + +/// One entry of the `shaderpacks` folder that is or looks like a pack. +#[derive(Debug, PartialEq)] +pub struct Found { + /// The folder or file name, which is how players and settings name the pack. + pub name: String, + pub path: PathBuf, + /// Why the entry can't be used, said to the player (a zip that doesn't open, a folder with + /// no `shaders` folder at its root). `None` for a usable pack. + pub problem: Option, +} + +/// The packs in `dir`, sorted by name ignoring case. Hidden entries and files that are not +/// `.zip` (the game's own option files live beside the packs) are skipped. +pub fn discover(dir: &Path) -> Vec { + let mut found: Vec = fs::read_dir(dir) + .into_iter() + .flatten() + .flatten() + .filter_map(|entry| { + let name = entry.file_name().to_string_lossy().into_owned(); + let path = entry.path(); + let is_zip = path + .extension() + .is_some_and(|e| e.eq_ignore_ascii_case("zip")); + if name.starts_with('.') || !(path.is_dir() || is_zip) { + return None; + } + let problem = Pack::open(&path).err().map(|e| e.to_string()); + Some(Found { + name, + path, + problem, + }) + }) + .collect(); + found.sort_by_cached_key(|f| (f.name.to_lowercase(), f.name.clone())); + found +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::pack::tests::{temp_dir, zip}; + + #[test] + fn lists_folders_and_zips_with_their_problems() { + let dir = temp_dir("discover"); + fs::create_dir_all(dir.join("Zeta/shaders")).unwrap(); + fs::create_dir_all(dir.join("Extracted wrong/Inner/shaders")).unwrap(); + fs::create_dir_all(dir.join(".hidden/shaders")).unwrap(); + fs::write(dir.join("alpha.ZIP"), zip(&[("shaders/final.fsh", "")])).unwrap(); + fs::write(dir.join("broken.zip"), "not a zip").unwrap(); + fs::write(dir.join("alpha.ZIP.txt"), "OPTION=1").unwrap(); + let found = discover(&dir); + let summary: Vec<(&str, bool)> = found + .iter() + .map(|f| (f.name.as_str(), f.problem.is_none())) + .collect(); + assert_eq!( + summary, + [ + ("alpha.ZIP", true), + ("broken.zip", false), + ("Extracted wrong", false), + ("Zeta", true) + ] + ); + assert_eq!( + found[2].problem.as_deref(), + Some("no shaders folder at the root of the pack") + ); + assert!(discover(&dir.join("missing")).is_empty()); + fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/crates/horizon-shaders/src/lang.rs b/crates/horizon-shaders/src/lang.rs new file mode 100644 index 000000000..483de67d2 --- /dev/null +++ b/crates/horizon-shaders/src/lang.rs @@ -0,0 +1,74 @@ +//! A pack's `lang/.lang` files (spec 8.4): `key=value` lines naming options, values, +//! screens and profiles. + +use std::collections::HashMap; + +use crate::Pack; + +#[derive(Debug, Default, PartialEq)] +pub struct Lang(HashMap); + +impl Lang { + /// English with the player's locale over it, so a key the locale lacks still has a name. + /// File names match ignoring case: packs ship `en_US.lang` for Minecraft's `en_us`. + /// Strings keep their `§` formatting codes for the game's text renderer. + pub fn load(pack: &Pack, locale: &str) -> Self { + let files = pack.list("lang"); + let mut lang = Self::default(); + for wanted in ["en_us", locale] { + let file = files.iter().find(|f| { + f.strip_suffix(".lang") + .is_some_and(|stem| stem.eq_ignore_ascii_case(wanted)) + }); + if let Some(text) = file.and_then(|f| pack.read_text(&format!("lang/{f}"))) { + lang.read(&text); + } + } + lang + } + + fn read(&mut self, text: &str) { + for line in text.lines().map(str::trim) { + if line.starts_with('#') { + continue; + } + if let Some((key, value)) = line.split_once('=') { + self.0 + .insert(key.trim().to_owned(), value.trim().to_owned()); + } + } + } + + pub fn get(&self, key: &str) -> Option<&str> { + self.0.get(key).map(String::as_str) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::pack::tests::zip; + + #[test] + fn lang_falls_back_by_case_then_english() { + let pack = Pack::from_zip_bytes( + "P.zip", + zip(&[ + ( + "shaders/lang/en_US.lang", + "# names\noption.A=Alpha\noption.B = §6Beta§r\n", + ), + ("shaders/lang/fr_FR.lang", "option.A=Alpha (fr)\n"), + ]), + ) + .unwrap(); + let fr = Lang::load(&pack, "fr_fr"); + assert_eq!(fr.get("option.A"), Some("Alpha (fr)")); + assert_eq!(fr.get("option.B"), Some("§6Beta§r")); + assert_eq!(fr.get("# names"), None); + let de = Lang::load(&pack, "de_de"); + assert_eq!(de.get("option.A"), Some("Alpha")); + let none = Pack::from_zip_bytes("Q.zip", zip(&[("shaders/final.fsh", "")])).unwrap(); + assert_eq!(Lang::load(&none, "en_us"), Lang::default()); + } +} diff --git a/crates/horizon-shaders/src/lib.rs b/crates/horizon-shaders/src/lib.rs new file mode 100644 index 000000000..1c9b46dd1 --- /dev/null +++ b/crates/horizon-shaders/src/lib.rs @@ -0,0 +1,15 @@ +//! Shader packs: the `shaderpacks/*.zip` format, written from Horizon's clean-room specification +//! (`shader-packs-spec.md`, revision 1). This crate reads the format and knows nothing of wgpu; +//! the game's renderer runs what it produces. +//! +//! - [`Pack`]: a pack as a folder or a zip, with paths relative to its `shaders` folder (spec 1.1). +//! - [`discover`]: the packs in a `shaderpacks` folder. +//! - [`Lang`]: the pack's translated names (8.4). + +mod discover; +mod lang; +mod pack; + +pub use discover::{Found, discover}; +pub use lang::Lang; +pub use pack::{Pack, PackError}; diff --git a/crates/horizon-shaders/src/pack.rs b/crates/horizon-shaders/src/pack.rs new file mode 100644 index 000000000..113db9ac9 --- /dev/null +++ b/crates/horizon-shaders/src/pack.rs @@ -0,0 +1,262 @@ +//! A pack is a folder or a `.zip` whose root holds a folder named `shaders`; everything else at +//! the root (licences, readmes, decoy folders) is ignored (spec 1.1). Every path a pack uses is +//! relative to that `shaders` folder, written with `/`. + +use std::collections::BTreeMap; +use std::fmt; +use std::fs; +use std::io::{self, Cursor, Read}; +use std::path::{Path, PathBuf}; +use std::sync::Arc; + +use zip::ZipArchive; + +const ROOT: &str = "shaders"; + +pub struct Pack { + name: String, + files: Files, +} + +enum Files { + /// The pack's `shaders` folder. + Folder(PathBuf), + /// The archive and its entries under `shaders/`, by their path inside that folder. + Zip { + archive: ZipArchive>>, + entries: BTreeMap, + }, +} + +#[derive(Debug)] +pub enum PackError { + Io(io::Error), + Zip(String), + /// A readable folder or archive with no `shaders` folder at its root. + NoShadersFolder, +} + +impl fmt::Display for PackError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::Io(e) => write!(f, "{e}"), + Self::Zip(e) => write!(f, "not a readable zip: {e}"), + Self::NoShadersFolder => f.write_str("no shaders folder at the root of the pack"), + } + } +} + +impl std::error::Error for PackError {} + +impl From for PackError { + fn from(e: io::Error) -> Self { + Self::Io(e) + } +} + +impl Pack { + /// Opens a pack folder or a `.zip` archive. + pub fn open(path: &Path) -> Result { + let name = path + .file_name() + .map_or_else(String::new, |n| n.to_string_lossy().into_owned()); + let files = if path.is_dir() { + let root = path.join(ROOT); + if !root.is_dir() { + return Err(PackError::NoShadersFolder); + } + Files::Folder(root) + } else { + Self::zip_files(fs::read(path)?)? + }; + Ok(Self { name, files }) + } + + /// An archive held in memory; `name` is what [`Pack::name`] returns. + pub fn from_zip_bytes(name: &str, bytes: Vec) -> Result { + let files = Self::zip_files(bytes)?; + Ok(Self { + name: name.to_owned(), + files, + }) + } + + fn zip_files(bytes: Vec) -> Result { + let archive = ZipArchive::new(Cursor::new(Arc::from(bytes))) + .map_err(|e| PackError::Zip(e.to_string()))?; + let entries: BTreeMap = (0..archive.len()) + .filter_map(|i| { + let name = archive.name_for_index(i)?.replace('\\', "/"); + let inner = name.strip_prefix(ROOT)?.strip_prefix('/')?; + (!inner.is_empty() && !inner.ends_with('/')).then(|| (inner.to_owned(), i)) + }) + .collect(); + if entries.is_empty() { + return Err(PackError::NoShadersFolder); + } + Ok(Files::Zip { archive, entries }) + } + + /// The folder or file name the pack was opened from (`BSL.zip`). + pub fn name(&self) -> &str { + &self.name + } + + /// The bytes of a file, by its path inside `shaders` (`lang/en_us.lang`). `None` when it + /// doesn't exist or the path leaves the folder. + pub fn read(&self, path: &str) -> Option> { + let path = normalize(path)?; + match &self.files { + Files::Folder(root) => fs::read(root.join(&path)).ok(), + Files::Zip { archive, entries } => { + // A clone shares the bytes and the central directory; reading needs `&mut`. + let mut archive = archive.clone(); + let mut entry = archive.by_index(*entries.get(&path)?).ok()?; + let mut out = Vec::with_capacity(entry.size() as usize); + entry.read_to_end(&mut out).ok()?; + Some(out) + } + } + } + + /// A text file, decoded as UTF-8 (invalid bytes replaced) without its byte-order mark. + pub fn read_text(&self, path: &str) -> Option { + let bytes = self.read(path)?; + let text = String::from_utf8_lossy(&bytes); + Some(text.strip_prefix('\u{feff}').unwrap_or(&text).to_owned()) + } + + pub fn exists(&self, path: &str) -> bool { + let Some(path) = normalize(path) else { + return false; + }; + match &self.files { + Files::Folder(root) => root.join(path).is_file(), + Files::Zip { entries, .. } => entries.contains_key(&path), + } + } + + /// The names of the files directly inside a folder of the pack (`""` for `shaders` itself), + /// sorted. + pub fn list(&self, dir: &str) -> Vec { + let Some(dir) = normalize(dir) else { + return Vec::new(); + }; + let mut names: Vec = match &self.files { + Files::Folder(root) => fs::read_dir(root.join(&dir)) + .into_iter() + .flatten() + .flatten() + .filter(|e| e.file_type().is_ok_and(|t| t.is_file())) + .map(|e| e.file_name().to_string_lossy().into_owned()) + .collect(), + Files::Zip { entries, .. } => { + let prefix = if dir.is_empty() { + String::new() + } else { + format!("{dir}/") + }; + entries + .keys() + .filter_map(|k| k.strip_prefix(&prefix)) + .filter(|rest| !rest.contains('/')) + .map(str::to_owned) + .collect() + } + }; + names.sort(); + names + } +} + +/// `a/./b/../c` → `a/c`; `None` for a path that climbs out of `shaders`. +fn normalize(path: &str) -> Option { + let mut parts: Vec<&str> = Vec::new(); + for part in path.split(['/', '\\']) { + match part { + "" | "." => {} + ".." => { + parts.pop()?; + } + _ => parts.push(part), + } + } + Some(parts.join("/")) +} + +#[cfg(test)] +pub(crate) mod tests { + use super::*; + use std::io::Write; + + /// A zip of `(path, contents)` pairs, paths from the archive root. + pub(crate) fn zip(files: &[(&str, &str)]) -> Vec { + let mut w = zip::ZipWriter::new(Cursor::new(Vec::new())); + let options = zip::write::SimpleFileOptions::default() + .compression_method(zip::CompressionMethod::Deflated); + for (path, contents) in files { + w.start_file(*path, options).unwrap(); + w.write_all(contents.as_bytes()).unwrap(); + } + w.finish().unwrap().into_inner() + } + + /// A fresh empty folder under the system's temp folder. + pub(crate) fn temp_dir(name: &str) -> PathBuf { + let dir = + std::env::temp_dir().join(format!("horizon-shaders-{name}-{}", std::process::id())); + let _ = fs::remove_dir_all(&dir); + fs::create_dir_all(&dir).unwrap(); + dir + } + + #[test] + fn zip_packs_read_only_the_shaders_folder() { + let bytes = zip(&[ + ("License.txt", "x"), + ("shaderFile_A.placebo/shaders.properties", "decoy"), + ("shaders/shaders.properties", "sun=false"), + ("shaders/lang/en_US.lang", "a=b"), + ("shaders/lang/fr_FR.lang", "a=c"), + ("shaders/lib/common.glsl", ""), + ]); + let pack = Pack::from_zip_bytes("P.zip", bytes).unwrap(); + assert_eq!(pack.read_text("shaders.properties").unwrap(), "sun=false"); + assert!(pack.exists("lib/common.glsl")); + assert!(pack.exists("lib/../shaders.properties")); + assert!(!pack.exists("../License.txt")); + assert!(!pack.exists("License.txt")); + assert_eq!(pack.list("lang"), ["en_US.lang", "fr_FR.lang"]); + assert_eq!(pack.list(""), ["shaders.properties"]); + } + + #[test] + fn archives_without_a_shaders_folder_are_not_packs() { + let bytes = zip(&[("Pack/shaders/final.fsh", ""), ("readme.txt", "")]); + assert!(matches!( + Pack::from_zip_bytes("P.zip", bytes), + Err(PackError::NoShadersFolder) + )); + assert!(matches!( + Pack::from_zip_bytes("P.zip", b"not a zip".to_vec()), + Err(PackError::Zip(_)) + )); + } + + #[test] + fn folder_packs_read_the_same_way() { + let dir = temp_dir("folder"); + fs::create_dir_all(dir.join("shaders/lang")).unwrap(); + fs::write( + dir.join("shaders/lang/en_us.lang"), + "\u{feff}option.A=Alpha", + ) + .unwrap(); + fs::write(dir.join("secret.txt"), "outside").unwrap(); + let pack = Pack::open(&dir).unwrap(); + assert_eq!(pack.read_text("lang/en_us.lang").unwrap(), "option.A=Alpha"); + assert_eq!(pack.list("lang"), ["en_us.lang"]); + assert!(pack.read("../secret.txt").is_none()); + fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/crates/horizon-shaders/tests/real_packs.rs b/crates/horizon-shaders/tests/real_packs.rs new file mode 100644 index 000000000..b35aef519 --- /dev/null +++ b/crates/horizon-shaders/tests/real_packs.rs @@ -0,0 +1,43 @@ +//! Reads real packs as black boxes: `HORIZON_TEST_SHADER_PACKS= cargo test -p +//! horizon-shaders --release -- --ignored --nocapture`. The folder (and its subfolders) holds +//! pack zips or folders, which are never committed; this prints what was read and how long it took. + +use std::path::Path; +use std::time::Instant; + +use horizon_shaders::{Lang, Pack, discover}; + +#[test] +#[ignore = "needs HORIZON_TEST_SHADER_PACKS"] +fn real_packs_read() { + let dir = std::env::var_os("HORIZON_TEST_SHADER_PACKS").expect("HORIZON_TEST_SHADER_PACKS"); + let dir = Path::new(&dir); + let mut found = discover(dir); + for sub in std::fs::read_dir(dir).unwrap().flatten() { + if sub.path().is_dir() { + found.extend(discover(&sub.path())); + } + } + let mut read = 0; + for f in found.iter().filter(|f| f.problem.is_none()) { + let start = Instant::now(); + let pack = Pack::open(&f.path).unwrap(); + let properties = pack.read_text("shaders.properties"); + let lang = Lang::load(&pack, "en_us"); + println!( + "{}: {} files at the root, shaders.properties {} bytes, lang {}, {:.2} ms", + f.name, + pack.list("").len(), + properties.as_ref().map_or(0, String::len), + if lang == Lang::default() { + "none" + } else { + "read" + }, + start.elapsed().as_secs_f64() * 1000.0 + ); + assert!(properties.is_some(), "{}: no shaders.properties", f.name); + read += 1; + } + assert!(read > 0, "no packs under {}", dir.display()); +} diff --git a/crates/horizon-world/examples/probe/main.rs b/crates/horizon-world/examples/probe/main.rs index f3b9b6ef5..479a3ed23 100644 --- a/crates/horizon-world/examples/probe/main.rs +++ b/crates/horizon-world/examples/probe/main.rs @@ -168,6 +168,7 @@ mod stored_consume_fixture; mod stored_effect_attributes_fixture; mod stored_effect_notifications_fixture; mod structure_density_fixture; +mod structure_pieces; mod suffocation_fixture; mod swimming_fixture; mod synced_bytes_fixture; @@ -338,6 +339,7 @@ probes! { stored_effect_attributes_fixture, stored_effect_notifications_fixture, structure_density_fixture, + structure_pieces, suffocation_fixture, swimming_fixture, synced_bytes_fixture, diff --git a/crates/horizon-world/examples/probe/structure_pieces.rs b/crates/horizon-world/examples/probe/structure_pieces.rs new file mode 100644 index 000000000..ebbad9c7a --- /dev/null +++ b/crates/horizon-world/examples/probe/structure_pieces.rs @@ -0,0 +1,103 @@ +//! The structure starts a chunk owns, piece by piece, as a saved start lists them. +//! +//! structure_pieces ... +//! prints, for every start whose chunk is a target, `start ID CX CZ` and then +//! one `piece TYPE ELEMENT ROTATION X Y Z GROUND_LEVEL_DELTA X0 Y0 Z0 X1 Y1 Z1` +//! line per piece in placement order (jigsaw pieces: the element's template +//! location; other pieces: `-` for element, rotation and position). +use crate::support::common::tag; +use horizon_core::position::ChunkPos; +use horizon_world::{ + DATA_VERSION, + nbt::Tag, + registry::BlockRegistry, + worldgen::{ + generator::{GeneratorData, OverworldGenerator}, + structure::{Rotation, jigsaw::PoolElement, start::Piece}, + }, +}; +use serde_json::Value; +use std::{fs, path::Path}; + +type Error = Box; + +fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> { + let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?; + let states = facts["states"].as_array().ok_or("facts states")?; + let registry = BlockRegistry::from_nbt(&Tag::compound([ + ("DataVersion", Tag::Int(DATA_VERSION)), + ( + "states", + Tag::List(states.iter().map(|v| tag(&v[4])).collect()), + ), + ("defaults", tag(&facts["defaults"])), + ]))?; + Ok(Box::leak(Box::new(registry))) +} + +fn element(element: &PoolElement) -> String { + match element { + PoolElement::Empty => "empty".into(), + PoolElement::Single { template, .. } => template.location.to_string(), + PoolElement::Feature { feature, .. } => format!("feature:{feature}"), + PoolElement::List { elements, .. } => { + let parts: Vec<_> = elements.iter().map(self::element).collect(); + format!("list:{}", parts.join("+")) + } + } +} + +fn rotation(rotation: Rotation) -> &'static str { + match rotation { + Rotation::None => "NONE", + Rotation::Clockwise90 => "CLOCKWISE_90", + Rotation::Clockwise180 => "CLOCKWISE_180", + Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90", + } +} + +pub fn main() -> Result<(), Error> { + let mut args = crate::args().skip(1); + let resources = std::path::PathBuf::from(args.next().ok_or("client resource directory")?); + let seed: i64 = args.next().ok_or("seed")?.parse()?; + let dimension = format!("minecraft:{}", args.next().ok_or("dimension")?); + let data = GeneratorData::load(&resources.join("worldgen"), registry(&resources)?)?; + let generator = OverworldGenerator::for_dimension(data, seed, "minecraft:normal", &dimension)?; + let mut worker = generator.worker(); + for target in args { + let (x, z) = target.split_once(',').ok_or("target cx,cz")?; + let chunk = ChunkPos::new(x.parse()?, z.parse()?); + for start in worker.structure_starts(chunk) { + if start.chunk != chunk { + continue; + } + println!("start {} {} {}", start.name, chunk.x, chunk.z); + for piece in &start.pieces { + let b = piece.bounding_box(); + let placed = match piece { + Piece::Pool(p) => format!( + "{} {} {} {} {} {}", + element(&p.element), + rotation(p.rotation), + p.position[0], + p.position[1], + p.position[2], + p.ground_level_delta + ), + Piece::Legacy(_) => "- - - - - -".into(), + }; + println!( + "piece {} {placed} {} {} {} {} {} {}", + piece.type_name(), + b.min[0], + b.min[1], + b.min[2], + b.max[0], + b.max[1], + b.max[2] + ); + } + } + } + Ok(()) +} 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/crates/horizon-world/src/worldgen/structure.rs b/crates/horizon-world/src/worldgen/structure.rs index 405073450..d9b037808 100644 --- a/crates/horizon-world/src/worldgen/structure.rs +++ b/crates/horizon-world/src/worldgen/structure.rs @@ -347,14 +347,16 @@ impl StructureResources { .read_to_end(&mut raw) .ok()?; let tag = nbt::read_named(&raw, Limits::templates()).ok()?.0.tag; - Some(Arc::new(StructureTemplate::from_nbt( + Some(StructureTemplate::from_nbt( &tag, self.registry, &self.transforms, - ))) + )) }); // StructureTemplateManager.getOrCreate: missing templates are empty. - let loaded = loaded.or_else(|| Some(Arc::new(StructureTemplate::empty()))); + let mut loaded = loaded.unwrap_or_else(StructureTemplate::empty); + loaded.location = id.as_str().into(); + let loaded = Some(Arc::new(loaded)); self.templates.write().unwrap().insert(id, loaded.clone()); loaded } diff --git a/crates/horizon-world/src/worldgen/structure/jigsaw.rs b/crates/horizon-world/src/worldgen/structure/jigsaw.rs index 54ebcdd8b..87a551c05 100644 --- a/crates/horizon-world/src/worldgen/structure/jigsaw.rs +++ b/crates/horizon-world/src/worldgen/structure/jigsaw.rs @@ -122,7 +122,11 @@ impl PoolElement { }; Ok(match kind { "minecraft:empty_pool_element" => Self::Empty, - "minecraft:single_pool_element" | "minecraft:legacy_single_pool_element" => { + // YUNG's API's element places what a single element places; its + // `name` and `max_count` are the pool entry's (`Pool::limits`). + "minecraft:single_pool_element" + | "minecraft:legacy_single_pool_element" + | "yungsapi:yung_single_element" => { let location = value["location"] .as_str() .ok_or(DecodeError::Field("location"))?; @@ -336,6 +340,9 @@ pub struct Pool { pub(super) templates: Vec>, /// The elements with their weights, in file order (`rawTemplates`). pub(super) raw: Vec<(Arc, i32)>, + /// Per entry of `raw`: a YUNG element's `name` and `max_count`, the most + /// pieces of that name in one start. + limits: Vec, i32)>>, pub(super) fallback: String, max_size: OnceLock, } @@ -354,6 +361,16 @@ impl Pool { shuffle(&mut copy, random); copy } + /// YUNG's API's pick: `nextInt` of the entries' total weight, walked in + /// `order` (indices into `raw`); the entry that takes it below zero. + fn weighted(&self, order: &[usize], random: &mut impl RandomSource) -> Option { + let total: i32 = order.iter().map(|&i| self.raw[i].1).sum(); + let mut pick = random.next_int_bound(total).ok()?; + order.iter().position(|&i| { + pick -= self.raw[i].1; + pick < 0 + }) + } pub(super) fn max_size(&self) -> i32 { *self.max_size.get_or_init(|| { self.templates @@ -393,7 +410,7 @@ impl Pools { } let pool = self.raw.get(name).and_then(|json| { let value: Value = serde_json::from_str(json).ok()?; - let (mut templates, mut raw) = (Vec::new(), Vec::new()); + let (mut templates, mut raw, mut limits) = (Vec::new(), Vec::new(), Vec::new()); for entry in value["elements"].as_array()? { let element = match PoolElement::decode(&entry["element"], resources, bindings, None) { @@ -410,10 +427,22 @@ impl Pools { templates.push(element.clone()); } raw.push((element, weight as i32)); + let fields = &entry["element"]; + limits.push( + match (fields["name"].as_str(), fields["max_count"].as_i64()) { + (Some(name), Some(max)) + if fields["element_type"] == "yungsapi:yung_single_element" => + { + Some((name.into(), max as i32)) + } + _ => None, + }, + ); } Some(Arc::new(Pool { templates, raw, + limits, fallback: value["fallback"] .as_str() .unwrap_or("minecraft:empty") @@ -587,6 +616,93 @@ pub trait JigsawContext { /// couldStructureExistInColumn over inclusive block Y bounds. fn column_has_valid_biome(&mut self, x: i32, z: i32, min_y: i32, max_y: i32) -> bool; } +/// How a jigsaw structure draws its pieces. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Draws { + /// JigsawPlacement's. + Vanilla, + /// YUNG's API's `yungsapi:yung_jigsaw` (spec-yungsapi §2.1, §3.1): pools + /// are drawn by weight from their file entries, without replacement, and + /// an element at its `max_count` is skipped. + Yung, +} + +/// The elements a jigsaw tries, in order. +enum Candidates { + /// Vanilla: the target pool's weight-expanded elements, then the + /// fallback's, each shuffled up front. + Listed(std::vec::IntoIter>), + /// YUNG's: weighted picks from each pool in turn (the fallback's only + /// once the target's are spent), each pool's entries shuffled when it + /// is reached. + Weighted { + pools: Vec>, + current: Option<(Arc, Vec)>, + }, +} +impl Candidates { + fn new( + draws: Draws, + target: &Arc, + fallback: &Arc, + below_max_depth: bool, + random: &mut impl RandomSource, + ) -> Self { + let pools = if below_max_depth { + vec![target.clone(), fallback.clone()] + } else { + vec![fallback.clone()] + }; + match draws { + Draws::Vanilla => Self::Listed( + pools + .iter() + .flat_map(|pool| pool.shuffled(random)) + .collect::>() + .into_iter(), + ), + Draws::Yung => Self::Weighted { + pools: pools.into_iter().rev().collect(), + current: None, + }, + } + } + /// The next element to try, with its YUNG name and limit. + fn next( + &mut self, + counts: &HashMap, i32>, + random: &mut impl RandomSource, + ) -> Option<(Arc, Option>)> { + match self { + Self::Listed(elements) => elements.next().map(|e| (e, None)), + Self::Weighted { pools, current } => loop { + let (pool, order) = match current { + Some((pool, order)) if !order.is_empty() => (pool, order), + _ => { + let pool = pools.pop()?; + let mut order: Vec = (0..pool.raw.len()).collect(); + shuffle(&mut order, random); + *current = Some((pool, order)); + continue; + } + }; + let Some(at) = pool.weighted(order, random) else { + order.clear(); + continue; + }; + let entry = order.remove(at); + let limit = pool.limits[entry].clone(); + if let Some((name, max)) = &limit + && counts.get(name).copied().unwrap_or(0) >= *max + { + continue; + } + return Some((pool.raw[entry].0.clone(), limit.map(|(name, _)| name))); + }, + } + } +} + pub struct JigsawConfig<'a> { pub start_pool: &'a str, pub start_jigsaw: Option<&'a str>, @@ -628,6 +744,30 @@ pub fn assemble( bindings: &FeatureBlockBindings<'_>, random: &mut impl RandomSource, position: [i32; 3], +) -> Option<([i32; 3], Vec)> { + assemble_drawing( + Draws::Vanilla, + config, + context, + pools, + resources, + bindings, + random, + position, + ) +} + +/// [`assemble`] with the given draws. +#[allow(clippy::too_many_arguments)] +pub fn assemble_drawing( + draws: Draws, + config: &JigsawConfig<'_>, + context: &mut impl JigsawContext, + pools: &Pools, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + random: &mut impl RandomSource, + position: [i32; 3], ) -> Option<([i32; 3], Vec)> { let alias = |name: &str| { config @@ -636,9 +776,24 @@ pub fn assemble( .cloned() .unwrap_or_else(|| name.to_owned()) }; - let rotation = Rotation::random(random); let center_pool = pools.get(&alias(config.start_pool), resources, bindings)?; - let element = center_pool.random_template(random); + let (rotation, element, limit) = match draws { + Draws::Vanilla => { + let rotation = Rotation::random(random); + (rotation, center_pool.random_template(random), None) + } + // The entries shuffled, then the rotation, then a weighted pick in + // the shuffled order. + Draws::Yung => { + let mut order: Vec = (0..center_pool.raw.len()).collect(); + shuffle(&mut order, random); + let rotation = Rotation::random(random); + let entry = order[center_pool.weighted(&order, random)?]; + let (element, _) = ¢er_pool.raw[entry]; + let limit = center_pool.limits[entry].clone().map(|(name, _)| name); + (rotation, element.clone(), limit) + } + }; if matches!(element.as_ref(), PoolElement::Empty) { return None; } @@ -691,7 +846,10 @@ pub fn assemble( let low_y = (cy - v).max(context.min_y() + config.padding[0]); let high_y = (cy + v + 1).min(context.max_y() + 1 - config.padding[1]); let container = BoundingBox::new([cx - h, low_y, cz - h], [cx + h, high_y - 1, cz + h]); - add_children( + let counts = limit.into_iter().map(|name| (name, 1)).collect(); + add_children_drawing( + draws, + counts, config, context, pools, @@ -719,6 +877,32 @@ pub(super) fn add_children( random: &mut impl RandomSource, pieces: &mut Vec, container: BoundingBox, +) { + add_children_drawing( + Draws::Vanilla, + HashMap::new(), + config, + context, + pools, + resources, + bindings, + random, + pieces, + container, + ); +} +#[allow(clippy::too_many_arguments)] +fn add_children_drawing( + draws: Draws, + counts: HashMap, i32>, + config: &JigsawConfig<'_>, + context: &mut impl JigsawContext, + pools: &Pools, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + random: &mut impl RandomSource, + pieces: &mut Vec, + container: BoundingBox, ) { let free = Rc::new(RefCell::new(Free { container, @@ -731,6 +915,8 @@ pub(super) fn add_children( bindings, pieces, queue: BTreeMap::new(), + draws, + counts, }; placer.children(0, free, 0, context, random); while let Some(state) = placer.next() { @@ -745,6 +931,9 @@ struct Placer<'a, 'p> { pieces: &'p mut Vec, /// SequencedPriorityIterator: highest priority first, FIFO within one. queue: BTreeMap>, + draws: Draws, + /// Pieces placed per YUNG element name. + counts: HashMap, i32>, } impl Placer<'_, '_> { fn next(&mut self) -> Option { @@ -816,12 +1005,14 @@ impl Placer<'_, '_> { } else { context_free.clone() }; - let mut targets = Vec::new(); - if depth != self.config.max_depth { - targets.extend(target_pool.shuffled(random)); - } - targets.extend(fallback.shuffled(random)); - for target in targets { + let mut candidates = Candidates::new( + self.draws, + &target_pool, + &fallback, + depth != self.config.max_depth, + random, + ); + while let Some((target, name)) = candidates.next(&self.counts, random) { if matches!(target.as_ref(), PoolElement::Empty) { break; } @@ -924,6 +1115,9 @@ impl Placer<'_, '_> { }], waterlogging: self.config.waterlogging, }); + if let Some(name) = name { + *self.counts.entry(name).or_default() += 1; + } if depth < self.config.max_depth { self.queue .entry(jigsaw.placement_priority) diff --git a/crates/horizon-world/src/worldgen/structure/start.rs b/crates/horizon-world/src/worldgen/structure/start.rs index 70e457b2e..44f4b70f4 100644 --- a/crates/horizon-world/src/worldgen/structure/start.rs +++ b/crates/horizon-world/src/worldgen/structure/start.rs @@ -2,7 +2,9 @@ //! references, terrain adaptation and per-chunk piece placement. use super::{ BoundingBox, StructureResources, - jigsaw::{JigsawConfig, JigsawContext, PlaceFeature, PoolPiece, Pools, Projection, assemble}, + jigsaw::{ + JigsawConfig, JigsawContext, PlaceFeature, PoolPiece, Pools, Projection, assemble_drawing, + }, legacy::{LegacyPiece, PieceContext}, }; use crate::{ @@ -59,6 +61,8 @@ pub struct JigsawDef { checks: super::start_checks::StartChecks, /// Laid out by YUNG's API's assembler (`"horizon:yungsapi"`). yung: Option, + /// Vanilla's draws, or YUNG's API's for `yungsapi:yung_jigsaw`. + draws: super::jigsaw::Draws, /// Laid out by Repurposed Structures' and Moog's piece-limited /// assembler (`"horizon:piece_limited"`). piece_limited: Option, @@ -320,8 +324,13 @@ impl StructureRegistry { .flatten() .filter_map(|t| Some(t.as_str()?.to_owned())), ); + let draws = match v["type"].as_str() { + Some("yungsapi:yung_jigsaw") => super::jigsaw::Draws::Yung, + _ => super::jigsaw::Draws::Vanilla, + }; let kind = match v["type"].as_str().unwrap_or_default() { - "minecraft:jigsaw" => StructureKind::Jigsaw(JigsawDef { + "minecraft:jigsaw" | "yungsapi:yung_jigsaw" => StructureKind::Jigsaw(JigsawDef { + draws, start_pool: v["start_pool"].as_str().unwrap_or_default().to_owned(), start_jigsaw: v["start_jigsaw_name"].as_str().map(str::to_owned), max_depth: v["size"].as_i64().unwrap_or(0) as i32, @@ -923,7 +932,8 @@ fn try_generate( &mut random, start, )?, - (None, None) => assemble( + (None, None) => assemble_drawing( + jigsaw.draws, &config, context, ®istry.pools, diff --git a/crates/horizon-world/src/worldgen/structure/template.rs b/crates/horizon-world/src/worldgen/structure/template.rs index 149033b8c..92c8c5676 100644 --- a/crates/horizon-world/src/worldgen/structure/template.rs +++ b/crates/horizon-world/src/worldgen/structure/template.rs @@ -5,7 +5,7 @@ use crate::{ nbt::{Compound, Tag}, registry::{BlockRegistry, BlockStateId}, }; -use std::sync::OnceLock; +use std::sync::{Arc, OnceLock}; #[derive(Clone, Debug, PartialEq)] pub struct BlockInfo { @@ -42,6 +42,9 @@ pub struct EntityInfo { } #[derive(Debug)] pub struct StructureTemplate { + /// The id it was loaded under (`StructureResources::template`); empty + /// for a template read from elsewhere. + pub location: Arc, pub size: [i32; 3], palettes: Vec, pub entities: Vec, @@ -129,6 +132,7 @@ impl StructureTemplate { /// A new, never-loaded template: zero size and no palettes. pub fn empty() -> Self { Self { + location: "".into(), size: [0; 3], palettes: Vec::new(), entities: Vec::new(), @@ -231,6 +235,7 @@ impl StructureTemplate { } } Self { + location: "".into(), size, palettes, entities, diff --git a/docs/README.md b/docs/README.md index a5ddf5593..1450ba388 100644 --- a/docs/README.md +++ b/docs/README.md @@ -20,6 +20,7 @@ To play, use [the launcher](../launcher/README.md); the project site is [playhor - [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/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/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/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/launcher/src/backend.rs b/launcher/src/backend.rs index 104a086a5..2f63951c8 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -282,11 +282,6 @@ pub fn releases() -> Result, String> { Ok(parse_releases(&release_list()?, ASSET, is_game_tag)) } -/// Published launcher releases (`launcher-v…`), newest first, with this platform's archive. -pub fn launcher_releases() -> Result, String> { - Ok(launcher_releases_in(&release_list()?)) -} - /// The launcher releases in `list` (the newest 100 releases). Game releases come out several times /// a day, so the newest launcher release can be older than all of those: then the newest /// `launcher@` and `launcher-v` tags are looked up one by one (a draft's tag is skipped: it has no @@ -1027,21 +1022,18 @@ fn download_for_owner( } } -/// A JDK of at least `major` for the preparation. `None` when horizon-prepare finds one by -/// itself (JAVA_HOME, the PATH, an installed JDK): the preparation then runs as before, in an -/// unchanged environment (a JDK found on the PATH can be a stub such as macOS's -/// /usr/bin/javac, whose folder is no Java home: `JAVA_HOME=/usr` makes it call itself -/// forever). Else the home of the Java the official launcher downloaded into one of the -/// `games` folders, else of Minecraft's own Java downloaded from Mojang into Horizon's game -/// folder, the runtime the version JSON at `manifest` names (Mojang's runtimes are whole JDKs). +/// The home of a JDK whose compiler and runtime support `major`. Forward even an installed +/// JDK to external preparers: older versions may otherwise rediscover incompatible PATH tools. +/// Else try the official launcher's Java in `games`, then download the runtime named by +/// `manifest` into Horizon's game folder (Mojang's runtimes are whole JDKs). fn java( major: i64, games: &[PathBuf], manifest: &Path, log: &dyn Fn(String), -) -> Result, String> { - if horizon_prepare::java::find(major, &[]).is_ok() { - return Ok(None); +) -> Result { + if let Ok(jdk) = horizon_prepare::java::find(major, &[]) { + return Ok(jdk.home()); } let mut runtimes: Vec = Vec::new(); for home in games @@ -1053,7 +1045,7 @@ fn java( } } let missing = match horizon_prepare::java::find(major, &runtimes) { - Ok(jdk) => return Ok(Some(jdk.home())), + Ok(jdk) => return Ok(jdk.home()), Err(e) => e, }; let component = read_json(manifest) @@ -1078,7 +1070,7 @@ fn java( let home = mojang::java_runtime(&component, &runtime, 8, &fetch, log).map_err(|e| { format!("{missing}\n • Horizon also tried to download Minecraft's own Java from Mojang, but: {e}") })?; - horizon_prepare::java::find(major, &[home]).map(|jdk| Some(jdk.home())) + horizon_prepare::java::find(major, &[home]).map(|jdk| jdk.home()) } /// The dynamic loader glibc programs on x86-64 Linux start through. @@ -1201,14 +1193,12 @@ pub fn preparer( import: !reused, minecraft_dir: Some(minecraft.clone()), server_jar: (!reused).then_some(jar), - java_home: java_home.clone(), + java_home: Some(java_home.clone()), }; return Ok((Preparer::InProcess(options), minecraft)); } let mut cmd = Command::new(binary); - if let Some(home) = &java_home { - with_java(&mut cmd, home); - } + with_java(&mut cmd, &java_home); cmd.current_dir(&dir).arg("--root").arg(&dir); if !reused { cmd.args(["--prepare", "--server-jar"]).arg(&jar); @@ -1217,9 +1207,7 @@ pub fn preparer( return Ok((Preparer::Process(cmd), minecraft)); } let mut cmd = Command::new(python.unwrap()); - if let Some(home) = &java_home { - with_java(&mut cmd, home); - } + with_java(&mut cmd, &java_home); cmd.current_dir(&dir) .args(["-u", "tools/prepare_native_client.py"]); if !reused { @@ -2175,6 +2163,8 @@ pub enum Msg { Links(Links), Progress(String, f32), Installed(String, Result<(), String>), + /// A version's files are gone (or could not be deleted). + Removed(String, Result<(), String>), Line(Job, String), Exit(Job, Result<(), String>), Updates(Result), @@ -2341,6 +2331,10 @@ impl Settings { #[path = "backend/release_loading_tests.rs"] mod release_loading_tests; +#[cfg(test)] +#[path = "backend/java_tests.rs"] +mod java_tests; + #[cfg(test)] mod tests { use super::*; diff --git a/launcher/src/backend/java_tests.rs b/launcher/src/backend/java_tests.rs new file mode 100644 index 000000000..75914a1b0 --- /dev/null +++ b/launcher/src/backend/java_tests.rs @@ -0,0 +1,85 @@ +use super::*; + +#[test] +fn selected_jdk_reaches_external_preparers() { + const CHILD: &str = "HORIZON_LAUNCHER_JAVA_TEST"; + if let Some(root) = std::env::var_os(CHILD) { + let root = PathBuf::from(root); + let home = java(25, &[], &root.join("missing.json"), &|_| {}).unwrap(); + assert_eq!( + fs::canonicalize(&home).unwrap(), + fs::canonicalize(root.join("jdk25")).unwrap() + ); + // An older preparer invokes Java tools by name; both must now resolve to this JDK. + for name in ["java", "javac"] { + let mut cmd = crate::process::command(name); + with_java(&mut cmd, &home); + let output = cmd.arg("-version").output().unwrap(); + assert!(output.status.success()); + let text = String::from_utf8_lossy(&output.stdout).into_owned() + + &String::from_utf8_lossy(&output.stderr); + assert!(text.contains("25.0.1"), "{name}: {text}"); + assert_eq!( + cmd.get_envs() + .find(|(key, _)| *key == "JAVA_HOME") + .unwrap() + .1, + Some(home.as_os_str()) + ); + } + return; + } + + let root = std::env::temp_dir().join(format!("horizon-launcher-java-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + let executable = + |bin: &Path, name: &str| bin.join(format!("{name}{}", std::env::consts::EXE_SUFFIX)); + let probe = executable(&root, "probe"); + let source = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../crates/horizon-prepare/tests/support/java_probe.rs"); + let output = crate::process::command("rustc") + .arg(source) + .arg("-o") + .arg(&probe) + .output() + .unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + for (home, compiler, runtime) in [ + ("jre21", None, "21.0.1"), + ("jdk25", Some("25.0.1"), "25.0.1"), + ] { + let bin = root.join(home).join("bin"); + fs::create_dir_all(&bin).unwrap(); + for (name, version) in [("javac", compiler), ("java", Some(runtime))] { + if let Some(version) = version { + fs::copy(&probe, executable(&bin, name)).unwrap(); + fs::write(bin.join(format!("{name}.version")), version).unwrap(); + } + } + } + let output = crate::process::command(std::env::current_exe().unwrap()) + .args([ + "--exact", + "backend::java_tests::selected_jdk_reaches_external_preparers", + "--nocapture", + ]) + .env(CHILD, &root) + .env_remove("JAVA_HOME") + .env( + "PATH", + std::env::join_paths([root.join("jre21/bin"), root.join("jdk25/bin")]).unwrap(), + ) + .output() + .unwrap(); + assert!( + output.status.success(), + "{}\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + fs::remove_dir_all(root).unwrap(); +} diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 4a68ecdef..0bcbc4011 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -144,6 +144,9 @@ struct Launcher { releases: Load>, installed: Vec, installing: Option<(String, f32)>, + /// The version being deleted on a background thread. It is already out of `installed`, so + /// nothing can launch, select or prepare it, and its row can't install or remove it again. + removing: Option, install_error: Option<(String, String)>, confirm_remove: Option, picker_open: bool, @@ -286,6 +289,7 @@ impl Launcher { releases: Load::Loading, installed, installing: None, + removing: None, install_error: None, confirm_remove: None, picker_open: false, @@ -415,7 +419,7 @@ impl Launcher { let Some(release) = self.updates.horizon.clone() else { return; }; - if self.installing.is_some() { + if self.installing.is_some() || self.removing.as_ref() == Some(&release.tag) { return; } let select = @@ -542,6 +546,17 @@ impl Launcher { Err(e) => self.install_error = Some((tag, e)), } } + Msg::Removed(tag, result) => { + if self.removing.as_ref() == Some(&tag) { + self.removing = None; + } + self.installed = backend::installed(); + self.settings.selected = + selection_after_removal(&self.installed, Settings::load().selected); + if let Err(e) = result { + self.install_error = Some((tag, e)); + } + } Msg::Updates(Ok(updates)) => { self.update_error = None; self.updates = updates; @@ -706,7 +721,7 @@ impl Launcher { } fn install(&mut self, release: &Release) { - if release.asset.is_none() { + if release.asset.is_none() || self.removing.as_ref() == Some(&release.tag) { return; } let (release, tx) = (release.clone(), self.tx.clone()); @@ -724,15 +739,26 @@ impl Launcher { }); } + /// Deletes an installed version on a background thread: a version is thousands of files and + /// the window must keep drawing meanwhile. `Msg::Removed` ends it. fn remove(&mut self, tag: &str) { - if let Err(e) = backend::remove_version(tag) { - self.install_error = Some((tag.to_string(), e)); - } self.confirm_remove = None; - self.installed = backend::installed(); - self.settings.selected = Settings::load() - .selected - .or_else(|| self.installed.first().cloned()); + if self.removing.is_some() + || self.installing.as_ref().is_some_and(|(t, _)| t == tag) + || !self.installed.iter().any(|t| t == tag) + { + return; + } + self.install_error = None; + self.removing = Some(tag.to_string()); + self.installed.retain(|t| t != tag); + self.settings.selected = + selection_after_removal(&self.installed, self.settings.selected.take()); + let (tag, tx) = (tag.to_string(), self.tx.clone()); + std::thread::spawn(move || { + let result = backend::remove_version(&tag); + let _ = tx.send(Msg::Removed(tag, result)); + }); } fn prepare(&mut self) { @@ -1158,6 +1184,14 @@ fn segments( })) } +/// The selected version once one has been removed: the saved choice if it is still installed, +/// else the newest left. +fn selection_after_removal(installed: &[String], saved: Option) -> Option { + saved + .filter(|s| installed.contains(s)) + .or_else(|| installed.first().cloned()) +} + fn disabled(b: Stateful
) -> Stateful
{ b.opacity(theme::DISABLED).cursor_default().tab_stop(false) } @@ -2923,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, @@ -2959,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()); @@ -3587,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/mods/horizon/src/test/java/dev/horizonlab/parity/LocatorBarClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/LocatorBarClient.java index 3eb241d5e..76a951894 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/LocatorBarClient.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/LocatorBarClient.java @@ -5,9 +5,12 @@ import io.netty.buffer.Unpooled; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.io.PrintStream; import java.io.PrintWriter; import java.net.InetSocketAddress; import java.net.Socket; @@ -78,7 +81,10 @@ import net.minecraft.world.phys.Vec3; * on|off} (the shift key, as ServerboundPlayerInputPacket), {@code fly NAME * on|off} (ServerboundPlayerAbilitiesPacket), {@code still NAME} (the * position reminder LocalPlayer.sendPosition sends every 20 ticks standing - * still), {@code quit NAME}, {@code + * still), {@code sync NAME} (runs {@code time query gametime}, whose reply is + * not recorded, and prints {@code synced NAME} once it is back: the server has + * handled everything this player sent before, and everything the server sent + * this player before the reply has been recorded), {@code quit NAME}, {@code * players on|off} (whether each player also records the other players added * to and removed from its level, and its own respawns into a dimension), * {@code chat on|off} (whether the system chat each player receives is @@ -95,6 +101,8 @@ public final class LocatorBarClient { private static final Map NAMES = new LinkedHashMap<>(); public static void main(String[] args) throws Exception { + // Bootstrap sends System.out to the logger: `synced` lines go to the real stdout. + PrintStream stdout = new PrintStream(new FileOutputStream(FileDescriptor.out), true, StandardCharsets.UTF_8); ParityData.init(); String host = args[0]; int port = Integer.parseInt(args[1]); @@ -122,6 +130,13 @@ public final class LocatorBarClient { players.get(w[1]).send(new net.minecraft.network.protocol.game.ServerboundPlayerAbilitiesPacket(abilities)); } case "still" -> players.get(w[1]).still(); + case "sync" -> { + try { + players.get(w[1]).sync(); + } finally { + stdout.println("synced " + w[1]); + } + } case "quit" -> players.get(w[1]).close(); case "players" -> LocatorBarClient.players = w[1].equals("on"); case "chat" -> chat = w[1].equals("on"); @@ -189,6 +204,7 @@ public final class LocatorBarClient { private final Map seen = new java.util.HashMap<>(); private final Object replyLock = new Object(); private int replies; + private int syncs; Player(String name) { this.name = name; @@ -211,6 +227,23 @@ public final class LocatorBarClient { } } + /** A round trip through the server thread, its reply left out of the transcript. */ + void sync() throws Exception { + synchronized (replyLock) { + int before = syncs; + send(new ServerboundChatCommandPacket("time query gametime")); + long until = System.nanoTime() + 30_000_000_000L; + while (syncs == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to sync"); + return; + } + replyLock.wait(left); + } + } + } + void record(String line) { synchronized (lines) { lines.add("step=" + step + " " + line); @@ -312,6 +345,13 @@ public final class LocatorBarClient { seen.clear(); } else if (p instanceof ClientboundTrackedWaypointPacket) { record(waypoint(r.payload)); + } else if (p instanceof ClientboundSystemChatPacket c + && c.content().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t + && t.getKey().equals("commands.time.query.gametime")) { + synchronized (replyLock) { + syncs++; + replyLock.notifyAll(); + } } else if (p instanceof ClientboundSystemChatPacket c) { if (chat) { record("chat " + (c.overlay() ? "overlay " : "") + net.minecraft.network.chat.ComponentSerialization.CODEC diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaItemWireOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaItemWireOracle.java new file mode 100644 index 000000000..cc95bb311 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaItemWireOracle.java @@ -0,0 +1,155 @@ +package dev.horizonlab.parity; + +import io.netty.buffer.Unpooled; +import it.unimi.dsi.fastutil.objects.Reference2ObjectMap; +import it.unimi.dsi.fastutil.objects.Reference2ObjectMaps; +import java.io.PrintWriter; +import java.lang.reflect.Field; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.HexFormat; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Optional; +import net.minecraft.core.Holder; +import net.minecraft.core.component.DataComponentPatch; +import net.minecraft.core.component.DataComponentType; +import net.minecraft.core.component.DataComponents; +import net.minecraft.core.component.TypedDataComponent; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.SoundEvents; +import net.minecraft.world.entity.decoration.painting.PaintingVariant; +import net.minecraft.world.item.JukeboxPlayable; +import net.minecraft.world.item.JukeboxSong; +import net.minecraft.world.item.component.MapPostProcessing; +import net.minecraft.util.Unit; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.Items; + +/** + * Item stacks as a server sends them (ItemStack.OPTIONAL_STREAM_CODEC), for + * every data component: each default component value of every vanilla item + * set on a stick (so it is in the patch), the SNBT fixtures given in a file + * (one `labelstack SNBT` per line), and a few patches built directly. + * Prints one JSON line per stack: its label, the encoded bytes in hex and the + * patch's component type ids in encoding order (added, then removed), or + * the error. + */ +public final class VanillaItemWireOracle { + private static final int PER_TYPE = 12; + + public static void main(String[] args) throws Exception { + ParityData.init(); + List fixtures = new ArrayList<>(); + for (String line : Files.readAllLines(Path.of(args[0]))) { + if (line.isBlank() || line.startsWith("#")) continue; + fixtures.add(line.split("\t", 2)); + } + try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1])))) { + // Each distinct default value, once per component type and + // encoding, and at most PER_TYPE of them for one type. + Set seen = new HashSet<>(); + Map, Integer> perType = new HashMap<>(); + for (var item : BuiltInRegistries.ITEM) { + for (TypedDataComponent c : item.components()) { + ItemStack stack = new ItemStack(Items.STICK); + if (!set(stack, c)) continue; + String hex = encode(stack); + if (hex == null || perType.getOrDefault(c.type(), 0) >= PER_TYPE) continue; + if (!seen.add(BuiltInRegistries.DATA_COMPONENT_TYPE.getKey(c.type()) + hex)) continue; + perType.merge(c.type(), 1, Integer::sum); + print(out, "default " + BuiltInRegistries.ITEM.getKey(item) + " " + BuiltInRegistries.DATA_COMPONENT_TYPE.getKey(c.type()), stack); + } + } + for (String[] f : fixtures) { + try { + print(out, f[0], ParityData.stack(f[1])); + } catch (Exception e) { + out.println("{\"label\":" + json(f[0]) + ",\"error\":" + json(String.valueOf(e)) + "}"); + } + } + // Components without a persistent codec, direct holders item SNBT + // can't name, and removals. + ItemStack direct = new ItemStack(Items.STICK); + direct.set(DataComponents.ADDITIONAL_TRADE_COST, 4); + direct.set(DataComponents.MAP_POST_PROCESSING, MapPostProcessing.SCALE); + direct.set(DataComponents.JUKEBOX_PLAYABLE, new JukeboxPlayable(Holder.direct( + new JukeboxSong(SoundEvents.ARMOR_EQUIP_CHAIN, Component.literal("S"), 10f, 3)))); + direct.set(DataComponents.PAINTING_VARIANT, Holder.direct(new PaintingVariant( + 2, 1, Identifier.withDefaultNamespace("kebab"), Optional.of(Component.literal("T")), Optional.empty()))); + print(out, "non-persistent and direct", direct); + ItemStack locked = new ItemStack(Items.STONE); + locked.set(DataComponents.CREATIVE_SLOT_LOCK, Unit.INSTANCE); + print(out, "creative_slot_lock", locked); + ItemStack removed = new ItemStack(Items.APPLE, 3); + removed.remove(DataComponents.FOOD); + removed.remove(DataComponents.CONSUMABLE); + removed.set(DataComponents.DAMAGE, 4); + print(out, "removed food and consumable", removed); + print(out, "empty", ItemStack.EMPTY); + } + } + + @SuppressWarnings("unchecked") + private static boolean set(ItemStack stack, TypedDataComponent c) { + if (stack.getPrototype().has(c.type()) && java.util.Objects.equals(stack.getPrototype().get(c.type()), c.value())) return false; + stack.set((DataComponentType) c.type(), c.value()); + return true; + } + + private static String encode(ItemStack stack) { + var buf = new RegistryFriendlyByteBuf(Unpooled.buffer(), ParityData.access); + try { + ItemStack.OPTIONAL_STREAM_CODEC.encode(buf, stack); + } catch (RuntimeException e) { + return null; + } + byte[] bytes = new byte[buf.readableBytes()]; + buf.readBytes(bytes); + return HexFormat.of().formatHex(bytes); + } + + private static void print(PrintWriter out, String label, ItemStack stack) { + String hex = encode(stack); + if (hex == null) { + out.println("{\"label\":" + json(label) + ",\"error\":\"encode failed\"}"); + return; + } + // DataComponentPatch's encoding order: its map's fast iteration, added + // components, then removals. + StringBuilder kinds = new StringBuilder(); + StringBuilder removed = new StringBuilder(); + for (var e : Reference2ObjectMaps.fastIterable(patchMap(stack.getComponentsPatch()))) { + // Removed (package-private) marks a removal. + StringBuilder to = e.getValue().getClass().getName().equals("net.minecraft.core.component.Removed") ? removed : kinds; + to.append(to.isEmpty() ? "" : ",").append(id(e.getKey())); + } + out.println("{\"label\":" + json(label) + ",\"hex\":\"" + hex + "\",\"added\":[" + kinds + "],\"removed\":[" + removed + "]}"); + } + + @SuppressWarnings("unchecked") + private static Reference2ObjectMap, Object> patchMap(DataComponentPatch patch) { + try { + Field map = DataComponentPatch.class.getDeclaredField("map"); + map.setAccessible(true); + return (Reference2ObjectMap, Object>) map.get(patch); + } catch (ReflectiveOperationException e) { + throw new IllegalStateException(e); + } + } + + private static int id(DataComponentType type) { + return BuiltInRegistries.DATA_COMPONENT_TYPE.getId(type); + } + + private static String json(String s) { + return "\"" + s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n") + "\""; + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStopSoundWireOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStopSoundWireOracle.java new file mode 100644 index 000000000..aebeba486 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStopSoundWireOracle.java @@ -0,0 +1,30 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import io.netty.buffer.Unpooled; +import java.nio.file.*; +import java.util.*; +import net.minecraft.network.FriendlyByteBuf; +import net.minecraft.network.protocol.game.ClientboundStopSoundPacket; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.SoundSource; + +/** Every source/event selection combination through the native stream codec. */ +public final class VanillaStopSoundWireOracle { + public static void main(String[] args) throws Exception { + var out = new ArrayList(); + for (int source = -1; source < SoundSource.values().length; source++) { + for (String sound : new String[]{null, "minecraft:entity.pig.ambient", "example:custom"}) { + var packet = new ClientboundStopSoundPacket(sound == null ? null : Identifier.parse(sound), source < 0 ? null : SoundSource.values()[source]); + var buf = new FriendlyByteBuf(Unpooled.buffer()); + ClientboundStopSoundPacket.STREAM_CODEC.encode(buf, packet); + byte[] bytes = new byte[buf.readableBytes()]; buf.readBytes(bytes); buf.release(); + var result = new JsonObject(); result.addProperty("wire", HexFormat.of().formatHex(bytes)); + result.add("source", source < 0 ? JsonNull.INSTANCE : new JsonPrimitive(source)); + result.add("sound", sound == null ? JsonNull.INSTANCE : new JsonPrimitive(sound)); + out.add(new Gson().toJson(result)); + } + } + Files.write(Path.of(args[0]), out); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayOracle.java new file mode 100644 index 000000000..deb125b41 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayOracle.java @@ -0,0 +1,76 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import io.netty.buffer.Unpooled; +import java.nio.file.*; +import java.lang.reflect.*; +import java.util.*; +import net.minecraft.nbt.TagParser; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.chat.*; +import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket; +import net.minecraft.network.syncher.EntityDataAccessor; +import net.minecraft.world.entity.*; +import org.joml.*; + +/** Actual accessors/defaults and wire bytes, not a second implementation of their layout. */ +public final class VanillaTextDisplayOracle { + static final class Level extends net.minecraft.server.level.ServerLevel { + Level() { super(null, null, null, null, null, null, false, 0L, List.of(), false); } + @Override public int getNextEntityId() { return 7; } + @Override public net.minecraft.core.RegistryAccess registryAccess() { return ParityData.access; } + } + static final String[] KEYS = {"interpolation_delay", "interpolation_duration", "teleport_duration", + "translation", "scale", "left_rotation", "right_rotation", "billboard", "brightness", "view_range", + "shadow_radius", "shadow_strength", "width", "height", "glow_color", "text", "line_width", "background", "opacity", "flags"}; + static final String[] FIELDS = {"DATA_TRANSFORMATION_INTERPOLATION_START_DELTA_TICKS_ID", "DATA_TRANSFORMATION_INTERPOLATION_DURATION_ID", "DATA_POS_ROT_INTERPOLATION_DURATION_ID", + "DATA_TRANSLATION_ID", "DATA_SCALE_ID", "DATA_LEFT_ROTATION_ID", "DATA_RIGHT_ROTATION_ID", "DATA_BILLBOARD_RENDER_CONSTRAINTS_ID", "DATA_BRIGHTNESS_OVERRIDE_ID", "DATA_VIEW_RANGE_ID", + "DATA_SHADOW_RADIUS_ID", "DATA_SHADOW_STRENGTH_ID", "DATA_WIDTH_ID", "DATA_HEIGHT_ID", "DATA_GLOW_COLOR_OVERRIDE_ID", "DATA_TEXT_ID", "DATA_LINE_WIDTH_ID", "DATA_BACKGROUND_COLOR_ID", "DATA_TEXT_OPACITY_ID", "DATA_STYLE_FLAGS_ID"}; + static final Gson GSON = new Gson(); + + @SuppressWarnings({"rawtypes", "unchecked"}) + public static void main(String[] args) throws Exception { + ParityData.init(); + var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe"); + unsafeField.setAccessible(true); + Object unsafe = unsafeField.get(null); + var level = (Level) unsafe.getClass().getMethod("allocateInstance", Class.class).invoke(unsafe, Level.class); + var out = new ArrayList(); + for (String line : Files.readAllLines(Path.of(args[0]))) { + JsonObject input = JsonParser.parseString(line).getAsJsonObject(); + var type = net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse("minecraft:text_display")); + var display = new Display.TextDisplay(type, level); + var state = new JsonObject(); + for (int i = 0; i < KEYS.length; i++) { + Field field = (i < 15 ? Display.class : Display.TextDisplay.class).getDeclaredField(FIELDS[i]); + field.setAccessible(true); + EntityDataAccessor accessor = (EntityDataAccessor) field.get(null); + Object value = display.getEntityData().get(accessor); + if (input.has(KEYS[i])) { + JsonElement in = input.get(KEYS[i]); + if (value instanceof Integer) value = in.getAsInt(); + else if (value instanceof Float) value = in.getAsFloat(); + else if (value instanceof Byte) value = in.getAsByte(); + else if (value instanceof Vector3f) value = new Vector3f(in.getAsJsonArray().get(0).getAsFloat(), in.getAsJsonArray().get(1).getAsFloat(), in.getAsJsonArray().get(2).getAsFloat()); + else if (value instanceof Quaternionf) value = new Quaternionf(in.getAsJsonArray().get(0).getAsFloat(), in.getAsJsonArray().get(1).getAsFloat(), in.getAsJsonArray().get(2).getAsFloat(), in.getAsJsonArray().get(3).getAsFloat()); + else if (value instanceof Component) value = ComponentSerialization.CODEC.parse(ParityData.ops, TagParser.parseCompoundFully("{v:" + in + "}").get("v")).getOrThrow(); + display.getEntityData().set(accessor, value); + } + JsonElement encoded; + if (value instanceof Vector3f v) encoded = GSON.toJsonTree(new float[]{v.x, v.y, v.z}); + else if (value instanceof Quaternionf q) encoded = GSON.toJsonTree(new float[]{q.x, q.y, q.z, q.w}); + else if (value instanceof Component c) encoded = new JsonPrimitive(c.getString()); + else encoded = GSON.toJsonTree(value); + state.add(KEYS[i], encoded); + } + state.addProperty("alignment", Display.TextDisplay.getAlign(state.get("flags").getAsByte()).name()); + var values = display.getEntityData().getNonDefaultValues(); + var buf = new RegistryFriendlyByteBuf(Unpooled.buffer(), ParityData.access); + ClientboundSetEntityDataPacket.STREAM_CODEC.encode(buf, new ClientboundSetEntityDataPacket(7, values == null ? List.of() : values)); + byte[] bytes = new byte[buf.readableBytes()]; buf.readBytes(bytes); buf.release(); + var result = new JsonObject(); result.add("expected", state); result.addProperty("wire", HexFormat.of().formatHex(bytes)); + out.add(GSON.toJson(result)); + } + Files.write(Path.of(args[1]), out); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayTransformOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayTransformOracle.java new file mode 100644 index 000000000..04000b33a --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayTransformOracle.java @@ -0,0 +1,44 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import io.netty.buffer.Unpooled; +import java.nio.file.*; +import java.util.*; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket; +import net.minecraft.world.entity.Display; +import org.joml.*; + +/** Invoke the real client renderer's private billboard method without opening a window. */ +public final class VanillaTextDisplayTransformOracle { + public static void main(String[] args) throws Exception { + ParityData.init(); + var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe"); unsafeField.setAccessible(true); + Object unsafe = unsafeField.get(null); + var allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); + var level = (VanillaTextDisplayOracle.Level) allocate.invoke(unsafe, VanillaTextDisplayOracle.Level.class); + Class renderer = Class.forName("net.minecraft.client.renderer.entity.DisplayRenderer"); + Class concrete = Class.forName("net.minecraft.client.renderer.entity.DisplayRenderer$TextDisplayRenderer"); + Class renderState = Class.forName("net.minecraft.client.renderer.entity.state.DisplayEntityRenderState"); + Object instance = allocate.invoke(unsafe, concrete); + var orientation = renderer.getDeclaredMethod("calculateOrientation", Display.RenderState.class, renderState, Quaternionf.class); + orientation.setAccessible(true); + var fresh = Display.class.getDeclaredMethod("createFreshRenderState"); fresh.setAccessible(true); + var output = new ArrayList(); + var type = net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse("minecraft:text_display")); + for (String line : Files.readAllLines(Path.of(args[0]))) { + JsonObject input = JsonParser.parseString(line).getAsJsonObject(); + var display = new Display.TextDisplay(type, level); + var buf = new RegistryFriendlyByteBuf(Unpooled.wrappedBuffer(HexFormat.of().parseHex(input.get("wire").getAsString())), ParityData.access); + display.getEntityData().assignValues(ClientboundSetEntityDataPacket.STREAM_CODEC.decode(buf).packedItems()); buf.release(); + Object state = Class.forName("net.minecraft.client.renderer.entity.state.TextDisplayEntityRenderState").getConstructor().newInstance(); + String[] fields = {"entityYRot", "entityXRot", "cameraYRot", "cameraXRot"}; + for (int i=0;i<4;i++) renderState.getField(fields[i]).setFloat(state,input.getAsJsonArray("angles").get(i).getAsFloat()); + var data = (Display.RenderState) fresh.invoke(display); + var q = (Quaternionf) orientation.invoke(instance,data,state,new Quaternionf()); + float[] matrix = new Matrix4f().rotate(q).mul(data.transformation().get(1).getMatrix()).get(new float[16]); + output.add(new Gson().toJson(matrix)); + } + Files.write(Path.of(args[1]),output); + } +} 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_pre_push.py b/tests/test_pre_push.py new file mode 100644 index 000000000..4acd74953 --- /dev/null +++ b/tests/test_pre_push.py @@ -0,0 +1,147 @@ +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[1] +ZERO_OID = "0" * 40 + + +@unittest.skipUnless(shutil.which("sh") and shutil.which("python3"), "Git hook needs sh and python3") +class PrePushTests(unittest.TestCase): + def setUp(self): + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.repo = Path(temporary.name) + self.env = {**os.environ, "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1"} + self.git("init", "-b", "main") + (self.repo / "tools").mkdir() + shutil.copyfile(ROOT / "tools/check_public_tree.py", self.repo / "tools/check_public_tree.py") + (self.repo / ".gitignore").write_text("/.local/\n") + (self.repo / "README.md").write_text("Public fixture\n") + self.git("add", ".gitignore", "README.md") + self.git("commit", "-m", "Public root") + self.base = self.git("rev-parse", "HEAD") + + def git(self, *args): + return subprocess.check_output( + ["git", "-c", f"core.hooksPath={self.repo / 'no-hooks'}", "-c", "user.name=Test", + "-c", "user.email=test@example.invalid", "-c", "commit.gpgsign=false", + "-c", "tag.gpgsign=false", *args], + cwd=self.repo, env=self.env, text=True, stderr=subprocess.PIPE).strip() + + def commit_file(self, path, content="Public fixture\n"): + destination = self.repo / path + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_text(content) + self.git("add", "-f", path) + self.git("commit", "-m", f"Add {path}") + return self.git("rev-parse", "HEAD") + + def private_commit(self): + return self.commit_file(".local/artifact.txt", "Private fixture, not game data\n") + + def update(self, local_ref, local_oid, remote_ref=None, remote_oid=ZERO_OID): + return f"{local_ref} {local_oid} {remote_ref or local_ref} {remote_oid}\n" + + def push(self, *updates): + return subprocess.run(["sh", str(ROOT / ".githooks/pre-push"), "origin", "unused"], + cwd=self.repo, env=self.env, input="".join(updates), + text=True, capture_output=True) + + def assert_passed(self, result): + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn("Public tree check passed.", result.stdout) + + def assert_private_rejected(self, result): + self.assertNotEqual(result.returncode, 0, result.stdout) + self.assertIn(".local/artifact.txt", result.stderr) + + def test_clean_branch_ignores_unpushed_refs_and_head(self): + self.git("checkout", "-b", "local-only") + private = self.private_commit() + for ref in ["refs/remotes/archive/private", "refs/original/refs/heads/main", "refs/tags/private"]: + self.git("update-ref", ref, private) + self.git("branch", "clean", self.base) + for remote_oid in [ZERO_OID, private]: + with self.subTest(remote_oid=remote_oid): + self.assert_passed(self.push(self.update("refs/heads/clean", self.base, remote_oid=remote_oid))) + # The standalone audit still checks every local ref. + audit = subprocess.run([sys.executable, "tools/check_public_tree.py", "--history"], + cwd=self.repo, env=self.env, text=True, capture_output=True) + self.assert_private_rejected(audit) + + def test_raw_revision_push_uses_supplied_oid(self): + self.private_commit() + self.assert_passed(self.push(self.update(self.base, self.base, "refs/heads/public"))) + + def test_unpushed_replacement_does_not_taint_clean_history(self): + private = self.private_commit() + tree = self.git("rev-parse", f"{private}^{{tree}}") + replacement = self.git("commit-tree", tree, "-m", "Private replacement root") + self.git("replace", self.base, replacement) + self.assert_passed(self.push(self.update(self.base, self.base, "refs/heads/public"))) + + def test_replacement_cannot_hide_private_history(self): + private = self.private_commit() + self.git("replace", private, self.base) + self.assert_private_rejected(self.push(self.update("refs/heads/main", private))) + + def test_all_pushed_refs_are_checked(self): + private = self.private_commit() + clean_update = self.update("refs/heads/clean", self.base) + private_update = self.update("refs/heads/main", private) + for updates in [(clean_update, private_update), (private_update, clean_update)]: + with self.subTest(updates=updates): + self.assert_private_rejected(self.push(*updates)) + + def test_private_ancestors_are_rejected_even_after_removal_and_an_earlier_push(self): + self.private_commit() + self.git("rm", ".local/artifact.txt") + self.git("commit", "-m", "Remove private fixture") + remote = self.git("rev-parse", "HEAD") + tip = self.commit_file("public.txt") + for remote_oid in [ZERO_OID, remote]: + with self.subTest(remote_oid=remote_oid): + self.assert_private_rejected(self.push(self.update("refs/heads/main", tip, remote_oid=remote_oid))) + + def test_annotated_tags_check_their_target_history(self): + self.private_commit() + self.git("rm", ".local/artifact.txt") + self.git("commit", "-m", "Remove private fixture") + self.git("tag", "-a", "clean", self.base, "-m", "Clean tag") + self.git("tag", "-a", "private", "-m", "Private history tag") + clean = self.git("rev-parse", "refs/tags/clean") + private = self.git("rev-parse", "refs/tags/private") + self.assert_passed(self.push(self.update("refs/tags/clean", clean))) + self.assert_private_rejected(self.push(self.update("refs/tags/private", private))) + + def test_empty_push_and_deletions_do_not_scan_unpushed_history(self): + private = self.private_commit() + deletion = self.update("(delete)", ZERO_OID, "refs/heads/private", private) + clean_update = self.update(self.base, self.base, "refs/heads/public") + for updates in [(), (deletion,), (deletion, clean_update)]: + with self.subTest(updates=updates): + self.assert_passed(self.push(*updates)) + + def test_private_file_introduced_only_by_merge_resolution_is_rejected(self): + self.git("checkout", "-b", "feature") + self.commit_file("feature.txt") + self.git("checkout", "main") + self.commit_file("main.txt") + self.git("merge", "--no-ff", "--no-commit", "feature") + merge = self.private_commit() + self.assert_private_rejected(self.push(self.update("refs/heads/main", merge))) + + def test_invalid_pushed_oid_fails_closed(self): + result = self.push(self.update("refs/heads/missing", "f" * 40)) + self.assertNotEqual(result.returncode, 0, result.stdout) + self.assertNotIn("Public tree check passed.", result.stdout) + + +if __name__ == "__main__": + unittest.main() 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/check_public_tree.py b/tools/check_public_tree.py index 7ca8b6217..fc92dd806 100644 --- a/tools/check_public_tree.py +++ b/tools/check_public_tree.py @@ -22,19 +22,40 @@ def prohibited(path): return bool(parsed.parts and parsed.parts[0] in PRIVATE_ROOTS) or parsed.suffix.lower() in PRIVATE_EXTENSIONS -def paths_in_repository(history=False): +def paths_in_repository(history=False, revisions=None): if not history: result = subprocess.check_output(["git", "ls-files", "-z"]) return result.decode("utf-8").split("\0") - result = subprocess.check_output(["git", "log", "--all", "--format=", "--name-only", "-z"]) + # An empty push (including deletions only) must not fall back to HEAD or --all. + if revisions is not None and not revisions: + return [] + roots = ["--all"] if revisions is None else revisions + # Include diffs against merge parents so merge-resolution-only artifacts are caught. + # Git pushes the stored objects, not the history presented by local replace refs. + result = subprocess.check_output(["git", "--no-replace-objects", "log", "--format=", "--name-only", + "-z", "-m", *roots, "--"]) return [path.lstrip("\n") for path in result.decode("utf-8").split("\0")] +def pushed_revisions(stream): + """Read Git's pre-push ref updates and retain the non-deleted local object IDs.""" + revisions = [] + for line in stream: + _local_ref, local_oid, _remote_ref, _remote_oid = line.split() + if local_oid.strip("0"): + revisions.append(local_oid) + return revisions + + def main(): parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--history", action="store_true", help="Also inspect paths in all local Git history") + mode = parser.add_mutually_exclusive_group() + mode.add_argument("--history", action="store_true", help="Inspect paths in all local Git history") + mode.add_argument("--pre-push", action="store_true", help="Inspect history reachable from Git's ref updates on stdin") args = parser.parse_args() - rejected = sorted({path for path in paths_in_repository(args.history) if path and prohibited(path)}) + revisions = pushed_revisions(sys.stdin) if args.pre_push else None + rejected = sorted({path for path in paths_in_repository(args.history or args.pre_push, revisions) + if path and prohibited(path)}) if rejected: print("Private game/profiling artifacts must stay outside Git:", file=sys.stderr) for path in rejected: diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py index 2b2a0afd1..425e3e919 100644 --- a/tools/command_exec_corpus.py +++ b/tools/command_exec_corpus.py @@ -36,6 +36,11 @@ def group_setup(): *setup('/kill @e[type=!player]'), {'op': 'tick', 'n': 25}, *setup('/fill 0 200 0 15 228 15 air', '/time set 1000', '/weather clear', '/difficulty normal', '/clear @s'), + # Before the gamerules above, while the oracle waits for its entities to load (a number of ticks that + # depends on the machine), mobs spawn and some die with their drops on: a bat's death rolled + # minecraft:entities/bat on 1 vanilla run in 24, one more sequence for the ticking group's + # /random reset * to count. Every run starts the script without them. + *setup('/random reset *'), ] @@ -286,6 +291,36 @@ def entities(): ] +def riding_teleport(): + """Player teleports remove the vehicle, leave it behind and keep the destination (#1473).""" + horse = '@e[tag=tp_horse,limit=1]' + operations = setup( + '/summon minecraft:horse 4.5 220 4.5 {Tame:1b,NoAI:1b,NoGravity:1b,Tags:["tp_horse"]}', + '/summon minecraft:marker 8.5 220 0.5 {Tags:["tp_destination"]}', + ) + for teleport in ('/tp @s 8.5 220 0.5', '/teleport @s ~4 220 ~-4', + '/tp @s @e[tag=tp_destination,limit=1]'): + operations += [ + *setup('/tp @s 4.5 220 4.5'), + cmd(f'/ride @s mount {horse}'), + cmd('/execute on vehicle run say mounted'), + # An invalid destination must not dismount the player. + cmd('/tp @s 30000000 220 0'), + cmd('/execute on vehicle run say still mounted'), + cmd(teleport), + cmd('/execute on vehicle run say still riding after teleport'), + cmd('/data get entity @s Pos'), + cmd(f'/data get entity {horse} Pos'), + {'op': 'tick', 'n': 60}, + cmd('/execute on vehicle run say still riding after ticks'), + cmd('/data get entity @s Pos'), + cmd(f'/data get entity {horse} Pos'), + cmd('/ride @s dismount'), + ] + return operations + setup('/kill @e[tag=tp_horse]', '/kill @e[tag=tp_destination]', + '/tp @s 8.5 230 8.5 0 0') + + def scores(): return [ cmd('/scoreboard objectives add harness dummy'), @@ -975,6 +1010,7 @@ def groups(): ('player state', player_state()), ('blocks and border', world_blocks()), ('entities', entities()), + ('riding teleport', riding_teleport()), ('scores, teams and bossbars', scores()), ('execute', execute()), ('levels', levels()), 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..0c8979f0a 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -87,7 +87,9 @@ address. The script then checks, from both sides, what a guest's game used to ge - commands: the guest's chat completes commands and their arguments over the server's command tree (Tab), and runs what it completed; - recipes: the guest's recipe book lists the planks recipe the logs unlock, and clicking it - places a log in the inventory's crafting grid (the server places it). + places a log in the inventory's crafting grid (the server places it). +- recipe_removal: the host and guest each forget all and individual recipes while the book + is open; it stays empty when reopened, and a later grant appears (#1495). - feedback: the guest's command feedback names the guest and shows the numbers, and the host (an operator) is told of it as `[Guest: ...]`. - clicks: with real mouse presses (not click-slot, which skips the screen's press and drag @@ -102,6 +104,9 @@ address. The script then checks, from both sides, what a guest's game used to ge pushes it, as in vanilla), not ever faster across the ground. - eat: holding right click with bread, the guest's own screen plays the eating (the item in use counts up) and the server eats one loaf and feeds the guest. +- consume-release: the host and the guest each cancel eating a golden apple and drinking milk from + either hand: use ends on client and server, the item and effects stay, and holding + use to completion still consumes the item (#1293). - eating: each side sees the other player eat: the item in use (LivingEntity's flags) on the player it draws, and no longer once the bread is eaten (#803); - xp: experience orbs 4 blocks away fly to the guest, show on the guest's screen and give the @@ -109,7 +114,9 @@ address. The script then checks, from both sides, what a guest's game used to ge - objects: boats, minecarts, armor stands, item frames and paintings the host summons reach the guest as the host has them (kind, place, rotation, what they hold or wear, the variant). - projectiles: primed TNT (one falling), an end crystal and an arrow that lands reach the guest where - the host has them; a falling block lands on both sides. + the host has them; a falling block lands on both sides. +- shulker_bullets: every shot a shulker fires has its own id and flies on both sides, following + the same trajectory; the bullets disappear on both sides when they hit blocks (#1494). - thrown: a splash potion and an eye of ender the host and the guest each throw fly on both sides (#1363, #1391); - sparks: level events' particles on both sides: the host's and the guest's bone meal on wheat @@ -136,6 +143,8 @@ address. The script then checks, from both sides, what a guest's game used to ge server's game time after the guest's game stalls for a few seconds (#848). - growth: far from the host, the chunks around the guest tick (#890): water placed there flows and wheat on farmland grows (random ticks), however the host runs its world. +- farmland: the host and guest each trample planted farmland: the wheat breaks and drops its items, + and both clients see dirt/air (#1492). - ladder: the guest climbs down ten blocks of ladder and lands unhurt: the server resets its fall distance on a ladder every tick, as LivingEntity.handleOnClimbable does (#1255). - boats: the host (single player, on its server thread or not) and the guest each right-click a @@ -156,6 +165,9 @@ address. The script then checks, from both sides, what a guest's game used to ge - riding: the host and the guest each saddle and ride a horse (walk, jump), a pig and a strider (with their sticks), a camel and a donkey, sit on a llama and fly a happy ghast, and get off by sneaking; the other side sees the animal move. +- riding_teleport: the host and the guest each /tp through chat while riding a horse; after 60 + ticks each stays dismounted at the destination and both sides see the horse left + behind. The host also teleports a mounted guest by name. - lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the sky (on its server thread the host's window is a client of it too). - drops: an item lies where the host, then the guest, places a block: it comes out of the block @@ -228,6 +240,14 @@ 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). +- stopsound: the host's and the guest's own /stopsound, by source and by event, reach their own + client's sounds, and the host's /stopsound of the guest only the guest's (StopSoundCommand + sends each target its packet). +- hero-trading: the host and the guest each trade 20 wheat for an emerald, paying 14 with Hero I + and 12 with Hero III; clearing the effect restores the ordinary price (#1365). +- 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 +295,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 @@ -4895,6 +4914,82 @@ CHECKS += ['helduse'] CHECK_FNS.update(helduse=check_held_use) +def check_consume_release(host, guest, out): + """#1293: releasing a consumable in either hand cancels it on client and server, while + holding it to completion applies its effects and remainder (Consumable.onConsume).""" + apart(host, guest) + seen = {} + try: + for game in (host, guest): + game('command', command='gamemode survival') + x, y, z = pos_of(game) + game.raw('look-at', x, y + 1.6, z + 2) + for hand in ('mainhand', 'offhand'): + for item in ('golden_apple', 'milk_bucket'): + case = f'{game.name}-{hand}-{item}' + game('command', command='clear @s') + game('command', command='item replace entity @s weapon.offhand with minecraft:air') + game('command', command='effect clear @s') + if item == 'milk_bucket': + game('command', command='effect give @s minecraft:speed 60') + game('command', command=f'item replace entity @s weapon.{hand} with minecraft:{item}') + game.wait(10) + assert game('looking_at')['kind'] == 'none', f'{case} is not aimed into the air' + before = set(effect_ids(game)) + assert before == ({'speed'} if item == 'milk_bucket' else set()), f'{case}: {before}' + game.raw('mouse', 'right', 'down') + game.wait(5) + during = {'client': game('state').get('using'), 'server': server_using(host, game)} + game.raw('mouse', 'right', 'up') + game.wait(10) + released = {'client': game('state').get('using'), 'server': server_using(host, game)} + # Wait past the full use duration: the server must not finish eating after release. + game.wait(60) + effects = set(effect_ids(game)) + inventory = game('inventory') + stack = inventory['offhand'] if hand == 'offhand' else inventory['held'] + cancelled = {'during': during, 'released': released, + 'stack': stack, 'effects': sorted(effects)} + seen[case] = {'cancelled': cancelled} + assert during['client'] and during['server'], f'{case} did not start on both sides: {cancelled}' + assert released == {'client': None, 'server': None}, f'{case} did not cancel: {cancelled}' + assert stack and stack['item'] == f'minecraft:{item}' and stack['count'] == 1, \ + f'{case} consumed the released item: {cancelled}' + assert effects == before, f'{case} applied consumption effects after release: {cancelled}' + game.shot(out, f'consume-release-{hand}-{item}') + # A sustained press must still consume normally, including the milk's empty bucket. + game.raw('mouse', 'right', 'down') + game.wait(40) + game.raw('mouse', 'right', 'up') + game.wait(10) + inventory = game('inventory') + stack = inventory['offhand'] if hand == 'offhand' else inventory['held'] + completed = {'stack': stack, 'effects': sorted(effect_ids(game)), + 'using': (game('state').get('using'), server_using(host, game))} + seen[case]['completed'] = completed + assert completed['using'] == (None, None), \ + f'{case} did not finish normally: {completed}' + if item == 'golden_apple': + assert inventory['counts'].get('minecraft:golden_apple', 0) == 0, \ + f'{case} kept the eaten apple: {completed}' + assert set(completed['effects']) == {'regeneration', 'absorption'}, f'{case}: {completed}' + else: + assert not completed['effects'] and stack and stack['item'] == 'minecraft:bucket' \ + and stack['count'] == 1, f'{case}: {completed}' + finally: + for game in (host, guest): + game.raw('mouse', 'right', 'up') + game('command', command='clear @s') + game('command', command='item replace entity @s weapon.offhand with minecraft:air') + game('command', command='effect clear @s') + face_each_other(host, guest) + return seen + + +CHECKS += ['consume-release'] +CHECK_FNS.update({'consume-release': check_consume_release}) + + def check_wind(host, guest, out): """A wind charge each player throws at its own feet (ServerExplosion with TRIGGER_BLOCK): the server's burst pushes the thrower through its ClientboundExplodePacket (hitPlayers), which @@ -5437,6 +5532,127 @@ CHECKS += ['knockback'] CHECK_FNS.update(knockback=check_knockback) +def check_hero_trading(host, guest, out): + """Villager.updateSpecialPrices keeps the trading player's Hero effect: the offer sent to the + client and the server's payment consumption agree, independently of the other player's effect.""" + x, y, z = (int(v // 1) for v in pos_of(host)) + tag = 'hero_trade' + seen = {} + cases = [('ordinary', None, 20), ('hero-i', 0, 14), ('hero-iii', 2, 12), ('cleared', None, 20)] + try: + host('command', command=f'fill {x - 4} {y - 1} {z - 2} {x + 4} {y - 1} {z + 2} minecraft:stone') + host('command', command=f'fill {x - 4} {y} {z - 2} {x + 4} {y + 3} {z + 2} minecraft:air') + for game, other in ((host, guest), (guest, host)): + back_to_game(game) + back_to_game(other) + other('command', command='effect clear @s') + other('command', command='effect give @s minecraft:hero_of_the_village 600 4 true') + other('command', command=f'tp @s {x - 3.5} {y} {z + 0.5}') + game('command', command='gamemode survival') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + for label, amplifier, price in cases: + game('command', command='effect clear @s') + if amplifier is not None: + game('command', command=f'effect give @s minecraft:hero_of_the_village 600 {amplifier} true') + game('command', command='clear @s') + game('command', command='give @s minecraft:wheat 20') + # A fresh, fixed offer avoids reputation, demand and level-ups between cases. + host('command', command=f'summon minecraft:villager {x + 2.5} {y} {z + 0.5} {{Tags:["{tag}"],' + 'NoAI:1b,PersistenceRequired:1b,Xp:1,VillagerData:{type:"minecraft:plains",' + 'profession:"minecraft:farmer",level:1},Offers:{Recipes:[{buy:{id:"minecraft:wheat",count:20},' + 'sell:{id:"minecraft:emerald",count:1},maxUses:16,uses:0,xp:0,priceMultiplier:0f,demand:0}]}}') + game.wait(20) + villager = next(e['id'] for e in game.raw('entities', 8, 'minecraft:villager')['entities'] + if math.dist(e['pos'], [x + 2.5, y, z + 0.5]) < 0.5) + game.raw('interact-entity', villager) + game.raw('wait-for', 'screen', 'station', '--timeout', 10) + assert game('screen')['station'] == 'Merchant', f'{game.name}-{label}: no merchant screen' + # The first offer button is 50 pixels left of the usual menu origin. Selecting it + # sends SelectTrade on a client; taking the result uses the authoritative menu. + game.raw('click-gui', -1, 28) + game.wait(10) + assert station_slots(game).get(650) == ('minecraft:emerald', 1), f'{game.name}-{label}: no result' + game.shot(out, f'hero-trading-{label}') + game.raw('click-slot', 650, 'shift') + game.wait(10) + game.raw('key', 'esc', 'tap') + game.wait(10) + offer = server_reply(game, f'data get entity @e[type=minecraft:villager,tag={tag},limit=1] ' + 'Offers.Recipes[0]', 'following entity data') + special = re.search(r'specialPrice"?\s*:\s*(-?\d+)', offer) + case = {'price': 20 + (int(special[1]) if special else 0), + 'server': {item: server_count(game, item) for item in ('wheat', 'emerald')}, + 'hero': 'hero_of_the_village' in effect_ids(game)} + seen[f'{game.name}-{label}'] = case + want = {'price': price, 'server': {'wheat': 20 - price, 'emerald': 1}, + 'hero': amplifier is not None} + assert case == want, f'{game.name}-{label}: expected {want}, got {case}' + host('command', command=f'kill @e[tag={tag}]') + game.wait(5) + finally: + for game in (host, guest): + back_to_game(game) + game('command', command='effect clear @s') + game('command', command='clear @s') + host('command', command=f'kill @e[tag={tag}]') + return seen + + +CHECKS += ['hero-trading'] +CHECK_FNS.update({'hero-trading': check_hero_trading}) + + +def check_spectator_travel(host, guest, out): + """Player.tick's spectator noPhysics survives a replacement body after dimension travel (#1299).""" + players = (host, guest) if SERVER_THREAD else (host,) + seen = {} + for game in players: + home = pos_of(game) + game('command', command='gamemode spectator') + game.wait(10) + try: + for dimension in (NETHER, OVERWORLD): + game('command', command=f'execute in {dimension} run tp @s .5 102 .5 0 0') + there = wait_dimension(game, dimension, 600) + assert there.get('dimension') == dimension, f'{game.name} stayed in {there.get("dimension")}' + # A replacement body arrives before its chunks; fill needs the whole corridor loaded. + for _ in range(30): + if all(game.raw('block', *pos).get('loaded') for pos in ((-2, 101, -1), (2, 105, 16))): + break + game.wait(20) + game('command', command='fill -2 101 -1 2 105 16 minecraft:air') + game('command', command='fill -2 101 3 2 105 3 minecraft:stone') + game.wait(10) + wall = game.raw('block', 0, 102, 3) + assert wall.get('loaded') and wall.get('block') == 'minecraft:stone', f'wall: {wall}' + label = f'spectator-{dimension.removeprefix("minecraft:")}' + game.shot(out, f'{label}-before') + game.raw('key', 'w', 'down') + game.wait(20) + game.raw('key', 'w', 'up') + game.wait(10) + state = game('state') + client = state['player'] + server = server_player(host, game) + seen[f'{game.name}-{dimension}'] = {'client': client['position'], 'server': server['position']} + game.shot(out, f'{label}-after') + assert state.get('gamemode') == 'spectator' and client['flying'], f'{game.name} lost spectator flight' + assert client['position'][2] > 4 and server['position'][2] > 4, \ + f'{game.name} collides after travel to {dimension}: {seen}' + game('command', command='fill -2 101 3 2 105 3 minecraft:air') + finally: + game.raw('key', 'w', 'up') + game('command', command=f'execute in {OVERWORLD} run tp @s {home[0]:.2f} {home[1]:.2f} {home[2]:.2f}') + wait_dimension(game, OVERWORLD, 600) + game('command', command='gamemode survival') + game.wait(20) + return seen + + +CHECKS += ['spectator-travel'] +CHECK_FNS.update({'spectator-travel': check_spectator_travel}) + + def check_villagers(host, guest, out): """Villager.DATA_VILLAGER_DATA and ZombieVillager's reach the guest: summoned villagers show their type, profession and level, and an unemployed villager that takes a composter placed @@ -5496,5 +5712,455 @@ CHECKS += ['villagers'] CHECK_FNS.update(villagers=check_villagers) +def check_stopsound(host, guest, out): + """StopSoundCommand sends each target ClientboundStopSoundPacket: a player's own /stopsound by + source and by event reaches its own client's sound engine, and the host's /stopsound of the + guest reaches the guest's (sounds stopped, counted in the status as `heard` is, audio or not).""" + event = 'minecraft:music_disc.cat' + + def stopped(game): + return game('status')['stopped_sounds'] + + seen = {} + for game in (host, guest): + before = stopped(game) + game('command', command='stopsound @s record') + game('command', command=f'stopsound @s * {event}') + game.wait(10) + after = stopped(game) + seen[game.name] = {k: after.get(k, 0) - before.get(k, 0) for k in after} + assert seen[game.name].get('record *') == 1 and seen[game.name].get(f'* {event}') == 1, \ + f'{game.name}: its own /stopsound did not reach its client: {seen}' + before = {g.name: stopped(g) for g in (host, guest)} + host('command', command=f'stopsound {GUEST_NAME}') + guest.wait(10) + for game in (host, guest): + after = stopped(game) + seen[f'{game.name}-by-host'] = after.get('* *', 0) - before[game.name].get('* *', 0) + assert seen['guest-by-host'] == 1 and seen['host-by-host'] == 0, \ + f"the host's /stopsound of the guest stopped the wrong client: {seen}" + return seen + + +CHECKS += ['stopsound'] +CHECK_FNS.update(stopsound=check_stopsound) + + +def check_riding_teleport(host, guest, out): + """#1473: a chat /tp dismounts each player and leaves the horse behind in both modes; + teleporting another player exercises the guest-target command path too.""" + spots = apart(host, guest) + result = {} + for label, player, source in (('host', host, None), ('guest', guest, None), + ('guest-targeted', guest, host)): + x, y, z = spots['host' if player is host else 'guest'] + horse_at = (x + 0.5, y, z + 2.5) + destination = (x + 3.5, y, z + 5.5) + tag = 'tp_horse' + try: + player('command', command='clear @s') + player('command', command='gamemode survival') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0') + player('command', command='item replace entity @s weapon.mainhand with minecraft:saddle') + player('command', command=f'summon minecraft:horse {horse_at[0]} {y} {horse_at[2]} ' + f'{{Tame:1b,NoAI:1b,NoGravity:1b,Tags:["{tag}"]}}') + player.wait(5) + horses = [m for m in player.raw('mobs', 16)['near'] + if m['kind'] == 'minecraft:horse' and m['health'] > 0] + horse = next((m for m in horses if math.dist(m['pos'], horse_at) < 0.1), None) + assert horse, f'{label}: no live horse at {horse_at}: {horses}' + player.raw('look-at', horse_at[0], y + 0.8, horse_at[2]) + player.raw('mouse', 'right', 'click') + player.wait(5) + player('command', command='item replace entity @s weapon.mainhand with minecraft:air') + player.wait(2) + player.raw('mouse', 'right', 'click') + player.wait(5) + assert player('status').get('riding') == horse['id'], f'{label}: not riding the horse' + player.shot(out, f'riding-tp-{label}-before') + coordinates = ' '.join(map(str, destination)) + if source is None: + player.raw('key', 't', 'tap') + player.raw('type', f'/tp @s {coordinates}') + player.raw('key', 'enter', 'tap') + else: + source('command', command=f'tp {GUEST_NAME} {coordinates}') + player.wait(60) + player.shot(out, f'riding-tp-{label}-after') + seen = {'riding': player('status').get('riding'), 'client': pos_of(player), + 'server': server_player(host, player)['position'], + 'horse': mob_seen(player, horse['id'])['pos'], + 'other_horse': mob_seen(guest if player is host else host, horse['id'])['pos']} + assert seen['riding'] is None, f'{label}: still mounted after /tp: {seen}' + assert all(math.dist(seen[side], destination) < 0.01 for side in ('client', 'server')), \ + f'{label}: /tp did not keep its destination after 60 ticks: {seen}' + assert all(math.dist(seen[side], horse_at) < 0.01 for side in ('horse', 'other_horse')), \ + f'{label}: /tp moved the horse: {seen}' + result[label] = seen + finally: + back_to_game(player) + player('command', command=f'kill @e[tag={tag}]') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0') + # The next case uses this spot again: let the previous horse's death animation finish. + player.wait(25) + return result + + +CHECKS += ['riding_teleport'] +CHECK_FNS.update(riding_teleport=check_riding_teleport) + + +def check_recipe_removal(host, guest, out): + """ServerRecipeBook.removeRecipes sends ClientboundRecipeBookRemovePacket to the player: + the open book updates immediately, reopening keeps it empty, and later grants still arrive.""" + seen = {} + for game in (host, guest): + back_to_game(game) + game('command', command='clear @s') + game('command', command='give @s minecraft:oak_log 4') + game('command', command='recipe give @s minecraft:oak_planks') + game('command', command='recipe give @s minecraft:stick') + game.wait(40) + game.raw('key', 'e', 'tap') + game.wait(5) + try: + book = game('screen').get('recipe_book') + assert book, f'{game.name}: the inventory has no recipe book' + if len(book['targets']) == 1: + game.raw('click-at', *centre(book['targets'][0])) + game.wait(5) + book = game('screen')['recipe_book'] + known = book['known'] + assert known > 1, f'{game.name}: recipes were not granted: {book}' + game.shot(out, 'recipe-removal-before') + + game('command', command='recipe take @s *') + game.wait(20) + empty = game('screen')['recipe_book']['known'] + game.shot(out, 'recipe-removal-empty') + assert empty == 0, f'{game.name}: forgotten recipes remain in the open book: {empty}' + game.raw('key', 'esc', 'tap') + game.wait(5) + game.raw('key', 'e', 'tap') + game.wait(5) + reopened = game('screen')['recipe_book']['known'] + assert reopened == 0, f'{game.name}: reopening restored {reopened} forgotten recipes' + + game('command', command='recipe give @s minecraft:oak_planks') + game('command', command='recipe give @s minecraft:stick') + game.wait(20) + given = game('screen')['recipe_book']['known'] + assert given == 2, f'{game.name}: two later grants did not appear: {given}' + game('command', command='recipe take @s minecraft:oak_planks') + game.wait(20) + one = game('screen')['recipe_book']['known'] + assert one == 1, f'{game.name}: taking one recipe left {one}, expected 1' + game('command', command='recipe take @s minecraft:stick') + game.wait(20) + assert game('screen')['recipe_book']['known'] == 0, f'{game.name}: the last recipe remains' + + game('command', command='recipe give @s minecraft:oak_planks') + game.wait(20) + granted = game('screen')['recipe_book']['known'] + assert granted == 1, f'{game.name}: a later grant did not appear: {granted}' + game.shot(out, 'recipe-removal-granted') + seen[game.name] = {'known': known, 'empty': empty, 'reopened': reopened, + 'given': given, 'one': one, 'granted': granted} + finally: + back_to_game(game) + return seen + + +CHECKS += ['recipe_removal'] +CHECK_FNS.update(recipe_removal=check_recipe_removal) + + +def check_shulker_bullets(host, guest, out): + """ShulkerAttackGoal's bullets reach ClientPacketListener.handleAddEntity, then the existing + projectile renderer and interpolation, with distinct ids from the server's entity counter.""" + x, y, z = (int(v // 1) for v in pos_of(host)) + tag = 'lan_shulker_bullets' + selector = f'@e[type=minecraft:shulker,tag={tag},limit=1]' + sound = 'minecraft:entity.shulker.shoot' + paths = {g.name: {} for g in (host, guest)} + before = {g.name: heard(g, sound) for g in (host, guest)} + shots = dict.fromkeys(before, 0) + first_shot = stopped = None + photographed = False + + def bullets(status): + return [p for p in status['projectiles'] if p['kind'] == 'ShulkerBullet'] + + try: + host('command', command='difficulty normal') + host('command', command='gamemode creative') + guest('command', command='gamemode survival') + guest('command', command='effect give @s minecraft:resistance 120 4 true') + host('command', command=f'fill {x - 10} {y - 1} {z - 10} {x + 10} {y - 1} {z + 18} minecraft:stone') + host('command', command=f'fill {x - 10} {y} {z - 10} {x + 10} {y + 12} {z + 18} minecraft:air') + # A west wall supports the shulker above the floor, leaving room for a short flight. + host('command', command=f'fill {x - 1} {y} {z + 7} {x - 1} {y + 4} {z + 7} minecraft:stone') + host('command', command=f'tp @s {x + 4.5} {y} {z - 0.5}') + guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + host('command', command=f'summon minecraft:shulker {x + 0.5} {y + 3} {z + 7.5} ' + f'{{NoAI:1b,PersistenceRequired:1b,Tags:["{tag}"]}}') + for game in (host, guest): + game.raw('look-at', x + 0.5, y + 3.5, z + 7.5) + guest.wait(20) + host('command', command=f'data merge entity {selector} {{NoAI:0b}}') + for waited in range(2, 402, 2): + guest.wait(2) + for game in (host, guest): + status = game('status') + live = bullets(status) + ids = [p['id'] for p in live] + assert all(ids) and len(set(ids)) == len(ids), f'{game.name}: invalid bullet ids {ids}' + for p in live: + paths[game.name].setdefault(p['id'], []).append(p['position']) + shots[game.name] = status['heard'].get(sound, 0) - before[game.name] + if shots['host'] and first_shot is None: + first_shot = waited + if first_shot is not None and waited - first_shot >= 8 and not photographed: + host('command', command='tick freeze') + try: + for game in (host, guest): + game.raw('look-at', x + 0.5, y + 3.5, z + 7.5) + game.raw('key', 'f1', 'tap') + try: + game.shot(out, 'shulker-bullets') + finally: + game.raw('key', 'f1', 'tap') + finally: + host('command', command='tick unfreeze') + photographed = True + if shots['host'] >= 2 and stopped is None: + host('command', command=f'data merge entity {selector} {{NoAI:1b}}') + stopped = waited + if stopped is not None and waited - stopped >= 20: + break + # Keep the survival target in range after a hit applies levitation. + if waited % 20 == 0: + guest('command', command='effect clear @s minecraft:levitation') + guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + lab.write_json(out / 'shulker-bullets.json', {'shots': shots, 'paths': paths}) + assert shots['host'] >= 2, f'the shulker did not attack twice: {shots}' + for name, by_id in paths.items(): + assert len(by_id) == shots[name], f'{name}: {shots[name]} shots but bullet ids {list(by_id)}' + for id, positions in by_id.items(): + assert any(math.dist(positions[0], p) > 0.5 for p in positions), \ + f'{name}: bullet {id} did not move: {positions}' + assert paths['host'].keys() == paths['guest'].keys(), f'different bullets: {paths}' + for id, positions in paths['guest'].items(): + # The clients interpolate three ticks behind, and reads are not simultaneous. + assert all(min(math.dist(p, q) for q in paths['host'][id]) < 1.5 for p in positions), \ + f'bullet {id} diverged from the host: {paths}' + + # Put blocks in the flight volume to exercise server removal without depending on homing. + for game in (host, guest): + game('command', command='gamemode creative') + game('command', command=f'tp @s {x + 0.5} {y + 16} {z + 0.5}') + host('command', command=f'fill {x - 10} {y} {z - 10} {x + 10} {y + 12} {z + 18} minecraft:stone') + for _ in range(20): + guest.wait(2) + remaining = {g.name: bullets(g('status')) for g in (host, guest)} + if not any(remaining.values()): + break + assert not any(remaining.values()), f'bullets survived block hits: {remaining}' + finally: + host('command', command='tick unfreeze') + host('command', command=f'kill @e[tag={tag}]') + host('command', command=f'fill {x - 10} {y} {z - 10} {x + 10} {y + 12} {z + 18} minecraft:air') + for game in (host, guest): + game('command', command='effect clear @s') + game('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + game('command', command='gamemode survival') + face_each_other(host, guest) + return {'shots': shots, 'ids': sorted(paths['host']), 'removed': True} + + +CHECKS += ['shulker_bullets'] +CHECK_FNS.update(shulker_bullets=check_shulker_bullets) + + +def check_farmland(host, guest, out): + """FarmlandBlock.fallOn's base-block change breaks the unsupported crop (#1492): + the host and guest each land on mature wheat, get its drops, and both clients see dirt/air.""" + hx, hy, hz = (int(v // 1) for v in pos_of(host)) + y = max(hy + 12, 100) + starts = {g.name: pos_of(g) for g in (host, guest)} + seen = {} + host('command', command='gamerule random_tick_speed 0') + try: + for game, other, dz in ((host, guest, -3), (guest, host, 3)): + x, z = hx + 2, hz + dz + soil, crop, marker = (x, y, z), (x, y + 1, z), (x + 4, y + 1, z) + for g in (game, other): + g('command', command='gamemode creative') + host('command', command=f'fill {x - 4} {y} {z - 2} {x + 4} {y} {z + 2} minecraft:stone') + host('command', command=f'fill {x - 4} {y + 1} {z - 2} {x + 4} {y + 7} {z + 2} minecraft:air') + host('command', command=f'setblock {x} {y} {z} minecraft:farmland[moisture=7]') + host('command', command=f'setblock {x} {y + 1} {z} minecraft:wheat[age=7]') + other('command', command=f'tp @s {x + 3.5} {y + 1} {z + 0.5}') + game('command', command=f'tp @s {x + 2.5} {y + 1} {z + 0.5}') + game('command', command='clear @s') + game('command', command='gamemode survival') + game.wait(20) + before = {g.name: [g.raw('block', *p).get('block') for p in (soil, crop)] + for g in (host, guest)} + assert all(v == ['minecraft:farmland', 'minecraft:wheat'] for v in before.values()), \ + f'{game.name}: planted wheat missing before landing: {before}' + other.raw('look-at', x + 0.5, y + 1, z + 0.5) + other.shot(out, f'farmland-{game.name}-before') + # More than 1.5 blocks of fall distance guarantees the trampling random check. + game('command', command=f'tp @s {x + 0.5} {y + 6} {z + 0.5}') + game.wait(80) + after = {g.name: [g.raw('block', *p).get('block') for p in (soil, crop)] + for g in (host, guest)} + # Test the authoritative blocks too, rather than only each client's view. + game('command', command=f'execute if block {x} {y} {z} minecraft:dirt ' + f'if block {x} {y + 1} {z} minecraft:air run ' + f'setblock {marker[0]} {marker[1]} {marker[2]} minecraft:gold_block') + game.wait(10) + counts = {item: server_count(game, item) for item in ('wheat', 'wheat_seeds')} + client_counts = game('inventory')['counts'] + seen[game.name] = {'blocks': after, 'server': game.raw('block', *marker).get('block'), + 'drops': counts, + 'client_drops': {item: client_counts.get('minecraft:' + item, 0) + for item in counts}} + other.shot(out, f'farmland-{game.name}-after') + finally: + host('command', command='gamerule random_tick_speed 3') + host('command', command='kill @e[type=minecraft:item]') + for g in (host, guest): + x0, y0, z0 = starts[g.name] + g('command', command=f'tp @s {x0} {y0} {z0}') + g('command', command='gamemode survival') + for name, s in seen.items(): + assert all(v == ['minecraft:dirt', 'minecraft:air'] for v in s['blocks'].values()), \ + f'{name}: unsupported wheat after landing: {seen}' + assert s['server'] == 'minecraft:gold_block', f'{name}: server kept the unsupported wheat: {seen}' + assert s['drops']['wheat'] == 1 and 1 <= s['drops']['wheat_seeds'] <= 4, \ + f'{name}: mature wheat drops missing: {seen}' + assert s['client_drops'] == s['drops'], f'{name}: crop drops did not synchronize: {seen}' + return seen + + +CHECKS += ['farmland'] +CHECK_FNS.update(farmland=check_farmland) + + +def check_large_chest(host, guest, out): + """Every player slot can be picked up or shift-clicked into a double chest (#1505, #1589). + Reopening checks the authoritative contents, with a single chest as the control.""" + seen = {} + for game in (host, guest): + game('command', command='gamemode survival') + x, y, z = (int(v // 1) for v in pos_of(game)) + chest, other = (x, y, z + 2), (x + 1, y, z + 2) + try: + for double in (False, True): + size = 54 if double else 27 + # Double chest indices 54..89 include the old cutoff at 63/64 and every hotbar slot. + sources = list(range(9, 36)) + list(range(9)) if double else [19, 0, 8] + for shift in (False, True): + back_to_game(game) + for at in (chest, other): + game('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:air') + game('command', command='kill @e[type=minecraft:item,distance=..8]') + game('command', command='clear @s') + block = 'minecraft:chest[facing=north,type=left]' if double else 'minecraft:chest' + game('command', command=f'setblock {x} {y} {z + 2} {block}') + if double: + game('command', command=f'setblock {x + 1} {y} {z + 2} minecraft:chest[facing=north,type=right]') + for slot in sources: + name = f'hotbar.{slot}' if slot < 9 else f'inventory.{slot - 9}' + game('command', command=f'item replace entity @s {name} with minecraft:diamond') + game.wait(10) + game.raw('interact', *chest) + game.raw('wait-for', 'screen', 'container', '--timeout', 10) + game.wait(10) + assert container_items(game)[1] == size, f'{game.name}: expected {size} chest slots' + label = f'{"double" if double else "single"}-chest-{"shift" if shift else "pickup"}' + for target, slot in enumerate(sources): + if shift: + game.raw('key', 'shift', 'down') + try: + mouse(game, slot) + finally: + if shift: + game.raw('key', 'shift', 'up') + if not shift: + held = game('inventory').get('carried') or {} + if held.get('item') != 'minecraft:diamond' or held.get('count') != 1: + game.shot(out, f'{label}-slot-{slot}-failed') + raise AssertionError(f'{game.name} {label}: slot {slot} picked up {held}') + mouse(game, 300 + target) + game.raw('key', 'esc', 'tap') + game.wait(10) + game.raw('interact', *chest) + game.raw('wait-for', 'screen', 'container', '--timeout', 10) + game.wait(10) + contents = [s for s in game('screen')['slots'] if 300 <= s['slot'] < 300 + size and s.get('item')] + inv = game('inventory') + stored = sum(s['count'] for s in contents if s['item'] == 'minecraft:diamond') + assert stored == len(sources) and not inv['counts'].get('minecraft:diamond') and not inv.get('carried'), \ + f'{game.name} {label}: chest {contents}, inventory {inv}' + game.shot(out, label) + seen[f'{game.name}-{label}'] = stored + game.raw('key', 'esc', 'tap') + finally: + back_to_game(game) + for at in (chest, other): + game('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:air') + game('command', command='kill @e[type=minecraft:item,distance=..8]') + game('command', command='clear @s') + return seen + + +CHECKS += ['large_chest'] +CHECK_FNS.update(large_chest=check_large_chest) + + +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 index 83e434435..160083d5e 100644 --- a/tools/server_pack_e2e.py +++ b/tools/server_pack_e2e.py @@ -206,9 +206,8 @@ class Game: self.home = work / 'home' for d in ('home', 'launcher', 'data', 'config'): (work / d).mkdir(parents=True) - self.env = dict(os.environ, HORIZON_HOME=str(self.home), HORIZON_LAUNCHER_HOME=str(work / 'launcher'), - XDG_DATA_HOME=str(work / 'data'), XDG_CONFIG_HOME=str(work / 'config'), - HORIZON_LAUNCHER_NO_SELF_UPDATE='1', HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') + 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) @@ -343,7 +342,7 @@ class Run: ('XDG_CONFIG_HOME', 'config')): (work / 'servers' / sub).mkdir(parents=True) os.environ[var] = str(work / 'servers' / sub) - os.environ.update(HORIZON_LAUNCHER_NO_SELF_UPDATE='1', HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') + 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' 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..49a934987 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() @@ -181,20 +181,25 @@ def settle(server, ticks=600, timeout=600): break time.sleep(2) - def game_time(): - start = len(server.lines) - server.console('time query gametime') - while time.time() < deadline: - for line in server.lines[start:]: - if m := re.search(r'The (?:game )?time is (\d+)', line): - return int(m.group(1)) - time.sleep(0.2) - raise AssertionError(f'{server.log_path.name}: no game time in {timeout} s') - until = game_time() + ticks - while game_time() < until: + until = game_time(server, deadline - time.time()) + ticks + while game_time(server, deadline - time.time()) < until: time.sleep(2) +def game_time(server, timeout=300): + """The server's game time, asked from its console: the console runs its queue in order, so every console + command sent before has run.""" + deadline = time.time() + timeout + start = len(server.lines) + server.console('time query gametime') + while time.time() < deadline: + for line in server.lines[start:]: + if m := re.search(r'The (?:game )?time is (\d+)', line): + return int(m.group(1)) + time.sleep(0.05) + raise AssertionError(f'{server.log_path.name}: no game time in {timeout:.0f} s') + + def legacy_ping(port): """The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler).""" host = 'localhost' @@ -352,7 +357,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_item_wire_parity.py b/tools/test_item_wire_parity.py new file mode 100755 index 000000000..1be6042ec --- /dev/null +++ b/tools/test_item_wire_parity.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Item stacks on the wire: every data component, as vanilla 26.3 encodes it. + +VanillaItemWireOracle encodes stacks with ItemStack.OPTIONAL_STREAM_CODEC +(what a server sends in inventories, recipe books and advancements): each +default component value of every vanilla item, the SNBT fixtures below +(direct holders, tags and lists, optional fields, every consume effect, +block predicates with component matchers, the mob variants) and patches +built in Java (components without a persistent codec, removals). The Rust +probe decodes each with horizon_protocol::item::Slot and must consume every +byte and find the same component ids in the same order; a stack whose +components Horizon only reads past must also encode back to the same bytes. +Every id in DataComponents must be covered.""" +import argparse +import json +import os +import platform +import subprocess +from pathlib import Path +try: + from . import lab, test_rust_parity as base +except ImportError: + import lab + import test_rust_parity as base + +COMPONENT_TYPES = 122 + +FIXTURES = [ + ('custom_data', '{custom_data:{a:1,b:"x",c:[1,2]}}'), + ('unbreakable', '{unbreakable:{}}'), + ('custom_name', '{custom_name:{text:"Hi",color:"red",bold:1b}}'), + ('lore', '{lore:["a",{text:"b",italic:0b}]}'), + ('enchantments', '{enchantments:{"minecraft:sharpness":5,"minecraft:unbreaking":3}}'), + ('can_break tag', '{can_break:{blocks:"#minecraft:logs"}}'), + ('can_break list state nbt', '{can_break:[{blocks:["minecraft:stone","minecraft:dirt"],state:{snowy:"true",age:{min:"1",max:"3"},level:{min:"2"}},nbt:"{a:1b}"}]}'), + ('can_place_on components', '{can_place_on:{blocks:"minecraft:chest",components:{"minecraft:custom_name":"x","minecraft:damage":3},predicates:{"minecraft:custom_data":{a:1},"minecraft:damage":{durability:{min:1}}}}}'), + ('can_place_on empty', '{can_place_on:[{}]}'), + ('custom_model_data', '{custom_model_data:{floats:[1.0f,2.5f],flags:[1b,0b],strings:["a"],colors:[16711680]}}'), + ('tooltip_display', '{tooltip_display:{hide_tooltip:1b,hidden_components:["minecraft:enchantments","minecraft:damage"]}}'), + ('repair_cost', '{repair_cost:7}'), + ('intangible_projectile', '{intangible_projectile:{}}'), + ('tooltip_style', '{tooltip_style:"minecraft:fancy"}'), + ('interact_animation', '{interact_animation:{type:"stab",duration:9}}'), + ('dyed_color', '{dyed_color:16711935}'), + ('map_id', '{map_id:42}'), + ('written_book_content', '{written_book_content:{title:{raw:"T",filtered:"F"},author:"me",generation:1,pages:[{raw:"p1",filtered:"q1"},"p2"],resolved:1b}}'), + ('trim registry', '{trim:{material:"minecraft:gold",pattern:"minecraft:coast"}}'), + ('trim direct', '{trim:{material:{palette_id:"minecraft:x",description:"X"},pattern:{asset_id:"minecraft:y",description:"Y",decal:1b}}}'), + ('block_entity_data', '{block_entity_data:{id:"minecraft:chest",Items:[]}}'), + ('lodestone_tracker target', '{lodestone_tracker:{target:{dimension:"minecraft:the_nether",pos:[1,-64,3]},tracked:0b}}'), + ('lodestone_tracker empty', '{lodestone_tracker:{}}'), + ('firework_explosion', '{firework_explosion:{shape:"star",colors:[1,2],fade_colors:[3],has_trail:1b,has_twinkle:0b}}'), + ('profile name', '{profile:{name:"Notch"}}'), + ('profile full', '{profile:{name:"jeb_",id:[I;1,2,3,4],properties:[{name:"textures",value:"abc",signature:"sig"}]}}'), + ('note_block_sound', '{note_block_sound:"minecraft:block.note_block.bell"}'), + ('base_color', '{base_color:"lime"}'), + ('sulfur_cube_content', '{sulfur_cube_content:{id:"minecraft:stone",count:1}}'), + ('lock', '{lock:{items:"minecraft:diamond"}}'), + ('container_loot', '{container_loot:{loot_table:"minecraft:chests/simple_dungeon",seed:5L}}'), + ('waxed', '{waxed:{}}'), + ('banner_patterns', '{banner_patterns:[{pattern:"minecraft:stripe_bottom",color:"red"},{pattern:{asset_id:"minecraft:x",translation_key:"y"},color:"blue"}]}'), + ('pot_decorations', '{pot_decorations:{back:{id:"minecraft:brick"},left:{id:"minecraft:angler_pottery_sherd"},front:{id:"minecraft:skull_pottery_sherd",count:1}}}'), + ('suspicious_stew_effects', '{suspicious_stew_effects:[{id:"minecraft:night_vision",duration:100},{id:"minecraft:poison"}]}'), + ('potion_contents full', '{potion_contents:{potion:"minecraft:swiftness",custom_color:123,custom_effects:[{id:"minecraft:speed",amplifier:1b,duration:200,ambient:1b,show_particles:0b,show_icon:1b,hidden_effect:{id:"minecraft:speed",duration:100,hidden_effect:{id:"minecraft:speed",duration:50}}}],custom_name:"x"}}'), + ('potion_contents bare', '{potion_contents:{}}'), + ('container', '{container:[{slot:0,item:{id:"minecraft:stone",count:3}},{slot:5,item:{id:"minecraft:diamond_sword",components:{"minecraft:damage":5,"minecraft:trim":{material:"minecraft:gold",pattern:"minecraft:coast"}}}}]}'), + ('bundle_contents', '{bundle_contents:[{id:"minecraft:stone",count:2},{id:"minecraft:potion",components:{"minecraft:potion_contents":{potion:"minecraft:water"}}}]}'), + ('charged_projectiles', '{charged_projectiles:[{id:"minecraft:arrow"},{id:"minecraft:firework_rocket",components:{"minecraft:fireworks":{flight_duration:2b,explosions:[{shape:"burst",colors:[5]}]}}}]}'), + ('block_state', '{block_state:{facing:"north",half:"top"}}'), + ('bees', '{bees:[{entity_data:{id:"minecraft:bee",Health:5f},ticks_in_hive:5,min_ticks_in_hive:10}]}'), + ('entity_data', '{entity_data:{id:"minecraft:pig",NoAI:1b}}'), + ('bucket_entity_data', '{bucket_entity_data:{Health:5f}}'), + ('instrument direct', '{instrument:{sound_event:{sound_id:"minecraft:x",range:8f},use_duration:3f,range:64f,description:"Horn"}}'), + ('painting variant', '{"minecraft:painting/variant":"minecraft:kebab"}'), + ('sign_text_front', '{sign_text_front:{messages:["a","b","c","d"],filtered_messages:["e","f","g","h"],color:"red",has_glowing_text:1b}}'), + ('sign_text_back', '{sign_text_back:{messages:["a","","",""]}}'), + ('map_decorations', '{map_decorations:{a:{type:"minecraft:player",x:1.0d,z:2.0d,rotation:0f}}}'), + ('debug_stick_state', '{debug_stick_state:{"minecraft:oak_stairs":"facing"}}'), + ('recipes', '{recipes:["minecraft:stone_bricks"]}'), + ('attribute_modifiers', '{attribute_modifiers:[{type:"minecraft:attack_damage",id:"minecraft:x",amount:1.5d,operation:"add_value",slot:"mainhand",display:{type:"override",value:"hi"}},{type:"minecraft:armor",id:"minecraft:y",amount:2d,operation:"add_multiplied_total",display:{type:"hidden"}}]}'), + ('consumable all effects', '{consumable:{consume_seconds:2f,animation:"drink",sound:{sound_id:"minecraft:x",range:4f},has_consume_particles:0b,on_consume_effects:[{type:"apply_effects",effects:[{id:"minecraft:speed",duration:20}],probability:0.5f},{type:"remove_effects",effects:"minecraft:poison"},{type:"remove_effects",effects:["minecraft:poison","minecraft:wither"]},{type:"clear_all_effects"},{type:"teleport_randomly",diameter:8f},{type:"play_sound",sound:"minecraft:entity.generic.eat"}]}}'), + ('death_protection', '{death_protection:{death_effects:[{type:"clear_all_effects"}]}}'), + ('equippable full', '{equippable:{slot:"head",equip_sound:"minecraft:item.armor.equip_gold",asset_id:"minecraft:gold",camera_overlay:"minecraft:misc/pumpkinblur",allowed_entities:"#minecraft:skeletons",dispensable:0b,swappable:0b,damage_on_hurt:0b,equip_on_interact:1b,can_be_sheared:1b,shearing_sound:{sound_id:"minecraft:y"}}}'), + ('equippable bare', '{equippable:{slot:"chest"}}'), + ('tool rules', '{tool:{rules:[{blocks:"#minecraft:mineable/pickaxe",speed:4f,correct_for_drops:1b},{blocks:["minecraft:stone"]}],default_mining_speed:2f,damage_per_block:2,can_destroy_blocks_in_creative:0b}}'), + ('blocks_attacks full', '{blocks_attacks:{block_delay_seconds:0.5f,disable_cooldown_scale:2f,damage_reductions:[{horizontal_blocking_angle:45f,type:"#minecraft:is_fire",base:1f,factor:0.5f},{base:0f,factor:1f}],item_damage:{threshold:3f,base:1f,factor:2f},bypassed_by:"#minecraft:bypasses_shield",block_sound:"minecraft:item.shield.block",disable_sound:{sound_id:"minecraft:z"}}}'), + ('damage_resistant', '{damage_resistant:{types:"#minecraft:is_fire"}}'), + ('repairable list', '{repairable:{items:["minecraft:diamond","minecraft:emerald"]}}'), + ('use_cooldown group', '{use_cooldown:{seconds:1.5f,cooldown_group:"minecraft:x"}}'), + ('use_remainder', '{use_remainder:{id:"minecraft:bowl",count:2}}'), + ('fireworks', '{fireworks:{flight_duration:3b,explosions:[{shape:"creeper",colors:[1],fade_colors:[2,3],has_trail:1b},{shape:"small_ball"}]}}'), + ('provides_banner_patterns', '{provides_banner_patterns:"#minecraft:pattern_item/globe"}'), + ('wolf variant', '{"minecraft:wolf/variant":"minecraft:ashen","minecraft:wolf/sound_variant":"minecraft:angry","minecraft:wolf/collar":"red"}'), + ('fox salmon parrot', '{"minecraft:fox/variant":"snow","minecraft:salmon/size":"large","minecraft:parrot/variant":"blue"}'), + ('tropical fish', '{"minecraft:tropical_fish/pattern":"flopper","minecraft:tropical_fish/base_color":"white","minecraft:tropical_fish/pattern_color":"black"}'), + ('mooshroom rabbit', '{"minecraft:mooshroom/variant":"brown","minecraft:rabbit/variant":"gold"}'), + ('pig cow chicken', '{"minecraft:pig/variant":"minecraft:cold","minecraft:pig/sound_variant":"minecraft:big","minecraft:cow/variant":"minecraft:warm","minecraft:cow/sound_variant":"minecraft:classic","minecraft:chicken/variant":"minecraft:cold","minecraft:chicken/sound_variant":"minecraft:classic"}'), + ('nautilus frog horse', '{"minecraft:zombie_nautilus/variant":"minecraft:warm","minecraft:frog/variant":"minecraft:cold","minecraft:horse/variant":"chestnut"}'), + ('llama axolotl cat', '{"minecraft:llama/variant":"brown","minecraft:axolotl/variant":"blue","minecraft:cat/variant":"minecraft:tabby","minecraft:cat/sound_variant":"minecraft:classic","minecraft:cat/collar":"blue"}'), + ('sheep shulker villager', '{"minecraft:sheep/color":"pink","minecraft:shulker/color":"purple","minecraft:villager/variant":"minecraft:taiga"}'), + ('trim material direct provider', '{provides_trim_material:{palette_id:"minecraft:x",description:"X"}}'), + ('everything at once', '{damage:3,unbreakable:{},custom_name:"n",enchantments:{"minecraft:mending":1},trim:{material:"minecraft:gold",pattern:"minecraft:coast"},banner_patterns:[{pattern:"minecraft:globe",color:"red"}],pot_decorations:{right:{id:"minecraft:brick"}},lore:["x"],rarity:"epic"}'), +] +# Fixtures on another item than a stick (the components need it, or read better there). +ITEMS = {'profile name': 'player_head', 'profile full': 'player_head', 'trim registry': 'diamond_chestplate', + 'trim direct': 'diamond_chestplate', 'banner_patterns': 'white_banner', 'pot_decorations': 'decorated_pot', + 'everything at once': 'diamond_chestplate'} + + +def compare(vanilla, rust): + """Failures, stacks checked, and the component ids covered.""" + results = {r['label']: r for r in rust} + failures, covered = [], set() + for v in vanilla: + if 'error' in v: + failures.append(f"oracle {v['label']}: {v['error']}") + continue + covered.update(v['added'] + v['removed']) + r = results.get(v['label']) + if r is None or 'error' in r: + failures.append(f"{v['label']}: {r and r['error']}") + elif r['left'] or r['added'] != v['added'] or r['removed'] != v['removed']: + failures.append(f"{v['label']}: {r['left']} bytes left, ids {r['added']}/{r['removed']}, vanilla {v['added']}/{v['removed']}") + elif not r['same_bytes'] and not r['typed']: + failures.append(f"{v['label']}: read past, but encoded back differently") + missing = sorted(set(range(COMPONENT_TYPES)) - covered) + if missing: + failures.append(f'component ids no stack covers: {missing}') + return failures, len(vanilla), covered + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--prepare', action='store_true') + args = parser.parse_args() + build = lab.LOCAL / 'item-wire-parity' + build.mkdir(parents=True, exist_ok=True) + report_path = build / 'report.json' + report_path.unlink(missing_ok=True) + if args.prepare: + lab.prepare() + lock, jars, libraries = base.verify_artifacts() + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaItemWireOracle.java' + classes = build / 'classes' + classes.mkdir(exist_ok=True) + + def run(command, name): + with (build / (name + '.log')).open('w', encoding='utf-8') as log: + base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT) + dependency_path = os.pathsep.join(map(str, libraries)) + run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', + lab.ROOT / 'mods/horizon/src/test/java', '-cp', str(jars['server']) + os.pathsep + dependency_path, + '-d', classes, oracle], 'compile-java') + fixtures = build / 'fixtures.tsv' + fixtures.write_text(''.join(f'{label}\t{{id:"minecraft:{ITEMS.get(label, "stick")}",count:1,components:{snbt}}}\n' + for label, snbt in FIXTURES), encoding='utf-8') + vanilla_path, rust_path = build / 'vanilla.jsonl', build / 'rust.jsonl' + run(['java', '-Xmx1G', '-cp', os.pathsep.join([str(classes), str(jars['server']), dependency_path]), + 'dev.horizonlab.parity.VanillaItemWireOracle', fixtures, vanilla_path], 'oracle') + run(['cargo', 'build', '--release', '-p', 'horizon-protocol', '--example', 'item_wire_probe'], 'compile-rust') + binary = lab.cargo_target() / 'release/examples' / ('item_wire_probe.exe' if os.name == 'nt' else 'item_wire_probe') + run([binary, vanilla_path, rust_path], 'rust') + read = lambda path: [json.loads(line) for line in path.read_text(encoding='utf-8').splitlines() if line.strip()] + failures, stacks, covered = compare(read(vanilla_path), read(rust_path)) + for failure in failures[:40]: + print(failure) + if failures: + raise SystemExit(f'{len(failures)} item wire mismatches (of {stacks} stacks)') + lab.write_json(report_path, { + 'schema': 1, 'minecraft': lock['minecraft']['version'], 'platform': platform.platform(), + 'stacks': stacks, 'component_types_covered': len(covered), + 'oracle_sha256': lab.digest(vanilla_path, 'sha256'), 'rust_sha256': lab.digest(rust_path, 'sha256')}) + print(f'Item wire parity passed: {stacks} stacks, all {len(covered)} component types: {report_path}') + + +if __name__ == '__main__': + main() 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_server_player_targets_parity.py b/tools/test_server_player_targets_parity.py index cad8782cc..263aa4a59 100644 --- a/tools/test_server_player_targets_parity.py +++ b/tools/test_server_player_targets_parity.py @@ -10,7 +10,11 @@ A vanilla dedicated server and Horizon's (`horizon-client --dedicated --nogui`) vanilla generated first, with Alice and Bob as operators in creative. LocatorBarClient joins them both (players made of vanilla's protocol code) and records, step by step, the system chat each receives and what the server changes about it: game mode events, teleports, inventory slots, effects, its death (with the death message), the other -players it is sent or loses and the levels it respawns into. Each player's lines in each step are compared exactly, +players it is sent or loses and the levels it respawns into. A step ends by the server's clock, not the wall's: its +console commands have run (the console's `time query gametime` comes back), each player's commands have run (a +`sync` round trip), the server has ticked STEP_TICKS more times, and each client holds what was sent until then (a +last `sync`), so a server that stalls under load still has each packet recorded in its own step (a fixed 2.5 s +filed a stalled vanilla's teleports under the next step). Each player's lines in each step are compared exactly, in sorted order (the packets of one step may leave in another order within the tick), with the locator bar's waypoints as each step leaves them (one manager per level: a player in another level is untracked). What a death does besides its messages is left to its own harness. @@ -25,12 +29,12 @@ import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server + from .test_dedicated_server_parity import Server, game_time from .test_locator_bar_parity import generate_world, server_dir except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server + from test_dedicated_server_parity import Server, game_time from test_locator_bar_parity import generate_world, server_dir NAME = 'server-player-targets-parity' @@ -70,7 +74,8 @@ SCRIPT = [ # What the players' locator bars show has its own harness (test_locator_bar_parity), and what a death does # besides its messages (drops, the body leaving) the player combat ones: here only the messages of `kill`. DEATH_STEP = 'step=console-kill' -STEP_SECONDS = 2.5 +STEP_TICKS = 40 +PLAYERS = ('Alice', 'Bob') def run_side(label, server_command, client_command, build, world): @@ -83,32 +88,49 @@ def run_side(label, server_command, client_command, build, world): server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) def tell(line): client.stdin.write(line + '\n') client.stdin.flush() + + def sync(): + for name in PLAYERS: + tell(f'sync {name}') + for name in PLAYERS: + while (line := client.stdout.readline()) != f'synced {name}\n': + if not line: + raise AssertionError(f'{label}: the client exited (see {build}/{label}-client.log)') + log.write(line) + + def finish_step(): + sync() + until = game_time(server) + STEP_TICKS + while game_time(server) < until: + time.sleep(0.2) + for name in PLAYERS: + tell(f'still {name}') + sync() try: - for name, x in (('Alice', 0.5), ('Bob', 4.5)): + for name, x in zip(PLAYERS, (0.5, 4.5)): tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) tell(f'fly {name} on') tell(f'cmd {name} tp @s {x} -60 0.5 0 0') - time.sleep(STEP_SECONDS) + finish_step() for flag in ('chat', 'state', 'players'): tell(f'{flag} on') for step, console, actions in SCRIPT: tell(f'step {step}') for command in console: server.console(command) + game_time(server) # the console runs its queue in order: these commands have run for action in actions: tell(action) - time.sleep(STEP_SECONDS) - for name in ('Alice', 'Bob'): - tell(f'still {name}') + finish_step() tell('end') - client.wait(timeout=60) + log.write(client.communicate(timeout=60)[0]) finally: if client.poll() is None: client.kill() diff --git a/tools/test_stop_sound_wire_parity.py b/tools/test_stop_sound_wire_parity.py new file mode 100644 index 000000000..480e760a5 --- /dev/null +++ b/tools/test_stop_sound_wire_parity.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Stop-sound packet bytes and selections against the native Java codec.""" +import json +import os +try: + from . import lab, test_rust_parity as base, oracle_harness as harness +except ImportError: + import lab + import test_rust_parity as base + import oracle_harness as harness + + +def main(): + build=lab.LOCAL/'stop-sound-wire-parity'; build.mkdir(exist_ok=True) + (build/'report.json').unlink(missing_ok=True) + lock,jars,libraries=base.verify_artifacts() + cp=os.pathsep.join(map(str,[jars['server'],*libraries])); classes=build/'classes';classes.mkdir(exist_ok=True) + source=lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStopSoundWireOracle.java' + sources=[source,lab.ROOT/'crates/horizon-protocol/src/packets/play.rs',lab.ROOT/'crates/horizon-client/src/game/remote.rs'] + tested=base.source_hashes(sources) + run=lambda cmd,name:harness.run_logged(cmd,build,name) + run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-cp',cp,'-d',classes,source],'compile-java') + run(['java','-cp',str(classes)+os.pathsep+cp,'dev.horizonlab.parity.VanillaStopSoundWireOracle',build/'java.jsonl'],'java') + run(['cargo','build','-p','horizon-protocol','--example','stop_sound_probe'],'compile-rust') + run([lab.cargo_target()/'debug/examples/stop_sound_probe',build/'java.jsonl',build/'rust.jsonl'],'rust') + java=[json.loads(x) for x in (build/'java.jsonl').read_text().splitlines()] + rust=[json.loads(x) for x in (build/'rust.jsonl').read_text().splitlines()] + assert len(java)==len(rust)==36 + assert all({'source':a.get('source'),'sound':a.get('sound')}==b for a,b in zip(java,rust)) + base.ensure_sources_unchanged(sources,tested) + lab.write_json(build/'report.json',{'pass':True,'cases':len(java),'sources_sha256':tested}) + print(f'Stop sound: {len(java)} native wire selections match and re-encode byte for byte') + + +if __name__=='__main__':main() diff --git a/tools/test_structure_layout_parity.py b/tools/test_structure_layout_parity.py new file mode 100644 index 000000000..185dde578 --- /dev/null +++ b/tools/test_structure_layout_parity.py @@ -0,0 +1,236 @@ +#!/usr/bin/env python3 +"""Compare Horizon's structure starts, piece by piece, with the starts a real server saved. + +Expected side: the clean-room structure oracle (horizon-parity `cleanroom/structures/oracle/`), which ran +vanilla 1.21.1 servers and kept every saved start. Its `base_pieces` are the no-mod world's start of each +located structure (villages, outposts, trial chambers, shipwrecks, ruined portals, desert pyramids): the +vanilla layout. Its results live outside the repository; put them (or link them) under +`.local/structure-oracle//seed-.json.gz`, or point HORIZON_STRUCTURE_ORACLE at that folder. + +Horizon side: the structure_pieces probe generates the same seed and lists the starts each chunk owns. +Jigsaw pieces must match exactly: element (template location), rotation, position, ground level delta and +bounding box, in saved order. Other pieces (shipwrecks, ruined portals, desert pyramids) match by type and +horizontal box: their height is settled when they are placed, after the start is created, and the oracle +saved them placed. + +The oracle's game is 1.21.1 and Horizon's 26.3. KNOWN lists the starts where 26.3 itself differs from +1.21.1, each checked against 26.3 vanilla (VanillaChunkGenerationOracle's `scan`, HORIZON_PIECES=1), whose +pieces equal Horizon's there; they are reported, not failed. + +Mod profiles compare the mod world's `pieces` instead. Horizon then reads the mod's own data from its jar +(`.local/structure-oracle/jars/`, or HORIZON_STRUCTURE_JARS): an overlay of the 26.3 resources adds the +jar's structures, sets, pools, processor lists, biome tags and templates, as they are written. The mod's +own processors are left out of the overlay's lists: they change blocks, never which pieces are placed. +Block states are upgraded to 26.3's JSON shape, as the port does. +The jars are the player's; nothing of them enters the repository. + +usage: test_structure_layout_parity.py [--profile lithostitched|betterdungeons] [--filter REGEX] [--verbose] +""" +import argparse +import gzip +import json +import os +import re +import shutil +import subprocess +import sys +import zipfile +from pathlib import Path + +try: + from . import lab +except ImportError: + import lab + +ORACLE = Path(os.environ.get('HORIZON_STRUCTURE_ORACLE', lab.LOCAL / 'structure-oracle')) +JARS = Path(os.environ.get('HORIZON_STRUCTURE_JARS', ORACLE / 'jars')) +# Per profile: which saved pieces are expected, the mod jars whose data Horizon reads, and the structures +# compared (a regex; None: every start that has the pieces). +PROFILES = { + 'lithostitched': {'side': 'base_pieces', 'jars': [], 'structures': None}, + 'betterdungeons': {'side': 'pieces', 'jars': ['YungsApi-1.21.1-NeoForge-5.1.9.jar', 'YungsBetterDungeons-1.21.1-NeoForge-5.1.4.jar'], + 'structures': r'^betterdungeons:(small|skeleton|zombie)_dungeon$'}, +} +BUNDLES = {'structure': 'structures', 'structure_set': 'structure_sets', 'template_pool': 'template_pools', + 'processor_list': 'processor_lists'} +# (profile, seed, structure id, start chunk x, z) -> how 26.3 vanilla differs from 1.21.1 there. +TRIAL_CHAMBERS = '26.3 vanilla lays it out as Horizon does, unlike 1.21.1' +SULFUR_CAVES = "the start is in 26.3's sulfur_caves, a biome the mod's 1.21.1 tag cannot list" +RUINED_PORTAL = "26.3 vanilla's portal is Horizon's; 1.21.1 picked another" +KNOWN = { + ('lithostitched', 1234, 'minecraft:village_plains', -24, 47): 'no start in 26.3 vanilla (nor in Horizon)', + ('lithostitched', 1234, 'minecraft:ruined_portal', -16, 51): RUINED_PORTAL, + ('lithostitched', 42, 'minecraft:ruined_portal', -19, -38): RUINED_PORTAL, + ('betterdungeons', 1234, 'betterdungeons:small_dungeon', 162, 10): SULFUR_CAVES, + ('betterdungeons', 42, 'betterdungeons:small_dungeon', -29, -28): SULFUR_CAVES, + **{('lithostitched', seed, 'minecraft:trial_chambers', x, z): TRIAL_CHAMBERS + for seed, x, z in [(1234, 13, 21), (2, -28, 13), (2, 11, 16), (2, 146, 44), (42, 17, 7), (42, 38, -25)]}, +} + + +def element(saved): + kind = saved.get('element_type') + if kind in ('minecraft:single_pool_element', 'minecraft:legacy_single_pool_element', 'yungsapi:yung_single_element'): + location = saved['location'] + return location if ':' in location else 'minecraft:' + location + if kind == 'minecraft:feature_pool_element': + return 'feature:' + saved['feature'] + if kind == 'minecraft:list_pool_element': + return 'list:' + '+'.join(element(e) for e in saved['elements']) + if kind == 'minecraft:empty_pool_element': + return 'empty' + return kind + + +def expected_piece(saved): + box = saved['BB'] + piece = {'type': saved['id'], 'box': box if saved['id'] == 'minecraft:jigsaw' else [box[0], box[2], box[3], box[5]]} + if saved['id'] == 'minecraft:jigsaw': + piece.update(element=element(saved['pool_element']), rotation=saved['rotation'], + position=[saved['PosX'], saved['PosY'], saved['PosZ']], ground_level_delta=saved['ground_level_delta']) + return piece + + +def upgrade_states(value): + """1.21.1's block states (`{"Name", "Properties"}`) in 26.3's shape (`{"id", "properties"}`).""" + if isinstance(value, list): + return [upgrade_states(v) for v in value] + if not isinstance(value, dict): + return value + if 'Name' in value and set(value) <= {'Name', 'Properties'}: + return {'id': value['Name'], **({'properties': value['Properties']} if 'Properties' in value else {})} + return {k: upgrade_states(v) for k, v in value.items()} + + +def overlay(profile, jars): + """The 26.3 resources plus the jars' structure data, in a folder the probe reads as its resources.""" + root = lab.LOCAL / 'structure-layout' / profile + shutil.rmtree(root, ignore_errors=True) + worldgen = root / 'worldgen' + (worldgen / 'structure').mkdir(parents=True) + (root / 'facts.json').symlink_to(lab.RESOURCES / 'facts.json') + source = lab.RESOURCES / 'worldgen' + merged = {name: json.loads((source / f'{name}.json').read_text()) for name in [*BUNDLES.values(), 'biome_tags']} + for entry in source.iterdir(): + if entry.name != 'structure' and entry.stem not in merged: + (worldgen / entry.name).symlink_to(entry) + for namespace in (source / 'structure').iterdir(): + (worldgen / 'structure' / namespace.name).symlink_to(namespace) + for jar in jars: + with zipfile.ZipFile(JARS / jar) as archive: + for name in archive.namelist(): + parts = name.split('/') + if parts[0] != 'data' or len(parts) < 4 or name.endswith('/'): + continue + namespace, kind = parts[1], parts[2] + if kind == 'structure' and name.endswith('.nbt'): + target = worldgen / 'structure' / namespace / '/'.join(parts[3:]) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(archive.read(name)) + elif name.endswith('.json') and kind == 'worldgen' and parts[3] in BUNDLES: + value = upgrade_states(json.loads(archive.read(name))) + if parts[3] == 'processor_list': + value['processors'] = [p for p in value['processors'] if p['processor_type'].startswith('minecraft:')] + merged[BUNDLES[parts[3]]][f'{namespace}:' + '/'.join(parts[4:])[:-5]] = json.dumps(value) + elif name.endswith('.json') and parts[2:5] == ['tags', 'worldgen', 'biome']: + tag = f'{namespace}:' + '/'.join(parts[5:])[:-5] + value = json.loads(archive.read(name)) + if tag in merged['biome_tags'] and not value.get('replace'): + value['values'] = json.loads(merged['biome_tags'][tag])['values'] + value['values'] + merged['biome_tags'][tag] = json.dumps(value) + for name, bundle in merged.items(): + (worldgen / f'{name}.json').write_text(json.dumps(bundle)) + return root + + +def probe_binary(): + subprocess.run(['cargo', 'build', '--release', '-q', '-p', 'horizon-world', '--example', 'world_probe'], check=True, cwd=lab.ROOT) + name = 'world_probe.exe' if os.name == 'nt' else 'world_probe' + return lab.cargo_target() / 'release/examples' / name + + +def horizon_starts(binary, resources, seed, dimension, chunks): + result = subprocess.run([str(binary), 'structure_pieces', str(resources), str(seed), dimension, + *(f'{x},{z}' for x, z in chunks)], capture_output=True, text=True, cwd=lab.ROOT) + if result.returncode: + raise SystemExit('structure_pieces failed: ' + result.stderr[-2000:]) + starts, current = {}, None + for line in result.stdout.splitlines(): + fields = line.split() + if fields[0] == 'start': + current = starts.setdefault((fields[1], int(fields[2]), int(fields[3])), []) + elif fields[0] == 'piece': + box = list(map(int, fields[8:14])) + piece = {'type': fields[1], 'box': box if fields[1] == 'minecraft:jigsaw' else [box[0], box[2], box[3], box[5]]} + if fields[1] == 'minecraft:jigsaw': + piece.update(element=fields[2], rotation=fields[3], position=list(map(int, fields[4:7])), + ground_level_delta=int(fields[7])) + current.append(piece) + return starts + + +def compare(expected, actual): + """Index of the first differing piece and what differs, or None.""" + for i, (want, got) in enumerate(zip(expected, actual)): + if want != got: + return i, {k: (want.get(k), got.get(k)) for k in want.keys() | got.keys() if want.get(k) != got.get(k)} + if len(expected) != len(actual): + return min(len(expected), len(actual)), {'pieces': (len(expected), len(actual))} + return None + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--profile', default='lithostitched', choices=sorted(PROFILES)) + parser.add_argument('--filter', default='', help='only structure ids matching this regex') + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + results = sorted((ORACLE / args.profile).glob('seed-*.json.gz')) + if not results: + print(f'SKIP: no oracle results in {ORACLE / args.profile} (see this file\'s docstring)') + return 0 + profile = PROFILES[args.profile] + missing = [jar for jar in profile['jars'] if not (JARS / jar).exists()] + if missing: + print(f'SKIP: mod jars not in {JARS}: {", ".join(missing)}') + return 0 + resources = overlay(args.profile, profile['jars']) if profile['jars'] else lab.RESOURCES + binary = probe_binary() + matched, known, failed = 0, 0, [] + for path in results: + oracle = json.load(gzip.open(path)) + seed = oracle['seed'] + by_dimension = {} + for start in oracle['structures']: + if start.get(profile['side']) is None or not re.search(args.filter, start['id']) \ + or not re.search(profile['structures'] or '', start['id']): + continue + by_dimension.setdefault(start['dimension'], []).append(start) + for dimension, starts in by_dimension.items(): + chunks = sorted({tuple(s['start_chunk']) for s in starts}) + actual = horizon_starts(binary, resources, seed, dimension.removeprefix('minecraft:'), chunks) + for start in starts: + key = (start['id'], *start['start_chunk']) + expected = [expected_piece(p) for p in start[profile['side']]] + got = actual.get(key) + label = f'seed {seed} {start["id"]} chunk {start["start_chunk"]}' + difference = (0, {'start': 'missing in Horizon'}) if got is None else compare(expected, got) + reason = KNOWN.get((args.profile, seed, *key)) + if difference is None: + matched += 1 + if args.verbose: + print(f'ok {label}: {len(expected)} pieces') + elif reason: + known += 1 + print(f'known {label}: {reason}') + else: + failed.append(label) + index, fields = difference + print(f'FAIL {label}: {len(expected)} pieces expected, {len(got or [])} placed; piece {index}: {fields}') + total = matched + known + len(failed) + print(f'{matched} of {total} starts match the oracle piece for piece; {known} known version differences') + return 1 if failed else 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/test_text_display_parity.py b/tools/test_text_display_parity.py new file mode 100644 index 000000000..5eef8b79c --- /dev/null +++ b/tools/test_text_display_parity.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +"""Decode text-display metadata produced by vanilla's actual entity accessors/codecs.""" +import json +import os +from pathlib import Path +try: + from . import lab, test_rust_parity as base, oracle_harness as harness +except ImportError: + import lab + import test_rust_parity as base + import oracle_harness as harness + + +def main(): + build = lab.LOCAL / 'text-display-parity' + build.mkdir(parents=True, exist_ok=True) + (build / 'report.json').unlink(missing_ok=True) + lock, jars, libraries = base.verify_artifacts() + cases = [{}] + [dict(flags=flags, opacity=opacity, billboard=billboard, + text={'text': 'Lobby 日本語', 'bold': bool(flags & 1)}, + translation=[1.25, -2.5, 0.0], scale=[0.5, 2.0, 1.0], + left_rotation=[0, 0, 0, 1], right_rotation=[0, 1, 0, 0], + line_width=80, background=-2147418368, brightness=15728880, + interpolation_delay=-1, interpolation_duration=12, teleport_duration=4, + view_range=2.0, shadow_radius=0.5, shadow_strength=0.75, width=3.0, height=2.0, glow_color=16711680) + for flags in range(32) for opacity in (-128, -1, 0, 127) for billboard in range(4)] + fixtures = build / 'cases.jsonl' + fixtures.write_text(''.join(json.dumps(c, ensure_ascii=False) + '\n' for c in cases)) + classes = build / 'classes' + classes.mkdir(exist_ok=True) + source = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayOracle.java' + sources = [Path(__file__).resolve(), source, + lab.ROOT / 'crates/horizon-client/src/text_display.rs', + lab.ROOT / 'crates/horizon-protocol/src/entity_data.rs', lab.ROOT / 'Cargo.lock'] + tested = base.source_hashes(sources) + cp = os.pathsep.join(map(str, [jars['server'], *libraries])) + run = lambda command, name: harness.run_logged(command, build, name) + run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', + lab.ROOT / 'mods/horizon/src/test/java', '-cp', cp, '-d', classes, source], 'compile-java') + run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + cp, + 'dev.horizonlab.parity.VanillaTextDisplayOracle', fixtures, build / 'java.jsonl'], 'java') + command = harness.build_probe(build, 'text_display_fixture') + run([*command, build / 'java.jsonl', build / 'rust.jsonl'], 'rust') + expected = [json.loads(line)['expected'] for line in (build / 'java.jsonl').read_text().splitlines()] + actual = [json.loads(line) for line in (build / 'rust.jsonl').read_text().splitlines()] + assert len(expected) == len(actual) == len(cases) + for index, (a, b) in enumerate(zip(expected, actual)): + assert a == b, (index, a, b) + base.ensure_sources_unchanged(sources, tested) + lab.write_json(build / 'report.json', {'minecraft': lab.VERSION, 'cases': len(cases), 'pass': True, + 'sources_sha256': tested, 'java_output_sha256': lab.digest(build / 'java.jsonl', 'sha256')}) + print(f'Text display metadata parity: {len(cases)} cases match vanilla') + + +if __name__ == '__main__': + main() diff --git a/tools/test_text_display_transform_parity.py b/tools/test_text_display_transform_parity.py new file mode 100644 index 000000000..81cda5bf7 --- /dev/null +++ b/tools/test_text_display_transform_parity.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +"""Compare text-display matrices with the real Java client renderer (no window).""" +import json +import os +try: + from . import lab, test_rust_parity as base, oracle_harness as harness, test_text_display_parity as metadata +except ImportError: + import lab + import test_rust_parity as base + import oracle_harness as harness + import test_text_display_parity as metadata + + +def main(): + metadata.main() + build = lab.LOCAL / 'text-display-transform-parity' + build.mkdir(exist_ok=True) + (build / 'report.json').unlink(missing_ok=True) + lock, jars, libraries = base.verify_artifacts() + cp = os.pathsep.join(map(str, [jars['client'], jars['server'], *libraries])) + classes = build / 'classes' + classes.mkdir(exist_ok=True) + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTextDisplayTransformOracle.java' + sources = [oracle, lab.ROOT/'crates/horizon-client/src/text_display.rs', + lab.ROOT/'crates/horizon-client/src/game/text_displays.rs'] + tested = base.source_hashes(sources) + source = lab.LOCAL / 'text-display-parity/java.jsonl' + # Every billboard mode, coupled and independent entity/camera rotations. + all_states = [json.loads(line) for line in source.read_text().splitlines()] + cases = [] + for state in all_states[1:5]: + for yaw in (-180, 0, 37): + for pitch in (-45, 0, 75): + for camera in ((0, 0), (97, -60), (-150, 42)): + cases.append(dict(state, angles=[yaw, pitch, *camera])) + inputs = build / 'cases.jsonl' + inputs.write_text(''.join(json.dumps(case) + '\n' for case in cases)) + harness.run_logged(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-sourcepath',lab.ROOT/'mods/horizon/src/test/java','-cp',cp,'-d',classes,oracle],build,'compile-java') + harness.run_logged(['java','-Xmx1G','-cp',str(classes)+os.pathsep+cp,'dev.horizonlab.parity.VanillaTextDisplayTransformOracle',inputs,build/'java.jsonl'],build,'java') + command = harness.build_probe(build,'text_display_fixture') + harness.run_logged([*command,inputs,build/'rust.jsonl'],build,'rust') + java = [json.loads(line) for line in (build/'java.jsonl').read_text().splitlines()] + rust = [json.loads(line) for line in (build/'rust.jsonl').read_text().splitlines()] + assert len(java) == len(rust) == len(cases) + for i,(a,b) in enumerate(zip(java,rust)): + # JOML and glam evaluate float matrix products in different orders. + assert all(abs(x-y) <= 0.00002 for x,y in zip(a,b)), (i,a,b) + base.ensure_sources_unchanged(sources, tested) + lab.write_json(build/'report.json', {'pass':True,'cases':len(cases),'matrix_absolute_tolerance':0.00002, + 'sources_sha256':tested}) + print(f'Text-display transforms: {len(cases)} cases match the native client renderer') + + +if __name__ == '__main__': + main() 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/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), ""); +});