Launcher: instances, each with its own game folder
The game's folder stays the default instance, "Horizon", where it is; imported and registry modpacks are listed as instances in their own folders; new ones go to instances/<slug>/ in the game's folder, empty (the player's options and offline name) or a copy of another (never sessions, logs or telemetry). Names, icons and groups live in the launcher's instances.json, so nothing moves. Play, `play --instance` and MCP play start the selected instance, which follows the launcher's data collection answer and No AI. Crash reports are read from the run's own folder. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -50,6 +50,7 @@ Start the client.
|
||||
|
||||
horizon-launcher play
|
||||
|
||||
- `--instance`: The instance to play (its name or id; default: the selected one)
|
||||
- `--world`: Open or create this world (a folder under saves) at once
|
||||
- `--creative`: Creative mode for a new world
|
||||
- `--join`: Join a friend's world with its invite code
|
||||
@@ -257,6 +258,68 @@ Upload a benchmark report (docs/benchmark-report.md); it is printed first.
|
||||
|
||||
MCP: `data_benchmark`, only when the player asks.
|
||||
|
||||
## `horizon-launcher instance list`
|
||||
|
||||
The instances, each with its game folder (* = the one Play starts).
|
||||
|
||||
horizon-launcher instance list
|
||||
|
||||
MCP: `instance_list`.
|
||||
|
||||
## `horizon-launcher instance create`
|
||||
|
||||
Make an instance: empty but for your options and name, or a copy of another one's worlds, options and packs.
|
||||
|
||||
horizon-launcher instance create <NAME>
|
||||
|
||||
- `NAME`
|
||||
- `--copy`: The instance to copy (its name or id)
|
||||
|
||||
MCP: `instance_create`.
|
||||
|
||||
## `horizon-launcher instance rename`
|
||||
|
||||
Rename an instance (its folder stays).
|
||||
|
||||
horizon-launcher instance rename <INSTANCE> <NAME>
|
||||
|
||||
- `INSTANCE`
|
||||
- `NAME`
|
||||
|
||||
MCP: `instance_rename`.
|
||||
|
||||
## `horizon-launcher instance icon`
|
||||
|
||||
Set an instance's icon: a block or item name from your prepared files (grass_block), a colour (#3fa7d6), or none.
|
||||
|
||||
horizon-launcher instance icon <INSTANCE> <ICON>
|
||||
|
||||
- `INSTANCE`
|
||||
- `ICON`
|
||||
|
||||
MCP: `instance_icon`.
|
||||
|
||||
## `horizon-launcher instance group`
|
||||
|
||||
Put an instance in a sidebar group, or take it out with no group.
|
||||
|
||||
horizon-launcher instance group <INSTANCE> [GROUP]
|
||||
|
||||
- `INSTANCE`
|
||||
- `GROUP`
|
||||
|
||||
MCP: `instance_group`.
|
||||
|
||||
## `horizon-launcher instance select`
|
||||
|
||||
Make Play start this instance.
|
||||
|
||||
horizon-launcher instance select <INSTANCE>
|
||||
|
||||
- `INSTANCE`
|
||||
|
||||
MCP: `instance_select`.
|
||||
|
||||
## `horizon-launcher modpack list`
|
||||
|
||||
The imported packs and their coverage (the default).
|
||||
|
||||
+13
-1
@@ -69,6 +69,14 @@ The opening, then Play ([clip](docs/opening.webm)):
|
||||
access controls, one click changes them so friends you share with reach only the server's
|
||||
port (Remove the limit undoes it); custom access controls are never rewritten, the page gives
|
||||
the rule to add instead. Horizon never turns on Funnel.
|
||||
- **Instances**: separate game folders, each with its own worlds, options and packs. The game's
|
||||
folder stays the first one, "Horizon", exactly where it was; imported and registry modpacks are
|
||||
instances too, in their own folders as before; new ones go to `instances/<name>/` in the game's
|
||||
folder, empty but for the player's options and name, or a copy of another instance (never its
|
||||
sign-in sessions, logs or data collection state). Names, icons (a block or item texture from the
|
||||
player's prepared files, or a colour) and groups are kept in `instances.json` in the launcher's
|
||||
data folder, so renaming moves nothing. Every instance follows the launcher's data collection
|
||||
answer and No AI.
|
||||
- **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,
|
||||
@@ -152,7 +160,7 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
|
||||
horizon-launcher install <tag|latest>
|
||||
horizon-launcher remove <tag>
|
||||
horizon-launcher prepare [--minecraft <dir>] [--version <tag>]
|
||||
horizon-launcher play [--version <tag>] [--arg <ARG>]... start the client; --arg passes an extra argument through (repeatable)
|
||||
horizon-launcher play [--version <tag>] [--instance <name>] [--arg <ARG>]... start the client; --arg passes an extra argument through (repeatable)
|
||||
horizon-launcher server [--dir <dir>] [--version <tag>] [--accept-eula]
|
||||
horizon-launcher notes [<tag>] patch notes as plain text
|
||||
horizon-launcher links the Discord, sponsor and website links
|
||||
@@ -164,6 +172,10 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
|
||||
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 instance [list] the instances and their game folders (* = Play starts it)
|
||||
horizon-launcher instance create <name> [--copy <instance>] empty, or a copy of one's worlds, options and packs
|
||||
horizon-launcher instance rename|icon|group <instance> <value> icon: a block or item name, #rrggbb or none
|
||||
horizon-launcher instance select <instance> make Play start it
|
||||
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
|
||||
|
||||
@@ -1585,9 +1585,10 @@ pub fn newest_crash_report() -> Option<PathBuf> {
|
||||
crash_reports_in(&crash_reports_dir()).pop()
|
||||
}
|
||||
|
||||
/// The newest crash report written at or after `since` (one from the run that started then).
|
||||
pub fn crash_report_since(since: std::time::SystemTime) -> Option<PathBuf> {
|
||||
crash_report_in_since(&crash_reports_dir(), since)
|
||||
/// The newest crash report the game playing in `home` wrote at or after `since` (one from the
|
||||
/// run that started then).
|
||||
pub fn crash_report_since(home: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
|
||||
crash_report_in_since(&home.join("crash-reports"), since)
|
||||
}
|
||||
|
||||
fn crash_report_in_since(dir: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
|
||||
@@ -2517,6 +2518,9 @@ pub enum Appearance {
|
||||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||||
pub struct Settings {
|
||||
pub selected: Option<String>,
|
||||
/// The instance Play starts (`instances`), by id. Unset means Horizon, the game's home.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub instance: Option<String>,
|
||||
pub minecraft_dir: Option<PathBuf>,
|
||||
pub server_dir: Option<PathBuf>,
|
||||
/// Unset means on: only a player who turned it off has `false` here. 0.1.1 wrote its
|
||||
|
||||
@@ -37,7 +37,7 @@ pub fn list() -> Vec<Installed> {
|
||||
list_in(&packs_dir())
|
||||
}
|
||||
|
||||
fn list_in(dir: &Path) -> Vec<Installed> {
|
||||
pub(crate) fn list_in(dir: &Path) -> Vec<Installed> {
|
||||
let mut packs: Vec<Installed> = fs::read_dir(dir)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
use clap::{Parser, Subcommand};
|
||||
use horizon_launcher::account::{self, Accounts};
|
||||
use horizon_launcher::backend::{self, Release};
|
||||
use horizon_launcher::instances;
|
||||
use std::io::{IsTerminal, Write};
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
@@ -155,6 +156,32 @@ enum ModpackCmd {
|
||||
Remove { pack: String },
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum InstanceCmd {
|
||||
/// The instances, each with its game folder (* = the one Play starts)
|
||||
List,
|
||||
/// Make an instance: empty but for your options and name, or a copy of another one's
|
||||
/// worlds, options and packs
|
||||
Create {
|
||||
name: String,
|
||||
/// The instance to copy (its name or id)
|
||||
#[arg(long)]
|
||||
copy: Option<String>,
|
||||
},
|
||||
/// Rename an instance (its folder stays)
|
||||
Rename { instance: String, name: String },
|
||||
/// Set an instance's icon: a block or item name from your prepared files (grass_block),
|
||||
/// a colour (#3fa7d6), or none
|
||||
Icon { instance: String, icon: String },
|
||||
/// Put an instance in a sidebar group, or take it out with no group
|
||||
Group {
|
||||
instance: String,
|
||||
group: Option<String>,
|
||||
},
|
||||
/// Make Play start this instance
|
||||
Select { instance: String },
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum ModsCmd {
|
||||
/// What the browser installed (the default)
|
||||
@@ -261,6 +288,9 @@ enum Cmd {
|
||||
Play {
|
||||
#[arg(long)]
|
||||
version: Option<String>,
|
||||
/// The instance to play (its name or id; default: the selected one)
|
||||
#[arg(long)]
|
||||
instance: Option<String>,
|
||||
/// Open or create this world (a folder under saves) at once
|
||||
#[arg(long)]
|
||||
world: Option<String>,
|
||||
@@ -341,6 +371,11 @@ enum Cmd {
|
||||
#[command(subcommand)]
|
||||
action: Option<DataCmd>,
|
||||
},
|
||||
/// Instances: separate game folders, each with its own worlds, options and packs
|
||||
Instance {
|
||||
#[command(subcommand)]
|
||||
action: Option<InstanceCmd>,
|
||||
},
|
||||
/// 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 {
|
||||
@@ -606,12 +641,18 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
|
||||
}
|
||||
Cmd::Play {
|
||||
version,
|
||||
instance,
|
||||
world,
|
||||
creative,
|
||||
join,
|
||||
arg,
|
||||
} => {
|
||||
let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
|
||||
let instance = match instance {
|
||||
Some(name) => instances::find(&name)?,
|
||||
None => instances::selected(),
|
||||
};
|
||||
instances::apply(&mut cmd, &instance)?;
|
||||
if let Some(code) = join {
|
||||
backend::join_friend(&mut cmd, &code)?;
|
||||
}
|
||||
@@ -784,6 +825,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
|
||||
println!("Horizon is in the applications menu.");
|
||||
}
|
||||
}
|
||||
Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
|
||||
Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
|
||||
Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
|
||||
Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
|
||||
@@ -1337,6 +1379,61 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
|
||||
use instances::Icon;
|
||||
let value = |i: &instances::Instance, selected: bool| {
|
||||
serde_json::json!({
|
||||
"id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
|
||||
"home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
|
||||
})
|
||||
};
|
||||
let line = |i: &instances::Instance, selected: bool| {
|
||||
let mark = if selected { "*" } else { " " };
|
||||
let group = i
|
||||
.group
|
||||
.as_ref()
|
||||
.map(|g| format!(" [{g}]"))
|
||||
.unwrap_or_default();
|
||||
println!(
|
||||
"{mark} {} ({}){group}\n {}",
|
||||
i.name,
|
||||
i.id,
|
||||
i.home.display()
|
||||
);
|
||||
};
|
||||
let changed = |i: instances::Instance| {
|
||||
let selected = i.id == instances::selected().id;
|
||||
match as_json {
|
||||
true => json(value(&i, selected)),
|
||||
false => line(&i, selected),
|
||||
}
|
||||
};
|
||||
match action {
|
||||
InstanceCmd::List => {
|
||||
let selected = instances::selected().id;
|
||||
let all = instances::list();
|
||||
if as_json {
|
||||
json(all.iter().map(|i| value(i, i.id == selected)).collect());
|
||||
} else {
|
||||
all.iter().for_each(|i| line(i, i.id == selected));
|
||||
}
|
||||
}
|
||||
InstanceCmd::Create { name, copy } => changed(instances::create(&name, copy.as_deref())?),
|
||||
InstanceCmd::Rename { instance, name } => {
|
||||
changed(instances::edit(&instance, |m| m.name = Some(name))?)
|
||||
}
|
||||
InstanceCmd::Icon { instance, icon } => {
|
||||
let icon = (icon != "none").then(|| Icon::parse(&icon)).transpose()?;
|
||||
changed(instances::edit(&instance, |m| m.icon = icon)?)
|
||||
}
|
||||
InstanceCmd::Group { instance, group } => {
|
||||
changed(instances::edit(&instance, |m| m.group = group)?)
|
||||
}
|
||||
InstanceCmd::Select { instance } => changed(instances::select(&instance)?),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
|
||||
use horizon_launcher::browser::horizon;
|
||||
use horizon_launcher::modpacks::{self, Imported};
|
||||
|
||||
@@ -0,0 +1,414 @@
|
||||
//! Instances: separate game folders, each with its own worlds, options and packs.
|
||||
//!
|
||||
//! Nothing that exists moves. The game's home (`backend::game_home`) stays the default instance,
|
||||
//! "Horizon", with its saves and options where they are. Imported modpacks (`ports/<pack>/home/`)
|
||||
//! and registry modpacks (`horizon-packs/<id>/home/`) are instances too, played from their own
|
||||
//! folders as before. New instances get `instances/<slug>/` in the game's home. What the player
|
||||
//! chooses about an instance (its name, icon, group) is kept in `instances.json` in the
|
||||
//! launcher's data folder, so renaming one never moves a folder.
|
||||
use crate::backend;
|
||||
use crate::browser::horizon::pack as registry_pack;
|
||||
use crate::modpacks;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
/// The default instance's id: the game's home itself.
|
||||
pub const DEFAULT: &str = "horizon";
|
||||
const FILE: &str = "instances.json";
|
||||
/// Where new instances live, in the game's home.
|
||||
const OWN: &str = "instances";
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
/// The game's home: what every player had before instances.
|
||||
Default,
|
||||
/// Made in the launcher: `instances/<slug>/`.
|
||||
Own,
|
||||
/// An imported Java modpack (modpacks.rs).
|
||||
Port,
|
||||
/// A modpack from Horizon's registry.
|
||||
Pack,
|
||||
}
|
||||
|
||||
/// What an instance shows in the sidebar: a block or item texture from the player's prepared
|
||||
/// files (never shipped), or a colour.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum Icon {
|
||||
/// A texture name: `grass_block` (block/ is looked in first, then item/).
|
||||
Texture(String),
|
||||
/// `#rrggbb`.
|
||||
Colour(String),
|
||||
}
|
||||
|
||||
impl Icon {
|
||||
/// `#3fa7d6` is a colour; a texture's name is lowercase letters, digits and `_`.
|
||||
pub fn parse(text: &str) -> Result<Icon, String> {
|
||||
let text = text.trim();
|
||||
if let Some(hex) = text.strip_prefix('#') {
|
||||
if hex.len() == 6 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
|
||||
return Ok(Icon::Colour(format!("#{}", hex.to_ascii_lowercase())));
|
||||
}
|
||||
} else if !text.is_empty()
|
||||
&& text
|
||||
.chars()
|
||||
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
|
||||
{
|
||||
return Ok(Icon::Texture(text.into()));
|
||||
}
|
||||
Err(format!(
|
||||
"{text}: give a block or item name (grass_block) or a colour (#3fa7d6)"
|
||||
))
|
||||
}
|
||||
|
||||
/// The texture's file in prepared resources, if it is a texture they hold.
|
||||
pub fn texture(&self, resources: &Path) -> Option<PathBuf> {
|
||||
let Icon::Texture(name) = self else {
|
||||
return None;
|
||||
};
|
||||
let textures = resources.join("assets/minecraft/textures");
|
||||
["block", "item"]
|
||||
.iter()
|
||||
.map(|kind| textures.join(kind).join(format!("{name}.png")))
|
||||
.find(|p| p.is_file())
|
||||
}
|
||||
}
|
||||
|
||||
/// The player's choices about one instance.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct Meta {
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub name: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub icon: Option<Icon>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub group: Option<String>,
|
||||
}
|
||||
|
||||
/// `instances.json`: each instance's choices, by id.
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
||||
struct Store {
|
||||
#[serde(default)]
|
||||
instances: BTreeMap<String, Meta>,
|
||||
}
|
||||
|
||||
impl Store {
|
||||
fn load(data: &Path) -> Store {
|
||||
fs::read_to_string(data.join(FILE))
|
||||
.ok()
|
||||
.and_then(|t| serde_json::from_str(&t).ok())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
fn save(&self, data: &Path) -> Result<(), String> {
|
||||
fs::create_dir_all(data).map_err(|e| format!("{}: {e}", data.display()))?;
|
||||
let text = serde_json::to_string_pretty(self).unwrap();
|
||||
fs::write(data.join(FILE), text).map_err(|e| format!("{FILE}: {e}"))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Instance {
|
||||
/// `horizon`, an own instance's folder name, `port:<pack>` or `pack:<id>`.
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub kind: Kind,
|
||||
/// The folder the pack's tools work in: the game's home for Default and Own instances.
|
||||
pub work: PathBuf,
|
||||
/// The game folder it plays in: saves, options.txt, packs.
|
||||
pub home: PathBuf,
|
||||
pub icon: Option<Icon>,
|
||||
pub group: Option<String>,
|
||||
}
|
||||
|
||||
/// The instances, by the default game home and the launcher's data folder: Horizon first, then
|
||||
/// by group and name.
|
||||
pub fn list() -> Vec<Instance> {
|
||||
list_in(&backend::game_home(), &backend::data_dir())
|
||||
}
|
||||
|
||||
fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
|
||||
let store = Store::load(data);
|
||||
let mut found = vec![(
|
||||
DEFAULT.to_string(),
|
||||
"Horizon".to_string(),
|
||||
Kind::Default,
|
||||
game_home.to_path_buf(),
|
||||
game_home.to_path_buf(),
|
||||
)];
|
||||
let mut own: Vec<_> = fs::read_dir(game_home.join(OWN))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.filter(|e| e.path().is_dir())
|
||||
.filter_map(|e| e.file_name().into_string().ok())
|
||||
.collect();
|
||||
own.sort();
|
||||
for slug in own {
|
||||
let dir = game_home.join(OWN).join(&slug);
|
||||
found.push((slug.clone(), slug, Kind::Own, dir.clone(), dir));
|
||||
}
|
||||
for p in modpacks::list_in(&game_home.join("ports")) {
|
||||
let home = modpacks::profile_home(&p.work);
|
||||
found.push((
|
||||
format!("port:{}", p.slug),
|
||||
p.title().into(),
|
||||
Kind::Port,
|
||||
p.work,
|
||||
home,
|
||||
));
|
||||
}
|
||||
for p in registry_pack::list_in(&game_home.join("horizon-packs")) {
|
||||
let home = registry_pack::home(&p.work);
|
||||
found.push((format!("pack:{}", p.id), p.name, Kind::Pack, p.work, home));
|
||||
}
|
||||
let mut out: Vec<Instance> = found
|
||||
.into_iter()
|
||||
.map(|(id, name, kind, work, home)| {
|
||||
let meta = store.instances.get(&id).cloned().unwrap_or_default();
|
||||
Instance {
|
||||
name: meta.name.unwrap_or(name),
|
||||
icon: meta.icon,
|
||||
group: meta.group,
|
||||
id,
|
||||
kind,
|
||||
work,
|
||||
home,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
out[1..].sort_by_key(|i| (i.group.clone(), i.name.to_lowercase()));
|
||||
out
|
||||
}
|
||||
|
||||
/// The instance an id, a name (any case) or a pack's folder name names.
|
||||
pub fn find(query: &str) -> Result<Instance, String> {
|
||||
find_in(&list(), query)
|
||||
}
|
||||
|
||||
fn find_in(all: &[Instance], query: &str) -> Result<Instance, String> {
|
||||
let q = query.trim();
|
||||
let bare = |id: &str| id.split_once(':').map_or(id, |(_, rest)| rest).to_string();
|
||||
all.iter()
|
||||
.find(|i| i.id == q)
|
||||
.or_else(|| all.iter().find(|i| i.name.eq_ignore_ascii_case(q)))
|
||||
.or_else(|| all.iter().find(|i| bare(&i.id) == q))
|
||||
.cloned()
|
||||
.ok_or_else(|| format!("No instance {q}: horizon-launcher instance list shows them"))
|
||||
}
|
||||
|
||||
/// The instance Play starts: the one picked in the launcher, else Horizon.
|
||||
pub fn selected() -> Instance {
|
||||
let all = list();
|
||||
backend::Settings::load()
|
||||
.instance
|
||||
.and_then(|id| all.iter().find(|i| i.id == id).cloned())
|
||||
.unwrap_or_else(|| all[0].clone())
|
||||
}
|
||||
|
||||
pub fn select(query: &str) -> Result<Instance, String> {
|
||||
let instance = find(query)?;
|
||||
let mut settings = backend::Settings::load();
|
||||
settings.instance = (instance.kind != Kind::Default).then(|| instance.id.clone());
|
||||
settings.save();
|
||||
Ok(instance)
|
||||
}
|
||||
|
||||
/// What a copy of a game folder leaves out: other instances and packs, logs and crash reports,
|
||||
/// caches, data collection's state, and sign-in sessions (a session never leaves its folder).
|
||||
const NOT_COPIED: &[&str] = &[
|
||||
OWN,
|
||||
"ports",
|
||||
"horizon-packs",
|
||||
"logs",
|
||||
"crash-reports",
|
||||
"sessions",
|
||||
"telemetry",
|
||||
"mod-browser",
|
||||
".horizon-cache",
|
||||
];
|
||||
|
||||
/// Files of the player, not of one instance, that a new instance starts with: the keys and video
|
||||
/// settings, and the offline name (so the player stays the same player in its worlds).
|
||||
const PLAYER_FILES: &[&str] = &["options.txt", "horizon-player.txt"];
|
||||
|
||||
/// Creates an instance named `name`: empty but for the player's options and offline name, or a
|
||||
/// copy of `from`'s game folder (its worlds, options and packs). Nothing of `from` changes.
|
||||
pub fn create(name: &str, from: Option<&str>) -> Result<Instance, String> {
|
||||
let from = from.map(find).transpose()?;
|
||||
create_in(
|
||||
&backend::game_home(),
|
||||
&backend::data_dir(),
|
||||
name,
|
||||
from.as_ref(),
|
||||
)
|
||||
}
|
||||
|
||||
fn create_in(
|
||||
game_home: &Path,
|
||||
data: &Path,
|
||||
name: &str,
|
||||
from: Option<&Instance>,
|
||||
) -> Result<Instance, String> {
|
||||
let name = name.trim();
|
||||
if name.is_empty() {
|
||||
return Err("An instance needs a name.".into());
|
||||
}
|
||||
let all = list_in(game_home, data);
|
||||
if all.iter().any(|i| i.name.eq_ignore_ascii_case(name)) {
|
||||
return Err(format!("There is already an instance called {name}."));
|
||||
}
|
||||
if let Some(from) = from.filter(|f| matches!(f.kind, Kind::Port | Kind::Pack)) {
|
||||
return Err(format!(
|
||||
"{} plays its pack's mods: import the pack again for a second copy.",
|
||||
from.name
|
||||
));
|
||||
}
|
||||
let base = modpacks::slug(name);
|
||||
let taken = |s: &str| s == DEFAULT || game_home.join(OWN).join(s).exists();
|
||||
let slug = (1..)
|
||||
.map(|n| {
|
||||
if n == 1 {
|
||||
base.clone()
|
||||
} else {
|
||||
format!("{base}-{n}")
|
||||
}
|
||||
})
|
||||
.find(|s| !taken(s))
|
||||
.unwrap();
|
||||
let dir = game_home.join(OWN).join(&slug);
|
||||
let made = match from {
|
||||
Some(from) => copy_home(&from.home, &dir),
|
||||
None => fs::create_dir_all(&dir).and_then(|()| {
|
||||
for f in PLAYER_FILES {
|
||||
let own = game_home.join(f);
|
||||
if own.is_file() {
|
||||
fs::copy(own, dir.join(f))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}),
|
||||
};
|
||||
if let Err(e) = made {
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
return Err(format!("Could not make {}: {e}", dir.display()));
|
||||
}
|
||||
let mut store = Store::load(data);
|
||||
let meta = store.instances.entry(slug.clone()).or_default();
|
||||
meta.name = (name != slug).then(|| name.to_string());
|
||||
meta.icon = from.and_then(|f| f.icon.clone());
|
||||
meta.group = from.and_then(|f| f.group.clone());
|
||||
store.save(data)?;
|
||||
find_in(&list_in(game_home, data), &slug)
|
||||
}
|
||||
|
||||
fn copy_home(from: &Path, to: &Path) -> std::io::Result<()> {
|
||||
fs::create_dir_all(to)?;
|
||||
for entry in fs::read_dir(from)? {
|
||||
let entry = entry?;
|
||||
let name = entry.file_name();
|
||||
if NOT_COPIED.iter().any(|n| name == *n) {
|
||||
continue;
|
||||
}
|
||||
let path = entry.path();
|
||||
if entry.file_type()?.is_dir() {
|
||||
copy_dir(&path, &to.join(&name))?;
|
||||
} else {
|
||||
fs::copy(&path, to.join(&name))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
|
||||
fs::create_dir_all(to)?;
|
||||
for entry in fs::read_dir(from)? {
|
||||
let entry = entry?;
|
||||
let target = to.join(entry.file_name());
|
||||
if entry.file_type()?.is_dir() {
|
||||
copy_dir(&entry.path(), &target)?;
|
||||
} else {
|
||||
fs::copy(entry.path(), target)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Changes what the player chose about an instance: its name, icon or group. No folder moves.
|
||||
pub fn edit(query: &str, change: impl FnOnce(&mut Meta)) -> Result<Instance, String> {
|
||||
edit_in(&backend::game_home(), &backend::data_dir(), query, change)
|
||||
}
|
||||
|
||||
fn edit_in(
|
||||
game_home: &Path,
|
||||
data: &Path,
|
||||
query: &str,
|
||||
change: impl FnOnce(&mut Meta),
|
||||
) -> Result<Instance, String> {
|
||||
let all = list_in(game_home, data);
|
||||
let instance = find_in(&all, query)?;
|
||||
let mut store = Store::load(data);
|
||||
let meta = store.instances.entry(instance.id.clone()).or_default();
|
||||
change(meta);
|
||||
meta.name = meta.name.take().map(|n| n.trim().to_string());
|
||||
meta.group = meta
|
||||
.group
|
||||
.take()
|
||||
.map(|g| g.trim().to_string())
|
||||
.filter(|g| !g.is_empty());
|
||||
if let Some(name) = &meta.name {
|
||||
if name.is_empty() {
|
||||
return Err("An instance needs a name.".into());
|
||||
}
|
||||
if all
|
||||
.iter()
|
||||
.any(|i| i.id != instance.id && i.name.eq_ignore_ascii_case(name))
|
||||
{
|
||||
return Err(format!("There is already an instance called {name}."));
|
||||
}
|
||||
}
|
||||
store.save(data)?;
|
||||
find_in(&list_in(game_home, data), &instance.id)
|
||||
}
|
||||
|
||||
/// Turns the game's command into this instance: its own game folder, and a pack's mods. The
|
||||
/// player's answers that hold everywhere follow it in: data collection and No AI as the
|
||||
/// launcher has them, and options.txt and the offline name when it has none yet.
|
||||
pub fn apply(cmd: &mut Command, instance: &Instance) -> Result<(), String> {
|
||||
match instance.kind {
|
||||
Kind::Default => return Ok(()),
|
||||
Kind::Own => {
|
||||
fs::create_dir_all(&instance.home)
|
||||
.map_err(|e| format!("{}: {e}", instance.home.display()))?;
|
||||
cmd.current_dir(&instance.home)
|
||||
.env("HORIZON_HOME", &instance.home);
|
||||
}
|
||||
Kind::Port | Kind::Pack => modpacks::apply_profile(cmd, &instance.work)?,
|
||||
}
|
||||
follow_player(&backend::game_home(), &instance.home);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn follow_player(game_home: &Path, home: &Path) {
|
||||
for f in PLAYER_FILES {
|
||||
if !home.join(f).exists() && game_home.join(f).is_file() {
|
||||
let _ = fs::copy(game_home.join(f), home.join(f));
|
||||
}
|
||||
}
|
||||
let consent = horizon_telemetry::consent::Consent::path(game_home);
|
||||
if consent.is_file() {
|
||||
let to = horizon_telemetry::consent::Consent::path(home);
|
||||
let _ = fs::create_dir_all(to.parent().unwrap());
|
||||
let _ = fs::copy(consent, to);
|
||||
}
|
||||
let no_ai = horizon_core::no_ai::is_on(game_home);
|
||||
if horizon_core::no_ai::is_on(home) != no_ai {
|
||||
let _ = horizon_core::no_ai::set(home, no_ai);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "instances/tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,203 @@
|
||||
use super::*;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn scratch(name: &str) -> PathBuf {
|
||||
let root = std::env::temp_dir().join(format!(
|
||||
"horizon-launcher-instances-{name}-{}",
|
||||
std::process::id()
|
||||
));
|
||||
let _ = fs::remove_dir_all(&root);
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
root
|
||||
}
|
||||
|
||||
fn put(path: &Path, text: &str) {
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(path, text).unwrap();
|
||||
}
|
||||
|
||||
/// Every file under `dir`, relative, with its bytes.
|
||||
fn files(dir: &Path) -> BTreeMap<PathBuf, Vec<u8>> {
|
||||
fn walk(root: &Path, dir: &Path, out: &mut BTreeMap<PathBuf, Vec<u8>>) {
|
||||
for e in fs::read_dir(dir).unwrap().flatten() {
|
||||
let p = e.path();
|
||||
if p.is_dir() {
|
||||
walk(root, &p, out);
|
||||
} else {
|
||||
out.insert(p.strip_prefix(root).unwrap().into(), fs::read(&p).unwrap());
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut out = BTreeMap::new();
|
||||
walk(dir, dir, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// A game home as a player has it before instances: worlds, options, packs, a session, an
|
||||
/// imported modpack and a registry modpack with their own worlds.
|
||||
fn player_home(home: &Path) {
|
||||
put(&home.join("saves/World/level.dat"), "world");
|
||||
put(&home.join("saves/World/region/r.0.0.mca"), "region");
|
||||
put(&home.join("saves/Other/level.dat"), "other");
|
||||
put(&home.join("options.txt"), "fov:90\n");
|
||||
put(&home.join("horizon-player.txt"), "name:Player123\n");
|
||||
put(&home.join("resourcepacks/faithful.zip"), "pack");
|
||||
put(&home.join("logs/latest.log"), "log");
|
||||
put(&home.join("sessions/a.json"), "token");
|
||||
put(&home.join("telemetry/consent.json"), "{}");
|
||||
let pack = horizon_port_pack::import::Pack {
|
||||
name: "Small Pack".into(),
|
||||
..Default::default()
|
||||
};
|
||||
put(
|
||||
&home.join("ports/small-pack/pack.json"),
|
||||
&serde_json::to_string(&pack).unwrap(),
|
||||
);
|
||||
put(
|
||||
&home.join("ports/small-pack/home/saves/Modded/level.dat"),
|
||||
"modded",
|
||||
);
|
||||
put(
|
||||
&home.join("horizon-packs/cozy/pack.json"),
|
||||
r#"{"id":"cozy","name":"Cozy","version":"1.0.0","sha256":"00","mods":[]}"#,
|
||||
);
|
||||
put(
|
||||
&home.join("horizon-packs/cozy/home/saves/Cozy/level.dat"),
|
||||
"cozy",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn existing_worlds_stay_where_they_are_and_every_folder_becomes_an_instance() {
|
||||
let root = scratch("migrate");
|
||||
let (home, data) = (root.join("horizon"), root.join("launcher"));
|
||||
player_home(&home);
|
||||
let before = files(&home);
|
||||
|
||||
// A launcher with instances, on a player's existing folders: no instances.json yet.
|
||||
let all = list_in(&home, &data);
|
||||
let ids: Vec<&str> = all.iter().map(|i| i.id.as_str()).collect();
|
||||
assert_eq!(ids, [DEFAULT, "pack:cozy", "port:small-pack"]);
|
||||
assert_eq!(all[0].name, "Horizon");
|
||||
assert_eq!(all[0].home, home);
|
||||
assert_eq!(all[1].home, home.join("horizon-packs/cozy/home"));
|
||||
assert_eq!(all[2].name, "Small Pack");
|
||||
assert_eq!(all[2].home, home.join("ports/small-pack/home"));
|
||||
|
||||
// Everything the player can do with instances, then not one byte of theirs has moved.
|
||||
let empty = create_in(&home, &data, "Survival", None).unwrap();
|
||||
let copy = create_in(&home, &data, "My copy", Some(&all[0])).unwrap();
|
||||
edit_in(&home, &data, DEFAULT, |m| m.name = Some("Main".into())).unwrap();
|
||||
edit_in(&home, &data, "Small Pack", |m| {
|
||||
m.icon = Some(Icon::Texture("diamond".into()));
|
||||
m.group = Some("Modded".into());
|
||||
})
|
||||
.unwrap();
|
||||
let after = files(&home);
|
||||
for (path, bytes) in &before {
|
||||
assert_eq!(after.get(path), Some(bytes), "{} changed", path.display());
|
||||
}
|
||||
assert!(!data.join("settings.json").exists());
|
||||
|
||||
// The empty one has only the player's options and name; the copy has the worlds and
|
||||
// packs, never the sessions, logs, data collection or other instances.
|
||||
assert_eq!(empty.home, home.join("instances/survival"));
|
||||
let empty_files: Vec<PathBuf> = files(&empty.home).into_keys().collect();
|
||||
assert_eq!(
|
||||
empty_files,
|
||||
[PathBuf::from("horizon-player.txt"), "options.txt".into()]
|
||||
);
|
||||
let copied = files(©.home);
|
||||
for kept in [
|
||||
"saves/World/region/r.0.0.mca",
|
||||
"saves/Other/level.dat",
|
||||
"resourcepacks/faithful.zip",
|
||||
] {
|
||||
assert_eq!(copied[Path::new(kept)], before[Path::new(kept)]);
|
||||
}
|
||||
assert!(copied.keys().all(|p| {
|
||||
let top = p.components().next().unwrap().as_os_str().to_str().unwrap();
|
||||
!NOT_COPIED.contains(&top)
|
||||
}));
|
||||
|
||||
let all = list_in(&home, &data);
|
||||
assert_eq!(all[0].name, "Main");
|
||||
let port = find_in(&all, "port:small-pack").unwrap();
|
||||
assert_eq!(port.group.as_deref(), Some("Modded"));
|
||||
assert_eq!(port.home, home.join("ports/small-pack/home"));
|
||||
fs::remove_dir_all(&root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_stay_unique_and_packs_are_not_copied() {
|
||||
let root = scratch("names");
|
||||
let (home, data) = (root.join("horizon"), root.join("launcher"));
|
||||
player_home(&home);
|
||||
create_in(&home, &data, "Survival", None).unwrap();
|
||||
assert!(create_in(&home, &data, "survival", None).is_err());
|
||||
assert!(create_in(&home, &data, " ", None).is_err());
|
||||
// Another name with the same folder name gets the next free folder.
|
||||
let second = create_in(&home, &data, "Survival!", None).unwrap();
|
||||
assert_eq!(second.id, "survival-2");
|
||||
assert_eq!(second.name, "Survival!");
|
||||
assert!(edit_in(&home, &data, "survival-2", |m| m.name =
|
||||
Some("SURVIVAL".into()))
|
||||
.is_err());
|
||||
let port = find_in(&list_in(&home, &data), "small-pack").unwrap();
|
||||
assert!(create_in(&home, &data, "Pack copy", Some(&port)).is_err());
|
||||
assert!(!home.join("instances/pack-copy").exists());
|
||||
// An empty group is no group.
|
||||
let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap();
|
||||
assert_eq!(grouped.group, None);
|
||||
fs::remove_dir_all(&root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_instance_follows_the_players_answers() {
|
||||
let root = scratch("follow");
|
||||
let (main, own) = (root.join("main"), root.join("own"));
|
||||
put(&main.join("options.txt"), "fov:90\n");
|
||||
put(&main.join("horizon-player.txt"), "name:Player123\n");
|
||||
put(&main.join("telemetry/consent.json"), r#"{"version":1}"#);
|
||||
horizon_core::no_ai::set(&main, true).unwrap();
|
||||
put(&own.join("options.txt"), "fov:70\n");
|
||||
follow_player(&main, &own);
|
||||
assert_eq!(
|
||||
fs::read_to_string(own.join("options.txt")).unwrap(),
|
||||
"fov:70\n"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read_to_string(own.join("horizon-player.txt")).unwrap(),
|
||||
"name:Player123\n"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read_to_string(own.join("telemetry/consent.json")).unwrap(),
|
||||
r#"{"version":1}"#
|
||||
);
|
||||
assert!(horizon_core::no_ai::is_on(&own));
|
||||
horizon_core::no_ai::set(&main, false).unwrap();
|
||||
follow_player(&main, &own);
|
||||
assert!(!horizon_core::no_ai::is_on(&own));
|
||||
fs::remove_dir_all(&root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn icons_are_a_texture_name_or_a_colour() {
|
||||
assert_eq!(Icon::parse("#3FA7D6"), Ok(Icon::Colour("#3fa7d6".into())));
|
||||
assert_eq!(
|
||||
Icon::parse("grass_block"),
|
||||
Ok(Icon::Texture("grass_block".into()))
|
||||
);
|
||||
for bad in ["#12345", "../x", "Grass", "", "#zzzzzz"] {
|
||||
assert!(Icon::parse(bad).is_err(), "{bad}");
|
||||
}
|
||||
let root = scratch("icon");
|
||||
put(
|
||||
&root.join("assets/minecraft/textures/item/diamond.png"),
|
||||
"png",
|
||||
);
|
||||
let diamond = Icon::Texture("diamond".into()).texture(&root).unwrap();
|
||||
assert!(diamond.ends_with("item/diamond.png"));
|
||||
assert_eq!(Icon::Texture("stone".into()).texture(&root), None);
|
||||
fs::remove_dir_all(&root).unwrap();
|
||||
}
|
||||
@@ -7,6 +7,7 @@ pub mod desktop;
|
||||
#[cfg(unix)]
|
||||
pub mod game_app;
|
||||
pub mod heads;
|
||||
pub mod instances;
|
||||
pub mod modpacks;
|
||||
pub mod mojang;
|
||||
pub mod process;
|
||||
|
||||
+12
-6
@@ -33,6 +33,7 @@ use gpui::{
|
||||
};
|
||||
use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
|
||||
use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates};
|
||||
use horizon_launcher::instances;
|
||||
use horizon_launcher::telemetry;
|
||||
use scrollbar::Scrollbar;
|
||||
use std::borrow::Cow;
|
||||
@@ -535,13 +536,16 @@ 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) =
|
||||
// A pack's Play button plays that pack; Play plays the selected instance.
|
||||
let profile = match self.starting_pack.take() {
|
||||
Some(work) => {
|
||||
horizon_launcher::modpacks::apply_profile(&mut cmd, &work)
|
||||
{
|
||||
self.client_error = Some(e);
|
||||
continue;
|
||||
}
|
||||
None => instances::apply(&mut cmd, &instances::selected()),
|
||||
};
|
||||
if let Err(e) = profile {
|
||||
self.client_error = Some(e);
|
||||
continue;
|
||||
}
|
||||
if let Some(code) = self.joining.take() {
|
||||
if let Err(e) = backend::join_friend(&mut cmd, &code) {
|
||||
@@ -668,10 +672,12 @@ impl Launcher {
|
||||
}
|
||||
Job::Client => {
|
||||
self.client = None;
|
||||
// The run's own game folder: an instance's or a pack's keeps its reports.
|
||||
let home = self.client_home.clone().unwrap_or_else(backend::game_home);
|
||||
let report = self
|
||||
.client_started
|
||||
.take()
|
||||
.and_then(backend::crash_report_since);
|
||||
.and_then(|since| backend::crash_report_since(&home, since));
|
||||
if error.is_some() && report.is_none() && self.switched_to_dx12() {
|
||||
self.client_error = Some(
|
||||
"Horizon's Vulkan renderer crashed while starting on this \
|
||||
|
||||
@@ -6,6 +6,7 @@ use crate::cli_tools;
|
||||
use crate::game_tools::{self, GameTools};
|
||||
use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
|
||||
use horizon_launcher::backend::{self, Job, Logged};
|
||||
use horizon_launcher::instances;
|
||||
use serde_json::{json, Value};
|
||||
use std::io::{BufRead, Write};
|
||||
use std::path::PathBuf;
|
||||
@@ -29,6 +30,7 @@ fn session_tools() -> Value {
|
||||
json!([
|
||||
{ "name": "play", "description": "Start the Horizon client (a game window on the player's screen) under agent control: the game_* tools then play it. Returns once it has started; game_wait_ready waits for the world. CLI: horizon-launcher play",
|
||||
"inputSchema": { "type": "object", "properties": { "version": version,
|
||||
"instance": { "type": "string", "description": "The instance to play, by name or id (instance_list). Default: the selected one." },
|
||||
"world": { "type": "string", "description": "Open or create this world (a folder under saves) at once." },
|
||||
"creative": { "type": "boolean", "description": "Creative mode for a new world." },
|
||||
"join": { "type": "string", "description": "Join a friend's world with its invite code. Only when the player asks." },
|
||||
@@ -68,6 +70,11 @@ impl Session {
|
||||
}
|
||||
let tag = backend::resolve_version(arg_str(args, "version"))?;
|
||||
let mut cmd = backend::client(&tag)?;
|
||||
let instance = match arg_str(args, "instance") {
|
||||
Some(name) => instances::find(name)?,
|
||||
None => instances::selected(),
|
||||
};
|
||||
instances::apply(&mut cmd, &instance)?;
|
||||
cmd.args(game_tools::control_args());
|
||||
if let Some(world) = arg_str(args, "world") {
|
||||
cmd.arg("--world").arg(world);
|
||||
|
||||
@@ -135,7 +135,11 @@ pub fn load(work: &Path) -> Result<Imported, String> {
|
||||
|
||||
/// Every imported pack, by name.
|
||||
pub fn list() -> Vec<Imported> {
|
||||
let mut packs: Vec<Imported> = fs::read_dir(ports_dir())
|
||||
list_in(&ports_dir())
|
||||
}
|
||||
|
||||
pub(crate) fn list_in(ports: &Path) -> Vec<Imported> {
|
||||
let mut packs: Vec<Imported> = fs::read_dir(ports)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
|
||||
Reference in New Issue
Block a user