diff --git a/Cargo.lock b/Cargo.lock index 6da6a64b1..27eaad0c4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1278,6 +1278,7 @@ dependencies = [ "rustix 1.1.5", "serde", "serde_json", + "sha1", "sha2", "symphonia", "ureq", diff --git a/crates/horizon-bench/src/hardware.rs b/crates/horizon-bench/src/hardware.rs index 17e460bed..440c834d8 100644 --- a/crates/horizon-bench/src/hardware.rs +++ b/crates/horizon-bench/src/hardware.rs @@ -1,8 +1,7 @@ //! The machine a report was measured on. CPU, RAM and OS are detected here; the GPU and the display //! come from the program that rendered (the game knows its adapter, the launcher its window). -use std::process::Command; - +use horizon_telemetry::system::command_output as output; use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] @@ -173,12 +172,6 @@ pub fn cpu_seconds(pid: u32) -> Option { Some(ticks / 100.0) } -fn output(program: &str, args: &[&str]) -> Option { - let out = Command::new(program).args(args).output().ok()?; - let text = String::from_utf8(out.stdout).ok()?.trim().to_owned(); - (out.status.success() && !text.is_empty()).then_some(text) -} - #[cfg(target_os = "macos")] fn os_version() -> Option { output("sw_vers", &["-productVersion"]) diff --git a/crates/horizon-bench/src/lib.rs b/crates/horizon-bench/src/lib.rs index bdc885af1..ae70977bd 100644 --- a/crates/horizon-bench/src/lib.rs +++ b/crates/horizon-bench/src/lib.rs @@ -245,13 +245,19 @@ pub struct Report { impl Report { /// An empty report for this machine, created now. pub fn new(kind: Kind, app: App) -> Report { + Self::with_hardware(kind, app, Hardware::detect()) + } + + /// Starts a report using supplied hardware, without running system probes. + /// Interactive apps can collect the remaining machine details after their first frame. + pub fn with_hardware(kind: Kind, app: App, hardware: Hardware) -> Report { Report { format: FORMAT.to_owned(), version: VERSION, kind, created: utc_now(), app, - hardware: Hardware::detect(), + hardware, conditions: Conditions::default(), metrics: BTreeMap::new(), frames: Vec::new(), diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index 35e9bee5c..85373b288 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -27,6 +27,8 @@ bytemuck = { version = "1.24", features = ["derive"] } glam = "0.30" png = "0.18" sha2 = "0.10.9" +# Server resource packs are checked and cached by their SHA-1, as vanilla does. +sha1 = "0.10" serde = { version = "1", features = ["derive"] } serde_json = { version = "1.0.151", features = ["raw_value"] } # hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature, diff --git a/crates/horizon-client/examples/probe/pack_screen_fixture.rs b/crates/horizon-client/examples/probe/pack_screen_fixture.rs index 881570990..5d84ce0a6 100644 --- a/crates/horizon-client/examples/probe/pack_screen_fixture.rs +++ b/crates/horizon-client/examples/probe/pack_screen_fixture.rs @@ -5,7 +5,7 @@ //! //! usage: pack_screen_fixture RESOURCES CASES OUTPUT use horizon_client::{ - hud::HudAtlas, + hud::{HudAtlas, PACK_ICON_SIZE}, lang, pack_screen::{Compat, PackInfo, PackScreen, Source}, packs::{self, Position}, @@ -13,7 +13,7 @@ use horizon_client::{ text::Text, }; use serde_json::{Value, json}; -use std::{fmt::Write as _, fs, path::PathBuf}; +use std::{fmt::Write as _, fs, path::PathBuf, sync::Arc}; /// Styled runs: [text, rgb or null, bold, italic, underlined, strikethrough, obfuscated]. pub fn runs(t: &Text) -> Value { @@ -105,7 +105,9 @@ pub fn main() -> horizon_client::Result<()> { Some("unknown") => Compat::Unknown, _ => Compat::Compatible, }, - icon: p["icon"].as_bool().unwrap_or(false), + icon: p["icon"].as_bool().unwrap_or(false).then(|| { + Arc::from(vec![0; (PACK_ICON_SIZE * PACK_ICON_SIZE * 4) as usize]) + }), required: p["required"].as_bool().unwrap_or(false), position: if p["position"] == "top" { Position::Top diff --git a/crates/horizon-client/src/confirm_screen.rs b/crates/horizon-client/src/confirm_screen.rs new file mode 100644 index 000000000..3b4f7e7aa --- /dev/null +++ b/crates/horizon-client/src/confirm_screen.rs @@ -0,0 +1,75 @@ +//! `ConfirmScreen`: a title, a message wrapped to `width - 50` (15 lines at +//! most) and two 150-wide buttons 4 apart and 16 below it, the whole column +//! centred; Escape answers no. +use crate::{ + font::Font, + hud::{HudAtlas, HudBatch}, + text::Text, + ui, +}; + +pub struct Confirm { + /// Each line and where it is drawn. + pub lines: Vec<(Text, f32, f32)>, + /// The yes and no buttons' corners. + pub buttons: [(f32, f32); 2], +} +impl Confirm { + pub fn new(font: &Font, (w, h): (f32, f32), title: &Text, message: &Text) -> Self { + let message: Vec = font + .split_lines(message, w - 50.0) + .into_iter() + .map(|(line, _)| line) + .take(15) + .collect(); + let tw = font.width_text(title); + let mw = message + .iter() + .map(|l| font.width_text(l)) + .fold(0.0, f32::max); + let mh = 9.0 * message.len() as f32; + let col = tw.max(mw).max(304.0); + let total = 9.0 + 8.0 + mh + 8.0 + 36.0; + let (lx, ly) = (((w - col) / 2.0).trunc(), ((h - total) / 2.0).trunc()); + let cell = |cw: f32| lx + ((col - cw) / 2.0).trunc(); + let mid = cell(mw) + (mw / 2.0).trunc(); + let mut lines = vec![(title.clone(), cell(tw), ly)]; + for (i, line) in message.into_iter().enumerate() { + let x = mid - (font.width_text(&line) / 2.0).trunc(); + lines.push((line, x, ly + 17.0 + 9.0 * i as f32)); + } + let (bx, by) = (cell(304.0), ly + 9.0 + 8.0 + mh + 8.0 + 16.0); + Self { + lines, + buttons: [(bx, by), (bx + 154.0, by)], + } + } + /// The answer a click at `cursor` gives: true for yes, false for no. + pub fn answer_at(&self, cursor: (f32, f32)) -> Option { + let [yes, no] = self.buttons; + let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0); + if on(yes) { + Some(true) + } else if on(no) { + Some(false) + } else { + None + } + } + /// The lines and the buttons (yes first), over whatever is behind. + pub fn draw( + &self, + batch: &mut HudBatch, + atlas: &HudAtlas, + cursor: (f32, f32), + labels: [&Text; 2], + ) { + for (line, x, y) in &self.lines { + batch.text_styled(atlas, line, *x, *y, u32::MAX, true); + } + for ((bx, by), label) in self.buttons.into_iter().zip(labels) { + let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); + ui::button(batch, atlas, bx, by, 150.0, 20.0, label, true, hover); + } + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 533973805..bf8327cc1 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -137,6 +137,7 @@ mod scoreboard; mod screens; mod sculk; mod sculk_fixture; +mod server_packs; mod server_travel; mod shield; mod sign_edit; @@ -1126,6 +1127,8 @@ struct Game<'a> { pending_entry: Option, world_loader: Option, pending_pack_reload: bool, + /// A server's resource packs (game/server_packs.rs). + server_packs: server_packs::ServerPackState, world_renderer_ready: bool, collision: &'a BlockCollisionRegistry<'a>, motion: &'a MotionResources, @@ -4771,7 +4774,14 @@ impl Game<'_> { hud_layout::paint(batch, &self.gui.atlas, &draws); } fn hud(&mut self, size: [u32; 2]) -> HudBatch { - let mut batch = self.hud_layers(size); + // The pack prompt replaces the connecting screen (setScreen), but + // in game it opens over the world. + let mut batch = if self.server_packs.prompt.is_some() && self.player.is_none() { + HudBatch::new(size) + } else { + self.hud_layers(size) + }; + self.draw_pack_prompt(&mut batch); // Gui.extractRenderState: the debug overlay comes after the screen // and the toasts, so it is over everything, menus included. self.draw_debug_overlay(&mut batch, size); @@ -10995,6 +11005,13 @@ impl ApplicationHandler for Game<'_> { self.advancements_scroll(scaled(raw_x) as f32, d); } } + WindowEvent::MouseInput { state, button, .. } + if self.server_packs.prompt.is_some() => + { + if state == ElementState::Pressed && button == MouseButton::Left { + self.pack_prompt_click()?; + } + } WindowEvent::MouseInput { .. } if self.screen == Screen::Win => {} WindowEvent::MouseInput { state, button, .. } if self.screen == Screen::Options => { if self.options_waiting_for_key() && state == ElementState::Pressed { @@ -11194,6 +11211,14 @@ impl ApplicationHandler for Game<'_> { _ => {} } } + // ConfirmScreen.keyPressed: Escape answers no. + WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => { + if event.state == ElementState::Pressed + && event.physical_key == PhysicalKey::Code(KeyCode::Escape) + { + self.answer_pack_prompt(false)?; + } + } WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Chat && self.title.is_none() => { @@ -11572,6 +11597,7 @@ impl ApplicationHandler for Game<'_> { event_loop.exit(); return; } + self.tick_server_packs(); self.poll_control(event_loop); if self.pending_save.is_some() { return; @@ -11666,6 +11692,7 @@ impl<'a> Game<'a> { pending_entry: None, world_loader: None, pending_pack_reload: false, + server_packs: Default::default(), world_renderer_ready: false, collision: res.collision(), motion: res.motion(), @@ -13254,7 +13281,7 @@ pub fn run() -> Result<()> { return run_loading(options, early_settings, vanilla_root, None, started); } let mut pack_error = None; - options.resources = packs::startup_root(&vanilla_root, &early_settings.resource_packs) + options.resources = packs::startup_root(&vanilla_root, &early_settings.resource_packs, &[]) .unwrap_or_else(|e| { log::warn!("Horizon: resource packs not applied: {e}"); pack_error = Some(e.to_string()); diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index a94f3f01b..e0ad706de 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -82,8 +82,10 @@ impl Game<'_> { } return true; } - // Screens with a text box take every key press first - // (EditBox.keyPressed); releases still reach KeyboardHandler. + // Vanilla types into a focused EditBox through charTyped, which no + // debug key can swallow. Here the character comes with the key press, + // so a screen with a focused text box takes every press first; + // releases still reach KeyboardHandler. let typing = matches!( self.screen, Screen::Chat | Screen::Options | Screen::WorldOptions | Screen::CommandBlock @@ -91,7 +93,11 @@ impl Game<'_> { || self.book.is_some() || (self.screen == Screen::Creative && self.creative_screen.tab().search) || self.recipe_search_focused() - || self.station_typing(); + || self.station_typing() + || self + .title + .as_mut() + .is_some_and(|t| t.focused_field().is_some()); // Container screens use Escape, the inventory key and the hotbar and // drop keys first; any other screen closes on Escape. let screen_key = match self.screen { diff --git a/crates/horizon-client/src/game/game_rules_screen.rs b/crates/horizon-client/src/game/game_rules_screen.rs index d99a7ab5b..d925c5081 100644 --- a/crates/horizon-client/src/game/game_rules_screen.rs +++ b/crates/horizon-client/src/game/game_rules_screen.rs @@ -3,6 +3,7 @@ //! box each, and Done sending the changed ones (ServerboundSetGameRulePacket). //! Leaving with changes asks first (ConfirmScreen). use horizon_client::{ + confirm_screen::Confirm, font::Font, gamerules::{self, GameRules, RULES, Rule, Value}, hud::{HudAtlas, HudBatch}, @@ -66,9 +67,6 @@ fn parse(r: &Rule, s: &str) -> Option { .flatten() .filter(|v| (r.min..=r.max).contains(v)) } -fn widest(font: &Font, lines: &[Text]) -> f32 { - lines.iter().map(|l| font.width_text(l)).fold(0.0, f32::max) -} fn lines(font: &Font, t: &Text, width: f32) -> Vec { font.split_lines(t, width) .into_iter() @@ -95,38 +93,11 @@ fn yellow() -> u32 { named_color("yellow").unwrap_or(0xFFFF55) } -/// ConfirmScreen: the title, the message (at most `width - 50` wide), and -/// Yes / No 16 below, 4 apart, all centred. -struct Confirm { - lines: Vec<(Text, f32, f32)>, - buttons: [(f32, f32); 2], -} -impl Confirm { - fn new(font: &Font, (w, h): (f32, f32)) -> Self { - let title = Text::translate("editGamerule.inGame.discardChanges.title", &[]); - let message = Text::translate("editGamerule.inGame.discardChanges.message", &[]); - let message: Vec = lines(font, &message, w - 50.0) - .into_iter() - .take(15) - .collect(); - let (tw, mw) = (font.width_text(&title), widest(font, &message)); - let mh = 9.0 * message.len() as f32; - let col = tw.max(mw).max(304.0); - let total = 9.0 + 8.0 + mh + 8.0 + 36.0; - let (lx, ly) = (((w - col) / 2.0).trunc(), ((h - total) / 2.0).trunc()); - let cell = |cw: f32| lx + ((col - cw) / 2.0).trunc(); - let mid = cell(mw) + (mw / 2.0).trunc(); - let mut out = vec![(title, cell(tw), ly)]; - for (i, line) in message.into_iter().enumerate() { - let x = mid - (font.width_text(&line) / 2.0).trunc(); - out.push((line, x, ly + 17.0 + 9.0 * i as f32)); - } - let (bx, by) = (cell(304.0), ly + 9.0 + 8.0 + mh + 8.0 + 16.0); - Self { - lines: out, - buttons: [(bx, by), (bx + 154.0, by)], - } - } +/// ConfirmScreen "Game Rule Changes". +fn confirm(font: &Font, size: (f32, f32)) -> Confirm { + let title = Text::translate("editGamerule.inGame.discardChanges.title", &[]); + let message = Text::translate("editGamerule.inGame.discardChanges.message", &[]); + Confirm::new(font, size, &title, &message) } impl RulesScreen { @@ -301,13 +272,10 @@ impl RulesScreen { let (w, h) = size; let on = |x: f32, y: f32, bw: f32, bh: f32| ui::hovered(cursor, x, y, bw, bh); if self.confirm { - let c = Confirm::new(&atlas.font, size); - let [(yx, yy), (nx, ny)] = c.buttons; - if on(yx, yy, 150.0, 20.0) { - return Some(Exit::Discard); - } - if on(nx, ny, 150.0, 20.0) { - self.confirm = false; + match confirm(&atlas.font, size).answer_at(cursor) { + Some(true) => return Some(Exit::Discard), + Some(false) => self.confirm = false, + None => {} } return None; } @@ -367,7 +335,7 @@ impl RulesScreen { let (w, h) = size; let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0); if self.confirm { - return Confirm::new(&atlas.font, size).buttons.into_iter().any(on); + return confirm(&atlas.font, size).answer_at(cursor).is_some(); } let [done, cancel] = footer(w, h); if (on(done) && !self.invalid()) || on(cancel) { @@ -384,15 +352,11 @@ impl RulesScreen { let (w, h) = (batch.width, batch.height); ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true); if self.confirm { - let c = Confirm::new(&atlas.font, (w, h)); - for (line, x, y) in &c.lines { - batch.text_styled(atlas, line, *x, *y, u32::MAX, true); - } - for ((bx, by), key) in c.buttons.into_iter().zip(["gui.yes", "gui.no"]) { - let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); - let label = Text::translate(key, &[]); - ui::button(batch, atlas, bx, by, 150.0, 20.0, &label, true, hover); - } + let labels = [ + Text::translate("gui.yes", &[]), + Text::translate("gui.no", &[]), + ]; + confirm(&atlas.font, (w, h)).draw(batch, atlas, cursor, [&labels[0], &labels[1]]); return; } let rows = self.rows(); diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ae2de00e6..7629a5d25 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -4,7 +4,7 @@ use super::Game; use horizon_client::{ hud::HudAtlas, lang, - pack_screen::{Compat, PackInfo, Source as PackSource}, + pack_screen::{self, Compat, PackInfo, Source as PackSource}, packs::{self, Pack, Position}, text::{Style, Text}, }; @@ -34,10 +34,16 @@ pub fn open_folder(dir: &Path) { log::warn!("Horizon: could not open {}: {e}", dir.display()); } } -/// The resource root to load from, given the vanilla root and the selection. -pub fn startup_root(vanilla: &Path, selected: &[String]) -> std::io::Result { +/// The resource root to load from, given the vanilla root, the selection and +/// a server's packs, which go on top (`Pack.Position.TOP`, fixed). +pub fn startup_root( + vanilla: &Path, + selected: &[String], + server: &[Pack], +) -> std::io::Result { let all = packs::discover(vanilla, &packs_dir()); - let enabled = packs::enabled(&all, selected); + let mut enabled = packs::enabled(&all, selected); + enabled.extend_from_slice(server); packs::resource_root(vanilla, &enabled, &cache_dir()) } fn info(p: &Pack) -> PackInfo { @@ -53,14 +59,15 @@ fn info(p: &Pack) -> PackInfo { PackSource::Default }, compat: p.compatibility, - icon: p.icon, + icon: p.icon_png().as_deref().and_then(pack_screen::load_icon), required: false, position: Position::Top, fixed: false, } } -/// The vanilla pack: required, at the bottom (`BuiltInPackSource`). -fn vanilla_info() -> PackInfo { +/// The vanilla pack: required, at the bottom (`BuiltInPackSource`), with the +/// client JAR's `pack.png` that the prepared resources hold. +fn vanilla_info(vanilla: &Path) -> PackInfo { PackInfo { id: "vanilla".into(), title: Text::translate("resourcePack.vanilla.name", &[]), @@ -68,7 +75,10 @@ fn vanilla_info() -> PackInfo { description_style: Style::default(), source: PackSource::BuiltIn, compat: Compat::Compatible, - icon: true, + icon: std::fs::read(vanilla.join("pack.png")) + .ok() + .as_deref() + .and_then(pack_screen::load_icon), required: true, position: Position::Bottom, fixed: false, @@ -80,7 +90,7 @@ pub(super) fn pack_infos(vanilla: &Path) -> Vec { .iter() .map(info) .collect(); - infos.push(vanilla_info()); + infos.push(vanilla_info(vanilla)); infos } impl Game<'_> { @@ -113,14 +123,7 @@ impl Game<'_> { self.pending_pack_reload = true; return; } - let vanilla = self.vanilla_root(); - if self.ui.vanilla_root.as_os_str().is_empty() { - self.ui.vanilla_root = vanilla.clone(); - } - let result = startup_root(&vanilla, &self.settings.resource_packs) - .map_err(Into::into) - .and_then(|root| self.reload_resources(&root)); - if let Err(e) = result { + if let Err(e) = self.reload_selected_packs() { log::warn!("Horizon: resource reload failed: {e}"); if self.screen != super::Screen::Options { self.open_options_at( @@ -131,6 +134,16 @@ impl Game<'_> { self.ui.options.resource_error = Some(e.to_string()); } } + /// Reload from the selected packs and the server's. + pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> { + let vanilla = self.vanilla_root(); + if self.ui.vanilla_root.as_os_str().is_empty() { + self.ui.vanilla_root = vanilla.clone(); + } + let server = &self.server_packs.active; + let root = startup_root(&vanilla, &self.settings.resource_packs, server)?; + self.reload_resources(&root) + } fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> { let render = std::sync::Arc::new(self.pack.assets.reload(root)?); let mut atlas = HudAtlas::build_over(root, &self.vanilla_root())?; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index da0def0fb..32cffa306 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -305,6 +305,16 @@ impl Game<'_> { // A signed-in account always plays under its own name. let auth = horizon_client::auth::current(); let name = auth.as_ref().map_or(name, |a| a.name.as_str()); + let user = auth.as_ref().map_or_else( + || { + ( + name.to_owned(), + horizon_protocol::crypto::offline_uuid(name), + ) + }, + |a| (a.name.clone(), a.uuid), + ); + self.server_packs_connect(local.is_none().then_some(address), user); let session = match local { Some(pipe) => Session::connect_local(pipe, name, view, lang.clone()), None => { @@ -453,6 +463,7 @@ impl Game<'_> { if let Some(mut r) = self.remote.take() { r.session.disconnect(); } + self.server_packs_disconnect(); // Single player's server thread saves the world before the title shows. let single_player = match self.integrated.take() { Some(server) => { @@ -827,6 +838,8 @@ impl Game<'_> { } } Event::Reconfigured(registries) => self.set_registries(registries), + Event::PackPush(p) => self.handle_pack_push(p), + Event::PackPop(id) => self.handle_pack_pop(id), Event::DecodeError(e) => { if let Some(r) = self.remote.as_mut() { r.decode_errors += 1; diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs new file mode 100644 index 000000000..6c891a831 --- /dev/null +++ b/crates/horizon-client/src/game/server_packs.rs @@ -0,0 +1,316 @@ +//! A server's resource packs bound to the game (`ClientCommonPacketListenerImpl. +//! handleResourcePackPush` and `handleResourcePackPop`, its `PackConfirmScreen`, +//! and `DownloadedPackSource` as `Minecraft` drives it): the prompt, the +//! server list's setting, downloads into `downloads/`, and a resource reload +//! with the server's packs on top of the player's own. +use super::Game; +use horizon_client::{ + Result, + confirm_screen::Confirm, + hud::{HudAtlas, HudBatch}, + multiplayer, packs, + scoreboard::{comp_text, tag_to_json}, + server_packs::{Prompt, ServerPacks, action, download, parse_sha1, valid_url}, + text::{Text, named_color}, + ui, +}; +use horizon_protocol::{packets::configuration::ResourcePackPush, servers}; +use std::path::PathBuf; + +/// `ClientCommonPacketListenerImpl.PackConfirmScreen`: the packs it asks +/// about, whether the last one is required, and the server's message. +pub(super) struct PackPrompt { + requests: Vec<(u128, String, String)>, + required: bool, + prompt: Option, +} +impl PackPrompt { + fn texts(&self) -> (Text, Text, [Text; 2]) { + let t = |key: &str| Text::translate(key, &[]); + let (title, line2) = if self.required { + let yellow = named_color("yellow").unwrap_or(0xFFFF55); + ( + t("multiplayer.requiredTexturePrompt.line1"), + t("multiplayer.requiredTexturePrompt.line2") + .with_color(yellow) + .bold(), + ) + } else { + ( + t("multiplayer.texturePrompt.line1"), + t("multiplayer.texturePrompt.line2"), + ) + }; + // preparePackPrompt. + let message = match &self.prompt { + Some(prompt) => Text::translate( + "multiplayer.texturePrompt.serverPrompt", + &[line2, prompt.clone()], + ), + None => line2, + }; + let buttons = if self.required { + [t("gui.proceed"), t("menu.disconnect")] + } else { + [t("gui.yes"), t("gui.no")] + }; + (title, message, buttons) + } + fn layout(&self, atlas: &HudAtlas, size: (f32, f32)) -> Confirm { + let (title, message, _) = self.texts(); + Confirm::new(&atlas.font, size, &title, &message) + } +} + +/// The game's `DownloadedPackSource`. +#[derive(Default)] +pub(super) struct ServerPackState { + packs: ServerPacks, + /// `downloads/` in the game folder, opened at the first download. + queue: Option, + pub(super) prompt: Option, + /// The server list entry the setting is saved to (none: a direct join). + address: Option, + /// The account the downloads are made for (the download headers). + user: (String, u128), + /// The packs loaded on top of the player's own, bottom first. + pub(super) active: Vec, +} + +fn saves() -> PathBuf { + std::env::current_dir().unwrap_or_default().join("saves") +} + +impl Game<'_> { + /// `ConnectScreen`: the server's setting decides what its packs do + /// (`configureForServerControl`); single player's own server takes them + /// all, quietly (`configureForLocalWorld`). + pub(super) fn server_packs_connect(&mut self, address: Option<&str>, user: (String, u128)) { + let state = &mut self.server_packs; + state.user = user; + state.prompt = None; + let Some(address) = address else { + state.address = None; + state.packs.local_world(); + return; + }; + let file = multiplayer::servers_file(&saves()); + let entry = servers::load(&file).into_iter().find(|s| s.ip == address); + let setting = entry.as_ref().and_then(|e| e.accept_textures); + state.address = entry.map(|e| e.ip); + state.packs.connect(Prompt::for_server(setting)); + } + /// `Minecraft.clearDownloadedResourcePacks`: every server pack goes at once. + pub(super) fn server_packs_disconnect(&mut self) { + self.server_packs.prompt = None; + self.server_packs.packs.disconnect(); + self.tick_server_packs(); + } + + /// `handleResourcePackPush`. + pub(super) fn handle_pack_push(&mut self, p: ResourcePackPush) { + if !valid_url(&p.url) { + self.send_pack_status(p.id, action::INVALID_URL); + return; + } + let setting = self.server_setting(); + let prompt = Prompt::for_server(setting); + if prompt != Prompt::Pending && (!p.required || prompt != Prompt::Declined) { + self.server_packs + .packs + .push(p.id, &p.url, parse_sha1(&p.hash)); + return; + } + // addOrUpdatePackPrompt: one prompt for every pack pushed before it is answered. + let text = p.prompt.as_ref().map(|t| comp_text(&tag_to_json(t))); + let state = &mut self.server_packs; + let open = state.prompt.get_or_insert(PackPrompt { + requests: Vec::new(), + required: p.required, + prompt: None, + }); + open.requests.push((p.id, p.url, p.hash)); + open.required = p.required; + open.prompt = text; + self.capture(false); + } + /// `handleResourcePackPop`: one pack, or all of them. + pub(super) fn handle_pack_pop(&mut self, id: Option) { + match id { + Some(id) => self.server_packs.packs.pop(id), + None => self.server_packs.packs.pop_all(), + } + } + /// The joined server's entry in the server list: its `acceptTextures`. + fn server_setting(&self) -> Option { + let address = self.server_packs.address.as_deref()?; + servers::load(&multiplayer::servers_file(&saves())) + .into_iter() + .find(|s| s.ip == address)? + .accept_textures + } + fn send_pack_status(&self, id: u128, status: i32) { + if let Some(r) = &self.remote { + r.session.send_pack_status(id, status); + } + } + + /// The prompt's answer (`PackConfirmScreen`'s callback): the server's + /// setting follows it, declining a required pack disconnects, and every + /// pack it asked about is pushed. + pub(super) fn answer_pack_prompt(&mut self, yes: bool) -> Result<()> { + let Some(prompt) = self.server_packs.prompt.take() else { + return Ok(()); + }; + if self.player.is_some() && self.screen == super::Screen::Playing { + self.capture(true); + } + let setting = if yes { + self.server_packs.packs.allow(); + Some(true) + } else { + self.server_packs.packs.reject(); + if prompt.required { + let reason = Text::translate("multiplayer.requiredTexturePrompt.disconnect", &[]); + return self.leave_server(Some(reason.plain())); + } + Some(false) + }; + for (id, url, hash) in prompt.requests { + self.server_packs.packs.push(id, &url, parse_sha1(&hash)); + } + // ServerList.saveSingleServer. + if let Some(address) = &self.server_packs.address { + let file = multiplayer::servers_file(&saves()); + let mut list = servers::load(&file); + for entry in list.iter_mut().filter(|s| &s.ip == address) { + entry.accept_textures = setting; + } + if let Err(e) = servers::save(&file, &list) { + log::warn!("Horizon: could not save {}: {e}", file.display()); + } + } + Ok(()) + } + + /// Runs what the packs need (`createUpdateScheduler`): the downloads + /// that finished, the ones to start, a resource reload when the active + /// packs change, and the statuses for the server. + pub(super) fn tick_server_packs(&mut self) { + // A reload waits for the world's resources (`reload_packs`). + if self.rest_loader.is_some() || self.world_loader.is_some() { + return; + } + let finished = self + .server_packs + .queue + .as_ref() + .map(download::Queue::finished) + .unwrap_or_default(); + for batch in finished { + self.server_packs.packs.downloaded(batch); + } + while self.server_packs.packs.wants_tick() { + let tick = self.server_packs.packs.tick(); + if !tick.download.is_empty() { + self.start_pack_downloads(tick.download); + } + if let Some(mut load) = tick.reload { + while let Some(recovery) = { + let ok = self.reload_server_packs(&load); + self.server_packs.packs.reloaded(ok) + } { + load = recovery; + } + } + } + for (id, status) in self.server_packs.packs.take_replies() { + self.send_pack_status(id, status); + } + } + fn start_pack_downloads(&mut self, requests: Vec) { + let state = &mut self.server_packs; + if state.queue.is_none() { + let dir = std::env::current_dir() + .unwrap_or_default() + .join("downloads"); + match download::Queue::open(dir) { + Ok(queue) => state.queue = Some(queue), + Err(e) => { + log::error!("Horizon: failed to open the download queue: {e}"); + let failed = requests.iter().map(|r| r.id).collect(); + state.packs.downloaded(horizon_client::server_packs::Batch { + downloaded: Vec::new(), + failed, + }); + return; + } + } + } + let headers = download::headers(&state.user.0, state.user.1); + if let Some(queue) = &state.queue { + queue.download(requests, headers); + } + } + /// `DownloadedPackSource.startReload`: the packs on top of the player's + /// own, then `Minecraft.reloadResourcePacks`. False when a pack has no + /// readable `pack.mcmeta` or the reload failed. + fn reload_server_packs(&mut self, load: &[(u128, PathBuf)]) -> bool { + let packs: Option> = load + .iter() + .map(|(id, path)| packs::server_pack(*id, path)) + .collect(); + let Some(packs) = packs else { + log::warn!("Horizon: invalid pack metadata in a server pack, ignoring all"); + return false; + }; + self.server_packs.active = packs; + match self.reload_selected_packs() { + Ok(()) => true, + Err(e) => { + log::warn!("Horizon: server resource pack reload failed: {e}"); + false + } + } + } + + pub(super) fn draw_pack_prompt(&self, batch: &mut HudBatch) { + let Some(prompt) = &self.server_packs.prompt else { + return; + }; + let atlas = &self.gui.atlas; + let (w, h) = (batch.width, batch.height); + if self.player.is_none() { + // In place of the connecting screen, on its background. + batch.fill( + atlas, + 0.0, + 0.0, + w, + h, + horizon_client::hud::rgba(20, 20, 20, 255), + ); + } + ui::menu_background(batch, atlas, 0.0, 0.0, w, h, self.player.is_some()); + let (_, _, [yes, no]) = prompt.texts(); + prompt + .layout(atlas, (w, h)) + .draw(batch, atlas, self.cursor, [&yes, &no]); + } + /// A left click on the prompt: its answer when it hit a button. + pub(super) fn pack_prompt_click(&mut self) -> Result<()> { + let Some(prompt) = &self.server_packs.prompt else { + return Ok(()); + }; + let answer = prompt + .layout(&self.gui.atlas, self.gui_size()) + .answer_at(self.cursor); + match answer { + Some(yes) => { + self.audio.play_button_click(); + self.answer_pack_prompt(yes) + } + None => Ok(()), + } + } +} diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs index e6cb6b04f..96af99bbc 100644 --- a/crates/horizon-client/src/game/startup_menu.rs +++ b/crates/horizon-client/src/game/startup_menu.rs @@ -219,12 +219,11 @@ pub(super) fn spawn_loader( .name("resource-loader".into()) .spawn(move || { let mut pack_error = None; - let root = packs::startup_root(&vanilla_root, &settings.resource_packs).unwrap_or_else( - |error| { + let root = packs::startup_root(&vanilla_root, &settings.resource_packs, &[]) + .unwrap_or_else(|error| { pack_error = Some(error.to_string()); vanilla_root.clone() - }, - ); + }); let root = mods::content_root(&root, &settings.mods.enabled, &dev_mods); let result = load_resources( root, diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index cc922752e..89d1b1c3c 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -81,6 +81,12 @@ pub const MINIMAP_SPRITE: &str = "horizon/minimap"; pub const SKIN_SLOTS: usize = 32; /// Reused by the visible rows of the classic world selector. pub const WORLD_ICON_SLOTS: usize = 32; +/// Atlas slots for the pack icons on the pack screen, one per icon drawn +/// (`PackSelectionScreen.loadPackIcon` registers a texture per pack): two lists +/// of 36-pixel rows at GUI scale 2 on a 4K screen still fit. +pub const PACK_ICON_SLOTS: usize = 64; +/// A pack icon slot's side: vanilla's own icons are 128x128. +pub const PACK_ICON_SIZE: u32 = 128; /// Atlas slots for armour trim textures made at run time (`trims`), each the /// size of the largest trim texture. pub const TRIM_SLOTS: usize = 32; @@ -252,7 +258,7 @@ impl HudAtlas { ) } /// Empty slots written at run time: map textures (game/maps.rs), the - /// minimap, downloaded skins, world icons and the on-screen keyboard's text. + /// minimap, downloaded skins, world and pack icons and the on-screen keyboard's text. fn slots(images: &mut Vec, trim: (u32, u32)) { for i in 0..MAP_SLOTS { images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); @@ -284,6 +290,15 @@ impl HudAtlas { vec![0; 64 * 64 * 4], )); } + let side = PACK_ICON_SIZE as usize; + for i in 0..PACK_ICON_SLOTS { + images.push(( + format!("horizon/pack-icon{i}"), + PACK_ICON_SIZE, + PACK_ICON_SIZE, + vec![0; side * side * 4], + )); + } // The on-screen keyboard's text and corner masks (ui_theme), rasterized at run time. images.push(( "horizon/ui-text".into(), diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 3c741e963..229f176f9 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -41,6 +41,7 @@ pub mod command; pub mod command_block; pub mod command_storage; pub mod component; +pub mod confirm_screen; pub mod container_screen; pub mod containers; pub mod control; @@ -157,6 +158,7 @@ pub mod screen_effects; pub mod screen_layout; pub mod sculk; pub use horizon_server_files as server; +pub mod server_packs; pub mod settings; pub mod shadows; pub mod signs; diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index 179685dee..07d8552ff 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -67,6 +67,9 @@ pub enum Screen { name: String, address: String, focus: u8, + /// Server Resource Packs (`acceptTextures`): Enabled, Disabled, or + /// none for Prompt. + packs: Option, }, Direct { address: String, @@ -224,6 +227,19 @@ fn entry_address(servers: &[ServerEntry], lan: &Scanner, index: usize) -> Option } } +/// The Server Resource Packs button's label: `CommonComponents.optionNameValue`. +fn pack_setting_label(packs: Option) -> String { + let (key, fallback) = match packs { + Some(true) => ("manageServer.resourcePack.enabled", "Enabled"), + Some(false) => ("manageServer.resourcePack.disabled", "Disabled"), + None => ("manageServer.resourcePack.prompt", "Prompt"), + }; + let name = crate::lang::get_or("manageServer.resourcePack", "Server Resource Packs"); + crate::lang::get_or("options.generic_value", "%s: %s") + .replacen("%s", &name, 1) + .replacen("%s", &crate::lang::get_or(key, fallback), 1) +} + /// JoinMultiplayerScreen's `HeaderAndFooterLayout(33, 60)`. const HEADER: f32 = 33.0; const FOOTER: f32 = 60.0; @@ -461,7 +477,16 @@ impl Screen { ), ] } - Self::Edit { address, .. } => vec![ + Self::Edit { address, packs, .. } => vec![ + // ManageServerScreen's CycleButton, above Done. + b( + w / 2.0 - 100.0, + h / 4.0 + 72.0, + 200.0, + &pack_setting_label(*packs), + true, + 60, + ), b( w / 2.0 - 100.0, h / 4.0 + 96.0 + 18.0, @@ -847,6 +872,7 @@ impl Screen { name, address, focus, + .. } => { centered( batch, @@ -996,6 +1022,7 @@ impl Screen { name: "Minecraft Server".into(), address: String::new(), focus: 1, + packs: None, } } ( @@ -1011,6 +1038,7 @@ impl Screen { name: s.name, address: s.ip, focus: 0, + packs: s.accept_textures, }; } } @@ -1125,21 +1153,32 @@ impl Screen { *selected = Some(index); } } + // CycleButton: Enabled, Disabled, Prompt, and round again. + (Self::Edit { packs, .. }, Some(60)) => { + *packs = match *packs { + Some(true) => Some(false), + Some(false) => None, + None => Some(true), + } + } ( Self::Edit { index, name, address, + packs, .. }, Some(50), ) => { let mut list = servers::load(&servers_file(saves)); - let entry = ServerEntry::new(name.trim(), address.trim()); + let mut entry = ServerEntry::new(name.trim(), address.trim()); + entry.accept_textures = *packs; match index.and_then(|i| list.get_mut(i)) { Some(e) => { e.name = entry.name; e.ip = entry.ip; + e.accept_textures = entry.accept_textures; } None => list.push(entry), } @@ -1637,4 +1676,57 @@ mod tests { assert_eq!(names(), ["Keep"]); let _ = std::fs::remove_dir_all(&dir); } + + #[test] + fn edit_cycles_and_saves_the_server_resource_pack_setting() { + let dir = std::env::temp_dir().join(format!("horizon-mp-packs-{}", std::process::id())); + let saves = dir.join("saves"); + std::fs::create_dir_all(&saves).unwrap(); + let file = servers_file(&saves); + let mut entry = ServerEntry::new("Packs", "127.0.0.1:4"); + entry.accept_textures = Some(false); + servers::save(&file, &[entry]).unwrap(); + let size = (427.0, 240.0); + let mut screen = Screen::list(&saves); + if let Screen::List { selected, .. } = &mut screen { + *selected = Some(0); + } + screen.click(Some(43), 0.0, 0.0, size, &saves); + let cycle = |screen: &Screen| { + screen + .buttons(size.0, size.1) + .into_iter() + .find(|b| b.5 == 60) + .map(|b| (b.0, b.1, b.2, b.3)) + }; + // ManageServerScreen: 200 wide at height / 4 + 72, the saved value first. + assert_eq!( + cycle(&screen), + Some(( + 113.5, + 132.0, + 200.0, + "Server Resource Packs: Disabled".into() + )) + ); + // Disabled, Prompt, Enabled: Cancel keeps what was saved. + screen.click(Some(60), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt"); + screen.click(Some(51), 0.0, 0.0, size, &saves); + assert_eq!(servers::load(&file)[0].accept_textures, Some(false)); + // Done saves it. + if let Screen::List { selected, .. } = &mut screen { + *selected = Some(0); + } + screen.click(Some(43), 0.0, 0.0, size, &saves); + screen.click(Some(60), 0.0, 0.0, size, &saves); + screen.click(Some(60), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Enabled"); + screen.click(Some(50), 0.0, 0.0, size, &saves); + assert_eq!(servers::load(&file)[0].accept_textures, Some(true)); + // A new server asks. + screen.click(Some(42), 0.0, 0.0, size, &saves); + assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt"); + let _ = std::fs::remove_dir_all(&dir); + } } diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs index 74f1b0b6d..3c009a1b5 100644 --- a/crates/horizon-client/src/net.rs +++ b/crates/horizon-client/src/net.rs @@ -20,6 +20,7 @@ use horizon_protocol::{ use std::{ sync::{ Arc, Mutex, + atomic::{AtomicBool, Ordering}, mpsc::{Receiver, Sender, channel}, }, thread::JoinHandle, @@ -43,6 +44,10 @@ pub enum Event { DecodeError(String), /// The server sent us back to configuration and finished it again. Reconfigured(Arc), + /// ClientboundResourcePackPushPacket, in configuration or in play. + PackPush(cfg::ResourcePackPush), + /// ClientboundResourcePackPopPacket: one pack, or every pack. + PackPop(Option), /// The connection ended. `from_server`: the server gave the reason (or /// the connection was refused for good), rather than the connection /// failing (auto-reconnect retries only failures and shutdowns). @@ -55,6 +60,9 @@ pub enum Event { pub struct Session { events: Receiver, writer: Arc>>, + /// The connection is in configuration (else in play). Changed only + /// with `writer` locked, as the packet that switches is sent. + configuring: Arc, thread: Option>, pub address: String, pub name: String, @@ -92,8 +100,10 @@ impl Session { ) -> Self { let (send, events) = channel(); let writer = Arc::new(Mutex::new(None)); + let configuring = Arc::new(AtomicBool::new(true)); let counters = Arc::new(Mutex::new(None)); let (thread_writer, thread_counters) = (writer.clone(), counters.clone()); + let thread_configuring = configuring.clone(); let (address_owned, name_owned) = (address.to_owned(), name.to_owned()); let thread = std::thread::Builder::new() .name("horizon-net".into()) @@ -107,6 +117,7 @@ impl Session { &lang, &send, &thread_writer, + &thread_configuring, &thread_counters, ); let from_server = result.is_ok(); @@ -124,6 +135,7 @@ impl Session { Self { events, writer, + configuring, thread, address: address.to_owned(), name: name.to_owned(), @@ -153,6 +165,21 @@ impl Session { w.shutdown(); } } + /// ServerboundResourcePackPacket, in whichever phase the connection is. + pub fn send_pack_status(&self, id: u128, action: i32) { + let status = cfg::ResourcePackResponse { id, action }; + let mut writer = self.writer.lock().unwrap(); + let body = if self.configuring.load(Ordering::Relaxed) { + cfg::Serverbound::ResourcePack(status).encode() + } else { + play::Serverbound::ResourcePack(status).encode() + }; + if let Some(w) = writer.as_mut() + && w.send(&body).is_err() + { + w.shutdown(); + } + } pub fn disconnect(&mut self) { if let Some(w) = self.writer.lock().unwrap().take() { w.shutdown(); @@ -253,6 +280,7 @@ fn run( lang: &Language, send: &Sender, shared_writer: &Mutex>, + configuring: &AtomicBool, shared_counters: &Mutex>>, ) -> Result { let (host, port, mut c) = if let Some(pipe) = local { @@ -377,18 +405,19 @@ fn run( .map_err(e)?; let (mut reader, writer) = c.split(); *shared_writer.lock().unwrap() = Some(writer); - let registries = configure(&mut reader, shared_writer, lang, send)?; + let registries = configure(&mut reader, shared_writer, configuring, lang, send)?; let _ = send.send(Event::Joined { registries: Arc::new(registries), uuid: profile.uuid, name: profile.name, }); - receive_play(&mut reader, shared_writer, lang, send) + receive_play(&mut reader, shared_writer, configuring, lang, send) } fn receive_play( reader: &mut ConnReader, shared_writer: &Mutex>, + configuring: &AtomicBool, lang: &Language, send: &Sender, ) -> Result { @@ -416,15 +445,17 @@ fn receive_play( play::Clientbound::KeepAlive(k) => reply(play::Serverbound::KeepAlive(k)), play::Clientbound::BundleDelimiter(_) => {} play::Clientbound::ResourcePackPush(p) => { - // Declined: Horizon has no server resource packs. - reply(play::Serverbound::ResourcePack(cfg::ResourcePackResponse { - id: p.id, - action: 1, - })); + let _ = send.send(Event::PackPush(p)); + } + play::Clientbound::ResourcePackPop(p) => { + let _ = send.send(Event::PackPop(p.id)); } play::Clientbound::StartConfiguration(_) => { - reply(play::Serverbound::ConfigurationAcknowledged(Empty)); - let registries = configure(reader, shared_writer, lang, send)?; + if let Some(w) = shared_writer.lock().unwrap().as_mut() { + let _ = w.send(&play::Serverbound::ConfigurationAcknowledged(Empty).encode()); + configuring.store(true, Ordering::Relaxed); + } + let registries = configure(reader, shared_writer, configuring, lang, send)?; let _ = send.send(Event::Reconfigured(Arc::new(registries))); } play::Clientbound::Disconnect(d) => return Ok(plain(&d.reason, lang)), @@ -445,6 +476,7 @@ fn receive_play( fn configure( reader: &mut ConnReader, writer: &Mutex>, + configuring: &AtomicBool, lang: &Language, send: &Sender, ) -> Result { @@ -471,11 +503,12 @@ fn configure( cfg::Clientbound::CodeOfConduct(_) => { reply(cfg::Serverbound::AcceptCodeOfConduct(Empty))? } + // The game answers: it may prompt the player first. cfg::Clientbound::ResourcePackPush(p) => { - reply(cfg::Serverbound::ResourcePack(cfg::ResourcePackResponse { - id: p.id, - action: 1, - }))? + let _ = send.send(Event::PackPush(p)); + } + cfg::Clientbound::ResourcePackPop(p) => { + let _ = send.send(Event::PackPop(p.id)); } cfg::Clientbound::CookieRequest(q) => { reply(cfg::Serverbound::CookieResponse(cfg::CookieResponse { @@ -485,7 +518,11 @@ fn configure( } cfg::Clientbound::Disconnect(d) => return Err(plain(&d.reason, lang)), cfg::Clientbound::FinishConfiguration(_) => { - reply(cfg::Serverbound::FinishConfiguration(Empty))?; + let mut w = writer.lock().unwrap(); + let w = w.as_mut().ok_or("Disconnected")?; + w.send(&cfg::Serverbound::FinishConfiguration(Empty).encode()) + .map_err(|e| e.to_string())?; + configuring.store(false, Ordering::Relaxed); return Ok(registries); } _ => {} @@ -602,7 +639,13 @@ mod tests { let (send, events) = channel(); let thread_writer = writer.clone(); let thread = std::thread::spawn(move || { - receive_play(&mut reader, &thread_writer, &Language::new(), &send) + receive_play( + &mut reader, + &thread_writer, + &AtomicBool::new(false), + &Language::new(), + &send, + ) }); let mut server = Connection::local(server); let teleport = play::Clientbound::PlayerPosition(play::PlayerPosition { diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 352ebf26e..99a83072f 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -2079,7 +2079,9 @@ impl OptionsUi { let blink = self.pack_focus.elapsed().as_millis() as u64; let m = crate::screen_draw::Measure(&atlas.font); let mouse = (cursor.0.floor() as i32, cursor.1.floor() as i32); - let draws = self.packs(atlas, (w, h)).draw(&m, mouse, blink); + let packs = self.packs(atlas, (w, h)); + let mut draws = packs.draw(&m, mouse, blink); + packs.bind_icons(&mut draws, atlas, &mut batch.patches); crate::screen_draw::paint(batch, atlas, &draws); return; } diff --git a/crates/horizon-client/src/pack_screen.rs b/crates/horizon-client/src/pack_screen.rs index 934ecaf95..2929fd663 100644 --- a/crates/horizon-client/src/pack_screen.rs +++ b/crates/horizon-client/src/pack_screen.rs @@ -6,10 +6,13 @@ //! [`PackScreen::draw`] gives the screen's GUI calls. The game shows it; //! tools/test_pack_screen_parity.py compares it with vanilla. use crate::{ + font::Patch, + hud::{HudAtlas, PACK_ICON_SIZE, PACK_ICON_SLOTS}, packs::{Position, Selectable, SelectionModel}, screen_draw::{self as d, Draw, Measure, TextField}, text::{Style, Text}, }; +use std::{collections::HashMap, sync::Arc}; /// `PackCompatibility`. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -50,8 +53,8 @@ pub struct PackInfo { pub description_style: Style, pub source: Source, pub compat: Compat, - /// Whether the pack has a `pack.png`. - pub icon: bool, + /// The pack's `pack.png` ([`load_icon`]); none draws `unknown_pack`. + pub icon: Option>, pub required: bool, pub position: Position, pub fixed: bool, @@ -90,6 +93,27 @@ impl PackInfo { (t, Style::color(d::GRAY)) } } +/// A `pack.png` as the pack screen draws it: RGBA, stretched to a +/// `PACK_ICON_SIZE` square by nearest texels, as vanilla's icon texture is +/// sampled into its 32x32 square. None when it does not decode, where +/// `loadPackIcon` falls back to `unknown_pack`. +pub fn load_icon(png: &[u8]) -> Option> { + let (w, h, rgba) = crate::hud::decode_bytes(png).ok()?; + if w == 0 || h == 0 { + return None; + } + let size = u64::from(PACK_ICON_SIZE); + let mut out = Vec::with_capacity((size * size * 4) as usize); + for y in 0..size { + let sy = ((2 * y + 1) * u64::from(h) / (2 * size)) as usize; + for x in 0..size { + let sx = ((2 * x + 1) * u64::from(w) / (2 * size)) as usize; + let at = (sy * w as usize + sx) * 4; + out.extend_from_slice(&rgba[at..at + 4]); + } + } + Some(out.into()) +} /// `PackSelectionScreen.loadPackIcon`'s texture for a pack with an icon. pub fn icon_texture(id: &str) -> String { let sanitized: String = id @@ -306,6 +330,8 @@ pub struct PackScreen { confirm: Option, /// The selection changed since the screen opened. pub changed: bool, + /// The packs' icons by their [`icon_texture`]. + icons: HashMap>, } fn tr(key: &str) -> Text { @@ -329,11 +355,16 @@ impl PackScreen { italic: Some(true), ..Style::default() })); + let icons = packs + .iter() + .filter_map(|p| Some((icon_texture(&p.id), p.icon.clone()?))) + .collect(); let mut s = Self { width, height, in_world, packs, + icons, model, search, focus: Focus::None, @@ -760,6 +791,35 @@ impl PackScreen { pub fn commit(&self) -> Vec { self.model.commit() } + /// Points the icon blits of `draws` at the atlas's pack icon slots and + /// writes the icons into them, one slot per icon drawn (vanilla registers a + /// texture per pack). Icons past the last slot keep `unknown_pack`. + pub fn bind_icons(&self, draws: &mut [Draw], atlas: &HudAtlas, patches: &mut Vec) { + let mut slots = 0..PACK_ICON_SLOTS; + for draw in draws { + let Draw::Blit { texture, .. } = draw else { + continue; + }; + let Some(icon) = self.icons.get(texture.as_str()) else { + continue; + }; + let Some(slot) = slots.next() else { + return; + }; + let sprite = format!("horizon/pack-icon{slot}"); + let Some(rect) = atlas.sprites.get(&sprite) else { + return; + }; + patches.push(Patch { + x: (rect.u0 * atlas.width as f32).round() as u32, + y: (rect.v0 * atlas.height as f32).round() as u32, + width: PACK_ICON_SIZE, + height: PACK_ICON_SIZE, + rgba: icon.to_vec(), + }); + *texture = sprite; + } + } /// The shown screen's calls (`Screen.extractRenderState`); `blink_ms` /// is the time since the search box took the focus. @@ -891,7 +951,7 @@ impl PackScreen { -8978432, ); } - let icon = if p.icon { + let icon = if p.icon.is_some() { icon_texture(id) } else { "textures/misc/unknown_pack.png".into() @@ -979,6 +1039,106 @@ impl PackScreen { } } +#[cfg(test)] +mod icon_tests { + use super::*; + + fn png(w: u32, h: u32, rgba: &[u8]) -> Vec { + let mut out = Vec::new(); + let mut encoder = png::Encoder::new(&mut out, w, h); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + encoder + .write_header() + .unwrap() + .write_image_data(rgba) + .unwrap(); + out + } + fn pack(id: &str, icon: Option>) -> PackInfo { + PackInfo { + id: id.into(), + title: Text::literal(id), + description: Text::literal(""), + description_style: Style::default(), + source: Source::BuiltIn, + compat: Compat::Compatible, + icon, + required: false, + position: Position::Top, + fixed: false, + } + } + + /// Any size stretches over the whole square, nearest texels, as the + /// icon texture is sampled into its 32x32 blit. + #[test] + fn icons_stretch_to_the_slot_by_nearest_texels() { + let (red, blue) = ([255, 0, 0, 255], [0, 0, 255, 128]); + let icon = load_icon(&png(2, 1, &[red, blue].concat())).unwrap(); + let side = PACK_ICON_SIZE as usize; + assert_eq!(icon.len(), side * side * 4); + let at = |x: usize, y: usize| &icon[(y * side + x) * 4..][..4]; + assert_eq!((at(0, 0), at(side / 2 - 1, side - 1)), (&red[..], &red[..])); + assert_eq!( + (at(side / 2, 0), at(side - 1, side - 1)), + (&blue[..], &blue[..]) + ); + assert!(load_icon(b"not a png").is_none()); + } + + /// Programmer Art and High Contrast draw their own `pack.png`; a pack + /// without one keeps `unknown_pack`. + #[test] + fn drawn_icons_take_atlas_slots() { + let atlas = + crate::hud::HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")) + .unwrap(); + let m = Measure(&atlas.font); + let dirt = load_icon(&png(1, 1, &[134, 96, 67, 255])).unwrap(); + let contrast = load_icon(&png(1, 1, &[0, 0, 0, 255])).unwrap(); + let packs = vec![ + pack("programmer_art", Some(dirt.clone())), + pack("high_contrast", Some(contrast.clone())), + pack("file/Iconless", None), + ]; + let screen = PackScreen::new(&m, 480, 320, false, packs, &[]); + let mut draws = screen.draw(&m, (0, 0), 0); + let mut patches = Vec::new(); + screen.bind_icons(&mut draws, &atlas, &mut patches); + let icons: Vec<&str> = draws + .iter() + .filter_map(|d| match d { + Draw::Blit { texture, .. } if texture.contains("pack") => Some(texture.as_str()), + _ => None, + }) + .collect(); + // The list shows them sorted by id. + assert_eq!( + icons, + [ + "textures/misc/unknown_pack.png", + "horizon/pack-icon0", + "horizon/pack-icon1" + ] + ); + assert_eq!(patches.len(), 2); + for (i, (patch, icon)) in patches.iter().zip([&contrast, &dirt]).enumerate() { + let rect = atlas.sprites[&format!("horizon/pack-icon{i}")]; + assert_eq!( + (patch.x, patch.y, patch.width, patch.height), + ( + (rect.u0 * atlas.width as f32).round() as u32, + (rect.v0 * atlas.height as f32).round() as u32, + PACK_ICON_SIZE, + PACK_ICON_SIZE + ) + ); + assert_eq!(&patch.rgba[..], &icon[..]); + } + } +} + #[cfg(test)] mod click_sound_tests { use super::*; diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 5daaaacad..5b4d11e82 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -34,8 +34,6 @@ pub struct Pack { pub description_style: Style, pub compatible: bool, pub compatibility: crate::pack_screen::Compat, - /// The pack has a `pack.png`. - pub icon: bool, /// Overlay directories active for this game version, in `pack.mcmeta` order. pub overlays: Vec, /// `filter.block` entries (namespace and path patterns) hiding resources @@ -260,6 +258,15 @@ fn filter_of(meta: &serde_json::Value) -> Vec { }) .collect() } +impl Pack { + /// The pack's `pack.png` (`PackResources.getRootResource`), for its icon. + pub fn icon_png(&self) -> Option> { + match &self.source { + Source::Dir(d) => fs::read(d.join("pack.png")).ok(), + Source::Zip(z) => Zip::open(z).ok()?.read("pack.png").ok(), + } + } +} fn read_meta(source: &Source) -> Option { let bytes = match source { Source::Dir(d) => fs::read(d.join("pack.mcmeta")).ok()?, @@ -270,10 +277,6 @@ fn read_meta(source: &Source) -> Option { fn pack(id: String, title: Text, source: Source) -> Option { let meta = read_meta(&source)?; let (raw_description, description_style) = component_root(&meta["pack"]["description"]); - let icon = match &source { - Source::Dir(d) => d.join("pack.png").is_file(), - Source::Zip(z) => Zip::open(z).is_ok_and(|z| z.read("pack.png").is_ok()), - }; Some(Pack { id, title, @@ -282,7 +285,6 @@ fn pack(id: String, title: Text, source: Source) -> Option { description_style, compatible: compatible(&meta), compatibility: compatibility(&meta), - icon, overlays: overlays_of(&meta), filter: filter_of(&meta), source, @@ -629,6 +631,17 @@ fn merge(kind: Merge, layers: &[Vec]) -> Option> { }; serde_json::to_vec(&out).ok() } +/// `DownloadedPackSource.loadRequestedPacks`: a server's downloaded pack, +/// "World Specific Resources"; None when its `pack.mcmeta` can't be read. Its +/// id names the file, which is named after its hash. +pub fn server_pack(id: u128, path: &Path) -> Option { + let file = path.file_name()?.to_string_lossy(); + pack( + format!("server/{id:032x}/{file}"), + Text::translate("resourcePack.server.name", &[]), + Source::Zip(path.to_path_buf()), + ) +} /// The packs to apply for an options.txt `resourcePacks` list (bottom first). pub fn enabled(all: &[Pack], ids: &[String]) -> Vec { ids.iter() @@ -983,6 +996,45 @@ mod tests { let _ = fs::remove_dir_all(base); } #[test] + fn built_in_and_folder_packs_give_their_pack_png() { + use std::io::Write as _; + let base = std::env::temp_dir().join(format!("horizon-pack-icons-{}", std::process::id())); + let _ = fs::remove_dir_all(&base); + let meta = br#"{"pack":{"description":"d","pack_format":97}}"#; + let built_in = base.join("vanilla/assets/minecraft/resourcepacks"); + fs::create_dir_all(&built_in).unwrap(); + let mut zip = + zip::ZipWriter::new(fs::File::create(built_in.join("programmer_art.zip")).unwrap()); + for (name, data) in [("pack.mcmeta", &meta[..]), ("pack.png", b"dirt")] { + zip.start_file(name, zip::write::SimpleFileOptions::default()) + .unwrap(); + zip.write_all(data).unwrap(); + } + zip.finish().unwrap(); + for (name, icon) in [("Iconless", None), ("Mine", Some(&b"mine"[..]))] { + let dir = base.join("packs").join(name); + fs::create_dir_all(&dir).unwrap(); + fs::write(dir.join("pack.mcmeta"), meta).unwrap(); + if let Some(icon) = icon { + fs::write(dir.join("pack.png"), icon).unwrap(); + } + } + let packs = discover(&base.join("vanilla"), &base.join("packs")); + let icons: Vec<_> = packs + .iter() + .map(|p| (p.id.as_str(), p.icon_png())) + .collect(); + assert_eq!( + icons, + [ + ("programmer_art", Some(b"dirt".to_vec())), + ("file/Iconless", None), + ("file/Mine", Some(b"mine".to_vec())), + ] + ); + let _ = fs::remove_dir_all(base); + } + #[test] fn overlays_and_filters() { let v = |s: &str| serde_json::from_str::(s).unwrap(); let meta = v(r#"{"overlays":{"entries":[ diff --git a/crates/horizon-client/src/server_packs.rs b/crates/horizon-client/src/server_packs.rs new file mode 100644 index 000000000..8e11217b5 --- /dev/null +++ b/crates/horizon-client/src/server_packs.rs @@ -0,0 +1,618 @@ +//! Server resource packs (`ServerPackManager`, `DownloadedPackSource`): the +//! packs a server pushes, the player's answer to its prompt, their downloads, +//! their activation on top of the player's own packs, and the status each one +//! reports back to the server. The game drives it: it shows the prompt, +//! starts the downloads [`ServerPacks::tick`] asks for and reloads the +//! resources with [`ServerPacks::active`] when it asks for a reload. +pub mod download; + +use std::path::PathBuf; + +/// `ServerboundResourcePackPacket.Action`, by its protocol number. +pub mod action { + pub const SUCCESSFULLY_LOADED: i32 = 0; + pub const DECLINED: i32 = 1; + pub const FAILED_DOWNLOAD: i32 = 2; + pub const ACCEPTED: i32 = 3; + pub const DOWNLOADED: i32 = 4; + pub const INVALID_URL: i32 = 5; + pub const FAILED_RELOAD: i32 = 6; + pub const DISCARDED: i32 = 7; +} + +/// `ServerPackManager.PackPromptStatus`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Prompt { + Pending, + Allowed, + Declined, +} +impl Prompt { + /// `ConnectScreen.convertPackStatus`: a server list entry's setting + /// (servers.dat `acceptTextures`; none is Prompt). + pub fn for_server(accept_textures: Option) -> Self { + match accept_textures { + Some(true) => Self::Allowed, + Some(false) => Self::Declined, + None => Self::Pending, + } + } +} + +/// `ClientCommonPacketListenerImpl.parseResourcePackUrl`: only http and https. +pub fn valid_url(url: &str) -> bool { + url.split_once(':').is_some_and(|(scheme, _)| { + scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https") + }) +} + +/// `DownloadedPackSource.tryParseSha1Hash`: 40 hex digits, else no check. +pub fn parse_sha1(hash: &str) -> Option { + (hash.len() == 40 && hash.bytes().all(|b| b.is_ascii_hexdigit())) + .then(|| hash.to_ascii_lowercase()) +} + +/// One pack to download (`DownloadQueue.DownloadRequest`). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Request { + pub id: u128, + pub url: String, + pub sha1: Option, +} + +/// `DownloadQueue.BatchResult`: the file each downloaded pack is in, and the +/// packs that failed. +#[derive(Debug, Default)] +pub struct Batch { + pub downloaded: Vec<(u128, PathBuf)>, + pub failed: Vec, +} + +/// What the game has to do after a [`ServerPacks::tick`]. +#[derive(Debug, Default, PartialEq)] +pub struct Tick { + /// Download these, then hand the result to [`ServerPacks::downloaded`]. + pub download: Vec, + /// Reload the resources with these packs on top, bottom first + /// (`PackReloadConfig.scheduleReload`), then call [`ServerPacks::reloaded`]. + pub reload: Option>, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Download { + Requested, + Pending, + Done, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Activation { + Inactive, + Pending, + Active, +} +/// `ServerPackManager.RemovalReason`, with the status it reports. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Removal { + DownloadFailed, + ActivationFailed, + Declined, + Discarded, + ServerRemoved, + ServerReplaced, +} +impl Removal { + fn reply(self) -> Option { + match self { + Self::DownloadFailed => Some(action::FAILED_DOWNLOAD), + Self::ActivationFailed => Some(action::FAILED_RELOAD), + Self::Declined => Some(action::DECLINED), + Self::Discarded => Some(action::DISCARDED), + Self::ServerRemoved | Self::ServerReplaced => None, + } + } +} + +/// `ServerPackManager.ServerPackData`. +#[derive(Debug)] +struct Pack { + id: u128, + url: String, + sha1: Option, + path: Option, + removal: Option, + download: Download, + activation: Activation, + accepted: bool, +} +impl Pack { + fn remove(&mut self, reason: Removal) { + self.removal.get_or_insert(reason); + } + fn removed(&self) -> bool { + self.removal.is_some() + } +} + +/// The reload in progress: the packs it loads and unloads (the callbacks +/// `triggerReloadIfNeeded` gives `scheduleReload`). +#[derive(Debug)] +struct Reload { + load: Vec, + unload: Vec, + /// It reloads what was active before a failed one (`isRecovery`). + recovery: bool, +} + +/// `ServerPackManager` with the feedback `DownloadedPackSource` gives it. +#[derive(Debug)] +pub struct ServerPacks { + packs: Vec, + prompt: Prompt, + reload: Option, + /// `registerForUpdate`: something changed, [`Self::tick`] again. + update: bool, + /// Report to the server (`configureForServerControl`); otherwise the + /// statuses are only logged, as for a local world. + reporting: bool, + replies: Vec<(u128, i32)>, +} +impl Default for ServerPacks { + fn default() -> Self { + Self { + packs: Vec::new(), + prompt: Prompt::Pending, + reload: None, + update: false, + reporting: false, + replies: Vec::new(), + } + } +} +impl ServerPacks { + fn report(&mut self, id: u128, status: i32) { + log::debug!("Horizon: server pack {id:032x} changed status to {status}"); + if self.reporting { + self.replies.push((id, status)); + } + } + /// The statuses to send the server, oldest first. + pub fn take_replies(&mut self) -> Vec<(u128, i32)> { + std::mem::take(&mut self.replies) + } + /// Whether [`Self::tick`] has something to do. + pub fn wants_tick(&self) -> bool { + self.update + } + + /// `DownloadedPackSource.configureForServerControl`. + pub fn connect(&mut self, prompt: Prompt) { + self.reporting = true; + match prompt { + Prompt::Allowed => self.allow(), + Prompt::Declined => self.reject(), + Prompt::Pending => self.prompt = Prompt::Pending, + } + } + /// `DownloadedPackSource.configureForLocalWorld`: single player's own + /// server; its packs are taken, and nothing is reported. + pub fn local_world(&mut self) { + self.reporting = false; + self.allow(); + } + /// `DownloadedPackSource.cleanupAfterDisconnect`: every pack goes, and + /// the next server starts from its own setting. + pub fn disconnect(&mut self) { + self.pop_all(); + self.reporting = false; + self.replies.clear(); + self.prompt = Prompt::Pending; + } + + pub fn push(&mut self, id: u128, url: &str, sha1: Option) { + if self.prompt == Prompt::Declined { + self.report(id, action::DECLINED); + return; + } + for pack in self.packs.iter_mut().filter(|p| p.id == id) { + pack.remove(Removal::ServerReplaced); + } + self.packs.push(Pack { + id, + url: url.to_owned(), + sha1, + path: None, + removal: None, + download: Download::Requested, + activation: Activation::Inactive, + accepted: false, + }); + if self.prompt == Prompt::Allowed { + self.accept(self.packs.len() - 1); + } + self.update = true; + } + fn accept(&mut self, i: usize) { + self.packs[i].accepted = true; + let id = self.packs[i].id; + self.report(id, action::ACCEPTED); + } + pub fn pop(&mut self, id: u128) { + if let Some(pack) = self.packs.iter_mut().find(|p| !p.removed() && p.id == id) { + pack.remove(Removal::ServerRemoved); + self.update = true; + } + } + pub fn pop_all(&mut self) { + for pack in &mut self.packs { + pack.remove(Removal::ServerRemoved); + } + self.update = true; + } + /// `allowServerPacks`: the prompt said yes (or the server is Enabled). + pub fn allow(&mut self) { + self.prompt = Prompt::Allowed; + for i in 0..self.packs.len() { + if !self.packs[i].accepted && !self.packs[i].removed() { + self.accept(i); + } + } + self.update = true; + } + /// `rejectServerPacks`: the prompt said no (or the server is Disabled). + pub fn reject(&mut self) { + self.prompt = Prompt::Declined; + for pack in self.packs.iter_mut().filter(|p| !p.accepted) { + pack.remove(Removal::Declined); + } + self.update = true; + } + + /// `ServerPackManager.tick`: start the downloads the accepted packs + /// need; once none is left, reload if the active packs should change; + /// then forget the packs that are gone, reporting why. + pub fn tick(&mut self) -> Tick { + self.update = false; + let mut out = Tick::default(); + let mut downloading = false; + for pack in self.packs.iter_mut().filter(|p| !p.removed() && p.accepted) { + downloading |= pack.download != Download::Done; + if pack.download == Download::Requested { + pack.download = Download::Pending; + out.download.push(Request { + id: pack.id, + url: pack.url.clone(), + sha1: pack.sha1.clone(), + }); + } + } + if !downloading { + out.reload = self.reload_if_needed(); + } + let mut gone = Vec::new(); + self.packs.retain(|p| { + let keep = p.activation != Activation::Inactive || p.removal.is_none(); + if !keep && let Some(reply) = p.removal.and_then(Removal::reply) { + gone.push((p.id, reply)); + } + keep + }); + for (id, reply) in gone { + self.report(id, reply); + } + out + } + fn reload_if_needed(&mut self) -> Option> { + if self.reload.is_some() + || self + .packs + .iter() + .any(|p| p.activation == Activation::Pending) + { + return None; + } + let mut changed = false; + let (mut load, mut unload) = (Vec::new(), Vec::new()); + for pack in &self.packs { + let wanted = pack.accepted && pack.download == Download::Done && !pack.removed(); + match pack.activation { + Activation::Inactive if wanted => { + load.push(pack.id); + changed = true; + } + Activation::Active if wanted => load.push(pack.id), + Activation::Active => { + unload.push(pack.id); + changed = true; + } + _ => {} + } + } + if !changed { + return None; + } + for pack in &mut self.packs { + let loading = load.contains(&pack.id) && pack.activation != Activation::Active; + if loading || unload.contains(&pack.id) { + pack.activation = Activation::Pending; + } + } + let paths = self.paths(&load); + self.reload = Some(Reload { + load, + unload, + recovery: false, + }); + Some(paths) + } + /// The packs to load (`PackReloadConfig.Callbacks.packsToLoad`), bottom first. + fn paths(&self, ids: &[u128]) -> Vec<(u128, PathBuf)> { + ids.iter() + .filter_map(|id| { + let pack = self + .packs + .iter() + .find(|p| p.id == *id && p.path.is_some())?; + Some((*id, pack.path.clone()?)) + }) + .collect() + } + + /// `ServerPackManager.onDownload`. + pub fn downloaded(&mut self, batch: Batch) { + if !batch.failed.is_empty() { + for pack in self + .packs + .iter_mut() + .filter(|p| p.activation != Activation::Active) + { + pack.remove(if batch.failed.contains(&pack.id) { + Removal::DownloadFailed + } else { + Removal::Discarded + }); + } + } + let mut done = Vec::new(); + for (id, path) in batch.downloaded { + if let Some(pack) = self + .packs + .iter_mut() + .find(|p| p.id == id && p.download == Download::Pending) + { + pack.download = Download::Done; + pack.path = Some(path); + if !pack.removed() { + done.push(id); + } + } + } + for id in done { + self.report(id, action::DOWNLOADED); + } + self.update = true; + } + + /// The reload [`Tick::reload`] asked for finished (`Callbacks.onSuccess`), + /// or its packs could not be loaded (`onFailure`). After a first failure + /// the packs that were active are loaded again: the packs to reload with + /// are returned, and this is called again with that reload's outcome. + pub fn reloaded(&mut self, ok: bool) -> Option> { + let mut reload = self.reload.take()?; + self.update = true; + if ok { + let mut applied = Vec::new(); + for pack in &mut self.packs { + if reload.load.contains(&pack.id) { + pack.activation = Activation::Active; + if pack.removal.is_none() { + applied.push(pack.id); + } + } else if reload.unload.contains(&pack.id) { + pack.activation = Activation::Inactive; + } + } + for id in applied { + self.report(id, action::SUCCESSFULLY_LOADED); + } + return None; + } + if reload.recovery { + // onFailure(true): nothing of the server's is loaded. + for pack in &mut self.packs { + if pack.activation == Activation::Pending { + pack.activation = Activation::Inactive; + } + } + return None; + } + reload.load.clear(); + for pack in &mut self.packs { + match pack.activation { + Activation::Inactive => pack.remove(Removal::Discarded), + Activation::Pending => { + pack.activation = Activation::Inactive; + pack.remove(Removal::ActivationFailed); + } + Activation::Active => reload.load.push(pack.id), + } + } + reload.recovery = true; + let paths = self.paths(&reload.load); + self.reload = Some(reload); + Some(paths) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use action::*; + + fn ok(id: u128) -> Batch { + Batch { + downloaded: vec![(id, PathBuf::from(format!("/p/{id}")))], + failed: vec![], + } + } + /// Runs the updates as `createUpdateScheduler` does, downloading and + /// reloading with `download` and `reload` as the game would. + fn settle( + sp: &mut ServerPacks, + download: &mut dyn FnMut(&[Request]) -> Batch, + reload: &mut dyn FnMut(&[(u128, PathBuf)]) -> bool, + ) { + let mut rounds = 0; + while sp.wants_tick() { + rounds += 1; + assert!(rounds < 50); + let t = sp.tick(); + if !t.download.is_empty() { + let batch = download(&t.download); + sp.downloaded(batch); + } + if let Some(mut packs) = t.reload { + while let Some(back) = sp.reloaded(reload(&packs)) { + packs = back; + } + } + } + } + + #[test] + fn an_enabled_server_s_pack_is_accepted_downloaded_and_loaded() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + let mut loaded = Vec::new(); + settle(&mut sp, &mut |r| ok(r[0].id), &mut |p| { + loaded = p.to_vec(); + true + }); + assert_eq!( + sp.take_replies(), + [(1, ACCEPTED), (1, DOWNLOADED), (1, SUCCESSFULLY_LOADED)] + ); + assert_eq!(loaded, [(1, PathBuf::from("/p/1"))]); + } + + #[test] + fn the_prompt_holds_packs_until_answered() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Pending); + sp.push(1, "http://a/p.zip", None); + settle(&mut sp, &mut |_| unreachable!(), &mut |_| unreachable!()); + assert!(sp.take_replies().is_empty()); + sp.reject(); + settle(&mut sp, &mut |_| unreachable!(), &mut |_| unreachable!()); + assert_eq!(sp.take_replies(), [(1, DECLINED)]); + // Declined: later pushes are declined at once. + sp.push(2, "http://a/q.zip", None); + assert_eq!(sp.take_replies(), [(2, DECLINED)]); + } + + #[test] + fn a_failed_download_discards_the_rest_of_the_batch() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + sp.push(2, "http://a/dead.zip", None); + settle( + &mut sp, + &mut |_| Batch { + downloaded: vec![(1, PathBuf::from("/p/1"))], + failed: vec![2], + }, + &mut |_| unreachable!(), + ); + assert_eq!( + sp.take_replies(), + [ + (1, ACCEPTED), + (2, ACCEPTED), + (1, DISCARDED), + (2, FAILED_DOWNLOAD) + ] + ); + } + + #[test] + fn a_pack_that_does_not_load_fails_its_reload() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + let mut reloads = Vec::new(); + settle(&mut sp, &mut |r| ok(r[0].id), &mut |p| { + reloads.push(p.to_vec()); + reloads.len() > 1 + }); + assert_eq!( + sp.take_replies(), + [(1, ACCEPTED), (1, DOWNLOADED), (1, FAILED_RELOAD)] + ); + // The recovery reload has none of the server's packs. + assert_eq!(reloads[1], []); + } + + #[test] + fn popping_and_disconnecting_unload_the_packs() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/p.zip", None); + sp.push(2, "http://a/q.zip", None); + let last = std::cell::RefCell::new(Vec::new()); + let mut reload = |p: &[(u128, PathBuf)]| { + *last.borrow_mut() = p.to_vec(); + true + }; + settle( + &mut sp, + &mut |r| Batch { + downloaded: r + .iter() + .map(|q| (q.id, PathBuf::from(format!("/p/{}", q.id)))) + .collect(), + failed: vec![], + }, + &mut reload, + ); + sp.take_replies(); + sp.pop(1); + settle(&mut sp, &mut |_| unreachable!(), &mut reload); + // Callbacks.onSuccess reports every pack the reload loaded, again. + assert_eq!(sp.take_replies(), [(2, SUCCESSFULLY_LOADED)]); + assert_eq!(*last.borrow(), [(2, PathBuf::from("/p/2"))]); + sp.disconnect(); + settle(&mut sp, &mut |_| unreachable!(), &mut reload); + assert!(last.borrow().is_empty()); + assert!(sp.packs.is_empty()); + } + + #[test] + fn a_pushed_id_replaces_its_pack() { + let mut sp = ServerPacks::default(); + sp.connect(Prompt::Allowed); + sp.push(1, "http://a/old.zip", None); + sp.push(1, "http://a/new.zip", None); + let mut urls = Vec::new(); + settle( + &mut sp, + &mut |r| { + urls.extend(r.iter().map(|q| q.url.clone())); + ok(1) + }, + &mut |_| true, + ); + assert_eq!(urls, ["http://a/new.zip"]); + } + + #[test] + fn urls_and_hashes_are_read_as_vanilla_reads_them() { + assert!(valid_url("https://example.com/p.zip")); + assert!(valid_url("HTTP://example.com/p.zip")); + assert!(!valid_url("ftp://example.com/p.zip")); + assert!(!valid_url("example.com/p.zip")); + let sha1 = "0123456789ABCDEF0123456789abcdef01234567"; + assert_eq!(parse_sha1(sha1), Some(sha1.to_ascii_lowercase())); + assert_eq!(parse_sha1("abc"), None); + } +} diff --git a/crates/horizon-client/src/server_packs/download.rs b/crates/horizon-client/src/server_packs/download.rs new file mode 100644 index 000000000..595612df8 --- /dev/null +++ b/crates/horizon-client/src/server_packs/download.rs @@ -0,0 +1,482 @@ +//! Server pack downloads into the game directory's `downloads/` cache, as +//! vanilla keeps it (`DownloadQueue`, `HttpUtil.downloadFile`, +//! `DownloadCacheCleaner`): `downloads//`, one +//! batch at a time on a thread of its own, every download logged in +//! `downloads/log.json`, and the cache cut to its 20 newest files on start. +use super::{Batch, Request}; +use sha1::{Digest, Sha1}; +use std::{ + fs, + io::{self, Read, Write}, + path::{Path, PathBuf}, + sync::mpsc::{Receiver, Sender, channel}, + time::SystemTime, +}; + +/// `DownloadedPackSource`'s MAX_PACK_SIZE_BYTES (250 MiB). +pub const MAX_SIZE: u64 = 262_144_000; +/// `DownloadQueue.MAX_KEPT_PACKS`. +const MAX_KEPT: usize = 20; + +/// `createDownloadHeaders`: who is downloading, with which game. +pub fn headers(name: &str, uuid: u128) -> Vec<(&'static str, String)> { + use horizon_core::version::{RESOURCE_PACK_FORMAT, VANILLA_VERSION, VERSION_ID}; + vec![ + ("X-Minecraft-Username", name.to_owned()), + ("X-Minecraft-UUID", format!("{uuid:032x}")), + ("X-Minecraft-Version", VANILLA_VERSION.to_owned()), + ("X-Minecraft-Version-ID", VERSION_ID.to_owned()), + ( + "X-Minecraft-Pack-Format", + format!("{}.{}", RESOURCE_PACK_FORMAT.0, RESOURCE_PACK_FORMAT.1), + ), + ("User-Agent", format!("Minecraft Java/{VANILLA_VERSION}")), + ] +} + +type Job = (Vec, Vec<(&'static str, String)>); + +/// `DownloadQueue`: batches download in order, on one thread. +pub struct Queue { + jobs: Sender, + done: Receiver, +} +impl Queue { + pub fn open(dir: PathBuf) -> io::Result { + fs::create_dir_all(&dir)?; + vacuum(&dir, MAX_KEPT); + let (jobs, todo) = channel::(); + let (finished, done) = channel(); + std::thread::Builder::new() + .name("download-queue".into()) + .spawn(move || { + for (requests, headers) in todo { + if finished.send(run(&dir, &requests, &headers)).is_err() { + break; + } + } + })?; + Ok(Self { jobs, done }) + } + pub fn download(&self, requests: Vec, headers: Vec<(&'static str, String)>) { + let _ = self.jobs.send((requests, headers)); + } + /// The batches finished since the last call. + pub fn finished(&self) -> Vec { + self.done.try_iter().collect() + } +} + +/// `DownloadQueue.runDownload`: each pack into `//`, logged. +fn run(dir: &Path, requests: &[Request], headers: &[(&'static str, String)]) -> Batch { + let mut batch = Batch::default(); + for request in requests { + let id = horizon_protocol::crypto::uuid_string(request.id); + let result = download_file(&dir.join(&id), request, headers, MAX_SIZE); + // DownloadQueue.LogEntry, its fields in the codec's order. + let mut entry = vec![ + ("id", serde_json::Value::from(id)), + ("url", request.url.as_str().into()), + ( + "time", + chrono::Utc::now() + .to_rfc3339_opts(chrono::SecondsFormat::AutoSi, true) + .into(), + ), + ]; + if let Some(sha1) = &request.sha1 { + entry.push(("hash", sha1.as_str().into())); + } + entry.push(match &result { + Ok(path) => match fs::metadata(path) { + Ok(meta) => { + let name = path.strip_prefix(dir).unwrap_or(path); + let name = name.to_string_lossy().replace('\\', "/"); + ( + "file", + serde_json::json!({"name": name, "size": meta.len()}), + ) + } + Err(_) => ("error", "no_access".into()), + }, + Err(e) => { + log::error!("Horizon: failed to download {}: {e}", request.url); + ("error", "download_failed".into()) + } + }); + if let Err(e) = append_log(&dir.join("log.json"), &entry) { + log::error!("Horizon: failed to log download of {}: {e}", request.url); + } + match result { + Ok(path) => batch.downloaded.push((request.id, path)), + Err(_) => batch.failed.push(request.id), + } + } + batch +} + +/// `JsonEventLog.write`: one JSON object a line, as Gson writes it (with +/// its HTML escaping). +fn append_log(path: &Path, entry: &[(&str, serde_json::Value)]) -> io::Result<()> { + let fields: Vec = entry + .iter() + .map(|(k, v)| format!("{}:{v}", serde_json::Value::from(*k))) + .collect(); + let mut line = String::new(); + for c in format!("{{{}}}", fields.join(",")).chars() { + match c { + '<' | '>' | '&' | '=' | '\'' => line.push_str(&format!("\\u{:04x}", c as u32)), + c => line.push(c), + } + } + line.push('\n'); + fs::OpenOptions::new() + .create(true) + .append(true) + .open(path)? + .write_all(line.as_bytes()) +} + +fn sha1_of(path: &Path) -> io::Result { + let mut hasher = Sha1::new(); + io::copy(&mut fs::File::open(path)?, &mut hasher)?; + Ok(hex(&hasher.finalize())) +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +/// `checkExistingFile`: the file is there with that hash. +fn matches(path: &Path, sha1: &str) -> bool { + path.exists() && sha1_of(path).is_ok_and(|actual| actual == sha1) +} +/// `updateModificationTime`: used now, so the cleaner keeps it longest. +fn touch(path: &Path) { + let _ = fs::File::options() + .append(true) + .open(path) + .and_then(|f| f.set_modified(SystemTime::now())); +} + +/// `HttpUtil.downloadFile`: into `/`. With a hash the cached file +/// is used when it matches, and a download that does not is an error; +/// without one the file is named after the hash of what came. +pub fn download_file( + dir: &Path, + request: &Request, + headers: &[(&'static str, String)], + max_size: u64, +) -> Result { + let target = request.sha1.as_ref().map(|sha1| dir.join(sha1)); + if let (Some(target), Some(sha1)) = (&target, &request.sha1) { + if matches(target, sha1) { + log::info!("Horizon: returning cached file since actual hash matches requested"); + touch(target); + return Ok(target.clone()); + } + if target.exists() { + log::warn!( + "Horizon: existing file {} not found or had mismatched hash", + target.display() + ); + } + fs::remove_file(target) + .or_else(|e| { + if e.kind() == io::ErrorKind::NotFound { + Ok(()) + } else { + Err(e) + } + }) + .map_err(|e| format!("Failed to remove existing file {}: {e}", target.display()))?; + } + let mut call = ureq::AgentBuilder::new().build().get(&request.url); + for (name, value) in headers { + call = call.set(name, value); + } + let response = call.call().map_err(|e| e.to_string())?; + let size = response + .header("Content-Length") + .and_then(|v| v.trim().parse::().ok()); + fs::create_dir_all(dir).map_err(|e| e.to_string())?; + if let Some(size) = size + && size > max_size + { + return Err(format!( + "Filesize is bigger than maximum allowed (file is {size}, limit is {max_size})" + )); + } + let mut input = response.into_reader(); + match (&target, &request.sha1) { + (Some(target), Some(sha1)) => { + let actual = save_hashed(&mut input, target, max_size).map_err(|e| e.to_string())?; + if &actual != sha1 { + return Err(format!( + "Hash of downloaded file ({actual}) did not match requested ({sha1})" + )); + } + Ok(target.clone()) + } + _ => { + let tmp = dir.join(format!("download{:016x}.tmp", rand_suffix())); + let result = save_hashed(&mut input, &tmp, max_size).and_then(|actual| { + let path = dir.join(&actual); + if matches(&path, &actual) { + touch(&path); + } else { + fs::rename(&tmp, &path)?; + } + Ok(path) + }); + let _ = fs::remove_file(&tmp); + result.map_err(|e| e.to_string()) + } + } +} +fn rand_suffix() -> u64 { + use std::hash::{BuildHasher, RandomState}; + RandomState::new().hash_one(std::time::Instant::now()) +} +/// `downloadAndHash`: write what comes, at most `max_size` bytes. +fn save_hashed(input: &mut dyn Read, path: &Path, max_size: u64) -> io::Result { + let mut out = fs::File::create(path)?; + let mut hasher = Sha1::new(); + let mut buffer = [0u8; 8196]; + let mut read_so_far = 0u64; + loop { + let n = input.read(&mut buffer)?; + if n == 0 { + break; + } + read_so_far += n as u64; + if read_so_far > max_size { + return Err(io::Error::other(format!( + "Filesize was bigger than maximum allowed (got >= {read_so_far}, limit was {max_size})" + ))); + } + out.write_all(&buffer[..n])?; + hasher.update(&buffer[..n]); + } + Ok(hex(&hasher.finalize())) +} + +/// `DownloadCacheCleaner.vacuumCacheDir`: keep the `max_files` files most +/// worth keeping (in the pack folders: the newest, and one per pack before a +/// second of any), then drop the folders left empty. +pub fn vacuum(dir: &Path, max_files: usize) { + let mut files = Vec::new(); + let mut stack = vec![dir.to_path_buf()]; + while let Some(d) = stack.pop() { + let Ok(entries) = fs::read_dir(&d) else { + continue; + }; + for e in entries.flatten() { + let path = e.path(); + let Ok(meta) = e.metadata() else { continue }; + if meta.is_dir() { + stack.push(path); + } else if meta.is_file() && path.parent() != Some(dir) { + let time = meta.modified().unwrap_or(SystemTime::UNIX_EPOCH); + files.push((path, time)); + } + } + } + let Some(remove) = files.len().checked_sub(max_files).filter(|n| *n > 0) else { + return; + }; + // Newest first, then each file's rank in its folder (0 for a folder's + // newest), reversed, and stably sorted by rank, highest first. + files.sort_by_key(|f| std::cmp::Reverse(f.1)); + let mut counts = std::collections::HashMap::::new(); + let mut ranked: Vec<(PathBuf, usize)> = files + .into_iter() + .map(|(path, _)| { + let count = counts + .entry(path.parent().unwrap_or(dir).to_path_buf()) + .or_default(); + let rank = *count; + *count += 1; + (path, rank) + }) + .collect(); + ranked.reverse(); + ranked.sort_by_key(|f| std::cmp::Reverse(f.1)); + let mut emptied = std::collections::HashSet::new(); + for (path, rank) in ranked.into_iter().take(remove) { + match fs::remove_file(&path) { + Ok(()) if rank == 0 => { + emptied.insert(path.parent().unwrap_or(dir).to_path_buf()); + } + Ok(()) => {} + Err(e) => log::warn!( + "Horizon: failed to delete cache file {}: {e}", + path.display() + ), + } + } + emptied.remove(dir); + for d in emptied { + let _ = fs::remove_dir(d); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::net::TcpListener; + + /// A one-shot HTTP server answering `status` with `body`; the request it got. + fn serve(status: &str, body: Vec) -> (String, std::thread::JoinHandle) { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let url = format!("http://{}/pack.zip", listener.local_addr().unwrap()); + let status = status.to_owned(); + let handle = std::thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + let mut request = Vec::new(); + let mut buf = [0u8; 1024]; + while !request.ends_with(b"\r\n\r\n") { + let n = stream.read(&mut buf).unwrap(); + request.extend_from_slice(&buf[..n]); + } + let head = format!( + "HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", + body.len() + ); + stream.write_all(head.as_bytes()).unwrap(); + stream.write_all(&body).unwrap(); + String::from_utf8_lossy(&request).into_owned() + }); + (url, handle) + } + fn sha1(bytes: &[u8]) -> String { + hex(&Sha1::digest(bytes)) + } + fn scratch() -> PathBuf { + let dir = std::env::temp_dir().join(format!("horizon-packs-{:016x}", rand_suffix())); + fs::create_dir_all(&dir).unwrap(); + dir + } + + #[test] + fn a_pack_lands_under_its_hash_and_is_reused_from_the_cache() { + let dir = scratch(); + let body = b"PK pack".to_vec(); + let (url, server) = serve("200 OK", body.clone()); + let request = Request { + id: 7, + url, + sha1: Some(sha1(&body)), + }; + let path = download_file(&dir, &request, &headers("Alex", 0xab), MAX_SIZE).unwrap(); + assert_eq!(path, dir.join(sha1(&body))); + assert_eq!(fs::read(&path).unwrap(), body); + let sent = server.join().unwrap(); + assert!(sent.contains("X-Minecraft-Username: Alex"), "{sent}"); + assert!(sent.contains("X-Minecraft-Pack-Format: 97.1"), "{sent}"); + // Cached: no server this time. + let cached = Request { + url: "http://127.0.0.1:9/gone.zip".into(), + ..request + }; + assert_eq!(download_file(&dir, &cached, &[], MAX_SIZE).unwrap(), path); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn a_wrong_hash_a_dead_url_and_a_large_pack_fail() { + let dir = scratch(); + let (url, server) = serve("200 OK", b"other bytes".to_vec()); + let wrong = Request { + id: 1, + url, + sha1: Some("0".repeat(40)), + }; + let err = download_file(&dir, &wrong, &[], MAX_SIZE).unwrap_err(); + assert!(err.contains("did not match requested"), "{err}"); + server.join().unwrap(); + let dead = Request { + id: 2, + url: "http://127.0.0.1:9/pack.zip".into(), + sha1: None, + }; + assert!(download_file(&dir.join("dead"), &dead, &[], MAX_SIZE).is_err()); + assert!(!dir.join("dead").exists()); + let (url, server) = serve("200 OK", vec![0; 100]); + let large = Request { + id: 3, + url, + sha1: None, + }; + let err = download_file(&dir, &large, &[], 10).unwrap_err(); + assert!(err.contains("bigger than maximum"), "{err}"); + let _ = server.join(); + let (url, server) = serve("404 Not Found", Vec::new()); + let missing = Request { + id: 4, + url, + sha1: None, + }; + assert!(download_file(&dir, &missing, &[], MAX_SIZE).is_err()); + server.join().unwrap(); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn the_queue_logs_each_download() { + let dir = scratch(); + let (url, server) = serve("200 OK", b"zip".to_vec()); + let queue = Queue::open(dir.clone()).unwrap(); + let id = 0x5b2c_7a4e_1f3d_4c8b_9a6e_2d4f_8b1c_3e5a; + queue.download( + vec![Request { + id, + url, + sha1: None, + }], + Vec::new(), + ); + let batch = loop { + if let Some(b) = queue.finished().pop() { + break b; + } + std::thread::sleep(std::time::Duration::from_millis(10)); + }; + server.join().unwrap(); + let file = dir + .join("5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a") + .join(sha1(b"zip")); + assert_eq!(batch.downloaded, [(id, file)]); + let log = fs::read_to_string(dir.join("log.json")).unwrap(); + let entry: serde_json::Value = serde_json::from_str(log.trim()).unwrap(); + assert_eq!(entry["id"], "5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a"); + assert_eq!(entry["file"]["size"], 3); + fs::remove_dir_all(dir).unwrap(); + } + + #[test] + fn the_cleaner_keeps_the_newest_file_of_each_pack_longest() { + let dir = scratch(); + let at = |secs| SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(secs); + for (pack, file, time) in [ + ("a", "1", 10), + ("a", "2", 20), + ("a", "3", 30), + ("b", "1", 5), + ] { + fs::create_dir_all(dir.join(pack)).unwrap(); + let path = dir.join(pack).join(file); + fs::write(&path, b"x").unwrap(); + fs::File::options() + .append(true) + .open(&path) + .unwrap() + .set_modified(at(time)) + .unwrap(); + } + fs::write(dir.join("log.json"), b"").unwrap(); + vacuum(&dir, 2); + assert!(dir.join("a/3").exists() && dir.join("b/1").exists()); + assert!(!dir.join("a/1").exists() && !dir.join("a/2").exists()); + assert!(dir.join("log.json").exists()); + fs::remove_dir_all(dir).unwrap(); + } +} diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 972389a82..9f00a12b1 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -14,19 +14,24 @@ interface log { warn, error, } + /// One line in the game's log as `[mod ] message`, at that level. write: func(level: level, message: string); } /// Capability `game-read`: the local player and the world clock. interface game { record player { + /// Feet position, in blocks. x: f64, y: f64, z: f64, /// Degrees, as F3 shows them. yaw: f32, + /// Degrees: -90 looks straight up, 90 straight down. pitch: f32, + /// Hit points as vanilla counts them: 20 is full health without effects. health: f32, + /// 0 to 20, as the hunger bar. food: u32, /// `minecraft:overworld`, `minecraft:the_nether`, ... dimension: string, @@ -39,6 +44,7 @@ interface game { } /// None on the title screen. get-player: func() -> option; + /// None on the title screen. get-clock: func() -> option; } @@ -58,11 +64,14 @@ interface hud { bottom-right, } record line { + /// Plain text, up to 256 characters. text: string, /// 0xRRGGBB. color: u32, } + /// Replaces the mod's panel: up to 16 lines in that corner of the screen. set-panel: func(corner: corner, lines: list); + /// Removes the mod's panel. clear: func(); } @@ -92,10 +101,13 @@ interface events { } /// Once, after loading. An error keeps the mod off and is shown. init: func() -> result; + /// Each game tick while in a world, with the game's tick counter. tick: func(tick: u64); + /// Each rendered frame, with the seconds since the last one. frame: func(seconds: f32); /// `/name args`: ok(some(text)) is shown as feedback, err(text) in red. command: func(name: string, args: string) -> result, string>; + /// Each chat line the player receives, as plain text. chat: func(text: string); } diff --git a/crates/horizon-mods/Cargo.toml b/crates/horizon-mods/Cargo.toml index 013d38a99..3dfc02331 100644 --- a/crates/horizon-mods/Cargo.toml +++ b/crates/horizon-mods/Cargo.toml @@ -30,5 +30,10 @@ pack = ["dep:wit-component", "dep:wit-parser"] name = "sandbox" required-features = ["runtime", "pack"] +# docs/api/mods-reference.md from the WIT contract (HORIZON_WRITE_DOCS=1 rewrites it). +[[test]] +name = "api_reference" +required-features = ["pack"] + [lints] workspace = true diff --git a/crates/horizon-mods/tests/api_reference.rs b/crates/horizon-mods/tests/api_reference.rs new file mode 100644 index 000000000..5e6a0a069 --- /dev/null +++ b/crates/horizon-mods/tests/api_reference.rs @@ -0,0 +1,304 @@ +//! docs/api/mods-reference.md, generated from the WIT contract and the manifest's capabilities, and a test that +//! fails when it is out of date. Update it with: +//! `HORIZON_WRITE_DOCS=1 cargo test -p horizon-mods --features pack --test api_reference`. +use horizon_mods::manifest::{APIS, Capability}; +use std::{fmt::Write, path::Path}; +use wit_parser::{Docs, Function, Handle, Resolve, Type, TypeDefKind, WorldItem}; + +const WIT: &str = "crates/horizon-mod-sdk/wit/horizon.wit"; +const DOC: &str = "docs/api/mods-reference.md"; + +fn root() -> &'static Path { + Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../..")) +} + +/// A doc comment on one line, for a table cell. +fn cell(docs: &Docs) -> String { + let text = docs.contents.as_deref().unwrap_or("").trim(); + text.split_whitespace() + .collect::>() + .join(" ") + .replace('|', "\\|") +} + +/// A type as WIT spells it. +fn ty(resolve: &Resolve, t: &Type) -> String { + let id = match t { + Type::Bool => return "bool".into(), + Type::U8 => return "u8".into(), + Type::U16 => return "u16".into(), + Type::U32 => return "u32".into(), + Type::U64 => return "u64".into(), + Type::S8 => return "s8".into(), + Type::S16 => return "s16".into(), + Type::S32 => return "s32".into(), + Type::S64 => return "s64".into(), + Type::F32 => return "f32".into(), + Type::F64 => return "f64".into(), + Type::Char => return "char".into(), + Type::String => return "string".into(), + Type::ErrorContext => return "error-context".into(), + Type::Id(id) => *id, + }; + match &resolve.types[id].name { + Some(name) => name.clone(), + None => definition(resolve, &resolve.types[id].kind), + } +} + +/// What an anonymous type, or the right-hand side of a `type` alias, spells. +fn definition(resolve: &Resolve, kind: &TypeDefKind) -> String { + let of = |t: &Option| t.as_ref().map_or("_".into(), |t| ty(resolve, t)); + match kind { + TypeDefKind::Option(t) => format!("option<{}>", ty(resolve, t)), + TypeDefKind::List(t) => format!("list<{}>", ty(resolve, t)), + TypeDefKind::FixedSizeList(t, n) => format!("list<{}, {n}>", ty(resolve, t)), + TypeDefKind::Result(r) => match (&r.ok, &r.err) { + (None, None) => "result".into(), + (ok, None) => format!("result<{}>", of(ok)), + (ok, err) => format!("result<{}, {}>", of(ok), of(err)), + }, + TypeDefKind::Tuple(t) => { + let items: Vec<_> = t.types.iter().map(|t| ty(resolve, t)).collect(); + format!("tuple<{}>", items.join(", ")) + } + TypeDefKind::Future(t) => t + .as_ref() + .map_or("future".into(), |t| format!("future<{}>", ty(resolve, t))), + TypeDefKind::Stream(t) => t + .as_ref() + .map_or("stream".into(), |t| format!("stream<{}>", ty(resolve, t))), + TypeDefKind::Handle(Handle::Own(t)) => ty(resolve, &Type::Id(*t)), + TypeDefKind::Handle(Handle::Borrow(t)) => format!("borrow<{}>", ty(resolve, &Type::Id(*t))), + TypeDefKind::Type(t) => ty(resolve, t), + other => panic!( + "{WIT}: an anonymous {} the reference can't spell", + other.as_str() + ), + } +} + +fn signature(resolve: &Resolve, f: &Function) -> String { + let params: Vec<_> = f + .params + .iter() + .map(|(name, t)| format!("{name}: {}", ty(resolve, t))) + .collect(); + let result = f + .result + .as_ref() + .map_or(String::new(), |t| format!(" -> {}", ty(resolve, t))); + format!("func({}){result}", params.join(", ")) +} + +/// Who may use an interface: the capability that grants it, or what it is. +fn access(interface: &str, exported: bool) -> String { + if exported { + return "exported by the mod: the game calls it".into(); + } + if interface == "log" { + return "always granted".into(); + } + match Capability::ALL.iter().find(|c| c.interface() == interface) { + Some(c) => format!("capability `{c}`"), + None => "not granted by any capability".into(), + } +} + +fn markdown() -> String { + let mut resolve = Resolve::new(); + let package = resolve + .push_file(root().join(WIT)) + .expect("the WIT contract parses"); + let package = &resolve.packages[package]; + let name = &package.name; + let mut out = String::new(); + let w = &mut out; + writeln!(w, "").unwrap(); + writeln!(w, "# Mod API reference\n").unwrap(); + writeln!( + w, + "The contract between Horizon and its mods: the WIT package `{name}`, every interface, type, function and hook in it, \ + and the capabilities a manifest may list. The guide is [mods.md](../mods.md); stability and versions: \ + [stability.md](stability.md). Manifest `api` lines this game serves: {}.\n", + APIS.map(|a| format!("`{a}`")).join(", ") + ) + .unwrap(); + + writeln!(w, "## Capabilities\n").unwrap(); + writeln!( + w, + "| In `capabilities` | Grants | The player reads \"May …\" |\n| --- | --- | --- |" + ) + .unwrap(); + for c in Capability::ALL { + let grants = if package.interfaces.contains_key(c.interface()) { + format!("[`{0}`](#{0})", c.interface()) + } else { + "data files (`assets/`, `data/`), no interface".into() + }; + writeln!(w, "| `{c}` | {grants} | {} |", c.describe()).unwrap(); + } + + let mut exported = Vec::new(); + for (world_name, &world) in &package.worlds { + let world = &resolve.worlds[world]; + let prefix = format!("{}:{}/", name.namespace, name.name); + let names = |keys: Vec<&wit_parser::WorldKey>| { + keys.into_iter() + .map(|key| { + let full = resolve.name_world_key(key); + let short = full.trim_start_matches(&prefix); + format!("`{}`", short.split('@').next().unwrap_or(short)) + }) + .collect::>() + .join(", ") + }; + writeln!(w, "\n## World `{world_name}`\n").unwrap(); + if world.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&world.docs)).unwrap(); + } + writeln!( + w, + "- Imports (what the game offers): {}", + names(world.imports.keys().collect()) + ) + .unwrap(); + writeln!( + w, + "- Exports (what the mod provides): {}", + names(world.exports.keys().collect()) + ) + .unwrap(); + for item in world.exports.values() { + if let WorldItem::Interface { id, .. } = item { + exported.push(*id); + } + } + } + + for (interface_name, &id) in &package.interfaces { + let interface = &resolve.interfaces[id]; + writeln!(w, "\n## `{interface_name}`\n").unwrap(); + writeln!( + w, + "Access: {}.\n", + access(interface_name, exported.contains(&id)) + ) + .unwrap(); + if interface.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&interface.docs)).unwrap(); + } + for (type_name, &type_id) in &interface.types { + let def = &resolve.types[type_id]; + writeln!(w, "### {} `{type_name}`\n", def.kind.as_str()).unwrap(); + if def.docs.contents.is_some() { + writeln!(w, "{}\n", cell(&def.docs)).unwrap(); + } + match &def.kind { + TypeDefKind::Record(r) => { + writeln!(w, "| Field | Type | |\n| --- | --- | --- |").unwrap(); + for f in &r.fields { + writeln!( + w, + "| `{}` | `{}` | {} |", + f.name, + ty(&resolve, &f.ty), + cell(&f.docs) + ) + .unwrap(); + } + } + TypeDefKind::Enum(e) => { + writeln!(w, "| Case | |\n| --- | --- |").unwrap(); + for c in &e.cases { + writeln!(w, "| `{}` | {} |", c.name, cell(&c.docs)).unwrap(); + } + } + TypeDefKind::Variant(v) => { + writeln!(w, "| Case | Payload | |\n| --- | --- | --- |").unwrap(); + for c in &v.cases { + let payload = + c.ty.as_ref() + .map_or(String::new(), |t| format!("`{}`", ty(&resolve, t))); + writeln!(w, "| `{}` | {payload} | {} |", c.name, cell(&c.docs)).unwrap(); + } + } + TypeDefKind::Flags(f) => { + writeln!(w, "| Flag | |\n| --- | --- |").unwrap(); + for flag in &f.flags { + writeln!(w, "| `{}` | {} |", flag.name, cell(&flag.docs)).unwrap(); + } + } + TypeDefKind::Resource => { + writeln!(w, "A resource: the game owns it, the mod holds a handle.").unwrap() + } + kind => writeln!(w, "`type {type_name} = {}`", definition(&resolve, kind)).unwrap(), + } + writeln!(w).unwrap(); + } + if !interface.functions.is_empty() { + writeln!( + w, + "| Function | Signature | What it does |\n| --- | --- | --- |" + ) + .unwrap(); + for (fn_name, f) in &interface.functions { + writeln!( + w, + "| `{fn_name}` | `{}` | {} |", + signature(&resolve, f), + cell(&f.docs) + ) + .unwrap(); + } + } + } + out +} + +#[test] +fn the_mod_api_reference_is_up_to_date() { + let path = root().join(DOC); + let want = markdown(); + if std::env::var_os("HORIZON_WRITE_DOCS").is_some() { + std::fs::write(&path, &want).unwrap(); + } + let have = std::fs::read_to_string(&path) + .unwrap_or_default() + .replace("\r\n", "\n"); + assert!( + have == want, + "{DOC} is out of date: HORIZON_WRITE_DOCS=1 cargo test -p horizon-mods --features pack --test api_reference" + ); +} + +#[test] +fn every_function_is_documented() { + let mut resolve = Resolve::new(); + resolve.push_file(root().join(WIT)).unwrap(); + for (_, interface) in resolve.interfaces.iter() { + for (name, f) in &interface.functions { + assert!( + f.docs.contents.is_some(), + "{WIT}: `{name}` needs a doc comment: the reference shows it to mod authors" + ); + } + } +} + +#[test] +fn every_capability_with_an_interface_is_in_the_contract() { + let mut resolve = Resolve::new(); + let package = resolve.push_file(root().join(WIT)).unwrap(); + let interfaces = &resolve.packages[package].interfaces; + for c in Capability::ALL { + if c != Capability::Registries { + assert!( + interfaces.contains_key(c.interface()), + "capability {c} grants `{}`, missing from {WIT}", + c.interface() + ); + } + } +} diff --git a/crates/horizon-prepare/src/java.rs b/crates/horizon-prepare/src/java.rs index a159fb055..b4023b7d1 100644 --- a/crates/horizon-prepare/src/java.rs +++ b/crates/horizon-prepare/src/java.rs @@ -1,6 +1,7 @@ //! The JDK that compiles and runs the vanilla exporters. They call Mojang's own code, so they //! stay Java; everything around them is here. +use std::ffi::OsStr; use std::fs; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; @@ -13,6 +14,20 @@ pub struct Jdk { const TIMEOUT: Duration = Duration::from_secs(3600); +/// Exporters and JDK probes write to pipes or log files: on Windows they open no terminal. +fn command(program: impl AsRef) -> Command { + let command = Command::new(program); + #[cfg(windows)] + let command = { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + let mut command = command; + command.creation_flags(CREATE_NO_WINDOW); + command + }; + command +} + fn executable(dir: &Path, name: &str) -> PathBuf { dir.join(if cfg!(windows) { format!("{name}.exe") @@ -29,7 +44,7 @@ fn on_path(name: &str) -> Option { /// The major version `javac -version` reports ("javac 25.0.1" → 25; "javac 1.8.0" → 8). fn javac_major(javac: &Path) -> Result { - let output = Command::new(javac) + let output = command(javac) .arg("-version") .stdin(Stdio::null()) .output() @@ -183,7 +198,7 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result { candidates.push((javac, java, "PATH")); } if cfg!(target_os = "macos") { - if let Ok(out) = Command::new("/usr/libexec/java_home") + if let Ok(out) = command("/usr/libexec/java_home") .args(["-v", &major.to_string()]) .stderr(Stdio::null()) .output() @@ -260,7 +275,7 @@ impl Jdk { /// `javac --release -proc:none` with Python's `subprocess.run(..., check=True, /// stdout=log, stderr=STDOUT, timeout=3600)`. pub fn javac(&self, major: i64, args: &[String], log: &fs::File) -> Result<(), String> { - let mut command = Command::new(&self.javac); + let mut command = command(&self.javac); command .args(["--release", &major.to_string(), "-proc:none"]) .args(args); @@ -268,7 +283,7 @@ impl Jdk { } pub fn java(&self, args: &[String], cwd: Option<&Path>, log: &fs::File) -> Result<(), String> { - let mut command = Command::new(&self.java); + let mut command = command(&self.java); command.args(args); if let Some(dir) = cwd { command.current_dir(dir); diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 24f163a9b..30b2f1cff 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -676,13 +676,15 @@ fn steps( } // The playable client needs every client asset (textures, models, fonts, GUI) - // and every data-pack resource (worldgen, recipes, loot tables, tags). + // and every data-pack resource (worldgen, recipes, loot tables, tags), and + // the vanilla pack's icon (`pack.png`) for the pack screen. (run.log)("Copying the client's assets and data"); let mut count = 0usize; let mut client = open_zip(&run.client)?; let version = pyjson::loads(&zip_text(&mut client, "version.json")?)?; for name in zip_names(&client) { - if !(name.starts_with("assets/") || name.starts_with("data/")) || name.ends_with('/') { + let wanted = name.starts_with("assets/") || name.starts_with("data/") || name == "pack.png"; + if !wanted || name.ends_with('/') { continue; } let relative = member_path(&name, "Invalid resource path")?; diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 206ed9aff..42e3ba686 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -13,8 +13,8 @@ use crate::{ packets::{ Empty, configuration::{ - ClientInformation, CustomPayload, Disconnect, KeepAlive, Ping, ResourcePackPush, - ResourcePackResponse, UpdateTags, + ClientInformation, CustomPayload, Disconnect, KeepAlive, Ping, ResourcePackPop, + ResourcePackPush, ResourcePackResponse, UpdateTags, }, login::Property, }, @@ -1640,6 +1640,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { RemoveEntities(RemoveEntities) = REMOVE_ENTITIES, RemoveMobEffect(RemoveMobEffect) = REMOVE_MOB_EFFECT, ResetScore(ResetScore) = RESET_SCORE, + ResourcePackPop(ResourcePackPop) = RESOURCE_PACK_POP, ResourcePackPush(ResourcePackPush) = RESOURCE_PACK_PUSH, Respawn(Respawn) = RESPAWN, RotateHead(RotateHead) = ROTATE_HEAD, diff --git a/crates/horizon-server/src/engine.rs b/crates/horizon-server/src/engine.rs index 051ae77f0..fd7c86321 100644 --- a/crates/horizon-server/src/engine.rs +++ b/crates/horizon-server/src/engine.rs @@ -68,7 +68,8 @@ pub fn program_in( /// system can't load the program, as on a Linux without the ALSA and udev libraries the full game links /// (the server build doesn't). The reason, with what to install. pub fn check_starts(program: &Path) -> Result<(), String> { - let output = Command::new(program) + let mut command = crate::process::command(program); + let output = command .arg("--help") .stdin(Stdio::null()) .stdout(Stdio::null()) @@ -176,7 +177,8 @@ pub fn spawn(program: &Path, resources: &Path, dir: &Path) -> std::io::Result) -> Command { + let command = Command::new(program); + #[cfg(windows)] + let command = { + use std::os::windows::process::CommandExt; + use windows_sys::Win32::System::{Console::GetConsoleWindow, Threading::CREATE_NO_WINDOW}; + let mut command = command; + // SAFETY: no arguments; it returns this process's console window or null. + if unsafe { GetConsoleWindow() }.is_null() { + command.creation_flags(CREATE_NO_WINDOW); + } + command + }; + command +} diff --git a/crates/horizon-server/src/service.rs b/crates/horizon-server/src/service.rs index 6e6d59f23..96b9f218f 100644 --- a/crates/horizon-server/src/service.rs +++ b/crates/horizon-server/src/service.rs @@ -178,7 +178,7 @@ fn systemd_path(service: &str, system: bool) -> Result { } fn run(program: &str, args: &[&str]) -> Result<(), String> { - let status = Command::new(program) + let status = crate::process::command(program) .args(args) .status() .map_err(|e| format!("{program}: {e}"))?; @@ -191,7 +191,7 @@ fn run(program: &str, args: &[&str]) -> Result<(), String> { /// A step that may fail harmlessly (stopping what isn't running): its output would only alarm. fn quiet(program: &str, args: &[&str]) { - let _ = Command::new(program) + let _ = crate::process::command(program) .args(args) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) diff --git a/crates/horizon-server/src/update.rs b/crates/horizon-server/src/update.rs index cbcfe637e..8c87c66bc 100644 --- a/crates/horizon-server/src/update.rs +++ b/crates/horizon-server/src/update.rs @@ -10,7 +10,6 @@ use serde_json::{Value, json}; use std::{ io::Read, path::{Path, PathBuf}, - process::Command, time::{Duration, Instant}, }; @@ -206,7 +205,7 @@ fn point(link: &Path, target: &Path) -> std::io::Result<()> { if link.exists() || link.symlink_metadata().is_ok() { std::fs::remove_dir(link)?; } - let status = Command::new("cmd") + let status = crate::process::command("cmd") .arg("/C") .arg("mklink") .arg("/J") @@ -474,7 +473,7 @@ pub fn unpack(install: &Install, archive: &Path, tag: &str) -> Result Option { - let out = std::process::Command::new(program) - .args(args) - .output() - .ok()?; +/// What `program args` prints, trimmed, when it succeeds and prints something. On Windows the +/// program opens no console window: a GUI launcher or a game started without one would flash a +/// terminal for every probe. +pub fn command_output(program: &str, args: &[&str]) -> Option { + let mut command = std::process::Command::new(program); + command.args(args); + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + command.creation_flags(CREATE_NO_WINDOW); + } + let out = command.output().ok()?; let text = String::from_utf8_lossy(&out.stdout).trim().to_owned(); (out.status.success() && !text.is_empty()).then_some(text) } diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md new file mode 100644 index 000000000..ca2fe9d7a --- /dev/null +++ b/docs/api/mods-reference.md @@ -0,0 +1,141 @@ + +# Mod API reference + +The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`, every interface, type, function and hook in it, and the capabilities a manifest may list. The guide is [mods.md](../mods.md); stability and versions: [stability.md](stability.md). Manifest `api` lines this game serves: `0.1`, `0.2`. + +## Capabilities + +| In `capabilities` | Grants | The player reads "May …" | +| --- | --- | --- | +| `game-read` | [`game`](#game) | see your position, health and the time | +| `chat` | [`chat`](#chat) | show you chat messages | +| `hud` | [`hud`](#hud) | draw text on your screen | +| `storage` | [`storage`](#storage) | save its own settings to disk | +| `registries` | data files (`assets/`, `data/`), no interface | add blocks and items to your worlds | + +## World `horizon-mod` + +- Imports (what the game offers): `log`, `game`, `chat`, `hud`, `storage` +- Exports (what the mod provides): `events` + +## `log` + +Access: always granted. + +The mod's log, in the game's log under the mod's id. Always granted. + +### enum `level` + +| Case | | +| --- | --- | +| `debug` | | +| `info` | | +| `warn` | | +| `error` | | + +| Function | Signature | What it does | +| --- | --- | --- | +| `write` | `func(level: level, message: string)` | One line in the game's log as `[mod ] message`, at that level. | + +## `game` + +Access: capability `game-read`. + +Capability `game-read`: the local player and the world clock. + +### record `player` + +| Field | Type | | +| --- | --- | --- | +| `x` | `f64` | Feet position, in blocks. | +| `y` | `f64` | | +| `z` | `f64` | | +| `yaw` | `f32` | Degrees, as F3 shows them. | +| `pitch` | `f32` | Degrees: -90 looks straight up, 90 straight down. | +| `health` | `f32` | Hit points as vanilla counts them: 20 is full health without effects. | +| `food` | `u32` | 0 to 20, as the hunger bar. | +| `dimension` | `string` | `minecraft:overworld`, `minecraft:the_nether`, ... | + +### record `clock` + +| Field | Type | | +| --- | --- | --- | +| `game-time` | `u64` | Ticks since the world was created. | +| `day-time` | `u64` | 24000 ticks per day; 0 is 6:00 on the first day. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `get-player` | `func() -> option` | None on the title screen. | +| `get-clock` | `func() -> option` | None on the title screen. | + +## `chat` + +Access: capability `chat`. + +Capability `chat`: messages only the local player sees. + +| Function | Signature | What it does | +| --- | --- | --- | +| `show` | `func(text: string)` | Shown in chat after the mod's name, like a system message. | + +## `hud` + +Access: capability `hud`. + +Capability `hud`: one panel of text lines per mod, drawn by the game every frame until the mod changes or clears it (no call per frame). + +### enum `corner` + +| Case | | +| --- | --- | +| `top-left` | | +| `top-right` | | +| `bottom-left` | | +| `bottom-right` | | + +### record `line` + +| Field | Type | | +| --- | --- | --- | +| `text` | `string` | Plain text, up to 256 characters. | +| `color` | `u32` | 0xRRGGBB. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `set-panel` | `func(corner: corner, lines: list)` | Replaces the mod's panel: up to 16 lines in that corner of the screen. | +| `clear` | `func()` | Removes the mod's panel. | + +## `storage` + +Access: capability `storage`. + +Capability `storage`: a per-mod folder of small key/value files, quota'd (docs/mods.md). Keys are `[a-z0-9_.-]{1,64}`, one path segment. + +| Function | Signature | What it does | +| --- | --- | --- | +| `get` | `func(key: string) -> option>` | None if `key` has never been `set`, or the key is not well-formed. | +| `set` | `func(key: string, value: list) -> result<_, string>` | Errs on a malformed key or over quota (bytes for the whole mod). | +| `delete` | `func(key: string)` | No error if `key` was already absent. | + +## `events` + +Access: exported by the mod: the game calls it. + +What the game calls. Only the hooks `init` asks for are ever called. + +### record `registration` + +| Field | Type | | +| --- | --- | --- | +| `commands` | `list` | Chat commands, without the slash. A name vanilla already uses is refused (vanilla's command runs). | +| `tick` | `bool` | Call `tick` every game tick (20 per second while playing). | +| `frame` | `bool` | Call `frame` every rendered frame. Budget: 0.1 ms. | +| `chat` | `bool` | Call `chat` for each chat line the player receives. | + +| Function | Signature | What it does | +| --- | --- | --- | +| `init` | `func() -> result` | Once, after loading. An error keeps the mod off and is shown. | +| `tick` | `func(tick: u64)` | Each game tick while in a world, with the game's tick counter. | +| `frame` | `func(seconds: f32)` | Each rendered frame, with the seconds since the last one. | +| `command` | `func(name: string, args: string) -> result, string>` | `/name args`: ok(some(text)) is shown as feedback, err(text) in red. | +| `chat` | `func(text: string)` | Each chat line the player receives, as plain text. | diff --git a/docs/resource-packs.md b/docs/resource-packs.md index d53b2a13d..783c381dd 100644 --- a/docs/resource-packs.md +++ b/docs/resource-packs.md @@ -33,6 +33,7 @@ harness named checks that loader against vanilla). | Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) | | Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) | | Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` | +| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works, no download toasts | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server | | Other namespaces | `assets//` | works | `test_resource_pack_parity` | | Block states: variants, multipart, weights, rotations, uvlock | `blockstates/` | works | `test_blockstate_model_parity`, `test_model_choice_parity`, `test_blockstate_transform_parity` | | Block models: parents, elements, rotations, faces, cullface, tint, shade, light emission, ambient occlusion | `models/block/` | works | `test_model_resolution_parity`, `test_model_baking_parity`, `test_section_mesh_parity` | @@ -74,7 +75,7 @@ harness named checks that loader against vanilla). | Core shaders | `shaders/core/`, `shaders/include/` | **no** | Horizon draws with WGSL; a pack's GLSL core shaders aren't run | | GPU warn list, regional compliance | `gpu_warnlist.json`, `regional_compliancies.json` | n/a | OpenGL driver warnings and play-time notices for some regions; not used | -Summary: 44 rows; 31 work, 3 partly, 8 don't (interpolated animation, TrueType fonts, credits and end poem, +Summary: 45 rows; 32 work, 3 partly, 8 don't (interpolated animation, TrueType fonts, credits and end poem, villager hats, trims on worn armour, locator bar styles, post effects, core shaders), 2 don't apply. Except the shaders, the missing pieces are missing vanilla features too, and each vanilla parity fix covers the pack case as well. @@ -83,6 +84,7 @@ shaders, the missing pieces are missing vanilla features too, and each vanilla p | Gap | Size | Where | | --- | --- | --- | | Animation `interpolate` | small | fix PR (`gfx.rs` `animate_sprites`) | +| Server pack download toasts (`download.pack.*`) | small | `game/server_packs.rs` | | GUI scaling `width`/`height`, `stretch_inner`, `tile`, `stretch` | small | next fix PR (`ui.rs`) | | Villager hats | small | [#334](https://github.com/ludovic111/horizon/issues/334) | | `blur`/`clamp` from packs | small | [#335](https://github.com/ludovic111/horizon/issues/335) | diff --git a/launcher/README.md b/launcher/README.md index cf968f93c..1c0ea5522 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -97,6 +97,10 @@ page `servers.json` (the list), `servers//` (the servers created there) an Long pages, dialogs, the server console and data previews have a visible scrollbar when their content overflows. Drag the thumb or click the track to navigate without a mouse wheel. +Pages and Home's landscape fill the window as it resizes. Windows uses a matching title +bar with native dragging, resizing, Snap, +minimize, maximize/restore and close; macOS and Linux keep their system title bars. + ## Updates The launcher looks for a newer Horizon release when it starts and every 30 minutes while it @@ -127,7 +131,12 @@ and `horizon-launcher-windows-x64.zip`, never marked latest. The version is buil ## Command line -The same binary is a command-line tool; without a subcommand it opens the window. +The same binary is a command-line tool; without a subcommand it opens the window. On Windows it +is a windowed program, so a desktop start opens no terminal; a subcommand writes to the terminal +it was typed in, or to the pipes and files it was given (MCP keeps its stdio). Interactive `cmd` +and PowerShell don't wait for a windowed program: they show the prompt again before its output +and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code use +`start /wait horizon-launcher …` or `Start-Process -Wait`, or read its output through a pipe. horizon-launcher versions [--installed] releases on GitHub, or what is installed (* = selected) horizon-launcher install @@ -250,14 +259,20 @@ Each session writes its own measurements to `benchmarks/launcher-