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

use mcvm_shared::versions::VersionPattern;
use mcvm_shared::Side;

use super::EvalData;
use mcvm_parse::conditions::{ArchCondition, ConditionKind, OSCondition};
use mcvm_parse::vars::VariableStore;

/// Evaluates a script condition to a boolean
pub fn eval_condition(condition: &ConditionKind, eval: &EvalData) -> anyhow::Result<bool> {
	match condition {
		ConditionKind::Not(condition) => eval_condition(condition.get(), eval).map(|op| !op),
		ConditionKind::And(left, right) => {
			Ok(eval_condition(left, eval)? && eval_condition(right.get(), eval)?)
		}
		ConditionKind::Or(left, right) => {
			Ok(eval_condition(left, eval)? || eval_condition(right.get(), eval)?)
		}
		ConditionKind::Version(version) => {
			let version = version.get(&eval.vars)?;
			let version = VersionPattern::from(&version);
			Ok(version.matches_single(
				&eval.input.constants.version,
				&eval.input.constants.version_list,
			))
		}
		ConditionKind::Side(side) => Ok(eval.input.params.side == *side.get()),
		ConditionKind::Modloader(loader) => Ok(loader.get().matches(
			&eval
				.input
				.constants
				.modifications
				.get_modloader(eval.input.params.side),
		)),
		ConditionKind::PluginLoader(loader) => Ok(loader
			.get()
			.matches(&eval.input.constants.modifications.server_type())
			&& matches!(eval.input.params.side, Side::Server)),
		ConditionKind::Feature(feature) => Ok(eval
			.input
			.params
			.features
			.contains(&feature.get(&eval.vars)?)),
		ConditionKind::OS(os) => Ok(check_os_condition(os.get())),
		ConditionKind::Arch(arch) => Ok(check_arch_condition(arch.get())),
		ConditionKind::Stability(stability) => Ok(eval.input.params.stability == *stability.get()),
		ConditionKind::Language(lang) => Ok(eval.input.constants.language == *lang.get()),
		ConditionKind::ContentVersion(version) => {
			let version = version.get(&eval.vars)?;

			let default_versions = Vec::new();
			let matches = eval.input.params.content_version.as_ref().is_some_and(|x| {
				x.matches_single(
					&version,
					&eval
						.properties
						.content_versions
						.as_ref()
						.unwrap_or(&default_versions),
				)
			});

			Ok(matches)
		}
		ConditionKind::Value(left, right) => Ok(left.get(&eval.vars)? == right.get(&eval.vars)?),
		ConditionKind::Defined(var) => Ok(eval.vars.var_exists(var.get())),
		ConditionKind::Const(val) => Ok(val.get_clone()),
		ConditionKind::Plugin(plugin) => Ok(eval.plugins.has_plugin(&plugin.get(&eval.vars)?)),
	}
}

/// Checks an OS condition to see if it matches the current operating system
pub fn check_os_condition(condition: &OSCondition) -> bool {
	match condition {
		OSCondition::Windows => cfg!(target_os = "windows"),
		OSCondition::Linux => cfg!(target_os = "linux"),
		OSCondition::MacOS => cfg!(target_os = "macos"),
		OSCondition::Unix => cfg!(target_family = "unix"),
		OSCondition::Other => {
			!(cfg!(target_os = "windows") || cfg!(target_os = "linux") || cfg!(target_os = "macos"))
		}
	}
}

/// Checks an arch condition to see if it matches the current system architecture
pub fn check_arch_condition(condition: &ArchCondition) -> bool {
	if cfg!(target_arch = "x86") {
		return condition == &ArchCondition::X86;
	}
	if cfg!(target_arch = "x86_64") {
		return condition == &ArchCondition::X86_64;
	}
	if cfg!(target_arch = "arm") {
		return condition == &ArchCondition::Arm;
	}
	condition == &ArchCondition::Other
}