diff --git a/AGENTS.md b/AGENTS.md index 489a1466b..0eb1fe8b5 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -11,7 +11,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md] - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d` folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the - launcher, `HORIZON_LAUNCHER_TRASH` and `HORIZON_LAUNCHER_CLIPBOARD` pointing into the scratch home. Never write to + launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`. - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what. Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7699e83d7..a59af8344 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2990,6 +2990,16 @@ impl Game<'_> { data, } => self.sculk_charge_event(pos, data), LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos), + // LevelEventHandler 2019 and 2020: the crack on a face of the + // block being mined, with its hit sound for 2020. + LevelEvent::LevelEvent { + id: id @ (2019 | 2020), + pos, + data, + } => { + let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize]; + self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020); + } LevelEvent::LevelEvent { id: 2004, pos, .. } => { self.spawner_burst([pos.x, pos.y, pos.z]) } @@ -4241,6 +4251,17 @@ impl Game<'_> { _ => {} } } + /// `ServerPlayerGameMode.tick` while a player digs: level event 2020 every + /// fourth tick since the START (the hit sound), else 2019 (the crack only), + /// for everyone around, the digger included (`levelEvent(null, ...)`). + fn destroy_progress_event(&mut self, pos: [i32; 3], face: [i32; 3], ticks: u32) { + let id = if ticks.is_multiple_of(4) { 2020 } else { 2019 }; + let direction = horizon_core::geometry::Direction::ALL + .iter() + .position(|d| d.normal() == face) + .unwrap_or(1); + self.level_event_at(id, pos, direction as i32); + } fn tick_mining(&mut self) -> Result<()> { if self.destroy_delay > 0 { self.destroy_delay -= 1; @@ -4284,6 +4305,11 @@ impl Game<'_> { let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]); let facts = self.res.facts().get(state); if facts.hardness < 0.0 { + // The server still counts its destroy ticks on an unbreakable block. + let m = self.mining.as_mut().ok_or("mining")?; + m.ticks += 1; + let (pos, ticks) = (m.pos, m.ticks); + self.destroy_progress_event(pos, hit.face, ticks); return Ok(()); } // Player.getDestroySpeed / BlockBehaviour.getDestroyProgress. @@ -4314,26 +4340,15 @@ impl Game<'_> { } else { speed / facts.hardness / if harvest { 30.0 } else { 100.0 } }; - let hit_sound = facts.sounds.clone(); self.swing_arm(); let m = self.mining.as_mut().ok_or("mining")?; m.progress += progress; m.ticks += 1; - let crack = (m.pos, hit.face); - if m.ticks % 4 == 1 { - let c = [ - f64::from(m.pos[0]) + 0.5, - f64::from(m.pos[1]) + 0.5, - f64::from(m.pos[2]) + 0.5, - ]; - self.audio.play( - &hit_sound.hit, - Some(c), - (hit_sound.volume + 1.0) / 8.0, - hit_sound.pitch * 0.5, - ); + // An instant break at START sends no destroy events. + if m.progress < 1.0 || m.ticks > 1 { + let (pos, ticks) = (m.pos, m.ticks); + self.destroy_progress_event(pos, hit.face, ticks); } - self.crack_particle(crack.0, crack.1, state); let m = self.mining.as_mut().ok_or("mining")?; // ServerPlayerGameMode breaks a player's block at once only when it is instant (START's // insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 28ec3fe8a..d681eccde 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -1267,8 +1267,9 @@ impl Game<'_> { horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => { // The acting guest does not predict the egg's teleport // particles, bone meal's growth, or anvil result sounds - // (these levelEvent calls name no excluded player). - let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) { + // (these levelEvent calls name no excluded player), nor + // the digger's own crack and hit sound (2019, 2020). + let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) { None } else { self.lan_acting diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs index 9fa53eb25..9eeb74932 100644 --- a/crates/horizon-client/src/game/level_particles.rs +++ b/crates/horizon-client/src/game/level_particles.rs @@ -135,6 +135,30 @@ impl Game<'_> { // Each guest plays it from the global packet. self.audio.play_unshared(sound, at, volume, 1.0); } + /// `ClientLevel.addBreakingBlockEffects`: the block's hit sound (only for + /// `play_sound`) and one crumb on the face being mined; nothing for air. + pub(super) fn breaking_block_effects( + &mut self, + pos: [i32; 3], + face: [i32; 3], + play_sound: bool, + ) { + let state = self.world.block(pos[0], pos[1], pos[2]); + if self.res.facts().is_air(state) { + return; + } + if play_sound { + let sounds = self.res.facts().get(state).sounds.clone(); + // Each guest plays it from the level event itself. + self.audio.play_unshared( + &sounds.hit, + Some(pos.map(|v| f64::from(v) + 0.5)), + (sounds.volume + 1.0) / 8.0, + sounds.pitch * 0.5, + ); + } + self.crack_particle(pos, face, state); + } /// `LevelEventHandler.potionSplashParticles` (2002 with `Effect`, 2007 /// with `InstantEffect`): eight splash potion crumbs, and a hundred /// spell particles in the potion's colour `data`, flung out in a disc. diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 8d54f017f..b2b870f4c 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3935,6 +3935,9 @@ impl Game<'_> { if let Some(r) = self.remote.as_mut() { r.destroying = Some((hit.pos, face, 0.0)); } + // startDestroyBlock plays the first hit and crack itself; the + // server's level events 2019 and 2020 do the rest. + self.breaking_block_effects(hit.pos, hit.face, true); self.mining = Some(Mining { pos: hit.pos, progress: 0.0, @@ -3947,20 +3950,6 @@ impl Game<'_> { }; let done = done + progress; let ticks = self.mining.as_ref().map_or(0, |m| m.ticks) + 1; - if ticks % 4 == 1 { - let c = [ - f64::from(pos[0]) + 0.5, - f64::from(pos[1]) + 0.5, - f64::from(pos[2]) + 0.5, - ]; - self.audio.play( - &facts.sounds.hit, - Some(c), - (facts.sounds.volume + 1.0) / 8.0, - facts.sounds.pitch * 0.5, - ); - } - self.crack_particle(pos, hit.face, state); if done >= 1.0 { let seq = self.next_sequence(); self.predict_break(pos, state, seq); diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md index 432b76e72..41108a86e 100644 --- a/docs/launcher-commands.md +++ b/docs/launcher-commands.md @@ -364,6 +364,30 @@ Export an instance (or a port) to share: its settings, packs, Horizon mods and t MCP: `instance_export`. +## `horizon-launcher instance launch` + +Show or set what runs around an instance's game: a shell command before it (the game starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment variables ("NAME=value NAME2=value"). An empty value clears one. + + horizon-launcher instance launch + +- `INSTANCE` +- `--pre-launch` +- `--wrapper` +- `--env` + +MCP: `instance_launch`, needs `confirm: true`. + +## `horizon-launcher instance shortcut` + +Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows. + + horizon-launcher instance shortcut [INSTANCE] + +- `INSTANCE`: The instance (default: the selected one) +- `--remove`: Move the instance's shortcuts to the trash instead + +MCP: `instance_shortcut`. + ## `horizon-launcher instance import` Import what a file is, as dropping it on the window does: a shared instance (a .mrpack without mod loaders, such as `instance export` writes, or a game folder zip) becomes a new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into the instance (default: the selected one). diff --git a/launcher/README.md b/launcher/README.md index ad96eece1..41ff3c915 100644 --- a/launcher/README.md +++ b/launcher/README.md @@ -100,6 +100,21 @@ The opening, then Play ([clip](docs/opening.webm)): pack into the selected instance. A data pack is pointed at the world rows, and the Packs section and the world rows keep taking their own drops. A note in the corner says what happened. `horizon-launcher instance import `. +- **Launch options**: Home's Instance row has **Launch…**: per instance, a shell command run in its + folder before the game (the game starts only if it succeeds), a wrapper the game runs through + (`nice -n 5`), and environment variables (`NAME=value OTHER="two words"`), kept in + `instances.json` (`horizon_launcher::launch`). The game stays one process the launcher follows: + on Unix `/bin/sh` runs the command and then `exec`s the wrapper and the game, whose words pass + through `"$@"` untouched; on Windows `cmd /C` runs ` && `. Both the window's Play + and `play` use them. `horizon-launcher instance launch [--pre-launch …] + [--wrapper …] [--env …]` (an MCP agent needs `confirm: true`: it sets commands Play runs). +- **Desktop shortcut**: Home's Instance row has **Shortcut**: a shortcut on the desktop that plays + the selected instance without opening the launcher (`horizon-launcher play --instance `). + A `.desktop` file on Linux (also put in the applications menu, and marked trusted with `gio` + where it exists), a small app with Horizon's icon on macOS, a `.lnk` on Windows + (`horizon_launcher::shortcut`). **Remove shortcut** moves it to the trash; it is found by the + instance id inside it, so a rename doesn't lose it. `horizon-launcher instance shortcut + [instance] [--remove]`; `HORIZON_LAUNCHER_DESKTOP` points it at another folder. - **Console**: Home's Console shows the game's output of this run as it comes: a search (every word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index 246538b08..38150917f 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -198,6 +198,27 @@ enum InstanceCmd { #[arg(long)] out: Option, }, + /// Show or set what runs around an instance's game: a shell command before it (the game + /// starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment + /// variables ("NAME=value NAME2=value"). An empty value clears one + Launch { + instance: String, + #[arg(long)] + pre_launch: Option, + #[arg(long)] + wrapper: Option, + #[arg(long)] + env: Option, + }, + /// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop + /// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows + Shortcut { + /// The instance (default: the selected one) + instance: Option, + /// Move the instance's shortcuts to the trash instead + #[arg(long)] + remove: bool, + }, /// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack /// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a /// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into @@ -929,7 +950,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> { } cmd.args(arg); let started = std::time::Instant::now(); - let played = attached(cmd); + let played = attached(horizon_launcher::launch::wrap(cmd, &instance.launch)); if let Err(e) = instances::record_play(&instance.id, started.elapsed()) { eprintln!("Play time not saved: {e}"); } @@ -1827,6 +1848,66 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> { }; changed(instances::edit(&instance, |m| m.version = pin)?) } + InstanceCmd::Launch { + instance, + pre_launch, + wrapper, + env, + } => { + use horizon_launcher::launch; + let env = env.as_deref().map(launch::parse_env).transpose()?; + let changing = pre_launch.is_some() || wrapper.is_some() || env.is_some(); + let i = match changing { + false => instances::find(&instance)?, + true => instances::edit(&instance, |m| { + if let Some(p) = pre_launch { + m.launch.pre_launch = p.trim().to_string(); + } + if let Some(w) = wrapper { + m.launch.wrapper = w.trim().to_string(); + } + if let Some(e) = env { + m.launch.env = e; + } + })?, + }; + let l = &i.launch; + if as_json { + json(serde_json::json!({ + "instance": i.id, "pre_launch": l.pre_launch, "wrapper": l.wrapper, "env": l.env, + })); + } else { + println!( + "{}: {}", + i.name, + l.summary().unwrap_or("nothing around the game".into()) + ); + println!(" pre-launch: {}", l.pre_launch); + println!(" wrapper: {}", l.wrapper); + println!(" env: {}", launch::env_line(&l.env)); + } + } + InstanceCmd::Shortcut { instance, remove } => { + use horizon_launcher::shortcut; + let i = match instance { + Some(name) => instances::find(&name)?, + None => instances::selected(), + }; + let paths = match remove { + false => shortcut::make(backend::exe_path(), &i.id, &i.name)?, + true => shortcut::remove(&i.id)?, + }; + if as_json { + json(serde_json::json!({ "instance": i.id, "paths": paths })); + } else if remove && paths.is_empty() { + println!("{} has no shortcut.", i.name); + } else { + let did = if remove { "Moved to the trash" } else { "Made" }; + for path in paths { + println!("{did}: {}", path.display()); + } + } + } InstanceCmd::Import { file, instance } => { use horizon_launcher::import::{self, Dropped}; use horizon_launcher::modpacks; diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index fad614d0f..a6ddbfa34 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -32,6 +32,8 @@ pub const DESTRUCTIVE: &[&str] = &[ "packs remove", "worlds datapack-remove", "unshare-log", + // It sets shell commands the next Play runs: the player says yes first. + "instance launch", ]; /// Commands that send something or reach other people: only when the player asks. diff --git a/launcher/src/desktop.rs b/launcher/src/desktop.rs index 281850cb6..863923acb 100644 --- a/launcher/src/desktop.rs +++ b/launcher/src/desktop.rs @@ -65,7 +65,7 @@ pub fn data_home() -> Option { } /// Quotes a path for an `Exec` key: inside double quotes, `"`, `` ` ``, `$` and `\` are escaped. -fn quote(path: &Path) -> String { +pub(crate) fn quote(path: &Path) -> String { let mut out = String::from("\""); for c in path.to_string_lossy().chars() { if matches!(c, '"' | '`' | '$' | '\\') { @@ -215,7 +215,7 @@ pub fn needs_repair_in(data: &Path, path: Option<&OsStr>) -> bool { /// What the entry starts: a distributor's wrapper (`HORIZON_LAUNCHER_DESKTOP_EXEC`) when one is /// configured, else the binary at `exe`. -fn target(exe: &Path) -> PathBuf { +pub(crate) fn target(exe: &Path) -> PathBuf { std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC") .filter(|path| !path.is_empty()) .map_or_else(|| exe.to_path_buf(), PathBuf::from) diff --git a/launcher/src/desktop_seams.rs b/launcher/src/desktop_seams.rs index edec7ab8d..2815748ea 100644 --- a/launcher/src/desktop_seams.rs +++ b/launcher/src/desktop_seams.rs @@ -7,7 +7,8 @@ //! (text as UTF-8, a picture as its PNG or JPEG bytes). //! //! Test runs point both into their scratch folders, beside `HORIZON_HOME` and -//! `HORIZON_LAUNCHER_HOME`. +//! `HORIZON_LAUNCHER_HOME`, and `HORIZON_LAUNCHER_DESKTOP` too (`shortcut`: where desktop +//! shortcuts go). use std::path::{Path, PathBuf}; pub const TRASH_ENV: &str = "HORIZON_LAUNCHER_TRASH"; @@ -22,7 +23,8 @@ pub fn to_trash(path: &Path) -> Result<(), String> { } } -fn to_folder(path: &Path, dir: &Path) -> Result<(), String> { +/// Moves `path` into `dir` under a free name: the trash of a test run. +pub fn to_folder(path: &Path, dir: &Path) -> Result<(), String> { std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?; let name = path.file_name().ok_or("Nothing to move")?.to_string_lossy(); let target = (1..) diff --git a/launcher/src/import/tests.rs b/launcher/src/import/tests.rs index dcbe0e548..1287b475e 100644 --- a/launcher/src/import/tests.rs +++ b/launcher/src/import/tests.rs @@ -48,6 +48,7 @@ fn maker(root: &Path) -> impl Fn(&str) -> Result + '_ { version: None, played: Duration::ZERO, last_played: None, + launch: Default::default(), }) } } diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs index 34d9bb408..38951bf02 100644 --- a/launcher/src/instances.rs +++ b/launcher/src/instances.rs @@ -8,6 +8,7 @@ //! launcher's data folder, so renaming one never moves a folder. use crate::backend; use crate::browser::horizon::pack as registry_pack; +use crate::launch::Launch; use crate::modpacks; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -97,6 +98,9 @@ pub struct Meta { /// When its last run ended, in seconds since 1970. #[serde(default, skip_serializing_if = "Option::is_none")] pub last_played: Option, + /// What runs around the game: a pre-launch command, a wrapper, variables (`launch`). + #[serde(default, skip_serializing_if = "Launch::is_empty")] + pub launch: Launch, } fn is_zero(n: &u64) -> bool { @@ -140,6 +144,8 @@ pub struct Instance { pub version: Option, pub played: Duration, pub last_played: Option, + /// What runs around the game (`launch::wrap`). + pub launch: Launch, } impl Instance { @@ -213,6 +219,7 @@ fn list_in(game_home: &Path, data: &Path) -> Vec { last_played: meta .last_played .map(|s| UNIX_EPOCH + Duration::from_secs(s)), + launch: meta.launch, id, kind, work, @@ -403,9 +410,13 @@ fn edit_in( 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)) + // Only a new name is checked: an import can share a name, and changing anything + // else about it must still work. + let renamed = !name.eq_ignore_ascii_case(&instance.name); + if renamed + && 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}.")); } diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs index 22f8f2b00..b2e2fe6fe 100644 --- a/launcher/src/instances/tests.rs +++ b/launcher/src/instances/tests.rs @@ -149,6 +149,18 @@ fn names_stay_unique_and_packs_are_not_copied() { // An empty group is no group. let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap(); assert_eq!(grouped.group, None); + // An import named like an instance: both can still change everything but their names. + let mut store = Store::load(&data); + store.instances.entry(port.id.clone()).or_default().name = Some("Survival".into()); + store.save(&data).unwrap(); + let launched = edit_in(&home, &data, "survival", |m| { + m.launch.wrapper = "nice".into() + }) + .unwrap(); + assert_eq!(launched.launch.wrapper, "nice"); + assert!(edit_in(&home, &data, "survival-2", |m| m.name = + Some("survival".into())) + .is_err()); fs::remove_dir_all(&root).unwrap(); } diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs index 273f967df..b0777e9ba 100644 --- a/launcher/src/instances_page.rs +++ b/launcher/src/instances_page.rs @@ -551,9 +551,13 @@ impl Launcher { instance.clone(), instance.name.clone(), ); + // Under the name, wrapping: six actions don't fit beside it at the window's narrowest. let actions = div() .flex() + .flex_wrap() .gap(px(8.)) + .mt(px(6.)) + .ml(px(-14.)) .child( button("instance-edit", "Edit…", Kind::Ghost, &t).on_click(cx.listener( move |this, _: &ClickEvent, _, cx| { @@ -590,6 +594,23 @@ impl Launcher { cx.notify(); })), ) + .child( + button( + "instance-launch", + if self.launch.is_some() { + "Close launch" + } else { + "Launch…" + }, + Kind::Ghost, + &t, + ) + .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { + this.toggle_launch(); + cx.notify(); + })), + ) + .child(self.shortcut_button(&instance, cx)) .child( button("instance-folder", "Open folder", Kind::Ghost, &t).on_click( move |_, _, cx| { @@ -604,17 +625,24 @@ impl Launcher { Some( div() .flex() - .items_baseline() - .gap(px(10.)) - .child(instance.name.clone()) + .flex_col() .child( - text(theme::CAPTION) - .text_color(t.muted) - .child(played_line(&instance)), + div() + .flex() + .items_baseline() + .gap(px(10.)) + .child(instance.name.clone()) + .child( + text(theme::CAPTION) + .text_color(t.muted) + .child(played_line(&instance)), + ), ) + .children(self.shortcut_note(&instance.id)) + .child(actions) .into_any_element(), ), - Some(actions.into_any_element()), + None, &t, )) } diff --git a/launcher/src/launch.rs b/launcher/src/launch.rs new file mode 100644 index 000000000..486f5f469 --- /dev/null +++ b/launcher/src/launch.rs @@ -0,0 +1,220 @@ +//! What runs around the game for one instance (`instances::Meta::launch`): a command run before +//! it, a wrapper it runs through, and environment variables. All empty by default. +//! +//! [`wrap`] turns the game's command into one process that does all three, so the launcher still +//! follows one program (its output, its exit, Stop): +//! +//! - Unix: `/bin/sh -c '() || exit; exec "$@"' horizon `. +//! The pre-launch command is the player's own shell line, run in the instance's folder; the +//! game's words go through `"$@"`, so they are never parsed by the shell. `exec` makes the +//! shell become the wrapper (or the game). +//! - Windows: `cmd /D /S /C " && "`, each word quoted. +//! +//! Without a pre-launch command the wrapper is the program itself, and no shell runs. +use crate::backend::split_args; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::ffi::{OsStr, OsString}; +use std::process::Command; + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct Launch { + /// A shell command run in the instance's folder before the game; the game starts only if it + /// succeeds. + #[serde(default, skip_serializing_if = "String::is_empty")] + pub pre_launch: String, + /// A command line the game runs through, such as `nice -n 5` (quotes group a word). + #[serde(default, skip_serializing_if = "String::is_empty")] + pub wrapper: String, + /// Environment variables for the game (and the two commands above). + #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] + pub env: BTreeMap, +} + +impl Launch { + pub fn is_empty(&self) -> bool { + self == &Launch::default() + } + + /// What it does, in one line, or None when nothing. + pub fn summary(&self) -> Option { + let mut parts = Vec::new(); + if !self.pre_launch.trim().is_empty() { + parts.push(format!("runs {} first", self.pre_launch.trim())); + } + if !self.wrapper.trim().is_empty() { + parts.push(format!("through {}", self.wrapper.trim())); + } + match self.env.len() { + 0 => {} + 1 => parts.push("with 1 variable".into()), + n => parts.push(format!("with {n} variables")), + } + (!parts.is_empty()).then(|| parts.join(", ")) + } +} + +fn valid_key(key: &str) -> bool { + let mut chars = key.chars(); + chars + .next() + .is_some_and(|c| c.is_ascii_alphabetic() || c == '_') + && chars.all(|c| c.is_ascii_alphanumeric() || c == '_') +} + +/// `KEY=value KEY2="two words"` (one line, or one per line) as variables. +pub fn parse_env(text: &str) -> Result, String> { + let mut env = BTreeMap::new(); + for word in split_args(text) { + let (key, value) = word + .split_once('=') + .ok_or_else(|| format!("{word}: write it as NAME=value"))?; + if !valid_key(key) { + return Err(format!( + "{key}: a variable's name is letters, digits and _, not starting with a digit" + )); + } + env.insert(key.to_string(), value.to_string()); + } + Ok(env) +} + +/// The variables as [`parse_env`] reads them back. +pub fn env_line(env: &BTreeMap) -> String { + env.iter() + .map( + |(k, v)| match v.is_empty() || v.contains([' ', '"', '\'', '\\']) { + true => format!("{k}=\"{}\"", v.replace('\\', "\\\\").replace('"', "\\\"")), + false => format!("{k}={v}"), + }, + ) + .collect::>() + .join(" ") +} + +/// The Unix script: the pre-launch command (in a subshell, so its `exit` doesn't end the script +/// before the message), then the rest of the arguments as the program. +fn script(pre_launch: &str) -> String { + format!( + "(\n{pre_launch}\n) || {{ s=$?; echo \"The pre-launch command failed (exit $s), so the \ + game did not start.\" >&2; exit $s; }}\nexec \"$@\"" + ) +} + +/// A word quoted for a Windows command line, as programs built with the C runtime read it back. +fn windows_quote(word: &OsStr) -> String { + let word = word.to_string_lossy(); + if !word.is_empty() && !word.contains([' ', '\t', '"']) { + return word.into_owned(); + } + let mut out = String::from("\""); + let mut slashes = 0; + for c in word.chars() { + match c { + '\\' => slashes += 1, + '"' => { + out.extend(std::iter::repeat_n('\\', slashes * 2 + 1)); + out.push('"'); + slashes = 0; + } + c => { + out.extend(std::iter::repeat_n('\\', slashes)); + out.push(c); + slashes = 0; + } + } + } + out.extend(std::iter::repeat_n('\\', slashes * 2)); + out.push('"'); + out +} + +/// How [`wrap`] runs a command on each system, apart from the variables and the folder: the +/// program and its arguments. +#[derive(Debug, PartialEq, Eq)] +pub enum Plan { + /// Run as given (`words[0]` is the program). + Direct(Vec), + /// `/bin/sh -c