diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 5f631f8f8..7e5c4babb 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -552,7 +552,7 @@ pub fn install(release: &Release, progress: impl Fn(f32)) -> Result<(), String> fs::write(target.join(COMPLETE), "").map_err(|e| e.to_string())?; let _ = fs::remove_dir_all(&partial); reuse_prepared(&root, tag); - complete_packs(tag); + complete_assets(tag); progress(1.0); Ok(()) } @@ -774,13 +774,13 @@ fn reuse_prepared(versions: &Path, tag: &str) -> Option { /// `reuse_prepared` for every installed version that is not prepared, oldest first, so a /// version prepared this way can serve the next. Launchers before 0.1.4 installed new versions /// without it; this catches those up. Returns each (version, where its resources came from). -/// Prepared versions also get the run-time reports (`complete_reports`) and built-in packs -/// (`complete_packs`) they lack. +/// Prepared versions also get the run-time reports (`complete_reports`) and the built-in packs, +/// panorama and sounds (`complete_assets`) they lack. pub fn reuse_prepared_everywhere() -> Vec<(String, String)> { let versions = versions_dir(); let reused = reuse_prepared_in(&versions); for tag in installed_in(&versions) { - complete_packs(&tag); + complete_assets(&tag); } reused } @@ -856,19 +856,77 @@ fn complete_reports(versions: &Path, tag: &str) -> bool { complete } -/// Adds vanilla's built-in Programmer Art and High Contrast packs to a prepared version that -/// lacks them, as `horizon-prepare packs` does: preparers before #1538 left them out, and a new -/// version reuses the resources of the one before (`reuse_prepared`). They come from the player's -/// own Minecraft asset store; without them there, one line in the log, once per launcher run, and -/// the version plays as before. Nothing is prepared again. -pub fn complete_packs(tag: &str) { - complete_packs_in(&versions_dir(), tag, minecraft_folders, &|line| { +/// What a prepared version may lack that the launcher adds without preparing again, each copied +/// from the player's own Minecraft asset store as `horizon-prepare ` does: what the +/// player misses without it, whether the resources lack it, and the copy. +type Completion = ( + &'static str, + fn(&Path) -> bool, + fn(&Path, Option<&Path>, horizon_prepare::Log) -> Result, +); + +const COMPLETIONS: [Completion; 5] = [ + // Preparers before #1538 left the built-in packs out. + ( + "Programmer Art and High Contrast", + lacks_packs, + horizon_prepare::packs, + ), + // A preparation that could not read the asset store keeps the client jar's 1x1 grey + // placeholders, its English alone, and no sounds (#1867: Prism Launcher installs prepared + // since 0.2.48). + ( + "The title panorama", + lacks_panorama, + horizon_prepare::panorama, + ), + ("The Unifont glyphs", lacks_unifont, horizon_prepare::fonts), + ("The languages", lacks_languages, horizon_prepare::languages), + ( + "The sounds", + |resources| !sounds_in(resources), + horizon_prepare::sounds, + ), +]; + +fn lacks_unifont(resources: &Path) -> bool { + !resources + .join("assets/minecraft/font/unifont.zip") + .is_file() +} + +/// Whether `en_us`, the one language the client jar has, is the only one. +fn lacks_languages(resources: &Path) -> bool { + fs::read_dir(resources.join("assets/minecraft/lang")).map_or(true, |dir| dir.count() <= 1) +} + +fn lacks_packs(resources: &Path) -> bool { + horizon_prepare::BUILT_IN_PACKS + .iter() + .any(|pack| !resources.join("assets").join(pack).is_file()) +} + +/// Whether the first panorama face is missing or the client jar's 1x1 placeholder (a PNG's +/// width is the big-endian word at byte 16, in the IHDR chunk). +fn lacks_panorama(resources: &Path) -> bool { + let face = resources.join("assets/minecraft/textures/gui/title/background/panorama_0.png"); + fs::read(face).map_or(true, |png| { + png.get(16..20).is_none_or(|width| width == [0, 0, 0, 1]) + }) +} + +/// Adds what a prepared version lacks of `COMPLETIONS`: a new version reuses the resources of the +/// one before (`reuse_prepared`), which may come from a preparer that left them out. Without them +/// in any Minecraft folder, one line each in the log, once per launcher run, and the version plays +/// as before. Nothing is prepared again. +pub fn complete_assets(tag: &str) { + complete_assets_in(&versions_dir(), tag, minecraft_folders, &|line| { eprintln!("{line}") }); } -/// `folders`: where to look, asked only when the version lacks a pack. -fn complete_packs_in( +/// `folders`: where to look, asked only when the version lacks something. +fn complete_assets_in( versions: &Path, tag: &str, folders: impl Fn() -> Vec, @@ -879,37 +937,41 @@ fn complete_packs_in( static TRIED: Mutex> = Mutex::new(Vec::new()); let root = versions.join(tag); let resources = resources_at(&root); - let lacking = || { - resources.join(RESOURCES_MANIFEST).exists() - && horizon_prepare::BUILT_IN_PACKS - .iter() - .any(|pack| !resources.join("assets").join(pack).is_file()) + let lacking = || -> Vec<&Completion> { + if !resources.join(RESOURCES_MANIFEST).exists() { + return Vec::new(); + } + COMPLETIONS + .iter() + .filter(|(_, lacks, _)| lacks(&resources)) + .collect() }; - if !lacking() { + if lacking().is_empty() { return; } let mut tried = TRIED.lock().unwrap_or_else(|e| e.into_inner()); - if tried.contains(&root) || !lacking() { + let lacking = lacking(); + if tried.contains(&root) || lacking.is_empty() { return; } tried.push(root.clone()); - let mut first_error = None; - for folder in folders() { - let copied = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { - horizon_prepare::packs(&root, Some(&folder), &|line| log(line.to_string())) - })) - .unwrap_or_else(|_| Err("the copy stopped unexpectedly".into())); - match copied { - Ok(_) => return, - Err(e) => { - first_error.get_or_insert(e); - } + let folders = folders(); + for (what, _, copy) in lacking { + let mut first_error = None; + let added = folders.iter().any(|folder| { + let copied = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + copy(&root, Some(folder), &|line| log(line.to_string())) + })) + .unwrap_or_else(|_| Err("the copy stopped unexpectedly".into())); + copied.map_err(|e| first_error.get_or_insert(e)).is_ok() + }); + if !added { + log(format!( + "{tag}: {what} not added: {}", + first_error.unwrap_or_else(|| "no Minecraft folder found".into()) + )); } } - log(format!( - "{tag}: Programmer Art and High Contrast not added: {}", - first_error.unwrap_or_else(|| "no Minecraft folder found".into()) - )); } /// The Minecraft folders whose asset store can hold what a prepared version lacks: the one @@ -1667,7 +1729,7 @@ pub fn need_prepared(tag: &str) -> Result<(), String> { /// The client's command, once its resources are prepared. pub fn client(tag: &str) -> Result { need_prepared(tag)?; - complete_packs(tag); + complete_assets(tag); crate::browser::horizon::before_play(&game_home()); let mut cmd = client_command(tag); // A sign-in that can't be renewed (no network, expired) still lets the game start, offline. @@ -3148,7 +3210,7 @@ mod tests { } #[test] - fn prepared_versions_get_the_built_in_packs_without_preparing_again() { + fn prepared_versions_get_what_the_asset_store_adds_without_preparing_again() { let dir = std::env::temp_dir().join(format!( "horizon-launcher-packs-test-{}", std::process::id() @@ -3159,17 +3221,42 @@ mod tests { fs::create_dir_all(path.parent().unwrap()).unwrap(); fs::write(path, data).unwrap(); }; - // An official launcher folder whose asset store holds the two packs. - let packs = horizon_prepare::BUILT_IN_PACKS.map(|name| (name, name.as_bytes())); + // An official launcher folder whose asset store holds the two packs, a panorama (fake + // 2x2 PNG headers), Unifont, a language and the sound list. + let background = "minecraft/textures/gui/title/background"; + let png = |n: u8| { + let mut data = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR\0\0\0\x02\0\0\0\x02".to_vec(); + data.push(n); + data + }; + let mut assets: Vec<(String, Vec)> = horizon_prepare::BUILT_IN_PACKS + .iter() + .map(|name| (name.to_string(), name.as_bytes().to_vec())) + .collect(); + for face in ["0", "1", "2", "3", "4", "5", "overlay"] { + assets.push(( + format!("{background}/panorama_{face}.png"), + png(face.as_bytes()[0]), + )); + } + for name in [ + "minecraft/font/include/unifont.json", + "minecraft/font/unifont.zip", + "pack.mcmeta", + "minecraft/lang/fr_fr.json", + "minecraft/sounds.json", + ] { + assets.push((name.into(), format!("{{\"{name}\": 1}}").into_bytes())); + } let mut index = serde_json::Map::new(); - for (name, data) in packs { + for (name, data) in &assets { let hash = sources::sha1_hex(data); write( store.join("assets/objects").join(&hash[..2]).join(&hash), data, ); index.insert( - name.into(), + name.clone(), serde_json::json!({"hash": hash, "size": data.len()}), ); } @@ -3184,6 +3271,8 @@ mod tests { .to_string(); write(store.join("versions/9.9/9.9.json"), manifest.as_bytes()); fs::create_dir_all(&empty).unwrap(); + // The client jar's 1x1 placeholder. + let placeholder = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR\0\0\0\x01\0\0\0\x01"; let release = |tag: &str, prepared: bool| { let root = versions.join(tag); write(root.join(COMPLETE), b""); @@ -3191,27 +3280,27 @@ mod tests { "client_sha1": "c", "server_sha1": "s", "manifest_sha1": sources::sha1_hex(manifest.as_bytes())}}); write(root.join("research-lock.json"), lock.to_string().as_bytes()); if prepared { - write(resources_at(&root).join(RESOURCES_MANIFEST), b"{}"); + let resources = resources_at(&root); + write(resources.join(RESOURCES_MANIFEST), b"{}"); + write(resources.join("assets/minecraft/lang/en_us.json"), b"{}"); write( - resources_at(&root).join("assets/minecraft/lang/en_us.json"), - b"{}", + resources + .join("assets") + .join(background) + .join("panorama_0.png"), + placeholder, ); } }; let lines = std::cell::RefCell::new(Vec::new()); let log = |line: String| lines.borrow_mut().push(line); - let pack = |tag: &str, i: usize| { - fs::read( - resources_at(&versions.join(tag)) - .join("assets") - .join(packs[i].0), - ) - .ok() + let asset = |tag: &str, name: &str| { + fs::read(resources_at(&versions.join(tag)).join("assets").join(name)).ok() }; - // Resources prepared before the packs were: a folder without an asset store is skipped. + // Resources prepared without any of them: a folder without an asset store is skipped. release("v0.2.1", true); - complete_packs_in( + complete_assets_in( &versions, "v0.2.1", || vec![empty.clone(), store.clone()], @@ -3219,37 +3308,55 @@ mod tests { ); assert_eq!( *lines.borrow(), - ["Built-in pack assets ready: 2 files, 0.0 MB"] + [ + "Built-in pack assets ready: 2 files, 0.0 MB", + "Panorama assets ready: 7 files, 0.0 MB", + "Font assets ready: 2 files, 0.0 MB", + "Language assets ready: 2 files, 0.0 MB", + "Sound assets ready: 1 files, 0.0 MB", + ] ); - for (i, (_, data)) in packs.iter().enumerate() { - assert_eq!(pack("v0.2.1", i).as_deref(), Some(*data)); + for (name, data) in &assets { + assert_eq!(asset("v0.2.1", name).as_ref(), Some(data), "{name}"); } // Nothing else is prepared again. let resources = resources_at(&versions.join("v0.2.1")); assert_eq!(fs::read(resources.join(RESOURCES_MANIFEST)).unwrap(), b"{}"); - assert!(!resources.join("assets/minecraft/sounds.json").exists()); - // No asset store anywhere: one line, the version stays prepared, and no second try. + // No asset store anywhere: one line each, the version stays prepared, and no second try. lines.borrow_mut().clear(); release("v0.2.2", true); - complete_packs_in(&versions, "v0.2.2", || vec![empty.clone()], &log); - complete_packs_in(&versions, "v0.2.2", || vec![empty.clone()], &log); - assert_eq!(lines.borrow().len(), 1); - assert!( - lines.borrow()[0].starts_with("v0.2.2: Programmer Art and High Contrast not added: "), - "{lines:?}" + complete_assets_in(&versions, "v0.2.2", || vec![empty.clone()], &log); + complete_assets_in(&versions, "v0.2.2", || vec![empty.clone()], &log); + let what = lines + .borrow() + .iter() + .map(|line| line.split(" not added: ").next().unwrap().to_string()) + .collect::>(); + assert_eq!( + what, + [ + "v0.2.2: Programmer Art and High Contrast", + "v0.2.2: The title panorama", + "v0.2.2: The Unifont glyphs", + "v0.2.2: The languages", + "v0.2.2: The sounds", + ] ); assert!(resources_at(&versions.join("v0.2.2")) .join(RESOURCES_MANIFEST) .exists()); - assert_eq!(pack("v0.2.2", 0), None); + assert_eq!( + asset("v0.2.2", &format!("{background}/panorama_0.png")).as_deref(), + Some(&placeholder[..]) + ); // Not prepared, or complete: nothing to do, without even looking for a Minecraft folder. lines.borrow_mut().clear(); release("v0.2.3", false); let unasked = || -> Vec { unreachable!("no folder is needed") }; - complete_packs_in(&versions, "v0.2.3", unasked, &log); - complete_packs_in(&versions, "v0.2.1", unasked, &log); + complete_assets_in(&versions, "v0.2.3", unasked, &log); + complete_assets_in(&versions, "v0.2.1", unasked, &log); assert!(lines.borrow().is_empty()); assert!(!resources_at(&versions.join("v0.2.3")).exists()); let _ = fs::remove_dir_all(&dir); diff --git a/launcher/src/main.rs b/launcher/src/main.rs index afc8dde45..9105f71a2 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -831,13 +831,14 @@ impl Launcher { // A little earlier than the spawn: file times can be coarse. self.client_started = Some(std::time::SystemTime::now() - std::time::Duration::from_secs(2)); - // The built-in packs the resources lack and the session (a network round trip when the - // token needs renewing) come first; `drain` starts the game when the session arrives. + // What the resources lack (built-in packs, panorama, sounds) and the session (a network + // round trip when the token needs renewing) come first; `drain` starts the game when the + // session arrives. self.starting_client = Some(tag.clone()); self.play_pressed = Some(Instant::now()); let tx = self.tx.clone(); std::thread::spawn(move || { - backend::complete_packs(&tag); + backend::complete_assets(&tag); let session = (|| { let mut accounts = Accounts::load(); let Some((a, secrets)) = account::session_for_launch(