osu_map_analyzer/analyze/
jump.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
use crate::utils::bpm;
use rosu_map::{section::hit_objects::HitObject, Beatmap};
use std::collections::VecDeque;

pub struct Jump {
    map: Beatmap,
}

#[derive(Debug, Clone, Copy, serde::Deserialize)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
pub struct JumpAnalysis {
    pub overall_confidence: f64,
    pub total_jump_count: usize,
    pub max_jump_length: usize,
    pub short_jumps_count: usize,
    pub medium_jumps_count: usize,
    pub long_jumps_count: usize,
    pub peak_jump_density: f64,
    pub bpm_consistency: f64,
}

impl Jump {
    /// Creates a new jump analyzer for the given beatmap.
    ///
    /// # Arguments
    ///
    /// * `map` - The beatmap to analyze, type: rosu_map::Beatmap.
    pub fn new(map: Beatmap) -> Self {
        Self { map }
    }

    /// Analyzes the beatmap for jumps and returns a `JumpAnalysis`.
    ///
    /// # Example
    ///
    /// ```rs
    /// let path = Path::new("example-maps/jump-caffeinefighter.osu");
    /// let map = rosu_map::from_path::<rosu_map::Beatmap>(path).unwrap();

    /// let mut jump_analyzer = Jump::new(map);
    /// let analasis = jump_analyzer.analyze();
    /// println!("{:#?}", analasis);
    /// ```
    pub fn analyze(&mut self) -> JumpAnalysis {
        let bpm = bpm(None, &self.map.control_points.timing_points);
        let beat_length = 60.0 / bpm * 1000.0;
        let expected_jump_interval = beat_length / 2.0; // 1/2ths

        let window_size = 200;
        let step_size = 50;
        let hit_objects = &self.map.hit_objects;

        let mut max_jump_length = 0;
        let mut peak_jump_density = 0.0_f64;

        let mut total_short_jump_count = 0;
        let mut total_medium_jump_count = 0;
        let mut total_long_jump_count = 0;

        let mut overall_bpm_consistency: f64 = 0.0;
        let mut total_jump_notes_length = 0;
        let mut total_jumps = 0;

        for window_start in (0..hit_objects.len()).step_by(step_size) {
            let window_end = (window_start + window_size).min(hit_objects.len());
            let window = &hit_objects[window_start..window_end];

            let (jumps_lengths, bpm_variations) =
                self.analyze_window(window, expected_jump_interval);

            let short_jumps = jumps_lengths
                .iter()
                .filter(|&&len| len > 2 && len < 10)
                .count();
            let medium_jumps = jumps_lengths
                .iter()
                .filter(|&&len| len >= 10 && len < 20)
                .count();
            let long_jumps = jumps_lengths.iter().filter(|&&len| len >= 20).count();

            total_short_jump_count += short_jumps;
            total_medium_jump_count += medium_jumps;
            total_long_jump_count += long_jumps;

            let total_jump_notes: usize = jumps_lengths.iter().sum();
            let jump_density = total_jump_notes as f64 / window.len() as f64;
            peak_jump_density = peak_jump_density.max(jump_density);

            max_jump_length = max_jump_length.max(*jumps_lengths.iter().max().unwrap_or(&0));

            total_jump_notes_length += jumps_lengths.iter().sum::<usize>();
            total_jumps += jumps_lengths.len();

            let bpm_consistency = if !bpm_variations.is_empty() {
                1.0 - (bpm_variations.iter().sum::<f64>() / bpm_variations.len() as f64)
                    / expected_jump_interval
            } else {
                0.0
            };

            overall_bpm_consistency = overall_bpm_consistency.max(bpm_consistency);
        }

        let average_jump_length = if total_jumps > 0 {
            total_jump_notes_length as f64 / total_jumps as f64
        } else {
            0.0
        };

        let jump_variety = (total_medium_jump_count * 2 + total_long_jump_count * 3) as f64
            / (total_short_jump_count + total_medium_jump_count + total_long_jump_count).max(1)
                as f64;

        let long_jump_ratio = total_long_jump_count as f64 / total_jumps as f64;

        let overall_confidence = (peak_jump_density * 0.3
            + overall_bpm_consistency * 0.2
            + jump_variety * 0.38
            + long_jump_ratio * 0.3
            + (average_jump_length / 3.0).min(1.0) * 0.3)
            .min(1.0);

        JumpAnalysis {
            long_jumps_count: total_long_jump_count,
            medium_jumps_count: total_medium_jump_count,
            short_jumps_count: total_short_jump_count,
            max_jump_length,
            total_jump_count: total_jumps,
            overall_confidence,
            peak_jump_density,
            bpm_consistency: overall_bpm_consistency,
        }
    }

    fn analyze_window(
        &self,
        window: &[HitObject],
        expected_interval: f64,
    ) -> (Vec<usize>, Vec<f64>) {
        let mut jumps_lengths = Vec::new();
        let mut curr_jump = VecDeque::new();
        let mut bpm_variations = Vec::new();
        // TODO: Add a global variable that stores the jumps' density and difficulty
        let tolerance = 0.10; // 10% tolerance

        for pair in window.windows(2) {
            let time_diff = pair[1].start_time - pair[0].start_time;

            // Check if the pair is between expected interval.
            if (time_diff - expected_interval).abs() / expected_interval <= tolerance {
                curr_jump.push_back(time_diff);
                if curr_jump.len() > 1 {
                    // TODO: Calculate x and y differences as well, and add them to a global variable to calculate jumps' density and difficulty
                    let prev_diff = curr_jump[curr_jump.len() - 2];
                    bpm_variations.push((time_diff - prev_diff).abs());
                }
            } else if !curr_jump.is_empty() {
                jumps_lengths.push(curr_jump.len());
                curr_jump.clear();
            }
        }

        if !curr_jump.is_empty() {
            jumps_lengths.push(curr_jump.len());
        }

        (jumps_lengths, bpm_variations)
    }
}

#[cfg(test)]
mod jump_tests {
    use super::*;
    use std::path::Path;

    #[test]
    fn test_jump_analysis() {
        let path = Path::new("example-maps/jump-flowerdance.osu");
        let map = rosu_map::from_path::<rosu_map::Beatmap>(path).unwrap();

        let mut jump_analyzer = Jump::new(map);
        let analasis = jump_analyzer.analyze();
        println!("{:#?}", analasis);
    }
}