store bpm_mult in diff points (/b/1033882+Taiko)

src/model/beatmap/mod.rs

@@ -5,7 +5,7 @@ use rosu_map::{
     LATEST_FORMAT_VERSION,
 };
 
-use crate::{Performance, Difficulty};
+use crate::{Difficulty, Performance};
 
 pub use self::{
     attributes::{BeatmapAttributes, BeatmapAttributesBuilder, HitWindows},
@@ -183,29 +183,3 @@ impl Default for Beatmap {
         }
     }
 }
-
-macro_rules! define_beat_len_fn {
-    ( $fn_name:ident, $clamp:literal) => {
-        #[allow(unused)]
-        pub(crate) fn $fn_name(map: &Beatmap, beat_len: f64, time: f64) -> f64 {
-            let slider_velocity = map
-                .difficulty_point_at(time)
-                .map_or(DifficultyPoint::DEFAULT_SLIDER_VELOCITY, |point| {
-                    point.slider_velocity
-                });
-
-            let slider_velocity_as_beat_len = -100.0 / slider_velocity;
-
-            let bpm_mult = if slider_velocity_as_beat_len < 0.0 {
-                f64::from(((-slider_velocity_as_beat_len) as f32).clamp(10.0, $clamp)) / 100.0
-            } else {
-                1.0
-            };
-
-            beat_len * bpm_mult
-        }
-    };
-}
-
-define_beat_len_fn!(get_precision_adjusted_beat_len_taiko_mania, 10_000.0);
-define_beat_len_fn!(get_precision_adjusted_beat_len_osu_catch, 1000.0);

src/model/control_point/difficulty.rs

@@ -1,4 +1,46 @@
-pub use rosu_map::section::timing_points::DifficultyPoint;
+/// Difficulty-related info about this control point.
+#[derive(Clone, Debug, PartialEq)]
+pub struct DifficultyPoint {
+    pub time: f64,
+    pub slider_velocity: f64,
+    pub bpm_multiplier: f64,
+    pub generate_ticks: bool,
+}
+
+impl DifficultyPoint {
+    pub const DEFAULT_SLIDER_VELOCITY: f64 = 1.0;
+    pub const DEFAULT_BPM_MULTIPLIER: f64 = 1.0;
+    pub const DEFAULT_GENERATE_TICKS: bool = true;
+
+    pub fn new(time: f64, beat_len: f64, speed_multiplier: f64) -> Self {
+        Self {
+            time,
+            slider_velocity: speed_multiplier.clamp(0.1, 10.0),
+            bpm_multiplier: if beat_len < 0.0 {
+                f64::from((-beat_len) as f32).clamp(10.0, 10_000.0) / 100.0
+            } else {
+                1.0
+            },
+            generate_ticks: !beat_len.is_nan(),
+        }
+    }
+
+    pub fn is_redundant(&self, existing: &Self) -> bool {
+        self.generate_ticks == existing.generate_ticks
+            && (self.slider_velocity - existing.slider_velocity).abs() < f64::EPSILON
+    }
+}
+
+impl Default for DifficultyPoint {
+    fn default() -> Self {
+        Self {
+            time: 0.0,
+            slider_velocity: Self::DEFAULT_SLIDER_VELOCITY,
+            bpm_multiplier: Self::DEFAULT_BPM_MULTIPLIER,
+            generate_ticks: Self::DEFAULT_GENERATE_TICKS,
+        }
+    }
+}
 
 pub fn difficulty_point_at(points: &[DifficultyPoint], time: f64) -> Option<&DifficultyPoint> {
     points