bundle parameters for osu object creation

src/osu/versions/no_leniency/mod.rs

@@ -7,6 +7,8 @@
 
 use std::mem;
 
+use self::osu_object::ObjectParameters;
+
 use super::super::DifficultyAttributes;
 
 mod difficulty_object;
@@ -67,26 +69,21 @@ pub fn stars(
         scaling_factor *= 1.0 + small_circle_bonus;
     }
 
-    let mut slider_state = SliderState::new(map);
-    let mut curve_bufs = CurveBuffers::default();
-    let mut ticks_buf = Vec::new();
+    let mut params = ObjectParameters {
+        map,
+        radius,
+        scaling_factor,
+        attributes: &mut diff_attributes,
+        slider_state: SliderState::new(map),
+        ticks: Vec::new(),
+        curve_bufs: CurveBuffers::default(),
+    };
 
     let mut hit_objects = map
         .hit_objects
         .iter()
         .take(take)
-        .filter_map(|h| {
-            OsuObject::new(
-                h,
-                map,
-                radius,
-                scaling_factor,
-                &mut ticks_buf,
-                &mut diff_attributes,
-                &mut slider_state,
-                &mut curve_bufs,
-            )
-        })
+        .filter_map(|h| OsuObject::new(h, &mut params))
         .map(|mut h| {
             h.time /= map_attributes.clock_rate;
 
@@ -239,22 +236,20 @@ pub fn strains(map: &Beatmap, mods: impl Mods) -> Strains {
         scaling_factor *= 1.0 + small_circle_bonus;
     }
 
-    let mut slider_state = SliderState::new(map);
-    let mut ticks_buf = Vec::new();
-    let mut curve_bufs = CurveBuffers::default();
+    let mut params = ObjectParameters {
+        map,
+        radius,
+        scaling_factor,
+        attributes: &mut diff_attributes,
+        slider_state: SliderState::new(map),
+        ticks: Vec::new(),
+        curve_bufs: CurveBuffers::default(),
+    };
 
-    let mut hit_objects = map.hit_objects.iter().filter_map(|h| {
-        OsuObject::new(
-            h,
-            map,
-            radius,
-            scaling_factor,
-            &mut ticks_buf,
-            &mut diff_attributes,
-            &mut slider_state,
-            &mut curve_bufs,
-        )
-    });
+    let mut hit_objects = map
+        .hit_objects
+        .iter()
+        .filter_map(|h| OsuObject::new(h, &mut params));
 
     let fl = mods.fl();
     let mut skills = Vec::with_capacity(2 + fl as usize);

src/osu/versions/no_leniency/osu_object.rs

@@ -26,17 +26,28 @@ pub(crate) enum OsuObjectKind {
     Spinner,
 }
 
+pub(crate) struct ObjectParameters<'a> {
+    pub(crate) map: &'a Beatmap,
+    pub(crate) radius: f32,
+    pub(crate) scaling_factor: f32,
+    pub(crate) attributes: &'a mut DifficultyAttributes,
+    pub(crate) ticks: Vec<f32>,
+    pub(crate) slider_state: SliderState<'a>,
+    pub(crate) curve_bufs: CurveBuffers,
+}
+
 impl OsuObject {
-    pub(crate) fn new(
-        h: &HitObject,
-        map: &Beatmap,
-        radius: f32,
-        scaling_factor: f32,
-        ticks: &mut Vec<f32>,
-        attributes: &mut DifficultyAttributes,
-        slider_state: &mut SliderState,
-        curve_bufs: &mut CurveBuffers,
-    ) -> Option<Self> {
+    pub(crate) fn new(h: &HitObject, params: &mut ObjectParameters) -> Option<Self> {
+        let ObjectParameters {
+            map,
+            radius,
+            scaling_factor,
+            attributes,
+            ticks,
+            slider_state,
+            curve_bufs,
+        } = params;
+
         attributes.max_combo += 1; // hitcircle, slider head, or spinner
 
         let obj = match &h.kind {
@@ -59,7 +70,7 @@ impl OsuObject {
 
                 let span_count = (*repeats + 1) as f32;
 
-                let approx_follow_circle_radius = radius * 3.0;
+                let approx_follow_circle_radius = *radius * 3.0;
                 let mut tick_dist = 100.0 * map.slider_mult / map.tick_rate;
 
                 if map.version >= 8 {
@@ -151,7 +162,7 @@ impl OsuObject {
                 ticks.clear();
 
                 let end_pos = curve.position_at(1.0); // TODO: what if reversing odd amount?
-                travel_dist *= scaling_factor;
+                travel_dist *= *scaling_factor;
 
                 Self {
                     time: h.start_time,