refactor!: overhauled gradual calc for mania

tests/gradual_mania.rs

@@ -1,4 +1,7 @@
-#![cfg(all(not(any(feature = "async_tokio", feature = "async_std")), feature = "gradual"))]
+#![cfg(all(
+    not(any(feature = "async_tokio", feature = "async_std")),
+    feature = "gradual"
+))]
 
 use rosu_pp::{
     mania::{ManiaGradualDifficultyAttributes, ManiaGradualPerformanceAttributes, ManiaScoreState},
@@ -34,52 +37,38 @@ fn correct_empty() {
     let map = test_map!(Mania);
     let mut gradual = ManiaGradualPerformanceAttributes::new(&map, 0);
 
-    let state = ManiaScoreState {
-        n320: 0,
-        n300: 0,
-        n200: 0,
-        n100: 0,
-        n50: 0,
-        n_misses: 0,
-    };
+    let state = ManiaScoreState::default();
 
-    let first_attrs = gradual.process_next_n_objects(state.clone(), usize::MAX);
+    let first_attrs = gradual.nth(state.clone(), usize::MAX);
 
     assert!(first_attrs.is_some());
-    assert!(gradual.process_next_object(state).is_none());
+    assert!(gradual.next(state).is_none());
 }
 
 #[test]
 fn next_and_next_n() {
     let map = test_map!(Mania);
 
-    let mut state = ManiaScoreState {
-        n320: 0,
-        n300: 0,
-        n200: 0,
-        n100: 0,
-        n50: 0,
-        n_misses: 0,
-    };
+    let mut state = ManiaScoreState::default();
 
     let mut gradual1 = ManiaGradualPerformanceAttributes::new(&map, 0);
     let mut gradual2 = ManiaGradualPerformanceAttributes::new(&map, 0);
 
     for _ in 0..20 {
-        let _ = gradual1.process_next_object(state.clone());
-        let _ = gradual2.process_next_object(state.clone());
+        let _ = gradual1.next(state.clone());
+        let _ = gradual2.next(state.clone());
         state.n320 += 1;
     }
 
     let n = 80;
 
     for _ in 1..n {
-        let _ = gradual1.process_next_object(state.clone());
+        let _ = gradual1.next(state.clone());
         state.n320 += 1;
     }
 
-    let next = gradual1.process_next_object(state.clone());
-    let next_n = gradual2.process_next_n_objects(state, n);
+    let next = gradual1.next(state.clone());
+    let next_n = gradual2.nth(state, n - 1);
 
     assert_eq!(next_n, next);
 }
@@ -92,15 +81,11 @@ fn gradual_end_eq_regular() {
     let mut gradual = ManiaGradualPerformanceAttributes::new(&map, 0);
 
     let state = ManiaScoreState {
-        n320: 3238,
-        n300: 0,
-        n200: 0,
-        n100: 0,
-        n50: 0,
-        n_misses: 0,
+        n320: map.hit_objects.len(),
+        ..Default::default()
     };
 
-    let gradual_end = gradual.process_next_n_objects(state, usize::MAX).unwrap();
+    let gradual_end = gradual.nth(state, usize::MAX).unwrap();
 
     assert_eq!(regular, gradual_end);
 }
@@ -112,11 +97,7 @@ fn gradual_eq_regular_passed() {
 
     let state = ManiaScoreState {
         n320: 100,
-        n300: 0,
-        n200: 0,
-        n100: 0,
-        n50: 0,
-        n_misses: 0,
+        ..Default::default()
     };
 
     let regular = ManiaPP::new(&map)
@@ -124,8 +105,9 @@ fn gradual_eq_regular_passed() {
         .state(state.clone())
         .calculate();
 
-    let mut gradual = ManiaGradualPerformanceAttributes::new(&map, 0);
-    let gradual = gradual.process_next_n_objects(state, n).unwrap();
+    let gradual = ManiaGradualPerformanceAttributes::new(&map, 0)
+        .nth(state, n - 1)
+        .unwrap();
 
     assert_eq!(regular, gradual);
 }