foch 0.0.1

EU4 mod analysis and merge toolkit
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

use crate::model::GamePath;
use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// The only verified game identity in Foch's product API.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Eu4;

impl Eu4 {
	pub const STEAM_APP_ID: u32 = 236_850;
	pub const KEY: &'static str = "eu4";
	pub const PARADOX_DATA_DIR_NAME: &'static str = "Europa Universalis IV";

	pub fn from_key(value: &str) -> Option<Self> {
		matches!(
			value.trim().to_ascii_lowercase().as_str(),
			"eu4" | "europauniversalis4" | "europa-universalis-4"
		)
		.then_some(Self)
	}

	pub const fn key(&self) -> &'static str {
		Self::KEY
	}

	pub const fn steam_app_ids(&self) -> &'static [u32] {
		&[Self::STEAM_APP_ID]
	}

	pub const fn paradox_data_dir_name(&self) -> Option<&'static str> {
		Some(Self::PARADOX_DATA_DIR_NAME)
	}

	pub const fn loadable_content_roots(&self) -> Option<&'static [&'static str]> {
		Some(&[
			"common",
			"customizable_localization",
			"decisions",
			"dlc",
			"dlc_metadata",
			"events",
			"fonts",
			"gfx",
			"hints",
			"history",
			"interface",
			"localisation",
			"map",
			"missions",
			"music",
			"music_async",
			"pdx_browser",
			"pdx_online_assets",
			"previewer_assets",
			"sfx",
			"sound",
			"tests",
			"tutorial",
			"tweakergui",
		])
	}

	/// Whether the game loads `relative`: a file below one of the
	/// [`loadable_content_roots`](Self::loadable_content_roots). The top-level
	/// directory is matched ignoring ASCII case.
	pub fn is_loadable_content_path(&self, relative: &GamePath) -> bool {
		if relative.parent().is_none() {
			return false;
		}
		let Some(top) = relative.iter().next() else {
			return false;
		};
		self.loadable_content_roots()
			.expect("EU4 loadable roots are static")
			.iter()
			.any(|root| top.eq_ignore_ascii_case(root))
	}
}

impl Serialize for Eu4 {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		serializer.serialize_str(Self::KEY)
	}
}

impl<'de> Deserialize<'de> for Eu4 {
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: Deserializer<'de>,
	{
		let value = String::deserialize(deserializer)?;
		Self::from_key(&value)
			.ok_or_else(|| serde::de::Error::custom(format!("unsupported game key {value:?}")))
	}
}