fix: adjust remaining catch pieces

src/catch/catcher.rs

@@ -15,6 +15,6 @@ impl Catcher {
     }
 
     fn calculate_scale(cs: f32) -> f32 {
-        1.0 - 0.7 * (cs - 5.0) / 5.0
+        ((1.0 - 0.7 * ((f64::from(cs) - 5.0) / 5.0)) as f32 / 2.0 * 1.0) * 2.0
     }
 }

src/catch/convert.rs

@@ -232,11 +232,14 @@ fn apply_hr_offset(
 ) {
     let mut offset_pos = x;
 
-    let Some(last_pos) = last_pos else {
-        *last_pos = Some(offset_pos);
-        *last_start_time = start_time;
+    let last_pos = match last_pos {
+        Some(pos) if pos.abs() >= f32::EPSILON => pos,
+        Some(_) | None => {
+            *last_pos = Some(offset_pos);
+            *last_start_time = start_time;
 
-        return;
+            return;
+        }
     };
 
     let pos_diff = offset_pos - *last_pos;
@@ -310,7 +313,10 @@ fn initialize_hyper_dash(cs: f32, palpable_objects: &mut [PalpableObject]) {
             -1
         };
 
-        let time_to_next = next.start_time - curr.start_time - f64::from(1000.0_f32 / 60.0 / 4.0);
+        // * Int truncation added to match osu!stable.
+        let time_to_next = f64::from(
+            (next.start_time as i32 - curr.start_time as i32) as f32 - 1000.0 / 60.0 / 4.0,
+        );
 
         let dist_to_next = f64::from((next.effective_x() - curr.effective_x()).abs())
             - if last_dir == this_dir {

src/catch/object/juice_stream.rs

@@ -44,12 +44,29 @@ impl<'a> JuiceStream<'a> {
 
         let path = slider.curve(GameMode::Catch, &mut bufs.curve);
 
-        let velocity_factor = JuiceStream::BASE_SCORING_DIST * slider_multiplier / beat_len;
-        let velocity = velocity_factor * slider_velocity;
-        let tick_dist_factor =
-            JuiceStream::BASE_SCORING_DIST * slider_multiplier / slider_tick_rate;
+        fn get_precision_adjusted_beat_len(slider_velocity_multiplier: f64, beat_len: f64) -> f64 {
+            let slider_velocity_as_beat_len = -100.0 / slider_velocity_multiplier;
 
-        let tick_dist = tick_dist_factor * slider_velocity;
+            let bpm_multiplier = if slider_velocity_as_beat_len < 0.0 {
+                f64::from(((-slider_velocity_as_beat_len) as f32).clamp(10.0, 10_000.0)) / 100.0
+            } else {
+                1.0
+            };
+
+            beat_len * bpm_multiplier
+        }
+
+        let velocity = JuiceStream::BASE_SCORING_DIST * slider_multiplier
+            / get_precision_adjusted_beat_len(slider_velocity, beat_len);
+        let scoring_dist = velocity * beat_len;
+
+        let tick_dist_multiplier = if converted.version < 8 {
+            slider_velocity.recip()
+        } else {
+            1.0
+        };
+
+        let tick_dist = scoring_dist / slider_tick_rate * tick_dist_multiplier;
 
         let span_count = slider.span_count() as f64;
         let duration = span_count * path.dist() / velocity;
@@ -70,7 +87,7 @@ impl<'a> JuiceStream<'a> {
         for e in events {
             if let Some(last_event_time) = last_event_time {
                 let mut tiny_droplets = 0;
-                let since_last_tick = e.time - last_event_time;
+                let since_last_tick = f64::from(e.time as i32 - last_event_time as i32);
 
                 if since_last_tick > 80.0 {
                     let mut time_between_tiny = since_last_tick;
@@ -135,12 +152,14 @@ impl<'a> JuiceStream<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct NestedJuiceStreamObject {
     pub pos: f32,
     pub start_time: f64,
     pub kind: NestedJuiceStreamObjectKind,
 }
 
+#[derive(Debug)]
 pub enum NestedJuiceStreamObjectKind {
     Fruit,
     Droplet,