From cdfcc3d4d446e59c075e6fd0018a8cc599519cdc Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 17:15:35 +0200 Subject: [PATCH 01/12] Server resource packs: the client's pack manager and downloads Vanilla's ServerPackManager, DownloadedPackSource and DownloadQueue, without the game around them yet: the prompt state, each pack's download and activation, the statuses in vanilla's order (onSuccess repeats SUCCESSFULLY_LOADED, a failed reload recovers with the packs that loaded), pop, and leaving. Downloads follow HttpUtil.downloadFile: downloads//, a cached file whose hash matches is reused, a wrong hash fails, no hash downloads to a temporary file renamed to its SHA-1, 250 MiB at most, vanilla's X-Minecraft-* headers, a log.json entry per download, and 20 files kept. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 1 + crates/horizon-client/Cargo.toml | 2 + crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/server_packs.rs | 618 ++++++++++++++++++ .../src/server_packs/download.rs | 482 ++++++++++++++ 5 files changed, 1104 insertions(+) create mode 100644 crates/horizon-client/src/server_packs.rs create mode 100644 crates/horizon-client/src/server_packs/download.rs diff --git a/Cargo.lock b/Cargo.lock index 1a1b288c9..d04c0a647 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1441,6 +1441,7 @@ dependencies = [ "rustix 1.1.5", "serde", "serde_json", + "sha1", "sha2", "symphonia", "toml", diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index 300872765..b11989ba8 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"] } # Shader packs: pack.toml, and WGSL checked before it reaches wgpu. diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index dddf87c0d..7ec79af5e 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -158,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 shader_pack; pub mod shadows; 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(); + } +} From 186ab70305dd8190745b6513524d241adfb62654 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 17:20:35 +0200 Subject: [PATCH 02/12] Server resource packs: prompt, Server Resource Packs setting, apply and remove Servers that push a resource pack now work (reported by scanfee on Discord: "Servers requiring custom resource packs do not work yet"; net.rs declined every push). - net.rs forwards resource_pack_push and _pop in configuration and play, and answers in the phase the connection is in. - The prompt is vanilla's PackConfirmScreen on a shared ConfirmScreen (confirm_screen.rs, now also used by the game rules screen): the required or optional wording, the server's message, Proceed/Disconnect or Yes/No, Escape for no. Declining a required pack disconnects with vanilla's reason. - The server list's Edit screen has the Server Resource Packs cycle button (Enabled, Disabled, Prompt), saved as acceptTextures; the prompt's answer is saved there too. - Downloaded packs go on top of the player's packs, in push order, through the same reload as the Resource Packs screen; they are removed on pop and when leaving the server. tools/server_pack_e2e.py drives the real client against vanilla's dedicated server or Horizon's, with a test pack (blue dirt, lang strings) from a local HTTP server, and checks the statuses the client sends through net_capture: decline, proceed, the cache, a wrong SHA-1, an optional pack declined and accepted, a dead URL. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/confirm_screen.rs | 75 +++ crates/horizon-client/src/game.rs | 31 +- .../src/game/game_rules_screen.rs | 68 +-- crates/horizon-client/src/game/packs.rs | 31 +- crates/horizon-client/src/game/remote.rs | 13 + .../horizon-client/src/game/server_packs.rs | 316 +++++++++++ .../horizon-client/src/game/startup_menu.rs | 7 +- crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/multiplayer.rs | 96 +++- crates/horizon-client/src/net.rs | 73 ++- crates/horizon-client/src/packs.rs | 11 + crates/horizon-protocol/src/packets/play.rs | 5 +- docs/resource-packs.md | 4 +- tools/server_pack_e2e.py | 516 ++++++++++++++++++ 14 files changed, 1158 insertions(+), 89 deletions(-) create mode 100644 crates/horizon-client/src/confirm_screen.rs create mode 100644 crates/horizon-client/src/game/server_packs.rs create mode 100644 tools/server_pack_e2e.py 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 7ac3d0829..0438cafd2 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 shader_packs; mod shield; @@ -1127,6 +1128,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, @@ -4774,7 +4777,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); @@ -11032,6 +11042,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 { @@ -11231,6 +11248,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() => { @@ -11609,6 +11634,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; @@ -11703,6 +11729,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(), @@ -13293,7 +13320,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/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..4704423ba 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -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 { @@ -113,14 +119,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 +130,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 ebf062a83..9958785da 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/lib.rs b/crates/horizon-client/src/lib.rs index 7ec79af5e..23415d6f0 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; 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/packs.rs b/crates/horizon-client/src/packs.rs index 5daaaacad..7ab436f72 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -629,6 +629,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() 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/docs/resource-packs.md b/docs/resource-packs.md index 227c9c5a4..06e3e7247 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; packs that replace core shaders need the GLSL translation of [shader-packs.md](shader-packs.md) | | 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/tools/server_pack_e2e.py b/tools/server_pack_e2e.py new file mode 100644 index 000000000..83e434435 --- /dev/null +++ b/tools/server_pack_e2e.py @@ -0,0 +1,516 @@ +#!/usr/bin/env python3 +"""Server resource packs end to end: a real Horizon client joins a real dedicated server (vanilla 26.3's, or +Horizon's with --horizon-server BIN) that offers a test pack from a local HTTP server, through tools/net_capture.py, +which records the statuses the client sends back. + +The pack is built here: dirt recoloured blue, and three lang strings (dirt's name, the pause menu's "Back to Game", +the server list's "Join Server"). Each scenario sets the server list entry's Server Resource Packs setting in +servers.dat, joins, answers the prompt the way a player would (horizon-ctl clicks its buttons), and checks the +statuses against what vanilla's client sends (ServerPackManager): + +- required, Prompt, Disconnect: no status, the disconnected screen says "This server requires a custom resource + pack", the setting stays Prompt; +- required, Prompt, Proceed: ACCEPTED, DOWNLOADED, SUCCESSFULLY_LOADED; the setting becomes Enabled, the file is in + downloads/ under its SHA-1 with a log.json entry, the HTTP request carries vanilla's X-Minecraft-* headers, the + blue dirt is on screen (screenshot) and the pause menu says the pack's "Back to Game"; after leaving, the server + list says "Join Server" again (the pack is gone); +- required, Enabled: no prompt, the same three statuses, and no second download (the cache); +- required with a wrong SHA-1: ACCEPTED, FAILED_DOWNLOAD, and the player still joins; +- optional, Prompt, No: DECLINED, joins, the setting becomes Disabled; then joining again sends DECLINED without + asking; then Prompt and Yes: the pack (no hash given) is downloaded and loaded; +- optional on a dead URL: ACCEPTED, FAILED_DOWNLOAD, joins. + + python3 tools/server_pack_e2e.py # vanilla's server + python3 tools/server_pack_e2e.py --horizon-server target/release/horizon-client + +Every game and server here runs in fresh temporary folders (HORIZON_HOME, HORIZON_LAUNCHER_HOME, XDG_*), with no +audio and no self-update. Needs .local (the vanilla jars and prepared resources) and a built horizon-client and +horizon-ctl (--bin DIR, default target/fast). +""" +import argparse +import hashlib +import http.server +import json +import os +from pathlib import Path +import shutil +import socket +import struct +import subprocess +import sys +import tempfile +import threading +import time +import zipfile +import zlib + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import lab # noqa: E402 +import net_capture # noqa: E402 +import test_rust_parity as base # noqa: E402 +from test_dedicated_server_parity import Server, free_port # noqa: E402 + +# ServerboundResourcePackPacket.Action, by ordinal. +ACTIONS = ['successfully_loaded', 'declined', 'failed_download', 'accepted', 'downloaded', 'invalid_url', + 'failed_reload', 'discarded'] +LOADED = ['accepted', 'downloaded', 'successfully_loaded'] +FAILED = ['accepted', 'failed_download'] +REQUIRED_REASON = 'This server requires a custom resource pack' +PLAYER = 'Steve' +PROPERTIES = { + 'online-mode': 'false', 'white-list': 'false', 'level-seed': '12345', 'level-type': 'minecraft\\:flat', + 'generate-structures': 'false', 'view-distance': '3', 'simulation-distance': '3', 'spawn-protection': '0', + 'pause-when-empty-seconds': '-1', 'gamemode': 'creative', +} + + +class Failed(Exception): + pass + + +def check(condition, what): + if not condition: + raise Failed(what) + print(f' ok: {what}') + + +# The pack. + +def png(width, height, pixel): + rows = b''.join(b'\0' + b''.join(bytes(pixel(x, y)) for x in range(width)) for y in range(height)) + + def chunk(kind, data): + return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data)) + header = struct.pack('>IIBBBBB', width, height, 8, 6, 0, 0, 0) + return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', header) + chunk(b'IDAT', zlib.compress(rows)) + chunk(b'IEND', b'') + + +def build_pack(path): + """The test pack, byte for byte the same every time (fixed dates), and its SHA-1.""" + def blue(x, y): + return (40, 90, 230, 255) if (x // 4 + y // 4) % 2 else (20, 50, 170, 255) + files = { + 'pack.mcmeta': json.dumps({'pack': {'description': 'Horizon server pack test', + 'min_format': 97, 'max_format': 97}}).encode(), + 'assets/minecraft/textures/block/dirt.png': png(16, 16, blue), + 'assets/minecraft/lang/en_us.json': json.dumps({ + 'block.minecraft.dirt': 'Blue Test Dirt', + 'menu.returnToGame': 'Back to Game (server pack)', + 'selectServer.select': 'Join Server (server pack)', + }).encode(), + } + with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as z: + for name, data in files.items(): + z.writestr(zipfile.ZipInfo(name, (2026, 1, 1, 0, 0, 0)), data) + return hashlib.sha1(path.read_bytes()).hexdigest() + + +def decode_png(data): + """RGB(A) pixels of an 8-bit PNG: (width, height, rows of (r, g, b)).""" + pos, idat, width = 8, b'', 0 + while pos < len(data): + length, kind = struct.unpack('>I4s', data[pos:pos + 8]) + body = data[pos + 8:pos + 8 + length] + if kind == b'IHDR': + width, height, depth, colour = struct.unpack('>IIBB', body[:10]) + assert depth == 8 and colour in (2, 6), (depth, colour) + channels = 4 if colour == 6 else 3 + elif kind == b'IDAT': + idat += body + pos += 12 + length + raw, stride, rows, previous = zlib.decompress(idat), width * channels, [], bytearray(width * channels) + for y in range(height): + kind, line = raw[y * (stride + 1)], bytearray(raw[y * (stride + 1) + 1:(y + 1) * (stride + 1)]) + for i in range(stride): + left = line[i - channels] if i >= channels else 0 + up, corner = previous[i], previous[i - channels] if i >= channels else 0 + if kind == 1: + line[i] = (line[i] + left) & 255 + elif kind == 2: + line[i] = (line[i] + up) & 255 + elif kind == 3: + line[i] = (line[i] + (left + up) // 2) & 255 + elif kind == 4: + p = left + up - corner + pa, pb, pc = abs(p - left), abs(p - up), abs(p - corner) + line[i] = (line[i] + (left if pa <= pb and pa <= pc else up if pb <= pc else corner)) & 255 + rows.append([tuple(line[x * channels:x * channels + 3]) for x in range(width)]) + previous = line + return width, height, rows + + +def blue_share(path): + """How much of the picture's lower middle (the ground under a player looking down) is blue.""" + width, height, rows = decode_png(path.read_bytes()) + samples = [rows[y][x] for y in range(height // 2 + height // 8, height - height // 8, 4) + for x in range(width // 4, 3 * width // 4, 4)] + return sum(b > r + 60 and b > g + 30 for r, g, b in samples) / len(samples) + + +# The HTTP server the pack comes from. + +class Files(http.server.ThreadingHTTPServer): + def __init__(self, files): + self.files, self.requests = files, [] + + class Handler(http.server.BaseHTTPRequestHandler): + def do_GET(handler): + headers = {k: v for k, v in handler.headers.items() if k.lower().startswith(('x-minecraft', 'user-agent'))} + self.requests.append((handler.path, headers)) + data = self.files.get(handler.path) + if data is None: + handler.send_error(404) + return + handler.send_response(200) + handler.send_header('Content-Type', 'application/zip') + handler.send_header('Content-Length', str(len(data))) + handler.end_headers() + handler.wfile.write(data) + + def log_message(handler, *args): + pass + super().__init__(('127.0.0.1', 0), Handler) + threading.Thread(target=self.serve_forever, daemon=True).start() + + def url(self, path): + return f'http://127.0.0.1:{self.server_address[1]}{path}' + + +# servers.dat (NbtIo.write: uncompressed, a named root compound). + +def nbt_string(s): + data = s.encode() + return struct.pack('>H', len(data)) + data + + +def write_servers(path, ip, setting): + """One entry for ip; setting True (Enabled), False (Disabled) or None (Prompt: no acceptTextures).""" + entry = b'\x08' + nbt_string('name') + nbt_string('Pack test') + b'\x08' + nbt_string('ip') + nbt_string(ip) + if setting is not None: + entry += b'\x01' + nbt_string('acceptTextures') + bytes([int(setting)]) + root = b'\x09' + nbt_string('servers') + b'\x0a' + struct.pack('>i', 1) + entry + b'\x00' + path.write_bytes(b'\x0a' + nbt_string('') + root + b'\x00') + + +def read_setting(path): + data = path.read_bytes() + key = b'\x01' + nbt_string('acceptTextures') + at = data.find(key) + return None if at < 0 else bool(data[at + len(key)]) + + +# The game. + +class Game: + def __init__(self, bins, resources, work): + self.home = work / 'home' + for d in ('home', 'launcher', 'data', 'config'): + (work / d).mkdir(parents=True) + self.env = dict(os.environ, HORIZON_HOME=str(self.home), HORIZON_LAUNCHER_HOME=str(work / 'launcher'), + XDG_DATA_HOME=str(work / 'data'), XDG_CONFIG_HOME=str(work / 'config'), + HORIZON_LAUNCHER_NO_SELF_UPDATE='1', HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') + self.base = [str(bins / 'horizon-ctl'), '--socket', str(work / 'c.sock')] + self.log = work / 'c.log' + reply = self('launch', '--game', bins / 'horizon-client', '--offscreen', '--resources', resources) + self.pid = reply.get('pid') + + def __call__(self, *words, ok=True, timeout=300): + result = subprocess.run(self.base + [str(w) for w in words], cwd=self.home, env=self.env, + capture_output=True, text=True, timeout=timeout) + lines = result.stdout.strip().splitlines() + reply = json.loads(lines[-1]) if lines else {'error': result.stderr.strip()} + print(f' {" ".join(map(str, words))[:80]} -> {json.dumps(reply)[:200]}') + if ok and (result.returncode or 'error' in reply): + raise Failed(f'{" ".join(map(str, words))}: {reply}') + return reply + + def labels(self): + return [w.get('label') for w in self('ui').get('widgets', [])] + + def wait_widget(self, widget, timeout=60): + return self('wait-for', 'widget', widget, '--timeout', timeout, ok=False) + + def quit(self): + try: + self('quit', ok=False, timeout=60) + except subprocess.TimeoutExpired: + pass + if self.pid: + for _ in range(40): + try: + os.kill(self.pid, 0) + except OSError: + return + time.sleep(0.5) + os.kill(self.pid, 9) + + +def statuses(capture, conn): + """The resource pack statuses the client sent on one connection: (id, action), in order.""" + out = [] + for e in net_capture.load(capture): + if e.get('conn') == conn and e.get('dir') == 'c2s' and e.get('name') == 'resource_pack': + data = bytes.fromhex(e['data']) + out.append((data[:16].hex(), ACTIONS[data[16]])) + return out + + +def connections(capture): + return max([e['conn'] for e in net_capture.load(capture) if 'conn' in e], default=0) + + +class Run: + def __init__(self, args, out): + self.args, self.out = args, out + lock, jars, libraries = base.verify_artifacts() + deps = os.pathsep.join(map(str, [jars['server'], *libraries])) + self.vanilla = ['java', '-Xmx2g', '-cp', deps, 'net.minecraft.server.Main', 'nogui'] + self.resources = lab.LOCAL / 'horizon-client' / lab.VERSION + self.files = {} + self.http = Files(self.files) + self.sha1 = build_pack(out / 'test-pack.zip') + self.files['/test-pack.zip'] = (out / 'test-pack.zip').read_bytes() + self.files['/optional-pack.zip'] = self.files['/test-pack.zip'] + dead = free_port() # nothing listens there + self.packs = { + 'required': {'resource-pack': self.http.url('/test-pack.zip'), 'resource-pack-sha1': self.sha1, + 'require-resource-pack': 'true', 'resource-pack-id': '5b2c7a4e-1f3d-4c8b-9a6e-2d4f8b1c3e5a', + 'resource-pack-prompt': '["Blue dirt for ",{"text":"this test","color":"aqua"}]'}, + 'bad-sha1': {'resource-pack': self.http.url('/test-pack.zip'), 'resource-pack-sha1': '0' * 40, + 'require-resource-pack': 'true'}, + 'optional': {'resource-pack': self.http.url('/optional-pack.zip'), 'require-resource-pack': 'false'}, + 'dead-url': {'resource-pack': f'http://127.0.0.1:{dead}/gone.zip', 'require-resource-pack': 'false'}, + } + self.results = [] + + def start_server(self, kind, work): + directory = work / f'server-{kind}' + directory.mkdir() + port = free_port() + props = dict(PROPERTIES, **self.packs[kind], **{'server-port': str(port)}) + (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), + encoding='iso-8859-1') + (directory / 'eula.txt').write_text('eula=true\n') + if self.args.horizon_server: + command = [self.args.horizon_server, '--resources', self.resources, '--dedicated', '--nogui'] + else: + command = self.vanilla + server = Server(command, directory, f'server-{kind}') + server.wait_for(r'Done \(', timeout=300) + return server, port + + def join(self, game, address, scenario): + """Connects; returns the capture's connection number.""" + game('connect', address, PLAYER) + deadline = time.time() + 30 + while connections(self.capture) <= self.conn and time.time() < deadline: + time.sleep(0.2) + self.conn = connections(self.capture) + print(f' [{scenario}] connection {self.conn}') + return self.conn + + def scenario(self, name, fn): + print(f'- {name}') + try: + fn() + self.results.append((name, 'pass', '')) + except Exception as e: # noqa: BLE001: report every scenario + print(f' FAILED: {e}') + self.results.append((name, 'FAIL', str(e)[:300])) + if self.game('state', ok=False).get('screen') not in (None, 'title'): + self.leave(self.game) + + def wait_statuses(self, conn, want, timeout=60): + deadline = time.time() + timeout + while time.time() < deadline: + got = [a for _, a in statuses(self.capture, conn)] + if len(got) >= len(want) and got[:len(want)] == want or got[:1] and got != want[:len(got)]: + break + time.sleep(0.3) + time.sleep(1.5) # nothing more comes after the last one + got = [a for _, a in statuses(self.capture, conn)] + check(got == want, f'statuses {got} == {want}') + + def leave(self, game): + game('disconnect', ok=False) + time.sleep(1) + + def run(self): + work = Path(tempfile.mkdtemp(prefix='hz-server-packs-')) + print(f'scratch: {work}') + # The servers too get scratch homes (the game sets its own below). + for var, sub in (('HORIZON_HOME', 'home'), ('HORIZON_LAUNCHER_HOME', 'launcher'), ('XDG_DATA_HOME', 'data'), + ('XDG_CONFIG_HOME', 'config')): + (work / 'servers' / sub).mkdir(parents=True) + os.environ[var] = str(work / 'servers' / sub) + os.environ.update(HORIZON_LAUNCHER_NO_SELF_UPDATE='1', HORIZON_NO_AUDIO='1', HORIZON_TELEMETRY_URL='off') + game = self.game = Game(Path(self.args.bin), self.resources, work / 'game') + servers_dat = game.home / 'servers.dat' + downloads = game.home / 'downloads' + try: + for kind, scenarios in self.plan(game, servers_dat, downloads): + server, port = self.start_server(kind, work) + # One capture per server: its connections are numbered from 1. + self.capture, self.conn = self.out / f'capture-{kind}.jsonl', 0 + self.capture.touch() + listen = free_port() + stop = net_capture.start_background(listen, f'127.0.0.1:{port}', self.capture) + self.address = f'127.0.0.1:{listen}' + try: + self.server = server + for name, fn in scenarios: + self.scenario(f'{kind}: {name}', fn) + finally: + stop.set() + server.stop() + shutil.copy(server.log_path, self.out / server.log_path.name) + finally: + game.quit() + if game.log.exists(): + shutil.copy(game.log, self.out / 'client.log') + if downloads.exists(): + shutil.copytree(downloads, self.out / 'downloads') + return work + + def plan(self, game, servers_dat, downloads): + sha1 = self.sha1 + + def required_disconnect(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'decline') + check(game.wait_widget('disconnect').get('ok'), 'the required prompt opened') + labels = game.labels() + check('Proceed' in labels and 'Disconnect' in labels, f'Proceed and Disconnect buttons: {labels}') + game('screenshot', self.out / 'prompt-required.png') + game('click', 'disconnect') + self.wait_statuses(conn, []) + screen = json.dumps(game('screen')) + check(REQUIRED_REASON in screen, 'the disconnected screen says "This server requires a custom resource pack"') + check(read_setting(servers_dat) is None, 'the setting stays Prompt') + check(not any(p == '/test-pack.zip' for p, _ in self.http.requests), 'nothing was downloaded') + + def required_proceed(): + conn = self.join(game, self.address, 'proceed') + check(game.wait_widget('proceed').get('ok'), 'the required prompt opened') + game('click', 'proceed') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(read_setting(servers_dat) is True, 'the setting became Enabled (acceptTextures 1)') + pack_id = self.packs['required']['resource-pack-id'] + check((downloads / pack_id / sha1).exists(), f'downloads/{pack_id}/{sha1} is cached') + log = json.loads((downloads / 'log.json').read_text().splitlines()[-1]) + check(log.get('id') == pack_id and log.get('hash') == sha1 + and log.get('file', {}).get('name') == f'{pack_id}/{sha1}', f'log.json entry {log}') + path, headers = [r for r in self.http.requests if r[0] == '/test-pack.zip'][-1] + want = {'X-Minecraft-Username': PLAYER, 'X-Minecraft-Version': lab.VERSION, + 'X-Minecraft-Version-ID': lab.VERSION, 'X-Minecraft-Pack-Format': '97.1', + 'User-Agent': f'Minecraft Java/{lab.VERSION}'} + check(all(headers.get(k) == v for k, v in want.items()) and len(headers.get('X-Minecraft-UUID', '')) == 32, + f'download headers {headers}') + self.server.console(f'execute at {PLAYER} run fill ~-6 ~-1 ~-6 ~6 ~-1 ~6 minecraft:dirt') + game('look', 0, 90) + game('wait', 40) + shot = self.out / 'applied-blue-dirt.png' + game('screenshot', shot) + share = blue_share(shot) + check(share > 0.5, f'the ground is the pack\'s blue dirt ({share:.0%} of the samples)') + game('key', 'esc', 'tap') + game('wait', 5) + labels = game.labels() + check('Back to Game (server pack)' in labels, f'the pause menu uses the pack\'s lang: {labels}') + game('key', 'esc', 'tap') + self.leave(game) + labels = game.labels() + check('Join Server' in labels and 'Join Server (server pack)' not in labels, + f'after leaving, the pack is gone: {labels}') + + def required_enabled(): + before = len(self.http.requests) + conn = self.join(game, self.address, 'enabled') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(len(self.http.requests) == before, 'no second download: the cached file is used') + game('key', 'esc', 'tap') + game('wait', 5) + check('Back to Game (server pack)' in game.labels(), 'the pack is applied without a prompt') + game('key', 'esc', 'tap') + self.leave(game) + + def bad_sha1(): + write_servers(servers_dat, self.address, True) + conn = self.join(game, self.address, 'bad-sha1') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, FAILED) + entries = [json.loads(line) for line in (downloads / 'log.json').read_text().splitlines()] + failed = [e for e in entries if e.get('hash') == '0' * 40] + check(failed and failed[-1].get('error') == 'download_failed' and 'file' not in failed[-1], + f'log.json records the failure: {failed[-1:]}') + self.leave(game) + + def optional_no(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'optional-no') + check(game.wait_widget('no').get('ok'), 'the optional prompt opened') + labels = game.labels() + check('Yes' in labels and 'No' in labels, f'Yes and No buttons: {labels}') + game('screenshot', self.out / 'prompt-optional.png') + game('click', 'no') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, ['declined']) + check(read_setting(servers_dat) is False, 'the setting became Disabled (acceptTextures 0)') + self.leave(game) + + def optional_disabled(): + conn = self.join(game, self.address, 'optional-disabled') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, ['declined']) + self.leave(game) + + def optional_yes(): + write_servers(servers_dat, self.address, None) + conn = self.join(game, self.address, 'optional-yes') + check(game.wait_widget('yes').get('ok'), 'the optional prompt opened') + game('click', 'yes') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, LOADED) + check(any(r[0] == '/optional-pack.zip' for r in self.http.requests), 'downloaded without a hash') + self.leave(game) + + def dead_url(): + write_servers(servers_dat, self.address, True) + conn = self.join(game, self.address, 'dead-url') + game('wait-for', 'loaded', '--timeout', 180) + self.wait_statuses(conn, FAILED) + self.leave(game) + + return [ + ('required', [('Disconnect at the prompt', required_disconnect), ('Proceed', required_proceed), + ('Enabled, cached', required_enabled)]), + ('bad-sha1', [('wrong SHA-1', bad_sha1)]), + ('optional', [('No at the prompt', optional_no), ('Disabled', optional_disabled), + ('Yes at the prompt, no hash', optional_yes)]), + ('dead-url', [('dead URL', dead_url)]), + ] + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--bin', default=str(lab.cargo_target() / 'fast'), help='horizon-client and horizon-ctl') + parser.add_argument('--horizon-server', help='a horizon-client binary to run as the dedicated server') + parser.add_argument('--out', default=str(lab.LOCAL / 'server-pack-e2e')) + args = parser.parse_args() + out = Path(args.out) / ('horizon' if args.horizon_server else 'vanilla') + shutil.rmtree(out, ignore_errors=True) + out.mkdir(parents=True) + run = Run(args, out) + work = run.run() + print(f'\nserver: {"horizon" if args.horizon_server else "vanilla 26.3"}; evidence in {out}') + for name, result, detail in run.results: + print(f' {result:4} {name}' + (f': {detail}' if detail else '')) + shutil.rmtree(work, ignore_errors=True) + if any(r != 'pass' for _, r, _ in run.results): + sys.exit(1) + + +if __name__ == '__main__': + main() From 4ebba25280031b1d4d9902a4d7a9814aa67c4ee7 Mon Sep 17 00:00:00 2001 From: RobertTGreat Date: Sat, 24 Oct 2026 18:30:36 +0100 Subject: [PATCH 03/12] fix(launcher): fill window width and add Windows title bar Keep page content and pixel art responsive, align navigation left, and use native Windows control hit regions in themed chrome. Co-Authored-By: OpenAI Codex (GPT-6.1 Sol) --- launcher/README.md | 4 + launcher/docs/launcher-window-after.png | Bin 0 -> 97826 bytes launcher/docs/launcher-window-before.png | Bin 0 -> 168449 bytes launcher/src/art.rs | 69 ++++++++-- launcher/src/main.rs | 63 +++++----- launcher/src/scrollbar.rs | 5 +- launcher/src/theme.rs | 1 + launcher/src/titlebar.rs | 153 +++++++++++++++++++++++ 8 files changed, 250 insertions(+), 45 deletions(-) create mode 100644 launcher/docs/launcher-window-after.png create mode 100644 launcher/docs/launcher-window-before.png create mode 100644 launcher/src/titlebar.rs diff --git a/launcher/README.md b/launcher/README.md index cf968f93c..5e38e9fd9 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 diff --git a/launcher/docs/launcher-window-after.png b/launcher/docs/launcher-window-after.png new file mode 100644 index 0000000000000000000000000000000000000000..59633eedb890ff45fcdaf4ce142511d524434f99 GIT binary patch literal 97826 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
7_CFxkE^*7Cjy*7wAfJKx;_|KqcB_>#3&RSc;& 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 literal 0 HcmV?d00001 diff --git a/launcher/src/art.rs b/launcher/src/art.rs index ecae80714..3cc85ac96 100644 --- a/launcher/src/art.rs +++ b/launcher/src/art.rs @@ -2,7 +2,7 @@ //! and the landscape behind Home (the vanilla grass block is `browser::images::grass_block`). //! GPUI samples images smoothly, so every image is baked at the window's scale with each texel a //! whole block of device pixels, and drawn at exactly its size: the edges stay sharp. Each image -//! is made once per appearance and scale, then reused. +//! is reused until its appearance, scale or landscape width changes. use gpui::RenderImage; use horizon_theme as tokens; use std::collections::HashMap; @@ -11,8 +11,15 @@ use std::sync::Arc; /// What an image is, to find it again. #[derive(Clone, PartialEq, Eq, Hash)] enum Key { - Stone { dark: bool, scale: u32 }, - Scene { dark: bool, scale: u32 }, + Stone { + dark: bool, + scale: u32, + }, + Scene { + dark: bool, + scale: u32, + width: usize, + }, } #[derive(Default)] @@ -24,7 +31,8 @@ pub struct Art { pub const STONE: f32 = tokens::TILE_TEXEL * (tokens::TILE_TEXELS * 4) as f32; /// Home's landscape: texels of this many logical pixels, and its size in texels. pub const SCENE_TEXEL: f32 = 6.; -pub const SCENE_SIZE: (usize, usize) = (220, 56); +pub const SCENE_HEIGHT: usize = 56; +const MIN_SCENE_WIDTH: f32 = 10.; impl Art { /// The page's stone texture, for a window at `scale`. @@ -42,20 +50,33 @@ impl Art { .clone() } - /// Home's landscape: a sunset in the dark appearance, a dawn in the light one. - pub fn scene(&mut self, dark: bool, scale: f32) -> Arc { + /// Home's landscape at the banner's width, without stretching its square texels. + /// Only the current size is retained, so resizing cannot accumulate large images. + pub fn scene(&mut self, dark: bool, scale: f32, width: f32) -> (Arc, f32) { + let width = (width / SCENE_TEXEL).ceil().max(MIN_SCENE_WIDTH) as usize; let key = Key::Scene { dark, scale: scale_key(scale), + width, }; - self.made + if !self.made.contains_key(&key) { + self.made.retain(|key, _| matches!(key, Key::Stone { .. })); + } + let image = self + .made .entry(key) .or_insert_with(|| { - let (w, h) = SCENE_SIZE; let palette = if dark { &SUNSET } else { &DAWN }; - bake(&opaque(&scene(palette, 3, w, h)), w, h, SCENE_TEXEL, scale) + bake( + &opaque(&scene(palette, 3, width, SCENE_HEIGHT)), + width, + SCENE_HEIGHT, + SCENE_TEXEL, + scale, + ) }) - .clone() + .clone(); + (image, width as f32 * SCENE_TEXEL) } } @@ -320,4 +341,32 @@ mod tests { let size = image.size(0); assert_eq!((size.width.0, size.height.0), (16, 16)); } + + #[test] + fn landscape_fills_the_banner_at_narrow_and_wide_window_sizes() { + let mut art = Art::default(); + for banner_width in [696., 916., 1633.] { + let (image, drawn_width) = art.scene(true, 2., banner_width); + assert!(drawn_width >= banner_width); + assert!(drawn_width - banner_width < SCENE_TEXEL); + assert_eq!(image.size(0).width.0, (drawn_width * 2.) as i32); + assert_eq!( + image.size(0).height.0, + (SCENE_HEIGHT as f32 * SCENE_TEXEL * 2.) as i32 + ); + } + } + + #[test] + fn resizing_replaces_the_landscape_and_preserves_the_stone_cache() { + let mut art = Art::default(); + let stone = art.stone(0x0f0d17, true, 1.); + let (first, _) = art.scene(true, 1., 900.); + let (reused, _) = art.scene(true, 1., 900.); + assert!(Arc::ptr_eq(&first, &reused)); + let (resized, _) = art.scene(true, 1., 1500.); + assert!(!Arc::ptr_eq(&first, &resized)); + assert_eq!(art.made.len(), 2); + assert!(Arc::ptr_eq(&stone, &art.stone(0x0f0d17, true, 1.))); + } } diff --git a/launcher/src/main.rs b/launcher/src/main.rs index db2309dd6..842d21b3b 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -19,12 +19,13 @@ mod perf; mod scrollbar; mod servers_page; mod theme; +mod titlebar; use gpui::{ actions, div, ease_out_quint, prelude::*, px, relative, size, Animation, AnimationExt, AnyElement, App, Application, Bounds, ClickEvent, Context, Div, ElementId, FocusHandle, FontWeight, Hsla, KeyBinding, KeyDownEvent, Menu, MenuItem, PathPromptOptions, SharedString, - Stateful, Subscription, TitlebarOptions, Window, WindowBounds, WindowOptions, + Stateful, Subscription, Window, WindowBounds, WindowOptions, }; use horizon_launcher::account::{self, Accounts, SignIn, SignInState}; use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates}; @@ -1313,11 +1314,10 @@ fn megabytes(bytes: u64) -> String { // ----- Pages ------------------------------------------------------------------------------------- impl Launcher { - /// The top bar: the mark and the name over the sidebar, the pages with their icons, then - /// the account playing and the Settings button. + /// The top bar: the pages with their icons, then the account and Settings. fn topbar(&mut self, cx: &mut Context) -> Div { let t = self.theme; - let mut nav = div().flex().h_full().gap(px(2.)); + let mut nav = div().flex().flex_none().h_full().gap(px(2.)); for (page, label, icon) in Page::ALL { if page == Page::Settings { continue; @@ -1372,6 +1372,8 @@ impl Launcher { let account = keyboard(div().id("account"), &t) .relative() .flex() + .min_w_0() + .max_w(px(180.)) .items_center() .gap(px(10.)) .h(px(40.)) @@ -1395,8 +1397,10 @@ impl Launcher { div() .flex() .flex_col() + .min_w_0() .child( blocks::pixel(14., FontWeight::MEDIUM) + .truncate() .text_color(t.ink) .child(name), ) @@ -1448,25 +1452,12 @@ impl Launcher { .bg(t.side) .border_b_2() .border_color(t.outline) - .child( - div() - .flex() - .flex_none() - .items_center() - .gap(px(10.)) - .w(px(theme::SIDEBAR - 18.)) - .child(mark(24., &t)) - .child( - blocks::pixel(20., FontWeight::SEMIBOLD) - .text_color(t.ink) - .child("HORIZON"), - ), - ) .child(nav) .child( div() .ml_auto() .flex() + .flex_none() .items_center() .gap(px(8.)) .child(account) @@ -1835,7 +1826,7 @@ impl Launcher { wrap } - fn play_page(&mut self, cx: &mut Context) -> Div { + fn play_page(&mut self, banner_width: f32, cx: &mut Context) -> Div { let t = self.theme; let Some(tag) = self.selected().cloned() else { // No hero without a version: the page starts below the top bar like the others. @@ -1994,7 +1985,7 @@ impl Launcher { // The banner: Horizon's landscape (`art.rs`) under a veil of the page colour, the hero and // the Play row over it. It reaches the content's edges and the top bar. - let scene = self.art.scene(t.dark, self.scale); + let (scene, scene_width) = self.art.scene(t.dark, self.scale, banner_width); let veil = |angle: f32, from: f32, to: f32, at: f32| { div() .absolute() @@ -2007,15 +1998,14 @@ impl Launcher { gpui::linear_color_stop(t.page.opacity(to), at), )) }; - let (w, h) = art::SCENE_SIZE; let banner = div() .relative() .flex() .flex_col() .justify_end() .min_h(px(340.)) - .mx(px(-32.)) - .px(px(32.)) + .mx(px(-theme::PAGE_GUTTER)) + .px(px(theme::PAGE_GUTTER)) .pb(px(28.)) .gap(px(24.)) .overflow_hidden() @@ -2027,8 +2017,8 @@ impl Launcher { .absolute() .bottom_0() .left_0() - .w(px(w as f32 * art::SCENE_TEXEL)) - .h(px(h as f32 * art::SCENE_TEXEL)), + .w(px(scene_width)) + .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)), ) .child(veil(90., 0.82, 0., 0.62)) .child(veil(180., 0., 0.75, 1.)) @@ -3251,8 +3241,10 @@ impl Render for Launcher { self.friend_focused = self.friend_focus.is_focused(window); self.mods.note_focus(window); self.args_focused = self.args_focus.is_focused(window); + let size = window.viewport_size(); + let banner_width = f32::from(size.width) - theme::SIDEBAR - scrollbar::GUTTER; let content = match self.page { - Page::Play => self.play_page(cx), + Page::Play => self.play_page(banner_width, cx), Page::Versions => self.versions_page(cx), Page::Mods => self.mods_page(cx), Page::Servers => self.servers_page(cx), @@ -3265,7 +3257,6 @@ impl Render for Launcher { .w_full() // Let the page shrink inside the padded flex row so long notices can wrap. .min_w_0() - .max_w(px(1152.)) .child(content) .with_animation( ElementId::named_usize("page", self.switches), @@ -3277,7 +3268,6 @@ impl Render for Launcher { if self.opening.is_none() && window.focused(cx).is_none() { window.focus(&self.root_focus); } - let size = window.viewport_size(); let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor()); let topbar = self.topbar(cx); let sidebar = self.sidebar(cx); @@ -3333,7 +3323,9 @@ impl Render for Launcher { .child( div() .flex() - .px(px(32.)) + .w_full() + .min_w_0() + .px(px(theme::PAGE_GUTTER)) .pt(px(if self.page == Page::Play { 0. } else { @@ -3411,7 +3403,13 @@ impl Render for Launcher { }), ); } - root + div() + .flex() + .flex_col() + .size_full() + .bg(t.side) + .children(titlebar::render(&t, window)) + .child(root.flex_1().min_h_0()) } } @@ -3533,10 +3531,7 @@ fn main() { WindowOptions { window_bounds: Some(WindowBounds::Windowed(bounds)), window_min_size: Some(size(px(960.), px(600.))), - titlebar: Some(TitlebarOptions { - title: Some("Horizon".into()), - ..Default::default() - }), + titlebar: Some(titlebar::options()), app_id: Some("horizon-launcher".into()), ..Default::default() }, diff --git a/launcher/src/scrollbar.rs b/launcher/src/scrollbar.rs index 757d3525e..723c98cca 100644 --- a/launcher/src/scrollbar.rs +++ b/launcher/src/scrollbar.rs @@ -6,6 +6,9 @@ use gpui::{ }; use std::{cell::Cell, rc::Rc}; +/// Space reserved beside scroll content for the track and its padding. +pub const GUTTER: f32 = 16.; + #[derive(Clone, Default)] pub(crate) struct Scrollbar { pub handle: ScrollHandle, @@ -60,7 +63,7 @@ impl Scrollbar { .child( content .track_scroll(&self.handle) - .mr(px(16.)) + .mr(px(GUTTER)) // Nested scroll areas must not also move the page behind them. .on_scroll_wheel(|_, _, cx| cx.stop_propagation()), ) diff --git a/launcher/src/theme.rs b/launcher/src/theme.rs index 6425232c5..60b796709 100644 --- a/launcher/src/theme.rs +++ b/launcher/src/theme.rs @@ -24,6 +24,7 @@ pub const CONTROL: f32 = 34.; /// The top bar, and the sidebar of instances and servers. pub const TOPBAR: f32 = 56.; pub const SIDEBAR: f32 = 248.; +pub const PAGE_GUTTER: f32 = 32.; /// Motion: short and eased out, never bouncy. pub const QUICK: Duration = tokens::QUICK.duration(); diff --git a/launcher/src/titlebar.rs b/launcher/src/titlebar.rs new file mode 100644 index 000000000..3ff88a3ef --- /dev/null +++ b/launcher/src/titlebar.rs @@ -0,0 +1,153 @@ +//! Custom Windows chrome. Other platforms keep their native window decorations. +use crate::theme::Theme; +use gpui::{Div, TitlebarOptions, Window}; + +pub fn options() -> TitlebarOptions { + TitlebarOptions { + title: Some("Horizon".into()), + appears_transparent: cfg!(target_os = "windows"), + ..Default::default() + } +} + +#[cfg(not(target_os = "windows"))] +pub fn render(_theme: &Theme, _window: &Window) -> Option

{ + None +} + +#[cfg(target_os = "windows")] +mod windows { + use super::*; + use crate::{blocks, mark}; + use gpui::{div, prelude::*, px, FontWeight, Stateful, WindowControlArea}; + + const HEIGHT: f32 = 32.; + const BUTTON_WIDTH: f32 = 46.; + const RESIZE_INSET: f32 = 5.; + + #[derive(Clone, Copy)] + enum Control { + Minimize, + Maximize, + Close, + } + + impl Control { + fn area(self) -> WindowControlArea { + match self { + Self::Minimize => WindowControlArea::Min, + Self::Maximize => WindowControlArea::Max, + Self::Close => WindowControlArea::Close, + } + } + + fn name(self) -> &'static str { + match self { + Self::Minimize => "window-minimize", + Self::Maximize => "window-maximize", + Self::Close => "window-close", + } + } + } + + fn control_icon(control: Control, maximized: bool, theme: &Theme) -> Div { + let square = || { + div() + .absolute() + .size(px(10.)) + .border_1() + .border_color(theme.ink_soft) + }; + let icon = div().relative().size(px(14.)); + match control { + Control::Minimize => icon.child( + div() + .absolute() + .left(px(2.)) + .top(px(7.)) + .w(px(10.)) + .h(px(1.)) + .bg(theme.ink_soft), + ), + Control::Maximize if maximized => icon + .child( + div() + .absolute() + .left(px(4.)) + .top_0() + .size(px(10.)) + .border_t_1() + .border_r_1() + .border_color(theme.ink_soft), + ) + .child(square().left(px(1.)).top(px(3.))), + Control::Maximize => icon.child(square().left(px(2.)).top(px(2.))), + Control::Close => { + let hover_color = theme.page; + icon.child( + blocks::icon("close", 14., theme.ink_soft) + .group_hover("window-close", move |style| style.text_color(hover_color)), + ) + } + } + } + + fn control_button(control: Control, theme: &Theme, maximized: bool) -> Stateful
{ + let theme = *theme; + div() + .id(control.name()) + .group(control.name()) + .flex() + .flex_none() + .items_center() + .justify_center() + .w(px(BUTTON_WIDTH)) + .h_full() + .text_color(theme.ink_soft) + // GPUI maps these to native non-client hit tests, retaining Snap Layouts, + // Alt+Space and close handling. Click callbacks would run the action twice. + .window_control_area(control.area()) + .hover(move |style| match control { + Control::Close => style.bg(theme.danger).text_color(theme.page), + _ => style.bg(theme.raised), + }) + .child(control_icon(control, maximized, &theme)) + } + + pub fn render(theme: &Theme, window: &Window) -> Option
{ + let drag = div() + .id("window-drag") + .flex() + .flex_1() + .h_full() + .items_center() + .gap(px(8.)) + .px(px(12.)) + .window_control_area(WindowControlArea::Drag) + .child(mark(16., theme)) + .child(blocks::pixel(13., FontWeight::MEDIUM).child("Horizon")); + Some( + div() + .flex() + .flex_none() + .items_center() + .h(px(HEIGHT)) + // Control hit tests run before native edge resizing in GPUI 0.2.2. + .when(!window.is_maximized(), |bar| { + bar.pt(px(RESIZE_INSET)).px(px(RESIZE_INSET)) + }) + .bg(theme.side) + .text_color(theme.muted) + .border_b_1() + .border_color(theme.outline) + .child(drag) + .children( + [Control::Minimize, Control::Maximize, Control::Close] + .map(|control| control_button(control, theme, window.is_maximized())), + ), + ) + } +} + +#[cfg(target_os = "windows")] +pub use windows::render; From 1be8a4caeaed1bd48a8feb8f249bbe6c90042583 Mon Sep 17 00:00:00 2001 From: RobertTGreat Date: Sat, 24 Oct 2026 18:34:08 +0100 Subject: [PATCH 04/12] fix(launcher): defer hardware probes and hide Windows consoles Collect performance-report hardware after the first frame and preserve logs, input and CLI pipes while suppressing background terminal windows. Co-Authored-By: OpenAI Codex (GPT-6.1 Sol) --- crates/horizon-bench/src/hardware.rs | 10 +- crates/horizon-bench/src/lib.rs | 8 +- crates/horizon-prepare/src/java.rs | 22 ++++- crates/horizon-server/src/engine.rs | 6 +- crates/horizon-server/src/main.rs | 1 + crates/horizon-server/src/process.rs | 18 ++++ crates/horizon-server/src/service.rs | 4 +- crates/horizon-server/src/update.rs | 7 +- crates/horizon-telemetry/src/system.rs | 13 ++- launcher/README.md | 6 ++ launcher/src/agents.rs | 4 +- launcher/src/agents_page.rs | 2 +- launcher/src/backend.rs | 15 +-- launcher/src/cli_tools.rs | 2 +- launcher/src/console.rs | 48 ++++++++++ launcher/src/game_tools.rs | 4 +- launcher/src/lib.rs | 1 + launcher/src/main.rs | 7 ++ launcher/src/perf.rs | 97 +++++++++++++++++++- launcher/src/process.rs | 22 +++++ launcher/src/servers.rs | 8 +- launcher/src/sources.rs | 2 +- launcher/src/tailscale.rs | 7 +- launcher/tests/hidden_processes.rs | 116 ++++++++++++++++++++++++ launcher/tests/startup.rs | 88 ++++++++++++++++++ launcher/tests/support/console_probe.rs | 73 +++++++++++++++ launcher/tests/support/mod.rs | 29 ++++++ 27 files changed, 570 insertions(+), 50 deletions(-) create mode 100644 crates/horizon-server/src/process.rs create mode 100644 launcher/src/console.rs create mode 100644 launcher/src/process.rs create mode 100644 launcher/tests/hidden_processes.rs create mode 100644 launcher/tests/startup.rs create mode 100644 launcher/tests/support/console_probe.rs create mode 100644 launcher/tests/support/mod.rs diff --git a/crates/horizon-bench/src/hardware.rs b/crates/horizon-bench/src/hardware.rs index 17e460bed..6b91202ad 100644 --- a/crates/horizon-bench/src/hardware.rs +++ b/crates/horizon-bench/src/hardware.rs @@ -174,7 +174,15 @@ pub fn cpu_seconds(pid: u32) -> Option { } fn output(program: &str, args: &[&str]) -> Option { - let out = Command::new(program).args(args).output().ok()?; + let mut command = 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(out.stdout).ok()?.trim().to_owned(); (out.status.success() && !text.is_empty()).then_some(text) } 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-prepare/src/java.rs b/crates/horizon-prepare/src/java.rs index a159fb055..78530486c 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,19 @@ pub struct Jdk { const TIMEOUT: Duration = Duration::from_secs(3600); +/// Exporters and JDK probes write to pipes or log files, never to a new terminal. +fn command(program: impl AsRef) -> Command { + let mut command = Command::new(program); + command.stdin(Stdio::null()); + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + command.creation_flags(CREATE_NO_WINDOW); + } + command +} + fn executable(dir: &Path, name: &str) -> PathBuf { dir.join(if cfg!(windows) { format!("{name}.exe") @@ -29,7 +43,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 +197,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 +274,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 +282,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-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 mut command = Command::new(program); + configure(&mut command); + command +} + +fn configure(command: &mut Command) { + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + command.creation_flags(windows_sys::Win32::System::Threading::CREATE_NO_WINDOW); + } + #[cfg(not(windows))] + let _ = 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()?; + 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/launcher/README.md b/launcher/README.md index cf968f93c..d2b78daea 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -97,6 +97,12 @@ 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. +On Windows, desktop launches and background tools run without terminal windows. Preparation +and server logs still reach the launcher, and CLI commands keep their terminal or redirected +input and output, including MCP. +Hardware details for performance reports are collected in the background after the first +frame, so Windows hardware queries do not delay the window opening. + ## Updates The launcher looks for a newer Horizon release when it starts and every 30 minutes while it diff --git a/launcher/src/agents.rs b/launcher/src/agents.rs index 0cc012b43..2baf198c6 100644 --- a/launcher/src/agents.rs +++ b/launcher/src/agents.rs @@ -122,8 +122,8 @@ pub fn locate(program: &str) -> std::path::PathBuf { /// Settings page's "Test the connection". pub fn self_test(exe: &Path) -> Result { use std::io::Write; - use std::process::{Command, Stdio}; - let mut child = Command::new(exe) + use std::process::Stdio; + let mut child = crate::process::command(exe) .arg("mcp") .stdin(Stdio::piped()) .stdout(Stdio::piped()) diff --git a/launcher/src/agents_page.rs b/launcher/src/agents_page.rs index ecb393bf0..e53d6550a 100644 --- a/launcher/src/agents_page.rs +++ b/launcher/src/agents_page.rs @@ -207,7 +207,7 @@ impl Launcher { /// Runs a client's add command; (went well, what it said). fn run_add(program: &str, args: &[String]) -> (bool, String) { - match std::process::Command::new(agents::locate(program)) + match horizon_launcher::process::command(agents::locate(program)) .args(args) .output() { diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 9612bda2b..104a086a5 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -943,7 +943,7 @@ pub fn default_minecraft_dir() -> Option { } fn found(program: &str, arg: &str) -> bool { - Command::new(program) + crate::process::command(program) .arg(arg) .stdout(Stdio::null()) .stderr(Stdio::null()) @@ -1239,14 +1239,14 @@ pub fn sounds(tag: &str, minecraft: &Path, log: &dyn Fn(String)) { let own = horizon_prepare::sources_sha256(&dir.join(PREPARER_CRATE)).as_deref() == Some(horizon_prepare::SOURCES_SHA256); let binary = preparer_binary(&dir).filter(|binary| { - !own && Command::new(binary) + !own && crate::process::command(binary) .arg("--help") .output() .is_ok_and(|o| String::from_utf8_lossy(&o.stdout).contains("horizon-prepare sounds")) }); log("Copying the sounds from your Minecraft install".into()); let result = match binary { - Some(binary) => Command::new(binary) + Some(binary) => crate::process::command(binary) .current_dir(&dir) .arg("sounds") .arg("--root") @@ -1877,16 +1877,10 @@ fn parse_version_output(out: &str) -> Option<&str> { /// The version of the launcher binary now at `path`, which is not this process's once another /// update (the command line, another window) has replaced the file. fn installed_launcher_version(path: &Path) -> Option { - let mut cmd = Command::new(path); + let mut cmd = crate::process::command(path); cmd.arg("--version") .stdin(Stdio::null()) .stderr(Stdio::null()); - #[cfg(windows)] - { - use std::os::windows::process::CommandExt; - const CREATE_NO_WINDOW: u32 = 0x0800_0000; - cmd.creation_flags(CREATE_NO_WINDOW); - } let out = cmd.output().ok()?; parse_version_output(&String::from_utf8_lossy(&out.stdout)).map(String::from) } @@ -2220,6 +2214,7 @@ impl Running { } pub fn spawn(job: Job, mut cmd: Command, tx: Sender) -> Result { + crate::process::hide_console(&mut cmd); let mut child = cmd .stdin(Stdio::piped()) .stdout(Stdio::piped()) diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index ff351f4b3..e420576b5 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -210,7 +210,7 @@ impl Tool { pub fn call(&self, args: &Value) -> Result { let words = self.argv(args)?; let exe = std::env::current_exe().map_err(|e| e.to_string())?; - let out = std::process::Command::new(exe) + let out = horizon_launcher::process::command(exe) .arg("--json") .args(&words) .stdin(std::process::Stdio::null()) diff --git a/launcher/src/console.rs b/launcher/src/console.rs new file mode 100644 index 000000000..b12067139 --- /dev/null +++ b/launcher/src/console.rs @@ -0,0 +1,48 @@ +//! A desktop launch has no console; CLI commands can use the invoking terminal or pipes. +#[cfg(windows)] +pub fn attach_for_cli() -> std::io::Result<()> { + use std::ffi::c_void; + + const ATTACH_PARENT_PROCESS: u32 = u32::MAX; + const STD_INPUT_HANDLE: u32 = -10_i32 as u32; + const STD_OUTPUT_HANDLE: u32 = -11_i32 as u32; + const STD_ERROR_HANDLE: u32 = -12_i32 as u32; + const INVALID_HANDLE_VALUE: isize = -1; + + #[link(name = "kernel32")] + extern "system" { + fn AttachConsole(process_id: u32) -> i32; + fn GetStdHandle(kind: u32) -> *mut c_void; + fn SetStdHandle(kind: u32, handle: *mut c_void) -> i32; + } + + if std::env::args_os().nth(1).is_none() { + return Ok(()); + } + // Attaching can replace the standard handles. Keep inherited pipes/files intact for + // JSON output, MCP and redirected logs, while filling missing handles from the terminal. + // SAFETY: These APIs take numeric constants and opaque handles returned by Windows. + // No handles are closed or dereferenced, and this runs before any worker starts. + unsafe { + let handles = [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] + .map(|kind| (kind, GetStdHandle(kind))); + if AttachConsole(ATTACH_PARENT_PROCESS) == 0 { + // No parent console (for example, an MCP client), or already attached. + return Ok(()); + } + for (kind, handle) in handles { + if handle.is_null() || handle as isize == INVALID_HANDLE_VALUE { + continue; + } + if SetStdHandle(kind, handle) == 0 { + return Err(std::io::Error::last_os_error()); + } + } + } + Ok(()) +} + +#[cfg(not(windows))] +pub fn attach_for_cli() -> std::io::Result<()> { + Ok(()) +} diff --git a/launcher/src/game_tools.rs b/launcher/src/game_tools.rs index 3504a531f..efa219396 100644 --- a/launcher/src/game_tools.rs +++ b/launcher/src/game_tools.rs @@ -6,7 +6,7 @@ use horizon_launcher::backend; use serde_json::{json, Value}; use std::io::{BufRead, BufReader, Write}; use std::path::PathBuf; -use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio}; +use std::process::{Child, ChildStdin, ChildStdout, Stdio}; pub const PREFIX: &str = "game_"; @@ -61,7 +61,7 @@ impl GameTools { if !ctl.exists() { return Err(format!("{tag} has no {CTL}")); } - let mut child = Command::new(&ctl) + let mut child = horizon_launcher::process::command(&ctl) .arg("--socket") .arg(socket_path()) .arg("mcp") diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs index aa8aec7f2..4b5c164fd 100644 --- a/launcher/src/lib.rs +++ b/launcher/src/lib.rs @@ -9,6 +9,7 @@ pub mod game_app; pub mod heads; pub mod modpacks; pub mod mojang; +pub mod process; pub mod servers; pub mod signed; pub mod sources; diff --git a/launcher/src/main.rs b/launcher/src/main.rs index db2309dd6..9d5d36b60 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -1,12 +1,15 @@ //! Horizon launcher: installs Horizon builds, prepares them from the player's own Minecraft, //! and starts the client or a dedicated server. +#![cfg_attr(target_os = "windows", windows_subsystem = "windows")] + mod agents_page; mod art; mod blocks; mod cli; mod cli_tools; mod collection; +mod console; mod cull; mod game_tools; mod internet; @@ -3497,6 +3500,10 @@ fn menus() -> Vec { } fn main() { + if let Err(error) = console::attach_for_cli() { + eprintln!("Could not restore the launcher's terminal streams: {error}"); + std::process::exit(1); + } perf::process_started(); backend::exe_path(); if let Some(code) = cli::run() { diff --git a/launcher/src/perf.rs b/launcher/src/perf.rs index f46393542..7ecd0136c 100644 --- a/launcher/src/perf.rs +++ b/launcher/src/perf.rs @@ -9,10 +9,11 @@ use std::collections::BTreeMap; use std::path::PathBuf; +use std::sync::mpsc::{self, Receiver, TryRecvError}; use std::sync::OnceLock; use std::time::{Duration, Instant}; -use horizon_bench::{App, Frames, Kind, Report}; +use horizon_bench::{App, Frames, Hardware, Kind, Report}; /// The first thing `main` does; every start time counts from here. pub fn process_started() -> Instant { @@ -35,14 +36,36 @@ pub struct Perf { dirty: bool, /// Off for the windows `horizon-launcher benchmark` starts: they report to it instead. log: bool, + /// Machine probes run after the first frame, never while opening the window. + hardware: Option>, +} + +#[derive(Debug)] +struct Machine { + hardware: Hardware, + power: Option, + load_average: Option, +} + +impl Machine { + fn detect() -> Self { + Self { + hardware: Hardware::detect(), + power: horizon_bench::power_source().map(str::to_owned), + load_average: horizon_bench::load_average(), + } + } } impl Perf { pub fn new(scenario: &str) -> Perf { - let mut report = Report::new(Kind::Launcher, app()); + let hardware = Hardware { + os: std::env::consts::OS.to_owned(), + arch: std::env::consts::ARCH.to_owned(), + ..Hardware::default() + }; + let mut report = Report::with_hardware(Kind::Launcher, app(), hardware); report.conditions.scenario = Some(scenario.to_owned()); - report.conditions.power = horizon_bench::power_source().map(str::to_owned); - report.conditions.load_avg_1m = horizon_bench::load_average(); let path = crate::backend::data_dir().join("benchmarks").join(format!( "launcher-{}-{scenario}.json", report @@ -61,6 +84,7 @@ impl Perf { saved: Instant::now(), dirty: false, log: true, + hardware: None, }; if let Some(bytes) = binary_bytes() { perf.record("launcher.binary_bytes", bytes); @@ -89,6 +113,12 @@ impl Perf { if first { self.first_frame = Some(now); self.record_since("launcher.start_ms", process_started()); + let (sender, receiver) = mpsc::channel(); + self.hardware = Some(receiver); + std::thread::spawn(move || { + // The window may close before the optional report details finish. + let _ = sender.send(Machine::detect()); + }); } else if let Some(gap) = self.last_frame.map(|t| now - t).filter(|g| *g < IDLE_GAP) { self.ui_frames.push(gap.as_secs_f32() * 1000.0); } @@ -102,6 +132,7 @@ impl Perf { /// Samples memory and writes the report when something changed, at most every few seconds. pub fn tick(&mut self) { + self.poll_hardware(); if self.saved.elapsed() < Duration::from_secs(5) { return; } @@ -118,6 +149,7 @@ impl Perf { } pub fn report(&mut self) -> &Report { + self.poll_hardware(); for (name, values) in &self.values { self.report.metric(name, values); } @@ -128,6 +160,28 @@ impl Perf { &self.report } + fn poll_hardware(&mut self) { + let Some(receiver) = &self.hardware else { + return; + }; + match receiver.try_recv() { + Ok(machine) => { + self.report.hardware = machine.hardware; + self.report.conditions.power = machine.power; + self.report.conditions.load_avg_1m = machine.load_average; + self.hardware = None; + self.dirty = true; + } + Err(TryRecvError::Empty) => {} + Err(TryRecvError::Disconnected) => { + self.hardware = None; + eprintln!( + "The launcher could not collect its performance report's machine details." + ); + } + } + } + pub fn save(&mut self) { self.dirty = false; if !self.log { @@ -381,6 +435,41 @@ fn binary_bytes() -> Option { mod tests { use super::*; + #[test] + fn performance_tracking_starts_without_hardware_probes() { + let mut perf = Perf::new("test"); + perf.keep_local_log(false); + assert!(perf.hardware.is_none()); + assert_eq!(perf.report.hardware.os, std::env::consts::OS); + assert!(perf.report.hardware.cpu.is_none()); + assert!(perf.report.conditions.power.is_none()); + } + + #[test] + fn background_hardware_details_preserve_recorded_metrics() { + let mut perf = Perf::new("test"); + perf.keep_local_log(false); + perf.record("launcher.start_ms", 125.); + let (sender, receiver) = mpsc::channel(); + perf.hardware = Some(receiver); + assert_eq!(perf.report().metrics["launcher.start_ms"].mean, 125.); + sender + .send(Machine { + hardware: Hardware { + cpu: Some("Detected CPU".into()), + ..Hardware::default() + }, + power: Some("ac".into()), + load_average: Some(0.5), + }) + .unwrap(); + let report = perf.report(); + assert_eq!(report.hardware.cpu.as_deref(), Some("Detected CPU")); + assert_eq!(report.conditions.power.as_deref(), Some("ac")); + assert_eq!(report.metrics["launcher.start_ms"].mean, 125.); + assert!(perf.hardware.is_none()); + } + #[test] fn the_first_frame_is_the_start_and_close_frames_are_ui_frames() { let mut perf = Perf::new("test"); diff --git a/launcher/src/process.rs b/launcher/src/process.rs new file mode 100644 index 000000000..cd224b686 --- /dev/null +++ b/launcher/src/process.rs @@ -0,0 +1,22 @@ +//! Background commands keep their configured streams without opening Windows consoles. +use std::ffi::OsStr; +use std::process::Command; + +/// Builds a background command. Callers still choose how to capture its input and output. +pub fn command(program: impl AsRef) -> Command { + let mut command = Command::new(program); + hide_console(&mut command); + command +} + +/// Hides a background command's console on Windows, preserving its configured standard streams. +pub fn hide_console(command: &mut Command) { + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + const CREATE_NO_WINDOW: u32 = 0x0800_0000; + command.creation_flags(CREATE_NO_WINDOW); + } + #[cfg(not(windows))] + let _ = command; +} diff --git a/launcher/src/servers.rs b/launcher/src/servers.rs index 49ef05d66..264ccb149 100644 --- a/launcher/src/servers.rs +++ b/launcher/src/servers.rs @@ -245,7 +245,7 @@ fn point(link: &Path, target: &Path) -> std::io::Result<()> { #[cfg(windows)] { let _ = fs::remove_dir(link); - let status = Command::new("cmd") + let status = crate::process::command("cmd") .args(["/C", "mklink", "/J"]) .arg(link) .arg(target) @@ -266,10 +266,8 @@ pub fn command(dir: &Path, args: &[&str]) -> Result { let program = program().ok_or( "The server programs aren't set up yet: create a server, or press Prepare on its page.", )?; - let mut cmd = Command::new(program); + let mut cmd = crate::process::command(program); cmd.arg("--dir").arg(dir).args(args); - #[cfg(windows)] - std::os::windows::process::CommandExt::creation_flags(&mut cmd, 0x0800_0000); // CREATE_NO_WINDOW Ok(cmd) } @@ -752,7 +750,7 @@ pub fn lan_address() -> Option { pub fn service_installed(dir: &Path) -> bool { if cfg!(windows) { let name = format!("horizon-server-{}", service_suffix(dir)); - return Command::new("schtasks") + return crate::process::command("schtasks") .args(["/Query", "/TN", &name]) .stdout(Stdio::null()) .stderr(Stdio::null()) diff --git a/launcher/src/sources.rs b/launcher/src/sources.rs index 864e6bc73..b27b8417b 100644 --- a/launcher/src/sources.rs +++ b/launcher/src/sources.rs @@ -488,7 +488,7 @@ fn make_link(target: &Path, link: &Path) -> std::io::Result<()> { arg.push("\""); arg }; - let status = std::process::Command::new("cmd") + let status = crate::process::command("cmd") .args(["/C", "mklink", "/J"]) .raw_arg(quoted(link)) .raw_arg(quoted(target)) diff --git a/launcher/src/tailscale.rs b/launcher/src/tailscale.rs index 683ff0aab..b0c20d3bc 100644 --- a/launcher/src/tailscale.rs +++ b/launcher/src/tailscale.rs @@ -126,13 +126,8 @@ pub fn status_of(cli: Option) -> State { let Some(cli) = cli else { return State::Missing; }; - let mut command = Command::new(&cli); + let mut command = crate::process::command(&cli); command.args(["status", "--json"]); - #[cfg(windows)] - { - use std::os::windows::process::CommandExt; - command.creation_flags(0x0800_0000); // CREATE_NO_WINDOW - } let out = match command.output() { Ok(out) => out, Err(e) => return State::Off(e.to_string()), diff --git a/launcher/tests/hidden_processes.rs b/launcher/tests/hidden_processes.rs new file mode 100644 index 000000000..c7da90ea9 --- /dev/null +++ b/launcher/tests/hidden_processes.rs @@ -0,0 +1,116 @@ +//! Windows background processes must keep logs, input and exit status without a console. +#![cfg(windows)] + +mod support; +use horizon_launcher::{ + backend::{self, Job, Msg}, + process, +}; +use std::{fs, path::Path, sync::mpsc, time::Duration}; +use support::console_probe as probe; + +fn logged_child(fail: bool) -> (Vec, Result<(), String>) { + let (sender, receiver) = mpsc::channel(); + let mut command = std::process::Command::new(probe()); + if fail { + command.arg("--fail"); + } + let mut child = backend::spawn(Job::Prepare, command, sender).unwrap(); + child.send("input reaches the child"); + let mut lines = Vec::new(); + loop { + match receiver.recv_timeout(Duration::from_secs(10)).unwrap() { + Msg::Line(Job::Prepare, line) => lines.push(line), + Msg::Exit(Job::Prepare, result) => return (lines, result), + _ => panic!("unexpected job message"), + } + } +} + +#[test] +fn hidden_children_keep_stdout_stderr_stdin_and_success() { + let (lines, result) = logged_child(false); + assert!(result.is_ok(), "{result:?}"); + for expected in [ + "console_window_visible=false", + "stdout is captured", + "stderr is captured", + "stdin=input reaches the child", + ] { + assert!( + lines.iter().any(|line| line == expected), + "missing {expected}: {lines:?}" + ); + } +} + +#[test] +fn hidden_children_report_failure_and_keep_their_logs() { + let (lines, result) = logged_child(true); + assert!(result.unwrap_err().contains('7')); + assert!(lines.iter().any(|line| line == "stderr is captured")); +} + +#[test] +fn exporters_write_to_their_log_file_without_a_console() { + let root = probe().parent().unwrap(); + let path = root.join("exporter.log"); + let log = fs::File::create(&path).unwrap(); + let jdk = horizon_prepare::java::Jdk { + java: probe().into(), + javac: probe().into(), + }; + jdk.java(&[], Some(root), &log).unwrap(); + let output = fs::read_to_string(path).unwrap(); + for expected in [ + "console_window_visible=false", + "stdout is captured", + "stderr is captured", + ] { + assert!(output.contains(expected), "missing {expected}: {output}"); + } +} + +#[test] +fn cli_keeps_redirected_stdout_and_stderr() { + let executable = env!("CARGO_BIN_EXE_horizon-launcher"); + let version = process::command(executable) + .arg("--version") + .output() + .unwrap(); + assert!(version.status.success()); + assert!(String::from_utf8_lossy(&version.stdout).starts_with("horizon-launcher ")); + let invalid = process::command(executable) + .arg("--unknown-option") + .output() + .unwrap(); + assert!(!invalid.status.success()); + assert!(String::from_utf8_lossy(&invalid.stderr).contains("--unknown-option")); +} + +#[test] +fn mcp_keeps_its_stdio_transport() { + let executable = Path::new(env!("CARGO_BIN_EXE_horizon-launcher")); + assert!(horizon_launcher::agents::self_test(executable).unwrap() > 0); +} + +#[test] +fn desktop_executable_uses_the_windows_gui_subsystem() { + const PE_HEADER_POINTER: usize = 0x3c; + const PE_OPTIONAL_HEADER_OFFSET: usize = 24; + const SUBSYSTEM_OFFSET: usize = 68; + const WINDOWS_GUI_SUBSYSTEM: u16 = 2; + + let executable = fs::read(env!("CARGO_BIN_EXE_horizon-launcher")).unwrap(); + let header = u32::from_le_bytes( + executable[PE_HEADER_POINTER..PE_HEADER_POINTER + 4] + .try_into() + .unwrap(), + ) as usize; + assert_eq!(&executable[header..header + 4], b"PE\0\0"); + let subsystem = header + PE_OPTIONAL_HEADER_OFFSET + SUBSYSTEM_OFFSET; + assert_eq!( + u16::from_le_bytes(executable[subsystem..subsystem + 2].try_into().unwrap()), + WINDOWS_GUI_SUBSYSTEM + ); +} diff --git a/launcher/tests/startup.rs b/launcher/tests/startup.rs new file mode 100644 index 000000000..776d8ef15 --- /dev/null +++ b/launcher/tests/startup.rs @@ -0,0 +1,88 @@ +//! Full launcher startup against instrumented Windows hardware probes. +#![cfg(windows)] + +mod support; +use std::{ + fs, + path::{Path, PathBuf}, + process::{Child, Output, Stdio}, + time::{Duration, Instant}, +}; + +fn fixture() -> PathBuf { + let root = std::env::temp_dir().join(format!("horizon-startup-{}", std::process::id())); + for folder in ["game/telemetry", "launcher", "data", "config", "probes"] { + fs::create_dir_all(root.join(folder)).unwrap(); + } + fs::write(root.join("launcher/settings.json"), r#"{"skip_opening":true,"install_new_versions":false,"desktop_entry":false,"ping_notice_seen":true}"#).unwrap(); + let consent = serde_json::json!({"version":horizon_telemetry::CONSENT_VERSION,"choices":{}}); + fs::write( + root.join("game/telemetry/consent.json"), + consent.to_string(), + ) + .unwrap(); + fs::copy(support::console_probe(), root.join("probes/powershell.exe")).unwrap(); + root +} + +fn launch(root: &Path) -> Child { + let inherited_path = std::env::var_os("PATH").unwrap(); + let paths = std::iter::once(root.join("probes")).chain(std::env::split_paths(&inherited_path)); + horizon_launcher::process::command(env!("CARGO_BIN_EXE_horizon-launcher")) + .current_dir(root) + .env("PATH", std::env::join_paths(paths).unwrap()) + .env("HORIZON_HOME", root.join("game")) + .env("HORIZON_LAUNCHER_HOME", root.join("launcher")) + .env("XDG_DATA_HOME", root.join("data")) + .env("XDG_CONFIG_HOME", root.join("config")) + .env("HORIZON_LAUNCHER_NO_SELF_UPDATE", "1") + .env("HORIZON_NO_AUDIO", "1") + .env("HORIZON_TELEMETRY_URL", "off") + .env("HORIZON_STARTUP_PROBE_LOG", root.join("probes.log")) + .env("HORIZON_LAUNCHER_BENCH", root.join("timing.json")) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap() +} + +fn wait_for_exit(mut child: Child, root: &Path) -> Output { + let deadline = Instant::now() + Duration::from_secs(30); + while child.try_wait().unwrap().is_none() { + if Instant::now() >= deadline { + child.kill().unwrap(); + child.wait().unwrap(); + panic!("launcher startup timed out: {}", root.display()); + } + std::thread::sleep(Duration::from_millis(20)); + } + child.wait_with_output().unwrap() +} + +#[test] +#[ignore = "requires an interactive Windows desktop and graphics adapter"] +fn hardware_probes_run_hidden_after_the_first_frame() { + let root = fixture(); + let output = wait_for_exit(launch(&root), &root); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + let timing: serde_json::Value = + serde_json::from_slice(&fs::read(root.join("timing.json")).unwrap()).unwrap(); + let first_frame = timing["first_frame_epoch_ms"].as_f64().unwrap().floor(); + let probes = fs::read_to_string(root.join("probes.log")).unwrap(); + // Rust resolves cmd.exe to the system directory, so instrument the seven PowerShell + // probes, which exercise both shared helpers (the cmd probes use those same helpers). + const POWERSHELL_PROBES: usize = 7; + assert_eq!(probes.lines().count(), POWERSHELL_PROBES, "{probes}"); + for probe in probes.lines() { + let fields: Vec<_> = probe.split('|').collect(); + assert!( + fields[0].parse::().unwrap() >= first_frame, + "probe blocked startup: {probe}" + ); + assert_eq!(fields[1], "false", "probe opened a terminal: {probe}"); + } +} diff --git a/launcher/tests/support/console_probe.rs b/launcher/tests/support/console_probe.rs new file mode 100644 index 000000000..1ff16a10b --- /dev/null +++ b/launcher/tests/support/console_probe.rs @@ -0,0 +1,73 @@ +//! A real Windows console program used to check hidden children and their streams. +use std::ffi::c_void; +use std::io; + +fn hardware_probe(visible: bool) -> bool { + let Some(path) = std::env::var_os("HORIZON_STARTUP_PROBE_LOG") else { + return false; + }; + use std::io::Write; + let arguments = std::env::args().skip(1).collect::>().join(" "); + let program = std::env::current_exe().unwrap(); + let timestamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis(); + let mut log = std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(path) + .unwrap(); + writeln!( + log, + "{timestamp}|{visible}|{}", + program.file_name().unwrap().to_string_lossy() + ) + .unwrap(); + // Slow probes make a synchronous startup regression visible without relying on WMI speed. + std::thread::sleep(std::time::Duration::from_millis(100)); + let responses = [ + ("TotalPhysicalMemory", "17179869184"), + ("NumberOfCores", "8"), + ("MaxClockSpeed", "3600"), + ("BatteryStatus", "2"), + ("Win32_Battery", "0"), + ]; + let response = responses + .iter() + .find_map(|&(query, response)| arguments.contains(query).then_some(response)) + .unwrap_or("Microsoft Windows [Version 10.0.26100]"); + println!("{response}"); + true +} + +#[link(name = "kernel32")] +extern "system" { + fn GetConsoleWindow() -> *mut c_void; +} + +#[link(name = "user32")] +extern "system" { + fn IsWindowVisible(window: *mut c_void) -> i32; +} + +fn main() { + // A console connection can exist without a terminal window, including in ConPTY. + // SAFETY: The opaque window handle comes from Windows and is only queried, never changed. + let visible = unsafe { + let window = GetConsoleWindow(); + !window.is_null() && IsWindowVisible(window) != 0 + }; + if hardware_probe(visible) { + return; + } + println!("console_window_visible={visible}"); + println!("stdout is captured"); + eprintln!("stderr is captured"); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + println!("stdin={}", input.trim()); + if std::env::args().any(|argument| argument == "--fail") { + std::process::exit(7); + } +} diff --git a/launcher/tests/support/mod.rs b/launcher/tests/support/mod.rs new file mode 100644 index 000000000..b5a72d115 --- /dev/null +++ b/launcher/tests/support/mod.rs @@ -0,0 +1,29 @@ +use horizon_launcher::process; +use std::{ + fs, + path::{Path, PathBuf}, + sync::OnceLock, +}; + +pub fn console_probe() -> &'static Path { + static PROBE: OnceLock = OnceLock::new(); + PROBE.get_or_init(|| { + let root = + std::env::temp_dir().join(format!("horizon-console-probe-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + let executable = root.join("console-probe.exe"); + let source = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/support/console_probe.rs"); + let output = process::command("rustc") + .arg(source) + .arg("-o") + .arg(&executable) + .output() + .unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + executable + }) +} From 98639d1471759f8d315bde469a9f7f5d33c0fc47 Mon Sep 17 00:00:00 2001 From: RobertTGreat Date: Sat, 24 Oct 2026 18:49:37 +0100 Subject: [PATCH 05/12] fix(launcher): virtualize long mod lists from the first frame Render nearby rows in the existing page scrollbar, defer hidden icons and cached verdict reads, and preserve bottom anchoring as row heights are measured. Co-Authored-By: OpenAI Codex (GPT-6.1 Sol) --- launcher/README.md | 6 + launcher/src/cull.rs | 397 +++++++++++++++++++++++++++------- launcher/src/main.rs | 7 +- launcher/src/modpacks_page.rs | 22 +- launcher/src/mods_page.rs | 70 ++++-- launcher/src/mods_project.rs | 96 ++++++-- 6 files changed, 479 insertions(+), 119 deletions(-) diff --git a/launcher/README.md b/launcher/README.md index cf968f93c..5923491e0 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -258,6 +258,12 @@ measure idle CPU, fetches the release list 3 times, and writes one report there your machine; a `benchmark` report is uploaded, dated to the day, only if you allowed benchmark uploads ([data collection](../docs/telemetry.md)). +Long lists on Mods (results, installed entries, coverage reports and project versions), Versions +and Patch notes build only nearby rows, including on their first frame. Variable row heights +are measured as they enter view; hidden ranges share spacers in the existing page scrollbar. +On Windows, `cargo test --bin horizon-launcher desktop_list_renders_the_viewport_after_scrollbar_jumps +-- --ignored` checks 10,000 rows of different heights in a real GPUI window (requires an awake desktop/GPU). + ## Building cargo build --release diff --git a/launcher/src/cull.rs b/launcher/src/cull.rs index 41df05610..38bd3dd6d 100644 --- a/launcher/src/cull.rs +++ b/launcher/src/cull.rs @@ -1,25 +1,39 @@ -//! Long lists in the page's scroll area (the hundred releases on Versions and Patch notes) draw -//! only the rows near what is on screen. A row far off screen becomes an empty block as tall as -//! it was the last time it was drawn, so the page keeps its length and the scrollbar its place. -use gpui::{div, px, Bounds, Div, IntoElement, ParentElement, Pixels, ScrollHandle, Styled}; -use std::{cell::RefCell, rc::Rc}; +//! Variable-height lists in the page's scroll area. Only nearby rows build elements; +//! unseen rows use estimated heights and consecutive hidden rows share one spacer. +use gpui::{ + div, point, px, size, Bounds, Div, IntoElement, ParentElement, Pixels, ScrollHandle, Styled, +}; +use std::{cell::RefCell, ops::Range, rc::Rc}; + +const ESTIMATED_HEIGHT: f32 = 96.; +/// Until the enclosing scroll area completes its first layout. +const INITIAL_VIEW_HEIGHT: f32 = 800.; #[derive(Clone, Default)] pub struct Cull(Rc>); -/// Where each row was in the last frame, and the scroll offset and the viewport's width then -/// (a narrower window wraps text, and the heights no longer hold). #[derive(Default)] struct Drawn { - rows: Vec>, + heights: Vec, + top: Pixels, offset: Pixels, width: Pixels, } +#[derive(Debug)] +enum Span { + Row(usize), + Space { rows: Range, height: Pixels }, +} + impl Cull { - /// A column for `rows` rows that remembers where they were drawn. Rows come from `row(i)`, or - /// an empty block when row `i` was more than a screen away from the viewport last frame and - /// `keep(i)` is false (a row being installed or showing an error is always drawn). + /// Invalidate measurements when filtering, ordering or collection identity changes. + pub fn reset(&self) { + *self.0.borrow_mut() = Drawn::default(); + } + + /// Render nearby rows plus those retained by `keep` (such as active confirmations). + /// `gap` is the bottom margin already supplied by each row. pub fn column( &self, handle: &ScrollHandle, @@ -28,92 +42,329 @@ impl Cull { keep: impl Fn(usize) -> bool, mut row: impl FnMut(usize) -> E, ) -> Div { - let far = self.far(handle, rows); - let skipped: Vec> = (0..rows).map(|i| far(i).filter(|_| !keep(i))).collect(); - let gaps = skipped.iter().any(Option::is_some); + let max = handle.max_offset().height; + if max > px(0.) + && handle.offset().y <= -max + px(0.5) + && self.0.borrow().heights.len() == rows + { + // Measuring taller rows at the end must keep the final row in view. Appending + // results deliberately leaves the current viewport in place instead. + handle.scroll_to_bottom(); + } + let spans = self + .0 + .borrow_mut() + .plan(handle.bounds(), handle.offset().y, rows, gap, keep); + let children = spans + .iter() + .map(|span| match span { + // The wrapper includes the row's margin in its measured height. + Span::Row(index) => div().flex().flex_col().flex_none().child(row(*index)), + Span::Space { height, .. } => div().flex_none().h(*height), + }) + .collect::>(); let state = self.0.clone(); let scroll = handle.clone(); div() .flex() .flex_col() - .children(skipped.iter().enumerate().map(|(i, skip)| match skip { - Some(height) => div().flex_none().h(*height).mb(px(gap)).into_any_element(), - None => row(i).into_any_element(), - })) + .children(children) .on_children_prepainted(move |bounds, window, _| { - let view = scroll.bounds(); - // A jump of more than a screen (the scrollbar dragged) can bring an empty block - // into view: draw again, with the rows where they are now. - if gaps - && bounds - .iter() - .zip(&skipped) - .any(|(b, skip)| skip.is_some() && !away(*b, px(0.), view)) + if state + .borrow_mut() + .record(&spans, &bounds, scroll.bounds(), scroll.offset().y) { window.refresh(); } - let mut drawn = state.borrow_mut(); - drawn.rows = bounds; - drawn.offset = scroll.offset().y; - drawn.width = view.size.width; }) } - - /// For row `i`: its height when it was more than a screen away from the viewport. - fn far(&self, handle: &ScrollHandle, rows: usize) -> impl Fn(usize) -> Option { - let drawn = self.0.borrow(); - let view = handle.bounds(); - // The rows moved by however far the page scrolled since they were drawn. - let moved = handle.offset().y - drawn.offset; - let known = - drawn.rows.len() == rows && view.size.height > px(0.) && drawn.width == view.size.width; - let rows = if known { - drawn.rows.clone() - } else { - Vec::new() - }; - move |i| { - let b = *rows.get(i)?; - away(b, moved, view).then_some(b.size.height) - } - } } -/// Whether a row drawn at `row`, since moved down by `moved`, is more than a screen above or -/// below `view`. -fn away(row: Bounds, moved: Pixels, view: Bounds) -> bool { - row.bottom() + moved < view.top() - view.size.height - || row.top() + moved > view.bottom() + view.size.height +impl Drawn { + fn plan( + &mut self, + mut view: Bounds, + offset: Pixels, + rows: usize, + gap: f32, + keep: impl Fn(usize) -> bool, + ) -> Vec { + let estimate = px(ESTIMATED_HEIGHT + gap); + if self.width != view.size.width { + // A resize changes wrapping, including in rows currently off screen. + self.heights.fill(estimate); + } + self.heights.resize(rows, estimate); + if view.size.height <= px(0.) { + view.size.height = px(INITIAL_VIEW_HEIGHT); + } + let mut top = self.top + offset - self.offset; + let mut spans = Vec::new(); + for (index, height) in self.heights.iter().copied().enumerate() { + let bounds = Bounds::new(point(view.left(), top), size(view.size.width, height)); + if !away(bounds, view) || keep(index) { + spans.push(Span::Row(index)); + } else if let Some(Span::Space { + rows, + height: total, + }) = spans.last_mut() + { + rows.end = index + 1; + *total += height; + } else { + spans.push(Span::Space { + rows: index..index + 1, + height, + }); + } + top += height; + } + spans + } + + /// A moved header or scrollbar jump can expose a spacer: request another frame when + /// measurements or the estimated visible range need correcting. + fn record( + &mut self, + spans: &[Span], + bounds: &[Bounds], + view: Bounds, + offset: Pixels, + ) -> bool { + let mut changed = false; + for (span, bounds) in spans.iter().zip(bounds) { + match span { + Span::Row(index) => { + let height = &mut self.heights[*index]; + changed |= (*height - bounds.size.height).abs() > px(0.5); + *height = bounds.size.height; + } + Span::Space { .. } => changed |= !away(*bounds, view), + } + } + self.top = bounds.first().map_or(view.top(), Bounds::top); + self.offset = offset; + self.width = view.size.width; + changed + } +} + +/// One viewport of overdraw above and below the visible area. +fn away(row: Bounds, view: Bounds) -> bool { + row.bottom() < view.top() - view.size.height || row.top() > view.bottom() + view.size.height } #[cfg(test)] mod tests { use super::*; - use gpui::{point, size}; - fn at(y: f32, h: f32) -> Bounds { - Bounds::new(point(px(0.), px(y)), size(px(10.), px(h))) + fn at(top: f32, height: f32, width: f32) -> Bounds { + Bounds::new(point(px(0.), px(top)), size(px(width), px(height))) + } + + fn rendered(spans: &[Span]) -> Vec { + spans + .iter() + .filter_map(|span| match span { + Span::Row(index) => Some(*index), + Span::Space { .. } => None, + }) + .collect() } #[test] - fn only_rows_more_than_a_screen_away_are_skipped() { - let view = at(100., 500.); - assert!(!away(at(100., 100.), px(0.), view)); - assert!(!away(at(1000., 100.), px(0.), view)); - assert!(away(at(1200., 100.), px(0.), view)); - assert!(away(at(-600., 100.), px(0.), view)); - // Scrolled 700 px down since: the row that was far below is now on screen. - assert!(!away(at(1200., 100.), px(-700.), view)); + fn ten_thousand_rows_build_only_nearby_elements_on_the_first_frame() { + let list = Cull::default(); + let mut count = 0; + list.column( + &ScrollHandle::new(), + 10_000, + 8., + |_| false, + |_| { + count += 1; + div().h(px(96.)).mb(px(8.)) + }, + ); + assert!(count <= 17, "built {count} rows before the first layout"); + let spans = list + .0 + .borrow_mut() + .plan(at(0., 800., 600.), px(0.), 10_000, 8., |_| false); + assert!(spans.len() <= count + 1, "hidden rows share one spacer"); } #[test] - fn nothing_is_skipped_before_the_rows_are_known() { - let cull = Cull::default(); - cull.0.borrow_mut().rows = (0..10).map(|i| at(i as f32 * 2000., 100.)).collect(); - // No viewport yet (the first frame), or another number of rows: every row is drawn. - let far = cull.far(&ScrollHandle::new(), 10); - assert!((0..10).all(|i| far(i).is_none())); - let far = cull.far(&ScrollHandle::new(), 11); - assert!((0..11).all(|i| far(i).is_none())); + fn large_scroll_jumps_reach_the_last_rows_and_return_to_the_first() { + let mut state = Drawn::default(); + let view = at(0., 500., 600.); + state.plan(view, px(0.), 10_000, 8., |_| false); + state.width = view.size.width; + let end = state.plan(view, px(-1_039_500.), 10_000, 8., |_| false); + assert!(rendered(&end).contains(&9_999)); + assert!(rendered(&end).len() < 20); + assert_eq!( + rendered(&state.plan(view, px(0.), 10_000, 8., |_| false))[0], + 0 + ); + } + + #[test] + fn resizing_and_appending_keep_render_work_bounded_and_retained_rows_available() { + let mut state = Drawn::default(); + let view = at(0., 500., 600.); + state.plan(view, px(0.), 5_000, 8., |_| false); + state.width = view.size.width; + state.heights[100] = px(900.); + let spans = state.plan(at(0., 500., 300.), px(0.), 10_000, 8., |index| { + index == 9_000 + }); + assert_eq!(state.heights[100], px(104.)); + assert!(rendered(&spans).contains(&9_000)); + assert!(spans.len() < 20); + assert_eq!(state.heights.len(), 10_000); + } + + #[test] + fn measurements_include_wrapping_and_reveal_spacers_after_headers_move() { + let mut state = Drawn::default(); + let view = at(0., 500., 600.); + state.plan(view, px(0.), 100, 8., |_| false); + let spans = vec![ + Span::Row(0), + Span::Space { + rows: 1..100, + height: px(10_296.), + }, + ]; + assert!(state.record( + &spans, + &[at(0., 240., 600.), at(240., 10_296., 600.)], + view, + px(0.) + )); + assert_eq!(state.heights[0], px(240.)); + assert!(rendered(&state.plan(view, px(0.), 100, 8., |_| false)).contains(&1)); + let list = Cull::default(); + list.0.borrow_mut().heights = vec![px(400.); 100]; + list.reset(); + assert!(list.0.borrow().heights.is_empty()); + } +} + +#[cfg(all(test, target_os = "windows"))] +mod desktop_tests { + use super::*; + use gpui::{ + prelude::*, AppContext, Application, Context, Render, Window, WindowBounds, WindowOptions, + }; + use std::time::Duration; + + struct ListWindow { + list: Cull, + scroll: ScrollHandle, + rendered: Vec, + } + + impl Render for ListWindow { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + self.rendered.clear(); + let rows = self.list.column( + &self.scroll, + 10_000, + 8., + |_| false, + |index| { + self.rendered.push(index); + div() + .h(px(if index % 2 == 0 { 72. } else { 180. })) + .mb(px(8.)) + .child(format!("Row {index}")) + }, + ); + div() + .id("viewport") + .size_full() + .overflow_y_scroll() + .track_scroll(&self.scroll) + .child(div().pt(px(320.)).child(rows)) + } + } + + #[test] + #[ignore = "requires an interactive desktop and graphics adapter"] + fn desktop_list_renders_the_viewport_after_scrollbar_jumps() { + Application::new().run(|cx| { + let window = cx + .open_window( + WindowOptions { + window_bounds: Some(WindowBounds::Windowed(Bounds::new( + point(px(0.), px(0.)), + size(px(600.), px(500.)), + ))), + ..WindowOptions::default() + }, + |_, cx| { + cx.new(|_| ListWindow { + list: Cull::default(), + scroll: ScrollHandle::new(), + rendered: Vec::new(), + }) + }, + ) + .unwrap(); + cx.spawn(async move |cx| { + for step in 0..3 { + cx.background_executor() + .timer(Duration::from_millis(300)) + .await; + window + .update(cx, |view, _, cx| { + assert!( + view.rendered.len() < 40, + "rendered {} rows", + view.rendered.len() + ); + let wanted = if step == 1 { 9_999 } else { 0 }; + assert!( + view.rendered.contains(&wanted), + "row {wanted} missing: {:?}", + view.rendered + ); + let measured = view.list.0.borrow(); + let mut top = measured.top; + for (index, height) in measured.heights.iter().enumerate() { + if top < view.scroll.bounds().bottom() + && top + *height > view.scroll.bounds().top() + { + assert!( + view.rendered.contains(&index), + "visible row {index} was a spacer" + ); + } + top += *height; + } + if step == 1 { + assert!( + top <= view.scroll.bounds().bottom() + px(1.), + "the last row stayed below the viewport by {:?}", + top - view.scroll.bounds().bottom() + ); + } + drop(measured); + let offset = if step == 0 { + -view.scroll.max_offset().height + } else { + px(0.) + }; + view.scroll.set_offset(point(px(0.), offset)); + cx.notify(); + }) + .unwrap(); + } + cx.update(|cx| cx.quit()).unwrap(); + }) + .detach(); + }); } } diff --git a/launcher/src/main.rs b/launcher/src/main.rs index db2309dd6..0c824bb44 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -366,6 +366,9 @@ impl Launcher { self.switches += 1; self.content_scroll = Scrollbar::default(); self.long_list = cull::Cull::default(); + if page == Page::Mods { + self.mods.reset_lists(); + } } self.picker_open = false; } @@ -2901,7 +2904,7 @@ impl Launcher { )) } Load::Ready(r) if r.is_empty() => return page.child(centered("No releases yet.", &t)), - Load::Ready(r) => r.clone(), + Load::Ready(r) => r, }; // A hundred releases: only the rows near the screen are drawn. let keep = |i: usize| { @@ -3138,7 +3141,7 @@ impl Launcher { ), ) } - Load::Ready(r) => r.clone(), + Load::Ready(r) => r, }; let list = self.long_list.clone().column( &self.content_scroll.handle, diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs index ccd0b3a4e..6346f8a0b 100644 --- a/launcher/src/modpacks_page.rs +++ b/launcher/src/modpacks_page.rs @@ -50,6 +50,7 @@ impl Launcher { self.pack_busy = false; match result { Ok(pack) => { + self.mods.report_list.reset(); self.pack_open = Some(pack.slug.clone()); self.packs.retain(|p| p.slug != pack.slug); self.packs.push(*pack); @@ -127,6 +128,7 @@ impl Launcher { /// Reads the imported packs, once (the sidebar and the Modpacks tab both show them). pub(super) fn load_packs(&mut self) { if self.packs_loaded.is_none() { + self.mods.report_list.reset(); self.packs = modpacks::list(); if self.pack_open.is_none() { self.pack_open = self.packs.first().map(|p| p.slug.clone()); @@ -193,6 +195,7 @@ impl Launcher { button(format!("open-{slug}"), "Open", Kind::Ghost, &t) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.pack_open = Some(slug.clone()); + this.mods.report_list.reset(); cx.notify(); })) .into_any_element() @@ -317,6 +320,7 @@ impl Launcher { Ok(()) => { this.packs.retain(|p| p.slug != slug); this.pack_open = this.packs.first().map(|p| p.slug.clone()); + this.mods.report_list.reset(); } Err(e) => this.pack_error = Some(e), } @@ -354,12 +358,13 @@ impl Launcher { move |value, _, cx| { let _ = this.update(cx, |this, cx| { this.pack_filter = value; + this.mods.report_list.reset(); cx.notify(); }); } }); - let mut list = div().flex().flex_col(); - for (i, r) in rows.iter().enumerate() { + let row = |i: usize| { + let r = rows[i]; let color = match r.status { Status::Ported => t.success, Status::Partial => t.accent, @@ -372,7 +377,7 @@ impl Launcher { format!("{} ({})", r.name, r.key) }; let detail = format!("{} · {} · {}: {}", r.class, r.tier, r.license, r.reason); - list = list.child(index_row( + index_row( i + 1, name, Some(detail.into_any_element()), @@ -383,8 +388,15 @@ impl Launcher { .into_any_element(), ), &t, - )); - } + ) + }; + let list = self.mods.report_list.column( + &self.content_scroll.handle, + rows.len(), + 8., + |_| false, + row, + ); Some( div() .flex() diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs index 00162f930..5c3e1b0c6 100644 --- a/launcher/src/mods_page.rs +++ b/launcher/src/mods_page.rs @@ -54,6 +54,9 @@ pub(super) struct Mods { searching: bool, searched: bool, results: Vec, + results_list: cull::Cull, + installed_list: cull::Cull, + pub(super) report_list: cull::Cull, more: bool, error: Option, installed: Vec, @@ -72,6 +75,12 @@ pub(super) struct Mods { } impl Mods { + pub(super) fn reset_lists(&self) { + self.results_list.reset(); + self.installed_list.reset(); + self.report_list.reset(); + } + /// Whether the Modpacks tab is open (the sidebar marks the pack shown there). pub(super) fn on_modpacks(&self) -> bool { self.kind == PackKind::Modpack @@ -94,6 +103,9 @@ impl Mods { searching: false, searched: false, results: Vec::new(), + results_list: cull::Cull::default(), + installed_list: cull::Cull::default(), + report_list: cull::Cull::default(), more: false, error: None, installed: Vec::new(), @@ -158,6 +170,7 @@ impl Launcher { self.go(Page::Mods); if slug.is_some() { self.pack_open = slug; + self.mods.report_list.reset(); } if self.mods.kind != PackKind::Modpack { self.mods.kind = PackKind::Modpack; @@ -203,6 +216,7 @@ impl Launcher { m.busy = None; m.message = Some(result); m.installed = installed::Installed::load(&backend::game_home()).entries; + m.installed_list.reset(); if modpack { // The Modpacks page reads its list again. self.packs_loaded = None; @@ -249,6 +263,8 @@ impl Launcher { if offset == 0 { m.results.clear(); m.more = false; + m.results_list.reset(); + m.installed_list.reset(); } let query = Query { everything: m.everything, @@ -296,7 +312,16 @@ impl Launcher { .and_then(|source| { java::check_project(&home, &*source, &p, everything, &|_| {}) }) - .map(|(_, c)| Box::new(c)); + .map(|(version, check)| { + let _ = tx.send(Event::Loaded( + super::mods_project::Loaded::Checked( + (p.source, p.id.clone()), + version.id, + check.verdict, + ), + )); + Box::new(check) + }); let _ = tx.send(Event::Checked((p.source, p.id), result)); } }); @@ -608,8 +633,8 @@ impl Launcher { return None; } let busy = self.mods.busy.is_some(); - let mut list = div().flex().flex_col(); - for (i, e) in entries.into_iter().enumerate() { + let row = |i: usize| { + let e = entries[i]; let key = (e.source, e.project.clone()); let mut right = div().flex().items_center().gap(px(8.)); if let Some(number) = self.mods.updates.get(&key) { @@ -654,6 +679,7 @@ impl Launcher { installed::remove(&home, &id).map(|e| format!("Removed {}.", e.title)), ); this.mods.installed = installed::Installed::load(&home).entries; + this.mods.installed_list.reset(); this.mods.confirm_remove = None; } else { this.mods.confirm_remove = Some(id.clone()); @@ -689,14 +715,21 @@ impl Launcher { .font_family(theme::MONO) .child(format!("checked: {}", short_sum(&e.checksum))), ); - list = list.child(index_row( + index_row( i + 1, e.title.clone(), Some(detail.into_any_element()), Some(right.into_any_element()), &t, - )); - } + ) + }; + let list = self.mods.installed_list.column( + &self.content_scroll.handle, + entries.len(), + 8., + |index| self.mods.confirm_remove.as_ref() == Some(&entries[index].project), + row, + ); Some( div() .flex() @@ -709,8 +742,6 @@ impl Launcher { fn mods_results(&mut self, cx: &mut Context) -> Div { let t = self.theme; - let found = self.mods.results.clone(); - let icons: Vec = found.iter().map(|p| self.mods_icon(p, 56.)).collect(); let m = &self.mods; if let Some(e) = &m.error { return div().child(notice(e.clone(), &t)); @@ -725,10 +756,15 @@ impl Launcher { }; return centered(line, &t); } - let busy = m.busy.as_ref().map(|b| b.0.as_str()); - let mut icons = icons.into_iter(); - let mut list = div().flex().flex_col(); - for (i, p) in m.results.iter().enumerate() { + let result_count = m.results.len(); + let rows = m.results_list.clone(); + let scroll = self.content_scroll.handle.clone(); + let row = |i: usize| { + let project = self.mods.results[i].clone(); + let icon = self.mods_icon(&project, 56.); + let p = &project; + let m = &self.mods; + let busy = m.busy.as_ref().map(|b| b.0.as_str()); let support = m.support(p); let checking = p.kind == PackKind::Mod && matches!( @@ -813,21 +849,23 @@ impl Launcher { .items_center() .gap(px(12.)) .cursor_pointer() - .child(icons.next().expect("one icon per result")) + .child(icon) .child(div().hover(|s| s.underline()).child(p.title.clone())) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.mods_open(open.clone()); cx.notify(); })); - list = list.child(index_row( + index_row( i + 1, name, Some(detail.into_any_element()), Some(right.into_any_element()), &t, - )); - } + ) + }; + let list = rows.column(&scroll, result_count, 8., |_| false, row); let mut out = div().flex().flex_col().child(list); + let m = &self.mods; if m.more { let mut more = button("mods-more", "More", Kind::Ghost, &t); if m.searching { diff --git a/launcher/src/mods_project.rs b/launcher/src/mods_project.rs index c66cf174a..ad75f58cd 100644 --- a/launcher/src/mods_project.rs +++ b/launcher/src/mods_project.rs @@ -19,6 +19,7 @@ use horizon_launcher::browser::{ }; use std::collections::{HashMap, HashSet}; use std::path::PathBuf; +use std::sync::Arc; /// A project page's tabs. #[derive(Clone, Copy, PartialEq, Eq)] @@ -38,8 +39,17 @@ const TABS: [(Tab, &str); 3] = [ pub(super) struct Opened { pub(super) project: Project, tab: Tab, - details: Option>, - versions: Option, String>>, + details: Option, String>>, + versions: Option, String>>, + version_list: cull::Cull, + checked_versions: HashMap, +} + +/// Cached verdicts are read with the version request, never while drawing a frame. +#[derive(Clone)] +pub(super) struct ProjectVersion { + version: Version, + verdict: Option, } /// The project page, filters and images' share of the Mods page's state. @@ -58,7 +68,12 @@ pub(super) struct Browse { /// What the background sends this module. pub(super) enum Loaded { Details((SourceId, String), Result), - Versions((SourceId, String), Result, String>), + Versions((SourceId, String), Result, String>), + Checked( + (SourceId, String), + String, + horizon_port_pack::check::Verdict, + ), Image((String, u32), Option), Tags((SourceId, PackKind), Result), } @@ -77,12 +92,20 @@ impl Launcher { match loaded { Loaded::Details(key, d) => { if let Some(o) = open(b, &key) { - o.details = Some(d); + o.details = Some(d.map(Arc::new)); } } Loaded::Versions(key, v) => { if let Some(o) = open(b, &key) { - o.versions = Some(v); + o.versions = Some(v.map(Arc::from)); + o.apply_checks(); + o.version_list.reset(); + } + } + Loaded::Checked(key, version, verdict) => { + if let Some(o) = open(b, &key) { + o.checked_versions.insert(version, verdict); + o.apply_checks(); } } Loaded::Image(key, path) => { @@ -106,7 +129,21 @@ impl Launcher { }; let d = source.details(&p); let _ = tx.send(Event::Loaded(Loaded::Details(key.clone(), d))); - let v = source.versions(&p); + let v = source.versions(&p).map(|versions| { + let home = backend::game_home(); + versions + .into_iter() + .map(|version| { + let verdict = version.file().and_then(|file| { + (p.kind == PackKind::Mod) + .then(|| java::cached(&home, file)) + .flatten() + .map(|check| check.verdict) + }); + ProjectVersion { version, verdict } + }) + .collect() + }); let _ = tx.send(Event::Loaded(Loaded::Versions(key, v))); }); self.mods.browse.open = Some(Opened { @@ -114,6 +151,8 @@ impl Launcher { tab: Tab::Description, details: None, versions: None, + version_list: cull::Cull::default(), + checked_versions: HashMap::new(), }); } @@ -361,6 +400,7 @@ impl Launcher { )); let details = o.details.clone(); let versions = o.versions.clone(); + let version_list = o.version_list.clone(); let mut meta = vec![format!("{} downloads", thousands(p.downloads))]; if let Some(Ok(d)) = &details { meta.push(format!("{} followers", thousands(d.followers))); @@ -551,9 +591,13 @@ impl Launcher { Tab::Versions => match &versions { None => centered("Loading…", &t), Some(Err(e)) => notice(e.clone(), &t), - Some(Ok(list)) => { - let mut rows = div().flex().flex_col(); - for (i, v) in list.iter().take(50).enumerate() { + Some(Ok(list)) => version_list.column( + &self.content_scroll.handle, + list.len().min(50), + 8., + |_| false, + |i| { + let v = &list[i].version; let file = v.file(); let mut detail = vec![ v.published.get(..10).unwrap_or_default().to_string(), @@ -570,27 +614,33 @@ impl Launcher { if let Some(f) = file { detail.push(format!("{} · {:.1} MB", f.name, f.size as f64 / 1e6)); } - let checked = file.and_then(|f| { - (p.kind == PackKind::Mod) - .then(|| java::cached(&backend::game_home(), f)) - .flatten() - }); - rows = rows.child(index_row( + index_row( i + 1, v.number.clone(), Some(detail.join(" · ").into_any_element()), - checked.map(|c| { - caps(c.verdict.label()) - .text_color(t.muted) - .into_any_element() + list[i].verdict.as_ref().map(|verdict| { + caps(verdict.label()).text_color(t.muted).into_any_element() }), &t, - )); - } - rows - } + ) + }, + ), }, }; Some(page.child(body)) } } + +impl Opened { + /// A check can finish before or after the version request; retain either event order. + fn apply_checks(&mut self) { + let Some(Ok(versions)) = &mut self.versions else { + return; + }; + for row in Arc::make_mut(versions) { + if let Some(verdict) = self.checked_versions.get(&row.version.id) { + row.verdict = Some(*verdict); + } + } + } +} From 094d5c8e16c3b3deef2f1b7bb71c7d4b4d213bf2 Mon Sep 17 00:00:00 2001 From: Ryan B Date: Sat, 24 Oct 2026 14:03:32 -0400 Subject: [PATCH 06/12] fix: let server text fields receive debug-bound characters Co-Authored-By: OpenAI Codex gpt-6.1-sol --- crates/horizon-client/src/game/debug_keys.rs | 64 ++++++++++++++++++-- 1 file changed, 60 insertions(+), 4 deletions(-) diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs index a94f3f01b..5a3dcbd01 100644 --- a/crates/horizon-client/src/game/debug_keys.rs +++ b/crates/horizon-client/src/game/debug_keys.rs @@ -20,6 +20,15 @@ use winit::keyboard::KeyCode; const YELLOW: u32 = 0xFF_FF55; const RED: u32 = 0xFF_5555; +/// Title text fields receive presses before debug shortcuts, but releases must +/// still clear a debug modifier held before the field gained focus. +fn title_takes_text_key( + title: Option<&mut horizon_client::title::Title>, + action: KeyAction, +) -> bool { + action != KeyAction::Release && title.is_some_and(|title| title.focused_field().is_some()) +} + /// The game as `KeyboardHandler` sees it while it runs one key event. struct Host<'g, 'a> { game: &'g mut Game<'a>, @@ -84,10 +93,12 @@ impl Game<'_> { } // Screens with a text box take every key press first // (EditBox.keyPressed); releases still reach KeyboardHandler. - let typing = matches!( - self.screen, - Screen::Chat | Screen::Options | Screen::WorldOptions | Screen::CommandBlock - ) || self.sign_edit.is_some() + let typing = title_takes_text_key(self.title.as_mut(), action) + || matches!( + self.screen, + Screen::Chat | Screen::Options | Screen::WorldOptions | Screen::CommandBlock + ) + || self.sign_edit.is_some() || self.book.is_some() || (self.screen == Screen::Creative && self.creative_screen.tab().search) || self.recipe_search_focused() @@ -813,3 +824,48 @@ impl Game<'_> { g } } + +#[cfg(test)] +mod tests { + use super::*; + use horizon_client::{ + multiplayer::Screen as ServerScreen, + title::{Mode, Title}, + }; + + #[test] + fn server_fields_take_debug_bound_text_keys_but_not_releases() { + let root = std::env::temp_dir().join(format!("horizon-debug-title-{}", std::process::id())); + let mut title = Title::new(root.join("saves"), &root); + for screen in [ + ServerScreen::Direct { + address: String::new(), + }, + ServerScreen::Edit { + index: None, + name: String::new(), + address: String::new(), + focus: 0, + }, + ServerScreen::Edit { + index: Some(0), + name: String::new(), + address: String::new(), + focus: 1, + }, + ServerScreen::friend(), + ] { + title.mode = Mode::Multiplayer(screen); + for action in [KeyAction::Press, KeyAction::Repeat] { + assert!(title_takes_text_key(Some(&mut title), action)); + } + assert!(!title_takes_text_key(Some(&mut title), KeyAction::Release)); + // A period bound to the debug modifier must reach the field. + title.type_text("mc.example.org"); + assert_eq!(title.focused_field().unwrap().1, "mc.example.org"); + } + title.mode = Mode::Main; + assert!(!title_takes_text_key(Some(&mut title), KeyAction::Press)); + assert!(!title_takes_text_key(None, KeyAction::Press)); + } +} From 1dffadeea30a4d60e035bac16d0fd510c59f70f2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 19:19:34 +0200 Subject: [PATCH 07/12] Pack screen: draw each pack's own pack.png instead of unknown_pack PackSelectionScreen.loadPackIcon registers every pack's pack.png as a texture; Horizon never loaded them, so every pack (Default, Programmer Art, High Contrast and the player's own) fell back to unknown_pack, the cobblestone. The icons now load from each pack when the screen opens and are written into 64 new 128x128 HUD atlas slots, one per icon on screen. The vanilla pack's icon is the client JAR's pack.png, which horizon-prepare now copies into the prepared resources. Co-Authored-By: Claude Opus 5.5 --- .../examples/probe/pack_screen_fixture.rs | 8 +- crates/horizon-client/src/game/packs.rs | 16 +- crates/horizon-client/src/hud.rs | 17 +- crates/horizon-client/src/options_ui.rs | 4 +- crates/horizon-client/src/pack_screen.rs | 166 +++++++++++++++++- crates/horizon-client/src/packs.rs | 55 +++++- crates/horizon-prepare/src/lib.rs | 6 +- 7 files changed, 249 insertions(+), 23 deletions(-) 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/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ae2de00e6..82ba69e9d 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}, }; @@ -53,14 +53,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 +69,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 +84,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<'_> { 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/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..0ba1dc1f5 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, @@ -983,6 +985,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-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")?; From 6d81b98f183e62529c246bf72da23a69972f09f3 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 20:22:10 +0200 Subject: [PATCH 08/12] launcher: keep one landscape per width step, free replaced ones, keep the top bar's wordmark off Windows - A resize re-baked Home's landscape every 6 px and never removed the old images from the window's sprite atlas (GPUI keeps an image there until `drop_image`): dragging a window wider piled up textures of up to ~14 MB each. The landscape now grows in steps of 64 texels, is kept when the window narrows, and the one it replaces leaves the atlas on the next frame. - The landscape was laid out from the width (sun at 0.68 w, one random stream for every part), so it reshuffled hills, trees and the sun at each step of a resize. Each part now has its own stream drawn left to right: a wider landscape only adds columns. - macOS and Linux keep their system title bar, so the top bar keeps the mark and "HORIZON" there (docs/design-system.md, Navigation); only the Windows title bar carries them. - The before/after screenshots were for the pull request, not the launcher's docs. Co-Authored-By: Claude Opus 5.5 --- launcher/docs/launcher-window-after.png | Bin 97826 -> 0 bytes launcher/docs/launcher-window-before.png | Bin 168449 -> 0 bytes launcher/src/art.rs | 181 ++++++++++++----------- launcher/src/main.rs | 21 ++- launcher/src/titlebar.rs | 5 +- 5 files changed, 117 insertions(+), 90 deletions(-) delete mode 100644 launcher/docs/launcher-window-after.png delete mode 100644 launcher/docs/launcher-window-before.png diff --git a/launcher/docs/launcher-window-after.png b/launcher/docs/launcher-window-after.png deleted file mode 100644 index 59633eedb890ff45fcdaf4ce142511d524434f99..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 97826 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
7_CFxkE^*7Cjy*7wAfJKx;_|KqcB_>#3&RSc;& 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 diff --git a/launcher/src/art.rs b/launcher/src/art.rs index 3cc85ac96..d61214c11 100644 --- a/launcher/src/art.rs +++ b/launcher/src/art.rs @@ -2,47 +2,36 @@ //! and the landscape behind Home (the vanilla grass block is `browser::images::grass_block`). //! GPUI samples images smoothly, so every image is baked at the window's scale with each texel a //! whole block of device pixels, and drawn at exactly its size: the edges stay sharp. Each image -//! is reused until its appearance, scale or landscape width changes. -use gpui::RenderImage; +//! is made once per appearance and scale, then reused; Home's landscape is made again only when +//! the window grows wider than it. +use gpui::{RenderImage, Window}; use horizon_theme as tokens; use std::collections::HashMap; use std::sync::Arc; -/// What an image is, to find it again. -#[derive(Clone, PartialEq, Eq, Hash)] -enum Key { - Stone { - dark: bool, - scale: u32, - }, - Scene { - dark: bool, - scale: u32, - width: usize, - }, -} - #[derive(Default)] pub struct Art { - made: HashMap>, + /// The stone texture for each appearance and scale. + stones: HashMap<(bool, u32), Arc>, + /// Home's landscape: its appearance and scale, and its width in texels. + scene: Option<((bool, u32), usize, Arc)>, + /// Landscapes replaced since the last frame, still in the window's sprite atlas. + replaced: Vec>, } /// The stone texture comes in squares of this many logical pixels (4 by 4 tiles). pub const STONE: f32 = tokens::TILE_TEXEL * (tokens::TILE_TEXELS * 4) as f32; -/// Home's landscape: texels of this many logical pixels, and its size in texels. +/// Home's landscape: texels of this many logical pixels, and its height in texels. Its width +/// grows in steps of `SCENE_STEP` texels, so resizing a window rarely makes another. pub const SCENE_TEXEL: f32 = 6.; pub const SCENE_HEIGHT: usize = 56; -const MIN_SCENE_WIDTH: f32 = 10.; +const SCENE_STEP: usize = 64; impl Art { /// The page's stone texture, for a window at `scale`. pub fn stone(&mut self, page: u32, dark: bool, scale: f32) -> Arc { - let key = Key::Stone { - dark, - scale: scale_key(scale), - }; - self.made - .entry(key) + self.stones + .entry((dark, scale_key(scale))) .or_insert_with(|| { let n = tokens::TILE_TEXELS * 4; bake(&opaque(&stone(page, n)), n, n, tokens::TILE_TEXEL, scale) @@ -50,33 +39,30 @@ impl Art { .clone() } - /// Home's landscape at the banner's width, without stretching its square texels. - /// Only the current size is retained, so resizing cannot accumulate large images. + /// Home's landscape, at least `width` logical pixels wide (the banner clips the rest), and + /// its width: a sunset in the dark appearance, a dawn in the light one. pub fn scene(&mut self, dark: bool, scale: f32, width: f32) -> (Arc, f32) { - let width = (width / SCENE_TEXEL).ceil().max(MIN_SCENE_WIDTH) as usize; - let key = Key::Scene { - dark, - scale: scale_key(scale), - width, - }; - if !self.made.contains_key(&key) { - self.made.retain(|key, _| matches!(key, Key::Stone { .. })); + let key = (dark, scale_key(scale)); + let texels = (width / SCENE_TEXEL).ceil().max(1.) as usize; + if !matches!(&self.scene, Some((k, w, _)) if *k == key && *w >= texels) { + let w = texels.next_multiple_of(SCENE_STEP); + let palette = if dark { &SUNSET } else { &DAWN }; + let texels = opaque(&scene(palette, 3, w, SCENE_HEIGHT)); + let image = bake(&texels, w, SCENE_HEIGHT, SCENE_TEXEL, scale); + if let Some((_, _, old)) = self.scene.replace((key, w, image)) { + self.replaced.push(old); + } + } + let (_, w, image) = self.scene.as_ref().expect("made above"); + (image.clone(), *w as f32 * SCENE_TEXEL) + } + + /// Frees the landscapes replaced since the last frame: GPUI keeps an image in the window's + /// sprite atlas until it is dropped there. + pub fn free_replaced(&mut self, window: &mut Window) { + for image in self.replaced.drain(..) { + let _ = window.drop_image(image); } - let image = self - .made - .entry(key) - .or_insert_with(|| { - let palette = if dark { &SUNSET } else { &DAWN }; - bake( - &opaque(&scene(palette, 3, width, SCENE_HEIGHT)), - width, - SCENE_HEIGHT, - SCENE_TEXEL, - scale, - ) - }) - .clone(); - (image, width as f32 * SCENE_TEXEL) } } @@ -220,8 +206,14 @@ pub const DAWN: Palette = Palette { /// A blocky landscape, `w` by `h` texels: banded sky, a sun half set behind the far hills and cut /// into slices like Horizon's mark, flat clouds, three ridges of hills and a few square trees. +/// Each part draws from its own generator from left to right, so a wider landscape only adds +/// columns: the first `w` are the same at every width, and a resized window keeps its view. pub fn scene(p: &Palette, seed: u32, w: usize, h: usize) -> Vec { - let mut rng = Rng(seed.wrapping_mul(0x2545_f491) | 1); + let mut seeds = Rng(seed.wrapping_mul(0x2545_f491) | 1); + let mut rng = || { + seeds.next(); + Rng(seeds.0) + }; let mut out = vec![0; w * h]; let horizon = h * 62 / 100; let band = horizon as f32 / p.sky.len() as f32; @@ -244,20 +236,23 @@ pub fn scene(p: &Palette, seed: u32, w: usize, h: usize) -> Vec { } } }; - for _ in 0..4 { - let cx = (rng.next() * w as f32) as isize; - let cy = (horizon as f32 * (0.12 + rng.next() * 0.4)) as isize; - let cw = 10 + (rng.next() * 14.) as usize; - let under = p.sky[((cy as f32 / band) as usize + 1).min(p.sky.len() - 1)]; - let c = mix(under, 0xffffff, 0.12); - rect(&mut out, cx, cy, cw, 2, c); - rect(&mut out, cx + 3, cy - 2, cw.saturating_sub(6), 2, c); + // Four clouds in every stretch of `CLOUDS` texels. + const CLOUDS: usize = 220; + let mut clouds = rng(); + for stretch in 0..w.div_ceil(CLOUDS) { + for _ in 0..4 { + let cx = (stretch * CLOUDS) as isize + (clouds.next() * CLOUDS as f32) as isize; + let cy = (horizon as f32 * (0.12 + clouds.next() * 0.4)) as isize; + let cw = 10 + (clouds.next() * 14.) as usize; + let under = p.sky[((cy as f32 / band) as usize + 1).min(p.sky.len() - 1)]; + let c = mix(under, 0xffffff, 0.12); + rect(&mut out, cx, cy, cw, 2, c); + rect(&mut out, cx + 3, cy - 2, cw.saturating_sub(6), 2, c); + } } + // The sun, where it was when the landscape had one width (two thirds of 220 texels). let r = (h as f32 * 0.2) as isize; - let (cx, cy) = ( - (w as f32 * 0.68) as isize, - horizon as isize - (h as f32 * 0.11) as isize, - ); + let (cx, cy) = (149, horizon as isize - (h as f32 * 0.11) as isize); for dy in -r..=0 { let half = ((r * r - dy * dy) as f32).sqrt().round() as isize; let t = (dy + r) as f32 / r as f32; @@ -272,7 +267,7 @@ pub fn scene(p: &Palette, seed: u32, w: usize, h: usize) -> Vec { rect(&mut out, cx - half, cy + dy, (half * 2) as usize, 1, c); } } - let ridge = |rng: &mut Rng, base: f32, amp: f32, rough: f32| -> Vec { + let ridge = |mut rng: Rng, base: f32, amp: f32, rough: f32| -> Vec { let (mut y, mut v) = (base, 0.); (0..w) .map(|x| { @@ -298,7 +293,7 @@ pub fn scene(p: &Palette, seed: u32, w: usize, h: usize) -> Vec { ]; let mut near = Vec::new(); for (c, base, amp, rough, top) in layers { - let hs = ridge(&mut rng, base, amp, rough); + let hs = ridge(rng(), base, amp, rough); for (x, &y) in hs.iter().enumerate() { for yy in y.min(h)..h { out[yy * w + x] = c; @@ -309,9 +304,12 @@ pub fn scene(p: &Palette, seed: u32, w: usize, h: usize) -> Vec { } near = hs; } - for _ in 0..w / 26 { - let tx = 4 + (rng.next() * (w - 10) as f32) as isize; - let ty = near[tx as usize] as isize; + // A tree somewhere in every 26 texels of the near hills. + let mut trees = rng(); + for cell in 0..w.div_ceil(26) { + let tx = cell * 26 + 2 + (trees.next() * 22.) as usize; + let Some(&ty) = near.get(tx) else { break }; + let (tx, ty) = (tx as isize, ty as isize); rect(&mut out, tx - 2, ty - 8, 5, 5, p.trees); rect(&mut out, tx - 1, ty - 10, 3, 2, p.trees); rect(&mut out, tx, ty - 3, 1, 3, p.trees); @@ -343,30 +341,37 @@ mod tests { } #[test] - fn landscape_fills_the_banner_at_narrow_and_wide_window_sizes() { + fn the_landscape_covers_the_banner_and_is_made_again_only_when_it_grows() { let mut art = Art::default(); - for banner_width in [696., 916., 1633.] { - let (image, drawn_width) = art.scene(true, 2., banner_width); - assert!(drawn_width >= banner_width); - assert!(drawn_width - banner_width < SCENE_TEXEL); - assert_eq!(image.size(0).width.0, (drawn_width * 2.) as i32); - assert_eq!( - image.size(0).height.0, - (SCENE_HEIGHT as f32 * SCENE_TEXEL * 2.) as i32 - ); + let stone = art.stone(0x0f0d17, true, 2.); + let (first, drawn) = art.scene(true, 2., 700.); + assert!(drawn >= 700.); + assert_eq!(first.size(0).width.0, (drawn * 2.) as i32); + assert_eq!( + first.size(0).height.0, + (SCENE_HEIGHT as f32 * SCENE_TEXEL * 2.) as i32 + ); + // A step wide: a few pixels more or a narrower window keep it. + for width in [drawn, 400.] { + assert!(Arc::ptr_eq(&first, &art.scene(true, 2., width).0)); } + let (wider, wider_drawn) = art.scene(true, 2., 1900.); + assert!(!Arc::ptr_eq(&first, &wider) && wider_drawn >= 1900.); + assert!(Arc::ptr_eq(&art.replaced[0], &first)); + assert!(Arc::ptr_eq(&stone, &art.stone(0x0f0d17, true, 2.))); } #[test] - fn resizing_replaces_the_landscape_and_preserves_the_stone_cache() { - let mut art = Art::default(); - let stone = art.stone(0x0f0d17, true, 1.); - let (first, _) = art.scene(true, 1., 900.); - let (reused, _) = art.scene(true, 1., 900.); - assert!(Arc::ptr_eq(&first, &reused)); - let (resized, _) = art.scene(true, 1., 1500.); - assert!(!Arc::ptr_eq(&first, &resized)); - assert_eq!(art.made.len(), 2); - assert!(Arc::ptr_eq(&stone, &art.stone(0x0f0d17, true, 1.))); + fn a_wider_landscape_only_adds_columns() { + let (h, narrow, wide) = (SCENE_HEIGHT, 150, 400); + let a = scene(&SUNSET, 3, narrow, h); + let b = scene(&SUNSET, 3, wide, h); + for y in 0..h { + assert_eq!( + a[y * narrow..(y + 1) * narrow], + b[y * wide..y * wide + narrow], + "row {y}" + ); + } } } diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 842d21b3b..9a97b8e8f 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -1314,7 +1314,8 @@ fn megabytes(bytes: u64) -> String { // ----- Pages ------------------------------------------------------------------------------------- impl Launcher { - /// The top bar: the pages with their icons, then the account and Settings. + /// The top bar: the mark and the name over the sidebar (in the title bar on Windows), the + /// pages with their icons, then the account playing and the Settings button. fn topbar(&mut self, cx: &mut Context) -> Div { let t = self.theme; let mut nav = div().flex().flex_none().h_full().gap(px(2.)); @@ -1452,6 +1453,23 @@ impl Launcher { .bg(t.side) .border_b_2() .border_color(t.outline) + // Where the title bar is drawn here (Windows), it carries the mark and the name. + .when(!titlebar::DRAWN, |bar| { + bar.child( + div() + .flex() + .flex_none() + .items_center() + .gap(px(10.)) + .w(px(theme::SIDEBAR - 18.)) + .child(mark(24., &t)) + .child( + blocks::pixel(20., FontWeight::SEMIBOLD) + .text_color(t.ink) + .child("HORIZON"), + ), + ) + }) .child(nav) .child( div() @@ -3251,6 +3269,7 @@ impl Render for Launcher { Page::Notes => self.notes_page(cx), Page::Settings => self.settings_page(cx), }; + self.art.free_replaced(window); // The new page fades in and rises a few pixels. let content = div() .relative() diff --git a/launcher/src/titlebar.rs b/launcher/src/titlebar.rs index 3ff88a3ef..3c2a78ea4 100644 --- a/launcher/src/titlebar.rs +++ b/launcher/src/titlebar.rs @@ -2,10 +2,13 @@ use crate::theme::Theme; use gpui::{Div, TitlebarOptions, Window}; +/// Whether the launcher draws its own title bar (`render`) rather than the system. +pub const DRAWN: bool = cfg!(target_os = "windows"); + pub fn options() -> TitlebarOptions { TitlebarOptions { title: Some("Horizon".into()), - appears_transparent: cfg!(target_os = "windows"), + appears_transparent: DRAWN, ..Default::default() } } From ac43cdea703eefac7a64e1452a6475ea47b47cf0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 20:25:40 +0200 Subject: [PATCH 09/12] launcher, server: one hidden-command helper per crate, server children keep its terminal - horizon-bench reads the machine with horizon-telemetry's `command_output` (now public) instead of a second copy of it; the console flag lives in one place. - horizon-server's `process::command` hides the console only when the server has none (started by the launcher). Run from a terminal, `schtasks`, `tar` and `mklink` share it as before, so their output still reaches it: a CREATE_NO_WINDOW child can't write to its parent's console. - horizon-prepare's java/javac keep the stdin they had; only the console flag is new. - launcher `process::hide_console` returns the command (no `let _ =` on other systems); the machine-details thread failing just leaves the report without them, as a slow one does. - README: the Windows subsystem's effect on the command line (interactive cmd/PowerShell don't wait or set the exit code) under "Command line", the deferred probe under "Performance log". Co-Authored-By: Claude Opus 5.5 --- crates/horizon-bench/src/hardware.rs | 17 +--------------- crates/horizon-prepare/src/java.rs | 11 +++++----- crates/horizon-server/src/process.rs | 28 ++++++++++++++------------ crates/horizon-telemetry/src/system.rs | 5 ++++- launcher/README.md | 17 ++++++++-------- launcher/src/perf.rs | 8 ++------ launcher/src/process.rs | 11 +++++----- 7 files changed, 41 insertions(+), 56 deletions(-) diff --git a/crates/horizon-bench/src/hardware.rs b/crates/horizon-bench/src/hardware.rs index 6b91202ad..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,20 +172,6 @@ pub fn cpu_seconds(pid: u32) -> Option { Some(ticks / 100.0) } -fn output(program: &str, args: &[&str]) -> Option { - let mut command = 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(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-prepare/src/java.rs b/crates/horizon-prepare/src/java.rs index 78530486c..b4023b7d1 100644 --- a/crates/horizon-prepare/src/java.rs +++ b/crates/horizon-prepare/src/java.rs @@ -14,16 +14,17 @@ pub struct Jdk { const TIMEOUT: Duration = Duration::from_secs(3600); -/// Exporters and JDK probes write to pipes or log files, never to a new terminal. +/// Exporters and JDK probes write to pipes or log files: on Windows they open no terminal. fn command(program: impl AsRef) -> Command { - let mut command = Command::new(program); - command.stdin(Stdio::null()); + 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 } diff --git a/crates/horizon-server/src/process.rs b/crates/horizon-server/src/process.rs index 8a79f1161..8e8d24c70 100644 --- a/crates/horizon-server/src/process.rs +++ b/crates/horizon-server/src/process.rs @@ -1,18 +1,20 @@ -//! Background helpers inherit their log streams without opening a Windows terminal. +//! The programs the server runs. Started by the launcher, the server has no console, and each +//! console program it started would open a terminal window on Windows: those open none. Run from +//! a terminal, they share it, so what they print still reaches it. use std::{ffi::OsStr, process::Command}; pub fn command(program: impl AsRef) -> Command { - let mut command = Command::new(program); - configure(&mut 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 } - -fn configure(command: &mut Command) { - #[cfg(windows)] - { - use std::os::windows::process::CommandExt; - command.creation_flags(windows_sys::Win32::System::Threading::CREATE_NO_WINDOW); - } - #[cfg(not(windows))] - let _ = command; -} diff --git a/crates/horizon-telemetry/src/system.rs b/crates/horizon-telemetry/src/system.rs index 33a5b744d..8ed6f2e3a 100644 --- a/crates/horizon-telemetry/src/system.rs +++ b/crates/horizon-telemetry/src/system.rs @@ -9,7 +9,10 @@ use std::sync::OnceLock; use crate::payload::System; -fn command_output(program: &str, args: &[&str]) -> Option { +/// 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)] diff --git a/launcher/README.md b/launcher/README.md index d2b78daea..d9738d0c2 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -97,12 +97,6 @@ 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. -On Windows, desktop launches and background tools run without terminal windows. Preparation -and server logs still reach the launcher, and CLI commands keep their terminal or redirected -input and output, including MCP. -Hardware details for performance reports are collected in the background after the first -frame, so Windows hardware queries do not delay the window opening. - ## Updates The launcher looks for a newer Horizon release when it starts and every 30 minutes while it @@ -133,7 +127,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 @@ -256,8 +255,8 @@ Each session writes its own measurements to `benchmarks/launcher-