mcvm 0.25.0

A fast, extensible, and powerful Minecraft launcher
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/// Addon-related functions for instances
mod addons;
/// Launching an instance
pub mod launch;
/// Managing and installing packages on an instance
pub mod packages;
/// Setup of instance contents
pub mod setup;
/// Keeping track of running instance processes
pub mod tracking;
/// Import and export of instances to other formats
pub mod transfer;
/// Updating an instance
pub mod update;

use mcvm_core::util::versions::MinecraftVersion;
use mcvm_shared::later::Later;
use mcvm_shared::pkg::PackageStability;
use mcvm_shared::versions::VersionPattern;
use mcvm_shared::Side;

use crate::config::instance::InstanceConfig;

use self::launch::LaunchOptions;
use self::setup::{InstanceDirs, ModificationData};

use super::config::instance::ClientWindowConfig;
use super::config::package::PackageConfig;
use super::config::profile::GameModifications;
use mcvm_shared::id::InstanceID;

/// An instance of the game on a profile
#[derive(Debug)]
pub struct Instance {
	/// What type of instance this is
	pub(crate) kind: InstKind,
	/// The ID of this instance
	pub(crate) id: InstanceID,
	/// Directories of the instance
	pub(crate) dirs: Later<InstanceDirs>,
	/// Configuration for the instance
	pub(crate) config: InstanceStoredConfig,
	/// Modification data
	modification_data: ModificationData,
}

/// Different kinds of instances and their associated data
#[derive(Debug, Clone)]
pub enum InstKind {
	/// A client instance
	Client {
		/// Configuration for the client window
		window: ClientWindowConfig,
	},
	/// A server instance
	Server {
		/// The new world name if it is changed by the options
		world_name: Option<String>,
	},
}

impl InstKind {
	/// Create a new client InstKind
	pub fn client(window: ClientWindowConfig) -> Self {
		Self::Client { window }
	}

	/// Create a new server InstKind
	pub fn server() -> Self {
		Self::Server { world_name: None }
	}

	/// Convert to the Side enum
	pub fn to_side(&self) -> Side {
		match self {
			Self::Client { .. } => Side::Client,
			Self::Server { .. } => Side::Server,
		}
	}
}

/// The stored configuration on an instance
#[derive(Debug)]
pub struct InstanceStoredConfig {
	/// The instance display name
	pub name: Option<String>,
	/// A path to an icon for the instance
	pub icon: Option<String>,
	/// The Minecraft version
	pub version: MinecraftVersion,
	/// Modifications to the instance
	pub modifications: GameModifications,
	/// Version for the game modification
	pub modification_version: Option<VersionPattern>,
	/// Launch options for the instance
	pub launch: LaunchOptions,
	/// The instance's global datapack folder
	pub datapack_folder: Option<String>,
	/// The packages on the instance, consolidated from all parent sources
	pub packages: Vec<PackageConfig>,
	/// Default stability for packages
	pub package_stability: PackageStability,
	/// The original instance configuration before applying profiles
	pub original_config: InstanceConfig,
	/// The original instance configuration after applying profiles
	pub original_config_with_profiles: InstanceConfig,
	/// Custom plugin config
	pub plugin_config: serde_json::Map<String, serde_json::Value>,
}

impl Instance {
	/// Create a new instance
	pub fn new(kind: InstKind, id: InstanceID, config: InstanceStoredConfig) -> Self {
		Self {
			kind,
			id,
			config,
			dirs: Later::Empty,
			modification_data: ModificationData::new(),
		}
	}

	/// Get the kind of the instance
	pub fn get_kind(&self) -> &InstKind {
		&self.kind
	}

	/// Get the side of the instance
	pub fn get_side(&self) -> Side {
		self.kind.to_side()
	}

	/// Get the ID of the instance
	pub fn get_id(&self) -> &InstanceID {
		&self.id
	}

	/// Get the instance's directories
	pub fn get_dirs(&self) -> &Later<InstanceDirs> {
		&self.dirs
	}

	/// Get the instance's stored configuration
	pub fn get_config(&self) -> &InstanceStoredConfig {
		&self.config
	}
}