expose Converted::map

src/osu/convert.rs

@@ -40,7 +40,6 @@ pub fn convert_objects(
     let mut ticks_buf = Vec::new();
 
     let mut osu_objects: Box<[_]> = converted
-        .map
         .hit_objects
         .iter()
         .map(|h| OsuObject::new(h, converted, &mut curve_bufs, &mut ticks_buf))
@@ -71,9 +70,9 @@ pub fn convert_objects(
         osu_objects.iter_mut().for_each(OsuObject::finalize_tail);
     }
 
-    let stack_threshold = time_preempt * f64::from(converted.map.stack_leniency);
+    let stack_threshold = time_preempt * f64::from(converted.stack_leniency);
 
-    if converted.map.version >= 6 {
+    if converted.version >= 6 {
         stacking(&mut osu_objects, stack_threshold);
     } else {
         old_stacking(&mut osu_objects, stack_threshold);

src/osu/difficulty/gradual.rs

@@ -89,7 +89,7 @@ impl OsuGradualDifficulty {
             &scaling_factor,
             mods.hr(),
             time_preempt,
-            converted.map.hit_objects.len(),
+            converted.hit_objects.len(),
             &mut attrs,
         );
 
@@ -290,7 +290,7 @@ mod tests {
         let mut gradual_2nd = OsuGradualDifficulty::new(&difficulty, &converted);
         let mut gradual_3rd = OsuGradualDifficulty::new(&difficulty, &converted);
 
-        let hit_objects_len = converted.map.hit_objects.len();
+        let hit_objects_len = converted.hit_objects.len();
 
         for i in 1.. {
             let Some(next_gradual) = gradual.next() else {

src/osu/difficulty/mod.rs

@@ -140,8 +140,7 @@ impl DifficultyValues {
             let mut flashlight = Skill::new(&mut skills.flashlight, &diff_objects);
 
             // The first hit object has no difficulty object
-            let take_diff_objects =
-                cmp::min(converted.map.hit_objects.len(), take).saturating_sub(1);
+            let take_diff_objects = cmp::min(converted.hit_objects.len(), take).saturating_sub(1);
 
             for hit_object in diff_objects.iter().take(take_diff_objects) {
                 aim.process(hit_object);

src/osu/object.rs

@@ -167,22 +167,20 @@ impl OsuSlider {
         ticks_buf: &mut Vec<SliderEvent>,
     ) -> Self {
         let start_time = h.start_time;
-        let slider_multiplier = converted.map.slider_multiplier;
-        let slider_tick_rate = converted.map.slider_tick_rate;
+        let slider_multiplier = converted.slider_multiplier;
+        let slider_tick_rate = converted.slider_tick_rate;
 
         let beat_len = converted
-            .map
             .timing_point_at(start_time)
             .map_or(TimingPoint::DEFAULT_BEAT_LEN, |point| point.beat_len);
 
-        let (slider_velocity, generate_ticks) =
-            converted.map.difficulty_point_at(start_time).map_or(
-                (
-                    DifficultyPoint::DEFAULT_SLIDER_VELOCITY,
-                    DifficultyPoint::DEFAULT_GENERATE_TICKS,
-                ),
-                |point| (point.slider_velocity, point.generate_ticks),
-            );
+        let (slider_velocity, generate_ticks) = converted.difficulty_point_at(start_time).map_or(
+            (
+                DifficultyPoint::DEFAULT_SLIDER_VELOCITY,
+                DifficultyPoint::DEFAULT_GENERATE_TICKS,
+            ),
+            |point| (point.slider_velocity, point.generate_ticks),
+        );
 
         let path = slider.curve(curve_bufs);
 
@@ -197,7 +195,7 @@ impl OsuSlider {
         let duration = end_time - start_time;
         let span_duration = duration / span_count;
 
-        let tick_dist_multiplier = if converted.map.version < 8 {
+        let tick_dist_multiplier = if converted.version < 8 {
             slider_velocity.recip()
         } else {
             1.0

src/osu/performance/gradual.rs

@@ -147,7 +147,7 @@ mod tests {
 
         let mut state = OsuScoreState::default();
 
-        let hit_objects_len = converted.map.hit_objects.len();
+        let hit_objects_len = converted.hit_objects.len();
 
         for i in 1.. {
             state.misses += 1;