Merge pull request #1986 from some-du6e/fix/prepare-atlauncher

🤖 Agent: contrib-gate-17 verified this head (26.3 sources, integration tree build, clippy, tests, parity; details in the PR comment). Thanks @some-du6e!
This commit is contained in:
Ludovic Marie
2026-10-26 13:42:23 +01:00
committed by GitHub
3 changed files with 263 additions and 41 deletions
+250 -32
View File
@@ -1,5 +1,5 @@
//! The player's own game files: the pinned version JSON, client jar and libraries from their
//! official launcher install, and the server jar they downloaded, each checked against
//! official launcher or ATLauncher install, and the server jar they downloaded, each checked against
//! research-lock.json before it is copied to `.local/minecraft/<version>` (tools/lab.py's
//! `prepare`, which the Python preparer ran first), then checked again on every run
//! (tools/test_rust_parity.py's `verify_artifacts`).
@@ -12,9 +12,10 @@ use std::path::{Component, Path, PathBuf};
const LAUNCHER_HINT: &str =
"Horizon does not download the game: play {version} once in the launcher you play \
Minecraft Java Edition with (the official launcher, Prism Launcher, MultiMC...) so it downloads \
the game's files, then rerun. If that launcher keeps them in another folder, pass \
--minecraft-dir or set HORIZON_MINECRAFT_DIR.";
Minecraft Java Edition with so it downloads the game's files, then rerun. Horizon reads the \
official launcher's folder, ATLauncher's and the CurseForge app's; for Prism Launcher, MultiMC, \
the Modrinth App or GDLauncher, prepare from the Horizon launcher, which finds their files. If your launcher keeps \
them in another folder, pass --minecraft-dir or set HORIZON_MINECRAFT_DIR.";
const SERVER_HINT: &str = "Horizon does not download the game: download the {version} server jar yourself (minecraft.net/download/server \
while {version} is the current release, otherwise the downloads.server.url in your launcher's \
versions/{version}/{version}.json), then pass --server-jar PATH or set HORIZON_SERVER_JAR.";
@@ -23,11 +24,6 @@ fn hint(text: &str, version: &str) -> String {
text.replace("{version}", version)
}
/// What to do when the player's launcher install lacks the pinned version's files.
pub(crate) fn launcher_hint(version: &str) -> String {
hint(LAUNCHER_HINT, version)
}
/// research-lock.json and the folder the pinned version's files go to.
pub struct Lock {
pub json: Value,
@@ -134,6 +130,137 @@ pub fn minecraft_dir(chosen: Option<&Path>) -> PathBuf {
}
}
/// One launcher's copy of the pinned version: its version JSON (Mojang's file, checked by its
/// sha1), the client jar, and the folder holding its `libraries` (at the version JSON's paths)
/// and `assets`.
pub struct GameFiles {
pub folder: PathBuf,
pub manifest: PathBuf,
pub client: PathBuf,
/// Mojang's Java runtimes the launcher downloaded (java::minecraft_runtimes).
pub runtimes: PathBuf,
/// The folders looked in, each with its launcher, when none held the version.
searched: Vec<(&'static str, PathBuf)>,
}
impl GameFiles {
/// What to do when these files are missing, with the folders looked in.
pub(crate) fn hint(&self, version: &str) -> String {
let mut text = hint(LAUNCHER_HINT, version);
if !self.searched.is_empty() {
text += &format!(" Horizon looked for {version} in:");
for (launcher, folder) in &self.searched {
text += &format!("\n {} ({launcher})", folder.display());
}
}
text
}
}
/// The layouts horizon-prepare reads in `folder`: the official launcher's, then ATLauncher's,
/// which saves Mojang's version JSON as is in `configs/json/minecraft` and the client jar as
/// the library `net.minecraft:client:<version>`.
fn layouts(folder: &Path, version: &str) -> [GameFiles; 2] {
let files = |manifest: String, client: String, runtimes: &str| GameFiles {
folder: folder.to_path_buf(),
manifest: folder.join(manifest),
client: folder.join(client),
runtimes: folder.join(runtimes),
searched: Vec::new(),
};
let v = version;
[
files(
format!("versions/{v}/{v}.json"),
format!("versions/{v}/{v}.jar"),
"runtime",
),
files(
format!("configs/json/minecraft/{v}.json"),
format!("libraries/net/minecraft/client/{v}/client-{v}.jar"),
"runtimes/minecraft",
),
]
}
/// The launchers whose folders are looked in when none is chosen: the official launcher's
/// (`minecraft_dir`), ATLauncher's, then the CurseForge app's `Install` folder, where it runs
/// the official launcher (its default modding folder, `curseforge/minecraft`, is in the home
/// folder on Windows and in Documents elsewhere). ATLauncher keeps its files in its working folder:
/// where its Windows installer puts it, inside the macOS app, and the folders its Linux
/// packages and Flatpak start it in.
fn launcher_folders() -> Vec<(&'static str, PathBuf)> {
let mut folders = vec![("the official launcher", minecraft_dir(None))];
// The same folders as the Horizon launcher's (launcher/src/sources.rs `known_folders`).
let atlauncher: Vec<PathBuf> = if cfg!(target_os = "macos") {
let app = Path::new("Applications/ATLauncher.app/Contents/Java");
vec![
home().join("Library/Application Support/ATLauncher"),
Path::new("/").join(app),
home().join(app),
]
} else if cfg!(windows) {
std::env::var_os("APPDATA")
.map(|d| PathBuf::from(d).join("ATLauncher"))
.into_iter()
.collect()
} else {
let data = std::env::var_os("XDG_DATA_HOME")
.filter(|d| !d.is_empty())
.map_or_else(|| home().join(".local/share"), PathBuf::from);
let flatpak = home().join(".var/app/com.atlauncher.ATLauncher/data");
vec![data.join("atlauncher"), flatpak.join("atlauncher"), flatpak]
};
folders.extend(atlauncher.into_iter().map(|dir| ("ATLauncher", dir)));
let curseforge = if cfg!(windows) { "" } else { "Documents" };
folders.push((
"the CurseForge app",
home().join(curseforge).join("curseforge/minecraft/Install"),
));
folders
}
/// The pinned version's files in the chosen folder (`--minecraft-dir`, HORIZON_MINECRAFT_DIR),
/// or the launcher above it when an instance folder (`instances/<name>`) is chosen; with no
/// folder chosen, in the first launcher folder that has them. When none does, the official
/// layout of the first folder is returned, for the errors to name, with the folders looked in.
pub fn game_files(chosen: Option<&Path>, version: &str) -> GameFiles {
let chosen = chosen
.filter(|d| !d.as_os_str().is_empty())
.map(Path::to_path_buf)
.or_else(|| std::env::var_os("HORIZON_MINECRAFT_DIR").map(PathBuf::from))
.filter(|d| !d.as_os_str().is_empty())
.map(|d| expand_user(&d));
let folders = match chosen {
Some(dir) => {
let launcher = dir
.ancestors()
.find(|a| a.file_name().is_some_and(|n| n == "instances"))
.and_then(Path::parent)
.map(Path::to_path_buf);
let mut folders = vec![("the folder chosen", dir)];
folders.extend(launcher.map(|dir| ("the launcher above it", dir)));
folders
}
None => launcher_folders(),
};
// A folder with both files first: a version JSON left without its jar is used, for the
// error to name the jar, only when no folder has both.
let complete = |files: &GameFiles| files.manifest.is_file() && files.client.is_file();
let partial = |files: &GameFiles| files.manifest.is_file();
for found in [complete, partial] {
let mut all = folders
.iter()
.flat_map(|(_, folder)| layouts(folder, version));
if let Some(files) = all.find(found) {
return files;
}
}
let [mut files, _] = layouts(&folders[0].1, version);
files.searched = folders;
files
}
/// Copy one file from the player's install, checked like a download; an existing verified
/// copy is kept.
pub(crate) fn import_copy(
@@ -156,17 +283,14 @@ pub(crate) fn import_copy(
.commit()
}
/// The pinned version JSON from the launcher's versions/ directory. The launcher's copy wins
/// over the cached one so the manifest matches the asset index installed alongside it.
pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result<Value, String> {
/// The pinned version JSON from the launcher's install. The launcher's copy wins over the
/// cached one so the manifest matches the asset index installed alongside it.
pub(crate) fn import_manifest(lock: &Lock, files: &GameFiles) -> Result<Value, String> {
let version = &lock.version;
let destination = lock.directory.join("manifest.json");
let source = minecraft
.join("versions")
.join(version)
.join(format!("{version}.json"));
let source = &files.manifest;
if source.is_file() {
let manifest = read_json(&source)?;
let manifest = read_json(source)?;
let downloads = manifest.get("downloads");
let sha1 = |side: &str| {
downloads
@@ -183,7 +307,7 @@ pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result<Value, St
source.display()
));
}
let checksum = digest(&source, "sha1")?;
let checksum = digest(source, "sha1")?;
if !lock.manifest_accepted(&checksum) {
// Another launcher's rewrite of Mojang's file (HMCL and PCL add their own fields to
// the same jars, #1772), or one Mojang republished: Mojang's own copy saved as the
@@ -202,13 +326,13 @@ pub(crate) fn import_manifest(lock: &Lock, minecraft: &Path) -> Result<Value, St
}
} else if !(destination.exists() && digest(&destination, "sha1")? == checksum) {
fs::create_dir_all(&lock.directory).map_err(|e| e.to_string())?;
fs::copy(&source, &destination).map_err(|e| e.to_string())?;
fs::copy(source, &destination).map_err(|e| e.to_string())?;
}
} else if !(destination.exists() && lock.manifest_accepted(&digest(&destination, "sha1")?)) {
return Err(format!(
"Missing {}. {}",
source.display(),
hint(LAUNCHER_HINT, version)
files.hint(version)
));
}
let manifest = read_json(&destination)?;
@@ -519,18 +643,15 @@ pub fn import(
server_jar: Option<&Path>,
log: Log,
) -> Result<(), String> {
let minecraft = minecraft_dir(minecraft);
let version = &lock.version;
let manifest = import_manifest(lock, &minecraft)?;
let files = game_files(minecraft, &lock.version);
let minecraft = &files.folder;
let manifest = import_manifest(lock, &files)?;
let client = import_copy(
&minecraft
.join("versions")
.join(version)
.join(format!("{version}.jar")),
&files.client,
&lock.directory.join("jars/client.jar"),
lock.pin("client_sha1")?,
"sha1",
&hint(LAUNCHER_HINT, version),
&files.hint(&lock.version),
)?;
let downloads = manifest.get("downloads");
if downloads.and_then(|d| d.get("client_mappings")).is_some()
@@ -555,7 +676,7 @@ pub fn import(
for (name, artifact) in client_library_artifacts(&manifest)? {
let (path, sha1) = artifact_fields(artifact)?;
let relative = safe_relative(path).ok_or("Unsafe library path")?;
let source = launcher_library(&minecraft, name, &relative);
let source = launcher_library(minecraft, name, &relative);
let destination = lock.directory.join("libraries/client").join(&relative);
if runs_without(name) && !source.is_file() && !destination.exists() {
log(&format!(
@@ -569,7 +690,7 @@ pub fn import(
&destination,
sha1,
"sha1",
&hint(LAUNCHER_HINT, version),
&files.hint(&lock.version),
)?);
}
write_import_metadata(
@@ -1122,7 +1243,7 @@ mod tests {
let lock = Lock::read(&root).unwrap();
let destination = lock.directory.join("manifest.json");
let error = import_manifest(&lock, &minecraft).unwrap_err();
let error = import_manifest(&lock, &game_files(Some(&minecraft), "9.9")).unwrap_err();
assert!(error.contains("may have rewritten it"), "{error}");
assert!(
error.contains(&format!("packages/{pinned}/9.9.json")),
@@ -1136,7 +1257,7 @@ mod tests {
fs::create_dir_all(&lock.directory).unwrap();
fs::copy(root.join("mojang.json"), &destination).unwrap();
let manifest = import_manifest(&lock, &minecraft).unwrap();
let manifest = import_manifest(&lock, &game_files(Some(&minecraft), "9.9")).unwrap();
assert!(manifest.get("patches").is_none());
assert_eq!(digest(&destination, "sha1").unwrap(), pinned);
fs::remove_dir_all(&root).unwrap();
@@ -1253,6 +1374,103 @@ mod tests {
assert!(prepare().unwrap_err().starts_with("Missing "));
}
/// ATLauncher keeps Mojang's version JSON in `configs/json/minecraft` and the client jar as
/// a library; its folder, or one of its instances, prepares like the official launcher's,
/// with the same pins.
#[test]
fn an_atlauncher_install_prepares() {
let fixture = Imports::new();
let old = fixture.imported(&fixture.source);
let atlauncher = fixture.directory.join("ATLauncher");
let put = |path: &str, data: &[u8]| {
let path = atlauncher.join(path);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, data).unwrap();
};
let client = fs::read(old.join("jars/client.jar")).unwrap();
put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client);
put("libraries/client.jar", b"client library");
put("instances/Minecraft99/instance.json", b"{}");
// A version JSON left without its jar does not hide the launcher's complete copy.
put("instances/Minecraft99/versions/9.9/9.9.json", b"{}");
let manifest = fs::read_to_string(old.join("manifest.json")).unwrap();
let manifest = manifest.replacen('{', r#"{"javaVersion":{"majorVersion":25},"#, 1);
put("configs/json/minecraft/9.9.json", manifest.as_bytes());
let pinned = digest(&atlauncher.join("configs/json/minecraft/9.9.json"), "sha1").unwrap();
let lock_path = fixture.target.join("research-lock.json");
let text = fs::read_to_string(&lock_path).unwrap();
let old_sha1 = digest(&old.join("manifest.json"), "sha1").unwrap();
fs::write(&lock_path, text.replace(&old_sha1, &pinned)).unwrap();
let lock = Lock::read(&fixture.target).unwrap();
let server = old.join("jars/server.jar");
let prepare = |dir: &Path| {
let _ = fs::remove_dir_all(&lock.directory);
import(&fixture.target, &lock, Some(dir), Some(&server), &|_| {})
};
for chosen in [atlauncher.clone(), atlauncher.join("instances/Minecraft99")] {
prepare(&chosen).unwrap();
let artifacts = verify(&lock).unwrap();
assert_eq!(fs::read(&artifacts.jars["client"]).unwrap(), client);
assert_eq!(
client_libraries(&lock, &artifacts.manifest).unwrap().len(),
1
);
}
let files = game_files(Some(&atlauncher), "9.9");
assert_eq!(files.runtimes, atlauncher.join("runtimes/minecraft"));
// The pins gate it as they gate the official layout.
put(
"libraries/net/minecraft/client/9.9/client-9.9.jar",
b"other",
);
assert!(prepare(&atlauncher)
.unwrap_err()
.contains("is not the pinned file"));
put("libraries/net/minecraft/client/9.9/client-9.9.jar", &client);
put(
"configs/json/minecraft/9.9.json",
manifest.replace(',', ", ").as_bytes(),
);
assert!(prepare(&atlauncher)
.unwrap_err()
.contains("may have rewritten it"));
}
/// With no launcher's files in the chosen folder, the error names where Horizon looked and
/// the launchers it reads.
#[test]
fn the_error_names_the_folders_looked_in() {
let fixture = Imports::new();
let empty = fixture.directory.join("instances/empty");
fs::create_dir_all(&empty).unwrap();
let lock = Lock::read(&fixture.target).unwrap();
let error = import(&fixture.target, &lock, Some(&empty), None, &|_| {}).unwrap_err();
assert!(error.starts_with(&format!(
"Missing {}",
empty.join("versions/9.9/9.9.json").display()
)));
assert!(error.contains("Horizon looked for 9.9 in:"), "{error}");
assert!(error.contains(&format!("\n {} (the folder chosen)", empty.display())));
assert!(error.contains(&format!(
"\n {} (the launcher above it)",
fixture.directory.display()
)));
assert!(error.contains("ATLauncher"));
}
#[test]
fn every_launcher_horizon_reads_is_looked_in() {
let launchers: Vec<_> = launcher_folders()
.into_iter()
.map(|(name, _)| name)
.collect();
for name in ["the official launcher", "ATLauncher", "the CurseForge app"] {
assert!(launchers.contains(&name), "{name}");
}
}
#[test]
fn runs_without_only_netty_native_transports() {
assert!(runs_without(
+1 -1
View File
@@ -434,7 +434,7 @@ fn prepare_impl(options: &Options, log: Log, compile_only: bool) -> Result<PathB
// Java first: nothing below can finish without it, and the player should hear it at once.
let mut homes: Vec<PathBuf> = options.java_home.iter().cloned().collect();
homes.extend(java::minecraft_runtimes(
&artifacts::minecraft_dir(options.minecraft_dir.as_deref()).join("runtime"),
&artifacts::game_files(options.minecraft_dir.as_deref(), &lock.version).runtimes,
));
let jdk = java::find_runtime(lock.java_major, &homes)?;
let reused = if options.import {
+12 -8
View File
@@ -1,5 +1,5 @@
//! The pinned version's sounds, title panorama, Unifont glyphs and built-in resource packs
//! from the player's own official launcher install, each object checked against the asset index's SHA-1, copied into
//! from the player's own launcher install, each object checked against the asset index's SHA-1, copied into
//! `.local/horizon-client/<version>/assets` where the game reads them (tools/fetch_sounds.py and
//! the tools/lab.py functions it called). Nothing is downloaded.
@@ -18,11 +18,11 @@ use std::path::{Path, PathBuf};
fn launcher_assets(
lock: &Lock,
manifest: &Value,
minecraft: &Path,
files: &artifacts::GameFiles,
cached_index: &Path,
log: Log,
) -> Result<(PathBuf, PathBuf, Vec<u8>), String> {
let assets = minecraft.join("assets");
let assets = files.folder.join("assets");
let info = manifest
.get("assetIndex")
.ok_or("The version JSON has no assetIndex")?;
@@ -44,7 +44,7 @@ fn launcher_assets(
return Err(format!(
"Missing {}. {}",
index.display(),
artifacts::launcher_hint(version)
files.hint(version)
));
}
let bytes = fs::read(&index).map_err(|e| format!("{}: {e}", index.display()))?;
@@ -240,13 +240,13 @@ pub(crate) struct Assets {
impl Assets {
pub(crate) fn load(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<Self, String> {
let lock = Lock::read(root)?;
let minecraft = artifacts::minecraft_dir(minecraft);
let manifest = artifacts::import_manifest(&lock, &minecraft)?;
let files = artifacts::game_files(minecraft, &lock.version);
let manifest = artifacts::import_manifest(&lock, &files)?;
let target = root.join(".local/horizon-client").join(&lock.version);
let (store, index, bytes) = launcher_assets(
&lock,
&manifest,
&minecraft,
&files,
&target.join("asset-index.json"),
log,
)?;
@@ -677,7 +677,11 @@ mod tests {
for missing in ["store", "install", "last-object"] {
let f = Fixture::new(&format!("optional-panorama-{missing}"));
// The JARs and manifest were imported earlier; the launcher need not remain.
artifacts::import_manifest(&Lock::read(&f.root).unwrap(), &f.minecraft).unwrap();
artifacts::import_manifest(
&Lock::read(&f.root).unwrap(),
&artifacts::game_files(Some(&f.minecraft), "9.9"),
)
.unwrap();
let target = f.root.join(".local/horizon-client/9.9/assets");
for name in PANORAMA {
let path = target.join(name);