add initial reworks

src/osu_2019/pp.rs

@@ -243,7 +243,7 @@ impl<'m> OsuPP<'m> {
         self.assert_hitresults();
 
         let total_hits = self.total_hits() as f32;
-        let mut multiplier = 1.09;
+        let mut multiplier = 0.882;
 
         let effective_miss_count = self.calculate_effective_miss_count();
 
@@ -265,7 +265,7 @@ impl<'m> OsuPP<'m> {
 
         if streams_nerf < 1.09 {
             let acc_factor = (1.0 - self.acc.unwrap()).abs();
-            acc_depression = (0.86 - acc_factor).max(0.5);
+            acc_depression = (0.89 - acc_factor).max(0.5);
 
             if acc_depression > 0.0 {
                 aim_value *= acc_depression;
@@ -357,7 +357,10 @@ impl<'m> OsuPP<'m> {
 
         // Penalize misses
         if effective_miss_count > 0.0 {
-            let miss_penalty = self.calculate_miss_penalty(effective_miss_count);
+            let miss_penalty = self.calculate_miss_penalty(
+                effective_miss_count,
+                attributes.aim_difficult_strain_count,
+            );
             aim_value *= miss_penalty;
         }
 
@@ -401,7 +404,7 @@ impl<'m> OsuPP<'m> {
         }
 
         // Scale with accuracy
-        aim_value *= 0.3 + self.acc.unwrap() / 2.0;
+        aim_value *= self.acc.unwrap();
         aim_value *= 0.98 + attributes.od as f32 * attributes.od as f32 / 2500.0;
 
         aim_value
@@ -421,7 +424,10 @@ impl<'m> OsuPP<'m> {
 
         // Penalize misses
         if effective_miss_count > 0.0 {
-            let miss_penalty = self.calculate_miss_penalty(effective_miss_count);
+            let miss_penalty = self.calculate_miss_penalty(
+                effective_miss_count,
+                attributes.speed_difficult_strain_count,
+            );
             speed_value *= miss_penalty;
         }
 
@@ -499,11 +505,12 @@ impl<'m> OsuPP<'m> {
     }
 
     #[inline]
-    fn calculate_miss_penalty(&self, effective_miss_count: f32) -> f32 {
+    fn calculate_miss_penalty(
-        let total_hits = self.total_hits() as f32;
+        &self,
-
+        effective_miss_count: f32,
-        0.97 * (1.0 - (effective_miss_count / total_hits).powf(0.5))
+        difficult_strain_count: f32,
-            .powf(1.0 + (effective_miss_count / 1.5))
+    ) -> f32 {
+        0.96 / ((effective_miss_count / (4.0 * difficult_strain_count.ln().powf(0.94))) + 1.0)
     }
 
     #[inline]

src/osu_2019/skill.rs

@@ -19,6 +19,8 @@ pub(crate) struct Skill {
 
     prev_time: Option<f32>,
     pub(crate) object_strains: Vec<f32>,
+
+    difficulty_value: Option<f32>,
 }
 
 impl Skill {
@@ -33,6 +35,8 @@ impl Skill {
 
             prev_time: None,
             object_strains: Vec::new(),
+
+            difficulty_value: None,
         }
     }
 
@@ -69,19 +73,19 @@ impl Skill {
             weight *= DECAY_WEIGHT;
         }
 
+        self.difficulty_value = Some(difficulty);
+
         difficulty
     }
 
-    pub(crate) fn count_difficult_strains(&mut self) -> f64 {
+    pub(crate) fn count_difficult_strains(&mut self) -> f32 {
-        let top_strain = self
+        let difficulty_value = self.difficulty_value.unwrap_or(self.difficulty_value());
-            .object_strains
+        let single_strain = difficulty_value / 10.0;
-            .iter()
-            .fold(f64::NEG_INFINITY, |prev, curr| prev.max(*curr as f64));
 
         self.object_strains
             .iter()
-            .map(|strain| (strain / top_strain as f32).powi(4))
+            .map(|strain| 1.1 / (1.0 + (-10.0 * (strain / single_strain - 0.88)).exp()))
-            .sum::<f32>() as f64
+            .sum::<f32>()
     }
 
     #[inline]

src/osu_2019/stars.rs

@@ -162,8 +162,8 @@ pub struct OsuDifficultyAttributes {
     pub n_spinners: usize,
     pub stars: f64,
     pub max_combo: usize,
-    pub aim_difficult_strain_count: f64,
+    pub aim_difficult_strain_count: f32,
-    pub speed_difficult_strain_count: f64,
+    pub speed_difficult_strain_count: f32,
     pub beatmap_id: i32,
     pub beatmap_creator: String,
 }