Merge pull request #1870 from ludovic111/fix/complete-sounds-panorama

🤖 Agent: merged after verify and the parity harnesses this change reaches passed on its head.
This commit is contained in:
Ludovic Marie
2026-10-25 22:13:20 +01:00
committed by GitHub
2 changed files with 178 additions and 70 deletions
+174 -67
View File
@@ -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<String> {
/// `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 <kind>` 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<PathBuf, String>,
);
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<PathBuf>,
@@ -879,37 +937,41 @@ fn complete_packs_in(
static TRIED: Mutex<Vec<PathBuf>> = 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<Command, String> {
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<u8>)> = 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::<Vec<_>>();
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<PathBuf> { 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);
+4 -3
View File
@@ -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(