Struct LaunchPlan 

#[non_exhaustive]
pub struct LaunchPlan {
    pub program: LaunchProgram,
    pub args: Vec<String>,
    pub env: Vec<(String, String)>,
    pub working_dir: Option<PathBuf>,
    pub steam_wrapper: Option<SteamWrapper>,
}

A fully computed launch invocation.

#[non_exhaustive]: fields may be added as more platforms are supported.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

program: LaunchProgram

What to execute.

args: Vec<String>

Arguments, in order, already resolved. Never shell-quoted.

env: Vec<(String, String)>

Environment variables to set for the child process.

Only honoured for a program the caller spawns directly. When Self::program is LaunchProgram::Steam, these are set on the short-lived steam process, and steam -applaunch <id> merely messages an already-running Steam client, which starts the game with its own environment. Nothing here reaches the game in that case. The visible consequence is a Proton + Steam launch silently starting unmodded: without WINEDLLOVERRIDES, Wine loads its builtin proxy instead of the loader’s and BepInEx never initialises, leaving no log to explain why. A caller needing the override under Steam must put it in the Wine prefix (proxy_dll gives the name), not here.

working_dir: Option<PathBuf>

Working directory, when it matters.

steam_wrapper: Option<SteamWrapper>

Some when starting Self::program is not sufficient on its own: a Linux native Steam launch injects through a loader script that Steam will not run unless a wrapper script is installed in its launch options. See SteamWrapper, write_wrapper_script, and steam_launch_options.

Implementations

impl LaunchPlan

pub fn to_command(&self, game_dir: &Path) -> Result<Command>

Translates this plan into the process to spawn.

Always an argv array, never a shell, so a path containing spaces or quotes cannot become an injection. Separate from spawning so the program, arguments, and environment can be asserted without starting anything.

Every LaunchProgram variant is handled, with no wildcard arm. LaunchProgram is #[non_exhaustive], but that only constrains other crates, so a wildcard here would be an unreachable pattern and fail -D warnings. Adding a variant therefore breaks this build deliberately, which is the point: a new launch shape must be translated, not silently rejected at run time.

This is where the host is read, which is why the two variants that need a real path both resolve one here rather than in launch_plan_in: the plan stays a pure computation, and translating it into a process is the step allowed to look at the machine. LaunchProgram::GameExe and LaunchProgram::ProfileScript resolve their binary out of game_dir, and LaunchProgram::Steam resolves the Steam client through crate::steam::steam_exe — a bare steam resolves on Linux but never on Windows, whose Steam installer adds nothing to PATH.

Trait Implementations

impl Clone for LaunchPlan

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LaunchPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LaunchPlan

impl PartialEq for LaunchPlan

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LaunchPlan