Skip to main content

elemental_core/minecraft/version/
kind.rs

1#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
2pub enum MinecraftVersionKind {
3    AlphaBeta(AlphaBetaVersion),
4    LegacySnapshot(LegacySnapshotVersion),
5    LegacyRelease(LegacyReleaseVersion),
6    YearSnapshot(YearSnapshotVersion),
7    YearRelease(YearReleaseVersion),
8}
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
11pub struct AlphaBetaVersion {
12    pub stage: VersionStage,
13    pub major: u32,
14    pub minor: u32,
15    pub patch: u32,
16}
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
19pub struct LegacySnapshotVersion {
20    /// Full year, for example `2025` for `25w41a`.
21    pub year: u32,
22    pub week: u32,
23    pub suffix: Option<char>,
24}
25
26#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
27pub struct LegacyReleaseVersion {
28    pub major: u32,
29    pub minor: u32,
30    pub patch: u32,
31    pub stage: VersionStage,
32    pub stage_number: u32,
33}
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
36pub struct YearSnapshotVersion {
37    /// Full year, for example `2025` for `25.4-snapshot-1`.
38    pub year: u32,
39    pub release: u32,
40    pub patch: u32,
41    pub snapshot: u32,
42}
43
44#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
45pub struct YearReleaseVersion {
46    /// Full year, for example `2026` for `26.1`.
47    pub year: u32,
48    pub release: u32,
49    pub patch: u32,
50    pub stage: VersionStage,
51    pub stage_number: u32,
52}
53
54#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
55pub enum VersionStage {
56    Alpha,
57    Beta,
58    Snapshot,
59    PreRelease,
60    ReleaseCandidate,
61    Release,
62}
63
64/// Ordering key for Minecraft versions.
65///
66/// The key normalizes missing components, so `1.21` and `1.21.0` have the same
67/// semantic position in a sorted collection. The original identifier is never
68/// changed. Legacy releases sort before year-based releases; snapshots are
69/// ordered by their own naming coordinates, so comparisons across snapshot
70/// naming schemes are approximate.
71#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
72pub struct MinecraftVersionKey {
73    era: VersionEra,
74    major: u32,
75    minor: u32,
76    patch: u32,
77    stage: VersionStage,
78    stage_number: u32,
79}
80
81#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
82enum VersionEra {
83    Alpha,
84    Beta,
85    Legacy,
86    Year,
87}
88
89impl MinecraftVersionKey {
90    fn alpha_beta(version: AlphaBetaVersion) -> Self {
91        let era = match version.stage {
92            VersionStage::Alpha => VersionEra::Alpha,
93            _ => VersionEra::Beta,
94        };
95
96        Self {
97            era,
98            major: version.major,
99            minor: version.minor,
100            patch: version.patch,
101            stage: version.stage,
102            stage_number: 0,
103        }
104    }
105
106    fn legacy_snapshot(version: LegacySnapshotVersion) -> Self {
107        Self {
108            era: VersionEra::Legacy,
109            major: version.year,
110            minor: version.week,
111            patch: 0,
112            stage: VersionStage::Snapshot,
113            stage_number: snapshot_suffix_rank(version.suffix),
114        }
115    }
116
117    fn legacy_release(version: LegacyReleaseVersion) -> Self {
118        Self {
119            era: VersionEra::Legacy,
120            major: version.major,
121            minor: version.minor,
122            patch: version.patch,
123            stage: version.stage,
124            stage_number: version.stage_number,
125        }
126    }
127
128    fn year_snapshot(version: YearSnapshotVersion) -> Self {
129        Self {
130            era: VersionEra::Year,
131            major: version.year,
132            minor: version.release,
133            patch: version.patch,
134            stage: VersionStage::Snapshot,
135            stage_number: version.snapshot,
136        }
137    }
138
139    fn year_release(version: YearReleaseVersion) -> Self {
140        Self {
141            era: VersionEra::Year,
142            major: version.year,
143            minor: version.release,
144            patch: version.patch,
145            stage: version.stage,
146            stage_number: version.stage_number,
147        }
148    }
149}
150
151impl From<MinecraftVersionKind> for MinecraftVersionKey {
152    fn from(kind: MinecraftVersionKind) -> Self {
153        match kind {
154            MinecraftVersionKind::AlphaBeta(version) => Self::alpha_beta(version),
155            MinecraftVersionKind::LegacySnapshot(version) => Self::legacy_snapshot(version),
156            MinecraftVersionKind::LegacyRelease(version) => Self::legacy_release(version),
157            MinecraftVersionKind::YearSnapshot(version) => Self::year_snapshot(version),
158            MinecraftVersionKind::YearRelease(version) => Self::year_release(version),
159        }
160    }
161}
162
163fn snapshot_suffix_rank(suffix: Option<char>) -> u32 {
164    match suffix {
165        Some(character) => u32::from(character) - u32::from('a') + 1,
166        None => 0,
167    }
168}