Merge pull request #663 from ludovic111/feat/launcher-import-modpack

Launcher: Import modpack, its coverage report, port and play it as a profile
This commit is contained in:
Ludovic Marie
2026-10-17 12:39:16 +02:00
committed by GitHub
10 changed files with 875 additions and 33 deletions
+13
View File
@@ -2664,6 +2664,7 @@ dependencies = [
"gpui",
"horizon-bench",
"horizon-friends",
"horizon-port-pack",
"horizon-prepare",
"horizon-telemetry",
"horizon-theme",
@@ -2680,6 +2681,18 @@ dependencies = [
"zip",
]
[[package]]
name = "horizon-port-pack"
version = "0.1.0"
dependencies = [
"serde",
"serde_json",
"sha1",
"toml 1.1.8+spec-1.1.0",
"ureq",
"zip",
]
[[package]]
name = "horizon-prepare"
version = "0.1.0"
+2
View File
@@ -26,6 +26,8 @@ horizon-prepare = { path = "../crates/horizon-prepare" }
# Join a friend: invite codes (the game does the joining).
horizon-friends = { path = "../crates/horizon-friends" }
horizon-bench = { path = "../crates/horizon-bench" }
# Import modpack: the porting pipeline, run on the player's own files (docs/modpacks.md).
horizon-port-pack = { path = "../crates/horizon-port-pack" }
# Opt-in data collection: the consent, the outbox and its upload (docs/telemetry.md).
horizon-telemetry = { path = "../crates/horizon-telemetry" }
# The session file's random name.
+17 -1
View File
@@ -25,6 +25,16 @@ The opening, then Play ([clip](docs/opening.webm)):
preparation reuses checksum-verified game jars and libraries from the current
or another installed Horizon version, so the original Minecraft install is
only required when no valid imported copy exists.
- **Modpacks**: import a Java modpack (a Modrinth `.mrpack`, a CurseForge zip, or a Prism,
MultiMC or CurseForge instance folder) and see its coverage report: per mod, ported, partial,
not yet or not needed, with the reason ([docs/modpacks.md](../docs/modpacks.md)). **Port**
gets the jars of what this computer can port today (content mods with data and assets only)
the player's own way: copied from a folder they have, or downloaded from the pack's own links
or the same file on Modrinth's CDN, hash checked; files only CurseForge has need its API key, so
they come from your installed instance. It carries them over for the selected version, and
**Play** starts the game as the pack's own profile (`ports/<pack>/home/` in the game's home:
its own saves and options) with those mods. Nothing is uploaded or shared: mod jars and ports
stay on this computer.
- **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -83,6 +93,11 @@ The same binary is a command-line tool; without a subcommand it opens the window
horizon-launcher account sign-out <name>
horizon-launcher account select <name> play as this account
horizon-launcher account offline play without an account
horizon-launcher modpack [list] the imported packs and their coverage
horizon-launcher modpack import <pack> a .mrpack, CurseForge zip or instance folder
horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>] get the jars and carry them over
horizon-launcher modpack play <pack> [--version <tag>] play it as its own profile
horizon-launcher modpack remove <pack>
horizon-launcher benchmark [--repeats N] measure the launcher (see Performance log)
horizon-launcher data [status] what data collection is allowed, the install ID, what waits
horizon-launcher data allow|deny <kinds|all> performance, crashes, bugs, benchmarks
@@ -92,7 +107,7 @@ The same binary is a command-line tool; without a subcommand it opens the window
horizon-launcher data benchmark <report.json> upload a benchmark report, printed first
`--json` prints JSON where there is something to report (`versions`, `install`, `notes`,
`next`, `links`, `menu-style`, `update --check`, `logs`, `account`, `benchmark`, `data`). Errors go to stderr with exit code 1. `server` runs in the terminal,
`next`, `links`, `menu-style`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal,
so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for
scripts and tests).
@@ -192,6 +207,7 @@ bundled so the type is the same on every platform.
## Screenshots
![Server](docs/server.png)
![Modpacks](docs/modpacks.png)
![Versions](docs/versions.png)
![Patch notes](docs/patch-notes.png)
![Settings](docs/settings.png)
Binary file not shown.

After

Width:  |  Height:  |  Size: 111 KiB

+4
View File
@@ -1709,6 +1709,10 @@ pub enum Msg {
/// The selected account's session file for the game about to start (none = offline), or
/// why it could not be renewed.
Session(Result<Option<PathBuf>, String>),
/// A modpack step's line (`modpacks`).
PackLine(String),
/// A modpack step ended: the pack as it now is.
PackDone(Result<Box<crate::modpacks::Imported>, String>),
}
/// A running process; its output arrives as `Msg::Line`, its end as `Msg::Exit`.
+104
View File
@@ -76,6 +76,33 @@ enum DataCmd {
},
}
#[derive(Subcommand)]
enum ModpackCmd {
/// The imported packs and their coverage (the default)
List,
/// Import a .mrpack, a CurseForge zip or an instance folder, and write its coverage report
Import { path: PathBuf },
/// Get the jars of what this computer can port and carry them over
Port {
/// The pack's folder name, as list shows it
pack: String,
/// A folder with your own jars (an installed instance, a downloads folder)
#[arg(long)]
from: Option<PathBuf>,
/// The installed version the ports are for (default: the selected one)
#[arg(long)]
version: Option<String>,
},
/// Play a ported pack as its own profile
Play {
pack: String,
#[arg(long)]
version: Option<String>,
},
/// Remove an imported pack: its jars, ports and the profile's saves
Remove { pack: String },
}
#[derive(Subcommand)]
enum Cmd {
/// List Horizon releases, or the installed versions
@@ -161,6 +188,12 @@ enum Cmd {
#[command(subcommand)]
action: Option<DataCmd>,
},
/// Modpacks: import a Java pack, see its coverage report, port what this computer can and
/// play it as its own profile (docs/modpacks.md)
Modpack {
#[command(subcommand)]
action: Option<ModpackCmd>,
},
/// Serve the Model Context Protocol on stdin and stdout, for AI agents
Mcp,
/// Measure the launcher: starts (the first is the cold one), page switching, idle CPU and
@@ -400,6 +433,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
println!("Horizon is in the applications menu.");
}
}
Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
Cmd::Mcp => unreachable!(),
}
Ok(())
@@ -591,3 +625,73 @@ fn data(action: DataCmd, as_json: bool) -> Result<(), String> {
}
Ok(())
}
fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
use horizon_launcher::modpacks::{self, Imported};
use horizon_port_pack::report::Status;
let log = &|line: String| eprintln!("{line}");
let work = |pack: &str| {
let work = modpacks::ports_dir().join(pack);
modpacks::load(&work).map(|_| work)
};
let show = |p: &Imported| {
let counts: Vec<String> = Status::ALL
.iter()
.map(|s| format!("{} {}", p.count(*s), s.label()))
.collect();
if as_json {
json(serde_json::json!({
"pack": p.slug, "name": p.title(), "summary": p.summary(),
"counts": Status::ALL.iter().map(|s| (s.label(), p.count(*s))).collect::<std::collections::BTreeMap<_, _>>(),
"portable": p.portable, "ported_mods": p.mods.len(), "jars": p.jars(),
"report": p.work.join("coverage.md"),
}));
} else {
println!(
"{} ({})\n {}\n {}",
p.title(),
p.slug,
p.summary(),
counts.join(", ")
);
println!(" {} portable, {} carried over", p.portable, p.mods.len());
if let Some(jars) = p.jars() {
println!(" {jars}");
}
println!(" {}", p.work.join("coverage.md").display());
}
};
match action {
ModpackCmd::List => {
let packs = modpacks::list();
if packs.is_empty() && !as_json {
println!("No modpack imported yet: horizon-launcher modpack import <pack>");
}
packs.iter().for_each(show);
}
ModpackCmd::Import { path } => show(&modpacks::import(&path, log)?),
ModpackCmd::Port {
pack,
from,
version,
} => {
let tag = backend::resolve_version(version.as_deref()).ok();
let resources = tag
.filter(|t| backend::is_prepared(t))
.map(|t| backend::resources(&t));
show(&modpacks::port(
&work(&pack)?,
resources.as_deref(),
from.as_deref(),
log,
)?)
}
ModpackCmd::Play { pack, version } => {
let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
modpacks::apply_profile(&mut cmd, &work(&pack)?)?;
attached(cmd)?
}
ModpackCmd::Remove { pack } => modpacks::remove(&work(&pack)?)?,
}
Ok(())
}
+1
View File
@@ -2,6 +2,7 @@
pub mod account;
pub mod backend;
pub mod desktop;
pub mod modpacks;
pub mod mojang;
pub mod sources;
pub mod telemetry;
+73 -32
View File
@@ -6,6 +6,7 @@ mod collection;
mod game_tools;
mod markdown;
mod mcp;
mod modpacks_page;
mod perf;
mod theme;
@@ -29,14 +30,16 @@ use theme::Theme;
enum Page {
Play,
Versions,
Modpacks,
Notes,
Settings,
}
impl Page {
const ALL: [(Page, &'static str); 4] = [
const ALL: [(Page, &'static str); 5] = [
(Page::Play, "Play"),
(Page::Versions, "Versions"),
(Page::Modpacks, "Modpacks"),
(Page::Notes, "Patch notes"),
(Page::Settings, "Settings"),
];
@@ -161,6 +164,17 @@ struct Launcher {
play_pressed: Option<Instant>,
/// `horizon-launcher benchmark` started this window to measure it.
bench: Option<perf::Bench>,
/// The Modpacks page: the imported packs (read when the page first opens), the one shown,
/// the report's filter, and the pipeline step running now with its log.
packs: Vec<horizon_launcher::modpacks::Imported>,
packs_loaded: Option<Instant>,
pack_open: Option<String>,
pack_filter: Option<horizon_port_pack::report::Status>,
pack_busy: bool,
pack_log: VecDeque<String>,
pack_error: Option<String>,
/// The game starting now plays this pack's profile (its work folder).
starting_pack: Option<std::path::PathBuf>,
}
impl Launcher {
@@ -266,6 +280,14 @@ impl Launcher {
prepare_started: None,
play_pressed: None,
bench: perf::Bench::from_env(),
packs: Vec::new(),
packs_loaded: None,
pack_open: None,
pack_filter: None,
pack_busy: false,
pack_log: VecDeque::new(),
pack_error: None,
starting_pack: None,
};
if this.bench.is_some() {
this.perf.keep_local_log(false);
@@ -406,6 +428,14 @@ impl Launcher {
Err(e) => self.client_error = Some(format!("Playing offline: {e}")),
}
self.accounts = Accounts::load();
if let Some(work) = self.starting_pack.take() {
if let Err(e) =
horizon_launcher::modpacks::apply_profile(&mut cmd, &work)
{
self.client_error = Some(e);
continue;
}
}
if let Some(code) = self.joining.take() {
if let Err(e) = backend::join_friend(&mut cmd, &code) {
self.client_error = Some(e);
@@ -473,6 +503,13 @@ impl Launcher {
Err(e) => SelfUpdate::Failed(e),
};
}
Msg::PackLine(line) => {
self.pack_log.push_back(line);
if self.pack_log.len() > LOG_LINES {
self.pack_log.pop_front();
}
}
Msg::PackDone(result) => self.pack_done(result),
Msg::Line(job, line) => {
if job == Job::Client && line.starts_with(perf::GAME_FIRST_FRAME) {
if let Some(pressed) = self.play_pressed.take() {
@@ -671,37 +708,8 @@ impl Launcher {
if self.client.is_some() || self.starting_client.is_some() {
return;
}
self.client_error = None;
self.crash = None;
self.prepare_log.clear();
// 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 session (a network round trip when the token needs renewing) comes first;
// `drain` starts the game when it arrives.
self.starting_client = Some(tag);
self.play_pressed = Some(Instant::now());
let tx = self.tx.clone();
std::thread::spawn(move || {
let session = (|| {
let mut accounts = Accounts::load();
let Some((a, secrets)) = account::session_for_launch(
&account::Endpoints::live(),
account::store(),
&mut accounts,
)?
else {
return Ok(None);
};
account::write_session_file(
&backend::game_home().join("sessions"),
&a,
&secrets,
)
.map(Some)
})();
let _ = tx.send(Msg::Session(session));
});
self.starting_pack = None;
self.start_client(tag);
}
Mode::Server => {
if let Some(server) = &mut self.server {
@@ -729,6 +737,38 @@ impl Launcher {
}
}
/// Starts the game: the session first (a network round trip when the token needs
/// renewing), then `drain` starts the process when it arrives.
fn start_client(&mut self, tag: String) {
self.client_error = None;
self.crash = None;
self.prepare_log.clear();
// 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 session (a network round trip when the token needs renewing) comes first;
// `drain` starts the game when it arrives.
self.starting_client = Some(tag);
self.play_pressed = Some(Instant::now());
let tx = self.tx.clone();
std::thread::spawn(move || {
let session = (|| {
let mut accounts = Accounts::load();
let Some((a, secrets)) = account::session_for_launch(
&account::Endpoints::live(),
account::store(),
&mut accounts,
)?
else {
return Ok(None);
};
account::write_session_file(&backend::game_home().join("sessions"), &a, &secrets)
.map(Some)
})();
let _ = tx.send(Msg::Session(session));
});
}
fn choose_folder(&mut self, server: bool, cx: &mut Context<Self>) {
let paths = cx.prompt_for_paths(PathPromptOptions {
files: false,
@@ -2774,6 +2814,7 @@ impl Render for Launcher {
let content = match self.page {
Page::Play => self.play_page(cx),
Page::Versions => self.versions_page(cx),
Page::Modpacks => self.modpacks_page(cx),
Page::Notes => self.notes_page(cx),
Page::Settings => self.settings_page(cx),
};
+249
View File
@@ -0,0 +1,249 @@
//! Modpacks: import a Java modpack (a Modrinth `.mrpack`, a CurseForge zip, an instance folder),
//! show what Horizon runs of it, port that on this computer from the player's own downloads, and
//! play it as a profile of its own (docs/modpacks.md).
//!
//! Each pack lives in `ports/<slug>/` in the game's home: the work folder `horizon-port-pack`
//! writes (pack.json, inventory, the jars, the carried-over mods, the coverage report) and
//! `home/`, the profile's own saves and options. Nothing is uploaded or shared: mod jars are
//! often All Rights Reserved, so the ports stay on the player's machine.
use crate::backend;
use horizon_port_pack::{
fetch::{Fetched, How},
import::Pack,
pipeline::{self, Log},
report::{Row, Status},
};
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
/// Where imported packs live.
pub fn ports_dir() -> PathBuf {
backend::game_home().join("ports")
}
/// A pack's folder name: its name in lowercase words joined by dashes.
pub fn slug(name: &str) -> String {
let words: Vec<String> = name
.split(|c: char| !c.is_ascii_alphanumeric())
.filter(|w| !w.is_empty())
.map(str::to_ascii_lowercase)
.collect();
if words.is_empty() {
"pack".into()
} else {
words.join("-")
}
}
/// An imported pack, as its work folder has it.
pub struct Imported {
pub slug: String,
pub work: PathBuf,
pub pack: Pack,
pub rows: Vec<Row>,
pub fetched: Fetched,
/// The carried-over mods the profile loads.
pub mods: Vec<PathBuf>,
/// The mods the port step gets and carries over (content, data tier).
pub portable: usize,
}
impl Imported {
pub fn title(&self) -> &str {
if self.pack.name.is_empty() {
&self.slug
} else {
&self.pack.name
}
}
pub fn count(&self, status: Status) -> usize {
self.rows.iter().filter(|r| r.status == status).count()
}
/// "Minecraft 1.21.1 · neoforge 21.1.259 · 496 mods".
pub fn summary(&self) -> String {
let mut parts = Vec::new();
if !self.pack.minecraft.is_empty() {
parts.push(format!("Minecraft {}", self.pack.minecraft));
}
if !self.pack.loader.is_empty() {
parts.push(format!("{} {}", self.pack.loader, self.pack.loader_version));
}
parts.push(format!("{} files", self.pack.files.len()));
parts.join(" · ")
}
/// What getting the jars did, in one line, or None before it ran.
pub fn jars(&self) -> Option<String> {
if self.fetched.files.is_empty() {
return None;
}
let mut parts = Vec::new();
for (how, what) in [
(How::Downloaded, "downloaded"),
(How::Local, "copied from your folder"),
(How::Present, "already here"),
(
How::NeedsKey,
"only on CurseForge (needs its API key: choose your installed instance instead)",
),
(How::NotFound, "not found"),
(How::Failed, "failed"),
] {
let n = self.fetched.count(how);
if n > 0 {
parts.push(format!("{n} {what}"));
}
}
Some(format!("Jars: {}.", parts.join(", ")))
}
}
/// Reads the pack in `work`.
pub fn load(work: &Path) -> Result<Imported, String> {
let pack: Pack = pipeline::read_json(&work.join("pack.json"))?;
let rows: Vec<Row> = pipeline::read_json(&work.join("coverage.json")).unwrap_or_default();
let records: Vec<horizon_port_pack::inventory::Record> =
pipeline::read_json(&work.join("inventory.json")).unwrap_or_default();
Ok(Imported {
slug: work
.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default(),
work: work.to_path_buf(),
pack,
rows,
fetched: Fetched::load(work),
mods: carried(work),
portable: records.iter().filter(|r| pipeline::portable(r)).count(),
})
}
/// Every imported pack, by name.
pub fn list() -> Vec<Imported> {
let mut packs: Vec<Imported> = fs::read_dir(ports_dir())
.into_iter()
.flatten()
.flatten()
.filter_map(|e| load(&e.path()).ok())
.collect();
packs.sort_by_key(|p| p.title().to_ascii_lowercase());
packs
}
/// The carried-over mods in a work folder (`mods/<id>/carry/` with its manifest).
pub fn carried(work: &Path) -> Vec<PathBuf> {
let mut mods: Vec<PathBuf> = fs::read_dir(work.join("mods"))
.into_iter()
.flatten()
.flatten()
.map(|e| e.path().join("carry"))
.filter(|c| c.join("horizon-mod.toml").is_file())
.collect();
mods.sort();
mods
}
/// Imports the pack at `path` into `ports/<slug>/` and writes its coverage report from
/// metadata (Modrinth answers by file hash; nothing is downloaded yet). Importing the same pack
/// again keeps the jars and ports it already has.
pub fn import(path: &Path, log: Log) -> Result<Imported, String> {
let pack = horizon_port_pack::import::import(path)?;
let name = if pack.name.is_empty() || pack.name == "modlist" {
path.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_default()
} else {
pack.name.clone()
};
let work = ports_dir().join(slug(&name));
log(format!("Importing {name} into {}", work.display()));
pipeline::import(path, &work, log)?;
pipeline::inventory(&work, false, log)?;
pipeline::report(&work, log)?;
load(&work)
}
/// Ports what this computer can: the portable mods' jars (from `from` when the player has them,
/// else the pack's links or Modrinth), carried over for `resources`, then the report again.
pub fn port(
work: &Path,
resources: Option<&Path>,
from: Option<&Path>,
log: Log,
) -> Result<Imported, String> {
pipeline::port(work, resources, from, log)?;
load(work)
}
/// Removes an imported pack: its jars, ports and the profile's saves.
pub fn remove(work: &Path) -> Result<(), String> {
if work.parent() != Some(ports_dir().as_path()) {
return Err(format!("{} is not an imported pack", work.display()));
}
fs::remove_dir_all(work).map_err(|e| format!("{}: {e}", work.display()))
}
/// The profile's own game home: saves, options.txt, logs.
pub fn profile_home(work: &Path) -> PathBuf {
work.join("home")
}
/// Turns the game's command into this pack's profile: its own home (the player's options.txt
/// copied in the first time, so keys and video settings carry over) and its carried-over mods.
pub fn apply_profile(cmd: &mut Command, work: &Path) -> Result<(), String> {
let mods = carried(work);
if mods.is_empty() {
return Err("Nothing is ported yet: port the pack first.".into());
}
let home = profile_home(work);
fs::create_dir_all(&home).map_err(|e| format!("{}: {e}", home.display()))?;
let options = home.join("options.txt");
let own = backend::game_home().join("options.txt");
if !options.exists() && own.is_file() {
let _ = fs::copy(own, &options);
}
cmd.current_dir(&home).env("HORIZON_HOME", &home);
for m in mods {
cmd.arg("--dev-mod").arg(m);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn slugs() {
assert_eq!(slug("All the Mods 10"), "all-the-mods-10");
assert_eq!(slug("Create: Above & Beyond!"), "create-above-beyond");
assert_eq!(slug(" "), "pack");
}
#[test]
fn a_profile_has_its_own_home_and_mods() {
let root =
std::env::temp_dir().join(format!("horizon-launcher-pack-{}", std::process::id()));
let _ = fs::remove_dir_all(&root);
let work = root.join("ports/small");
let mut cmd = Command::new("true");
assert!(apply_profile(&mut cmd, &work).is_err());
for id in ["a", "b"] {
let carry = work.join("mods").join(id).join("carry");
fs::create_dir_all(&carry).unwrap();
fs::write(carry.join("horizon-mod.toml"), "").unwrap();
}
// Left out: no manifest.
fs::create_dir_all(work.join("mods/c/carry")).unwrap();
apply_profile(&mut cmd, &work).unwrap();
let args: Vec<String> = cmd
.get_args()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert_eq!(args.len(), 4);
assert!(args[1].ends_with("a/carry") && args[3].ends_with("b/carry"));
assert_eq!(cmd.get_current_dir(), Some(profile_home(&work).as_path()));
assert!(profile_home(&work).is_dir());
fs::remove_dir_all(&root).unwrap();
}
}
+412
View File
@@ -0,0 +1,412 @@
//! The Modpacks page: import a pack, read its coverage report, port what this computer can and
//! play it as its own profile (`horizon_launcher::modpacks`).
use super::*;
use horizon_launcher::modpacks::{self, Imported};
use horizon_port_pack::report::Status;
use std::path::PathBuf;
/// The report's filter: every row, or one status.
pub(super) const FILTERS: [(Option<Status>, &str); 5] = [
(None, "All"),
(Some(Status::Ported), "Ported"),
(Some(Status::Partial), "Partial"),
(Some(Status::NotYet), "Not yet"),
(Some(Status::NotNeeded), "Not needed"),
];
/// Lines of the pipeline's log the page shows while it works.
const LOG_SHOWN: usize = 6;
impl Launcher {
fn open_pack(&self) -> Option<&Imported> {
let slug = self.pack_open.as_ref()?;
self.packs.iter().find(|p| &p.slug == slug)
}
/// Runs a pipeline step on a thread; its lines and its end arrive as messages.
fn pack_job(
&mut self,
job: impl FnOnce(&dyn Fn(String)) -> Result<Imported, String> + Send + 'static,
) {
if self.pack_busy {
return;
}
self.pack_busy = true;
self.pack_log.clear();
self.pack_error = None;
let tx = self.tx.clone();
std::thread::spawn(move || {
let lines = tx.clone();
let log = move |line: String| {
let _ = lines.send(Msg::PackLine(line));
};
let result = job(&log);
let _ = tx.send(Msg::PackDone(result.map(Box::new)));
});
}
/// A finished step: the pack's new state, opened.
pub(super) fn pack_done(&mut self, result: Result<Box<Imported>, String>) {
self.pack_busy = false;
match result {
Ok(pack) => {
self.pack_open = Some(pack.slug.clone());
self.packs.retain(|p| p.slug != pack.slug);
self.packs.push(*pack);
self.packs.sort_by_key(|p| p.title().to_ascii_lowercase());
}
Err(e) => self.pack_error = Some(e),
}
}
fn choose_pack(&mut self, folder: bool, cx: &mut Context<Self>) {
let paths = cx.prompt_for_paths(PathPromptOptions {
files: !folder,
directories: folder,
multiple: false,
prompt: Some("Import".into()),
});
cx.spawn(async move |this, cx| {
if let Ok(Ok(Some(mut paths))) = paths.await {
if let Some(path) = paths.pop() {
let _ = this.update(cx, |this, cx| {
this.pack_job(move |log| modpacks::import(&path, log));
cx.notify();
});
}
}
})
.detach();
}
/// Ports the open pack; `from` is a folder of the player's jars, chosen when `ask`.
fn port_pack(&mut self, ask: bool, cx: &mut Context<Self>) {
let Some(work) = self.open_pack().map(|p| p.work.clone()) else {
return;
};
let resources = self
.selected()
.filter(|tag| backend::is_prepared(tag))
.map(|tag| backend::resources(tag));
if !ask {
self.pack_job(move |log| modpacks::port(&work, resources.as_deref(), None, log));
return;
}
let paths = cx.prompt_for_paths(PathPromptOptions {
files: false,
directories: true,
multiple: false,
prompt: Some("Use these jars".into()),
});
cx.spawn(async move |this, cx| {
if let Ok(Ok(Some(mut paths))) = paths.await {
if let Some(from) = paths.pop() {
let _ = this.update(cx, |this, cx| {
this.pack_job(move |log| {
modpacks::port(&work, resources.as_deref(), Some(&from), log)
});
cx.notify();
});
}
}
})
.detach();
}
fn play_pack(&mut self, work: PathBuf) {
let Some(tag) = self.selected().cloned() else {
return;
};
if self.client.is_some() || self.starting_client.is_some() {
return;
}
self.starting_pack = Some(work);
self.start_client(tag);
}
pub(super) fn modpacks_page(&mut self, cx: &mut Context<Self>) -> Div {
let t = self.theme;
if self.packs_loaded.is_none() {
self.packs = modpacks::list();
if self.pack_open.is_none() {
self.pack_open = self.packs.first().map(|p| p.slug.clone());
}
self.packs_loaded = Some(Instant::now());
}
let header = page_header(
"Modpacks",
"Bring a Java modpack: see what Horizon runs of it, port that on this computer from \
your own downloads, and play it as its own profile. Nothing is uploaded or shared.",
&t,
);
let busy = self.pack_busy;
let pick = |id: &'static str, label: &'static str, folder: bool| {
let b = button(id, label, Kind::Secondary, &t);
if busy {
disabled(b)
} else {
b.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.choose_pack(folder, cx);
cx.notify();
}))
}
};
let actions = div()
.flex()
.flex_wrap()
.items_center()
.gap(px(8.))
.child(pick("import-file", "Import a pack file…", false))
.child(pick("import-folder", "Import an instance folder…", true))
.child(text(theme::CAPTION).text_color(t.muted).child(
".mrpack (Modrinth), .zip (CurseForge), or a Prism, MultiMC or CurseForge instance",
));
let mut page = div()
.flex()
.flex_col()
.gap(px(32.))
.child(header)
.child(actions);
if busy || !self.pack_log.is_empty() {
page = page.child(self.pack_log_plate(&t));
}
if let Some(e) = &self.pack_error {
page = page.child(notice(e.clone(), &t));
}
if self.packs.is_empty() {
return page.child(centered(
"No modpack yet. Import one to see what Horizon can run of it.",
&t,
));
}
if self.packs.len() > 1 {
let mut list = div().flex().flex_col().border_t_1().border_color(t.rule);
for (i, p) in self.packs.iter().enumerate() {
let open = self.pack_open.as_ref() == Some(&p.slug);
let slug = p.slug.clone();
let right = if open {
caps("Open").text_color(t.accent).into_any_element()
} else {
button(format!("open-{slug}"), "Open", Kind::Ghost, &t)
.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.pack_open = Some(slug.clone());
cx.notify();
}))
.into_any_element()
};
list = list.child(index_row(
i + 1,
p.title().to_string(),
Some(p.summary().into_any_element()),
Some(right),
&t,
));
}
page = page.child(list);
}
match self.pack_detail(cx) {
Some(detail) => page.child(detail),
None => page,
}
}
fn pack_log_plate(&self, t: &Theme) -> Div {
let start = self.pack_log.len().saturating_sub(LOG_SHOWN);
plate(t)
.flex()
.flex_col()
.gap(px(4.))
.p(px(16.))
.child(
caps(if self.pack_busy { "Working" } else { "Done" })
.text_color(if self.pack_busy { t.accent } else { t.muted }),
)
.children(self.pack_log.iter().skip(start).map(|line| {
text(theme::CAPTION)
.font_family(theme::MONO)
.text_color(t.ink_soft)
.truncate()
.child(line.clone())
}))
}
fn pack_detail(&self, cx: &mut Context<Self>) -> Option<Div> {
let t = self.theme;
let p = self.open_pack()?;
let mut counts = div().flex().gap(px(12.));
for (status, label) in FILTERS.iter().skip(1) {
let status = status.expect("the first filter is All");
let color = match status {
Status::Ported => t.success,
Status::Partial => t.accent,
_ => t.ink,
};
counts = counts.child(
plate(&t)
.flex()
.flex_col()
.flex_1()
.gap(px(4.))
.p(px(16.))
.child(
text(theme::DISPLAY)
.text_color(color)
.child(p.count(status).to_string()),
)
.child(caps(*label).text_color(t.muted)),
);
}
let can_play = self.selected().is_some_and(|tag| backend::is_prepared(tag));
let running = self.client.is_some() || self.starting_client.is_some();
let mut buttons = div().flex().flex_wrap().items_center().gap(px(8.));
let play_label = if p.mods.is_empty() {
"Play".to_string()
} else {
format!("Play with {} mods", p.mods.len())
};
let mut play = button("pack-play", play_label, Kind::Primary, &t);
if p.mods.is_empty() || !can_play || running || self.pack_busy {
play = disabled(play);
} else {
let work = p.work.clone();
play = play.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.play_pack(work.clone());
cx.notify();
}));
}
let port_label = format!("Port {} mods", p.portable);
let mut port = button("pack-port", port_label, Kind::Secondary, &t);
let mut from = button("pack-from", "Use jars from my instance…", Kind::Ghost, &t);
if self.pack_busy || p.portable == 0 {
port = disabled(port);
from = disabled(from);
} else {
port = port.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
this.port_pack(false, cx);
cx.notify();
}));
from = from.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
this.port_pack(true, cx);
cx.notify();
}));
}
let confirming = self.confirm_remove.as_deref() == Some(p.slug.as_str());
let slug = p.slug.clone();
let work = p.work.clone();
let remove = button(
"pack-remove",
if confirming {
"Remove for good"
} else {
"Remove"
},
if confirming {
Kind::Secondary
} else {
Kind::Ghost
},
&t,
)
.when(confirming, |b| b.text_color(t.danger))
.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
if this.confirm_remove.as_ref() == Some(&slug) {
match modpacks::remove(&work) {
Ok(()) => {
this.packs.retain(|p| p.slug != slug);
this.pack_open = this.packs.first().map(|p| p.slug.clone());
}
Err(e) => this.pack_error = Some(e),
}
this.confirm_remove = None;
} else {
this.confirm_remove = Some(slug.clone());
}
cx.notify();
}));
buttons = buttons.child(play).child(port).child(from).child(remove);
let mut notes = vec![format!(
"Port gets the jars of the {} mods this computer can port today (content with data \
and assets only) from the pack's own links, Modrinth, or your folder, and carries \
them over. The ports stay here, in {}.",
p.portable,
short(&p.work)
)];
if let Some(jars) = p.jars() {
notes.push(jars);
}
if !can_play {
notes.push("Playing needs a prepared Horizon version (Play page).".into());
}
let mut rows: Vec<&horizon_port_pack::report::Row> = p
.rows
.iter()
.filter(|r| self.pack_filter.is_none_or(|s| r.status == s))
.collect();
rows.sort_by(|a, b| (a.status, &a.key).cmp(&(b.status, &b.key)));
let filter = segments("pack-filter", &FILTERS, self.pack_filter, &t, {
let this = cx.entity().downgrade();
move |value, _, cx| {
let _ = this.update(cx, |this, cx| {
this.pack_filter = value;
cx.notify();
});
}
});
let mut list = div().flex().flex_col().border_t_1().border_color(t.rule);
for (i, r) in rows.iter().enumerate() {
let color = match r.status {
Status::Ported => t.success,
Status::Partial => t.accent,
Status::NotYet => t.ink_soft,
Status::NotNeeded => t.muted,
};
let name = if r.name.is_empty() || r.name == r.key {
r.key.clone()
} else {
format!("{} ({})", r.name, r.key)
};
let detail = format!("{} · {} · {}: {}", r.class, r.tier, r.license, r.reason);
list = list.child(index_row(
i + 1,
name,
Some(detail.into_any_element()),
Some(
caps(r.status.label())
.flex_none()
.text_color(color)
.into_any_element(),
),
&t,
));
}
Some(
div()
.flex()
.flex_col()
.gap(px(24.))
.child(
div()
.flex()
.flex_col()
.gap(px(4.))
.child(
text(theme::TITLE)
.text_color(t.ink)
.child(p.title().to_string()),
)
.child(text(theme::UI).text_color(t.muted).child(p.summary())),
)
.child(counts)
.child(buttons)
.children(self.client_error.clone().map(|e| notice(e, &t)))
.children(notes.into_iter().map(|n| {
text(theme::CAPTION)
.max_w(px(720.))
.text_color(t.muted)
.child(n)
}))
.child(div().flex().child(filter))
.child(list),
)
}
}