refactor!: store lazer in Difficulty

src/osu/convert.rs

@@ -55,18 +55,8 @@ pub fn convert_objects(
                 OsuObjectKind::Circle => attrs.n_circles += 1,
                 OsuObjectKind::Slider(ref slider) => {
                     attrs.n_sliders += 1;
+                    attrs.n_slider_ticks += slider.tick_count() as u32;
                     attrs.max_combo += slider.nested_objects.len() as u32;
-
-                    attrs.n_slider_ticks += slider
-                        .nested_objects
-                        .iter()
-                        .filter(|nested| {
-                            matches!(
-                                nested.kind,
-                                NestedSliderObjectKind::Tick | NestedSliderObjectKind::Repeat
-                            )
-                        })
-                        .count() as u32;
                 }
                 OsuObjectKind::Spinner(_) => attrs.n_spinners += 1,
             }

src/osu/difficulty/gradual.rs

@@ -92,6 +92,7 @@ impl OsuGradualDifficulty {
 
         attrs.n_circles = 0;
         attrs.n_sliders = 0;
+        attrs.n_slider_ticks = 0;
         attrs.n_spinners = 0;
         attrs.max_combo = 0;
 
@@ -128,6 +129,7 @@ impl OsuGradualDifficulty {
             OsuObjectKind::Circle => attrs.n_circles += 1,
             OsuObjectKind::Slider(slider) => {
                 attrs.n_sliders += 1;
+                attrs.n_slider_ticks += slider.tick_count() as u32;
                 attrs.max_combo += slider.nested_objects.len() as u32;
             }
             OsuObjectKind::Spinner { .. } => attrs.n_spinners += 1,

src/osu/object.rs

@@ -308,6 +308,19 @@ impl OsuSlider {
             .count()
     }
 
+    /// Counts both ticks and repeats
+    pub fn tick_count(&self) -> usize {
+        self.nested_objects
+            .iter()
+            .filter(|nested| {
+                matches!(
+                    nested.kind,
+                    NestedSliderObjectKind::Tick | NestedSliderObjectKind::Repeat
+                )
+            })
+            .count()
+    }
+
     pub fn tail(&self) -> Option<&NestedSliderObject> {
         self.nested_objects
             .iter()

src/osu/performance/gradual.rs

@@ -80,15 +80,17 @@ use super::{OsuPerformanceAttributes, OsuScoreState};
 /// [`next`]: OsuGradualPerformance::next
 /// [`nth`]: OsuGradualPerformance::nth
 pub struct OsuGradualPerformance {
+    lazer: bool,
     difficulty: OsuGradualDifficulty,
 }
 
 impl OsuGradualPerformance {
     /// Create a new gradual performance calculator for osu!standard maps.
     pub fn new(difficulty: Difficulty, converted: &OsuBeatmap<'_>) -> Self {
+        let lazer = difficulty.get_lazer();
         let difficulty = OsuGradualDifficulty::new(difficulty, converted);
 
-        Self { difficulty }
+        Self { lazer, difficulty }
     }
 
     /// Process the next hit object and calculate the performance attributes
@@ -113,6 +115,7 @@ impl OsuGradualPerformance {
             .difficulty
             .nth(n)?
             .performance()
+            .lazer(self.lazer)
             .state(state)
             .difficulty(self.difficulty.difficulty.clone())
             .passed_objects(self.difficulty.idx as u32)

src/osu/performance/mod.rs

@@ -35,7 +35,6 @@ pub struct OsuPerformance<'map> {
     pub(crate) n50: Option<u32>,
     pub(crate) misses: Option<u32>,
     pub(crate) hitresult_priority: HitResultPriority,
-    pub(crate) lazer: Option<bool>,
 }
 
 impl<'map> OsuPerformance<'map> {
@@ -158,12 +157,12 @@ impl<'map> OsuPerformance<'map> {
     /// Whether the calculated attributes belong to an osu!lazer or osu!stable
     /// score.
     ///
-    /// Defaults to lazer.
+    /// Defaults to `true`.
     ///
     /// This affects internal accuracy calculation because lazer considers
     /// slider heads for accuracy whereas stable does not.
-    pub const fn lazer(mut self, lazer: bool) -> Self {
-        self.lazer = Some(lazer);
+    pub fn lazer(mut self, lazer: bool) -> Self {
+        self.difficulty = self.difficulty.lazer(lazer);
 
         self
     }
@@ -366,7 +365,7 @@ impl<'map> OsuPerformance<'map> {
         let mut n100 = self.n100.map_or(0, |n| cmp::min(n, n_remaining));
         let mut n50 = self.n50.map_or(0, |n| cmp::min(n, n_remaining));
 
-        let lazer = self.lazer.unwrap_or(true);
+        let lazer = self.difficulty.get_lazer();
 
         let (n_slider_ends, n_slider_ticks, max_slider_ends, max_slider_ticks) = if lazer {
             let n_slider_ends = self
@@ -627,7 +626,7 @@ impl<'map> OsuPerformance<'map> {
 
         let effective_miss_count = calculate_effective_misses(&attrs, &state);
 
-        let lazer = self.lazer.unwrap_or(true);
+        let lazer = self.difficulty.get_lazer();
 
         let (n_slider_ends, n_slider_ticks) = if lazer {
             (attrs.n_sliders, attrs.n_slider_ticks)
@@ -660,7 +659,6 @@ impl<'map> OsuPerformance<'map> {
             n50: None,
             misses: None,
             hitresult_priority: HitResultPriority::DEFAULT,
-            lazer: None,
         }
     }
 }