renamed GameMode variants

CHANGELOG.md

@@ -4,6 +4,7 @@
   - Slider velocity is now adjusted properly for taiko converts
 - __Breaking changes:__
   - Replaced the simple `Strains` struct with a new struct `{Mode}Strains` that contains more detail w.r.t. the mode.
+  - Renamed all `GameMode` variants to more idiomatic names
 
 # v0.6.0 (2022-07-05)
 

src/beatmap/converts/mania/mod.rs

@@ -195,7 +195,7 @@ impl Beatmap {
 
         legacy_sort(&mut map.hit_objects);
 
-        map.mode = GameMode::MNA;
+        map.mode = GameMode::Mania;
 
         map
     }

src/beatmap/converts/taiko.rs

@@ -87,7 +87,7 @@ impl Beatmap {
         map.hit_objects
             .sort_by(|p1, p2| p1.partial_cmp(p2).unwrap_or(Ordering::Equal));
 
-        map.mode = GameMode::TKO;
+        map.mode = GameMode::Taiko;
 
         map
     }

src/beatmap/mod.rs

@@ -132,9 +132,9 @@ impl Beatmap {
         }
 
         match mode {
-            GameMode::STD | GameMode::CTB => Cow::Borrowed(self),
+            GameMode::Osu | GameMode::Catch => Cow::Borrowed(self),
-            GameMode::TKO => Cow::Owned(self.convert_to_taiko()),
+            GameMode::Taiko => Cow::Owned(self.convert_to_taiko()),
-            GameMode::MNA => Cow::Owned(self.convert_to_mania()),
+            GameMode::Mania => Cow::Owned(self.convert_to_mania()),
         }
     }
 

src/beatmap/mode.rs

@@ -1,20 +1,19 @@
 /// The mode of a beatmap.
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-#[allow(clippy::upper_case_acronyms)]
 pub enum GameMode {
     /// osu!standard
-    STD = 0,
+    Osu = 0,
     /// osu!taiko
-    TKO = 1,
+    Taiko = 1,
     /// osu!catch
-    CTB = 2,
+    Catch = 2,
     /// osu!mania
-    MNA = 3,
+    Mania = 3,
 }
 
 impl Default for GameMode {
     #[inline]
     fn default() -> Self {
-        Self::STD
+        Self::Osu
     }
 }

src/gradual.rs

@@ -53,10 +53,10 @@ impl<'map> GradualDifficultyAttributes<'map> {
     /// Create a new gradual difficulty calculator for maps of any mode.
     pub fn new(map: &'map Beatmap, mods: impl Mods) -> Self {
         match map.mode {
-            GameMode::STD => Self::Osu(OsuGradualDifficultyAttributes::new(map, mods)),
+            GameMode::Osu => Self::Osu(OsuGradualDifficultyAttributes::new(map, mods)),
-            GameMode::TKO => Self::Taiko(TaikoGradualDifficultyAttributes::new(map, mods)),
+            GameMode::Taiko => Self::Taiko(TaikoGradualDifficultyAttributes::new(map, mods)),
-            GameMode::CTB => Self::Catch(CatchGradualDifficultyAttributes::new(map, mods)),
+            GameMode::Catch => Self::Catch(CatchGradualDifficultyAttributes::new(map, mods)),
-            GameMode::MNA => Self::Mania(ManiaGradualDifficultyAttributes::new(map, mods)),
+            GameMode::Mania => Self::Mania(ManiaGradualDifficultyAttributes::new(map, mods)),
         }
     }
 }
@@ -285,10 +285,10 @@ impl<'map> GradualPerformanceAttributes<'map> {
     /// Create a new gradual performance calculator for maps of any mode.
     pub fn new(map: &'map Beatmap, mods: u32) -> Self {
         match map.mode {
-            GameMode::STD => Self::Osu(OsuGradualPerformanceAttributes::new(map, mods)),
+            GameMode::Osu => Self::Osu(OsuGradualPerformanceAttributes::new(map, mods)),
-            GameMode::TKO => Self::Taiko(TaikoGradualPerformanceAttributes::new(map, mods)),
+            GameMode::Taiko => Self::Taiko(TaikoGradualPerformanceAttributes::new(map, mods)),
-            GameMode::CTB => Self::Catch(CatchGradualPerformanceAttributes::new(map, mods)),
+            GameMode::Catch => Self::Catch(CatchGradualPerformanceAttributes::new(map, mods)),
-            GameMode::MNA => Self::Mania(ManiaGradualPerformanceAttributes::new(map, mods)),
+            GameMode::Mania => Self::Mania(ManiaGradualPerformanceAttributes::new(map, mods)),
         }
     }
 

src/lib.rs

@@ -80,7 +80,7 @@
 //! This could be done by using `passed_objects` as the amount of objects that were passed so far.
 //! However, this requires to recalculate the beginning again and again, we can be more efficient than that.
 //!
-//! Instead, you should use `GradualDifficultyAttributes` and `GradualPerformanceAttributes`:
+//! Instead, you should use [`GradualDifficultyAttributes`] and [`GradualPerformanceAttributes`]:
 //!
 //! ```no_run
 //! use rosu_pp::{
@@ -255,24 +255,24 @@ impl BeatmapExt for Beatmap {
     #[inline]
     fn stars(&self) -> AnyStars<'_> {
         match self.mode {
-            GameMode::STD => AnyStars::Osu(OsuStars::new(self)),
+            GameMode::Osu => AnyStars::Osu(OsuStars::new(self)),
-            GameMode::MNA => AnyStars::Mania(ManiaStars::new(self)),
+            GameMode::Mania => AnyStars::Mania(ManiaStars::new(self)),
-            GameMode::TKO => AnyStars::Taiko(TaikoStars::new(self)),
+            GameMode::Taiko => AnyStars::Taiko(TaikoStars::new(self)),
-            GameMode::CTB => AnyStars::Catch(CatchStars::new(self)),
+            GameMode::Catch => AnyStars::Catch(CatchStars::new(self)),
         }
     }
 
     #[inline]
     fn max_pp(&self, mods: u32) -> PerformanceAttributes {
         match self.mode {
-            GameMode::STD => PerformanceAttributes::Osu(OsuPP::new(self).mods(mods).calculate()),
+            GameMode::Osu => PerformanceAttributes::Osu(OsuPP::new(self).mods(mods).calculate()),
-            GameMode::MNA => {
+            GameMode::Mania => {
                 PerformanceAttributes::Mania(ManiaPP::new(self).mods(mods).calculate())
             }
-            GameMode::TKO => {
+            GameMode::Taiko => {
                 PerformanceAttributes::Taiko(TaikoPP::new(self).mods(mods).calculate())
             }
-            GameMode::CTB => {
+            GameMode::Catch => {
                 PerformanceAttributes::Catch(CatchPP::new(self).mods(mods).calculate())
             }
         }
@@ -286,10 +286,10 @@ impl BeatmapExt for Beatmap {
     #[inline]
     fn strains(&self, mods: u32) -> Strains {
         match self.mode {
-            GameMode::STD => Strains::Osu(OsuStars::new(self).mods(mods).strains()),
+            GameMode::Osu => Strains::Osu(OsuStars::new(self).mods(mods).strains()),
-            GameMode::MNA => Strains::Mania(ManiaStars::new(self).mods(mods).strains()),
+            GameMode::Mania => Strains::Mania(ManiaStars::new(self).mods(mods).strains()),
-            GameMode::TKO => Strains::Taiko(TaikoStars::new(self).mods(mods).strains()),
+            GameMode::Taiko => Strains::Taiko(TaikoStars::new(self).mods(mods).strains()),
-            GameMode::CTB => Strains::Catch(CatchStars::new(self).mods(mods).strains()),
+            GameMode::Catch => Strains::Catch(CatchStars::new(self).mods(mods).strains()),
         }
     }
 

src/mania/gradual_difficulty.rs

@@ -56,8 +56,8 @@ impl<'map> ManiaGradualDifficultyAttributes<'map> {
         let rounded_cs = map.cs.round();
 
         let columns = match map.mode {
-            GameMode::MNA => rounded_cs.max(1.0) as u8,
+            GameMode::Mania => rounded_cs.max(1.0) as u8,
-            GameMode::STD => {
+            GameMode::Osu => {
                 let rounded_od = map.od.round();
 
                 let n_objects = map.n_circles + map.n_sliders + map.n_spinners;

src/mania/mod.rs

@@ -140,8 +140,8 @@ fn calculate_strain(params: ManiaStars<'_>) -> Strain {
     let rounded_cs = map.cs.round();
 
     let columns = match map.mode {
-        GameMode::MNA => rounded_cs.max(1.0) as u8,
+        GameMode::Mania => rounded_cs.max(1.0) as u8,
-        GameMode::STD => {
+        GameMode::Osu => {
             let rounded_od = map.od.round();
 
             let n_objects = map.n_circles + map.n_sliders + map.n_spinners;
@@ -270,7 +270,7 @@ impl<'map> From<OsuStars<'map>> for ManiaStars<'map> {
         } = osu;
 
         Self {
-            map: map.convert_mode(GameMode::MNA),
+            map: map.convert_mode(GameMode::Mania),
             mods,
             passed_objects,
             clock_rate,

src/mania/pp.rs

@@ -225,7 +225,7 @@ impl<'map> From<OsuPP<'map>> for ManiaPP<'map> {
         } = osu;
 
         Self {
-            map: map.convert_mode(GameMode::MNA),
+            map: map.convert_mode(GameMode::Mania),
             stars: None,
             mods,
             score: None,

src/osu/mod.rs

@@ -71,10 +71,10 @@ impl<'map> OsuStars<'map> {
     #[inline]
     pub fn mode(self, mode: GameMode) -> AnyStars<'map> {
         match mode {
-            GameMode::STD => AnyStars::Osu(self),
+            GameMode::Osu => AnyStars::Osu(self),
-            GameMode::TKO => AnyStars::Taiko(self.into()),
+            GameMode::Taiko => AnyStars::Taiko(self.into()),
-            GameMode::CTB => AnyStars::Catch(self.into()),
+            GameMode::Catch => AnyStars::Catch(self.into()),
-            GameMode::MNA => AnyStars::Mania(self.into()),
+            GameMode::Mania => AnyStars::Mania(self.into()),
         }
     }
 

src/osu/pp.rs

@@ -73,10 +73,10 @@ impl<'map> OsuPP<'map> {
     #[inline]
     pub fn mode(self, mode: GameMode) -> AnyPP<'map> {
         match mode {
-            GameMode::STD => AnyPP::Osu(self),
+            GameMode::Osu => AnyPP::Osu(self),
-            GameMode::TKO => AnyPP::Taiko(self.into()),
+            GameMode::Taiko => AnyPP::Taiko(self.into()),
-            GameMode::CTB => AnyPP::Catch(self.into()),
+            GameMode::Catch => AnyPP::Catch(self.into()),
-            GameMode::MNA => AnyPP::Mania(self.into()),
+            GameMode::Mania => AnyPP::Mania(self.into()),
         }
     }
 

src/parse/mod.rs

@@ -101,10 +101,10 @@ macro_rules! parse_general_body {
 
             if key == b"Mode" {
                 mode = match value {
-                    "0" => Some(GameMode::STD),
+                    "0" => Some(GameMode::Osu),
-                    "1" => Some(GameMode::TKO),
+                    "1" => Some(GameMode::Taiko),
-                    "2" => Some(GameMode::CTB),
+                    "2" => Some(GameMode::Catch),
-                    "3" => Some(GameMode::MNA),
+                    "3" => Some(GameMode::Mania),
                     _ => return Err(ParseError::InvalidMode),
                 };
             }
@@ -114,7 +114,7 @@ macro_rules! parse_general_body {
             }
         }
 
-        $self.mode = mode.unwrap_or(GameMode::STD);
+        $self.mode = mode.unwrap_or(GameMode::Osu);
         $self.stack_leniency = stack_leniency.unwrap_or(0.7);
 
         Ok(empty)
@@ -456,7 +456,7 @@ macro_rules! parse_hitobjects_body {
 
         // BUG: If [General] section comes after [HitObjects] then the mode
         // won't be set yet so mania objects won't be sorted properly
-        if $self.mode == GameMode::MNA {
+        if $self.mode == GameMode::Mania {
             // First a _stable_ sort by time
             $self
                 .hit_objects

src/pp.rs

@@ -53,10 +53,10 @@ impl<'map> AnyPP<'map> {
     #[inline]
     pub fn new(map: &'map Beatmap) -> Self {
         match map.mode {
-            GameMode::CTB => Self::Catch(CatchPP::new(map)),
+            GameMode::Catch => Self::Catch(CatchPP::new(map)),
-            GameMode::MNA => Self::Mania(ManiaPP::new(map)),
+            GameMode::Mania => Self::Mania(ManiaPP::new(map)),
-            GameMode::STD => Self::Osu(OsuPP::new(map)),
+            GameMode::Osu => Self::Osu(OsuPP::new(map)),
-            GameMode::TKO => Self::Taiko(TaikoPP::new(map)),
+            GameMode::Taiko => Self::Taiko(TaikoPP::new(map)),
         }
     }
 
@@ -90,10 +90,10 @@ impl<'map> AnyPP<'map> {
     pub fn mode(self, mode: GameMode) -> Self {
         match self {
             AnyPP::Osu(o) => match mode {
-                GameMode::STD => AnyPP::Osu(o),
+                GameMode::Osu => AnyPP::Osu(o),
-                GameMode::TKO => AnyPP::Taiko(o.into()),
+                GameMode::Taiko => AnyPP::Taiko(o.into()),
-                GameMode::CTB => AnyPP::Catch(o.into()),
+                GameMode::Catch => AnyPP::Catch(o.into()),
-                GameMode::MNA => AnyPP::Mania(o.into()),
+                GameMode::Mania => AnyPP::Mania(o.into()),
             },
             other => other,
         }

src/stars.rs

@@ -37,10 +37,10 @@ impl<'map> AnyStars<'map> {
     #[inline]
     pub fn new(map: &'map Beatmap) -> Self {
         match map.mode {
-            GameMode::CTB => Self::Catch(CatchStars::new(map)),
+            GameMode::Catch => Self::Catch(CatchStars::new(map)),
-            GameMode::MNA => Self::Mania(ManiaStars::new(map)),
+            GameMode::Mania => Self::Mania(ManiaStars::new(map)),
-            GameMode::STD => Self::Osu(OsuStars::new(map)),
+            GameMode::Osu => Self::Osu(OsuStars::new(map)),
-            GameMode::TKO => Self::Taiko(TaikoStars::new(map)),
+            GameMode::Taiko => Self::Taiko(TaikoStars::new(map)),
         }
     }
 
@@ -49,10 +49,10 @@ impl<'map> AnyStars<'map> {
     pub fn mode(self, mode: GameMode) -> Self {
         match self {
             AnyStars::Osu(o) => match mode {
-                GameMode::STD => AnyStars::Osu(o),
+                GameMode::Osu => AnyStars::Osu(o),
-                GameMode::TKO => AnyStars::Taiko(o.into()),
+                GameMode::Taiko => AnyStars::Taiko(o.into()),
-                GameMode::CTB => AnyStars::Catch(o.into()),
+                GameMode::Catch => AnyStars::Catch(o.into()),
-                GameMode::MNA => AnyStars::Mania(o.into()),
+                GameMode::Mania => AnyStars::Mania(o.into()),
             },
             other => other,
         }

src/taiko/mod.rs

@@ -362,7 +362,7 @@ impl<'map> From<OsuStars<'map>> for TaikoStars<'map> {
         } = osu;
 
         Self {
-            map: map.convert_mode(GameMode::TKO),
+            map: map.convert_mode(GameMode::Taiko),
             mods,
             passed_objects,
             clock_rate,

src/taiko/pp.rs

@@ -321,7 +321,7 @@ impl<'map> From<OsuPP<'map>> for TaikoPP<'map> {
         } = osu;
 
         Self {
-            map: map.convert_mode(GameMode::TKO),
+            map: map.convert_mode(GameMode::Taiko),
             attributes: None,
             mods,
             combo,