elemental_core/minecraft/version/
kind.rs1#[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 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 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 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#[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}